Knowledge Representation and Reasoning

Artificial Intelligence 

Knowledge Representation and Reasoning 

Propositional Logic 

Knowledge Representation and Reasoning – 1

Outline 

♦ Knowledge-based agents 

♦ Logic in general—models and entailment 

♦ Propositional (Boolean) logic 

♦ Equivalence, validity, satisfiability 

♦ Inference rules and theorem proving 

– forward chaining 

– backward chaining 

– resolution 


Motivation 

♦ All our search programs seem quite special purpose. 

♦ The search algorithm may be general, but we have to 

code up the problem representation and heuristic 

functions ourselves 

♦ Wouldn’t it be nice if we could build a more “general purpose” 

program. 

♦ E.g., suppose we could just 

♦ tell our program about the rules of chess or checkers, and 

it would be able to play 

♦ give it some ideas about how to play well, and it would use 

them. 


Knowledge Representation 

♦ Such a general program would have to be capable of 

"knowing" lots of things: 

♦ E.g., the rules of chess 

♦ Good strategies 

♦ Lots of things needed to make sense out of these rules, 

etc. (“Background knowledge”) 

♦ We would need to be able to express an open-ended variety 

of things, in some form that they can be properly manipulated. 

♦ The means of expressing general “facts”, or beliefs, etc., is 

called a knowledge representation language. 


Procedural vs. Declarative 

♦ "Know-how" versus "know-that". 

♦ In general, procedural knowledge is 

♦ Hard to use generally, reason with, introspect on, 

articulate. 

♦ Enable fast behavior 

♦ Declarative knowledge is 

♦ More flexible (multi-use), amenable to introspection, 

articulation 

♦ This is the focus of most KR work. 

♦ there must always be some sort of (procedural) 

mechanism around that interprets declarative knowledge 

(inference engine). 


Knowledge Representation Language 

♦ A KRL is a way of writing down beliefs (or other kinds of 

mental states) 

♦ Needs to be 

♦ Expressive 

♦ Unambiguous 

♦ Context-independent 

♦ Compositional 

♦ There have been various candidates proposed for KRLs over 

the years 


Logic as KRL 

♦ formal logic used as a basic framework for KRLs 

♦ Logic consists of 

♦ A language 

how to build up sentences in the language (syntax) 

and what those sentences mean (semantics) 

♦ An inference procedure 

which sentences are valid inferences from other 

sentences 


Knowledge bases 

Inference engine 

domain−independent algorithms 

Knowledge base 

domain−specific content 

♦ Knowledge base = set of sentences in a formal language 

♦ Declarative approach to building an agent (or other system): 

TELL it what it needs to know 

ASK itself what to do (answers follow from the KB) 

♦ agents can be viewed at the 

♦ knowledge level 

i.e., what they know, regardless of how implemented 

♦ implementation level 

i.e., data structures and algorithms to manipulate KB 


¦ 

§¨© 

¥ 

¡ ¢ ¡ £¤ 

¨ 

 

 

¨ 

¦ 

¦ 

 

¨ 

¦ 

¥ 

¡ £¤ 

 

¡ 

 

 

 

 

 

 

 

 

 

 

" 

# 

! ¡ 

A simple knowledge-based agent 

KB 

t 

¦ ¨ 

© ¢ ¡ 

TELL 

£ KB-AGENT 

action ← ASK 

TELLKB 

t ←t 

percept 

! ¡ 

¦¨ 

action 

¤ 

KB 

MAKE-PERCEPT-SENTENCE 

KB 

MAKE-ACTION-QUERY 

MAKE-ACTION-SENTENCE 

action 

percept,t 

t 

action t 

The agent must be able to: 

♦ represent states, actions, etc. 

♦ incorporate new percepts 

♦ update internal representations of the world 

♦ deduce hidden properties of the world 

♦ deduce appropriate actions 


Logic in general 

♦ Logics are formal languages for representing information 

such that conclusions can be drawn 

♦ Syntax defines the sentences in the language 

♦ Semantics define the “meaning” of sentences; 

i.e., define truth of a sentence in a world 

E.g., the language of arithmetic 

x + 2 ≥ y is a sentence; x2 + y > is not a sentence 

x + 2 ≥ y is true iff the number x + 2 is no less than the number y 

x + 2 ≥ y is true in a world where x = 7, y = 1 

