Third edition of Artificial Intelligence: foundations of computational agents, Cambridge University Press, 2023 is now available (including the full text).
5.5 Complete Knowledge Assumption
A database is often complete in the sense that anything not stated is false.
The given definite-clause logic does not allow the derivation of a conclusion from a lack of knowledge or a failure to prove. It does not assume that the knowledge is complete. In particular, the negation of an atom can never be a logical consequence of a definite-clause knowledge base.
The complete knowledge assumption assumes that, for every atom, the clauses with the atom as the head cover all the cases when the atom is true. Under this assumption, an agent can conclude that an atom is false if it cannot derive that the atom is true. This is also called the closed-world assumption. It can be contrasted with the open-world assumption, which is that the agent does not know everything and so cannot make any conclusions from a lack of knowledge. The closed-world assumption requires that everything relevant about the world be known to the agent.
When there are rules for an atom, the assumption is that the rules for each atom cover all of the cases where the atom is true. In particular, suppose the rules for atom a are
...
a←bn.
where an atomic clause a is the rule a ←true. The complete knowledge assumption says that if a is true in some interpretation then one of the bi must be true in that interpretation; that is,
Because the clauses defining a are equivalent to
the meaning of the clauses can be seen as the conjunction of these two propositions, namely, the equivalence:
where ↔ is read as "if and only if" (see Figure 5.1). This equivalence is called Clark's completion of the clauses for a. Clark's completion of a knowledge base is the completion for each atom in the knowledge base.
Clark's completion means that if there are no rules for an atom a, the completion of this atom is a↔false, which means that a is false.
up_s2.
live_l1 ←live_w0.
live_w0 ←live_w1 ∧up_s2.
live_w0 ←live_w2 ∧down_s2.
live_w1 ←live_w3 ∧up_s1.
Suppose that these are the only clauses for the atoms in the heads of these clauses, and there are no clauses for up_s1 or down_s2. The completion of these atoms is
up_s1 ↔false.
up_s2 ↔true.
down_s2 ↔false.
live_l1 ↔live_w0.
live_w0 ↔(live_w1 ∧up_s2) ∨(live_w2 ∧down_s2).
live_w1 ↔live_w3 ∧up_s1.
This implies that up_s1 is false, and live_w1 is false.
With the completion, the system can derive negations, and so it is useful to extend the language to allow negations in the body of clauses. A literal is either an atom or the negation of an atom. The definition of a definite clause can be extended to allow literals in the body rather than just atoms. We write the negation of atom a under the complete knowledge assumption as ∼a to distinguish it from classical negation that does not assume the completion. This negation is often called negation as failure.
Under negation as failure, body g is a consequence of the knowledge
base KB if KB' 
g, where KB' is Clark's
completion of KB. A negation ∼a in the body of a
clause or the query becomes ¬a in the completion.
That is, a query following from a knowledge base
under the complete knowledge assumption means that the query is a logical
consequence of the completion of
the knowledge base.
down_s2 ←∼up_s2.
down_s3 ←∼up_s3.
Similarly, the system may conclude that the circuit breakers are okay unless it has been told they are broken:
ok_cb2 ←∼broken_cb2.
Although this may look more complicated than the previous representation, it means that is it easier for the user to specify what is occurring in a particular situation. The user has to specify only what is up and what is broken. This may save time if being down is normal for switches and being okay is normal for circuit breakers.
To represent the state of Figure 5.2, the user specifies
up_s3.
The system can infer that s1 must be down and both circuit breakers are okay.
The completion of the knowledge base is
down_s2 ↔¬up_s2.
down_s3 ↔¬up_s3.
ok_cb1 ↔¬broken_cb1.
ok_cb2 ↔¬broken_cb2.
up_s1↔false.
up_s2 ↔true.
up_s3 ↔true.
broken_cb1↔false.
broken_cb2↔false.
Notice that atoms in bodies of clauses but not in the head of any clauses are false in the completion.
Recall that a knowledge base is acyclic if there is an assignment of natural numbers (non-negative integers) to the atoms so that the atoms in the body of a clause are assigned a lower number than the atom in the head. With negation as failure, non-acyclic knowledge bases become semantically problematic.
The following knowledge base is not acyclic:
b ←∼a.
Clark's completion of this knowledge base is equivalent to a ↔¬b, which just specifies that a and b have different truth values but not which one is true.
The following knowledge base is not acyclic:
Clark's completion of this knowledge base is a ↔¬a, which is logically inconsistent.
Clark's completion of an acyclic knowledge base is always consistent and always gives a truth value to each atom. For the rest of this chapter, we assume that the knowledge bases are acyclic.
