an introduction to logic programming n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
An introduction to Logic Programming PowerPoint Presentation
Download Presentation
An introduction to Logic Programming

Loading in 2 Seconds...

play fullscreen
1 / 93

An introduction to Logic Programming - PowerPoint PPT Presentation


  • 166 Views
  • Uploaded on

An introduction to Logic Programming. Chapter 6. Chapter topics. Introduction Relational Logic Programming : specify relations among entities Logic Programming : data structures: lists, binary trees, symbolic expressions, natural numbers (church) Prolog : arithmetic , cuts, negation

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'An introduction to Logic Programming' - ping


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
chapter topics
Chapter topics
  • Introduction
  • Relational Logic Programming: specify relations among entities
  • Logic Programming: data structures: lists, binary trees, symbolic expressions, natural numbers (church)
  • Prolog: arithmetic, cuts, negation
  • Meta-circular Interpreters for Logic Programming
logic programming introduction
Logic Programming: Introduction
  • Origin: automate the process of proving logical statements
  • Mind switch:
    • Formula ⇔ procedure declaration
    • Query ⇔procedure call
    • Proving ⇔ computation
logic programming introduction1
Logic Programming: Introduction

Every programming language has:

  • Syntax: set of formulas (facts and rules)
  • Semantics (set of answers)
  • Operational Semantics (how to get an answer):
    • Unification
    • Backtracking
logic programming introduction2
Logic Programming: Introduction
  • The building blocks of LP expressions are formulas: formulas defined relations. For example, formula p(X,Y) - a relation between X and Y called p.
  • axioms - are the knowledge base. axioms have the form:

X1,X2,...,XkH  B1 and B2 ... and Bn

  • A query - claim that the computation is attempting to proof.

A query has the form X1,X2,...,Xk Q1 and Q2 ... and Qm

A typical logic programming answer "X1=..., ... Xk=... also X1 =..., ... Xk=... "

  • Operational semantics: set of axioms  procedure definitionquery  procedure application

interpretation  prove query via program

logic programming model
Logic programming model

Kowalski's interpretation: An axiom H  B1 and B2 ... and Bnrepresents a procedure

  • H is the procedure’s head and the Bi’s are its body
  • To solve (execute) H, we recursively solve B1 ... Bn