x + 2 ≥ y is false in a world where x = 0, y = 6 


Entailment 

♦ Entailment means that one thing follows from another: 

KB |= α 

Knowledge base KB entails sentence α 

if and only if 

α is true in all worlds where KB is true 

♦ e.g., the KB containing “I’m hungry” and “I’m tired” entails 

“I’m hungry or I’m tired” 

♦ e.g., x + y = 4 entails 4 =x + y 

♦ Entailment is a relationship between sentences (i.e., syntax) 

based on semantics 

Note: brains process syntax (of some sort) 


Models 

Logicians typically think in terms of models, which are formally 

structured worlds with respect to which truth can be evaluated 

♦ we say m is a model of a sentence α if α is true in m 

♦ M(α) is the set of all models of α 

♦ KB |= α if and only if M(KB) ⊆ M(α) 

E.g. 

KB = I’m hungry and I’m tired 

α = I’m hungry M( ) 

x 

x 

x 

x 

x 

xx 

x 

x 

x 

x 

x 

x 

x 

x 

x 

x 

x 

x 

x 

M(KB) 

x 

x 

x 

x 

x 

x 

x 

x x 

x xx 

x 

x 

x 

x 

x 

x 

x 

x 

x 

x 

x 

x x 

x 


Inference 

♦ KB ⊢ i α = α can be derived from KB by procedure i 

♦ Consequences of KB are a haystack; α is a needle 

Entailment = needle in haystack; inference = finding it 

♦ Soundness: i is sound if whenever KB ⊢ i α, it is also true 

that KB |= α 

♦ Completeness: i is complete if whenever KB |= α, it is also 

true that KB ⊢ i α 


Propositional logic: Syntax 

Propositional logic is the simplest logic—illustrates basic ideas 

The proposition symbols P 1 , P 2 etc are sentences 

♦ If S is a sentence, ¬S is a sentence (negation) 

♦ If S 1 , S 2 are sentences, S 1 ∧ S 2 is a sentence (conjunction) 

♦ If S 1 , S 2 are sentences, S 1 ∨ S 2 is a sentence (disjunction) 

♦ If S 1 , S 2 are sentences, S 1 → S 2 is a sentence (implication) 

♦ If S 1 , S 2 are sentences, S 1 ↔ S 2 is a sentence (biconditional) 


Propositional logic: Semantics 

Each model specifies true/false for each proposition symbol 

E.g. P 1,2 P 2,2 P 3,1 

true true false 

(With these symbols, 8 possible models, can be enumerated 

automatically.) 

Rules for evaluating truth with respect to a model m: 

¬S is true iff S is false 

S 1 ∧ S 2 is true iff S 1 is true and S 2 is true 

S 1 ∨ S 2 is true iff S 1 is true or S 2 is true 

S 1 → S 2 is true iff S 1 is false or S 2 is true 

i.e., is false iff S 1 is true and S 2 is false 

S 1 ↔ S 2 is true iff S 1 → S 2 is true and S 2 → S 1 is true 

Simple recursive process evaluates an arbitrary sentence, e.g., 

¬P 1,2 ∧ (P 2,2 ∨ P 3,1 ) = true ∧ (false ∨ true) =true ∧ true =true 


Truth tables for connectives 

P Q ¬P P ∧ Q P ∨ Q P → Q P ↔ Q 

false false true false false true true 

false true true false true true false 

true false false false true false false 

true true false true true true true 


¤ ¡ 

¦¨ 

 

© ¨ 

¦ 

© 

 

 

! ¡ 

 

 

¤ ¡ 

 

 

 

 

 

