Philosophy, Computing, and Artificial Intelligence

PHI 319. Kowalksi's Attempt to Understand the Suppression Task.

Computational Logic and Human Thinking
Chapter 5 (75-91), Appendix A4 (284-289)

Negations-as-Failure and Negation-Introduction

Negation-as-failure (NAF) is the reasoning Kowalski describes as the "derivation of negative conclusions from the lack of positive information" (Computational Logic and Human Thinking, 78). The reasoning in this "derviation" is defeasible reasoning. It follows, in this case, that NAF is not reasoning in accordance with the classical rule of Negation-Introduction (¬I). Negation-Introduction (¬I) is a rule of logical consequence.

To understand this, it necessary to understand what Negation-Introduction (¬I) is.

The classical rule of Negation-Introduction (¬I) says that if absurdity (⊥) is a consequence of a set of premises and assumption φ, then ¬φ is a consequence of these premises:

    [φ]¹
.
.
.
⊥
------- ¬I,1
¬φ 

If absurdity (⊥) is a consequence of a set of premises and assumption φ, it will remain a consequence even in the presence of more premises in the form of new information.

NAF in Everyday Reasoning

In everyday life, we often reason in the following way. I look at a schedule of flights from Phoenix to San Francisco. I don't see one listed as leaving at 10:00 am. So I naturally conclude that it is not the case that there is a flight leaves at that time. This inference seems entirely reasonable, but it is not sanctioned by the classical Negation-Introduction rule.

The inference is an instance of NAF reasoning. I want to know whether a flight leaves at 10:00. I try to prove there is. This proof fails. I conclude that no flight leaves at that time.

So, unlike negation-introduction, NAF reasoning has the form

   failure to prove φ
-------
¬φ

There is no logical deduction to the conclusion from the premise. The reasoning is defeasible.

Why NAF Reasoning is Rational

"The derivation of negative conclusions from the lack of positive information about a predicate is justified by a belief or assumption that we have all the positive information that there is to be had about the predicate" (Kowalksi, Computational Logic and Human Thinking, 78).

"The use of negation as failure to derive a negative conclusion is justified by the closed world assumption that you have complete knowledge about all the conditions under which the positive conclusion holds" (Kowalksi, Computational Logic and Human Thinking, 79).
Since the this reasoning is not conclusive, one might wonder why is it is rational.

One answer is that the agent assumes and thus believes the closed world assumption (CWA), but I think this is a mistake. CWA makes the reasoning conclusive reasoning.

CWA is the assumption that propositions that are not logical consequences of the KB are false.

Given CWA, the list of flights we see is the complete list of flights from Phoenix to San Francisco. So, given this assumption, it is perfectly reasonable to conclude that no flight leaves at a certain time if we do not see a flight on the list that leaves at this time.

In this case, though, the reasoning is conclusive reasoning, not defeasible reasoning. We would have to give up our belief that we had a complete list of flights if we were to acquire the new information that there is a flight that leaves for San Francisco at 10:00 am.

NAF in Default Reasoning

"[T]he kind of reasoning involved in the suppression task, once its intended logical form has been identified, is a form of default (or defeasible) reasoning, in which the conclusion of a rule is deemed to hold by default, but is subsequently withdrawn (or suppressed) when additional information contradicting the application of the rule is given later" (Kowalksi, Computational Logic and Human Thinking, 48).

"This property of negation as failure and the closed world assumption is called defeasibility or non-monotonicity. It is a form of default reasoning, in which an agent jumps to a conclusion, but then withdraws the conclusion given new information that leads to the contrary of the conclusion" (Kowalksi, Computational Logic and Human Thinking, 81).
NAF reasoning is part of what Kowalski calls default reasoning. This is reasoning "in which the conclusion of a rule is deemed to hold by default, but is subsequently withdrawn (or suppressed) when additional information contradicting the application of the rule is given later" (Computational Logic and Human Thinking, 48).

To see how NAF is part of this reasoning, consider a slight variation on his "innocent unless proven guilty" example (Computational Logic and Human Thinking, 84).

(k1) A person is innocent of a crime
if the person is accused of the crime
and it is not the case that the person committed the crime
.

(k2) A person committed a crime if another person witnessed the person commit the crime.

(k3) Bob is accused of the crime of robbing a bank

Suppose we think of this example along the lines of a logic program. Suppose the query is

(q) Bob is innocent of the crime of robbing a bank.

Given the first rule (k1) in the KB, this query will succeed if the derived queries

(i) Bob is accused of the crime of robbing a bank
(ii) It is not the case that Bob committed (the crime of) robbing a bank

