Artificial Intelligence

1
Artificial Intelligence

• Prolog
• for

2
SWI-Prolog

• SWI-Prolog is a good, standard Prolog for Windows
  and Linux
• It's licensed under GPL, therefore free
• Downloadable from http//www.swi-prolog.org/

3
What is Prolog?

• A logic programming language
• Prolog stands for Programming in Logic (or
  Programmation en Logique in French)
• Designed in 1972 by Alain Colmerauer and Robert
  Kowalski (much later than Lisp)
• Used in AI programming, expert systems, and
  computational linguistics

4
Logic Programming

• Creates logical models that describe the world in
  which a problem exists
• Uses first-order logic (but can also be used with
  propositional logic)
• A subset of declarative programming
• Creates a set of conditions that describe a
  solution space
• Two phases declaration and interpretation

5
Syllogisms

• Prolog is all about programming in logic.
• Aristotle described syllogisms 2300 years ago
• Sample syllogism
• Socrates is a man.
• All men are mortal.
• Therefore, Socrates is mortal.
• This is logic. Can Prolog do it?

6
Forward and backward reasoning

• A syllogism gives two premises, then asks, "What
  can we conclude?"
• This is forward reasoning -- from premises to
  conclusions
• it's inefficient when you have lots of premises
• Instead, you ask Prolog specific questions
• Prolog uses backward reasoning -- from
  (potential) conclusions to facts

7
Syllogisms in Prolog
Syllogism Socrates is a man. All men are
mortal. Is Socrates mortal?
Prolog
man(socrates).
mortal(X) - man(X).
?- mortal(socrates).
8
Facts, rules, and queries

• Fact Socrates is a man.
• man(socrates).
• Rule All men are mortal.
• mortal(X) - man(X).
• Query Is Socrates mortal?
• mortal(socrates).
• Queries have the same form as facts

9
Running Prolog I

• Create your "database" (program) in any editor
• Save it as text only, with a .pl extension
• Here's the complete program

man(socrates).mortal(X) - man(X).
10
Running Prolog II

• Prolog is completely interactive. Begin by
• Double-clicking on your .pl file, or
• Double-clicking on the Prolog application and
  consulting your file at the ?- prompt
• ?- consult('C\\My Programs\\adv.pl').
• On a mac, opening a terminal window and typing
  swipl
• Then, ask your question at the prompt
• ?- mortal(socrates).
• Prolog responds
• Yes

11
Prolog is a theorem prover

• Prolog's "Yes" or true means "I can prove it"
  --Prolog's "No" or false means "I can't prove
  it"
• ?- mortal(plato).False.
• This is the closed world assumption the Prolog
  program knows everything it needs to know
• Prolog supplies values for variables when it can
• ?- mortal(X).X socrates

12
Syntax I Structures

• A structure consists of a name and zero or more
  arguments.
• Omit the parentheses if there are no arguments
• Example structures
• sunshine
• man(socrates)
• path(garden, south, sundial)

13
Syntax II Base Clauses

• A base clause is just a structure that represents
  a simple fact.
• Example base clauses
• debug_on.
• loves(john, mary).
• loves(mary, bill).

14
Syntax III Nonbase Clauses

• A nonbase clause is a structure, a turnstile
  (meaning IF), and a list of structures.
• Example nonbase clauses
• mortal(X) - man(X).
• mortal(X) - woman(X)
• happy(X) - healthy(X), wealthy(X), wise(X).
• The comma between structures means AND

15
Syntax IV Predicates

• A predicate is a collection of clauses with the
  same functor (name) and arity (number of
  arguments).
• loves(john, mary). loves(mary, bill).
  loves(chuck, X) - female(X), rich(X).

16
Syntax V Programs

• A program is a collection of predicates.
• Predicates can be in any order.
• Clauses within a predicate are used in the order
  in which they occur.

17
Syntax VI Variables and atoms

• Variables begin with a capital letter X,
  Socrates, _result
• Atoms do not begin with a capital letter x,
  socrates
• Atoms containing special characters, or beginning
  with a capital letter, must be enclosed in single
  quotes