! ( ! ! ¡ 

! ( ! 

 

 

) 

 

¢ 

* 

 

 

! ¡ 

 

 

 

Inference by enumeration 

Depth-first enumeration of all models is sound and complete 

symbols ← 

£ 

£ TT-ENTAILS? 

$ %&©&© 

 

TT-CHECK-ALL 

£ TT-CHECK-ALL 

EMPTY? 

PL-TRUE? 

¡ 

 

PL-TRUE? 

symbols 

KB 

KB 

α 

KB 

! ¡ 

model 

α model 

α 

©¨ 

symbols 

KB 

α 

true 

symbols 

¡'! £ 

¡'! ! 

[ ] 

© 

model 

false 

KB 

! ¡ 

α 

true 

© 

false 

true 

P ← FIRST 

TT-CHECK-ALL 

symbols 

 

TT-CHECK-ALL 

KB α 

rest ← REST 

KB α 

rest 

EXTEND 

symbols 

rest EXTEND P,true,model 

P,false,model 

O(2 n ) for n symbols; problem is co-NP-complete 


Logical equivalence 

Two sentences are logically equivalent iff true in same models: 

α ≡ β if and only if α |= β and β |= α 

(α ∧ β) ≡ (β ∧ α) commutativity of ∧ 

(α ∨ β) ≡ (β ∨ α) commutativity of ∨ 

((α ∧ β) ∧ γ) ≡ (α ∧ (β ∧ γ)) associativity of ∧ 

((α ∨ β) ∨ γ) ≡ (α ∨ (β ∨ γ)) associativity of ∨ 

¬(¬α) ≡ α double-negation elimination 

(α → β) ≡ (¬β → ¬α) contraposition 

(α → β) ≡ (¬α ∨ β) implication elimination 

(α ↔ β) ≡ ((α → β) ∧ (β → α)) biconditional elimination 

¬(α ∧ β) ≡ (¬α ∨ ¬β) de Morgan 

¬(α ∨ β) ≡ (¬α ∧ ¬β) de Morgan 

(α ∧ (β ∨ γ)) ≡ ((α ∧ β) ∨ (α ∧ γ)) distributivity of ∧ over ∨ 

(α ∨ (β ∧ γ)) ≡ ((α ∨ β) ∧ (α ∨ γ)) distributivity of ∨ over ∧ 


Validity and satisfiability 

A sentence is valid if it is true in all models, 

e.g., True, A ∨ ¬A, A → A, (A ∧ (A → B)) → B 

Validity is connected to inference via the Deduction Theorem: 

KB |= α if and only if (KB → α) is valid 

A sentence is satisfiable if it is true in some model 

e.g., A ∨ B, C 

A sentence is unsatisfiable if it is true in no models 

e.g., A ∧ ¬A 

Satisfiability is connected to inference via the following: 

KB |= α if and only if (KB ∧ ¬α) is unsatisfiable 

i.e., prove α by reductio ad absurdum 


Proof methods 

Proof methods divide into (roughly) two kinds: 

♦ Application of inference rules 

♦ Legitimate (sound) generation of new sentences from old 

♦ Proof = a sequence of inference rule applications Can use 

inference rules as operators in a standard search alg 

♦ Typically require translation of sentences into a normal 

form 

♦ Model checking 

♦ truth table enumeration (always exponential in n) 

♦ improved backtracking, e.g., 

Davis–Putnam–Logemann–Loveland 

♦ heuristic search in model space (sound but incomplete) 

e.g., min-conflicts-like hill-climbing algorithms 


Forward and backward chaining 

Horn Form (restricted) 

KB = conjunction of Horn clauses 

Horn clause = 

♦ proposition symbol; or 

♦ (conjunction of symbols) → symbol 

E.g., C ∧ (B → A) ∧ (C ∧ D → B) 

Modus Ponens (for Horn Form): complete for Horn KBs 

α 1 ,...,α n , 

α 1 ∧ · · · ∧ α n → β 

β 

Can be used with forward chaining or backward chaining. 

These algorithms are very natural and run in linear time 


Forward chaining 

Idea: fire any rule whose premises are satisfied in the KB, 

add its conclusion to the KB, until query is found 

L ∧ M → P 

B ∧ L → M 

A ∧ P → L 

A ∧ B → L 

A 

B 

P → Q 

L 

Q 

P 

A 

M 

B 


! ¡ 

¤ ¡ 

KB 

 

¨ 

¦ 

+ 

false 

+ 

 

! 

Knowledge Representation and Reasoning – 23 

 

* 

© 

$ & 

false 

Forward chaining algorithm 

true 

q 

 

© 

 

£ PL-FC-ENTAILS? 

 

%¨ 

¦ 

¨ 

count 

inferred 

agenda 

¥ 

¦ 

¦ 

 

§¨©¨ 

© 

¦ & ¦ 

 

¨ 

¦ %¨ 

© 

 

 

¨ 

¥ 

¦ 

¦ 

© 

© ¨ 

¦ 

% 

 

© 

$ 

¦ 

 

¥ 

, 

* 

 

& 

' £( ! agenda 

¨© 

p ← POP agenda 

inferred p 

inferred p ←true 

 

 

. ¡'! 

- 

¡ 

£ 

. 

- 

p 

 

% ©& 

¨ 

 

c 

' /©¨ ¦ 

¢¤ 

c 

count 

. 

- 

¨ 

¡ ! ' 

 

- 

£ 

c 

0 

. 

- 

count 

£ 

true 

0q 

¡ 

' ! ! 

c 

HEAD 

. 

¡ 

 

agenda 

 

c 

HEAD 

. 

- 

PUSH 

 

false 

 

! ¡ 

 

¦

Forward chaining example 

Q 

1 

L 

2 

P 

M 

2 

2 2 

A 

B 



Q 

1 

L 

2 

P 

M 

2 

1 1 

A 

B 



Q 

1 

L 

2 

P 

M 

1 

1 

0 

A 

B 



Q 

1 

L 

1 

P 

M 

0 

1 

0 

A 

B 



Q 

1 

L 

0 

P 

M 

0 

1 

0 

A 

B 



Q 

0 

L 

0 

P 

M 

0 

0 

0 

A 

B 



Q 

0 

L 

0 

P 

M 

0 

0 

0 

A 

B 



Q 

0 

L 

0 

P 

M 

0 

0 

0 

A 

B 


Proof of completeness 

FC derives every atomic sentence that is entailed by KB 

1. FC reaches a fixed point where no new atomic sentences are 

derived 

2. Consider the final state as a model m, assigning true/false to 

symbols 

3. Every clause in the original KB is true in m 

Proof: Suppose a clause a 1 ∧ ... ∧ a k → b is false in m 

Then a 1 ∧ ... ∧ a k is true in m and b is false in m 

Therefore the algorithm has not reached a fixed point! 

4. Hence m is a model of KB 

5. If KB |= q, q is true in every model of KB, including m 


Backward chaining 

Idea: work backwards from the query q: 

to prove q by BC, 

check if q is known already, or 

prove by BC all premises of some rule concluding q 

Avoid loops: check if new subgoal is already on the goal stack 

Avoid repeated work: check if new subgoal 

1) has already been proved true, or 