relational lp
Relational LP
  • a computational model based on Kowalski's interpretation
  • The Prolog language ('70) - contains RLP + additional programming features
relational lp syntax
Relational LP - Syntax
  • atomic formula:

predicate_symbol(term1, ..., termn)

  • predicate symbols start with lowercase
  • terms:
    • symbols (representing individual constants)
    • variables (start with uppercase or _ for anonymous)
relational lp semantics
Relational LP - Semantics
  • Values:
    • all atomic values are symbols (typeless)
    • Very few primitive predicates, such as = (unification), \=, true, false
  • Computation output:
    • an answer to a query.
    • An answer to a query is a (possibly partial) substitution (assignment) of query variables.
relational lp syntax formulas
Relational LP Syntax - formulas
  • atomic formula:

Syntax: predicate_symbol(term1,...,termn)

Examples:

male(moshe)

color(red)

parent(reuven, moshe)

parent(moshe, rina)

parent(Parent, Child)

ancestor(A,D)

address(_City, hertzel, 20)

  • The only difference between predicates and individual constant symbols are their context/location.
relational lp syntax procedures
Relational LP Syntax - Procedures
  • A fact is an assertion of an atomic formula.

Syntax: H. where H is an atomic formula.

Examples:

parent(rina, moshe).

color(red).

ancestor(A,A).

  • Variables in facts are universally quantified. "for all A, it holds that ancestor(A,A)".
  • Procedures are an ordered collection of axioms (facts and rules)sharing the same predicate name and arity.
slide12

% Signature: parent(Parent, Child)/2

% Purpose: Parent is a parent of Child

parent(rina, moshe).

parent(rina, rachel).

parent(rachel, yossi).

parent(reuven, moshe).

% Signature: female(Person)/1

% Purpose: Person is a female.

female(rina).

female(rachel).

  • Predicates have arity(no. of parameters). specified in /n in the comment above the procedure.
  • not necessarily unique
relational lp syntax queries
Relational LP Syntax - Queries

A query has the syntax:

?- Q1, Q2, . . . , Qn.

where the Qi are atomic formulas.

Meaning:

Assuming the program axioms, do Q1 and ... and Qn hold?

',' means conjunction.

For example,

?- parent(rina, moshe).

"Is rina a parent of moshe?”

A computation is a proof of a query, returns:

true ;

false. user requests another answer

relational lp syntax queries1
Relational LP Syntax - Queries

A query has the syntax:

?- Q1, Q2, . . . , Qn.

where the Qi are atomic formulas.

Meaning:

Assuming the program axioms, do Q1 and ... and Qn hold as well?

',' means conjunction.

For example,

?- parent(rina,X).

"Does there exist an X which is a child of rina?"

X = moshe ;

X = rachel.

  • Variables in queries are existentially quantified.
relational lp syntax queries2
Relational LP Syntax - Queries

"Is there an X which is a child of rina, and is also a parent of some Y?"

?- parent(rina,X),parent(X,Y).

X = rachel,

Y = yossi.

"Find two parents of moshe?":

?- parent(X,moshe),parent(Y,moshe).

X = rina,

Y = rina ;

X = rina,

Y = reuven ;

X = reuven,

Y = rina ;

X = reuven,

Y = reuven.

relational lp syntax queries3
Relational LP Syntax - Queries

"Find two different parents of moshe?":

?- parent(X,moshe),parent(Y,moshe),X \= Y.

X = rina,

Y = reuven ;

X = reuven,

Y = rina ;

false.

?- parent(X,moshe), X \= Y, parent(Y,moshe).

false.

?- X=3.

X = 3.

?- X\=3.

false.

?- 4\=3.

true.

relational lp syntax1
Relational LP - Syntax

% Signature: loves(Someone, Somebody)/2

% Purpose: Someone loves Somebody

loves(rina,Y). % rina loves everybody.

loves(moshe, rachel).

loves(moshe, rina).

loves(Y,Y). % everybody loves himself

  • Variables in axioms are universally quantified.

"for all Y loves(rina,Y)"

can be renamed

"for all X loves(rina,X)"

  • Using a variable in a fact is defining it. The scope is the fact itself.
relational lp syntax2
Relational LP - Syntax

% Signature: loves(Someone, Somebody)/2

% Purpose: Someone loves Somebody

loves(rina,Y). % rina loves everybody.

loves(moshe, rachel).

loves(moshe, rina).

loves(Y,Y). % everybody loves himself

Queries:

?- loves(rina,moshe).

true ;

false.

relational lp syntax3
Relational LP - Syntax

% Signature: loves(Someone, Somebody)/2

% Purpose: Someone loves Somebody

loves(rina,Y). % rina loves everybody.

loves(moshe, rachel).

loves(moshe, rina).

loves(Y,Y). % everybody loves himself

Queries:

?- loves(rina,X).

true ;

X = rina.

relational lp syntax4
Relational LP - Syntax

% Signature: loves(Someone, Somebody)/2

% Purpose: Someone loves Somebody

loves(rina,Y). % rina loves everybody.

loves(moshe, rachel).

loves(moshe, rina).

loves(Y,Y). % everybody loves himself

Queries:

?- loves(X,rina).

X = rina ;

X = moshe ;

X = rina.

relational lp syntax5
Relational LP - Syntax

% Signature: loves(Someone, Somebody)/2

% Purpose: Someone loves Somebody

loves(rina,Y). % rina loves everybody.

loves(moshe, rachel).

loves(moshe, rina).

loves(Y,Y). % everybody loves himself

Queries:

?- loves(X,X).

X = rina ;

true.

this query has two answers.

relational lp syntax rules
Relational LP Syntax - Rules
  • Syntax:H :−B1, . . . , Bn.

is an assertion of an implication statement.

The conjunction of B1, .., Bn implies the head H.

Bi's and H are atomic formulas.

% Signature: mother(Mum, Child),

% Purpose: Mum is a mother of Child

mother(Mum, Child) :- parent(Mum, Child), female(Mum).

  • Variables occurring in rule heads are universally quantified. The lexical scope of the variable is the rule.
  • A variable can multiple times in the head.
  • variables are bound within a rule.
relational lp syntax rules1
Relational LP Syntax - Rules

% Signature: mother(Mum, Child),

% Purpose: Mum is a mother of Child

mother(Mum, Child) :- parent(Mum, Child), female(Mum).

?- mother(M,C).

M = rina,

C = moshe ;

M = rina,

C = rachel ;

M = rachel,

C = yossi ;

false.

relational lp syntax rules2
Relational LP Syntax - Rules

% Signature: mother(Mum, Child),

% Purpose: Mum is a mother of Child

mother(Mum, Child) :- parent(Mum, Child), female(Mum).

“Find a two-different-kids mother”

?- mother(M,C1),mother(M,C2),C1\=C2.

M = rina,

C1 = moshe,

C2 = rachel ;

M = rina,

C1 = rachel,

C2 = moshe ;

false.

relational lp syntax rules3
Relational LP Syntax - Rules

the ancestor relationship - a recursive rule that computes the transitive closure of the parent relationship.

% Signature: ancestor(Ancestor, Descendant)/2

% Purpose: Ancestor is an ancestor of Descendant.

ancestor(Ancestor, Descendant) :-

parent(Ancestor, Descendant).

ancestor(Ancestor, Descendant) :-

parent(Ancestor, Person),

ancestor(Person, Descendant).

  • Variables occurring in the rule body and not in the head are existentially quantified.

"for all Ancestor and for all Descendant, ancestor(Ancestor, Descendant) if there exists some Person such that parent(Ancestor, Person) and ancestor(Person, Descendant)."

relational lp syntax rules4
Relational LP Syntax - Rules

the ancestor relationship - a recursive rule that computes the transitive closure of the parent relationship.

% Signature: ancestor(Ancestor, Descendant)/2

% Purpose: Ancestor is an ancestor of Descendant.

ancestor(Ancestor, Descendant) :-

parent(Ancestor, Descendant).

ancestor(Ancestor, Descendant) :-

parent(Ancestor, Person),

ancestor(Person, Descendant).

?- ancestor(rina,D).

D = moshe ;

D = rachel ;

D = yossi ;

false.

relational lp syntax rules5
Relational LP Syntax - Rules

the ancestor relationship - a recursive rule that computes the transitive closure of the parent relationship.

% Signature: ancestor(Ancestor, Descendant)/2

% Purpose: Ancestor is an ancestor of Descendant.

ancestor(Ancestor, Descendant) :-

parent(Ancestor, Descendant).

ancestor(Ancestor, Descendant) :-

parent(Ancestor, Person),

ancestor(Person, Descendant).

?- ancestor(A,yossi).

A = rachel ;

A = rina ;

false.

  • The reported result/functionality depends on the variables and their location in the query.
relational lp syntax rules6
Relational LP Syntax - Rules

ancestor1(Ancestor, Descendant) :-

parent(Ancestor, Descendant).

ancestor1(Ancestor, Descendant) :- ancestor1(Person, Descendant),

parent(Ancestor, Person).

?- ancestor1(A,yossi).

A = rachel ;

A = rina ;

ERROR: Out of local stack

?- ancestor1(rina,yossi).

true ;

ERROR: Out of local stack

  • This procedure is not tail recursive.
  • Since this query cannot be answered using the base case, new similar queries are infinitely created.
slide29
Note

Facts can be considered as rules with an empty body.

For example,

parent(rina, moshe).

parent(rina, moshe):- true.

have equivalent meaning.

true - is the zero-arity predicate.

concrete syntax of relational logic programming
Concrete syntax of Relational Logic Programming

<program> -> <procedure>+

<procedure> -> (<rule> | <fact>)+ with identical predicate and arity

<rule> -> <head> ’: -’ <body>’.’

<fact> -> <head>’.’

<head> -> <atomic-formula>

<body> -> (<atomic-formula>’,’)* <atomic-formula>

<atomic-formula> -> <constant> | <predicate>’(’(<term>’,’)* <term>’)’

<predicate> -> <constant>

<term> -> <constant> | <variable>

<constant> -> A string starting with a lower case letter.

<variable> -> A string starting with an upper case letter.

<query> -> ’?-’ (<atomic-formula>’,’)* <atomic-formula> ’.’

summary rlp semantic and syntax
Summary - RLP Semantic and syntax

parent(rina, moshe).

parent(rina, rachel).

parent(rachel, yossi).

parent(reuven, moshe).

ancestor(Ancestor, Descendant) :- parent(Ancestor, Descendant).

ancestor(Ancestor, Descendant) :- parent(Ancestor, Person),

ancestor(Person, Descendant).

?- ancestor(A,yossi).

A = rachel ;

A = rina ;

false.

Concepts:

  • predicate symbol, individual constant symbol, axioms (facts/rules), query.

Semantics:

  • individual constant symbols - entities, axioms - relations of entities.
  • Quantification of variables (universal/existential)
  • Answers are partial substitutions to query variables (or true/false indications).
operational semantics for lp
Operational Semantics for LP

Input: a program P and a query Q

Interpreter of LP:

  • Unify - pattern matching between an atomic formula from Q and a head of some rule/fact from P.
  • Answer-query (proof-tree)- Create a proof tree. Back track from a leaf if it is a "dead end" fail leaf, or if it is a success leaf and there may be additional answers to the query.
unification
Unification

The unification operation:

two atomic formulas ==> substitution

p(3, X), p(Y, 4) ==> {X = 4, Y = 3}

p(X, 3, X), p(Y, Z, 4) ==> {X = 4, Z = 3, Y = 4}

  • substitution - a finite mapping, s, from variables to terms, such that s(X)≠X.

Examples: s={X=4, Y=4, Z=3}

{X = 4, Z = 3, U = X}, {X = 4, Z = 3, U = V }

Not substitutions:

{X = 4, Z = 3, Y = Y }, {X = 4, Z = 3, X = Y }

application of substitution
Application of Substitution

atomic formula ◦ substitution ==> atomic formula'

p(X, 3, X, W ) ◦ {X = 4, Y = 4} = p(4, 3, 4, W)

p(X, 3, X, W ) ◦ {X = 4, W = 5} = p(4, 3, 4, 5)

p(X, 3, X, W ) ◦ {X = W, W = X} = p(W, 3, W, X)

  • A unifier of atomic formulas A and B is a substitution s, such that A◦s = B◦s.
  • The unification operation returns a unifier.
  • Goal of Unify(A,B): find the most general unifier.

Unify( p(X, 3, X, W), p(Y, Z, 4, W ) ) ==> {X=4, Y=4, Z=3}

p(X, 3, X, W ) ◦ {X=4, Y=4, Z=3} = p(4, 3, 4, W )

p(Y, Z, 4, W ) ◦ {X=4, Y=4, Z=3} = p(4, 3, 4, W)

  • Less general unifiers {X = 4, Z = 3, Y = 4, W = 5}, {X = 4, Z = 3, Y = 4, W = 0}
instantiation and generalization
Instantiation and Generalization
  • An atomic formula A’ is an instance of an atomic formula A if there is a substitution s such that A◦s = A’
  • A is more general than A’ if A’ is an instance of A
most general unifier mgu
Most General Unifier (MGU)
  • mgu of atomic formulas A and B is a unifier s of A and B such that A◦s = B◦s is more general than all other instances of A and B obtained by applying a unifier
combination of substitutions
Combination of substitutions

s ◦ s'

  • s' is applied to the terms of s
  • A variable X for which s(X) is defined, is removed from the domain of s'
  • The modified s' is added to s.
  • Identity bindings are removed.

{X = Y, Z = 3, U = V } ◦ {Y = 4, W = 5, V = U, Z = X}

={X = 4, Z = 3, Y = 4, W = 5, V = U}.

disagreement set
Disagreement Set
  • The disagreement set of atomic formulas is the set of left most symbols on which the formulas disagree.

disagreement-set(p(X, 3, X, W ), p(Y, Z, 4, W )) = {X, Y }.

disagreement-set(p(5, 3, X, W ), p(5, 3, 4, W )) = {X, 4}.

unify a unification algorithm
Unify - A unification algorithm

Signature: unify(A, B)

Type: atomic-formula*atomic-formula -> a substitution or FAIL

Post-condition: result = mgu(A, B) if A and B are unifiable or FAIL, otherwise

unify examples
Unify - examples

1. unify[ p(X, 3, X, W), p(Y, Y, Z, Z) ] ==>

help[ {} ] ==>

D = {X, Y}

help[ {X = Y } ] ==>

D = {Y, 3}

help[ {X = 3, Y = 3 } ] ==>

D = {Z, 3} ]

