Prolog by Example

30 September 2005 Foundations of Logic and Constraint Programming 1

Prolog by Example

­ A­Prolog­program­is­composed­by­facts­and­rules,­which­are­special­cases­of­definite­(or­Horn)­clauses,­i.e.­clauses­with­at­most­one­positive­literal­(the­head­of­the­clause).­

­ This­predicate­may­have­several­alternative­definitions­(both­facts­and­rules).­

­ A­ fact­ has­ no­ negative­ literals­ and­ expresses­ positive­ knowledge­ that­ is­ definite­ (no­disjunctions).­Example:­The­knowledge­that­John­is­a­child­of­Ann­and­Alex,­and­that­Ann­is­a­child­of­Bob,­is­expressed­by­two­facts,­namely­

child_of(john, ann).child_of(john, alex).child_of(ann, bob).

­ A­ rule­ has­ one­ or­ more­ negative­ literals­ (the­ body­ of­ the­ clause),­ and­ is­ used­ to­ infer­predicates­from­other­predicates.­Example:­A­grand­child­is­the­child­of­the­child,­i.e.

grand_child_of(X,Y) :- child_of (X,Z), child_of(Z,Y).

­ The­name­rule­is­due­to­the­fact­that­a­definite­clause,­H B1 B2 ... Bk­can­be­written­ in­ the­ form­of­an­ if­expression­H ← B1 B2 ... Bk, which­ i­ the­syntax­adopted­in­Prolog.

30 September 2005 Foundations of Logic and Constraint Programming 2

Prolog by Example

child_of(john, ann).child_of(john, alex).child_of(ann,bob).grand_child_of(X,Y) :- child_of(X,Z), child_of(Z,Y).

­ All­variables­(starting­with­capital­ letters)­are­universally­quantified.­The­rule­can­be­read­“For­any­X,­Y­and­Z,­if­X­is­a­child­of­Z­and­Z­is­a­child­of­Y,­then­X­is­a­grand­child­of­Y”.­

­ Rules­ can­ be­ rephrased­ such­ that­ variables­ appearing­ only­ in­ the­ body­ of­ a­ rule­ are­existencially­quantfied.­In­this­case,­“X­is­a­grand­child­of­Y,­if­there­is­some­Z,­of­which­X­is­a­child,­and­is­a­child­of­Y”.

­ A­program­may­be­regarded­as­a­knowledge­base,­combining­explicit­knowledge­of­facts­as­ well­ as­ implicit­ knowledge­ by­ means­ of­ rules.­ This­ knowledge­ may­ be­ queried­ by­negative­rules­(no­head).­Notice­that­due­to­the­negation,­variables­are­read­existenctially.

­ Examples:­

Are­there­any­parents­of­Alex­(any­X­of­which­John­is­a­parent)­?

?- child_of(X,alex).

Are­there­any­A­and­B­such­that­A­is­a­grand­parent­of­B­(or­B­is­a­grand­child­of­A)­?

?- grand_child_of(A,B).

30 September 2005 Foundations of Logic and Constraint Programming 3

Prolog by Example

child_of(john, ann).child_of(john, alex).child_of(bob, john).

grand_child_of(X,Y) :- child_of(X,Z), child_of(Z,Y).

­ A­ Prolog­ engine­ is­ able­ to­ answer­ the­ queries­ (by­ implementing­ resolution­ on­ Horn­clauses),­finding­all­solutions­and­presenting­them­one­at­a­time.

?- child_of(X, alex).

X = john; no.

?- grand_child_of(A,B).

A = bob, B = ann ;

A = bob, B = alex; no.

­ In­ practice,­ to­ program­ in­ Prolog,­ it­ is­ important­ to­ understand­ the­ options­ that­ Prolog­engines­assume,­in­applying­resolution.

­ ­ Informally,­ to­search­ for­all­ solutions,­Prolog­uses­ the­query­as­an­ initial­ resolvent,­and­organises­all­the­other­resolvents­in­an­execution­tree.­

­ Solutions,­if­any,­are­the­success­leafs­of­the­tree­(the­other­leafs­are­failed).

30 September 2005 Foundations of Logic and Constraint Programming 4

child_of(john, ann).child_of(john, alex).child_of(bob, john).

grand_child_of(X,Y) :- child_of(X,Z), child_of(Z,Y).

­ For­example,­query­?- grand_child_of(A,B),­expands­into­the­execution­tree­

­ Notice­that­ Instances­of­ the­answers­are­obtained­by­composing­the­substitutions­ in­a­path­ to­a­successful­leaf

The­tree­is­searched­depth-first,­left-to-right.

Prolog by Example

grand_child_of(A,B)

child_of(A,Z), child_of(Z,B)

child_of(ann,B) child_of(alex,B) child_of(john,B)

X/A, Y/B

A/john Z/alex

A/john Z/ann

A/bob Z/john

B/ann B/alex

30 September 2005 Foundations of Logic and Constraint Programming 5

­ Let­us­assume­some­elements­from­the­larger­family­tree.

­ The­basic­relationship­that­must­be­recorded­is­parent-child­(the­one­kept­in­the­ID­cards­and­databases),­modeled­by­the­binary­predicate­parent_of/2.

Prolog by Example: Family relationships

child_of(john,doug).child_of(john,carol).child_of(mary,carol).child_of(tess,mary).child_of(fred,tess).child_of(peter,john).child_of(bob,john).

child_of(alex,john).child_of(peter,ann).child_of(bob,ann).child_of(alex,ann).child_of(alice, peter).child_of(alice,vicky).

john

doug carol

peter bob alex

ann

alice

vicky

mary

tess

fred

30 September 2005 Foundations of Logic and Constraint Programming 6

