Post on 18-Jan-2016
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
Logic Programming: Example 1 – logic circuits
% 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).
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
Logic Programming: Example 1 – logic circuits
% 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).
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.
Logic Programming: Example 1 – logic circuits
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
Logic Programming: Example 1 – logic circuits
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).
Logic Programming: Example 1 – logic circuits
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
{ In2=n5} Fact 3 – transistor
true
resistor(power, n2)
{ In2=n2} Fact 1 – transistor
fail fail
{ In2=n3} Fact 2 – transistor
{ In2=n5} Fact 3 – transistor
{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
tree_member (X, nil)
{X_2 = X, Y_2 = 2, Left_2 = nil, Right_2 = nil}
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}
tree_member (X, nil)
{X_2 = X, Y_2 = 3, Left_2 = nil, Right_2 = nil}
fail
tree_member (X, nil)
{X_2 = X, Y_2 = 3, Left_2 = nil, Right_2 = nil}
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