succeed. If, contrary to the way we have been understanding backward chaining, this second query is understood to succeed just in case

(*) Bob committed (the crime of) robbing a bank

fails, then (ii) will succeed. So the original query (q) succeed too. The agent can conclude that Bob is innocent because there is no proof of (*). It is not a logical consequence of the KB.

If, however, we change the example so that the KB includes the new belief that

Another person witnessed Bob commit (the crime of) robbing a bank

then (ii) will fail and so the original query (q) will fail too. The new information gives the agent the ability to draw a new conclusion contrary to the old conclusion that (q) is true.

Negation-as-Failure in Logic Programming

Logic programming can be developed so that it allows for NAF.

Logic programs, as we have defined them, do not contain "nots" in the tails of rules. So the first step is to allow for this. So now a rule can have "nots" in its tail and thus have this form:

positive condition if positive conditions and not-conditions

In addition, we have to modify the backward chaining computation so that there is a procedure to handle the "nots" that may appear in the tails of rules.

To understand the modification, consider the following logic program with NAF:

P if Q, not-R
R if S, T
Q
S

Relative to this KB, suppose the query is

?-P

This query unifies with the head of the first rule. So the derived query list becomes

Q, not-R

To process the first entry on the list, we proceed as we did in logic programming without NAF. We see whether Q unifies with the head of any entry in the KB. It does. It unifies with the first fact. So, since facts have no tail, the derived query list becomes

not-R

Now we must do something new. We do not determine whether not-R unifies with the head any entry in the KB. (We do not allow negations in heads of rules.) Instead, in logic programming with NAF, the query not-R succeeds just in case the query

R

fails. So what we have to determine is whether R fails. To find out, we evaluate it just as we would in logic programming without NAF. When we do, we see that R unifies with the head of the second rule to produce the derived query list

S, T

Now we have to process the entries on this list. We see that S unifies with the head of the second fact. Since facts have no tail, the new derived query list is

T

We see that T does not unify with any head in the program. So now we know that it fails and thus that R fails. So not-R succeeds. Since, as we have seen Q succeeds, it follows that

?- P

succeeds. Hence, P is a consequence (but not a logical consequence) of the program.

The Suppression Task Revisited

Kowalski suggests, reasonably enough, that in everyday conversation it is common to state only the most important conditions of a general statement and to leave implicit the other conditions that apply. In the Suppression Task, the general statement is

If she has an essay to write, she will study late in the library.

If, according to Kowalski (Computational Logic and Human Thinking, 86), the underlying rule in this statement were made more explicit, it would look something like this:

If she has an essay to write,
and it is not the case that she is prevented from studying late in the library,
then she will study late in the library.

To set out this more formally, let the sentences be symbolized as follows:

E = She has an essay to write
L = She will study late in the library
P = She is prevented from studying late in the library

The corresponding logic program or KB with NAF is

L if E, not-P
E

Relative to this KB, the query

?- L

succeeds. This is the outcome the experimenters expect.

Here the computation. L unifies with the head of the rule. The new query list is E, not-P. E unifies with the head of the fact. Facts have no tails. So now the query list is

not-P

To process not-P, we use the negation-as-failure procedure. So not-P succeeds if P fails. Since P does fail, it follows that not-P succeeds. At this point, because the query list is empty, the computation stops. L is a consequence (but not a logical consequence) of the program.

Explaining the Experimental Results

Given NAF and this new KB, it may seem that the logic programming/agent model provides a good way to explain why subjects draw the conclusion

She will study late in the library

on the basis of the premises

If she has an essay to write, then she will study late in the library
She has an essay to write

The subjects incorporate the conditional into their minds in a way that includes

it is not the case that she is prevented from studying late in the library

Since the negation in this "preventing" clause is negation-as-failure, the conclusion L is a consequence (but not a logical conseqence) of the premises in the KB.

This would explain the first experimental result.

It remains, though, expain the second result: that about 40% of the subjects retract (or "suppress") L upon receiving the new information

If the library is open, she will study late in the library.

To explain this, there must be a natural way to incorporate this new information so that

?- L.

failes. Otherwise, Kowalski has not explained the experimental results in the Suppression Task.

One Way to Incorporate the New Information

It is plausible to think that the new information makes explicit the following preventing condition that was implicit in the original information:

She is prevented from studying late in the library if the library is not open.

So when the subjects get the new information, they must incorporate it in their minds. One way to incorporate this new information changes the KB so that it becomes