help[ {X = 3, Y = 3, Z = 3 } ] ==>

D = {W, 3}

help[ {X = 3, Y = 3, Z = 3, W = 3 } ] ==>

{X = 3, Y = 3, Z = 3, W = 3 }

2. unify[ p(X, 3, X, 5), p(Y, Y, Z, Z) ] ==>

FAIL

properties of unify a b algorithm
Properties of unify(A, B) algorithm:
  • The algorithm always terminates.
  • Unification is a generalization of Pattern matching
  • If B does not include variables and A does not include repeated variable occurrences, the time complexity can be linear.
operational semantics for lp1
Operational Semantics for LP

Interpreter of LP:

  • Unify - pattern matching between an atomic formula from Q and a head of some rule/fact from P.
  • Answer-query (proof-tree)- Create a proof tree. Back track from a leaf if it is a "dead end" fail leaf, or if it is a success leaf and there may be additional answers to the query.
answer query an interpretation algorithm for lp
answer-query: an interpretation algorithm for LP

Input:

A query: Q = ?- Q1, ..., Qn. Each component is called goal

A program P , with numbered rules (denoted by number(R))

A goal selection policy Gsel

A rule selection policy Rsel

Output:

A set of (possibly partial) substitutions for variables of Q.

General Idea:

Repeated effort to select a goal using roles.