• 'C\\My Documents\\examples.pl'
• Variables consisting of, or beginning with, _ are
  called anonymous variables. They are used when
  we dont care what their value is.

18
Syntax VII Strings are atoms

• In a quoted atom, a single quote must be doubled
  or backslashed
• 'Can''t, or won\'t?'
• Backslashes in file names must also be doubled
• 'C\\My Documents\\examples.pl'

19
Common problems

• Capitalization is extremely important!
• No space is allowed between a functor and its
  argument list man(socrates), not
  man(socrates).
• Double quotes indicate a list of ASCII character
  values, not a string
• Dont forget the period! (But you can put it on
  the next line.)

20
Backtracking

• loves(femi, X) - female(X), rich(X).
• female(ajoke).
• female(asake).
• rich(asake).
• Suppose we ask loves(femi, X).
• female(X) female(ajoke), X ajoke.
• rich(ajoke) fails.
• female(X) female(asake), X asake.
• rich(asake) succeeds.

21
Readings

• loves(femi, X) - female(X), rich(X).
• Declarative reading Femi loves X if X is female
  and rich.
• Approximate procedural reading To find an X that
  Femi loves, first find a female X, then check
  that X is rich.
• Declarative readings are almost always preferred.

22
Monotonic logic

• Standard logic is monotonic once you prove
  something is true, it is true forever
• Logic isn't a good fit to reality
• If the wallet is in the purse, and the purse in
  is the car, we can conclude that the wallet is in
  the car
• But what if we take the purse out of the car?

23
Nonmonotonic logic

• Prolog uses nonmonotonic logic
• Facts and rules can be changed at any time
• such facts and rules are said to be dynamic
• assert(...) adds a fact or rule
• retract(...) removes a fact or rule
• assert and retract are said to be extralogical
  predicates

24
Limitations of backtracking

• In Prolog, backtracking over something generally
  undoes it
• Output can't be undone by backtracking
• Neither can assert and retract be undone by
  backtracking
• Perform any necessary testing before you use
  write, nl, assert, or retract

25
The Notion of Unification

• Unification is when two things become one
• Unification is kind of like assignment
• Unification is kind of like equality in algebra
• Unification is mostly like pattern matching
• Example
• loves(ade, X) can unify with loves(ade, asake)
• and in the process, X gets unified with asake

26
Unification I

• Any value can be unified with itself.
• weather(sunny) weather(sunny)
• A variable can be unified with another variable.
• X Y
• A variable can be unified with (instantiated
  to) any Prolog value.
• Topic weather(sunny)

27
Unification

• Once a variable has been unified with a value, it
  continues to have that value for the rest of the
  clause, and can be used that way
• If we have
• female(X) female(jane)
• then
• write(X) will write jane.

28
Writing Prolog Programs

• Suppose the database contains loves(femi, X)
  - female(X), rich(X). female(jane).and we
  ask who Femi loves, ?- loves(chuck, Woman).
• female(X) finds a value for X , say, abike
• rich(X) then tests whether Abike is rich

29
Clauses as Cases

• A predicate consists of multiple clauses, each of
  which represents a case

grandson(X,Y) - son(X,Z), son(Z,Y). grandson(X,Y)
- son(X,Z), daughter(Z,Y).
abs(X, Y) - X lt 0, Y is -X. abs(X, X) - X gt 0.
30
Ordering

• Clauses are always tried in order
• buy(X) - good(X).buy(X) - cheap(X).cheap(Jav
  a 2 Complete).good(Thinking in Java).
• What will buy(X) choose first?

31
Ordering II

• Try to handle more specific cases (those having
  more variables instantiated) first.

dislikes(john, bill). dislikes(john, X) -
rich(X). dislikes(X, Y) - loves(X, Z), loves(Z,
Y).
32
Basic and derived clauses

• You can often choose which facts you want to be
  "basic" and which derived

son(isaac, steven).child(X, Y) - son(X, Y).
male(isaac).child(isaac, steven).son(X, Y) -
male(X), child(X, Y).
33
Arithmetic

• The equals sign, , means unify.
• 22 does not unify with 4.
• To force arithmetic to be performed, use is
  X is 2 2, X 4.
