1. Automated reasoning and theorem proving
Introduction: logic in AI
Automated reasoning:
Resolution
Unification
Normalization

2. Introduction: Syntax Model semantics Logical entailment
Motivating example
Automated reasoning
Logic:
Syntax
Model semantics
Logical entailment

3. Why Logic is needed in AI?
Solutions to many problems might require logical analysis
In order to automate logical reasoning, we need a formal language
So, we need a language that can represent a problem and a method to search the problem 3

4. Logic and AI: The Basics
Representation => predicate calculus
Search => resolution principle 4

5. Things We Will Do With Logic
A two step process
1. See if there is a solution
2. Find the solution 5

6. “Marcia is wherever John is” and “John is at school”
Example Problems
John and Marcia
given
“Marcia is wherever John is” and “John is at school”
we will find where Marcia is! 6

7. Resolution Proofs - Example
Given:
( x) {AT(John, x) AT(Marcia, x)}
AT(John, school)
Prove:
( x) AT(Marcia, x)
i.e., “where is Marcia?” 7

8. Resolution Proof - Finally!
~AT(John, x) AT(Marcia, x)
~AT(Marcia,x)
~AT(John, x)
AT(John, school)
The negation is false; Marcia must be somewhere. But, where!
nil 8

9. Modified Proof Tree ~AT(John, x) AT(Marcia, x)
~AT(Marcia,x)  AT(Marcia,x)
~AT(John, x)  AT(Marcia,x)
AT(John, school)
AT(Marcia, school) 9

10. Why Logical is good Representation?
The principles of correct reasoning
i.e. sound and complete inference rules and semantics of predicate calculus emphasizes truth preserving operations on well formed expression.

11. Problem Solving Requires sufficient knowledge
Makes correct inference from this knowledge
Must do inference sufficiently

12. Building Knowledge
Select the significant objects and relation in the domain
Map these into a formal language

13. Four Categories of Knowledge Representation
Logical representation schemes
Procedural representation schemes
Network representation schemes
Structured representation schemes

14. Four Categories of Knowledge Representation

15. H/W Assignment for Assignment group 2
G2: What does “sound and complete inference rules” mean?
NAiST-LAB

16. Introduction: Syntax Model semantics Logical entailment
Motivating example
Automated reasoning
Logic:
Syntax
Model semantics
Logical entailment

17. The AI dream in the 60’s:
Logic allows to express almost everything ‘formally’.
Logic also allows to prove “theorems” based on the information given.
Can we exploit this to build automated reasoning systems ??

18. Underlying premises:
Logic is the ‘assembly language’ of knowledge and is closely related to natural language.
In logic almost all kinds of knowledge can be
represented formally and unambiguously.
Since computers are supposed to process the knowledge, it should be expressed formally and unambiguously.
Logical deduction allows us to derive systematically new knowledge from the existing one.
Automating deduction ??

19. Example: The following knowledge is given :
1. Marcus was a man.
2. Marcus was a Pompeian.
3. All Pompeians were Romans.
4. Caesar was a ruler.
5. All Romans were either loyal to Caesar or hated him.
6. Everyone is loyal to someone.
7. People only try to assassinate rulers to whom they are not loyal.
8. Marcus tried to assassinate Caesar.
Can we automatically answer the following questions?
Was Marcus loyal to Caesar?
Did Marcus hate Caesar?

20. Question
Is there any ambiguity of given statement?
Is there any problem about predicate selection?

21. Conversion to the First Order Logic:
Representation of facts:
1. Marcus was a man.
man(Marcus)
2. Marcus was a Pompeian.
Pompeian(Marcus)
4. Caesar was a ruler.
ruler(Caesar)
8. Marcus tried to assassinate Caesar.
try_assassinate(Marcus, Caesar)

22. Conversion to the First Order Logic (2):
General representation (representation of rules):
3. All Pompeians were Romans.
x Pompeian(x)  Roman(x)
5. All Romans were either loyal to Caesar or hated him.
( ) 
~(loyal_to(x,Caesar)  hates(x,Caesar))
XOR
x Roman(x)  loyal_to(x,Caesar)  hates(x,Caesar)
6. Everyone is loyal to someone.
x y loyal_to(x,y)
7. People only try to assassinate rulers to whom they are not loyal.
xy person(x)  ruler(y)  try_assassinate(x,y) 
~loyal_to(x,y)