answer query algorithm
answer-query Algorithm
  • PT := proof-tree(make_node(Q))
  • Return {s | s ∈ labels(Success(P T ))/Q }, where Success(PT) is the set of Success nodes of P T , and labels/Q is the restriction of the substitutions in labels to the variables of Q.
proof tree current node
proof-tree(current_node)

If label(current_node) is ?- true, ..., true.

1. Mark current_node as a Success node

2. If the path from the tree root to current_node is labeled with the substitutions s1, . . . , sn, label current_node with the substitution s1 ◦ s2 ◦ . . . ◦ sn

Else 1. Select a goal G true in label(current_node) according to Gsel.

2. Rename variables in every rule and fact of P .

3. While has-next?(iterator(current_node)):

(a) Advance iterator: next(iterator(current_node))

(b) Rule selection: Starting from iterator(current_node), and according to Rsel, select a rule R = [A :- B1, ..., Bm.] such that Unify(A, G) = s' succeeds with the unifying substitution s'.

(c) Rule application: if a rule R is selected then

i. Construct a new query node by removing G, adding the body of R, and applying s' to the resulting query:

new_node = make_node([label(current_node)−G+B1,...,Bm]◦s')

ii. Add a child node and start a new proof:

add_child(current_node, < s', number(R) >, (new_node))

proof-tree(new_node)

comments about answer query
Comments about answer-query
  • Variable renaming according to depth in tree. Xi at depth i.
  • Unify(A,G), where G is the selected goal and A the head of the selected rule.
    • Let XG is a variable from G and XA a variable of A
    • Selecting XA=XG or XG=XA does not change query results.
    • Selecting XA=XG leaves the query variables in the tree.
  • The goal and rule selection decisions can affect the performance of the interpreter.
example 6 5
Example 6.5

% Signature: father(F,C)/2

parent(abraham,isaac). %1

parent(isaac, jacob). %2

parent(haran,lot). %3

parent(haran,yiscah). %4

parent(haran,milcah). %5

% Signature: male(P)/1

male(isaac). %1

male(lot). %2

% Signature: son(C, P)/2

son(X, Y) - parent(Y, X), male(X). %1

% Signature: ancestor(Ancestor, Descendant)/2

anc(Anc, Des) :- parent(Anc, Des). %1

anc(Anc, Des) :- parent(Anc, Person), %2

anc(Person, Des).

slide49

?- anc(abraham, D).

What happens if rules 1 and 2 of 'anc' are switched?

significant kinds of proof trees
Significant kinds of proof trees:
  • Finite success proof tree: A finite tree with a successful path.
  • Finite failure proof tree: A finite tree with no successful path.
  • Infinite success proof tree: An infinite tree with a successful path. In this case it is important not to explore an infinite path. For Prolog: Tail recursion is safe.
  • Infinite failure proof tree: An infinite tree with no successful path.
6 1 6 relational logic programming and structured query language sql operations
6.1.6 Relational logic programming and Structured Query Language (SQL) operations
  • RLP naturally represents structured databases (tables with static columns).
  • A procedure consisting of facts can represent a table in the database.
  • Often databases are access via elementary SQL operations such as: select, project, union, Cartesian product and join.
  • Select (rows from table r, fitting some criteria):

r1(X1, X2, X3) :- r(X1, X2, X3),

X2 \= X3.

  • Project (some columns from table r):

r1(X1, X3) :- r(X1, X2, X3).

6 1 6 relational logic programming and structured query language sql operations1
6.1.6 Relational logic programming and Structured Query Language (SQL) operations
  • Union (unite tables r and s, with identical columns):

r_union_s(X1, ..., Xn) :- r(X1, ..., Xn).

r_union_s(X1, ..., Xn) :- s(X1, ..., Xn).

  • Cartesian product (all combinations of rows from r and s):

r_X_s(X1, ..., Xn, Y1, ..., Ym) :-

r(X1, ..., Xn ),

s(Y1, ..., Ym).

  • Natural Join (join tables r and s, with mutual column X):

r_join_s(X1, ..., Xn, X, Y1, ..., Ym) :-

r(X1, ..., Xn, X ),

s(X, Y1, ..., Ym).

6 1 5 3 halting problem rlp decidability
6.1.5.3 Halting problem, RLP decidability

LRLP = {(P,Q) | P|- Q in RLP syntax}

Claim: Given a program P and a query Q, the problem "Is Q provable from P ", denoted P|- Q, is decidable.

Proof:

  • The number of terms(constants/variables) and predicates appearing in P and Q is finite.
  • Thus, the number of possible atomic formula (i.e. goals appearing in a node of the proof tree) is finite (except for renaming).
  • Let N(P,Q) be that number.
  • Then, any path that is longer than N(P,Q) is infinite. QED
  • Most programming languages are only partially decidable (recursively enumerable/TM recognizable)
6 2 logic programming
6.2 Logic Programming

typeless atomic terms, type safe

decidable

multi-directional

Prolog

LP

Relational LP

functors,

typeless composite terms, type safe

partially decidable,

multi-directional

arithmetics,

uni-directional dynamically typed,

not type safe,

system predicates (e.g. !)

6 2 1 logic programming
6.2.1 Logic Programming

A functor symbol is added to the syntax, to represent data structures.

Terms (definition):

  • constant individual symbols
  • variables
  • f(t1, . . . , tn) for terms t1, . . . , tn and a functor f.

Implications

  • additional expressiveness (composite data structures)
  • the LP language is partially decidable (recursively enumerable/TM recognizable) (in the same rank as other programming languages).
6 2 1 atomic formula in flp examples
6.2.1 Atomic formula in FLP - examples

parent(rina, Child)

p(f(f(f(g(a,g(b,c))))))

member(cube(red(X)), Lst)

terms (a constant and a variable)

predicate

predicate

a term (functorsf,g combining constants a,b,c)

predicate

terms (functors cube and red applied to variable X)

6 2 1 1 formalizing the syntax extension
6.2.1.1 Formalizing the syntax extension

<term> -> <constant> | <variable> | <composite-term>

<composite-term> -> <functor> ’(’ (<term>’,’)* <term>’)’

<functor> -> <constant>

6 2 2 1 uni cation for terms that include functors
6.2.2.1 Unification for terms that include functors
  • A substitution s is a finite mapping from variables to terms, such that s(X) does not include X.
  • Unify remains the same, except for two points:
  • Disagreement set can happen within a term

- unify(member(X,tree(X,Left,Right)) ,

member(Y,tree(9,void,tree(3,void,void))))

==> {Y=9, X=9, Left=void, Right=tree(3,void,void)}

− unify(t(X, f(a),X),

t(g(U),U,W))

==> {X=g(f(a)), U=f(a), W=g(f(a))}

6 2 2 1 uni cation for terms that include functors1
6.2.2.1 Unification for terms that include functors
  • A substitution s is a finite mapping from variables to terms, such that s(X) does not include X.
  • Unify remains the same, except for two points:

1. Disagreement set can happen within a term

2. Validation of occur check error (i.e. s(X) includes X).

− unify(t(X,f(X),X),

t(g(U),U,W))

==> fails due to occur check error! Expansion is infinite

  • Unify algorithm for LP is modified so that it fails if occur check error is found in the {X=t} substitution at the disagreement-set.
6 2 3 2 natural number arithmetic
6.2.3.2 Natural number arithmetic

Natural numbers can be represented by Church numerals: The constant zero denotes the number 0, s(0) - denotes 1, s(...s(s(0))...), n times - denotes natural number n, where s is a functor.

% Signature: natural_number(N)/1

% Purpose: N is a natural number.

natural_number(zero). %1

natural_number(s(X)) :- natural_number(X). %2

% Signature: le(X,Y)/2

% Purpose: X is less or equal Y.

le(zero, X) :- natural_number(X). %1

le(s(X), s(Z)) :- le(X, Z). %2

  • no data structure definition - definition via use.
6 2 3 2 natural number arithmetic1
6.2.3.2 Natural number arithmetic

?- le(s(s(zero)), s(s(s(s(zero))))).

true.

?- le(s(s(X)), s(s(s(s(zero))))).

X = zero ;

X = s(zero) ;

X = s(s(zero)) ;

false.

?- le(s(s(X)), s(s(s(s(Y))))).

X = Y, Y = zero ;

X = zero,

Y = s(zero) ;

X = zero,

Y = s(s(zero)) ;

X = zero,

Y = s(s(s(zero))) ...

multi-directional definition - Functionality depends on the locations of variables in the query.

slide63

substitution for first leaf to the left

{X1=zero, N=s(Z1)}{X2=Z1} {Z1=zero}= {X1=zero, N=s(zero), X2=zero, Z1=zero}

substitution for second leaf:

{X1=zero, N=s(Z1)}{X2=Z1} {Z1=s(X3)}  {X3=zero}=

{X1=zero, N=s(s(zero)), X2=s(zero), Z1=s(zero), X3=zero}

summary
Summary
  • Proof tree types
  • LP with functors
  • Unify + occur check error
6 2 3 3 lists in lp
6.2.3.3 Lists in LP
  • Lists are a primitive composite data structure.
  • Unlike non-primitive data-structure prefix notation f(t1, . . . , tn)list functor appears in infix notation.
  • Syntax

[ ] - a 0-arity functor representing the empty list.

[Head|Tail] - a 2-arity functor representing a list that is constructed from its head and its tail, where the tail is also a list.

examples
Examples
  • ?- Y = [1,2,3].
  • Y = [1, 2, 3].

?- Y=[1,2,3], X= [a,b| Y].

Y = [1, 2, 3],

X = [a, b, 1, 2, 3].

?- X = [a, b, c|[d,e,f]].

X = [a,b,c,d,e,f].

?- X=[1|t]. /* not a list */

X = [1|t].

?- X=[].

X=[].

?- X=[a|[ ]].

X = [a].

?- X = [a].

X = [a].

?- [a|[ ]] = [a].

true.

?- X= [a | [ b | [] ]].

X = [a, b].

6 2 3 3 lp lists list membership
6.2.3.3 LP lists - List membership

% Signature: member(X, List)/2

% Purpose: X is a member of List.

member(X, [X|Xs]).

member(X, [Y|Ys]) :- member(X, Ys).

% checks membership

?- member(a, [b,c,a,d]).

% takes an element from a list

?- member(X, [b,c,a,d]).

% generates a list containing b

?- member(b, Z).

6 2 3 3 lp lists list concatenation
6.2.3.3 LP lists - List concatenation

% Signature: append(List1, List2, List3)/3

% Purpose: List3 is the concatenation of List1 and List2.

append([], Xs, Xs).

append([X|Xs], Ys, [X|Zs]) :- append(Xs, Ys, Zs).

/* addition of two lists */

?- append([a,b], [c], X).

/* finds a difference between lists */

?- append(Xs, [a,d], [b,c,a,d]).

/* divides a list into two lists */

?- append(Xs, Ys, [a,b,c,d]).

slide69

append(Xs, [a,d], [b,c,a,d])

2

{Xs=[X1|Xs1], Ys1=[a,d],

X1=b

Zs1=[c,a,d]}

append(Xs1, [a,d], [c,a,d])

append([], Xs, Xs). %1

append([X|Xs], Ys, [X|Zs] ) :- append(Xs, Ys, Zs). %2

2

{Xs1=[X2|Xs2], Ys2=[a,d],

X2=c

Zs2=[a,d]}

append(Xs2, [a,d], [a,d])

2

{Xs2=[X3|Xs3], Ys3=[a,d],

X3=a

Zs3=[d]}

1

{Xs2=[], Xs3=[a,d]}

true

append(Xs3, [a,d], [d])

2

{Xs3=[X4|Xs4], Ys4=[a,d],

X4=d

Zs4=[]}

append(Xs4, [a,d], [])

fail

6 2 3 3 lp lists list concatenation1
6.2.3.3 LP lists - List concatenation

% Signature: append(List1, List2, List3)/3

% Purpose: List3 is the concatenation of List1 and List2.

append([], Xs, Xs).

append([X|Xs], Ys, [X|Zs]) :- append(Xs, Ys, Zs).

  • List prefix and suffix:

prefix(Xs, Ys) :- append(Xs, Zs, Ys).

suffix(Xs, Ys) :- append(Zs, Xs, Ys).

  • Redefine member:

member(X, Ys) :- append(Zs, [X|Xs], Ys).

  • Adjacent list elements:

adjacent(X, Y, Zs) :- append(Ws, [X,Y|Ys], Zs).

  • Last element of a list:

last(X, Ys) :- append(Xs, [X], Ys).

6 2 3 3 lp lists list reverse
6.2.3.3 LP lists - List Reverse

% Signature: reverse(List1, List2)/2

% Purpose: List2 is the reverse of List1.

reverse([], []).

reverse([H|T], R) :- reverse(T, S),

append(S, [H], R).

?- reverse([a,b,c,d],R).

R=[d,c,b,a]

?- reverse(R,[a,b,c,d]).

  • Rule body ordering impacts the performance in various directions.
slide73

reverse(RList,[a,b,c])

2

{Rlist=[H1|T1],

R1=[a,b,c]}

  • reverse(T1,S1), append(S1, [H1], [a,b,c])

2

{T1=[H2|T2], R2=S1}

1

{T1=[], S1=[]}

  • reverse(T2, S2)append(S2, [H2], S1)append(S1, [H1], [a,b,c])
  • append([], [H1], [a,b,c])

reverse([], []). %1

reverse([H|T], R) :- reverse(T, S), append(S, [H], R). %2

append([], Xs, Xs). %1

append([X|Xs], Y, [X|Zs] ) :- append(Xs, Y, Zs). %2

2

{T2=[H3|T3], R3=S2}

1

{T2=[], S2=[]}

fail

  • reverse(T3, S3)append(S3, [H3], S2) append(S2, [H2], S1)append(S1, [H1], [a,b,c])
  • append([], [H2], S1) append(S1, [H1], [a,b,c])

1

{T3=[],S3=[]}

1

{Xs1=[H2], S1=[H2]}

...

  • append([], [H3], S2) append(S2, [H2], S1)append(S1, [H1], [a,b,c])
  • append([H2], [H1], [a,b,c])

1

{Xs1=[H3], S2=[H3]}

fail

  • append([H3], [H2], S1)append(S1, [H1], [a,b,c])

...

S1=[H3,H2]

  • append([H3,H2], [H1], [a,b,c])

H3=a, H2=b, H1=c

Rlist=[c,b,a]

...

true

6 2 3 3 lp lists list reverse1
6.2.3.3 LP lists - List Reverse
  • An iterative version: uses the unification mechanism to accumulate the result in the second parameter which is returned in the base case.
  • The help procedure is global. In Prolog all procedures are global.

% Signature: reverse(List1, List2)/2

reverse(Xs, Ys):- reverse_help(Xs,[],Ys).

% Signature: reverse_help(List1, AccReversed, RevList)/2

reverse_help([ ],Ys,Ys ).

reverse_help([X|Xs], Acc, Ys ) :-

reverse_help(Xs,[X|Acc],Ys).

?- reverse([a,b,c],R).

R=[c,b,a]

?- reverse(R,[a,b,c]).

ERROR: Out of local stack

6 3 prolog
6.3 Prolog

typeless atomic terms, type safe

decidable

multi-directional definitions

Prolog

LP

RLP

functors,

typeless composite terms, type safe

partially decidable,

multi-directional definitions

arithmetics,

uni-directional procedures dynamically typed,

not type safe,

system predicates (e.g. !)

6 3 2 the cut operator pruning trees
6.3.2 The cut operator - pruning trees

The cut system predicate, denoted !, is a Prolog built-in predicate, for pruning proof trees.

  • avoiding traversing failed sub-trees.
  • eliminates wrong answers or infinite branches
6 3 2 the cut operator
6.3.2 The cut operator

For a node v, in which rule H :- B1, ...Bi, !, Bi+1, ..., Bnis applied, and having a branch to a node u, in which the current goal is !, all alternative branches splitting from nodes in the path between v (including) and node u are trimmed.

v

u

example trimming unwanted answers
Example: trimming unwanted answers

p(X) :- a(X).

p(X) :- b(X),c(X),d(X),e(X).

p(X) :- f(X).

a(1).

b(1).

b(2).

c(1).

c(2).

d(2).

e(2).

f(3).

?- p(X).

X = 1 ;

X = 2 ;

X = 3 ;

fail

example trimming unwanted answers1
Example: trimming unwanted answers

p(X) :- a(X).

p(X) :- b(X),c(X),!,d(X),e(X).

p(X) :- f(X).

a(1).

b(1).

b(2).

c(1).

c(2).

d(2).

e(2).

f(3).

?- p(X).

X = 1 ;

fail

Some answers were eliminated

example trimming unwanted answers2
Example: trimming unwanted answers

Problem domain: colored pieces, each piece has one color.

color(P, red) :- red(P).

color(P, black) :- black(P).

color(P, unknown).

red(a).

black(b).

The queries to return a single solution

?- color(a, Color).

example trimming unwanted answers3
Example: trimming unwanted answers

Eliminates wrong answers

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

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

color(P, unknown).

red(a).

black(b).

example avoiding unnecessary searches duplicate answers
Example: avoiding unnecessary searches (duplicate answers)

member(X,[X|Ys]).

member(X,[Y|Zs]) :- member(X, Zs).

Adding cut:

member(X,[X|Ys]) :- !.

member(X,[Y|Zs]) :- member(X, Zs).

?- member(5, [5, 9, 24, 17, 5, 2])).

% After one application the proof tree is complete.

?- member(9, [5, 9, 24, 17, 5, 2])).