• Comparisons \ gt gt lt lt also
  force their operands to be evaluated.
• - / mod, when evaluated, have their usual
  meanings.

34
Step 1 Declaration

• Creating a knowledge base (KB) of sentences
  describing the world
• Declaring facts
• fun(ai). (AI is fun!)
• likes(mark,bacon). (Mark likes bacon)
• Defining rules
• heartbroken(X) - loves(X,Y), not(loves(Y,X)). (X
  is heartbroken if X loves Y and Y does not love
  X sniff)
• Sentences end with a period

35
A simple Knowledge Base

• orbits(mercury, sun).
• orbits(venus, sun).
• orbits(earth, sun).
• orbits(mars, sun).
• orbits(moon, earth).
• orbits(phobos, mars).
• orbits(deimos, mars).
• planet(P) - orbits(P,sun).
• satellite(S) - orbits(S,P), planet(P).

36
Step 2 Interpretation

• Deriving new sentences from the sentences in the
  KB by making queries
• Uses a Prolog interpreter
• SWI-Prolog, GNU Prolog, etc.
• Knowledge bases must first be loaded/consulted
  using consult(filename.pl).

37
Some simple queries

• ?- consult(solar.pl).
• Is the moon a satellite?
• ?- satellite(moon).
• Is the sun a planet?
• ?- planet(sun).
• Is Uranus a planet?
• ?- planet(uranus).
• What are the planets?
• ?- planet(Planet).
• What objects orbit Mars?
• ?- orbits(X, mars).
• Is the moon made of cheese?
• ?- made_of_cheese(moon).

38
Another KB example

• parents(william, diana, charles).
• parents(henry, diana, charles).
• parents(charles, elizabeth, philip).
• parents(diana, frances, edward).
• parents(anne, elizabeth, philip).
• parents(andrew, elizabeth, philip).
• parents(edwardW, elizabeth, philip).
• married(diana, charles).
• married(elizabeth, philip).
• married(frances, edward).
• married(anne, mark).
• parent(C,M) - parents(C,M,D).
• parent(C,D) - parents(C,M,D).
• sibling(X,Y) - parents(X,M,D), parents(Y,M,D).
  Whats wrong with this?
• aORuDirect(C, A) - parent(C,P), sibling(P,A).
• aORuMarr(C, A) - aORuDirect(C,X),
  married(X,A).
• aORuMarr(C, A) - aORuDirect(C,X),
  married(A,X).

39
Predicates

• Used to express facts or statements about objects
  and their relationships
• Examples likes heartbroken orbits
• Have arguments
• teaches(jpv,cs171). (2 arguments)
• Names/atoms are alphanumeric, can contain
  underscores, begin with a lowercase letter
• Meanings of predicates, arguments, and order of
  arguments are arbitrary (but should be
  descriptive and consistent!)

40
Variables

• Can be used to stand for any object
• Are instantiated during matching
• Examples Planet X
• Scope is statement-wide
• Usually used in rules, but can also be used in
  facts
• goes_to_heaven(Dog) - dog(Dog). (All dogs go to
  heaven.)
• must_perish(Thing). (All things must perish.)
• Variable names are alphanumeric, can contain
  underscores, must begin with an uppercase letter
• Use the underscore to indicate an anonymous
  variable
• female(X) - mother(X,_). (All mothers are
  female, regardless of who the child is.)

41
Queries

• Describe problems to be solved
• Consist of goals to be satisfied
• Example father(X) - male(X), parent(X,_).
• Goals are male(X) and parent (X,_).
• Goals are checked against facts in the KB
• Rules are satisfied if all the goals in the if
  part (in the body, separated by commas) are
  satisfied
• Variables can take on any value
• Press semi-colon to look for further matches
• Uses backtracking to satisfy goals in all
  possible ways (brute-forcing it)

42
Prolog and FOL

• Rules are usually in the form of Horn clauses
• - is ? reversed
• Backtracking in Prolog is known in FOL terms as
  backward chaining
• Begins with a goal (the query)
• Recursively builds a set of substitutions that
  satisfy the goals necessary to conclude the goal
• All variables in Prolog are assumed to be
  universally quantified (though skolemization can
  still be done)