Outline

• Logic
• Quiz
• Propositional Logic
• Propositional Theorem Proving

Introduction

• Last Wednesday, we started talking about knowledge-based agents
• These agents are equipped with a knowledge-base (KB) that they can tell things as well as ask things.
• The basic KB agent returns an action by telling its KB is current percept, asking its KB an action query, and then telling the KB what it did before returning that action.
• We gave an example of a KB agent in action in the Wumpus world setting. Here an agent had to find a bar of gold in a partially observable world, given that a deadly wumpus might be in one room and other rooms might have pits.
• In adjacent to danger squares, the agent's sensors can detect either a breeze or a stench, using these properties the agent can often get the gold without dying, by inferring the actual state of the squares.
• We want to discuss this inference process in more detail so we started talking about logic. We discussed syntax, semantics, model and satisfies.
• Today, we continue to talk about logic.

Entailment

• We have already said semantics tells us about the truth of a syntactically correct statement in a possible world/model
• We now want to consider logical reasoning. To do this we begin by looking at entailment between sentences -- the idea that one sentence follows from another sentence/set of sentences.
• We say `alpha |== beta` iff `M(alpha) subseteq M(beta)` . We read `|==` as entails
• For example, if we considers worlds satisfying the Wumpus World rules, the fact that we didn't feel a breeze at `(1,1)` entails that there is no pit in `(1,2)`. On the other hand, when we felt a breeze in `(1,2)` it didn't entail there was a pit in `(1,1)`.
• The process of using entailment to derive conclusions is called logical inference.
• One way to infer `KB models alpha` is to check every single possible model of say `M(KB)` and verify it is a model of `alpha`. This is called model checking
• General we would like to come with faster ways to determine entailment.
• We write `KB |--_i alpha` when we want to express that it was our inference algorithm `i` that derived `alpha` as following from `KB`.
• An inference algorithm that derives only entailed sentences is called sound or truth-preserving.
• An inference algorithm is complete if it can derive any sentence that is entailed.

Quiz

Propositional Logic

• We now study a simple but powerful logic called propositional logic. We briefly discussed this at the end of last day when I went off notes.
• We want to describe in detail its syntax, its semantics, and entailment.

Syntax

• The syntax of propositional logic defines the allowable sentences.
• The simplest of these are the atomic sentences which consist of a single propositional symbol, (aka a variable).
• Each symbol stands for a proposition that can be true or false.
• We use symbols that start with an uppercase letter followed by other letters or subscripts to denote these symbols. For example, `P, Q, R, W_(1,3), N\o\r\th` are each propositional symbols.
• There are two propositional symbols with fixed meanings: True is the always-true proposition, False is the always-false proposition.
• Complex sentences are constructed from simpler sentences using parentheses and logical connectives...

Logical Connectives

The logical connectives are:

• `neg` (not). We say a sentence such as `neg W` is the negation of `W`. We use the term literal to mean either an atomic formula (positive literal) `W` or its negation (negative literal), `neg W`.
• `^^` (and). A sentence whose main connective is `^^` such as `(W ^^ P)` is called a conjunction and its parts are called conjuncts.
• `vv` (or). A sentence whose main connective is `vv` such as `((W ^^ E)vv P)` is called a disjunction and its parts are called disjuncts. (`vv` comes from the Latin "vel" which means or)
• `=>` (implies). A sentence such as `((A ^^ B) => C)` is called an implication. Its premise or antecedent is `(A ^^ B)` and its conclusion or consequent is `C`. Sometimes implies is written as `supset`.
• `<=>` (if and only if) The sentence `(A<=>B)` is a biconditional.
• What constitutes a sentence can be given by the following context-free grammar:

  Sentence := AtomicSentence | ComplexSentence
  AtomicSentence := True | False | P | Q | R |...
  ComplexSentence := (Sentence) | [Sentence]
  | `neg` Sentence
  | Sentence `^^` Sentence
  | Sentence `vv` Sentence
  | Sentence `=>` Sentence
  | Sentence `<=>` Sentence
  
  

• Operator precedence `neg`, `^^`, `vv`, `=>`, `<=>` to enforce meaning.

Semantics

• Now that we have defined what is a legal sentence, we now turn to what does a sentence mean? i.e., its semantics.
• In propositional logic, a model fixes the truth value -- true or false -- for every propositional symbol.
• So if the sentence in the KB used the propositional symbols `A, B, C, D`, then an example model might be:
  `M = {A = true, B = false, C = false, D = true}`
• For four propositional symbols there are `2^4 = 16` possible models.

Truth of any Sentence in a Model

• The semantics of propositional logic must specify how to compute the truth value of any sentence, given a model.
• We do this inductively. We define True to be true in any model and False to be false in any model. The model itself says the truth or falsity of all AtomicSentences. Suppose we have already defined the truth of `phi` and `psi`. Then:
  `neg phi` is true in `M` iff `phi` is false in `M`
  `phi ^^ psi` is true in `M` iff `phi` is true in `M` and `psi` is true in `M`
  `phi vv psi` is true in `M` iff `phi` is true in `M` or `psi` is true in `M`
  `phi => psi` is true in `M` unless `phi` is true in `M` and `psi` is false in `M`
  `phi <=> psi`is true in `M` iff both `phi` and `psi` are both true or both false

A Simple Knowledge Base

• Now that we have defined the semantics of propositional logic, we can construct a KB for the wumpus world:
• We use the following variables with intended meanings:
  • `P_(x,y)` is true if there is a pit in `[x,y]`
  • `W_(x,y)` is true if there is a wumpus in `[x,y]` dead or alive
  • `B_(x,y)` is true if the agent perceives a breeze in `[x,y]`
  • `S_(x,y)` is true if the agent perceives a stench in `[x,y]`
• We now write some sentences which suffice to derive `neg P_(1,2)`. We label each sentence `R_i` so we can refer to them.
  1. There is no pit in [1,1]:
     `R_1 : neg P_(1,1)`
  2. A square is breezy iff there is a pit in a neighboring square. The 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))`
  3. 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)`

A Simple Inference Procedure

• Our goal is to decide whether `KB models alpha` for some sentence `alpha`.
• In particular, is `neg P_(1,2)` entailed by our `KB`.
• Our first algorithm for inference is a model-checking approach: enumerate the models, and check that `alpha` is true in every model in which KB is true.
• So for our wumpus world example the relevant variables to consider are: `B_(1,1), B_(2,1), P_(1,1), P_(1,2), P_(2,1), P_(2,2), and P_(3,1)`
• These can take on `2^7 = 128` values (possible worlds). In three of these the KB is true. In each of these it turns out that `neg P_(1,2)`, so it does follow
• This is an exponential time algorithm in the number of propositions. It turns out that we don't know if we can do better by being clever: It would imply `NP = co`-`NP`.

Theorem Proving

• Rather than determining entailment by model checking, one could instead do it via theorem proving -- applying rules of inference directly to the sentences in our knowledge base to construct a proof of the desired sentence without consulting models.
• To do this we make use of something called logical equivalence: two sentences `alpha` and `beta` are logically equivalent if they are true in the same set of models. For `alpha`, and `beta` sentences we would write this as `alpha equiv beta`.
• For example, `P ^^ Q` and `Q ^^ P` are logically equivalent
• The second concept needed for theorem proving is that of validity: A sentence is valid if it is true in all models. Valid sentences are also known as tautologies.
• The deduction theorem known to the ancient Greeks says that `alpha models beta` iff the sentence `alpha => beta` is valid.
• So we will be interested in tautologies of the latter form