These agents have a knowledge-base that they can tell their percepts to.
They can 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.
If a knowledge base and statement involve `n` propositional variables then checking `KB models A` means cycle over `2^n` models (so taking exponential time) and for each one seeing that if all the statements of `KB` hold in the model then also `A` holds in model.
We said theorem proving was another approach to check `KB models A`.
In this approach, we try to use the logical equivalences we discussed last day (such as `(alpha ^^ beta) equiv (beta ^^ alpha)`) to derive A from KB.
To make this idea concrete we introduced a set of logical equivalences. We also defined the concepts of a sentence being valid and a sentence being satisfiable.
We mentioned the deductions theorem: `alpha models beta` iff `alpha => beta` is valid.
We said one approach to proving `alpha => beta` is valid is by giving a refutation, that is, checking the unsatisfiability of `alpha ^^ not beta` (show has no models).
Inferences and Proofs
We now look at inference rules that can be applied to derive a proof -- a chain of conclusions that leads to the establishment
of some statement following from the knowledge base.
The best known such rule is called Modus Ponens (IMP-Elimination) and it is written as:
`frac(alpha, alpha => beta)(beta)`
It states that if we have already derives the two statements `alpha` and `alpha => beta` then we are allowed to derive `beta`.
For example, if we know (WumpusAhead `^^` WumpusAlive) and (WumpusAhead `^^` WumpusAlive) `=>` Shoot, then we are allowed to infer Shoot.
By considering all the possible true values for `alpha` and `beta` one can show both Modus Ponens, And-Elimination, etc are sound.
One can also make any of our logical equivalences into a rule of inference. For example, biconditional elimination yields the following two inferences:
`frac(alpha <=> beta)(alpha => beta ^^ beta =>alpha)` and
`frac(alpha => beta ^^ beta =>alpha)(alpha <=> beta)`
An Example
Recall earlier we derived `neg P_(1,2)` from the following knowledge base statements `R_i` using model checking.
There is no pit in [1,1]:
`R_1 : neg P_(1,1)`
A square is breezy iff there is a pit in a neighboring square. This has to be stated for each square: for now we include just the relevant squares:
`R_2 : B_(1,1) <=> (P_(1,2) vv P_(2,1))`
`R_3 : B_(2,1) <=> (P_(1,1) vv P_(2,2) vv P_(3,1))`
The preceding sentences are true in all wumpus worlds. Now we include the breeze percept for the first two squares visited in the specific world the agent is in:
`R_4: neg B_(1,1)`
`R_5: B_(2,1)`
Alternatively, we can come up with a (propositional) proof of `neg P_(1,2)` from the above knowledge base using rules of inferences.
A proof consists of a sequence of lines `R_1 , ... R_m` where each `R_i` is either from the knowledge base, an instance or excluded middle, (i.e, of the form `neg A vv A`), a substitution instance of a logical equivalence, or follows from some `R_j` and `R_k` where
`j < i` and `k < i` by some rule of (propositional) inference.
The proof system we have just described is called natural deduction.
The desired statement follows from `R_10` by And-Elimination
Search and Proofs
Each line in the proof we just gave can be checked mechanically (say by a program) to determine it is either from the KB or
follows from preceding lines by one of our rules of inference.
We found this proof by looking in our textbook, but we could imagine framing proof search as a problem and using one of
our algorithms from earlier in the semester to find proofs:
Initial State: the initial knowledge base
Actions: The set of actions consist of all inference rules applied to all the sentences that match the top half of an inference rule
Result: The result of an action is to add the bottom half of the inference rule to our KB
Goal: The goal is a KB that contains the statement we are trying to prove
This gives an alternative to model-checking which is often faster as the proof can ignore irrelevant propositions no matter how many there are.
Notice this algorithm and propositional logic illustrate a property of knowledge bases known as monotonicity: that the set of entailed sentences can only increase as information is added to the database.
There are actually logics known as nonmonotonic logics (extensively studied in AI as connected with human reasoning) for which this property fails.
Proof by Resolution
So far we have looked at making inference algorithms which are sound; we have not considered the completeness of our algorithms.
It turns out Natural Deduction is complete, but I won't prove this, I'll instead focus on a simpler system.
We next consider a proof system that has a single inference rule, resolution, which is known to be sound and complete.
In its simplest form, the rule says that if we know `(A vv B)` and we know `neg B` then we can conclude `A`.
We can generalize this to:
`frac( L_1 vv ... vv L_m, quad neg L_m vv L_1' vv ...vv L_n')(L_1 vv ... vv L_(m-1) vv L_1' vv ... vv L_n')`
In the above, `L_i` and `L_j'` are literals: either variables or their negation.
For a variable `X`, we often write `bar(X)` for `neg X`.
That the top of the inference logically implies the bottom can be checked using model checking so the rule above is sound.
The bottom line of this inference is called the resolvent.
If we don't have any `L_j'`'s then it is called unit resolution. That is, the right hand clause consists of just `bar(L_m)`. (There are algorithms that work better for this case).
You often see clauses written as `{L_1, ..., L_m}` rather than use `vv`.
Set notation is used because `{L, L}` is logically equivalent to `{L}`.
A resolution refutation of a set of clauses `Gamma` is a sequence of clauses `R_1, ..., R_m` where `R_m = {}` such that for `1 leq i leq m`, `R_i in Gamma` or for some `j,k < i`, `R_i` follows from `R_j` and `R_k` by resolution.
Quiz
Which of the following is true?
The syntax of propositional sentences defines what sentences are allowable/well-formed.
Semantics is the study of the computation needed to determine if a sentence is syntactically correct.
A propositional sentence is valid iff it is true in exactly one model.
Resolution Example - the Pigeonhole Principle
The m-into-n pigeonhole principle (`PHP_n^m`) states you can't map `m>n` many pigeons into `n` holes without multiple pigeons ending in some hole together.
Let's see how we could express `\neg PHP_n^m` as clauses and give a refutation of the statement `\neg PHP_1^2`.
First, we use the variables `p_{ij}` to denote the `i`th pigeon ends up in the `j`th hole.
We express that each pigeons ends up in some hole by have for `1 \leq i leq m` a clause of the form `{p_{i1}, ..., p_{i\n}}`.
To express that pigeon `i` and pigeon `j` don't end up in hole `k` together, we have for all `1 \leq i \ne j leq m` and for all `1 \leq k leq n`,
we have the clause `{bar{p_{ik}}, \bar{p_{jk}}}`.
I am being lazy and not adding clauses that say a single pigeon can't be in more than one hole. Some people call this variant of the pigeonhole principle, the multifunction pigeonhole principle.
If we use the above bullets to define `\neg PHP_n^m`, then `\neg PHP_1^2` is the set of clauses `{{p_{11}}, {p_{21}}, {bar{p}_{11},bar{p}_{21}}}`.
