JESS: Nested not conditional element with slots referring to facts

classic Classic list List threaded Threaded
9 messages Options
hlc
Reply | Threaded
Open this post in threaded view
|

JESS: Nested not conditional element with slots referring to facts

hlc
Hi,

I have just reproduced the example of section 6.10 of the Jess manual:

    (defrule forall-example
        (not (and (a ?x)
                  (not (b ?x)) ) )
        =>
        (printout t "whassup?" crlf) )
   
    (deffacts qwe
        (a 1)
    ;    (a 2)
        (b 1) )
   
    (reset) (facts) (run)

So in this case, if I comment out fact (a 2), the rule stops firing.
But then I tried to implement the following rule:

    (defrule r
        (not (and ?x <- (a ?)   ; variable binding
                  (not (b ?x)) ) )   ; check if there is a b referring
to the a fact
        =>
        (printout t "sure thing!" crlf) )
   
    (deffacts qwe
        (a 1)
    ;    (a 2)
        (b (fact-id 1)) )   ; fact b referring to fact (a 1)
 
    (reset) (facts) (run)

It's quite similar to the previous one, but now I am inspecting if fact
b contains a reference to fact a.
In this case the rule does not cease to fire when I comment out (a 2).

Am I missing something?

Thanks,

Henrique



--------------------------------------------------------------------
To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
in the BODY of a message to [hidden email], NOT to the list
(use your own address!) List problems? Notify [hidden email].
--------------------------------------------------------------------

Reply | Threaded
Open this post in threaded view
|

Re: JESS: Nested not conditional element with slots referring to facts

Wolfgang Laun-2
When (deffacts) is evaluated to build the facts, (fact-id) won't
return a fact since only the (reset) inserts
the defined facts. You'll have to use dynamic insertion with (assert)
to insert a fact referring to another
fact.

-W

On 20 July 2010 19:23, Henrique Lopes Cardoso <[hidden email]> wrote:

> Hi,
>
> I have just reproduced the example of section 6.10 of the Jess manual:
>
>    (defrule forall-example
>        (not (and (a ?x)
>                  (not (b ?x)) ) )
>        =>
>        (printout t "whassup?" crlf) )
>
>    (deffacts qwe
>        (a 1)
>    ;    (a 2)
>        (b 1) )
>
>    (reset) (facts) (run)
>
> So in this case, if I comment out fact (a 2), the rule stops firing.
> But then I tried to implement the following rule:
>
>    (defrule r
>        (not (and ?x <- (a ?)   ; variable binding
>                  (not (b ?x)) ) )   ; check if there is a b referring
> to the a fact
>        =>
>        (printout t "sure thing!" crlf) )
>
>    (deffacts qwe
>        (a 1)
>    ;    (a 2)
>        (b (fact-id 1)) )   ; fact b referring to fact (a 1)
>
>    (reset) (facts) (run)
>
> It's quite similar to the previous one, but now I am inspecting if fact
> b contains a reference to fact a.
> In this case the rule does not cease to fire when I comment out (a 2).
>
> Am I missing something?
>
> Thanks,
>
> Henrique
>
>
>
> --------------------------------------------------------------------
> To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
> in the BODY of a message to [hidden email], NOT to the list
> (use your own address!) List problems? Notify [hidden email].
> --------------------------------------------------------------------
>
>




--------------------------------------------------------------------
To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
in the BODY of a message to [hidden email], NOT to the list
(use your own address!) List problems? Notify [hidden email].
--------------------------------------------------------------------

hlc
Reply | Threaded
Open this post in threaded view
|

Re: JESS: Nested not conditional element with slots referring to facts

hlc
Actually, asserts do work, because (deffacts) are added to working  
memory by a call to (reset). This is wy I am calling (facts) before  
(run), to make sure facts are in working memory as intended.

Anyway, I tried (assert)ing them one by one and it still does not work  
as expected.

It must be something else.

Henrique


Citando Wolfgang Laun <[hidden email]>:

