Logic Programming and Prolog

1

Logic ProgrammingLogic Programming

And PrologAnd Prolog

MacLennan - Chapter 13MacLennan - Chapter 13ECE Department of Tehran UniversityECE Department of Tehran UniversityProgramming Language Design CourseProgramming Language Design CourseStudent LectureStudent Lecture

Sadegh Dorri Nogoorani (http://ce.sharif.edu/~dorri)Sadegh Dorri Nogoorani (http://ce.sharif.edu/~dorri)

2ECE Dep. of Tehran Univ. - Programming Language DesignECE Dep. of Tehran Univ. - Programming Language Design

55thth-Generation Languages-Generation Languages

Declarative (nonprocedural)Declarative (nonprocedural) Functional Programming Logic Programming

ImperativeImperative Object Oriented Programming


Nonprocedural ProgrammingNonprocedural Programming

Sorting procedurally:Sorting procedurally:1. Find the min in the remained numbers.2. Swap it with the first number.3. Repeat steps 1,2 until no number remains.

Sorting nonprocedurally:Sorting nonprocedurally:1. B is a sorting of A ↔ B is a permutation of A and B is

ordered.2. B is ordered ↔ for each i<j: B[i] ≤ B[j]

Which is Which is higher levelhigher level??


Automated Theorem ProvingAutomated Theorem Proving

A.T.P:A.T.P: Developing programs that can construct formal proofs Developing programs that can construct formal proofs of propositions stated in a symbolic language.of propositions stated in a symbolic language.

ConstructConstruct the desired result to prove its existence (most the desired result to prove its existence (most A.T.P.’s).A.T.P.’s).

In In Logic ProgrammingLogic Programming, , programs are expressed in the form of programs are expressed in the form of propositions and the theorem prover constructs the result(s).propositions and the theorem prover constructs the result(s).

J. A. Robinson: A program is a theory (in some logic) and J. A. Robinson: A program is a theory (in some logic) and computation is deduction from the theory.computation is deduction from the theory.


Programming In Logic (Prolog)Programming In Logic (Prolog)

Developed in Developed in Groupe d’Intelligence ArtificielleGroupe d’Intelligence Artificielle (GIA)(GIA) of the University of Marseilles (early 70s) to process of the University of Marseilles (early 70s) to process a natural language (French).a natural language (French).

Interpreters: Algol-W (72), FORTRAN (73), Pascal Interpreters: Algol-W (72), FORTRAN (73), Pascal (76), Implemented on many platforms (Now)(76), Implemented on many platforms (Now)

Application in AI since mid-70sApplication in AI since mid-70sSuccessor to LISP for AI appsSuccessor to LISP for AI apps

Not standardized (but has ISO standard now)Not standardized (but has ISO standard now)

6

Structural OrganizationStructural Organization

13.213.2

7

parentparent(X,Y) :- (X,Y) :- fatherfather(X,Y).(X,Y).parentparent(X,Y) :- (X,Y) :- mothermother(X,Y).(X,Y).grandparentgrandparent(X,Z) :- (X,Z) :- parentparent(X,Y), (X,Y), parentparent(Y,Z).(Y,Z).ancestorancestor(X,Z) :- (X,Z) :- parentparent(X,Z).(X,Z).ancestorancestor(X,Y) :- (X,Y) :- parentparent(X,Y), (X,Y), ancestorancestor(Y,Z).(Y,Z).siblingsibling(X,Y) :- (X,Y) :- mothermother(M,X), (M,X), mothermother(M,Y),(M,Y), fatherfather(F,X), (F,X), fatherfather(F,Y), X \= Y.(F,Y), X \= Y.cousincousin(X,Y) :- (X,Y) :- parentparent(U,X), (U,X), parentparent(V,Y), (V,Y), siblingsibling(U,V).(U,V).

fatherfather(albert, jeffrey).(albert, jeffrey).mothermother(alice, jeffrey).(alice, jeffrey).fatherfather(albert, george).(albert, george).mothermother(alice, george).(alice, george).fatherfather(john, mary).(john, mary).mothermother(sue, mary).(sue, mary).fatherfather(george, cindy).(george, cindy).mothermother(mary, cindy).(mary, cindy).fatherfather(george, victor).(george, victor).mothermother(mary, victor).(mary, victor).

8

?- ?- [kinship].[kinship].% kinship compiled 0.00 sec, 3,016 bytes% kinship compiled 0.00 sec, 3,016 bytesYesYes

?- ?- ancestor(X, cindy), sibling(X, jeffrey).ancestor(X, cindy), sibling(X, jeffrey).X = georgeX = george YesYes

?- ?- grandparent(albert, victor).grandparent(albert, victor).YesYes

?- ?- cousin(alice, john).cousin(alice, john).NoNo

?- ?- sibling(A,B).sibling(A,B).A = jeffrey, B = georgeA = jeffrey, B = george ; ; A = george, B = jeffreyA = george, B = jeffrey ; ; A = cindy, B = victorA = cindy, B = victor ; ; A = victor, B = cindyA = victor, B = cindy ; ; NoNo

SWI Prolog


ClausesClauses

Programs are constructed from A number of Programs are constructed from A number of clausesclauses: <head> : <head> :-:- <body> <body>Clauses have three forms:Clauses have three forms: hypotheses (facts) conditions (rules) goalsBoth <headBoth <head>> and <body> are composed of and <body> are composed of relationshipsrelationships (also called (also called predicationspredications or or literalsliterals))

assertions (database)

questions


RelationshipsRelationships

Represent properties of and relations among the Represent properties of and relations among the individualsindividualsA relationship is application of a A relationship is application of a predicatepredicate to one or to one or more more termstermsTerms:Terms: atoms (or constants): john, 25, … variables (begin with uppercase letters): X, … compounds

Horn clause formHorn clause form: : At most one relationship in At most one relationship in <head><head>


Compound TermsCompound Terms

It is It is moremore convenient to describe individuals without convenient to describe individuals without giving them names (giving them names (expressionsexpressions or or compoundscompounds as as terms).terms).using using functors functors (tags):(tags):d(X, plus(U,V), plus(DU,DV)) :- d(X,U,DU), d(X,V,DV).

or using or using infix functorsinfix functors::d(X, U+V, DU+DV) :- d(X,U,DU), d(X,V,DV).

instead ofinstead ofd(X,W,Z) :- sum(U,V,W), d(X,U,DU), d(X,V,DV),

sum(DU,DV,Z).with less readability and some other things…with less readability and some other things…

12

Data StructuresData Structures

13.313.3


Primitives and ConstructorsPrimitives and Constructors

FewFew primitives and primitives and NoNo constructors. constructors.

Data types and data structures are defined Data types and data structures are defined implicitlyimplicitly by their by their propertiesproperties..


Example (datatype)Example (datatype)

Natural number arithmeticNatural number arithmetic

sum(succ(X), Y, succ(Z)) :- sum(X,Y,Z).sum(0,X,X).dif(X,Y,Z) :- sum(Z,Y,X).

:-sum(succ(succ(0)),succ(succ(succ(0))),A).A = succ(succ(succ(succ(succ(0)))))

Very inefficient! (Why such a decision?)Very inefficient! (Why such a decision?)Use of Use of ‘is’‘is’ operator (unidirectional) operator (unidirectional)


PrinciplesPrinciples

SimplicitySimplicity Small number of built-in data types and operations

RegularityRegularity Uniform treatment of all data types as predicates

and terms


Data StructuresData Structures

Compound termsCompound terms can represent data structures can represent data structures

Example: Example: ListsLists in LISP in LISP

(car (cons X L)) = X(cdr (cons X L)) = L(cons (car L) (cdr L)) = L, for nonnull L


Lists in PrologLists in Prolog

Using compound terms:Using compound terms:car( cons(X,L), X).cdr( cons(X,L), L).list(nil).list(cons(X,L)) :- list(L).null(nil).

What about null(L)?What about null(L)?

How to accomplish (car (cons How to accomplish (car (cons ‘‘(a b) (a b) ‘‘(c d)))?(c d)))?


Some Syntactic SugarSome Syntactic Sugar

Using Using ‘.’‘.’ infix functor (in some systems) infix functor (in some systems) instead of cons:instead of cons: Clauses?

Most Prolog systems allow the abbreviation:Most Prolog systems allow the abbreviation: [X1, X2, …, Xn] = X1. X2. … .Xn.nil [ ] = nil ‘.’ is right associative!


Component SelectionComponent Selection

Implicitly done by Implicitly done by pattern matchingpattern matching ( (unificationunification).).append( [ ], L, L).append( X.P, L, X.Q) :- append(P,L,Q).

Compare with LISP append:Compare with LISP append:(defun append (M L) (if (null M) L (cons (car M) (append (cdr M) L)) ))

Taking apartTaking apart in terms of in terms of putting togetherputting together!! What X and P are cons’d to create M? What number do I add to 3 to get 5 (instead of 5-3)

Efficient!?Efficient!?


Complex StructuresComplex Structures

A tree using lists (in LISP): A tree using lists (in LISP): (times (plus x y) (plus y 1))

Using compound terms directly (as records):Using compound terms directly (as records): times(plus(x, y), plus(y, 1))

Using predicates directly:Using predicates directly: sum(x, y, t1). sum(y, 1, t2). prod(t1, t2, t3).

Which is Which is betterbetter??


Why Not Predicates?Why Not Predicates?

Symbolic differentiation using predicate Symbolic differentiation using predicate structured expressions: structured expressions:

d(X,W,Z) :- sum(U,V,W), d(X,Y,DU), d(X,V,DV), sum(DU,DV,Z).

d(X,W,Z) :- prod(U,V,W), d(X,U,DU), d(X,V,DV), prod(DU,V,A), prod(U,DV,B), sum(A,B,Z).

d(X,X,1).d(X,C,0) :- atomic(C), C \= X.


Why Not Predicates? (cont.)Why Not Predicates? (cont.)

Waste use of intermediate (temporary) Waste use of intermediate (temporary) variablesvariablesLess readabilityLess readabilityUnexpected answers!Unexpected answers!sum(x,1,z).:- d(x,z,D).No Why? What did you expect? How to correct it?


Closed World ModelClosed World Model

AllAll that is true is what can be that is true is what can be provedproved on the basis of the facts and on the basis of the facts and rules in the database.rules in the database.

Very reasonable in Very reasonable in object-orientedobject-oriented apps (modeling a real or apps (modeling a real or imagined world)imagined world) All existing objects are defined. No object have a given property which cannot be found in db.

Not suitable for Not suitable for mathematical problemsmathematical problems (Why?) (Why?) An object is generally take to exist if its existance doesn’t contradict the

axioms.

PredicatesPredicates are better for OO-relationships, are better for OO-relationships, CompoundsCompounds for for mathematical ones (Why?)mathematical ones (Why?) We cannot assume existance of 1+0 whenever needed.


An Argument!An Argument!

What’s the answer?What’s the answer?equal(X,X).:- equal(f(Y),Y).?

What’s the What’s the logicallogical meaning? ( meaning? (occurs checkoccurs check))Any Any otherother meaning?meaning?Can it be represented in a Can it be represented in a finite amountfinite amount of of memory?memory?Should we Should we detectdetect it? it?

25

Control StructuresControl Structures

13.413.4


Algorithm = Logic + ControlAlgorithm = Logic + Control

N. Wirth: N. Wirth: Program = data structure + algorithmProgram = data structure + algorithmR. Kowalski: R. Kowalski: Algorithm = logic + control Algorithm = logic + control

In conventional programming:In conventional programming: Logic of a program is closely related to its control A change in order of statements alters the meaning of program

In (pure) logic programming:In (pure) logic programming: Logic (logic phase) is determined by logical interrelationships of the

clauses not their order. Control (control phase) affects the order in which actions occur in time

and only affects the efficiency of programs.

Orthogonality PrincipleOrthogonality Principle


Top-Down vs. Bottom-Up ControlTop-Down vs. Bottom-Up Control

Top-down ≈ Top-down ≈ RecursionRecursion:: Try to reach the hypotheses

from the goal.

Bottom-up ≈ Bottom-up ≈ IterationIteration:: Try to reach the goal from the

hypotheses.

Hybrid:Hybrid: Work from both the goals and

the hypotheses and try to meet in the middle.

Which one is better?Which one is better?

:- fib(3, F).:- fib(3, F).N=3, M=2, K=1,N=3, M=2, K=1,

F=G+HF=G+H

:- fib(2,F).:- fib(2,F). N=2, M=1, k=0, N=2, M=1, k=0,

F=G+HF=G+H

:- fib(1,F).:- fib(1,F).F=1F=1

:- fib(1,F).:- fib(1,F).F=1F=1 :- fib(1,1).:- fib(1,1).:- fib(0,F).:- fib(0,F).

F=1F=1

:- fib(1,1).:- fib(1,1). :- fib(0,1).:- fib(0,1).

fib(0,1). fib(1,1).fib(N,F) :- N=M+1, M=K+1, fib(M,G),

fib(K,H), F=G+H, N>1.


Procedural InterpretationProcedural Interpretation

We have seen We have seen logicallogical and and recordrecord (data structure) (data structure) interpretationsinterpretations..

Clauses can also be viewed as Clauses can also be viewed as procedure invocationsprocedure invocations:: <head>: proc. definition <body>: proc. body (a series of proc. calls) Multiple definitions: branches of a conditional (case) fib() example…

Procedure calls can be executed in any order or even Procedure calls can be executed in any order or even concurrently! (pure logic)concurrently! (pure logic)

Input/Output params are not distinguished!Input/Output params are not distinguished! fib(3,3) ↔ true. fib(3,F) ↔ F=3. fib(N,3) ↔ N=3. fib(N,F) ↔ ?


Unify, Fail, Redo…Unify, Fail, Redo…

Heavy use of Heavy use of unificationunification, , backtrackingbacktracking and and recursionrecursion..Unification (Prolog pattern matching – from Unification (Prolog pattern matching – from WikipediaWikipedia):): One-time assignment (binding) uninst. var with atom/term/another uninst. var (aliasing) (occurs check) atom with the same atom compound with compound if top predicates and arities of the terms are

identical and if the parameters can be unified simultaneously We can use ‘=‘ operator to explicitly unify two terms

Backtracking:Backtracking: Make another choice if a choice (unif./match) failes or want to find

other answers. In logic prog. It is the rule rather than the exception. Very expensive!

Example: Example: lenlen([ ], 0). ([ ], 0). lenlen(X.T, L+1) :- (X.T, L+1) :- lenlen(T,L).(T,L).


Prolog’s Control RegimeProlog’s Control Regime

Prolog lang. is Prolog lang. is defineddefined to use to use depth-firstdepth-first search:search: Top to bottom (try the clauses in order of entrance) Left to right In pure logic prog., some complete deductive algorithm such as Robinson’s

resolution algorithm must be implemented.

DFS other than BFSDFS other than BFS Needs much fewer memory Doesn’t work for an infinitely deep tree (responsibility of programmer)

Some programs may fail if clauses and subgoals are not ordered Some programs may fail if clauses and subgoals are not ordered correctly (pp.471-474)correctly (pp.471-474)

Predictable execution of Predictable execution of impureimpure predicates (write, nl, read, retract, predicates (write, nl, read, retract, asserta, assertz, …)asserta, assertz, …)

31

[trace] ?- ancestor(X, cindy), sibling(X,jeffrey).[trace] ?- ancestor(X, cindy), sibling(X,jeffrey).EventEvent DepthDepth SubgoalSubgoal====================================================================Call:Call: (1)(1) ancestor(X, cindy) ancestor(X, cindy) Call:Call: (2)(2) parent(X, cindy) parent(X, cindy) Call:Call: (3)(3) father(X, cindy) father(X, cindy) Exit:Exit: (3)(3) father(george, cindy) father(george, cindy) Exit:Exit: (2)(2) parent(george, cindy) parent(george, cindy) Exit:Exit: (1)(1) ancestor(george, cindy) ancestor(george, cindy) Call:Call: (1)(1) sibling(george, jeffrey) sibling(george, jeffrey) Call:Call: (2)(2) mother(M, george) mother(M, george) Exit:Exit: (2)(2) mother(alice, george) mother(alice, george) Call:Call: (2)(2) mother(alice, jeffrey) mother(alice, jeffrey) Exit:Exit: (2)(2) mother(alice, jeffrey) mother(alice, jeffrey) Call:Call: (2)(2) father(F, george) father(F, george) Exit:Exit: (2)(2) father(albert, george) father(albert, george) Call:Call: (2)(2) father(albert, jeffrey) father(albert, jeffrey) Exit:Exit: (2)(2) father(albert, jeffrey) father(albert, jeffrey) Call:Call: (2)(2) george\=jeffrey george\=jeffrey Exit:Exit: (2)(2) george\=jeffrey george\=jeffrey Exit:Exit: (1)(1) sibling(george, jeffrey) sibling(george, jeffrey)

X = georgeX = georgeYesYes

SWI Prolog

32

If we move If we move parent(X,Y) :- father(X,Y)parent(X,Y) :- father(X,Y) before before parent(X,Y) :- mother(X,Y)parent(X,Y) :- mother(X,Y), , we have:we have:EventEvent DepthDepth SubgoalSubgoal====================================================================Call:Call: (1)(1) ancestor(X, cindy)ancestor(X, cindy)Call:Call: (2)(2) parent(X, cindy)parent(X, cindy)Call:Call: (3)(3) mother(X, cindy)mother(X, cindy)Exit:Exit: (3)(3) mother(mary, cindy)mother(mary, cindy)Exit:Exit: (2)(2) parent(mary, cindy)parent(mary, cindy)Exit:Exit: (1)(1) ancestor(mary, cindy)ancestor(mary, cindy)Call:Call: (1)(1) sibling(mary, jeffrey)sibling(mary, jeffrey)Call:Call: (2)(2) mother(M, mary)mother(M, mary)Exit:Exit: (2)(2) mother(sue, mary)mother(sue, mary)Call:Call: (2)(2) mother(sue, jeffrey)mother(sue, jeffrey)Fail:Fail: (2)(2) mother(sue, jeffrey)mother(sue, jeffrey)Redo:Redo: (2)(2) mother(M, mary)mother(M, mary)Fail:Fail: (2)(2) mother(M, mary)mother(M, mary)Fail:Fail: (1)(1) sibling(mary, jeffrey)sibling(mary, jeffrey)Redo:Redo: (3)(3) mother(X, cindy)mother(X, cindy)Fail:Fail: (3)(3) mother(X, cindy)mother(X, cindy)Redo:Redo: (2)(2) parent(X, cindy)parent(X, cindy)……

SWI Prolog


Cut! Cut!

‘‘!’!’: Discard choice points of parent frame and frames created after : Discard choice points of parent frame and frames created after the parent frame.the parent frame.

Always is satisfied.Always is satisfied.Used to guarantee termination or control execution order.Used to guarantee termination or control execution order.

i.e. in the goal i.e. in the goal :- p(X,a), !:- p(X,a), ! Only produce the 1st answer to X Probably only one X satisfies p and trying to find another one leads to an

infinite search!

i.e. in the rule i.e. in the rule color(X,red) :- red(X), !.color(X,red) :- red(X), !. Don’t try other choices of red (mentioned above) and color if X satisfies red Similar to then part of a if-then-elseif

Fisher, J.R., Prolog Tutorial, http://www.csupomona.edu/~jrfisher/www/prolog_tutorial/contents.html


Red-Green Cuts (!)Red-Green Cuts (!)

A A ‘‘greengreen’’ cut cut Only improves efficiency e.g. to avoid additional unnecessary computation

A A ‘red’‘red’ cut cut e.g. block what would be other consequences of

the program e.g. control execution order (procedural prog.)



Three ExamplesThree Examples

p(a).p(a).p(X) :- s(X), r(X).p(X) :- s(X), r(X).p(X) :- u(X).p(X) :- u(X).

r(a). r(b). r(a). r(b).

s(a). s(b). s(c).s(a). s(b). s(c).

u(d).u(d).

:- p(X), !:- p(X), !:- r(X), !, s(Y).:- r(X), !, s(Y).:- r(X), s(Y), !:- r(X), s(Y), !:- r(X), !, s(X).:- r(X), !, s(X).

part(a). part(b). part(c). part(a). part(b). part(c). red(a). black(b). red(a). black(b).

color(P,red) :- red(P),!. color(P,red) :- red(P),!. color(P,black) :- black(P),!. color(P,black) :- black(P),!. color(P,unknown). color(P,unknown).

:- color(a, C).:- color(a, C).:- color(c, C).:- color(c, C).:- color(a, unknown).:- color(a, unknown).


max(X,Y,Y) :- Y>X, !. max(X,Y,Y) :- Y>X, !. max(X,Y,X). max(X,Y,X). :- max(1,2,D).:- max(1,2,D).:- max(1,2,1).:- max(1,2,1).

See also MacLennan’s example p.476


Higher-Order RulesHigher-Order Rules

Logic programming is limited to first-order logic: Logic programming is limited to first-order logic: can’t bind variables to predicates themselves.can’t bind variables to predicates themselves.

e.g.e.g. redred (f-reduction) is illegal: (p(x,y,z) ↔ z=f(x,y)) (f-reduction) is illegal: (p(x,y,z) ↔ z=f(x,y))red(P,I,[ ],I).red(P,I,X.L,S) :- red(P,I,L,T), P(X,T,S).

But is legal if the latter be defined as:But is legal if the latter be defined as:red(P,I,X.L,S):- red(P,I,L,T), Q=..[P,X,T,S], call(Q).

What’s the difference?


Higher-Order Rules (cont.)Higher-Order Rules (cont.)

In LISP, both code and data are In LISP, both code and data are first-orderfirst-order objects, objects, but in Prolog arenbut in Prolog aren’’t.t.

Robinson Robinson resolution algorithmresolution algorithm is refutation complete is refutation complete for for first-orderfirst-order predicate logic. predicate logic.

GödelGödel’’s s incompleteness theoremincompleteness theorem: No algorithm is : No algorithm is refutation complete for refutation complete for higher-orderhigher-order predicate logic. predicate logic.

So, Prolog So, Prolog indirectlyindirectly supports higher-order rules. supports higher-order rules.


Negative FactsNegative Facts

How to define How to define nonsiblingnonsibling? Logically? Logically……nonsibling(X,Y) :- X = Y.nonsibling(X,Y) :- mother(M1,X), mother(M2,Y), M1 \= M2.nonsibling(X,Y) :- father(F1,X), father(F2,Y), F1 \= F2.

But if parents of X or Y are not in database?But if parents of X or Y are not in database? What is the answer of nonsibling? Can be solved by…nonsibling(X,Y) :- no_parent(X).nonsibling(X,Y) :- no_parent(Y). How to define no_parent?


Negative Facts (cont.)Negative Facts (cont.)

Problem:Problem: There is no There is no positivepositive fact expressing fact expressing the the absenceabsence of parent. of parent.

Cause: Cause: Horn clauses are limited to C :- P1,P2,…,Pn ≡ C holds if P1^P2^…^Pn hold. No conclusion if P1^P2^…^Pn don’t hold! If, not iff


Cut-failCut-fail

Solutions:Solutions:Stating Stating allall negative facts such as no_parent negative facts such as no_parent Tedious Error-prone Negative facts about sth are usually much more than positive facts

about it

““Cut-fail”Cut-fail” combination combination nonsibling(X,Y) is satisfiable if sibling(X,Y) is not (i.e. sibling(X,Y) is

unsatisfiable) nonsibling(X,Y) :- sibling(X,Y), !, fail. nonsibling(X,Y). how to define ‘fail’ ?!


negation :- unsatisfiablilitynegation :- unsatisfiablility

‘‘not’not’ predicate predicate not(P) is satisfiable if P is not (i.e. is

unsatisfiable). not(P) :- call(P), !, fail. not(P). nonsibling(X,Y) :- not( sibling(X,Y) ).

Is Is ‘not’‘not’ predicate the same as predicate the same as ‘logical ‘logical negation’negation’? (see p.484)? (see p.484)

42

Evaluation and EpilogEvaluation and Epilog

13.513.5


TopicsTopics

Logic programs are Logic programs are self-documentingself-documentingPure logic programs Pure logic programs separateseparate logic and control logic and controlProlog falls Prolog falls short ofshort of logic programming logic programmingImplementation techniques are Implementation techniques are improvingimprovingProlog is Prolog is a stepa step towardtoward nonproceduralnonprocedural programmingprogramming


Self-documentationSelf-documentation

Programming in a higher-level, …Programming in a higher-level, …Application orientation and…Application orientation and…TransparencyTransparency programs are described in terms of predicates and

individuals of the problem domain.

Promotes clear, rapid, accurate programmingPromotes clear, rapid, accurate programming


Separation of Logic and ControlSeparation of Logic and Control

Simplifies programmingSimplifies programmingCorrectness only deals with logicCorrectness only deals with logicOptimization in control cannot affect Optimization in control cannot affect correctnesscorrectnessObeys Obeys Orthogonality PrincipleOrthogonality Principle


Prolog vs. Logic ProgrammingProlog vs. Logic Programming

Definite control strategyDefinite control strategy Programmers make explicit use of it and the result

have little to do with logic Reasoning about the order of events in Prolog is

comparable in difficaulty with most imperative of conventional programming languages

CutCut doesn’t make any sense in logic! doesn’t make any sense in logic!notnot doesn’t correspond to logical negation doesn’t correspond to logical negation


Improving EfficiencyImproving Efficiency

Prolog is far from an efficient language.Prolog is far from an efficient language.So, it’s applications are limited to apps in So, it’s applications are limited to apps in which:which: Performance is not important Difficult to implement in a conventional lang.

New methods are inventedNew methods are inventedSome compilers produce code comparable to Some compilers produce code comparable to LISPLISP


Toward Nonprocedural ProgrammingToward Nonprocedural Programming

PurePure logic programs prove the possibility of logic programs prove the possibility of nonprocedural programming.nonprocedural programming.InIn PrologProlog, DFS requires programmers to think in , DFS requires programmers to think in terms of terms of operationsoperations and their proper and their proper orderingordering in time in time (procedurally).(procedurally).AndAnd Prolog’s control regime is more Prolog’s control regime is more unnaturalunnatural than than conventional languages.conventional languages.So,So, there is still much more important work to be there is still much more important work to be done before nonprocedural programming becomes done before nonprocedural programming becomes practicalpractical..


Covered Sections of MacLennanCovered Sections of MacLennan

13.113.113.213.213.313.313.413.4 except topics starting on pp. 471, 475, 477, 484,

485, 486, 488

13.513.5


Presentation ReferencesPresentation References

Colmerauer, Alain, Philippe Roussel, Colmerauer, Alain, Philippe Roussel, The Birth of Prolog, The Birth of Prolog, Nov. 1992, Nov. 1992, URL: URL: http://www.lim.univ-mrs.fr/~colmer/ArchivesPublications/HistoireProlog/http://www.lim.univ-mrs.fr/~colmer/ArchivesPublications/HistoireProlog/19november92.pdf19november92.pdf

Fisher, J.R., Prolog TutorialFisher, J.R., Prolog Tutorial, 2004, URL: , 2004, URL: http://www.csupomona.edu/~jrfisher/www/prolog_tutorial/contents.htmlhttp://www.csupomona.edu/~jrfisher/www/prolog_tutorial/contents.html

MacLennan, Bruce J., Principles of Programming Languages: Design, MacLennan, Bruce J., Principles of Programming Languages: Design, Evaluation and Implementation,Evaluation and Implementation, 3rd ed, Oxford University Press, 1999 3rd ed, Oxford University Press, 1999

Merritt, Dennis, “Prolog Under the Hood: An Honest Look”Merritt, Dennis, “Prolog Under the Hood: An Honest Look”, , PC AI PC AI magazine, Sep/Oct 1992magazine, Sep/Oct 1992

““Unification”Unification”, Wikipedia, the free encyclopedia, 25 Sep. 2005, URL: , Wikipedia, the free encyclopedia, 25 Sep. 2005, URL: http://en.wikipedia.org/wiki/Unificationhttp://en.wikipedia.org/wiki/Unification

51

Thank You!Thank You!

This lecture was a student lecture presented at the This lecture was a student lecture presented at the Electrical and Computer Engineering Department of Electrical and Computer Engineering Department of

the University of Tehran, in Fall 2005. the University of Tehran, in Fall 2005. Instructor: Dr. M. SirjaniInstructor: Dr. M. Sirjani

Logic Programming and Prolog

Engineering

Transcript of Logic Programming and Prolog