­ Other­useful­ information­can­be­ introduced,­such­as­sex­ (although­usually­ implicit­ in­ the­name­–­but­still­ this­ info­ is­explicit­ in­ ID­cards­and­passports).­This­ is­expressed­by­ the­unary­predicate­is_male/1­and­is_female/1.

­ Once­ the­ basic­ relationships­ are­ established­ among­ the­ elements­ of­ the­ family,­ other­family­ relationsships­ and­ predicates.­ For­ example,­ the­ relationship­ parent_of­ is­ the­opposite­of­child_of:

parent_of(X,Y):- child_of(Y,X).

­ ­The­predicate­mother­is­assigned­to­anyone,­of­sex­female­that­is­the­parent­of­someone.

mother_of(X,Y):- parent_of(X,Y), is_female(X).

­ ­A­mother­is­­the­mother­of­someone.­

is_mother_of(X):- mother_of(X,_).

Prolog by Example: Family relationships

is_male(doug).is_male(john).is_male(fred).is_male(peter).is_male(bob).is_male(alex).

is_female(mary).is_female(carol).is_female(tess).is_female(ann).is_female(alice).is_female(vicky).

john

doug carol

peter bob alex

ann

alice

vicky

mary

tess

fred

30 September 2005 Foundations of Logic and Constraint Programming 7

­ For­any­mother­with­many­children,­the­predicate­is_mother/1­may­be­deduced­several­times,­once­for­each­child.­This­leads­to­repeated­answers­to­query­

Prolog by Example: Repeated Answers

?- is_mother(X). X= carol ? ;X = carol ? ;X = mary ? ;X = tess ? ;X = ann ? ;X = ann ? ;

X = ann ? ;X = vicky ? ;no.

is_mother_of(X)

mother_of(X,Y)

parent_of(X,Y), is_female(X).

X/johnY/doug

child_of(Y,X), is_female(X).

is_female(doug) is_female(carol)

X/johnY/carol

child_of(john,doug).child_of(john,carol).child_of(mary,carol).child_of(tess,mary).child_of(fred,tess).child_of(peter,john).child_of(bob,john).child_of(alex,john).child_of(peter,ann).child_of(bob,ann).child_of(alex,ann).child_of(alice, peter).child_of(alice,vicky).

30 September 2005 Foundations of Logic and Constraint Programming 8

­ Other­indirect­relationships­may­be­derived­from­their­definition,­namely­

grand_child_of/2

sibling_of/2, brother_of/2, sister_of/2

uncle_of/2, aunt_of/2,

great_uncle_of, great_aunt_of/2,

cousin_of, second_cousin_of/2, third_cousin_of/2, ...

­ Although­most­ definitions­ are­ direct,­ some­ care­must­ be­ taken­For­ example,­ siblings­ are­children­of­a­common­parent

sibling_of(X,Y):- child_of(X,Z), child_of(Y,Z).

­ This­ definition­ suffers­ from­ a­ quite­ common­ mistake:­ to­ assume­ that­ different­ variables­should­stand­for­different­values.­In­the­definition­above­a­person­is­a­sibling­of­him/herself!

­ Here­is­the­correct­definition,­where­the­difference­(\=)­is­made­explicitely::sibling_of(X,Y):- child_of(X,Z), child_of(Y,Z). X \= Y.

Prolog by Example: Different Variables

30 September 2005 Foundations of Logic and Constraint Programming 9

Prolog by Example: Different Variables

john

doug carol

peter bob alex

ann

alice

vicky

mary

tess

fred

sibling_of(X,Y):- child_of(X,Z), child_of(Y,Z), X \= Y.

child_of(john,doug).child_of(john,carol).child_of(mary,carol).child_of(tess,mary).child_of(fred,tess).child_of(peter,john).child_of(bob,john).child_of(alex,john).child_of(peter,ann).child_of(bob,ann).child_of(alex,ann).child_of(alice, peter).child_of(alice,vicky).

sibling_of(X,Y)

child_of(X,Z), child_of(Y,Z), X \= Y.

child_of(Y,doug), john\= Y

X/johnZ/doug

child_of(Y,carol), john\= Y

john\= john john\= mary

X/johnZ/carol

Y/john Y/mary

30 September 2005 Foundations of Logic and Constraint Programming 10

­ Care­ must­ also­ be­ taken­ to­ avoid­ definitions,­ that­ correct­ as­ they­ might­ be,­ eventually­become­circular,­leading­to­non­termination.

­ For­ example,­ the­ simetric­ property­ of­ the­ sibling_of­ relationship­ could,­ in­ principle­ be,­explicitely­defined,­by­the­additional­definition­

sibling_of(X,Y):- sibling_of(Y,X).

­ But­this­definition­would­lead,­when­X­and­Y­are­non-ground,­to­an­infinite­tree:

Prolog by Example: Non-termination

sibling_of(X,Y):- child_of(X,Z), child_of(Y,Z), X \= Y.sibling_of(X,Y):- sibling_of(Y,X).

sibling_of(X,Y)

child_of(X,Z), child_of(Y,Z), X \= Y.

sibling_of(Y,X)

sibling_of(X,Y)

sibling_of(Y,X)

sibling_of(X,Y)

30 September 2005 Foundations of Logic and Constraint Programming 11

­ Logic­ has­ been­ used­ to­ formalise­ arithmetics,­ and­ a­ number­ of­ interesting­ (mostly­theoretucal)­ results­ where­ obtained­ from­ this­ effort­ (for­ example,­ the­ famous­ Gödel­ ­incompletness­theorem)­.

­ The­“standard”­formalisation­is­due­to­Peano­(end­of­19th­century),­that­proposed­a­simple­set­of­axioms,­for­this­purpose.­

­ To­begin­with,­ integers­are­defined­ inductively:­ an­ integer­ is­either­0­or­ the­sucessor­of­another­number.