23. The “theorem” ? Was Marcus loyal to Caesar?
Try, for example, to prove that he was not :
~loyal_to(Marcus,Caesar)
Did Marcus hate Caesar?
Prove that he did:
hates(Marcus,Caesar)

24. A proof using backward-reasoning problem-reduction:
~loyal_to(Marcus,Caesar)
person(Marcus)
ruler(Cesar)
AND
try_assassinate(Marcus, Caesar)
xy person(x)  ruler(y) 
try_assassinate(x,y)  ~loyal_to(x,y)
+ substitution: x/Marcus
y/Caesar
person(Marcus)  ruler(Caesar)  try_assassi-nate(Marcus,Caesar)  ~loyal_to(Marcus,Caesar)
+ Modus ponens
Extra rule:
x man(x)
 person(x)
man(Marcus)
Done! 8.
Done! 4.
Done! 1.

25. Way of Representing Class Membership
1. man(Marcus)
2. Pompeian(Marcus)
3. x: Pompeian(x) Roman(x)
4. ruler(Caesar)
5. x: Roman(x) loyalto(x,Caesar) hate(x,Caesar)

26. Way of Representing Class Membership
1. instance(Marcus,man)
2. instance(Marcus,Pompeian)
3. x: instance(x, Pompeian) instance(x, Roman)
4. instance(Caesar,ruler)
5. x: instance(x, Roman) loyalto(x,Caesar) hate(x,Caesar)
CS 6833/CS 680
NAiST-LAB
NAiST-LAB

27. Way of Representing Class Membership
1. instance(Marcus,man)
2. instance(Marcus,Pompeian)
3. isa(Pompeian,Roman)
4. instance(Caesar,ruler)
5. x: instance(x, Roman) loyalto(x,Caesar) hate(x,Caesar)
6. x: y: z: instance(x, y) isa(y,z) instance(x, z)
CS 6833/CS 680
NAiST-LAB
NAiST-LAB

28. Problems: 1) knowledge representation:
Natural language is imprecise / ambiguous
see “People only try …”
Obvious information is easily forgotten.
see man <-> person
Some information is more difficult to represent in logic.
Vb.: “perhaps …”, “possibly…”, “probably…”, “the chance of … is 45%”,
Logic is inconvenient from a software engineering perspective.
too ‘fine-grained’ (like an assembly language)

29. Problems: 2) Problem solving:
All trade-offs that we had with search methods based on states space representation:
backward/forward, tree/graph, OR-tree/AND- OR, control aspects, ...
What deduction rules are needed in general?
Example: prove “ hates(Marcus,Caesar) “
x Roman(x)  loyal_to(x,Caesar)  hates(x,Caesar)
The only applicable rule is:
Modus ponens???
How do we handle x and y ?

30. Problems: 2) Problem solving (2):
How to compute substitutions in the general case ?
xy person(x)  ruler(y) 
try_assassinate(x,y)  ~loyal_to(x,y)
+ substitution: x/Marcus
y/Caesar
In general:
more complex
Which theorem do we try to prove?
Ex.: loyal_to(Marcus,Caesar) or ~loyal_to(Marcus,Caesar)
How to handle equality of objects?
Problem: combinatorial explosion of the derived equalities (reflexivity, symmetry, transitivity, …)
How to guarantee correctness/completeness?

31. The formal model semantics of Logic
The meaning of “Logical entailment”

32. Propositional logic

33. Basic concepts: In propositional logic:    ~   connectors ( )
The alphabet:    ~  
connectors
weather_is_rainy
joe_has_an_umbrella
Atomic propositions ( )
punctuation
joe_has_an_umbrella  weather_is_rainy
~ weather_is_rainy
Well-formed formulas:
Notation: p, q, r : atomic propositions.

34. Semantics (meaning) 1. Intuitive (natural) semantics:
In general (for all knowledge representation formalisms):
2 approaches to define semantics:
1. Intuitive (natural) semantics:
Describe the meaning by means of a natural language
Exs. (propositional logic):
 : “implies”
~ : “not true that”
 : “or”