% After 2 applications the proof tree is complete.

?- member(X, [5, 9, 24, 17, 5, 2]).

% Only one answer will be returned.

example cut implements negation
Example: cut implements negation

% Signature: not_member(Element, List)/2

% Purpose: the relation in which Element is not a member of List

not_member(_, []).

not_member(X, [Y|Ys]) :- X \= Y, not_member(X, Ys).

Alternatively,

not_member(X,Xs):- member(X,Xs),!,false.

not_member(X,Xs).

6 3 3 negation in logic programming
6.3.3 Negation in Logic Programming
  • not(X) is primitive operator for negation in Prolog.
  • Negation by failure: not(X) does not mean that X is false, it means that X can't be proven.
  • For example, with the program:

man('Adam').

woman('Eve').

?- not(man('Abel')).

true

  • We can implement not, as follows:

not(Goal) :- Goal, !, false.

not(Goal).

6 4 meta circular interpreters for lp
6.4 Meta-circular interpreters for LP
  • Based on unification and backtracking.
  • Two points of selection:

(a) Goal selection - leftmost for Prolog.

(b) Rule selection - top-to-bottom for Prolog, with backtracking to the following rules, in case of a failure.

meta interpreter version 1
Meta-Interpreter - version 1

% Signature: solve(Goal)/1

