O A procedure: a set of axioms (rules and facts) with identical signature (predicate symbol and...

1

o A procedure: a set of axioms (rules and facts) with identical signature (predicate symbol and arity).

o A logic program: a set of procedures (predicates), defining relations in the program domain.

Signature: parent (Parent, Child) /2Purpose: Parent is a parent of Child1. parent (erik, jonas).2. parent (lena, jonas).

Signature: male(Person) /1Purpose: Person is a male1. male (erik).

Signature: father (Dad, Child) /2Purpose: Dad is father of Child1. father (Dad, Child) :- parent(Dad, Child) , male (Dad).

program

axiomsrulefact

arity

procedure

predicate

The relation father holds between Dad and Child if parent holds and Dad is male

Logic Programming: Introduction

2

The prolog interpreter operates in a read-eval-print loop. Given a query, it attempts to prove it

based on the program:

o If it fails, it answers false.

o Else, if the query has no variables, it answers true.

o Else, it outputs all possible variables assignments found during proof process.

Logic Programming: Introduction

% Signature: parent (Parent, Child) /2% Purpose: Parent is a parent of Childparent (erik, jonas).parent (lena, jonas).

% Signature: male(Person) /1% Purpose: Person is a malemale (erik).

% Signature: father (Dad, Child) /2% Purpose: Dad is father of Childfather (Dad, Child) :- parent(Dad, Child), male (Dad).

? - father (X,Y).X=erik, Y=jonas

? - parent (X,jonas).X=erik ;X=lena

Next possible assignment

query

3

A program that models electronic logic circuits:o Connection points: are individual constants.

o Logic gates: are relations on the constants.

Logic Programming: Example 1 – logic circuits

An electronic logic circuit combines:o Logic gates: resistor, transistor, implement simple logic functions.

o Connection points: connects one logic gate to another, or to power or ground.

Connection point

Resistor(symmetric)

Ground

Transistor(asymmetric)

Power Power

Ground

N1

N2 N3

N4N5

% Signature: resistor(End1,End2)/2% Purpose: A resistor component connects two ends1 resistor(power, n1). 2 resistor(power, n2).3 resistor(n1, power). 4 resistor(n2, power).

% Signature: transistor (Gate, Source, Drain)/3% Purpose: …1 transistor(n2,ground,n1). 2 transistor(n3,n4,n2). 3 transistor(n5,ground,n4).

Note: In contrast resistor, the order of arguments in transistor is important. Each has a different role.

4



Reminders…

o A procedure begins with a contract.

o Constants start with lowercase characters.

o A predicate name is also a constant, which defines a relation between its arguments.

o variables start with uppercase characters (‘_’ for wildcard).

o Atomic formulas are either true, false or of the form predicate(t1 , ..., tn), ti is a term.

o A rule is a formula defining a relation that depends on certain conditions.

o A fact is an atomic formula which is unconditionally true.

% Signature: resistor(End1,End2)/2% Purpose

3 resistor(n1, power).

1 resistor(power, n1). 2 resistor(power, n2).

End1,End2

terms

5



Reminders…

o A query is a sequence of atomic formulas:

% Signature: resistor(End1,End2)/2% Purpose

3 resistor(n1, power).

1 resistor(power, n1). 2 resistor(power, n2).

“Does an X exists such that the resistor relation holds for (power, X)?”

?- resistor(power, n1),resistor(n2, power). true;false No more answers

?- resistor(power, X).X = n1 ;X = n2;false

Is there another answer?

End1,End2

6

Combining logic gates to create a “not” logic circuit:o The resistor and transistor relations are based on facts.

o The relations can be combined by a rule to determine whether or not the not_circuit

relation stands for Input and Output.


power

ground

transistor

resistor

Input

Output

7

% Signature: not_circuit(Input, Output)/2% Purpose: not logic circuit.1. not_circuit(Input, Output) :- transistor(Input, ground, Output) , 2 . resistor(power, Output).

Rule head: an atomic formula with variables Rule body

“and”

power

ground

transistor

resistor

Input

Output


Combining logic gates to create a NOT logic circuit:

?- not_circuit(X,Y).X=n2,Y=n1;false

“For all Input and Output: (Input, Output) stands in the relation not_circuit if:

• (Input, ground, Output) stand in the relation transistor and• (power, Output) stand in the relation resistor.”

8

% Signature: nand_circuit(Input1, Input2, Output)/3% Purpose: nand logic circuitnand_circuit(Input1, Input2, Output) :-

transistor(Input1, X, Output), transistor(Input2, ground, X),resistor(power, Output).


Combining logic gates to create a NAND logic circuit:

?- not_circuit(X, Y), nand_circuit(In1, In2, X).X = n2,Y = n1,In1 = n3,In2 = n5;false

Connection point

Ground

Power Power

Ground

N1

N2 N3

N4N5

9

Semantics: Unification algorithm

A program execution is triggered by a query in attempt to prove its goals:

o To find a possible proof, the answer-query algorithm is used.

o It makes multiple attempts to apply rules on a selected goal.

o This is done by applying a unification algorithm, Unify, to the rule head

and the goal.

10

Definitions:

1. binding: a non-circular expression, X=t, where X is a variable and t is a term not including X.

2. Substitution: a function from a finite set of variables to a finite set of terms (or bindings).

3. Application of a sub. S to an atomic formula A, replaces vars in A with corresponding terms in S:

S = {I=X} A = not_circuit(I, I) , A º S = not_circuit(X, X)

B = not_circuit(X,Y) , B º S = not_circuit(X, Y)

the result is an instance of A

4. Unifier: a substitution S is called a unifier of formulas A and B if A º S = B º S. For example:

S = {I=X} º {X=Y} = {I=Y, X=Y} A º S = not_circuit(Y, Y)

B º S = not_circuit(Y, Y)

Semantics: Unification algorithm

The algorithm Unify receives two atomic formulas and returns their most general unifier.

S = {J=5, X=5, Y=5} is a unifier for A and B, but not the most general one.

12

Semantics: Proof trees

Executing answer-query:

o The interpreter searches for a proof for a given query (a conjunction of goals).

o The search is done by building and traversing a proof tree where all possibilities are examined.

o The possible outcome is one of the following:

The algorithm finishes, and possible values of the query variables are given.

The algorithm finishes, but there is no proof for the query (false).

The proof attempt loops and never ends.

13

Semantics: Proof trees

The tree structure depends on Prolog's goal selection and rule selection policies:

1. Query goals (Q1,…,Qn) are at the root of the proof tree.

2. Choose current goal (atomic formula). Prolog's policy: the leftmost goal.

3. Choose current rule to prove current goal. (top to bottom program order).

4. Rename the variables in the rule and unify the rule head with the goal.

If unification succeeds:

1. A new child node is created.

2. The query for this node is the rule body.

5. A leaf may be created if the goal list is empty (success), or if the goal cannot be proven (failure).

6. Backtracking: When a leaf is reached, the search travels up to the first parent node where another

rule can be matched.

Q = ?- Q1, ..., Qn

14

resistor(End1,End2) :- resistor(power, n1). resistor(power, n2). resistor(n1, power). resistor(n2, power).

nand_circuit(In1, In2, Out)

transistor(In1, X_1, Out), transistor(In2, ground, X_1),resistor(power, Out)

transistor(In2,ground,ground),resistor(power, n1)

transistor(In2,ground,n4),resistor(power, n2)

nand_circuit(Input1,Input2,Output) :- transistor(Input1,X,Output), transistor(Input2,ground,X), resistor(power, Output).

{ In1=n2, X_1=ground, Out=n1} Fact 1 – transistor

transistor (Gate, Source, Drain) :- transistor(n2,ground,n1). transistor(n3,n4,n2). transistor(n5,ground,n4).

{ In1=n3, X_1=n4, Out=n2} Fact 2 – transistor

fail

{ In2=n3} Fact 2 – transistor

fail


true

resistor(power, n2)


fail fail



{In2=n2} Fact 1 – transistor

fail

{ Input1_1 = In1, Input2_1 = In2, Output_1 = Out }Rule 1

mgu

Semantics: Example 2 – A generated proof tree

?- nand_circuit(In1, In2, Out).

transistor(In2,ground,ground),resistor(power, n2)

{ In1=n5, X_1=ground, Out=n4} Fact 2 – transistor

a finite success tree

with one success path.

15

Semantics: proof trees

Possible types of proof trees:

o A success tree has at least one success path in it.

o A failure tree is one in which every path is a failure path.

o A proof tree is an infinite tree if it contains an infinite path.

o Otherwise, it is a finite tree.

Example:

An infinite is generated by repeatedly applying the rule p(X):-p(Y),q(X,Y) (left recursion).

To avoid the infinite path, we could rewrite the rule: p(X):- q(X,Y),p(Y) (tail recursion).

16

An example: Relational logic programming & SQL operations.

Table name: resistorSchema: End1, End2Data: (power, n1), (power, n2), (n1, power), (n2, power).

Table name: transistorSchema: Gate, Source, DrainData: (n2, ground, n1) (n3, n4, n2), (n5, ground, n4).

% Signature: res_join_trans(End1, X, Gate, Source)/4 % Purpose: Join between resistor and transistor % according to End2 of resistor and Gate of transistor. res_join_trans(End1, X, Source, Drain):-

resistor(End1,X),transistor(X, Source, Drain).

End1 = power,X = n2,Source = ground,Drain = n1 ;false.

?-res_join_trans(End1,X,Source,Drain).SQL Operation: Natural join

Semantics: Example 3 – SQL in Relational Logic Programming

o Relations may be regarded as tables in a database of facts.

o Recall the resistor and transistor relations presented earlier:

17

An example: Relational logic programming & SQL operations.Semantics: Example 3 – SQL in Relational Logic Programming

o Relations may be regarded as tables in a database of facts.

o Recall the resistor and transistor relations presented earlier:

Table name: resistorSchema: End1, End2Data: (power, n1), (power, n2), (n1, power), (n2, power).

Table name: transistorSchema: Gate, Source, DrainData: (n2, ground, n1) (n3, n4, n2), (n5, ground, n4).

X = power,Y = n1 ;X = power,Y = n2 ;X = n1,Y = power ;X = n2,Y = power ;X = power , Y = power ;

X = power,Y = n1 ;X = power,Y = n2 ;X = power, Y = power ;X = power,Y = n1;...

The resistor relation is symmetric. Therefore, we get a finite series of answers repeated an infinite number of times.

Transitive closure for the resistor relation%Signature: res_closure(X, Y)/2res_closure(X, Y) :- resistor(X, Y).res_closure(X, Y) :- resistor(X, Z), res_closure(Z, Y).

?- res_closure(X, Y).

18

% Signature: tree_member(Element,Tree)/ 2% Purpose: Checks if Element is an element of the binary tree Tree.tree_member (X,tree(X,Left,Right)).tree_member (X,tree(Y,Left,Right)):- tree_member(X,Left).tree_member (X,tree(Y,Left,Right)):- tree_member(X,Right).

Q: In the following procedure, which symbols are predicates? Which are functors?

A Functor applied to three data items.

Q: how can you tell? by their relative location in the program:• A predicate appears as an identifier of an atomic formula.• A functor is way to construct a term. A term is a part of a formula. • A functor can be nested – a predicate cannot.

NOTE: The same name may be used for both a predicate and a functor!

An example: Relational logic programming & SQL operations.Logic Programming:

o Relational logic programming has no ability to describe composite data, only atoms.

o Logic programming is equipped with functors to describe composite data.

Predicate

19

Unification is more complex with functors. Here is an execution of the Unify algorithm, step by step:

Unify(A,B) where A = tree_member (tree (X, 10, f(X)), W) ; B = tree_member (tree (Y, Y, Z), f(Z)).

Initially, s={} Disagreement-set = {X=Y} X does not occur in Y s=s {X=Y} = {X=Y}

As= tree_member (tree (X, 10, f(Y)), W )Bs= tree_member (tree (Y, Y , Z ), f(Z)) As ≠ Bs

Disagreement-set = {Y=10} s=s {Y=10} = {X=10, Y=10}

As= tree_member (tree (Y, 10, f(Y)), W )Bs= tree_member (tree (Y, Y ,Z ), f(Z)) As ≠ Bs

Disagreement-set = {Z=f(10)} s=s {Z=f(10)} = {X=10, Y=10, Z=f(10)}

As= tree_member (tree (10, 10, f(10)), W )Bs= tree_member (tree (10, 10, Z ), f(Z)) As ≠ Bs

Disagreement-set = {W=f(f(10))} s={X=10, Y=10, Z=f(10), W=f(f(10))}

As= tree_member (tree (10, 10, f(10)), W )Bs= tree_member (tree (10, 10, f(10)), f(f(10))) As ≠ Bs

As= tree_member (tree (10, 10, f(10)), f(f(10)) )Bs= tree_member (tree (10, 10, f(10)), f(f(10))) Q: Why do we check for occurence?

An example: Relational logic programming & SQL operations.Logic Programming: Unification with functors

20

A: Consider the following two atomic formulas:

A = tree_member (tree (X, Y, f(X)), X )

B = tree_member (tree (Y, Y, Z ), f(Z))

Applying Unify(A,B) will result in a loop: X=Y, Z=f(Y), Y=f(Z)=f(f(Y))…

the substitution cannot be successfully solved.

An example: Relational logic programming & SQL operations.Logic Programming: Unification with functors

21

% Signature: tree_member(Element,Tree)/ 2% Purpose: Testing tree membership, checks if Element is % an element of the binary tree Tree.tree_member (X,tree(X,Left,Right)).tree_member (X,tree(Y,Left,Right)):- tree_member(X,Left).tree_member (X,tree(Y,Left,Right)):- tree_member(X,Right).

?- tree_member(1, tree(1,nil, nil)).true

?- tree_member(2,tree(1,tree(2,nil,nil), tree(3,nil, nil))).true.

?- tree_member(1, tree(3,1, 3)).false.

?- tree_member(X,tree(1,tree(2,nil,nil), tree(3,nil, nil))).X=1;X=2;X=3;false.

An example: Relational logic programming & SQL operations.Logic Programming: Example queries

22

tree_member(X, tree(1, tree(2, nil, nil), tree(3, nil, nil)))

?- tree_member(X, tree(1, tree(2, nil, nil), tree(3, nil, nil))).

Full Logic Programming: An example proof tree

% Signature: tree_member(Element,Tree)/ 2% …tree_member (X,tree(X,Left,Right)).tree_member (X,tree(Y,Left,Right)):-

tree_member(X,Left).tree_member (X,tree(Y,Left,Right)):-

tree_member(X,Right).

{X_1 = 1, X = 1Left_1 = tree(2,nil,nil),Right_1 = tree(3, nil, nil)}

true

{X=1}

tree_member (X, tree(2,nil,nil))

{X_1 = X, Y_1 = 1, Left_1 = tree(2,nil,nil), Right_1 = tree(3, nil, nil)}

true

{X=2}

tree_member (X, nil)

{X_2 = X, Y_2 = 2, Left_2 = nil, Right_2 = nil}

fail



fail

{X_2 = 2, X = 2Left_2 = nil, Right_2 = nil}

{X_1 = X, Y_1 = 1, Left_1 = tree(2,nil,nil), Right_1 = tree(3, nil, nil)}

tree_member (X, tree(3,nil,nil))

true

{X=3}



fail



fail

{X_2 = 3, X = 3 Left_2 = nil, Right_2 = nil}

23

% Signature: tree_member(Element,Tree)/ 2% Purpose: Testing tree membership, checks if Element is % an element of the binary tree Tree.tree_member (X,tree(X,Left,Right)).tree_member (X,tree(Y,Left,Right)):- tree_member(X,Left).tree_member (X,tree(Y,Left,Right)):- tree_member(X,Right).

?- tree_member(1, T).T = tree(1, _G445, _G446) ;T = tree(_G444, tree(1, _G449, _G450), _G446) ;T = tree(_G444, tree(_G448, tree(1, _G453, _G454), _G450), _G446) ;...

o Looking for all trees in which 1 is a member, we get an infinite success tree with partially instantiated answers (containing variables).

o We use a rule that requires a defined input, but our input is a variable. Possible answers are generated by the proof algorithm.

o In this case we call the rule a generator rule.

Full Logic Programming: An example proof tree

O A procedure: a set of axioms (rules and facts) with identical signature (predicate symbol and...

Documents

Transcript of O A procedure: a set of axioms (rules and facts) with identical signature (predicate symbol and...