resolution strategies one common strategy for applying resolution is called level saturation. here...
TRANSCRIPT
Resolution Strategies
One common strategy for applying resolution is
called level saturation. Here you try to resolve
every pair of clauses from the original set, thus
generating a new set of clause. The next step is
trying to resolve every new clause against every
new clause and every original clause, generating
another new set. Then try to resolve those new
clauses against themselves and the previous
clauses.
Restrictions of Resolution
Several ways to restrict the possible resolutions are:Unit resolution – one of the two clauses resolved
upon must be a unit clause (a single literal)Input resolution – one of the two clauses resolved
upon must be from the original set of clausesLinear resolution – after the first resolution step,
one of the two clauses resolved upon must be the
last clause generate.
These restrictions are sound, but not complete. Why?
Subsumption
One strategy that is complete is subsumption. On
clause subsumes another (in proposition calculus) if
it is a subset of the other clause. As we are trying to
obtain the empty clauses, smaller clauses are better.
So, if a clause subsumes another clauses, that other
clause may be eliminated. This works in both the
forward direction (a new clause is subsumed by and
old clause) and the backward direction (an old
clause is subsumed by a new clause).
Predicate Calculus
Resolution also works for the predicate calculus, but
is more complicated (of course!). In particular,
reducing a formula to a clause set requires more
work, and we have to pay attention to the murder
rule.
Prenex Form
(From Chang and Lee, Symbolic Logic and
Mechanical Theorem Proving)
Prenex form occurs when the quantifiers all occur to
the left of the formula, that is a formula of the form
(Q1 x
1) (Q
2 x
2) (Q
3 x
3) (M), where Q
1, Q
2, Q
3, ... are
either ∀ or ∃, and M is a quantifier-free formula,
called the matrix.
Prenex Form (cont'd)
To put a formula into prenex form, we do the
following steps:1. Get rid of -> and <-> by using the equivalences F
<->G = (F -> G) ^ (G -> F) and F -> G = ~F v G.2. Push ~ in to the atoms by using the equivalences
~~F = F, ~(F v G) = ~F ^ ~G, ~(F ^ G) = ~F v ~G.3. Rename bound variables if necessary.4. Move the quantifiers to the outside.
Moving Quantifiers to the Outside
We use the following equivalences:(Q x) F(x) v G = (Q x) (F(x) v G)(Q x) F(x) ^ G = (Q x) (F(x) ^ G(∀ x) F(x) ^ (∀ x) H(x) = (∀ x) (F(x) ^ H(x))(∃ x) F(x) v (∃ x) H(x) = (∃ x) (F(x) v H(x))(Q1 x) F(x) v (Q2 x) H(x) = (Q1 x) (Q2 z) (F(x) v H(z))(Q1 x) F(x) ^ (Q2 x) H(x) = (Q1 x) (Q2 z) (F(x) ^ H(z))
Skolem Standard Form
To achieve Skolem Standard form, we do the
following;Transform the formula into prenex normal form.Put the matrix into conjunctive normal form (CNF).Eliminate the existentially quantified variables by
using Skolem functions (and constants)Drop the universal quantifiers as only universally
quantified variables remain.
Skolem Functions
Consider the formula (∀ x) (∃ y) x >= y. That is, for
every x, there is some y less than x. If that's the
case, we could create a function smaller(x) that,
given an x, returns some number smaller than x.
There are many such functions, by the formula
guarantees that one exists. Consider the formula (∀
x) x >= smaller(x). These two formulas are not
equivalent under an interpretation (why?) but one is
unsatisfiable iff the other is unsatisfiable (why?)
Skolem Functions (cont'd)
We can replace each existentially quantified variable
by a new Skolem function whose arguments are all
the universally quantified variable to the left of its
quantifier – as those are the values that the
existentially quantified variable depends on. If there
are no universally quantified variables to the left,
we replace the variable by a function of no
arguments, or a constant. Once we have no
existentially quantified variables, we drop the ∀'s.
Resolution
The resolution procedure for predicate calculus is a
refutation procedure. The steps are:Negate the formulaPut the formula into Skolem Standard form (which
requires putting it into prenex for first)Write the formula as a set of clausesUse the resolution rule repeatedly to find the empty
clause (box) if possible.
Binary Resolution Rule
The resolution rule for predicate calculus is a bit
more complicated because of the presence of
variables. Two literals don't have to be exactly the
same, but rather could unify. The binary resolution
rule corresponds to the marriage rule: If C
1 and C
2 are two clauses with no variables in common and L
1 and
L2 are two literals in C
1 and C
2, respectively, where L
1 and ~L
2 have
the mgu σ, then the clause (σ(C1)-σ(L
1) U (σ(C
1)-σ(L
1) is the binary
resolvent of C1 and C
2.
Factors
For propositional calculus, the murder rule simply
means that the clauses are sets. For predicate
calculus, since we have variables, we must deal
with the case when two (or more) literals in a single
clause unify:
If two (or more) literals (with the same sign) of a
clause C have an mgu σ, then σ(C) is called a factor
of C.
Resolution Rule for Pred. Calc.
Remembering that a murder may only occur the night
before a wedding, we now have the (full) resolution
rule:
A resolvent of two clauses C1 and C
2 is a binary
resolvent of C1 or a factor of C
1 and C
2 or a factor of
C2.
Resolution Procedure
Resolution is sound and complete.
Many of strategies used in propositional calculus
resolution apply to predicate calculus (with
modification).Level saturation is the same.A clause C
1 subsumes a clause C
2 iff there is a
substitution σ such that σ(C1) ⊆ C
2. The deletion
strategy used this new definition of subsumption.Unit, input, and linear resolution are the same.
Other Strategies - Definitions
Definitions: A clause is called positive is it does not
contain any negative literals. A clause is called
negative if it does not contain any negative literals.
A clause is called mixed if it is neither positive nor
negative.
Positive Hyperresolution
In positive hyperresolution, a single step is a series of
resolution steps between a nucleus, (a negative or
mixed clause) and several electrons (positive
clauses). The result must be a positive clause, i.e.,
the electrons must knock out all the negative literals
in the nucleus. Example: R(x) v R(a), S(x), ~R(a) v
~S(a) -> □.
Negative Hyperresolution
Negative Hyperresolution is just like positive
hyperresolution except that the nucleus is positive
or mixed and the electrons are negative clauses.
Set of Support Resolution
A subset T of a set of clauses S is called a set of
support if S – T is satisfiable. For example, given a
theorem with hypothesis and a conclusion, the
hypotheses are normally satisfiable, so T could be
the clauses formed by the conclusion. A set-of-
support resolution is one in which both parent
clauses are not from S – T. A set-of-support
deduction is one where every resolution is a set-of-
support resolution.
Automated Theorem Provers
Otter – Argonne National Lab, McCuneProver9 - McCuneSETHEO – Technical University of MunichE-SETHEO - TUMVampire- Manchester University, Voronkov
Users of Automated Thm. Proving
Mathematical ProofProof-checkingProgram VerificationQuestion AnsweringGeneral ReasoningCombine with other Reasoning Modules
Horn Clauses
A Horn clause is a restricted predicate calculus
formula of formP1 ^ P
2 ^ P
3 ^ ... P
n -> Q
or justQ
The formulas Pi and Q must be positive literals.
Queries
Given a set of Horn clauses (the hypotheses) and a
query (the conclusion) , we can easily check if the
query is true.A ^ B ^ C -> DB -> CAEA ^ E -> B------------------------D
Proof
One systematic way is to keep a stack of goals yet to
be proved. Begin by pushing the conclusion (D) on
the stack. While the stack is not empty, pop the
stack to get the current goal. If a fact (atomic
clause) matches the goal, return T. If not, search for
an implication whose right-hand side matches the
goal, and then push all the conjuncts from the left-
hand side onto the stack (if not already there).
Example
D (conclusion)A B C (matches first clause)B C (A is a fact)A E C (matches fifth clause)E C (A is a fact)C (E is a fact)B (matches second clause)A E (matches fifth clause)E (A is a fact) (E is a fact)
Resolution
Alternatively we could use resolution. Written as a
clause set (with the conclusion negated) we have:~A v ~B v ~C v D~B v CAE~A v ~E v B~D
A restricted form of resolution called LUSH or SLD
works fine for these sets.
Lists
We can add a list constructor to this language:
[] means the empty list, and cons(x,y) means the list
with first element x and the remainder is y (so x is
added to the beginning of list y). We can use
standard list notation as shorthand for our lists. So,
the list cons(a, cons(b, cons(c, []))) would be
written [a,b,c]. We also use the vertical bar (|) with
brackets to be shorthand for cons – [x|y] means
cons (x,y).
Statements about Lists
We can use this notation to define list operations:
member(x, [x | y])member(x, z) -> member(x, [y | z])
means that x is a member of a list which has x as its
head, and if x is a member z, then x is a member of
the list constructed by adding y to the head of z.
Sorting
What does it mean if one list is the sorted version of
another list? For example, consider [3,1,4,2] and
[1,2,3,4]. The both must have the same members,
and the second list must be in order. We assume
that we have predicates for the usual mathematical
relations such as <=. So, to state that a list is in
order we could say:
Same Elements
To check if two lists have exactly the same member
is a little more complicated. To state this property,
we use a three argument member predicate which
removes the member of the list, i.e.,member(x, y, z)
means that x is a member of y and that z is the result
of removing (one instance of) x from y.
So member(3,[1,2,3,4],[1,2,4]) is true.
Same Elements (cont'd)
member(x, [x | y], y)member(x, y, z) -> member(x, [w | y], [w | z])
sameElements([], [])sameElements(y, z), member(x, w, z) -> sameElements([x | y], w)
Sorting
sameElements(x,y) ^ inOrder(y) -> sorted(x,y)sameElements([], [])sameElements(y, z), member(x, w, z) -> sameElements([x | y], w)member(x, [x | y], y)member(x, y, z) -> member(x, [w | y], [w | z])inOrder([y | z])^(x <= y)->inOrder([x, y | z])inOrder([])inOrder([x])
Prolog
sorted(L1,L2) :- sameElements(L1,L2), inOrder(L2).
inOrder([X,Y|L]) :- X =< Y, inOrder([Y|L]).inOrder([]).inOrder([_]).
sameElements([],[]).sameElements([X|L1],L2) :- sameElements(L1,L3), member(X,L2,L3).
member(X,[X|L],L).member(X,[Y|L],[Y|L1]) :- member(X,L,L1).