­ The­basic­algebraic­operations­can­also­be­formalised,­again­inductively.­For­example­the­addition­of­two­integers:

Base­clause:­The­sum­of­0­and­some­integer­M,­is­that­integer.

Inductive­clause:­The­sum­of­the­successor­of­an­integer­M­and­another­integer­N­is­the­successor­of­the­sum­of­the­integers­M­and­N.

­ Similar­definitions­can­be­used­to­define­the­operations­of­multiplication­and­potentiation.

­ ­Logic­programming­can­thus­be­used­to­directly­implement­arithmetics­(although­in­a­very­inneficient­way).­

Prolog by Example: Peano Arithmetics

30 September 2005 Foundations of Logic and Constraint Programming 12

­ The­definition­­of­ integers­is­straighgtforward.­Below­the­predicate­int/1­is­used­to­assign­the­property­intehger,­and­the­functor­s/1­to­denote­the­successor­of­an­integer.

int(0). % 0 is an integer int(s(M)):- int(M). % the successor of an integer is integer.

­ The­addition­follows­directly­the­definition. sum(0,M,M). % The sum of 0 and any integer M is M sum(s(N),M,s(K)):- % The sum the successor of N and M is the sum(N,M,K). % successor of the sum of N and M.

­ The­product,­as­a­repeated­sum,­is­modelled­by­means­of­addition. prod(0,M,0). % The product of 0 with any integer is 0. prod(s(N),M,P):- % The product of the successor of N and M is prod(N,M,K), % the sum of M with the product of M and N. sum(K,M,P).

­ And­so­is­the­power,­as­a­repeated­multiplication­(the­exponent­is­the­first­argument) pow(0,0, s(0)). % 0 raised to 0 is 0. pow(0,s(_),s(0)). % Integer M (>0) raised to 0 is 1 (i.e. S(0)). pow(s(N),M,P):- % Integer M raised to the successor of N pow(N,M,K), % is the product of M with M raised to N. prod(K,M,P).

Prolog by Example: Peano Arithmetics

30 September 2005 Foundations of Logic and Constraint Programming 13

­ It­is­interesting­to­note­the­functioning­of­Prolog,­with­these­predicates.­

­ First,­the­predicate­integer­can­be­used­either­to­check­whether­an­argument­is­an­integer,­either­to­generate­integers.

­ Notice­ in­ the­ last­case,­ that­ the­arguments­of­ int­ that­are­reported­ in­ the­answers­are­2,­3,­...

Prolog by Example: Peano Arithmetics

| ?- int(s(s(0))).yes| ?- int(X). X = 0 ? ; % X=0 X = s(0) ? ; % X=1 X = s(s(0)) ? ; % X=2 X = s(s(s(0))) ? % X=3| ?- int(s(s(X))). X = 0 ? ; % X = s(0) ? ;

30 September 2005 Foundations of Logic and Constraint Programming 14

­ The­ predicate­ sum­ performs­ as­ expected.­ Given­ two­ numbers­ to­ be­ summed,­ the­predicate­returns­their­sum.­Let­us­sum­3­with­2

­ The­corresponding­execution­tree­can­be­displayed

Prolog by Example: Peano Arithmetics

| ?- sum(s(s(0)),s(s(s(0))),X). X = s(s(s(s(s(0))))) ? ;no

sum(0,M,M). sum(s(N),M,s(K)):- sum(N,M,K).

The­result­X­is­then­obtained­by­composition­of­substitutions

X/s(K1)­­­but­­­K1/s(K2)) ­­­­­­so­X/s(s(K2))­­­but­­­K2/s(s(s(0)))­­­­­­so­X/s(s(s(s(s(0)))))­­­­­­i.e.­X = 5

sum(s(s(0)))),s(s(s(0))),X)

M1 / s(s(s(0)))N1 / s(0); X / s(K1)

sum(s(0),s(s(s(0))),s(K1))

sum(s(s(s(0))),0,s(K2))

M2 / s(s(s(0)))N2 / 0 ; K1 / s(K2)

K2 / s(s(s(0)))

30 September 2005 Foundations of Logic and Constraint Programming 15

­ Logic­programming­is­flexible.­Predicate­sum­also­defines­subtraction!­Given­two­numbers­to­be­subtracted,­the­predicate­also­returns­their­difference.­Let­us­subtract­2­from­5

Prolog by Example: Peano Arithmetics

