Outline

• Using First-order Logic
• Theorem Proving
• Unification

Introduction

• On Monday, we started talking about First-Order Logic.
• When we were talking about search we switched from problem solving agents which worked on atomic domains, to constraint satisfaction problems where the domain was factored.
• In similar fashion, we have talked about logic-based agents and we have said that one way to represent their knowledge bases is with propositional logic.
• This works well for atomic domains, but now we are interested in logic-based agents that can work with factored domains, where we have real world objects whose properties can take on more than binary values.
• First-order logic is our approach for doing this.
• In first-order logic, we have constants and variables which run over domains. We can build up terms using these, and the functions of our first-order logic. We can substitute terms into the predicates of our logic to make atomic formulas, and we can build general first-order formulas out of these using `neg, ^^, vv, forall x, exists y`.
• At the end of last day we gave, the Tarski definition of truth of a formula `F` in a model `M`.
• We now return to talking about knowledge bases, but in this new setting.

Using First-Order Logic

• As in the propositional case, our logic-based agent will tell its knowledge base facts.
• For example,
  `TELL(KB, K\i\ng(John))`.
  `TELL(KB, Person(Richard))`.
  `TELL(KB, forall x K\i\ng(x) => Person(x))`.
  
• In the course, of deciding what to do next the logic-based agent might ask the knowledge-base questions:
  `Ask(KB, K\i\ng(John))`
• Such a question is called a query or a goal. The result in the case should be just True.
• We can ask more complicated questions such as:
  `Ask(KB, exists x Person(x))`
• Again, from our knowledge base we can see the answer is True since Richard is a Person. In this case, it also useful to know this witness to the truth of the question. So in addition to Ask questions like above, we also allow questions like:
  `AskVars(KB, Person(x))`
• The response to such a query is a substitution (aka binding list) which makes the query statement true, in this case, {x/Richard}.

Example 1st Order Knowledge bases

• Any relational database.
• The Natural Numbers:
  • Has one constant `0` and one function symbol `S`. (The Peano Axioms add to these `+`, and `times`).
  • We have two predicate symbols: NatNum(x) which obeys the axioms:
    `NatNum(0).`
    `forall n, NatNum(n) => NatNum(S(n)))`
    we also have equality `=` in our language.
  • So `0`, `S(0)`, `S(S(0))`... are natural numbers
  • To constrain the behavior of `S` we need to add the axioms:
    `forall n, 0 ne S(n).`
    `forall m,n, m ne n => S(m) ne S(n)`.
• Set theory:
  • Has one constant `O/` (empty) and predicate symbols `in` (element of)
  • No function symbols
  • Knowledge base for set theory consists of formulas like `neg( 0 in 0)`, `exists x neg(x = 0)`, ...
  • `=` abbreviates that `x` and `y` have the same elements.
• The book gives an example of reformulating the Wumpus World in the first-order setting.

KBs, First-Order Proofs