> When (deffacts) is evaluated to build the facts, (fact-id) won't
> return a fact since only the (reset) inserts
> the defined facts. You'll have to use dynamic insertion with (assert)
> to insert a fact referring to another
> fact.
>
> -W
>
> On 20 July 2010 19:23, Henrique Lopes Cardoso <[hidden email]> wrote:
>> Hi,
>>
>> I have just reproduced the example of section 6.10 of the Jess manual:
>>
>>    (defrule forall-example
>>        (not (and (a ?x)
>>                  (not (b ?x)) ) )
>>        =>
>>        (printout t "whassup?" crlf) )
>>
>>    (deffacts qwe
>>        (a 1)
>>    ;    (a 2)
>>        (b 1) )
>>
>>    (reset) (facts) (run)
>>
>> So in this case, if I comment out fact (a 2), the rule stops firing.
>> But then I tried to implement the following rule:
>>
>>    (defrule r
>>        (not (and ?x <- (a ?)   ; variable binding
>>                  (not (b ?x)) ) )   ; check if there is a b referring
>> to the a fact
>>        =>
>>        (printout t "sure thing!" crlf) )
>>
>>    (deffacts qwe
>>        (a 1)
>>    ;    (a 2)
>>        (b (fact-id 1)) )   ; fact b referring to fact (a 1)
>>
>>    (reset) (facts) (run)
>>
>> It's quite similar to the previous one, but now I am inspecting if fact
>> b contains a reference to fact a.
>> In this case the rule does not cease to fire when I comment out (a 2).
>>
>> Am I missing something?
>>
>> Thanks,
>>
>> Henrique
>>
>>
>>
>> --------------------------------------------------------------------
>> To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
>> in the BODY of a message to [hidden email], NOT to the list
>> (use your own address!) List problems? Notify [hidden email].
>> --------------------------------------------------------------------
>>
>>
>
>
>
>
> --------------------------------------------------------------------
> To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
> in the BODY of a message to [hidden email], NOT to the list
> (use your own address!) List problems? Notify [hidden email].
> --------------------------------------------------------------------
>
>






--------------------------------------------------------------------
To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
in the BODY of a message to [hidden email], NOT to the list
(use your own address!) List problems? Notify [hidden email].
--------------------------------------------------------------------

Reply | Threaded
Open this post in threaded view
|

Re: JESS: Nested not conditional element with slots referring to facts

Friedman-Hill, Ernest
Indeed, the rule doesn't seem to compile correctly; the two ?x's are  
not merged.