L if E, not-P
If she has an essay to write,
and it is not the case that she is prevented from studying late in the library,
then she will study late in the library.

P if not-O
She is prevented from studying late in the library if the library is not open.

E
She has an essay to write

L is not a consequence of this KB. So we might conclude that this is the way to incorporate the new information and thus to explain the "suppression."

Here is the computation that shows L is not a consequence of this KB. The query

?-L

unifies with the head of the first rule. The derived query list is

E, not-P.

E unifies with the head of the fact. It has no tail. So now the derived query list is

not-P

P unifies with the head of the second rule. This produces the derived query

not-O

O does not unify with any head in the KB. So not-O succeeds. This means that not-P fails and hence L fails too. Thus, L is not a consequence of the KB.

A Question about this way of Incorporating the New Information

Does this way of changing the KB explain why subjects "suppress" the conclusion L when they get the new information? The answer, it seems, is that it does not.

There are lots of possible conditions that would prevent one from studying in the library. Here the possibilities that Kowalski gives (Computational Logic and Human Thinking, 86-87):

She is prevented from studying late in the library if the library is not open.
She is prevented from studying late in the library if she is unwell.
She is prevented from studying late in the library if she has a more important meeting.
She is prevented from studying late in the library if she has been distracted.

In this list, it is not obvious that all of the preventing conditions are negative. So given the new information, it is unclear that the query L to the new KB will always fail.

Hence, it is unclear that we have a general explanation for why subjects in the experiment "suppress" their original conclusion when they receive new information.

Two Other Ways to Incorporate the New Information

There are two other ways to incorporate the new information. These two ways to incorporate the new information change the KB in different ways.

Here is the KB before the new information is incorporated:

E = She has an essay to write
L = She will study late in the library
P = She is prevented from studying in the library

L if E, not-P
E

The query L succeeds in this KB.

Here is the first way to incorporate the new information:

E = She has an essay to write
L = She will study late in the library
P = She is prevented from studying late in the library
C = The library is closed

L if E, not-P
E
P if C
C

Here is the second way to incorporate the new information:

E = She has an essay to write
L = She will study late in the library
O = The library is open

L if E, O
E

The query L fails in both of these new KBs.

Which is the more plausible way to incorporate the new information?

The first can seem to be the more plausible of the two insofar as the new information is added without changing or eliminating an entry in the KB. The problem, though, is that there appears to be no justification for adding C (the belief that the library is closed) to the KB.

Kowalski Thinks that the Second Way is Correct

Which of the the ways does Kowalski intend in his explanation of the Suppression Task?

His discussion (Computational Logic and Human Thinking, 86-87) suggests that he thinks that the second way is correct. He says that the "higher-level representation"

she will study late in the library if she has an essay to write and it is not the case that she is prevented from studying late in the library.
she is prevented from studying late in the library if the library is not open.
she is prevented from studying late in the library if she is unwell.
she is prevented from studying late in the library if she has a more important meeting.
she is prevented from studying late in the library if she has been distracted.

"The relationship between the two formulations [in the Suppression Task] is another example of the relationship between a higher-level and lower-level representation, which is a recurrent theme in this book. In this case, the higher-level rule acts as a simple first approximation to the more complicated rule. In most cases, when a concept is under development, the complicated rule doesn’t even exist, and the higher-level representation as a rule and exceptions makes it easier to develop the more complex representation by successive approximation" (Robert Kowalski, Computational Logic and Human Thinking, 87). is "compiled into" the following "lower-level representation":

she will study late in the library
if she has an essay to write
and the library is open
and she is not unwell
and she doesn’t have a more important meeting
and she hasn’t been distracted.

Kowalski's view, it seems, is that this "compiling" happens in human beings as part of the development of the concept "she will study late in the library."

This idea of "concept development" is interesting and has a certain amount of initial plausibility, but more explanation is necessary before it is reasonable to conclude that Kowalksi has provided a satisfactory explanation of the experimental results in the Suppression Task.

Problems for the Logic Programming/Agent Model

The addition of NAF (negation-as-failure) improves the logic programming/agent model, but it also highlights certain problems that need solutions if the model is to be adequate.