• Write `KB |== F` to mean for all structures `M`, such that `M |== KB` we also have `M |== F`
• Proofs in 1st Order Logic are very much like proofs in propositional logic except now we have some additional axioms.
• For example, some possible additional axioms might be:
  `(forall x) (neg P) => neg((exists x) P)`
  (for every pig, it can't fly = not there is a pig that can fly)
  `neg(forall x P) =>(exists x) neg P`
  (Not for every horse it is blue = there is a horse that is not blue)
  `A(t) => (exists x) A(x)`
  `A(x)=> (forall y) A(y)`
  etc.
• In many ways, one can treat thehttp://www.cs.sjsu.edu/faculty/pollett/156.1.12s/folder.php behavior of `forall x F(x)` as a big AND over the substitution of values `x` could take in the formula `F`.
• Similar, one can treat the behavior of `exists x F(x)` as a big OR over the substitution of values `x` could take in the formula `F`.

Soundness and Completeness

• As with the propositional case one can show that for first-order logic, `Gamma |-- F` then `Gamma |== F` for the proof system extended by axioms as on the last slide for exists and forall. (Soundness)
• Moreover, if we have a good initial set of propositional axioms, Godel (1930) showed that whenever our proof system can prove a statement `Gamma |== F` then in fact `Gamma |-- F`. (Completeness)
• It is possible to do model checking in the first-order setting if the universe is finite, but the time complexity is just as bad/worse than the propositional setting.
• So let's consider for a moment how we could make a theorem prover for first-order logic.

Theorem Proving in First-Order Logic

The basic idea is we want to reduce the first-order case to the propositional case. To do this:

1. Convert `KB ^^ neg alpha` using some of the operations previously described into prenex normal form:
   `forall vec(x) exists vec(y) forall vec(z) ... G(vec(x), vec(y), vec(z), ...)`
   where `G` does not involve quantifiers.
2. Introduce new function symbols for `forall exists` blocks. For example,
   `forall x_1 forall x_2, exists y_1, exists y_2, exists y_3 G(x_1, x_2, y_1, y_2, y_3) => forall x_1 forall x_2,G(x_1, x_2, f_1(x_1, x_2), f_2(x_1, x_2), f_3(x_1, x_2))`
3. Once get open formulas without any quantifiers, convert to CNF and try to use resolution algorithm.

One new wrinkle is that we now might need to come up with substitution lists between two atomic formula `G(vec(t))`, `G(vec(s))` for the terms `t_1, ..., t_n` and `s_1`, ..., `s_n`. Unification is an algorithm for doing this.

Unification Algorithm

If x is a list let head(x) denote the first element of the list, x[0], and tail(x) denote x[1:]. The code below relies on Unify-var which is on the next slide.

Unify(x, y, S)
x - a variable, constant, term or list 
y - a variable, constant, term, or list 
S - a substitution so far
if(S == fail) return fail
if (x(S) == y(S)) return S
else if ( var? (x))
    return Unify-var(x, y, S)
else if ( var? (y))
    return Unify-var(y, x, S)
else if ( term? (x) and term? (y))
    return (Unify(args (x), args(y), Unify( op(x), op(y), S))
else if (list? (x) and list? (y) )
    return (Unify(tail(x), tail(y), Unify(head(x), head(y), S)))
else
    return fail

As an example of what I mean by op, consider x:=((z*z) +35). Here op is the top operation, so +. args(x) := (z*z, 35), so contains two terms: the left and right symbol of +.

Unify-var

Here Unify-var is defined as:

Unify-var(var, y, S)
var - a variable
y - an expression 
S - a substitution
if(var |-> val) exists in S 
    return Unify(val, x, S)
else if (x |-> val) exists in S 
     return Unify(var, val, S)
else if (occur-ck? (var, x)) return fail;
else
    return ( append((var |-> x), S))

Suppose x is f(var), then var occurs in f(var) in the above and occur-ck of (var, x) is true! (note: prolog doesn't do occur-ck's)

Example

Consider:

num(0).
num(s(X)) :- num(X) 
|?- num(s (s (X))) (returns fail, because of the occurs check)

As an example of unify in action, consider:

x' = g(h(x, y), z)
y' = g(w, t(v))

Initially, S is (). Since x' and y' are both terms, we return

Unify((h(x, y), z), (w, t(v)), Unify(g(a, b), g(a, b))) 

Notice that a, b are new variable names. The second Unify will return S = (), since both g(a, b) are the same thing.

So now we try to unify two lists (h(x, y), z), (w, t(v)).

So we will do Unify( (z), (t(v)), Unify (Unify (h(x, y), w, S). S is still ().

Now we call Unify-var (w, h(x,y), S).

This statement will return (w |-> h(x, y)). We now need to unify (z) and (t(v)) with respect to the substitution (w |-> h(x,y')). When we get the final recursive answer, we will have ( (z |-> t(v)), (w |-> h(x,y)) )