Introduction

Before the break we were talking about logic-based agents.
These agents had a knowledge-base that they could tell their percepts to.
They could also ask their knowledge base questions in order to figure out what to do next.
We considered formulating knowledge bases using propositional logic and gave an example with the Wumpus World.
We also gave an example of how to infer facts about the Wumpus World using model checking and theorem proving.
We said we can determine if A is true in a propositional KB, by taking `(KB ^^ neg A)`, converting it to CNF, and checking using resolution if this had a refutation.
Today, we are going to look at more complicated logics to formulate KBs with.
Although we haven't said yet how to use the fact we can infer what's true in a KB to decide what to do next, we will do that after talking about first-order logic when we talk about planning.

Horn Clauses and Definite Clauses

Before we talk about first-order logic I wanted to mention some last things about resolution.
So far we have looked at the case where we could have had more than one positive and more than one negative literal.
In the case where he have exactly one positive literal, we have a definite clause. For example, `(L vv neg B vv neg C)`. This is often written like `L :- B, C` as an ASCII short-hand for `(B ^^ C) => L`.
Here is `L` is the head of the clause, and `B, C` is called the tail and the whole clause is called a rule.
Slightly more general than a definite clause is a Horn clause, it is allowed to have at most one positive literal. So `(neg B)` is a Horn Clause, but not a definite clause. This might be written as `:- B`. If this were a prompt in Prolog, it would be written as `|?-B` and called a goal clause.
A collection of Horn clauses is called a Horn Program, which is a particular kind of logic program.
KBs that are Horn Programs are useful as deciding entailment for these clauses can be done in linear time and space.
If we want to see if `B` follows from a `KB` which is a Horn program we can start with the rules that involve `B` in the head. For each such rule we could then check each variable in its tail to see if it is a fact in the KB. If not, we look for a rule that involves that variable and try to see if we can derive it and so on. This is called backward chaining.
Alternatively, we can start with the fact in the `KB`. Then for each rule for which its tail consists of only facts, add its head to the `KB`. Keep iterating until no change. If we derive `B` in the process, we know `KB` entails `B` this is called forward-chaining.

Quiz

Which of the following is true?

The number of models of a propositional formula is always linearly bounded in the number of variables.
If a propositional logic formula is unsatisfiable then its resolution closure after conversion to CNF will contain the empty clause.
`alpha models beta` iff the sentence `alpha => beta` is valid can fail sometimes in propositional logic.

First-Order Logic

Point: Want to be able to reason about sets of objects rather than true/false values.
Where used: Parsers, Prolog, relational databases, planning

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

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 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`.
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 if the meaning of a formula `F`?

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]`

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.

First-Order Logic

Outline

Introduction

Horn Clauses and Definite Clauses

Quiz

First-Order Logic

Examples

Semantics 1st order formulas

What if the meaning of a formula `F`?

KBs, First-Order, Proofs

Example 1st Order Knowledge bases