likes(tom,jerry).likes(mary,john).likes(tom,mouse).likes(tom,jerry).likes(jerry,cheeze).likes(mary,fruit).likes(john,book).likes(mary,book).likes(tom,john).
Queries?- likes(jerry,cheeze).yes?-likes(X,john).X=mary;X=tom;no
Prolog: Facts
Rules
X is brother of Y if
X is a male and
X and Y have the same parents.
In Prolog
is_brother_of(X,Y):-male(X),
parents(X, Father, Mother),
parents(Y, Father, Mother).
Backtracking
?- concen(X,Y).
X = us
Y = 91.6667 ;
X = china
Y = 315.5 ;
X = nz
Y = 16 ;
X = india
Y = 304.136 ;
No
population(us,275).population(china,1262).population(nz,4).Population(india,1000).land(us,3000).land(china,4000).land(nz,250).land(india,3288).concen(X,Y):-
population(X,P),land(X,L),Y is P*1000/L.
Cut: !
Eliminates choicesAlways succeeds but stops backtracking
a:-b,c,!,d.a:-e,f.
max(X,Y,Y) :- Y>X.max(X,Y,X). ?- max(1,2,X).X = 2 ;X = 1 ;No?-
max(X,Y,Y) :- Y>X, !. max(X,Y,X). ?- max(1,2,X).X = 2 ;No?-
[ ][a,b,c,d,e][5,8,3,9,7][the, boy, run]
A list can be split into a head and a tail: [H|T].
grades(john, [70,87,90,58]).?- grades(john, [H|T]). H = 70 T = [87,90,58]
member(X,[X| _ ]).member(X, [ _ | Y]) :- member(X, Y).
?- member(1, [3,4,5,8,1,9]).Yes
Recursion and Lists
Lists
put(Ch).get(Ch).get0(Ch).tab(X).nl.read(X).write(X).
I/O
tell(Filename) telling(X) told see(Filename) seeing(X) seen
File I/O
male(andrew).male(john). male(george). male(greg). male(adam). female(mary). female(jennifer). female(eve). parents(john,george,mary).parents(greg,adam,eve).parents(jennifer, adam,eve).parents(andrew, adam,eve).
?- male(X).X= andrew;X= john;X= george;X= greg;X= adam;
?- female(X).X= mary;X= jennifer;X= eve;
?- parents(X, adam, eve).X= greg;X= jennifer;X= andrew;
?- findall(X, male(X), List).List= [andrew, john, george, greg, adam]?- findall(X, female(X), List).List= [mary, jennifer, eve]?- findall(X, parents(X,adam,eve), List).List= [greg, jennifer, andrew]
findall(X,Term,List).
?- arg(2,likes(mary,john),X).
X = john
Yes
?- arg(2,likes(mary,X),john).
X = john
Yes
?- arg(3,parents(john,george,X),Val).
X = _G346
Val = _G346
Yes
?- arg(3,parents(john,george,victoria),Val).
Val = victoria
Yes
?- functor(likes(mary,john),Fun,Arity).
Fun = likes
Arity = 2
Yes
?- X=likes(mary,john),functor(X,Func,Arity).
X = likes(mary, john)
Func = likes
Arity = 2
Yes
?- functor(parents(adam,john,mary),F,N).
F = parents
N = 3
Yes
?- functor(X,likes,2).
X = likes(_G303, _G304)
Yes
functor(Term, Functor, Arity)
arg(N,Term,Value)
GamesRobot control Natural language processingExpert systemsImage processingParsing of context-free languagesCompiler writingVLSI Design Relational database applicationsOther AI applications
Applications
expr ::= term | term addop expr term ::= factor | factor multop term
factor ::= ‘x’ | ‘y’ | lbr expr rbr
addop ::= ‘+’ | ‘-’
multop ::= ‘*’ | ‘/’
lbr ::= ‘(’
rbr ::= ‘)’
A simple grammar for expressions
Applications
expr --> term. expr --> term, addop, expr. term --> factor. term --> factor, multop, term. factor -->[x]. factor -->[y]. factor --> lbr, expr, rbr. addop -->['+']. addop -->['-']. multop -->['*']. multop -->['/']. lbr -->['(']. rbr -->[')'].
?- phrase(expr, [y, '*', '(', x, '+', x, ')']) Yes ?- phrase(factor, [y]) Yes ?- phrase(rbr, [')']) Yes ?- phrase(factor, [y , '*', x]) No ?- phrase(expr, [y , '*', x]) .Yes?- phrase(factor, ['(',y , '*', x,')']). Yes?-
Applications
A Grammar for a very small fragment of English
sentence --> noun_phrase, verb_phrase.
noun_phrase --> determiner, noun. noun_phrase --> proper_noun.
determiner -->[the]. determiner -->[a].
proper_noun -->[pedro].
noun -->[man]. noun -->[apple].
verb_phrase --> verb, noun_phrase. verb_phrase --> verb.
verb -->[eats]. verb -->[sings].
Applications
InferenceEngine
Knowledge Base
Working Memory
ExplanationFacility
User
User Interface
Domain Expert(S)
Knowledge Engineer
Knowledge
FormalizedKnowledeg
Applications
Horn ClausesDefinition: A Horn clause is a clause with at most one positive literal.
A Horn clause therefore belongs to one of four categories:
A rule: 1 positive literal, at least 1 negative literal.
A rule has the form: ~P1 V ~P2 V ... V ~Pk V Q This is logically equivalent to P1^P2^ ... ^Pk => Q thus, an if-then implication with any number of conditions but one conclusion. Examples: ~man(X) V mortal(X) (All men are mortal); ~parent(X,Y) V ~ancestor(Y,Z) V ancestor(X,Z) If X is parent of Y and Y is ancestor of Z then X is ancestor of Z.
A fact or unit: 1 positive literal, 0 negative literals.
Examples:
man(socrates) parent(elizabeth,charles)",
A negated goal : 0 positive literals, at least 1 negative literal.
In virtually all implementations of Horn clause logic, the negated goal is the negation of the statement to be proved
The null clause: 0 positive and 0 negative literals. Appears only as the end of a proof.
Prolog
• is designed to represent Horn clauses,
• does backward chaining only,
• is a full Turing equivalent programming language, and can compute anything any other programming language can. Modern Prolog implementations have GUI facilities, fast compilers and (if your code is designed appropriately) very high run-time performance.
Program ::= Clause... Query | Query Clause ::= Predicate . | Predicate :- PredicateList . PredicateList ::= Predicate | PredicateList , Predicate Predicate ::= Atom | Atom( TermList ) TermList ::= Term | TermList , Term Term ::= Numeral | Atom | Variable | Structure Structure ::= Atom ( TermList ) Query ::= ?- PredicateList . Numeral ::= an integer or real number Atom ::= string of characters beginning with a lowercase letter or enclosed in apostrophes.
Variable ::= string of characters beginning with an uppercase letter or underscore
Terminals = {Numeral, Atom, Variable, :-, ?-, comma, period, left and right parentheses }
Prolog Grammer
Comparing Prolog and Haskell Syntax
In Prolog:
• functions are not evaluated - they are like data constructors
• the language is untyped
• variables begin with upper-case letters or an underscore
• predicate and function symbols begin with a lower-case letter
• the list constructor functor is [ | ], not :
Haskell Prolog
Kinds of objects functions relations
Arity (number of parameters) fixed; if fewer arguments, then return a function variable; indicated with /n ending
Variables start with lower case start with upper case
Values start with upper case start with lower case
Clause parameters separated by spaces separated by commas
Head-body separator = (after possible alternatives) :- (when body is needed)
Alternatives preceded by | (or can use if-then-else) separated by semi-colons
Clause ending off-side rule (or semi-colon) full stop
List constructor : (inside parens when potentially ambiguous) | (always inside brackets)