p  q : “p if and only if q”
~ p  r : “not p and r”
every symbol and every well-formed formula gets meaning through the associated natural language

35. Semantics (2) 2. Transformational semantics: Logically entailed p
Describe the meaning by converting to an associated “mathematical” object
In propositional logic :
the set of all propositional symbols that are logically entailed by the given formulas:
Logically entailed p
p  ~ q p
q  r q r p q p r q r p q r

36. But how to define “logical entailment” ?
NOT as:
Everything that we can derive from the formulas
SINCE:
At this moment we do not know yet:
“what is a complete set of the derivation rules”
This is exactly what Automated Reasoning aims to find out!
BUT by:
Interpretations
Models

37. Interpretation:
= a function that assigns a truth value to each “atomic” formula
Also provides (indirectly) truth values for each well-formed formula p q ~p
p  q
p  q
p  q
p  q T F T T F F T F T T F F T F
Truth table

38. Model
Given a set of formulas S: a model is an interpretation that makes all formulas in S true
p  ~ q p
q  r S
Example: p q r T F
Model:
p  ~q
q  r T p

39. Logical entailment:
Given a set of formulas S and a formula F: F is logically entailed by S ( S |= F ), if all models of S also make F true.
p  ~ q p
q  r S
Example: F:
r  p p q r T F
(the only) Model:
r  p T

40. Predicate logic

41. Well-formed formulas:
The alphabet: 
constants
Yvonne
Yvette
variables x y z  ~  
connectors 
function symbols g f h 
quantifiers 
predicate symbols q p ( )
punctuation ,
Terms:
Yvonne y
f(x, g(Yvette))
Well-formed formulas:
p(Yvonne)
p(x)  ~q(x)
z p(z)
x y p(x)  q(y)  p(f(Yvonne, Yvette)

42. Formally:
An alphabet consists of variables, constants, function symbols, predicate symbols (all user-defined) and of connectors, punctuations en quantifiers.
Terms are either:
variables,
constants,
function symbols provided with as many terms as arguments, as the function symbol expects.
Well-formed formulas are constructed from predicate symbols, provided with terms as arguments, and from connectors, quantifiers and punctuation – according to the rules of the connectors.

43. Example: { {0}, {x,y}, {s}, {odd,even}, Con, Pun, Quan}
Alphabet:
{ {0}, {x,y}, {s}, {odd,even}, Con, Pun, Quan}
Terms:
{ 0, s(0), s(s(0)), s(s(s(0))), …
x, s(x), s(s(x)), s(s(s(x))), …
y, s(y), s(s(y)), s(s(s(y))), … }
Well-formed formulas:
odd(0), even(s(0)), …
odd(x), odd(s(y)), …
odd(x)  even(s(s(x))), …
x ( odd(x)  even(s(x)) ), …
odd(y)  x (even( s(x))), ...

44. Interpretation: A D = N Example: = a set D (the domain), and
a function that maps constants to D, and
a function that maps function symbols to functions: D -> D, and
a function that maps predicate symbols to predicates: D -> Booleans. A s x y
odd
Example:
Booleans
true
false
“even”
D = N 1 2 3

45. Assigning truth values:
1. To ground atomic formulas:
form: p(f(a), g(a,b))
Example:
I( odd( s ( s( 0 ) ) ) ) ) = ?
= I (odd) ( I(s) ( I(s) ( I(0) ) ) )
= “even” ( succ ( succ ( ) ) )
= “even” ( succ ( 1 ) )
= “even” ( 2 )
= true

46. Assigning truth values (2):
2. For closed well-formed formulas:
(= no non-quantified variables)
x F(x) is true if:
for all d D: I( F(d) ) = true
 x F(x) is true if:
there exists d D such that: I( F(d) ) = true
further: use the truth tables.
I(x odd( s ( x ) )  odd(x) ) = ?
= true if for all d in N:
I (odd( s (d) )  odd(d) ) = true
Example:
= “even” ( succ(d) )  “even” (d)
Assume: d = 0, then:
= false  true
Truth tables: false !

47. Semantics / Logical entailment:
Exactly as in propositional logic !
Given a set of formulas S: a model is an interpretation that makes all formulas in S true.
Given a set of formulas S and a formula F: F is logically entailed by S ( S |= F ), if all models of S also make F true.
Additional: inconsistency:
Given a set of formulas S: S is inconsistent if S has no models.
Example: S = { p(a), ~p(a)}