1. "[T]he human designer, after studying the world, uses the language of a particular logical system to give to our agent an initial set of beliefs Delta_0 about what this world is like. In doing so, the designer works with a formal model of this world, W, and ensures that W ⊨ Delta_0. Following tradition, we refer to Delta_0 as the agent’s (starting) knowledge base. (This terminology, given that we are talking about the agent’s beliefs, is known to be peculiar, but it persists.) Next, the agent ADJUSTS its knowledge base to produce a new one, Delta_1. We say that adjustment is carried out by way of an operation ccA; so A[Delta_0]= Delta_1. How does the adjustment process, ccA, work? ... [The adjustment] can come by way of any mode of reasoning.... The cycle continues when the agent ACTS on the environment, in an attempt to secure its goals. Acting, of course, can cause changes to the environment. At this point, the agent SENSES the environment, and this new information Gamma_1 factors into the process of adjustment, so that ccA[Delta_1 ∪ Gamma_1] = Delta_2. The cycle of SENSESADJUSTSACTS continues to produce the life Delta_0, Delta_1, Delta_2,Delta_3…, … of our agent" (Stanford Encyclopedia of Philosophy, Artificial Intelligence). Suppose an agent notices that "not-φ" is a consequence of what he believes. He is permitted to add it to his beliefs, but logic programming with NAF does not allow for this possibility.

2. If an agent notices that a proposition φ is a defeasible consequence of what he believes, he is permitted to add the proposition to his beliefs. Suppose he notices and adds it. Suppose subsequently he comes to believe some new proposition that defeats φ. It is rational for the agent in these circumstances to retract his belief in φ, but as we have set out the logic programming/agent model, there is no mechanism for adjusting the KB in this way.

3. Suppose an agent notices that a proposition is a consequence of what he believes. He is permitted to add the consequence to his existing beliefs, but he is not required to add it. He might instead decide to give up one of his existing beliefs. As we have set out the logic programming/agent model, there is no mechanism for adjusting the KB in this way.

This problems show that in the logic programming/agent model, we need a better mechanism for updating beliefs. All we have now is the ability to determine logical consequence and the ability to determine NAF consequence. This is some intelligence, but it is not enough.

Negation-As-Failure in Prolog

Here is an example Prolog program (based on the movie Pulp Fiction) with NAF (negation-as-failure). Suppose that Vincent enjoys every kind of burger except a Big Kahuna Burger.

enjoys(vincent,X) :- burger(X), \+ big_kahuna_burger(X).
burger(X) :- big_mac(X).
burger(X) :- big_kahuna_burger(X).
burger(X) :- whopper(X).
big_mac(a).
big_mac(c).
big_kahuna_burger(b).
whopper(d).

Suppose we ask whether there is something Vincent enjoys:

Given unification, the initial query

enjoys(vincent,X)

matches the head of the instance of the first rule

enjoys(vincent,a) :- burger(a), \+ big_kahuna_burger(a)

So the derived query is

burger(a), \+ big_kahuna_burger(a)

The first conjunct in this derived query matches the head of the instance of the second rule

burger(a) :- big_mac(a).

So the derived query becomes

big_mac(a), \+ big_kahuna_burger(a)

The first conjunct in this query matches the fact

big_mac(a)

So the derived query becomes

\+ big_kahuna_burger(a)

This "not" as NAF (\+) query succeeds if

big_kahuna_burger(a)

fails. It does fail. So

\+ big_kahuna_burger(a)

succeeds and hence

enjoys(vincent,a)

succeeds. One kind of burger Vincent enjoys is a Big Mac.

Another Example with NAF

Here is a variation on the "burger" example that is a little more like the "innocent unless proven guilty" example. The query asks whether Vincent enjoys a Big Kahuna burger. Given the first rule in the KB, Vincent enjoys all burgers except those to which he is allergic. Since there is no proof that he is allergic to Big Kahuna burgers, the query succeeds.

:- dynamic allergic/2.

enjoys(vincent,X) :- burger(X), \+ allergic(vincent,X).

%allergic(vincent,X) :- big_kahuna_burger(X).

burger(X) :- big_mac(X).
burger(X) :- big_kahuna_burger(X).
burger(X) :- whopper(X).

big_kahuna_burger(a_big_kahuna_burger).
big_mac(a_big_mac_burger).
whopper(a_whopper).

Here is what happens when the KB contains the new belief that Vincent is allergic to Big Kahuna Burgers. (To add the belief, uncomment the rule for predicate allergic.)

What we have Accomplished in this Lecture

We distinguished the Negation-as-Failure rule (NAF) from the Negation-Introduction (¬I) rule of classical logic and identified it as a form of defeasible reasoning. We considered how to incorporate NAF into logic programming. We looked at Kowalski's use of NAF in his solution to the Suppression Task, and we raised some questions about whether his solution is adequate. We considered some of the problems that remain for using the logic programming with NAF/agent model. Finally, we saw NAF at work in some simple Prolog programs.