| ?- sum(s(s((0)),s(s(s(0))),X). X = s(s(s(s(s(0))))) ? ;no

sum(0,M,M). sum(s(N),M,s(K)):- sum(N,M,K).

sum(s(s(0)),X,s(s(s(s(s(0))))))

M1 / X ; N1 / s(0)K1 / s(s(s(s(0))))

sum(s(0),X, s(s(s(s(0))))

sum(0,X,s(s(s(s(s(0)))))

X / s(s(s(0)))

M2 / X ; N2 / 0K2 / s(s(s(0)))

30 September 2005 Foundations of Logic and Constraint Programming 16

­ The­flexibility­of­ logic­programming­allows­that­still­ the­same­definition­enables­to­find­all­operands­whose­sum­is­5.­

Prolog by Example: Peano Arithmetics

| ?- sum(Y,S, sum(s(s(s((0)))). Y = s(s(s(s(s(0))))) , X = 0? ; Y = s(s(s(s(0)))) , X = s(0)? ;Y = s(s(s(0))) , X = s(s(0))? ;Y = s(s(0)) , X = s(s(s(0)))? ;Y = s(0) , X = s(s(s(s(0))))? ;Y = 0 , X = s(s(s(s(s(0)))))? ; no

sum(0,M,M). sum(s(N),M,s(K)):- sum(N,M,K).

sum(Y,X,s(s(s(s(s(0))))))

M1 / X ; Y / s(N1)K1 / s(s(s(s(0))))

sum(N1,X,s(s(s(s(0)))))

sum(N2,X,s(s(s(0))))

M2 / X ; N1 / s(N2)K2 / s(s(s(0)))

X / s(s(s(s(s(0)))))Y / 0

X / s(s(s(s(0))))N1 / 0

X / s(s(s(0)))N2 / 0

30 September 2005 Foundations of Logic and Constraint Programming 17

­ The­ other­ predicates,­ for­ product­ and­ potentiation,­ behave­ similarly­ to­ the­ predicate­ for­sum.­However,­if­no­solutions­exist­there­might­be­termination­problems,­if­the­recursion­is­performed­in­the­“wrong”­argument.­For­example,­there­are­no­problems­with­­­“2 * X = 3”

Prolog by Example: Peano Arithmetics

prod(0,M,0). prod(s(N),M,P):- prod(N,M,K) sum(K,M,P).

sum(0,M,M). sum(s(N),M,s(K)):- sum(N,M,K).

prod(s(s(0)),X,s(s(s(0))))

prod(s(0),X,K1), sum(X,K1,s(s(s(0))))

prod(0,X,K2), sum(X,K2,K1), sum(X,K1,s(s(s(0))))

sum(0,X,K1), sum(X,K1,s(s(s(0))))

sum(M1,M1,s(s(s(0))))

sum(N2, s(N2), s(s(0)))

sum(N3, s(s(N3)), s(0))

sum(N4, s(s(s(s(N4)), 0)

N2 / s(N3)

N3 / s(N4)

X / M1, K1 / M1 )

M1 / s(N2)

30 September 2005 Foundations of Logic and Constraint Programming 18

­ However,­ the­same­ is­not­ true­ for­ “X * 2 = 3”,­where­ the­unknown­argument­ is­ the­one­used­in­the­recursion.

­ It­ is­ left­ as­ an­ exercise­ to­ check­ what­ types­ of­ calls­ do­ not­ terminate­ with­ the­ above­definitions.

Prolog by Example: Peano Arithmetics

prod(X,s(s(0)),s(s(s(0))))

prod(N1,s(s(0)),K1), sum(N1,s(s(0)),s(s(s(0))))

sum(0,s(s(0)),s(s(s(0))))

M1/s(s(0)), X /s(N1)

N1 / 0, K1 / 0

prod(N2,s(s(0)),K2), sum(K2,s(s(0)),P2), sum(P2,s(s(0)),s(s(s(0))))

M2/s(s(0)) ; N1/s(N2), K1 / P2

prod(N3,s(s(0)),K3), sum(K3,s(s(0)),P3), sum(...), sum(...)

prod(N4,s(s(0)),K4), sum(K4,s(s(0)),P4), sum(...), sum(...), sum(...)

M3/s(s(0)) ; N2/s(N3), K2 / P3

M4/s(s(0)) ; N3/s(N4), K3 / P4

prod(0,M,0). prod(s(N),M,P):- prod(N,M,K) sum(K,M,P).

sum(0,M,M). sum(s(N),M,s(K)):- sum(N,M,K).

30 September 2005 Foundations of Logic and Constraint Programming 19

­ Although­ important­ from­ a­ theoretical­ viewpoint,­ Peano­ arithmetics­ is­ not­ very­ useful­ in­practice­ due­ to­ the­ complexity­ of­ both­ the­ representation­ of­ numbers­ and­ the­ basic­operations.­

­ For­example,­the­usual­repretsentation­of­an­integer­N­in­the­usual­base­2­or­10­requires­O(lg2­N)­or­O(lg10­N)­bits.­In­contrast,­Peano­representation­requires­O(N)­symbols­(more­precisely­N­s´s­+­2N­parenthesis­+­1­zero,­which­is­significantly­larger.

­ As­to­the­sum­operation,­say­N­plus­N,­the­usual­method­is­proportional­to­the­number­of­bits­/­digits­i.e.­it­has­complexity­O(lg­N).­

­ In­contrast,­peano­sum­requires­N­calls­to­the­sum­definition,­i.e.­It­has­complexity­O(N)

Prolog by Example: Peano Arithmetics

sum(M,0,M). sum(s(N),M,s(K)):- sum(N,M,K).

sum(s(s(s(0))),X,P)

sum(s(s(0)),X,P)

sum(s(0),X,P)

sum(0,X,P)

30 September 2005 Foundations of Logic and Constraint Programming 20

­ If­Peano­arithmetics­is­not­very­useful­ in­practice,­the­same­kind­of­definitions­are­widely­applicable,­namely­in­structures­like­lists.

­ Assuming­ the­ peano­ representation­ of­ integers,­ the­ following­ definition­ of­ predicate­ ­p_lenght/2­highlights­the­correspondence­between­0­and­the­empty­list­as­well­as­between­the­s­and­the­list­functors

­ Of­course,­if­the­usual­arithmetics­s­used,­the­definition­has­to­be­adapted,­such­that­the­notion­of­successor­is­replaced­by­the­usual­“+1”­operation

­ There­ are­ however­ disadvantages­ in­ this­ formulation,­ namely­ non-termination.­ This­ is­illustrated­by­the­execution­trees­of­both­predicates­to­obtain­lists­of­size­2.

List Processing in Prolog: Length

P_length([],0). p_length([_|T],s(N)):- p_lenght(T,N).

a_length([],0). a_length([_|T], M):- a_lenght(T,N), M is N+1.

30 September 2005 Foundations of Logic and Constraint Programming 21

­ There­ are­ however­ disadvantages­ in­ this­ formulation,­ namely­ non-termination.­ This­ is­illustrated­by­the­execution­trees­of­both­predicates­to­obtain­lists­of­size­2.

­ In­the­peano­modelling,­

the­goal­is­of­course­?- p_length(L,s(s(0))).­

and­the­execution­tree­is­as­follows

List Processing in Prolog : Length

P_length([],0). P_length([_|T],s(N)):- p_lenght(T,N).

p_length(L,s(s(0)))

L/ [_|T1]

p_length(T1,s(0)))

p_length(T2,0)

L1/ [_|T2]

T2/ []

Composing­substitutions,­the­value­of­L­is­obtained T2 = [] T1 = [_|T2] = [_] L = [_|T1] = [_,_]

30 September 2005 Foundations of Logic and Constraint Programming 22

­ With­ the­ modelling­ with­ standard­ arithmentics,­ the­ corresponding­ tree,­ for­ query­?- a_length(L,2),­is­­more­complex

­ The­correct­answer­is­obtained­as­before,­in­the­left­part­of­the­tree

T2 = [] ; T1 = [_|T2] = [_]; L = [_|T1] = [_,_]

­ However,­there­is­now­a­right­part­of­the­tree...

List Processing in Prolog : Length

a_length([],0). a_length([_|T],M):- a_lenght(T,N), M is N+1.

a_length(L,2)

L/ [_|T1] , M / 2

a_length(T1,N1), 2 is N1+1

2 is 0+1

T1/ [] , N1 / 0

a_length(T2,N2), N1 is N2+1, 2 is N1+1

T1/ [_|T2] , M2 / N1

N1 is 0+1, 2 is N1+1

T2/[] , N2/0

2 is 1+1

N1/1

a_length(T3,N3), N2 is N3+1, ...

T2/ [_|T3] , M3 / N2

30 September 2005 Foundations of Logic and Constraint Programming 23

­ However,­the­right­part­of­the­execution­tree­is­infinite­!

List Processing in Prolog : Length

a_length([],0). a_length([_|T],M):- a_lenght(T,N), M is N+1.

a_length(T3,N3), N2 is N3+1, ...

T4/ [_|T3] , M3 / N2

N3 is 0+1,..., 2 is N1+1 a_length(T4,N4), N3 is N4+1, ...

T4/ [_|T3] , M3 / N2

N4 is 0+1,..., 2 is N1+1 a_length(T5,N5), N4 is N5+1, ...

T4/ [_|T3] , M3 / N2

N5 is 0+1,..., 2 is N1+1 a_length(T6,N6), N5 is N6+1, ...

30 September 2005 Foundations of Logic and Constraint Programming 24

­ A­ very­ common­ operation­ between­ lists­ is­ their­ concatenation.­ Predicate­ cat/3­ below­ is­true,­when­ the­ list­ in­ the­ third­ argument­ is­ the­ concatenation­of­ the­ lists­ in­ the­ first­ and­second­arguments.­

­ As­usual,­the­definition­below­relies­on­the­inductive­structure­of­the­first­list,­and­considers­the­cases­where­it­is­empty­(the­base­clause)­or­not­(the­induction­clause).

­ It­ is­ interesting­ to­notice­ in­ the­execution­ tree,­ that­concatenating­a­ list­with­N1­elements­with­a­list­with­N2­elements,­requires­

N1­calls­to­the­recursive­clause,­for­lists­with­sizes­N1,­N1-1,­N1-2,­...,­2,­1.­

N1­ trivial­ failed­ calls­ to­ the­ base­ clause,­ for­ these­ lists­ (in­ fact,­ implementations­ of­prolog­indexing­on­the­first­argument­do­not­make­these­calls).

1­successful­call­with­an­empty­list­as­first­argument.

­ The­ concatenation­ of­ a­ list­ requires­ thus­ N1+1­ (non-trivial)­ calls,­ and­ presents­ thus­ a­complexity­of­O(N),­where­N­is­the­size­of­the­first­list­argument.

List Processing in Prolog: Concatenation

cat([],L,L). cat([H|T],L,[H|R]):- cat(T,L,R).

30 September 2005 Foundations of Logic and Constraint Programming 25

­ From­an­algorithmic­view­point,­ this­complexity­ is­ the­one­that­can­be­expected­ for­ lists,­maintained­as­simply­linked­lists,­with­a­pointer­to­its­head­(first­element).

­ This­ is­ in­ fact­ the­case­with­Prolog,­where­ lists­are­maintained­ in­ this­ form.­However,­a­different­ form­ of­ representation,­ difference­ lists,­ allow­ the­ tail­ append­ to­ be­ a­ simple­operation,­as­if­lists­were­implenmented­with­a­pointer­to­their­tail.

­ In­any­case,­the­declarativity­of­this­definition­allows­the­use­of­this­cat/3­predicate­either ­to­concatenate­two­lists­into­a­third­one,­or­ to­remove­a­sublist­(prefix­or­postfix)­from­a­list.

List Processing in Prolog: Concatenation

cat([],L,L). cat([H|T],L,[H|R]):- cat(T,L,R).

?- cat([1,2],[3,4,5],L). L = [1,2,3,4,5]; no.?- cat(L,[3,4,5],[1,2,3,4,5]). L = [1,2]; no.?- cat([1,2],L,[1,2,3,4,5]). L = [3,4,5]; no.?- cat(L1,L2,[1,2,3]). L1 = [], L2 = [1,2,3]; L1 = [1], L2 = [2,3]; L1 = [1,2], L2 = [3]; L1 = [1,2,3], L2 = []; no.

30 September 2005 Foundations of Logic and Constraint Programming 26

­ The­ declarativity­ of­ logic­ programming,­ makes­ it­ possible­ to­ reuse­ the­ definition­ of­concatenation,­to­define­other­relations­between­a­list­and­its­(non-empty)­sublists.

­ Prefix:­List­P­is­a­(non-empty)­prefix­of­list­L­if­there­is­some­other­list­X­such­that­L­is­the­concatenation­of­P­and­X­(in­Prolog,­X­may­be­declared­as­an­anonimous­list).

­ Posfix:­List­P­is­a­(non-empty)­postfix­of­list­L­if­there­is­some­other­list­X­such­that­L­is­the­concatenation­of­X­and­P­(in­Prolog,­X­may­be­declared­as­an­anonimous­list).

­ Sublist:­The­sublist­relation­can­be­defined­upon­the­prefix­and­posfix­relations:­list­S­is­a­(non-empty)­sublist­of­L­if­there­is­a­prefix­P­of­list­L,­of­which­S­is­a­posfix.

List Processing in Prolog: Sublists

prefix([H|T],L):- cat([H|T],_,L).

sublist(S,L):- prefix(P,L), posfix(S,P).

posfix_of([H|T],L):- cat(_,[H|T],L).

30 September 2005 Foundations of Logic and Constraint Programming 27

­ In­ addition­ to­ relationships­ bewteen­ lists,­ it­ is­ often­ important­ to­ consider­ relationships­between­lists­and­their­members.

­ The­most­useful­predicate,­member/2,­­relates­a­list­with­any­of­its­members

­ Another­ important­ predicate­ relates­ two­ lists,­ L1­ and­ L2,­ with­ an­ element­ X.­ Given­ the­declarativeness­of­logic­programming­this­predicate­can­either­be­interpreted­as­

Inserting­X­into­L1­to­obtain­L2­ Removing­X­from­L2­to­otain­L1

­ The­definition­is­similar­to­that­above,­considering­the­cases­where­the­insertion­is­done­in­the­beginning­or­not­of­list­L1.

List Processing in Prolog: Membership and Append

member(X,[X|_]). member(X,[_|T]). member(X,T).

append(X,L,[X|L]). append(X,[H|T], [H|R]). append(X,T,R).

30 September 2005 Foundations of Logic and Constraint Programming 28

­ Other­ interesting­ predicates­ relate­ a­ list­ with­ any­ of­ its­ permutations.­ As­ usual­ the­definition­considers­two­cases

The­(only)­permutation­of­an­emptry­list­is­an­empty­list A­ permutation­ of­ a­ non-empty­ list­ is­ a­ permutation­ of­ its­ tail,­ to­ which­ the­ head­ is­inserted.

­ A­similar­definition­is­used­to­relate­a­list­with­its­reverse. The­(only)­reversion­of­an­empty­list­is­an­empty­list A­reversion­of­a­non-empty­list­is­a­reversion­of­its­tail,­to­which­the­head­is­inserted­at­the­end­(this­append­at­the­end­­can­be­obtained­by­concatenation­of­the­list­with­a­list­composed­of­the­element­to­be­appended)

­ Notice­the­non­termination­problems­when­the­first­argument­is­a­variable.­Why?

List Processing in Prolog: Permutation and Reversion

perm([],[]). perm([H|T],L). perm(T,P), append(H,P,L).

reverse([],[]). reverse([H|T], L):- reverse(T, R), cat(R,[H], L).

30 September 2005 Foundations of Logic and Constraint Programming 29

­ The­ reversion­ of­ a­ list­ is­ not­ very­ efficient.­ Analysing­ the­ execution­ tree­ (left­ as­ an­exercise),­the­reversion­of­a­list­of­size­N­requires­

One­(non-trivial)­call­to­revert­a­list­(of­length­N-1) One­call­ to­ “append”­an­element­ to­ the­end­of­ this­ list,­which­ requires­N­ “non-trivial­calls”­to­predicate­cat/3.

­ Hence,­the­complexity­of­this­“algorithm”­measured­by­the­number­of­non-trivial­“calls”,­is 1­call­to­reverse­and­a­call­to­cat­for­a­list­of­length­N­(i.e.­N+1­calls­to­cat) 1­call­to­reverse­and­a­call­to­cat­for­a­list­of­length­N-1­(i.e.­(N-1)+1­calls­to­cat) ... 1­call­to­reverse­and­a­call­to­cat­for­a­list­of­length­1­(i.e.­1+1­calls­to­cat) 0­call­to­reverse­and­1­call­to­cat­for­a­list­of­length­0­(i.e.­0+1­calls­to­cat)

­ The­number­of­calls­is­thus­ N­(non-trivial)­calls­to­predicate­reverse [N+1]+­[(N-1)+1]­+­...­+­2­+­1­=­(N+1)­(N+2)­/­2­(non-trivial)­calls­to­predicate­cat

­ The­ complexity­ of­ the­algorithm­ is­ then­O(N2)­which­ is­quite­ inneficient,­ since­ it­ is­ quite­easy­to­get­an­algorithm­to­perform­reversion­of­a­list­in­O(N)­steps.

List Processing in Prolog : Permutation and Reversion

30 September 2005 Foundations of Logic and Constraint Programming 30

­ As­seen­before,­concatenation­of­lists­could­be­made­more­efficient­if­a­pointer­to­the­end­of­the­list­is­maintained.­­This­is­the­basic­idea­of­the­coding­of­lists­as­difference­lists.

­ A­difference­list­is­a­structure­L-T­where­L­and­T­are­lists­and­T­is­the­tail­of­L.­

­ This­ structure­ represents­ a­ list­ whose­ elements­ are­ those­ belonging­ to­ L­ but­ not­ to­ T,­(hence­the­name­and­the­functor­used).­For­example,­the­difference­list­[1,2,3,4,5,6]-[5,6]­encodes­list­[1,2,3,4].

­ The­ interesting­ case­ for­ processing­ is­ the­ case­ where­ T­ is­ a­ variable.­ In­ this­ case,­appending­to­the­end­of­the­list­requires­processing­T.

­ For­ example,­ assume­ list­ [1,2,3,4],­ encoded­ as­ [1,2,3,4|T]-T.­ Appending­ 5­ to­ this­ list,­corresponds­to

­Obtaining­a­new­tail­T­=­[5|S] Subtracting­L­by­S.

­ This­is­the­declarative­meaning­of­predicate­td_app/3

which­can­be­simplified­with­head­unification

List Processing in Prolog: Difference Lists

td_app(X,L-T,L-S):- T = [X|S].

td_app(X,L-[X|S],L-S).

30 September 2005 Foundations of Logic and Constraint Programming 31

­ The­same­technique­can­be­used­to­concatenate­two­difference­lists,­L1-T1­and­L2-T2,­in­to­a­third­one­L3-T3.­

­ To­exemplify,­ let­us­concatenate­lists­[1,2,3]­to­[4,5]­resulting­into­[1,2,3,4,5],­all­encoded­as­difference­lists­

[1,2,3|T1]­-­T1­+­­[4,5|T2]-T2­=­[1,2,3,4,5|T3]­–­T3

­ By­analysing­this­example,­it­is­clear­that We­can­make­L1 = L3­if­the­substitution­T1­=­[4,5|T3]­is­imposed Since­L2­=­[4,5|T2],­the­above­substitution­is­imposed­when­T2 = T3­and­T1 = L2

­ Hence­predicate­cat_diff/3,­describes­the­concatenation­of­difference­lists­

­ By­using­head­unification­the­concatenation­becomes­quite­“intuitive”

List Processing in Prolog: Difference Lists

cat_diff(L1-T1,L2-T2,L3-T3):- L3 = L1, T3 = T2, L2 = T1

cat_diff(L1-T1,T1-T2,L1-T2).

30 September 2005 Foundations of Logic and Constraint Programming 32

­ The­concatenation­of­difference­lists­is­thus­performed­through­simple­unification,­instead­of­requiring­the­inneficient­recursion­of­the­usual­lists.

­ This­result­can­thus­be­used­to­reverse­difference­lists,­by­adapting­the­previous­definition­of­ reverse/2­ (for­ standard­ lists)­ to­ the­ new­ encoding­ as­ difference­ lists­ (the­ special­encoding­of­the­empty­difference­list­is­exaplained­in­the­next­slide)

­ The­definition­can­be­“improved”­by­head­unification.­Since­the­call­to­cat_diff/3­performs­substitutions­Lx = L2,­Tx = [H|T]­ and­T = T2,­ such­ substitutions­ can­be­made­directly,­avoiding­the­explicit­call­to­cat_diff/3

List Processing in Prolog: Difference Lists

reverse([],[]). reverse([H|T], L):- reverse(T, R), cat(R,[H], L).

rev_diff(L-T,L-T):- L == T. rev_diff([H1|L1]-T1, L2-T2):- rev_diff (L1-T1, Lx-Tx), cat_diff(Lx-Tx,[H|T]-T,L2-T2).

rev_diff(L-T,L-T):- L == T. rev_diff([H1|L1]-T1, L2-T):- rev_diff (L1-T1, T1-[H|T]).

30 September 2005 Foundations of Logic and Constraint Programming 33

­ In­principle,­ the­encoding­of­an­empty­difference­ list­ is­L-L.­As­such­ the­ reversion­of­an­empty­difference­list­could­be­made­with­a­clause­such­as

­ Hence,­when­this­clause­is­tested­to­reverse­a­non-empty­list,­say­rev_diff([1,2|Z]-Z,­X-Y),­the­call­should­fail,­since­[1,2|Z]-Z­does­not­encode­an­empty­list­(it­encodes­of­course­list­[1,2])­and­should­not­unify­with­L-L.­

­ More­precisely,­it­is­not­possible­to­unify­L­=­[1,2|Z]­and­L­=­Z,­because­that­would­require­Z­=­[1,2|Z],­i.e.­to­substitute­a­variable,­Z,­by­a­term,­[1,2|Z],­where­the­variable­occurs.

­ This­“occurs-check”­failure­does­not­occur­in­most­Prolog­systems­that­do­not­implement­it­correctly­(ending­in­an­infinite­loop­X­=­f(X)­=­f(f(X))­=­f(f(f(X)))­=­...).

­ For­ this­ reason,­ instead­ of­ checking­ if­ the­ two­ variable­ L-T­ are­ the­ same­ through­unification­(i.e.­with­predicate­“=/2”),­ the­clause­tests­this­case­with­predicate­“==/2”,­ that­only­succeeds­if­the­terms­are­already­the­same­at­the­time­of­call.

List Processing in Prolog: Difference Lists

rev_diff(L-L,L-L). rev_diff(L-T,L-T):- L = T

rev_diff(L-T,L-T):- L == T

30 September 2005 Foundations of Logic and Constraint Programming 34

­ The­declarativity­of­Prolog­allows­ that­simple­programs­are­specified­ to­solve­apparently­complex­problems.­

­ The­Langford(M,N)­problem­aims­at­finding­a­list­of­M*N­elements,­such­that­the­integers­1­to­M­each­appear­N­times,­in­such­positions­that­between­two­occurrences­of­any­J­(in­the­range­1..M)­are­separated­by­J­different­elements.

­ The­specification­of­the­Langford(4,2)­is­quite­obvious­­us­when­the­sublist/2­predicate­is­used

­ Of­ course,­ such­ simple­ specification­ is­ only­ possible­ due­ to­ the­ flexibility­ of­ logic­programming,­namely­the­lack­of­fixed­input-output­arguments.

List Processing in Prolog: Langford

langford42(L):- L = [_,_,_,_,_,_,_,_], sublist([1,_,1], L), sublist([2,_,_,2], L), sublist([3,_,_,_,3], L), sublist([4,_,_,_,_,4], L).

30 September 2005 Foundations of Logic and Constraint Programming 35

­ A­more­challenging­problem­is­the­classic­zebra­puzzle:­

1. There­are­five­houses,­each­of­a­different­color­and­inhabited­by­men­of­different­nationalities,­with­different­pets,­drinks,­and­cigarettes.­

2. The­Englishman­lives­in­the­red­house.­3. The­Spaniard­owns­the­dog.­4. Coffee­is­drunk­in­the­green­house.­5. The­Ukrainian­drinks­tea.­6. The­green­house­is­immediately­to­the­right­of­the­ivory­house.­7. The­Old­Gold­smoker­owns­snails.­8. Kools­are­smoked­in­the­yellow­house.­9. Milk­is­drunk­in­the­middle­house.­10.The­Norwegian­lives­in­the­first­house­on­the­left.­11.The­man­who­smokes­Chesterfields­lives­in­the­house­next­to­the­man­with­the­fox.­12.Kools­are­smoked­in­the­house­next­to­the­house­where­the­horse­is­kept.­13.The­Lucky­Strike­smoker­drinks­orange­juice.­14.The­Japanese­smoke­Parliaments.­15.The­Norwegian­lives­next­to­the­blue­house.­

16.NOW,­who­drinks­water?­And­who­owns­the­zebra?­

List Processing in Prolog: Zebra

30 September 2005 Foundations of Logic and Constraint Programming 36

­ Again,­ this­ problem­ is­ solved­ with­ a­ very­ simple­ program,­ but­ requires­ slightly­ more­involved­data­structures.­Here­is­a­possible­solution A­solution­ is­ a­ list­ of­ 5­entities,­ each­composed­of­a­house,­a­nationality,­ a­pet,­ a­

drink­and­a­cigarrette­brand. These­different­components­can­be­associated­in­a­single­term,­h(H,N,P,D,C). In­list­L,­an­element­A­that­is­before­another­element­B,­encodes­the­fact­that­house­

HA­is­to­the­left­of­house­HB.

­ Once­ this­ is­done,­ ­ the­program­has­ the­ following­structure,­where­ the­constraints­are­still­to­be­specified

List Processing in Prolog: Zebra

zebra(L):- L = [h(H1,N1,P1,D1,C1), h(H2,N2,P2,D2,C2), h(H3,N3,P3,D3,C3), h(H4,N4,P4,D4,C4), h(H5,N5,P5,D5,C5)],

... constraints...

30 September 2005 Foundations of Logic and Constraint Programming 37

­ Most­constraints­associate­two­entities­in­the­same­house.­For­example

2.­The­Englishman­lives­in­the­red­house.

­ This­ type­of­ constraint­ (common­ to­constraints­2,­3,­4,­5,­7,­8,­13,­14­and­ the­ implicit­constraints­ in­ the­query)­ is­simply­modelled­by­ imposing­ that­a­ term­with­ the­specified­association­is­a­member­of­list­L

­ Constraints­9­and­10­state­facts­about­the­house­in­the­middle­and­the­leftmost­house,­which­are­respectively­the­third­and­the­firts­member­of­list­L.­

9.­Milk­is­drunk­in­the­middle­house.­

10.­The­Norwegian­lives­in­the­first­house­on­the­left.­

List Processing in Prolog: Zebra

member(h(red,english,_,_,_),L), %2

L = [_,_,h(_,_,_,milk,_),_,_], % 9 L = [h(_,norwegian,_,_,_)| _], % 10

30 September 2005 Foundations of Logic and Constraint Programming 38

­ Another­constraints­refers­to­a­house­left­to­another

6.­The­green­house­is­immediately­to­the­right­of­the­ivory­house.­

­ This­type­of­constraint­is­simply­modelled­with­the­sublist­relation

­ Other­constraints­refer­to­houses­next­to­eacother,­but­not­specifing­which­is­to­the­left­and­which­ is­ to­ the­ right.­ ­Hence,­ the­predicate­next/3­may­be­defined­specifying­both­alternatives

­ Now,­constraints­11,­12­and­15­may­be­expressed­declaratively.­For­example.

15.­The­Norwegian­lives­next­to­the­blue­house.­

List Processing in Prolog: Zebra

sublist([h(ivory,_,_,_,_),h(green,_,_,_,_)],L), % 6

next(A,B,L):- sublist([A,B],L). next(A,B,L):- sublist([B,A],L).

next(h(_,norwegian,_,_,_),h(blue,_,_,_,_),L), % 15

30 September 2005 Foundations of Logic and Constraint Programming 39

List Processing in Prolog: Zebra

­ ­Here­is­the­full­program

zebra(L):- L = [h(H1,N1,P1,D1,C1), h(H2,N2,P2,D2,C2), h(H3,N3,P3,D3,C3), h(H4,N4,P4,D4,C4), h(H5,N5,P5,D5,C5)], member(h(red,english,_,_,_),L), % 2 member(h(_,spanish,dog,_,_),L), % 3 member(h(green,_,_,coffee,_),L), % 4 member(h(_,ukrainian,_,tea,_),L), % 5 sublist([h(ivory,_,_,_,_),h(green,_,_,_,_)],L), % 6 member(h(_,_,snails,_,old_gold),L), % 7 member(h(yellow,_,_,_,kool),L), % 8 L = [_,_,h(_,_,_,milk,_),_,_], % 9 L = [h(_,norwegian,_,_,_)|_], % 10 next(h(_,_,_,_,chesterfields),h(_,_,fox,_,_),L), % 11 next(h(_,_,_,_,kool),h(_,_,horse,_,_),L), % 12 member(h(_,_,_,orange,lucky_strike),L), % 13 member(h(_,japanese,_,_,parliaments),L), % 14 next(h(_,norwegian,_,_,_),h(blue,_,_,_,_),L), % 15 member(h(_,_,zebra,_,_),L), % Q1 member(h(_,_,_,water,_),L). % Q2