2) has already failed 


Backward chaining example 

Q 

P 

M 

L 

A 

B 



Q 

P 

M 

L 

A 

B 



Q 

P 

M 

L 

A 

B 



Q 

P 

M 

L 

A 

B 



Q 

P 

M 

L 

A 

B 



Q 

P 

M 

L 

A 

B 



Q 

P 

M 

L 

A 

B 



Q 

P 

M 

L 

A 

B 



Q 

P 

M 

L 

A 

B 



Q 

P 

M 

L 

A 

B 



Q 

P 

M 

L 

A 

B 


Forward vs. backward chaining 

FC is data-driven, cf. automatic, unconscious processing, 

e.g., object recognition, routine decisions 

May do lots of work that is irrelevant to the goal 

BC is goal-driven, appropriate for problem-solving, 

e.g., Where are my keys? How do I get into a PhD program? 

Complexity of BC can be much less than linear in size of KB 


Resolution 

Conjunctive Normal Form (CNF—universal) 

conjunction of disjunctions of literals 

} {{ } 

clauses 

E.g., (A ∨ ¬B) ∧ (B ∨ ¬C ∨ ¬D) 

Resolution inference rule (for CNF): complete for propositional 

logic 

l 1 ∨ · · · ∨ l k , 

m 1 ∨ · · · ∨ m n 

l 1 ∨ · · · ∨ l i−1 ∨ l i+1 ∨ · · · ∨ l k ∨ m 1 ∨ · · · ∨ m j−1 ∨ m j+1 ∨ · · · ∨ m n 

where l i and m j are complementary literals. E.g., 

P 1,3 ∨ P 2,2 , ¬P 2,2 

P 1,3 

Resolution is sound and complete for propositional logic 


Conversion to CNF 

B 1,1 ↔ (P 1,2 ∨ P 2,1 ) 

1. Eliminate ↔, replacing α ↔ β with (α → β) ∧ (β → α). 

(B 1,1 → (P 1,2 ∨ P 2,1 )) ∧ ((P 1,2 ∨ P 2,1 ) → B 1,1 ) 

2. Eliminate →, replacing α → β with ¬α ∨ β. 

(¬B 1,1 ∨ P 1,2 ∨ P 2,1 ) ∧ (¬(P 1,2 ∨ P 2,1 ) ∨ B 1,1 ) 

3. Move ¬ inwards using de Morgan’s rules and double-negation: 

(¬B 1,1 ∨ P 1,2 ∨ P 2,1 ) ∧ ((¬P 1,2 ∧ ¬P 2,1 ) ∨ B 1,1 ) 

4. Apply distributivity law (∨ over ∧) and flatten: 

(¬B 1,1 ∨ P 1,2 ∨ P 2,1 ) ∧ (¬P 1,2 ∨ B 1,1 ) ∧ (¬P 2,1 ∨ B 1,1 ) 


¤ ¡ 

( 4 

! 

£ 

 

% © 

Ci 

¢¤ 

' 

¡ 

 

¨ 

% 

 

Ci 

* 

 

 

1 23&¨ ¦ 

 

¡ 

' ! ! 

 

©¨© $ 

¡ 

 

Resolution algorithm 

Proof by contradiction, i.e., show KB ∧ ¬α unsatisfiable 

clauses ← 

new ← { } 

£ PL-RESOLUTION 

$ ¦ 

KB 

α 

! ¡ 

true 

© 

false 

KB ∧ ¬α 

C j 

£ clauses 

resolvents ← PL-RESOLVE 

resolvents 

new ←new ∪resolvents 

new ⊆ clauses 

clauses ←clauses ∪new 

£ 

©¨ 

¦ 

¨ 

% & 

' ! ! ¡ 

C j 

¦ 

false 

true 


Resolution example 

KB = (B 1,1 ↔ (P 1,2 ∨ P 2,1 )) ∧ ¬B 1,1 α = ¬P 1,2 

P 1,2 

P 1,2 

P 2,1 B 1,1 P 1,2 P 2,1 P 1,2 B 1,1 B 1,1 

B 1,1 B 1,1 

P 1,2 

B 1,1 

B 1,1 P 2,1 B 1,1 P1,2 P 2,1 P 2,1 

P 2,1 

P 1,2 P 2,1 P 1,2 


Local search algorithms 

♦ local search algorithms can be applied directly to PL-SAT 

♦ HILL-CLIMBING, or SIMULATED-ANNEALING 

♦ CSP 

♦ we need an appropriate evaluation function 

♦ goal is to satisfy every clause 

♦ just count the number of unsatisfied clauses 

♦ steps are defined by flipping the truth value of a variable 

♦ e.g. P = true P = false 

♦ search space usually contains many local minima (we need 

randomness) 


! ¡ 

¤ ¡ 

p 

max5 

clauses 

max5 

WALKSAT 

failure 

 

© 

flips 

 

 

¦ © 

£ WALKSAT 

¨¨ 

model ← 

i 

model 

clause ← 

¦¨ 

©¦ 

flips 

clauses 

* 

# ¡ 

 

¡ 

model 

¡ 

' ! ! 

¦ 

6 

£ 

$ ©clauses 

 

¨¦ 6 

 

 

¦¨ 

© 

p 

 

 

% 7£(£ ¡8 

7 ¢ :¦ © 

% & 9 

, £ ¡'4 

clause 

¦ 

¨ 

$ ¦¦¨ ©:¦ 

¦ 

6 

¨ 

; ¨¦ 

% ¦ 

¦ 

© 9 &¦:¦ 

♦ algorithm correct but incomplete 

♦ would be complete with max_flips = ∞ 

♦ but with unsatisfiable formulae it would not terminate 

♦ useful when we expect the formula to be satisfiable 

♦ not good for deduction 


Summary 

Logical agents apply inference to a knowledge base 

to derive new information and make decisions 

Basic concepts of logic: 

– syntax: formal structure of sentences 

– semantics: truth of sentences wrt models 

– entailment: necessary truth of one sentence given another 

– inference: deriving sentences from other sentences 

– soundess: derivations produce only entailed sentences 

– completeness: derivations can produce all entailed 

sentences 

Forward, backward chaining are linear-time, complete for Horn 

clauses 

Resolution is complete for propositional logic 

Propositional logic lacks expressive power

Knowledge Representation and Reasoning

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?