% Purpose: Goal is true if it is true when posed to the original program P.

solve( A ) :- A.

meta interpreter version 2
Meta-interpreter - version 2

% Signature: solve(Goal)/1

% Purpose: Goal is true if it is true when posed to the original program P.

solve(true) :- !.

solve( (A, B) ) :- !, solve(A), solve(B).

solve(A) :- clause(A, B), solve(B).

comments
Comments

(A,B) is a tuple.

?- X=(Y,T).

X = (Y, T).

?- (X,Y)=(A,B,C,D).

X = A,

Y = (B, C, D).

comments1
Comments

The Prolog system predicate clause, which for a query ?- clause(A,B).

selects the first program rule whose head unifies with A, and unifies B with

the rule body.

append([ ],Xs,Xs).

append([X|Xs],Y,[X|Zs]) :- append(Xs,Y,Zs).

reverse([], []).

reverse([H|T], R) :- reverse(T, S), append(S, [H], R).

?- clause(append(X,[1,2], Z), Body).

X = [], Z = [1,2], Body = true;

X = [X1|Xs1 ], Z = [X1|Zs1], Body = append(Xs1, [1,2], Zs1).

?- clause(reverse(List,RList), Body).

List = [], RList = [], Body = true ;

List = [_G513|_G514],

Body = (reverse(_G514, _G517),append(_G517, [_G513], RList)).

