Outline

• First-Order Logic
• In-Class Exercise
• First-Order Theorem Proving Algorithms

Introduction

• We have been talking about first-order logic as a means to extend our logic-based agents to factored domains.
• At the end of last day, we introduced the syntax of first order formulas which we repeat below before giving some examples and then discussing the meaning of a first-order sentence.
• Syntax

  Variables: x, y, z, ... -> range over sets. 
     Example: x might be an element in a set of colors.
  Constants: a, b, c, ... 
     Example: Fixed values from a set, 0, "Bob"
  Functions: f, g, h, ...
     Example: x + y is a function
  Predicates: `P`, `Q`, `R` ...  These take inputs and output true/false.
     Example, x=7 is a predicate.
  

• A term is variable or a constant, or built up from these using function symbols and composition.
• An atomic formula is a predicate where each of the predicate slots has been filled with a term. For example: IsPrime(X*X+3).
• A formula is either an atomic formula or built out of simpler formulas, `F_1` and `F_2` by one of the following operations.
  1. `neg (F_1)`
  2. `(F_1 ^^ F_2)`
  3. `(F_1 vv F_2)`
  4. `(F_1 => F_2)`
  5. `(F_1 <=> F_2)`
  6. `forall x F_1` for some variable `x`. Reads as for every `x`, `F_1` holds.
  7. `exists x F_1` for some variable `x`. Reads as there exists some `x`, `F_1` holds.

Examples

• Suppose Richard and John are constants, we assume variables range over a space of things.
• We can express facts about two famous kings of England using the predicates, Brother, Married, and King:
  `Brother(Richard, John)`.
• This is an example atomic formula. Let Mother and Father be functions which given a person returns their mother or their father. A more complicated atomic formula expressing that Richard and John are at least half-brothers is:
  `Married(Father(Richard), Mother(John))`
• More complicated non atomic formulas are things like:
  `K\i\ng(John) vv K\i\ng(Richard)`
  `Brother(John, Richard) ^^ Brother(Richard, John)`
  `forall x (K\i\ng(x) => Person(x))`

Semantics 1st order formulas

• To start we need to have a set `M` called the universe that our variables range over.
• For each constant `c` in our language, we need to give a value `c^M` in `M`. For example, if our universe where the reals, `RR`, and we had a constant symbol `pi`, `pi^{RR}` would be the assignment of `pi` to the value `3.1415 ... in RR`.
• Here the superscript means in the model, not exponentiation.
• For each function `f` in our language need to give an actual function
  `f^M: M times ... times M -> M` determined on `M`.
• For each predicate symbol `P`, `P^M:M times ... times M -> {T, F}`
• All of the above information together is called a structure/model. Usually, denoted by `M`.
• We can almost now talk about the meaning of a formula `F` in a given structure `M`...
• Consider:
  `(exists x)G(x, y)`
  in this formula `x` is called a bound variable as it is in the scope of an `exists` or `forall`, `y` is unbound.
• To give the meaning of a formula, we also need an unbound variable assignment. Here variable/object assignment `nu` is a map from unbound variables to elements of `M`. We can finally write `M |== F[v]` (`M` entails `F` with assignment `nu`)

What is the meaning of a formula `F`?

The definitions below are due to Tarski (1933) and Tarski and Vaught (1956).

• If `F` is an atomic formula calculate the value in `M` of each of the terms in `F`. Plug these values into the predicate `P^M` and see if outputs `T` or `F`.
• If `F:= neg G`, then `F` is true in `M,nu` iff not `M |== G[nu]`.
• If `F:= G vv H`, then `M|== F[nu]` iff `M|== G[nu]` or `M|== H[nu]`
• If `F:= G ^^ H` then `M|== F[nu]` iff `M|== G[nu]` and `M|== H[nu]`
• Other connectives are similar.
• If `F := (exists x) G` then `M |== F[nu]` iff there is some way to map `x -> x^M in M` such that `nu` is extended by this additional mapping give `M |== G [x-> x^M, v]`
• If `F := (forall x) G` then `M |== F[nu]` iff for all ways to map `x -> x^M in M`, `M|== G[x->x^M , nu]`.
• Write `M |== F` if for every variable assignment, `nu, M |== F[v]`

Example

• Suppose we have the language: `0`,`1`, `+`, `cdot`, `=` consider the formula `(exists x) (1+1)cdot x = 1+1+1+1`.
• This intuitively asserts there is some number such that twice that number is four.
• All variables in this formula are bound.
• Let our universe `M` be the natural numbers, `NN`: 0,1,2,3 ...
• Recall we will use superscript to mean in the model of the natural numbers, not exponentiation.
• We interpret `0^M` to be 0, zero in the natural numbers, and `1^M` to be 1, one in the natural numbers.
• We interpret the functions `+^M` and `cdot^M` as the usual plus and times on the natural numbers.
• We interpret the predicate `=^M` as the usual equality of two natural numbers.
• From the last slide `M |== (exists x) (1+1)cdot x = 1+1+1+1` iff there is some variable `x -> x^M in M` such that `M|== (1+1)cdot x = 1+1+1+1[x -> x^M]`.
• Suppose we map `x` to `2^M`. Then the statement holds if `(1^M +^M 1^M) cdot 2^M =^M 1^M +^M 1^M +^M 1^M +^M 1^M`. Now both sides, after computing the values in the model based on `1^M`, `2^M`, and `+^M`, are `4^M`. Thus, the statement does hold for our model.
• Consider the statement `(exists x) (1+1)cdot x = 1+1+1`. In our natural number model there is no assignment to `x->x^M` that could make this statement true. so `M` does not model `(exists x) (1+1)cdot x = 1+1+1`.
• Consider the model `M'` with universe `{0,1,2,3,4}` and where we interpret `+` and `cdot` using the integers mod `5`. In this model both, `(exists x) (1+1)cdot x = 1+1+1+1` and `(exists x) (1+1)cdot x = 1+1+1` will hold. To see this for the second statement, notice that `2 cdot 4 mod5 equiv 3` This shows that a statement can be true in more than one model and it also shows just because a statement is false in one model doesn't mean it is false in all models.

In-Class Exercise

• Let our language consist of the predicate `Knows(x,y)`.
• Consider the formula `(forall x) Knows(x,x) ^^ (exists y) neg Knows(z,y)`.
• Give a model and variable assignment under which this statement is true.
• Post your solutions to the Nov 2 In-Class Exercise Thread.

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 implies not there is a pig that can fly)
  `neg(forall x P) =>(exists x) neg P`
  (Not for every horse it is blue implies there is a horse that is not blue)
  `A(t) => (exists x) A(x)`
  `A(x)=> (forall y) A(y)`
  etc.

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}.