SLD-resolution Introduction Most general unifiers SLD-resolution Soundness Completeness.
-
Upload
zachary-eve -
Category
Documents
-
view
229 -
download
1
Transcript of SLD-resolution Introduction Most general unifiers SLD-resolution Soundness Completeness.
SLD-resolution
• Introduction
• Most general unifiers
• SLD-resolution
• Soundness
• Completeness
Proof of A = refutation of A : true (any valid formula) : false (any unsatisfiable formula)
• Fact 1– P |= A iff P { A} |=
• Fact 2– if P { A} |- then P { A} |= – supposing the inference rules are sound– ’if and only if’ if they are sound and complete
idea of ‘proof by refutation’– start from P and A – apply inference rules until is produced – if so, we know that P |= A
Refutation proofs with clauses
• Definite clauses – F can be read as F G1, ..., Gm G1, ..., Gm – ‘empty clause’
• Refutation proofs – start from P and G1,...,Gm – try to derive the ‘empty clause’ – example pp. 34-35: a sort of generalized Modus Ponens
How to automate refutations?
• G = G1, ...,Gm – select some Gi = p(t1, ..., tn) – look for clauses ‘defining’ p/n
• H B1, ..., Bk (we may have several such)
– make Gi and H syntactically identical• reason: Modus Ponens requires it find substitution (unifier) such that H = Gi • if such exists, apply it to (B1,...,Bk) and the rest of G
– new goal: ( G1, ..., B1, ..., Bk, ... Gm) – continue until G is empty (if possible)
What did we just compute?
• G: ( (G1 ... Gm)) ( G1 ... Gm) – if G lead to contradiction – then we have the conclusion that G1 ... Gm holds
• Derivation: any chain of inference steps • Refutation of G: finite derivation of falsity starting from G
– consists of k inferences with k unifications i (1 i k) (( G1 ... Gm) 1... k) was shown to be unsatisfiable – fact: p(X) is unsatisfiable iff some instance of p(X) is
• Thus: P |= (G1 ... Gm) 1 ... k 1 ... k is the counter-example or the answer to our question– if some variables are left unbound we may assume the universal
closure
Troubles in the computation
• Selections: deterministic or not? – goal literals – program clauses – unifiers
• Computations:success/fail/infinite? – dead ends (no matching clauses) – infinite number of solutions (several unifiers) – loops (p p)
Most general unifiers
• Algorithmic solution to the ‘matching’ problem– deterministic & efficient
• Vocabulary – predicate symbols & functors: constructors – atoms, terms: structures– principal symbol, direct substructures – size of a structure (# of symbols)
Unifier (definition)
• Let s1, s2 be structures and a substitution – if s1 = s2 then is a unifier of s1 and s2
• Notes – if s contains X then X and s have no unifier
• proof: size(s) > size(X) size(s) > size(X) whatever is
– unifier may leave (some) variables free
– composition of with any substitution yields another unifier
• each of them is ‘more specific’ than
Generality of unifiers
• let and be unifiers of s and t = : is more general than
– any s is an instance of s
• Note: generality is not antisymmetric …• … but the following holds
– if is more general than and vice versa then – s and s are identical up to the renaming of
variables
Most general unifier(s), mgu
• substitution is a mgu of s & t if is a unifier of s & t is more general than any other unifier of s & t
• Thm: mgus are unique up to renaming!
• mgus are the substitutions we are looking for in the matching
• problem: how to find them effectively
(yet) Some (more) terminology
• Set of equations {X1=t1,…,Xn=tn} – is in solved form iff– X1,…,Xn are distinct variables, and– none of X1,…,Xn appear in t1,…,tn
• Proposition– If E = {X1=t1,…,Xn=tn} is in solved form– then = {X1/t1,…,Xn/tn} is a mgu of E
• Definition: E1 and E2 are equivalent– both have the same set of unifiers– consequently same solutions in Herbr. interpretations
Unification algorithm
• Several implementations exist – simple O(min(size(s), size(t))) presented – with ‘occurs check’: quadratic time
• Basic ideas – if s is a variable, bind it to t (and vice versa) – if both are structures (or constants)
• principal symbols must be the same • direct substructures must unify (use recursion)
– note: bindings may ‘spread’ elsewhere in terms• same variable may have several occurrences
Our algorithm (p. 40)
• To unify s & t– try to transform {s = t} into an equivalent one in solved
form
– if this succeeds, the result gives also a mgu of s & t
– if this fails, no unifier exists
– note: constants are treated as 0-ary functors
• Theorem: Algorithm returns – the equivalent solved form of s = t
– or ‘failure’ if no such exists
Resolution rule
• Inference rule for definite clauses & goals• From
– ( (G1,...,Gi,...,Gm)) and– ( H B1,...,Bk)
• such that– Gi and H have a mgu
• derive– ( (G1,...,B1,...,Bk,...,Gm))
Procedural view
• FROM – query G and clause C
• SUCH THAT – subgoal Gi of G and the head H of C unify
• DERIVE – a new query G’ with – Gi replaced with body of C and– mgu of H and Gi applied to the result
Resolution: technicalities (i)
• Both premises universally closed – scopes of the quantifiers are disjoint
• Conclusion is universally closed – variables in the premises must be disjoint
• What to do? – rename variables in clauses before inference
– e.g. attach the # of the inference step to all variables
– allows multiple uses of the same clause• essential with recursive clauses
Resolution: technicalities (ii)
• Selection of subgoals – abstraction: assume some selection function
– a.k.a. computation rule
• SLD-resolution – Linear resolution for Definite clauses with Selection
function
– linear resolution • P1 is always the query created in the previous step
• P2 is always a program clause
Using SLD-resolution
• G0 = A1,...,Am (G0) = Ai – apply resolution to
• Ai and • a (renamed copy of a) program clause C
– construct new goal G1, then G2, ... – computations end (at some goal Gi) when
(Gi) does not unify with any clause head or• Gi = false (empty goal)
– infinite computations possible, too
Formalizing resolution proofs
• SLD-derivation– From Gi & (a copy of) Ci, determine G(i+1)– Note: Gi, & Ci determine (i+1)
• reason: mgus are unique (up to var. names) no need to state separately in derivations• including s improves the readability, though
– G(i+1) is said to be derived from Gi & Ci– Gi & Ci resolve into G(i+1)– special notation (jagged arrow, p. 44)
• Each derivation G0,...,Gn yields a computed substitution 1…n
Successful derivations
• Finite and end to the empty goal– SLD-refutation of G– answer substitution = computed substitution of a
refutation• Theorem (independence of the computation rule)
– If G has a SLD-refutation with some rule 1 then• G has one with the same answer with any other rule 2, and• the refutation ‘2’ is obtained by permuting the clauses used
in the refutation ‘1’ proof– intuitive reason
• all subgoals are selected sooner or later• same clauses are used to refute each of them
Classifying derivations
• Successful– lead to false
• Failed– lead to some goal Gi such that (Gi) does no unify with any clause head– note: it doesn’t matter if there are some other subgoals than the
selected one which unify with some clause head, we are stuck with the selected one anyway
• Infinite• Complete derivation: any of the above
– ’taken to the extreme’, continued as long as possible
SLD-trees...
• Consider alternative clauses for a selected subgoal (Gi) may unify with several clauses Gi may have several (and different) complete derivations with
rule
• SLD-trees formalize the set of all such derivations– nodes: goals (G0 at the root) – edges are labeled with the clause used in inference– descendant: the resulting new goal
• Each path represents some derivation– some may fail, some succeed, some may be infinite
• Definition 3.18.
...SLD-trees
• SLD-trees are (usually) distinct for different selection functions– Finite tree with 1 & infinite with 2 possible!
• Independence of computation rule tells that– refutations in tree T1 (using 1)– are also found in T2 (using 2)– and are permutations of the paths in T1
• Note– there may exist other failing or infinite paths for which the above
does not hold – but they don’t interest us that much anyway– it is enough that the successful derivations are found
Soundness of SLD-resolution
• Final conclusion for a give goal G– try to find a refutation of G– if found, apply the answer substitution to G
• this step is actually an additional inference rule SLD-resolution gives answers
p(X), …, empty goal, = {X/tom,…}– reasoning is sound, if P |= p(tom) – Answer = computed substitution restricted on query variables– negative answer is possible, too
• Soundness (or correctness) – Shown w.r.t. computed answer substitutions– Reason: user is not (usually) interested in individual resolution
steps, but the final answer
Soundness theorem (Clark -79)
• Let– P be a definite program a selection function a -computed answer for goal A1,…,Am
• Then– P |= ( (A1 … Am) )
• Note– Requires ‘occurs-check’ in unification– see example 3.21
Completeness theorem...
• Does SLD-resolution compute all logical consequences?– strictly speaking NOT, but practically YES, since– every correct answer is an instance of some computed answer
• Let– P, A1,…,Am, and be as before
• If– P |= (A1 … Am)
• Then– there exists a refutation of A1,…,Am with answer
• such that– (A1 … Am) is an instance of (A1 … Am)
• See Example 3.23
...Completeness theorem
• Most general unifiers are used in inference steps refutations give the most general answers
– necessity for completeness theorem to hold
• Thm. confirms only the existence of a refutation– does not tell how to find one
– in practice, we have to systematically search in the SLD-tree for the successful derivations
Search in SLD-trees
• Prolog systems– Textual ordering of clauses ordering of edges– Depth-first –search in this order– Backtrack from leaf nodes– Solutions are reported at empty leaves– Property: the above is complete for finite SLD-trees– Infinite trees infinite paths infinite search
• Breadth-first?– theoretically better– makes implementation (memory management) much more
complicated– too slow for practical applications
Proof trees
• Structural representations for SLD-derivations– like derivation trees in CF grammars
– each clause represents an elementary tree
– derivation tree = combination of elementary trees
– joint nodes labeled with • equations for clause head & corresponding body atom above
– proof tree• a complete derivation tree, i.e. all leaf nodes are constants true
Proof trees…
• Alternative view– proof tree = collection of equations (joint nodes)– consistent tree: equation set has a solved form– not all derivation trees are consistent– Note: works also in other interpretations
• i.e. no matter what the ‘equality’ stands for
• Extension: use (atomic) goals as the root– solved form = an answer for the goal
• Simplification of proof trees– apply the substitution induced by the solved form to the tree– collapse identical equations into one node– simplified tree shows (clearly) the consistence
Searching for a consistent proof tree
• Two (possibly) interleaved processes– combination of elementary trees
• given this subgoal, try out this clause
– simplification of nodes– not necessary to simplify the whole tree at once
• In which order to simplify?– construct the whole tree & check then– check while building
• check the whole set of equations when new ones are added• simplify the tree as new equations are introduced
– Prolog approach• build tree in depth-first manner• simplify immediately
Derivations and proof trees
• Many derivations may map to the same proof tree
• Clear due to the independence of computation rule– computation rule tells the order in which
equations are solved– the final result stays the same