Logic Programming and Prolog Goal: use formalism of first-order logic Output described by logical formula (theorem) Input described by set of formulae (axioms) Computation is verification that output can be formally derived from input Computation engine is theorem prover Side-effect of computation is a set of bindings of logical variables to terms, which describes desired result.

Biblical Prolog father (adam, abel). % an assertion (a fact) father (adam, cain). brother (X, Y) :- father (Z, X), father (Z, Y). % a rule ? :- father (adam, abel) % a query yes % response ? :- father (X, abel) X = adam ? :- father (cain, abel) no ? :- brother (abel, Z) Z = cain ? :- mother (eve, abel) no % no is non-provability, not falsehood

The syntax of logical formulae Terminals: literals, variables, function symbols, punctuation Productions: term ::= literal | variable | function_symbol ( terms ) terms ::= term | term terms simple_clause ::= term | term, simple_clause clause ::= simple_clause | term :- simple_clause program ::= clauses comma is conjunction: and :- is reverse implication: iff

Substitutions and unification Computation perfoms unification between terms, by generating substitutions on variables. Computation halts when no further unifications are possible Result is final set of substitutions, mapping variables to terms Unify father (adam, cain) with father (X, cain) by unifying X with adam. –Result is { X/adam } Unify father (adam, cain) with father (X, Y) –Result is { X/adam, Y/cain } Unify father ( adam, cain ) with father ( X, X ) –Result is { } : failure

Unification algorithm To unify two terms t1 and t2: t1 = t2 f (s 1, s 2,..) = f (t 1, t 2..) Replace equation with s 1 = t 1, s 2 = t 2 … f (s 1, s 2..) = g(t 1, t 2..) where f /= g fail v = v delete equation v = t where t is a term not containing v Apply the substitution v / t everywhere v = t where t is a term that contains v fail

The meaning of a clause P (x 1, x 2 …) :- q 1 (s 1, s 2..), q 2 (t 1, t 2..).. Logical (declarative) interpretation: the predicate P is true (satisfiable) on arguments x 1, x 2.. If each predicate q i can be shown to be satisfiable Procedural interpretation: a call to procedure P is executed by calling in turn q 1, q 2 … (subgoals) Several unifications may be possible at a given time: selection is non-deterministic If unification fails, computation backtracks

Lists Terms are sufficient for everything, but need special syntax for simple recursive structures [X | Y] designates list with head X and tail Y – (special term for function symbol cons) [X| _ ] indicates that tail of list is irrelevant: – _ is variable that needs no binding

Backtracking and brute force search color (C):- member (C, [green, red, blue, yellow]) member (X, [X | _ ]). member X [ _ |Y]) :- member (X, Y). next (R 1, R 2 ) :- color (R 1 ), color (R 2 ), R 1 \= R 2. Graph to be colored is described by adjacency terms: ?:- next(R 1, R 2 ), next (R 1, R 3 ), next (R 1, R 4 ), next (R 2, R 3 ), next (R 2, R 4 ), next (R 3, R 4 )

reversibility Predicate can be used as generator: member (X, [X | _ ]). member X [ _ |Y]) :- member (X, Y). color (C):- member (C, [green, red, blue, yellow]) ?:- color (C) C = green; % semicolon forces backtracking C = read; % second choice C = blue C = yellow; no % no further backtracking possible

arithmetic Ideal: symmetric handling of queries factor (X, Y, Z) :- X = Y * Z ?:- factor (10, 2, 5) Yes ?:- factor ( , Y, Z) % you wish! In practice: cannot do arithmetic on uninstantiated variables

arithmetic and binding Z is X + Y succeeds if X and Y are instantiated and Z is uninstantiated Z is Z + 1 always fails fact (0, 1). fact (N, M) :- N1 is N -1, fact (N1, M1), M is N * M1