Jess> (ppdefrule r)
"(defrule MAIN::r
    (initial-fact)
    (not ?x <- (and ?x <- (a ?_021__blank_2) (not (b ?_0022_x))))
    =>
    (printout t \"sure thing!\" crlf))"


On Jul 20, 2010, at 4:04 PM, Henrique Lopes Cardoso wrote:

> Actually, asserts do work, because (deffacts) are added to working
> memory by a call to (reset). This is wy I am calling (facts) before
> (run), to make sure facts are in working memory as intended.
>
> Anyway, I tried (assert)ing them one by one and it still does not work
> as expected.
>
> It must be something else.
>
> Henrique
>
>

---------------------------------------------------------
Ernest Friedman-Hill
Informatics & Decision Sciences, Sandia National Laboratories
PO Box 969, MS 9012, Livermore, CA 94550
http://www.jessrules.com







--------------------------------------------------------------------
To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
in the BODY of a message to [hidden email], NOT to the list
(use your own address!) List problems? Notify [hidden email].
--------------------------------------------------------------------

Reply | Threaded
Open this post in threaded view
|

Fwd: JESS: Nested not conditional element with slots referring to facts

Wolfgang Laun-2
In reply to this post by Wolfgang Laun-2
I have analyzed this some, but the mail just went to Henrique.
-W

---------- Forwarded message ----------
From: Wolfgang Laun <[hidden email]>
Date: 21 July 2010 08:20
Subject: Re: JESS: Nested not conditional element with slots referring to facts
To: Henrique Lopes Cardoso <[hidden email]>


Hmm, I was sure that I did have a problem with references within a
deffacts at one time. However, a little experimenting shown that

(defrule r
 (not (and ?x <- (a ?) (not (b ?x)) ) )
 =>... )

is (according  to (ppdefrul r)) internally represented as

(defrule MAIN::r
  (initial-fact)
  (not ?x <- (and ?x <- (a ?_021__blank_17) (not (b ?_0022_x))))
  => ... )

Besides the (incorrect) duplication of ?x in front of (and), the identity of
the bound variable ?x is lost. I *guess* that some sort of (usually) optimizing
transformation is being done which results in

(defrule rx
  (or (not (a ?))  (b ?x))
=> ... )

which is always true due to any (b) being present.

If rule rx is added, it behaves just like rule r, i.e., when there is
no fact (a) but
some fact (x) to provide the fact-id 1,  both r and rx fire.
Conversely, removing
fact (b (slot-id 1)) with just a single (a 1) results in both rules
(r) and (rx) not
firing.

I'd say this is a bug: the aforementioned transformation may not be done
if there are *fact* bindings to achieve linkage between the patterns.

BTW, if the example from the Jess manual is modfied with a redundant
variable binding:for the x-fact:

 (defrule xy (not (and ?xf <- (x ?v) (not (y ?v)))) => ... )

(ppdefrule xy) also produces a syntactically incorrect rule, while the
variable bindings for slot values are retained correctly, just renamed
to make them local within the outer (not), .

 (defrule MAIN::xy
  (initial-fact)
  (not ?xf <- (and ?xf <- (x ?_021_v) (not (y ?_021_v))))  => ... )

Best
Wolfgang


On 20 July 2010 22:04, Henrique Lopes Cardoso <[hidden email]> wrote:

> Actually, asserts do work, because (deffacts) are added to working memory by
> a call to (reset). This is wy I am calling (facts) before (run), to make
> sure facts are in working memory as intended.
>
> Anyway, I tried (assert)ing them one by one and it still does not work as
> expected.
>
> It must be something else.
>
> Henrique
>
>
> Citando Wolfgang Laun <[hidden email]>:
>
>> When (deffacts) is evaluated to build the facts, (fact-id) won't
>> return a fact since only the (reset) inserts
>> the defined facts. You'll have to use dynamic insertion with (assert)
>> to insert a fact referring to another
>> fact.
>>
>> -W
>>
>> On 20 July 2010 19:23, Henrique Lopes Cardoso <[hidden email]> wrote:
>>>
>>> Hi,
>>>
>>> I have just reproduced the example of section 6.10 of the Jess manual:
>>>
>>>    (defrule forall-example
>>>        (not (and (a ?x)
>>>                  (not (b ?x)) ) )
>>>        =>
>>>        (printout t "whassup?" crlf) )
>>>
>>>    (deffacts qwe
>>>        (a 1)
>>>    ;    (a 2)
>>>        (b 1) )
>>>
>>>    (reset) (facts) (run)
>>>
>>> So in this case, if I comment out fact (a 2), the rule stops firing.
>>> But then I tried to implement the following rule:
>>>
>>>    (defrule r
>>>        (not (and ?x <- (a ?)   ; variable binding
>>>                  (not (b ?x)) ) )   ; check if there is a b referring
>>> to the a fact
>>>        =>
>>>        (printout t "sure thing!" crlf) )
>>>
>>>    (deffacts qwe
>>>        (a 1)
>>>    ;    (a 2)
>>>        (b (fact-id 1)) )   ; fact b referring to fact (a 1)
>>>
>>>    (reset) (facts) (run)
>>>
>>> It's quite similar to the previous one, but now I am inspecting if fact
>>> b contains a reference to fact a.
>>> In this case the rule does not cease to fire when I comment out (a 2).
>>>
>>> Am I missing something?
>>>
>>> Thanks,
>>>
>>> Henrique
>>>
>>>
>>>
>>> --------------------------------------------------------------------
>>> To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
>>> in the BODY of a message to [hidden email], NOT to the list
>>> (use your own address!) List problems? Notify
>>> [hidden email].
>>> --------------------------------------------------------------------
>>>
>>>
>>
>>
>>
>>
>> --------------------------------------------------------------------
>> To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
>> in the BODY of a message to [hidden email], NOT to the list
>> (use your own address!) List problems? Notify [hidden email].
>> --------------------------------------------------------------------
>>
>>
>
>
>




--------------------------------------------------------------------
To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
in the BODY of a message to [hidden email], NOT to the list
(use your own address!) List problems? Notify [hidden email].
--------------------------------------------------------------------

hlc
Reply | Threaded
Open this post in threaded view
|

Re: JESS: Nested not conditional element with slots referring to facts

hlc
In reply to this post by Friedman-Hill, Ernest
Hi again,

In the sequel of this problem, I've fond another (possibly related)
situation where the rule does not seem to compile correctly.
I managed to simplify the example to the following rule:

    (defrule r3
        (s)
        (or (not (a))
            (and ?x <- (a)
                 (b ?x) ) )
        (test (= qwe asd))   ; stupid test, just to expose the problem
        =>
        (printout t "tssss!" crlf) )

Using (ppdefrule), we see that this rule compiles to:

    (defrule MAIN::r3
       (or
         (and
           (s)
           (not (a)))
         (and
           (s)
           ?x <- (a)
           (and (b ?x)
            (test (= qwe asd)))))
       =>
       (printout t "tssss!" crlf))

Therefore, the test is not done in the first branch of (or).

Is there a way to stop Jess from transforming rules and keep the
original coding, possibly with some loss of performance? The point here
is to avoid the apparently buggy transformations that are being made.

Thanks.

Henrique


Ernest Friedman-Hill wrote:

> Indeed, the rule doesn't seem to compile correctly; the two ?x's are
> not merged.
>
> Jess> (ppdefrule r)
> "(defrule MAIN::r
>    (initial-fact)
>    (not ?x <- (and ?x <- (a ?_021__blank_2) (not (b ?_0022_x))))
>    =>
>    (printout t \"sure thing!\" crlf))"
>
>
> On Jul 20, 2010, at 4:04 PM, Henrique Lopes Cardoso wrote:
>
>> Actually, asserts do work, because (deffacts) are added to working
>> memory by a call to (reset). This is wy I am calling (facts) before
>> (run), to make sure facts are in working memory as intended.
>>
>> Anyway, I tried (assert)ing them one by one and it still does not work
>> as expected.
>>
>> It must be something else.
>>
>> Henrique
>>
>>
>



--------------------------------------------------------------------
To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
in the BODY of a message to [hidden email], NOT to the list
(use your own address!) List problems? Notify [hidden email].
--------------------------------------------------------------------

hlc
Reply | Threaded
Open this post in threaded view
|

Re: JESS: Nested not conditional element with slots referring to facts

hlc
Hi,

Is there any update on this issue?
Since I did not get any answer to my last question in the previous
e-mail (below), I am asking again:
- Is there a way to stop Jess from transforming rules and keep the
original coding, possibly with some loss of performance?
Or even better: is the bug solved?

Thanks,

Henrique



Henrique Lopes Cardoso wrote:

> Hi again,
>
> In the sequel of this problem, I've fond another (possibly related)
> situation where the rule does not seem to compile correctly.
> I managed to simplify the example to the following rule:
>
>     (defrule r3
>         (s)
>         (or (not (a))
>             (and ?x <- (a)
>                  (b ?x) ) )
>         (test (= qwe asd))   ; stupid test, just to expose the problem
>         =>
>         (printout t "tssss!" crlf) )
>
> Using (ppdefrule), we see that this rule compiles to:
>
>     (defrule MAIN::r3
>        (or
>          (and
>            (s)
>            (not (a)))
>          (and
>            (s)
>            ?x <- (a)
>            (and (b ?x)
>             (test (= qwe asd)))))
>        =>
>        (printout t "tssss!" crlf))
>
> Therefore, the test is not done in the first branch of (or).
>
> Is there a way to stop Jess from transforming rules and keep the
> original coding, possibly with some loss of performance? The point here
> is to avoid the apparently buggy transformations that are being made.
>
> Thanks.
>
> Henrique
>
>
> Ernest Friedman-Hill wrote:
>  
>> Indeed, the rule doesn't seem to compile correctly; the two ?x's are
>> not merged.
>>
>> Jess> (ppdefrule r)
>> "(defrule MAIN::r
>>    (initial-fact)
>>    (not ?x <- (and ?x <- (a ?_021__blank_2) (not (b ?_0022_x))))
>>    =>
>>    (printout t \"sure thing!\" crlf))"
>>
>>
>> On Jul 20, 2010, at 4:04 PM, Henrique Lopes Cardoso wrote:
>>
>>    
>>> Actually, asserts do work, because (deffacts) are added to working
>>> memory by a call to (reset). This is wy I am calling (facts) before
>>> (run), to make sure facts are in working memory as intended.
>>>
>>> Anyway, I tried (assert)ing them one by one and it still does not work
>>> as expected.
>>>
>>> It must be something else.
>>>
>>> Henrique


--------------------------------------------------------------------
To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
in the BODY of a message to [hidden email], NOT to the list
(use your own address!) List problems? Notify [hidden email].
--------------------------------------------------------------------

Reply | Threaded
Open this post in threaded view
|

Re: JESS: Nested not conditional element with slots referring to facts

Friedman-Hill, Ernest
It's definitely a bug, and no patch has been released yet. To work  
around it, you could add an extra pattern to the rule right before the  
test and after the "or":

(defrule r3
        (s)
        (or (not (a))
            (and ?x <- (a)
                 (b ?x) ) )
        (initial-fact)
        (test (= qwe asd))
=> ...

Alternatively you could move the test before the "or".



On Sep 7, 2010, at 5:10 AM, Henrique Lopes Cardoso wrote:

> Hi,
>
> Is there any update on this issue?
> Since I did not get any answer to my last question in the previous
> e-mail (below), I am asking again:
> - Is there a way to stop Jess from transforming rules and keep the
> original coding, possibly with some loss of performance?
> Or even better: is the bug solved?
>
> Thanks,
>
> Henrique
>
>
>
> Henrique Lopes Cardoso wrote:
>> Hi again,
>>
>> In the sequel of this problem, I've fond another (possibly related)
>> situation where the rule does not seem to compile correctly.
>> I managed to simplify the example to the following rule:
>>
>>    (defrule r3
>>        (s)
>>        (or (not (a))
>>            (and ?x <- (a)
>>                 (b ?x) ) )
>>        (test (= qwe asd))   ; stupid test, just to expose the problem
>>        =>
>>        (printout t "tssss!" crlf) )
>>
>> Using (ppdefrule), we see that this rule compiles to:
>>
>>    (defrule MAIN::r3
>>       (or
>>         (and
>>           (s)
>>           (not (a)))
>>         (and
>>           (s)
>>           ?x <- (a)
>>           (and (b ?x)
>>            (test (= qwe asd)))))
>>       =>
>>       (printout t "tssss!" crlf))
>>
>> Therefore, the test is not done in the first branch of (or).
>>
>> Is there a way to stop Jess from transforming rules and keep the
>> original coding, possibly with some loss of performance? The point  
>> here
>> is to avoid the apparently buggy transformations that are being made.
>>
>> Thanks.
>>
>> Henrique
>>
>>
>> Ernest Friedman-Hill wrote:
>>
>>> Indeed, the rule doesn't seem to compile correctly; the two ?x's are
>>> not merged.
>>>
>>> Jess> (ppdefrule r)
>>> "(defrule MAIN::r
>>>   (initial-fact)
>>>   (not ?x <- (and ?x <- (a ?_021__blank_2) (not (b ?_0022_x))))
>>>   =>
>>>   (printout t \"sure thing!\" crlf))"
>>>
>>>
>>> On Jul 20, 2010, at 4:04 PM, Henrique Lopes Cardoso wrote:
>>>
>>>
>>>> Actually, asserts do work, because (deffacts) are added to working
>>>> memory by a call to (reset). This is wy I am calling (facts) before
>>>> (run), to make sure facts are in working memory as intended.
>>>>
>>>> Anyway, I tried (assert)ing them one by one and it still does not  
>>>> work
>>>> as expected.
>>>>
>>>> It must be something else.
>>>>
>>>> Henrique
>
>
> --------------------------------------------------------------------
> To unsubscribe, send the words 'unsubscribe jess-users  
> [hidden email]'
> in the BODY of a message to [hidden email], NOT to the list
> (use your own address!) List problems? Notify [hidden email]
> .
> --------------------------------------------------------------------

---------------------------------------------------------
Ernest Friedman-Hill
Informatics & Decision Sciences          Phone: (925) 294-2154
Sandia National Labs
PO Box 969, MS 9012                            [hidden email]
Livermore, CA 94550                             http://www.jessrules.com





--------------------------------------------------------------------
To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
in the BODY of a message to [hidden email], NOT to the list
(use your own address!) List problems? Notify [hidden email].
--------------------------------------------------------------------

hlc
Reply | Threaded
Open this post in threaded view
|

Re: JESS: Nested not conditional element with slots referring to facts

hlc
Yes, but of course I do not have such a rule in my application. Besides,
that "patch" will only apply to this case, not to the one originally
pointed out in thie mail thread...

If there is no way to prevent Jess from transforming rules, I guess I'll
have to wait until the bug is fixed...

Henrique


Ernest Friedman-Hill wrote:

> It's definitely a bug, and no patch has been released yet. To work
> around it, you could add an extra pattern to the rule right before the
> test and after the "or":
>
> (defrule r3
>        (s)
>        (or (not (a))
>            (and ?x <- (a)
>                 (b ?x) ) )
>        (initial-fact)
>        (test (= qwe asd))
> => ...
>
> Alternatively you could move the test before the "or".
>
>
>
> On Sep 7, 2010, at 5:10 AM, Henrique Lopes Cardoso wrote:
>
>> Hi,
>>
>> Is there any update on this issue?
>> Since I did not get any answer to my last question in the previous
>> e-mail (below), I am asking again:
>> - Is there a way to stop Jess from transforming rules and keep the
>> original coding, possibly with some loss of performance?
>> Or even better: is the bug solved?
>>
>> Thanks,
>>
>> Henrique
>>
>>
>>
>> Henrique Lopes Cardoso wrote:
>>> Hi again,
>>>
>>> In the sequel of this problem, I've fond another (possibly related)
>>> situation where the rule does not seem to compile correctly.
>>> I managed to simplify the example to the following rule:
>>>
>>>    (defrule r3
>>>        (s)
>>>        (or (not (a))
>>>            (and ?x <- (a)
>>>                 (b ?x) ) )
>>>        (test (= qwe asd))   ; stupid test, just to expose the problem
>>>        =>
>>>        (printout t "tssss!" crlf) )
>>>
>>> Using (ppdefrule), we see that this rule compiles to:
>>>
>>>    (defrule MAIN::r3
>>>       (or
>>>         (and
>>>           (s)
>>>           (not (a)))
>>>         (and
>>>           (s)
>>>           ?x <- (a)
>>>           (and (b ?x)
>>>            (test (= qwe asd)))))
>>>       =>
>>>       (printout t "tssss!" crlf))
>>>
>>> Therefore, the test is not done in the first branch of (or).
>>>
>>> Is there a way to stop Jess from transforming rules and keep the
>>> original coding, possibly with some loss of performance? The point here
>>> is to avoid the apparently buggy transformations that are being made.
>>>
>>> Thanks.
>>>
>>> Henrique
>>>
>>>
>>> Ernest Friedman-Hill wrote:
>>>
>>>> Indeed, the rule doesn't seem to compile correctly; the two ?x's are
>>>> not merged.
>>>>
>>>> Jess> (ppdefrule r)
>>>> "(defrule MAIN::r
>>>>   (initial-fact)
>>>>   (not ?x <- (and ?x <- (a ?_021__blank_2) (not (b ?_0022_x))))
>>>>   =>
>>>>   (printout t \"sure thing!\" crlf))"
>>>>
>>>>
>>>> On Jul 20, 2010, at 4:04 PM, Henrique Lopes Cardoso wrote:
>>>>
>>>>
>>>>> Actually, asserts do work, because (deffacts) are added to working
>>>>> memory by a call to (reset). This is wy I am calling (facts) before
>>>>> (run), to make sure facts are in working memory as intended.
>>>>>
>>>>> Anyway, I tried (assert)ing them one by one and it still does not
>>>>> work
>>>>> as expected.
>>>>>
>>>>> It must be something else.
>>>>>
>>>>> Henrique
>>
>>
>> --------------------------------------------------------------------
>> To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
>> in the BODY of a message to [hidden email], NOT to the list
>> (use your own address!) List problems? Notify
>> [hidden email].
>> --------------------------------------------------------------------
>
> ---------------------------------------------------------
> Ernest Friedman-Hill
> Informatics & Decision Sciences          Phone: (925) 294-2154
> Sandia National Labs
> PO Box 969, MS 9012                            [hidden email]
> Livermore, CA 94550                             http://www.jessrules.com
>
>
>
>
>
> --------------------------------------------------------------------
> To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
> in the BODY of a message to [hidden email], NOT to the list
> (use your own address!) List problems? Notify
> [hidden email].
> --------------------------------------------------------------------
>
>

--
----- - - - - -  -  -  -  -  -   -   -
Henrique Lopes Cardoso
DEI/FEUP
Rua Dr. Roberto Frias | 4200-465 Porto
PORTUGAL
 VoIP: (+351) 225574199 ext.3355
Phone: (+351) 225081400 ext.1315
[hidden email] | www.fe.up.pt/~hlc
----- - - - - -  -  -  -  -  -   -   -



--------------------------------------------------------------------
To unsubscribe, send the words 'unsubscribe jess-users [hidden email]'
in the BODY of a message to [hidden email], NOT to the list
(use your own address!) List problems? Notify [hidden email].
--------------------------------------------------------------------