meta interpreter version 3
Meta-interpreter - version 3

Pre-processing – Program transformation.

Every rule A :- B1, B2, ..., Bnin program P,

is written in program P' as a fact rule(A,[B1, B2, ..., Bn]).

Program P:

member(X,[X|Xa]).

member(X,[Y|Ys]) :- member(X, Ys).

append([ ], Xs, Xs).

append([X|Xs],Ys,[X|Zs]) :- append(Xs,Ys,Zs).

reverse([], []).

reverse([H|T], R) :- reverse(T, S), append(S, [H], R).

meta interpreter version 31
Meta-interpreter - version 3

Pre-processing – Program transformation.

Every rule A :- B1, B2, ..., Bnin program P,

is written in program P' as a fact rule(A,[B1, B2, ..., Bn]).

Program P':

rule( member(X,[X|Xa]), [ ]).

rule( member(X,[Y|Ys]), [member(X,Ys)]).

rule( append([ ],Xs,Xs), [ ]).

rule( append([X|Xs],Ys,[X|Zs]), [append(Xs,Ys,Zs)]).

rule( reverse([], []), []).

rule( reverse([H|T], R), [reverse(T, S), append(S, [H], R)]).

meta interpreter version 32
Meta-interpreter - version 3

% Signature: solve(Goal)/1

% Purpose:

% Goal is true if it is true when posed to the program P.

solve(Goal) :- solve(Goal, []).

% Signature: solve(Goal, Rest_of_goals)/2

solve([ ], [ ] ).

solve([ ], [G| Goals] ) :- solve(G, Goals).

solve([A|B], Goals):- append(B,Goals,Goals1),

solve(A,Goals1).

solve(A, Goals) :- rule(A, B),

solve(B, Goals).

logic programming summary
Logic Programming Summary

Pure(relational) LP:

  • typeless
  • atomic terms, atomic formula
  • program axioms, queries
  • lexical scoping, global definitions
  • unification, build proof tree (backtracking)
  • decidability

FLP:

  • functors, composite terms
  • lists

Prolog:

  • cut!
  • meta-circular interpreters (clause, tuples/list)