48. Marcus example: A x y V Marcus Caesar C F =  ruler person man P
Boolean
true
false
“was_ruler”
try_assassinate
Pompeian
Roman
“was_pompeian”
Boolean
true
false
hates
loyal_to
“Intended” interpretation:
D = world of ~40 VC.
“Marcus”
“Caesar”
Is a model IF ALL FORMULAS ARE CORRECT

49. Marcus example: A x y V Marcus Caesar C F =  man person ruler Roman
Pompeian
hates
loyal_to
try_assassinate P N 4 3
I(man) = I(person)= I(Roman)
= “natural number”
I(try_assassinate) = “ > ”
I(Pompeian) = “even number”
I(loyal_to) = “divides”
I(ruler) = “prime number”
I(hates) = “doesn’t divide”

50. Model ?? YES ! 1. Marcus was a man. 4 is a natural number
2. Marcus was Pompeian.
4 is an even number
4. Caesar was a ruler.
3 is a prime number
8. Marcus tried to assassinate Caesar. 4 > 3
3. All Pompeians were Romans.
Even numbers are naturals.
5. All Romans were either loyal to Caesar or hated him.
A number either divides 3 or doesn’t divide 3.
6. Everybody is loyal to somebody.
Each number is a divisor of some number.
7. People try to assassinate only those rulers to whom they are not loyal.
A natural number that is greater than a prime number doesn’t divide the prime number.

51. “Logic is all form, no content”
person(x)  mortal(x)
person(Socrates)
mortal(Socrates)
January(x)  cold(x)
January(21/1/01)
cold(21/1/01)
P(x)  Q(x)
P(A)
Q(A)
Only the underlying structure of a set of logical formulas is
important for the conclusions! (up to the names isomorphism)
But from the knowledge representation perspective
also the ‘contents’ is important.

52. Relation with respect to other courses:

53. Logic as a foundation for AI
A much deeper and more formal study of Logic for Knowledge Representation and Reasoning !

54. Programming Languages and Programming Methodologies
Logic-based programming languages
(Prolog/CLP)

55. Selected Topics in Logic Programming
Formal studies of semantics and formal methods (analysis, termination) of logic-based programming languages
(also beyond Prolog)

56. Fundamentals of Artificial Intelligence
First Order predicate Logic
Formal semantics
and analysis
Logic-based
programming languages
(Prolog/CLP)
Techniques for
automated reasoning
Problem-representation
in logic
Mostly in the exercises

57. Methodology for knowledge representation?
Very complicated. Not many simple guidelines.
Basis:
Choose an alphabet that allows us to represent all objects and all relations from the problem domain:
What are the basic objects, functions and relations in your problem domain ?
Ontology: represent only the RELEVANT information
Choose constants, function and predicate symbols to represent them.
Translate every sentence in a natural language in one or more corresponding logical formulas.

58. Summary

59. Syntax of Predicate Calculus
Universe - The domain of discourse, D, corresponding to the set of objects represented by logical variables.
Terms - Variables are terms and f(T) is a term, where f is a function and T is a sequence of n terms.
Atomic formula - P(T) is an atomic formula, where P is a predicate and T is a sequence of n terms.
Literals - Atomic formulas and negated atomic formulas.

60. Syntax of Predicate Calculus
Well-formed formulas (wffs) - Literals are wffs and wffs connected or quantified by logic symbols are also wffs.
Sentence - A wff in which all variables are within the scope of corresponding quantifiers.
Clause - A wff consisting of a literal or a disjunction of literals (literals connected by ORs).

61. Syntax of Predicate Calculus
A system in first-order predicate calculus consists of
a set of sentences S which represent a physical system.
The system builder has complete freedom in selecting predicates and building expressions to represent the problem s/he is trying to solve.

62. Proposition โธมัส อัลวา เอดิสัน
อัจฉริยะนั้น 99% เกิดจากความพากเพียร 1% ขึ้นอยู่ กับมันสมอง
ความสำเร็จ 10% เกิดจากแรงบันดาลใจ 90% มา จากความทุ่มเทด้วยหยาดเหงื่อ