Hubbry Logo
Resolution (logic)Resolution (logic)Main
Open search
Resolution (logic)
Community hub
Resolution (logic)
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Resolution (logic)
Resolution (logic)
from Wikipedia

In mathematical logic and automated theorem proving, resolution is a rule of inference leading to a refutation-complete theorem-proving technique for sentences in propositional logic and first-order logic. For propositional logic, systematically applying the resolution rule acts as a decision procedure for formula unsatisfiability, solving the (complement of the) Boolean satisfiability problem. For first-order logic, resolution can be used as the basis for a semi-algorithm for the unsatisfiability problem of first-order logic, providing a more practical method than one following from Gödel's completeness theorem.

The resolution rule can be traced back to Davis and Putnam (1960);[1] however, their algorithm required trying all ground instances of the given formula. This source of combinatorial explosion was eliminated in 1965 by John Alan Robinson's syntactical unification algorithm, which allowed one to instantiate the formula during the proof "on demand" just as far as needed to keep refutation completeness.[2]

The clause produced by a resolution rule is sometimes called a resolvent.

Resolution in propositional logic

[edit]

Resolution rule

[edit]

The resolution rule in propositional logic is a single valid inference rule that produces a new clause implied by two clauses containing complementary literals. A literal is a propositional variable or the negation of a propositional variable. Two literals are said to be complements if one is the negation of the other (in the following, is taken to be the complement to ). The resulting clause contains all the literals that do not have complements. Formally:

where

all , , and are literals,
the dividing line stands for "entails".

The above may also be written as:

Or schematically as:

We have the following terminology:

  • The clauses and are the inference's premises
  • (the resolvent of the premises) is its conclusion.
  • The literal is the left resolved literal,
  • The literal is the right resolved literal,
  • is the resolved atom or pivot.

The clause produced by the resolution rule is called the resolvent of the two input clauses. It is the principle of consensus applied to clauses rather than terms.[3]

When the two clauses contain more than one pair of complementary literals, the resolution rule can be applied (independently) for each such pair; however, the result is always a tautology.

Modus ponens can be seen as a special case of resolution (of a one-literal clause and a two-literal clause).

is equivalent to

A resolution technique

[edit]

When coupled with a complete search algorithm, the resolution rule yields a sound and complete algorithm for deciding the satisfiability of a propositional formula, and, by extension, the validity of a sentence under a set of axioms.

This resolution technique uses proof by contradiction and is based on the fact that any sentence in propositional logic can be transformed into an equivalent sentence in conjunctive normal form.[4] The steps are as follows.

  • All sentences in the knowledge base and the negation of the sentence to be proved (the conjecture) are conjunctively connected.
  • The resulting sentence is transformed into a conjunctive normal form with the conjuncts viewed as elements in a set, S, of clauses.[4]
    • For example, gives rise to the set .
  • The resolution rule is applied to all possible pairs of clauses that contain complementary literals. After each application of the resolution rule, the resulting sentence is simplified by removing repeated literals. If the clause contains complementary literals, it is discarded (as a tautology). If not, and if it is not yet present in the clause set S, it is added to S, and is considered for further resolution inferences.
  • If after applying a resolution rule the empty clause is derived, the original formula is unsatisfiable (or contradictory), and hence it can be concluded that the initial conjecture follows from the axioms.
  • If, on the other hand, the empty clause cannot be derived, and the resolution rule cannot be applied to derive any more new clauses, the conjecture is not a theorem of the original knowledge base.

One instance of this algorithm is the original Davis–Putnam algorithm that was later refined into the DPLL algorithm that removed the need for explicit representation of the resolvents.

This description of the resolution technique uses a set S as the underlying data-structure to represent resolution derivations. Lists, Trees and Directed Acyclic Graphs are other possible and common alternatives. Tree representations are more faithful to the fact that the resolution rule is binary. Together with a sequent notation for clauses, a tree representation also makes it clear to see how the resolution rule is related to a special case of the cut-rule, restricted to atomic cut-formulas. However, tree representations are not as compact as set or list representations, because they explicitly show redundant subderivations of clauses that are used more than once in the derivation of the empty clause. Graph representations can be as compact in the number of clauses as list representations and they also store structural information regarding which clauses were resolved to derive each resolvent.

A simple example

[edit]

In plain language: Suppose is false. In order for the premise to be true, must be true. Alternatively, suppose is true. In order for the premise to be true, must be true. Therefore, regardless of falsehood or veracity of , if both premises hold, then the conclusion is true.

Resolution in first-order logic

[edit]

Resolution rule can be generalized to first-order logic to:[5]

where is a most general unifier of and , and and have no common variables.

Example

[edit]

The clauses and can apply this rule with as unifier.

Here x is a variable and b is a constant.

Here we see that

  • The clauses and are the inference's premises
  • (the resolvent of the premises) is its conclusion.
  • The literal is the left resolved literal,
  • The literal is the right resolved literal,
  • is the resolved atom or pivot.
  • is the most general unifier of the resolved literals.

Informal explanation

[edit]

In first-order logic, resolution condenses the traditional syllogisms of logical inference down to a single rule.

To understand how resolution works, consider the following example syllogism of term logic:

All Greeks are Europeans.
Homer is a Greek.
Therefore, Homer is a European.

Or, more generally:

Therefore,

To recast the reasoning using the resolution technique, first the clauses must be converted to conjunctive normal form (CNF). In this form, all quantification becomes implicit: universal quantifiers on variables (X, Y, ...) are simply omitted as understood, while existentially-quantified variables are replaced by Skolem functions.

Therefore,

So the question is, how does the resolution technique derive the last clause from the first two? The rule is simple:

  • Find two clauses containing the same predicate, where it is negated in one clause but not in the other.
  • Perform a unification on the two predicates. (If the unification fails, you made a bad choice of predicates. Go back to the previous step and try again.)
  • If any unbound variables which were bound in the unified predicates also occur in other predicates in the two clauses, replace them with their bound values (terms) there as well.
  • Discard the unified predicates, and combine the remaining ones from the two clauses into a new clause, also joined by the "∨" operator.

To apply this rule to the above example, we find the predicate P occurs in negated form

¬P(X)

in the first clause, and in non-negated form

P(a)

in the second clause. X is an unbound variable, while a is a bound value (term). Unifying the two produces the substitution

Xa

Discarding the unified predicates, and applying this substitution to the remaining predicates (just Q(X), in this case), produces the conclusion:

Q(a)

For another example, consider the syllogistic form

All Cretans are islanders.
All islanders are liars.
Therefore all Cretans are liars.

Or more generally,

X P(X) → Q(X)
X Q(X) → R(X)
Therefore, ∀X P(X) → R(X)

In CNF, the antecedents become:

¬P(X) ∨ Q(X)
¬Q(Y) ∨ R(Y)

(The variable in the second clause was renamed to make it clear that variables in different clauses are distinct.)

Now, unifying Q(X) in the first clause with ¬Q(Y) in the second clause means that X and Y become the same variable anyway. Substituting this into the remaining clauses and combining them gives the conclusion:

¬P(X) ∨ R(X)

Factoring

[edit]

The resolution rule, as defined by Robinson, also incorporated factoring, which unifies two literals in the same clause, before or during the application of resolution as defined above. The resulting inference rule is refutation-complete,[6] in that a set of clauses is unsatisfiable if and only if there exists a derivation of the empty clause using only resolution, enhanced by factoring.

An example for an unsatisfiable clause set for which factoring is needed to derive the empty clause is:

Since each clause consists of two literals, so does each possible resolvent. Therefore, by resolution without factoring, the empty clause can never be obtained. Using factoring, it can be obtained e.g. as follows:[7]

Non-clausal resolution

[edit]

Generalizations of the above resolution rule have been devised that do not require the originating formulas to be in clausal normal form.[8][9][10][11][12][13]

These techniques are useful mainly in interactive theorem proving where it is important to preserve human readability of intermediate result formulas. Besides, they avoid combinatorial explosion during transformation to clause-form,[10]: 98  and sometimes save resolution steps.[13]: 425 

Non-clausal resolution in propositional logic

[edit]

For propositional logic, Murray[9]: 18  and Manna and Waldinger[10]: 98  use the rule

,

where denotes an arbitrary formula, denotes a formula containing as a subformula, and is built by replacing in every occurrence of by ; likewise for . The resolvent is intended to be simplified using rules like , etc. In order to prevent generating useless trivial resolvents, the rule shall be applied only when has at least one "negative" and "positive"[14] occurrence in and , respectively. Murray has shown that this rule is complete if augmented by appropriate logical transformation rules.[10]: 103 

Traugott uses the rule

,

where the exponents of indicate the polarity of its occurrences. While and are built as before, the formula is obtained by replacing each positive and each negative occurrence of in with and , respectively. Similar to Murray's approach, appropriate simplifying transformations are to be applied to the resolvent. Traugott proved his rule to be complete, provided are the only connectives used in formulas.[12]: 398–400 

Traugott's resolvent is stronger than Murray's.[12]: 395  Moreover, it does not introduce new binary junctors, thus avoiding a tendency towards clausal form in repeated resolution. However, formulas may grow longer when a small is replaced multiple times with a larger and/or .[12]: 398 

Propositional non-clausal resolution example

[edit]

As an example, starting from the user-given assumptions

the Murray rule can be used as follows to infer a contradiction:[15]

For the same purpose, the Traugott rule can be used as follows :[12]: 397 

From a comparison of both deductions, the following issues can be seen:

  • Traugott's rule may yield a sharper resolvent: compare (5) and (10), which both resolve (1) and (2) on .
  • Murray's rule introduced 3 new disjunction symbols: in (5), (6), and (7), while Traugott's rule did not introduce any new symbol; in this sense, Traugott's intermediate formulas resemble the user's style more closely than Murray's.
  • Due to the latter issue, Traugott's rule can take advantage of the implication in assumption (4), using as the non-atomic formula in step (12). Using Murray's rules, the semantically equivalent formula was obtained as (7), however, it could not be used as due to its syntactic form.

Non-clausal resolution in first-order logic

[edit]

For first-order predicate logic, Murray's rule is generalized to allow distinct, but unifiable, subformulas and of and , respectively. If is the most general unifier of and , then the generalized resolvent is . While the rule remains sound if a more special substitution is used, no such rule applications are needed to achieve completeness.[citation needed]

Traugott's rule is generalized to allow several pairwise distinct subformulas of and of , as long as have a common most general unifier, say . The generalized resolvent is obtained after applying to the parent formulas, thus making the propositional version applicable. Traugott's completeness proof relies on the assumption that this fully general rule is used;[12]: 401  it is not clear whether his rule would remain complete if restricted to and .[16]

Paramodulation

[edit]

Paramodulation is a related technique for reasoning on sets of clauses where the predicate symbol is equality. It generates all "equal" versions of clauses, except reflexive identities. The paramodulation operation takes a positive from clause, which must contain an equality literal. It then searches an into clause with a subterm that unifies with one side of the equality. The subterm is then replaced by the other side of the equality. The general aim of paramodulation is to reduce the system to atoms, reducing the size of the terms when substituting.[17]

Implementations

[edit]

See also

[edit]

Notes

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia
from Grokipedia
In , resolution is a fundamental designed for in both propositional and , enabling the derivation of new from pairs of clauses containing complementary literals. Introduced by John Alan Robinson in 1965, it combines substitution and truth-functional analysis into a single, machine-oriented principle that facilitates refutation proofs by generating the empty clause from unsatisfiable sets of . In propositional logic, resolution operates on ground by simply removing a pair of complementary literals (such as PP and ¬P\neg P) to form a resolvent clause, while in , it incorporates unification to match literals across clauses with variables, ensuring applicability to quantified formulas. The method's soundness guarantees that all derived clauses are logical consequences of the original set, while its completeness ensures that, given sufficient computational resources, it can detect unsatisfiability in any contradictory clause set, making it a cornerstone of clausal logic. Robinson's formulation addressed limitations in prior approaches, such as the Davis-Putnam procedure, by providing a more efficient, complete calculus that avoids exhaustive instantiation and supports practical implementation in theorem provers. Over time, resolution has evolved with refinements like ordered resolution and hyper-resolution to mitigate , enhancing efficiency in saturation-based proving strategies. Resolution's significance extends to and , underpinning logic programming languages like —where it drives —and serving as the basis for modern SAT solvers and systems used in , knowledge representation, and deductive databases. Its refutation-complete nature has enabled breakthroughs in proving complex theorems, such as those in and , by mechanizing logical deduction at scale. Despite challenges like undecidability in full , resolution remains a pivotal technique, with ongoing research focusing on optimizations and integrations with for hybrid proving.

Propositional Logic

Resolution Rule

In propositional logic, clauses are represented as disjunctions of literals, where a literal is either a propositional atom pp or its ¬p\neg p. The resolution rule is a binary inference rule that takes two such clauses containing complementary literals—a literal LL and its ¬L\neg L—and derives a single resolvent clause by removing the complementary pair and combining the remaining disjunctions. Formally, given clauses (AB)(A \lor B) and (¬AC)(\neg A \lor C), where AA is a literal and BB and CC are disjunctions of literals (possibly empty), the rule infers the resolvent (BC)(B \lor C): (AB), (¬AC)(BC)(A \lor B),\ (\neg A \lor C) \vdash (B \lor C) This resolvent is unique and obtained by resolving away the complementary literals AA and ¬A\neg A, ensuring no duplication of literals in the resulting clause. Semantically, the resolution rule is sound: if the two clauses are satisfied under some interpretation, then the resolvent is also satisfied. Equivalently, the rule preserves unsatisfiability in that if a set of clauses containing the parents is unsatisfiable, then the set augmented with the resolvent remains unsatisfiable. This follows from the validity of the inference, as assuming the resolvent false leads to a contradiction in at least one parent under any truth assignment.

Proof Procedure

The resolution proof procedure in propositional logic operates as a refutation system, aimed at demonstrating the unsatisfiability of a set of clauses derived from a and the of a query . To establish that a KBKB entails a ϕ\phi (denoted KBϕKB \models \phi), the procedure first negates ϕ\phi and incorporates it into KBKB, then seeks to derive a contradiction in the form of the empty . This method leverages the resolution rule to systematically generate new clauses until either the empty is produced—proving unsatisfiability and thus entailment—or the set of clauses reaches saturation, meaning no further resolutions are possible, indicating . The procedure begins with converting the formulas in KB{¬ϕ}KB \cup \{\neg \phi\} to clausal normal form, which is a conjunction of disjunctions of literals (clauses). This involves multiple steps: first, transform each formula to (NNF) by eliminating implications (ABA \rightarrow B becomes ¬AB\neg A \vee B), equivalences (ABA \leftrightarrow B becomes (AB)(BA)(A \rightarrow B) \wedge (B \rightarrow A)), and pushing negations inward using (e.g., ¬(AB)\neg (A \wedge B) becomes ¬A¬B\neg A \vee \neg B) while removing double negations (¬¬A\neg \neg A becomes AA); second, distribute disjunctions over conjunctions to achieve (CNF), such as converting A(BC)A \vee (B \wedge C) to (AB)(AC)(A \vee B) \wedge (A \vee C). If the conversion yields the empty clause directly, the set is unsatisfiable, corresponding to ϕ\phi being a tautology. The resulting clauses form the initial set SS, from which the iterative resolution process proceeds: repeatedly select pairs of clauses containing complementary literals (a literal and its ), apply the resolution rule to derive a new clause by combining the remaining literals, and add it to SS until the empty clause appears or saturation is reached. Resolution derivations are structured as trees or directed acyclic graphs (DAGs), where leaf nodes represent initial clauses from SS, internal nodes denote resolvents derived from their parent clauses via resolution, and the root is the empty if a refutation exists. Each derived expands the proof space, with the search space encompassing all possible resolvents generatable from SS; this space is finite for propositional logic but can grow exponentially in the number of literals, necessitating efficient implementation in automated provers. The procedure typically employs binary resolution, where each inference step resolves exactly two clauses, though strategies like linear resolution— which chains resolutions sequentially from a single path of ancestors—can prune the search space for more directed proofs.

Example

To illustrate resolution in propositional logic, consider a refutation proof to show that the knowledge base consisting of PQP \lor Q, PRP \to R, and QRQ \to R entails RR. The clausal normal form of the knowledge base is:
  • Clause 1: PQP \lor Q
  • Clause 2: ¬PR\neg P \lor R
  • Clause 3: ¬QR\neg Q \lor R
The negation of the goal RR is ¬R\neg R, which in clausal form is:
  • Clause 4: ¬R\neg R
The resolution procedure proceeds as follows, deriving the empty clause, which confirms the entailment (since the augmented set is unsatisfiable).
  1. Resolve 1 (PQP \lor Q) and 2 (¬PR\neg P \lor R).
    The complementary literals are PP and ¬P\neg P.
    Resolvent ( 5): QRQ \lor R.
  2. Resolve 5 (QRQ \lor R) and 3 (¬QR\neg Q \lor R).
    The complementary literals are QQ and ¬Q\neg Q.
    Resolvent ( 6): RR.
  3. Resolve Clause 6 (RR) and Clause 4 (¬R\neg R).
    The complementary literals are RR and ¬R\neg R.
    Resolvent: \square (empty clause).
This derivation demonstrates how successive binary resolutions on ground clauses eliminate literals step by step until a contradiction is reached, proving the query without needing variables or unification. The resolution sequence can be visualized as a tree:
  • Root: Clauses 1, 2, 3, 4
    • Branch 1: Resolve 1 and 2 → Clause 5
      • Branch 2: Resolve 5 and 3 → Clause 6
        • Branch 3: Resolve 6 and 4 → \square

First-Order Logic

Clausal Normal Form

In first-order logic, a clause is defined as a disjunction of literals, where each literal is either an atomic formula or the negation of an atomic formula, and the variables in the clause are implicitly universally quantified. This representation allows clauses to serve as the fundamental units for resolution-based inference, treating variables as universally closed to ensure the formula holds for all interpretations of those variables. The universal closure of a formula, obtained by prefixing universal quantifiers over all free variables, is essential prior to transformation, as it guarantees the resulting clauses capture the full semantic content without existential commitments beyond Skolemization. To transform a into clausal normal form (CNF), which is a conjunction of clauses, the process follows a of syntactic equivalences. First, negate the formula if proving unsatisfiability (for refutation), eliminate implications by replacing PQP \rightarrow Q with ¬PQ\neg P \vee Q, and remove equivalences by rewriting PQP \leftrightarrow Q as (PQ)(QP)(P \rightarrow Q) \wedge (Q \rightarrow P). Next, apply by pushing negations inward using and quantifier dualities, such as ¬xϕx¬ϕ\neg \forall x \, \phi \equiv \exists x \, \neg \phi and ¬(ϕψ)¬ϕ¬ψ\neg (\phi \wedge \psi) \equiv \neg \phi \vee \neg \psi. Then, achieve by moving all quantifiers to the front, renaming variables to avoid clashes during the process. Following prenex form, Skolemize to eliminate existential quantifiers: replace each existentially quantified variable with a Skolem constant (if no enclosing universals) or a Skolem function depending on the preceding universal variables, ensuring the formula's is preserved. Drop the remaining universal quantifiers, as variables are understood to be universally bound. Finally, convert to CNF by distributing conjunctions over disjunctions, yielding a set of clauses such as {P(x)¬Q(y),R(z)}\{ P(x) \vee \neg Q(y), R(z) \}. In propositional logic, this reduces to the special case without quantifiers or Skolem functions. The Herbrand interpretation plays a crucial role in the semantics of clausal normal form by providing a ground-based framework for evaluating . For a set of clauses over a , the Herbrand universe consists of all ground terms constructible from the constants and functions, while the Herbrand base is the set of all ground atoms over this ; an interpretation is then a subset of the base assigning truth values to ground atoms. This grounds the variable-containing clauses by considering all possible instantiations, enabling resolution's completeness via Herbrand's theorem, which equates unsatisfiability of the clauses to the absence of a Herbrand model.

Unification

In first-order logic, unification is the process of finding a substitution that makes two terms or literals syntactically identical. This substitution replaces variables with terms, enabling the matching of expressions that differ only in their variable bindings. Unification is crucial for handling variables in resolution-based inference, allowing generalization over specific instances. A substitution σ\sigma is a most general unifier (mgu) of two terms ss and tt if applying σ\sigma makes sσ=tσs\sigma = t\sigma, and every other unifier τ\tau of ss and tt satisfies τ=σρ\tau = \sigma \circ \rho for some substitution ρ\rho. The mgu is unique up to variable renaming and represents the most general way to unify the terms without introducing unnecessary specializations. For example, consider unifying the terms f(x,g(y))f(x, g(y)) and f(a,g(b))f(a, g(b)), where aa and bb are constants; the mgu is {x/a,y/b}\{x/a, y/b\}, as it substitutes xx with aa and yy with bb to yield f(a,g(b))f(a, g(b)) for both. If the second term were f(a,b)f(a, b) with bb a constant (arity 0), unification would fail due to the arity mismatch between g(y)g(y) (arity 1) and bb. The unification algorithm, introduced by Robinson, operates on a set of disagreement pairs and builds the mgu incrementally through three main operations: decomposition, elimination, and occur-check. It can be described recursively as follows:
  • Base cases: If both terms are identical constants or the same variable, they unify with the empty substitution. If one is a variable not occurring in the other term, substitute the other term for the variable.
  • Decomposition: If both terms are applications of the same function symbol ff with the same arity, recursively unify corresponding arguments.
  • Elimination: Apply the current substitution to simplify terms by replacing variables with their bindings.
  • Occur-check: If a variable xx is to be unified with a term tt containing xx, fail to prevent infinite structures (e.g., x=f(x)x = f(x)).
A pseudocode outline of the recursive unification function unify(s, t) (returning the mgu or failure) is:

function unify(s, t): if s == t: return {} if is_variable(s): if occurs(s, t): return fail return {s: t} if is_variable(t): if occurs(t, s): return fail return {t: s} if functor(s) != functor(t) or [arity](/page/Arity)(s) != [arity](/page/Arity)(t): return fail σ = {} for i in 1 to [arity](/page/Arity)(s): σ_i = unify(arg_i(s), arg_i(t)) if σ_i == fail: return fail σ = compose(σ, apply(σ_i, σ)) return σ

function unify(s, t): if s == t: return {} if is_variable(s): if occurs(s, t): return fail return {s: t} if is_variable(t): if occurs(t, s): return fail return {t: s} if functor(s) != functor(t) or [arity](/page/Arity)(s) != [arity](/page/Arity)(t): return fail σ = {} for i in 1 to [arity](/page/Arity)(s): σ_i = unify(arg_i(s), arg_i(t)) if σ_i == fail: return fail σ = compose(σ, apply(σ_i, σ)) return σ

This algorithm terminates in linear time for terms and succeeds the terms are unifiable. Terms are unifiable if there exists a substitution making them identical, which requires matching function symbols, arities, and avoiding cycles in variable occurrences. For instance, f(x)f(x) and g(y)g(y) are not unifiable because ff and gg are distinct function symbols. Conversely, p(x,y)p(x, y) and p(z,a)p(z, a) unify with mgu {x/z,y/a}\{x/z, y/a\} ( renaming). In resolution for , the mgu plays a central role by being applied to the parent before deriving the resolvent, ensuring that complementary literals match after substitution. This step generalizes the propositional resolution rule to handle variables, allowing proofs by refutation in clausal form.

Factoring and Resolution

In first-order resolution, factoring is an inference rule that eliminates redundancy in a by unifying and collapsing repeated literals of the same polarity. Specifically, given a CLMC \vee L \vee M, where LL and MM are literals that unify with most general unifier (mgu) σ\sigma, the factored (CL)σ(C \vee L)\sigma is derived. This step ensures that contain at most one instance of each unifiable literal before resolution, preventing the generation of trivial or duplicate resolvents. For example, the P(x)P(y)P(x) \vee P(y) factors to P(x)P(x) under the substitution {y/x}\{ y / x \}. The resolution rule in extends the propositional version by incorporating unification to handle variables. Given two C1=ALC_1 = A \vee L and C2=B¬LC_2 = B \vee \neg L', where LL and LL' are literals that unify with mgu σ\sigma, the resolvent clause (AB)σ(A \vee B)\sigma is inferred, provided factoring has been applied to C1C_1 and C2C_2 first to standardize the literals. This binary inference combines the remaining disjuncts after substituting variables to make the resolved literals complementary, enabling refutation proofs through repeated applications until the empty clause is derived. Unification, as a prerequisite, finds the most general substitution that equates terms, distinguishing first-order resolution from its propositional counterpart. Ordered resolution refines the basic rule to improve by restricting inferences based on a well-founded term ordering >> and literal selection. In this variant, resolution occurs only if the literal LL in the first is maximal with respect to >> among all atoms in that , and no selected atoms appear in its non-resolved part; similarly, ¬L\neg L' must be selected (or maximal if none are) in the second . Literal selection is defined by a function SS that assigns to each a (possibly empty) of its negative literals, guiding the prover to resolve primarily on these to reduce the search space while preserving completeness. Unlike propositional resolution, which operates on ground clauses without variables and thus requires no unification or factoring, first-order resolution demands these mechanisms to manage variable instantiations and avoid redundant inferences from non-ground clauses. Factoring addresses literal repetition arising from variable differences, while unification enables across terms, making the method complete for first-order unsatisfiability.

Example

To illustrate resolution in first-order logic, consider a refutation proof for the goal yQ(f(z),y)\exists y \, Q(f(z), y) given the knowledge base consisting of P(f(z))P(f(z)) and x(P(x)Q(x,b))\forall x \, (P(x) \to Q(x, b)). The clausal normal form of the knowledge base is:
  • Clause 1: P(f(z))P(f(z))
  • Clause 2: ¬P(x)Q(x,b)\neg P(x) \lor Q(x, b)
The negation of the goal is y¬Q(f(z),y)\forall y \, \neg Q(f(z), y), which in clausal form (with variable yy standardized apart) yields:
  • Clause 3: ¬Q(f(z),y)\neg Q(f(z), y)
The resolution procedure proceeds as follows, applying unification to complementary literals and deriving the empty clause, which confirms the goal (since the augmented set is unsatisfiable).
  1. Resolve 3 (¬Q(f(z),y)\neg Q(f(z), y)) and 2 (¬P(x)Q(x,b)\neg P(x) \lor Q(x, b)).
    The complementary literals are Q(x,b)Q(x, b) and ¬Q(f(z),y)\neg Q(f(z), y).
    The most general unifier (MGU) is θ={x/f(z),y/b}\theta = \{x / f(z), y / b\}.
    Applying θ\theta to the remaining literal in 2 yields ¬P(f(z))\neg P(f(z)).
    Resolvent ( 4): ¬P(f(z))\neg P(f(z)).
  2. Resolve 4 (¬P(f(z))\neg P(f(z))) and 1 (P(f(z))P(f(z))).
    The complementary literals are P(f(z))P(f(z)) and ¬P(f(z))\neg P(f(z)).
    The MGU is the empty substitution θ={}\theta = \{\}.
    Applying θ\theta yields no remaining literals.
    Resolvent: \square (empty ).
This derivation demonstrates how unification with the substitution {x/f(z),y/b}\{x / f(z), y / b\} allows the universal quantifier in the implication to generalize over the complex term f(z)f(z), while instantiating the (negated) existential yy in the goal to the specific constant bb provided by the , enabling resolution beyond ground (propositional-like) instances. Unlike propositional resolution, variables and substitutions handle nested structures like function applications, capturing relational dependencies across the . No factoring was required here, as no contained duplicate literals needing contraction. The resolution sequence can be visualized as a :
  • : Clauses 1, 2, 3
    • 1: Resolve 2 and 3 → Clause 4
      • 2: Resolve 1 and 4 → \square

Variants

Non-Clausal Resolution

Non-clausal resolution is an inference method in that operates directly on arbitrary quantifier-free formulas without requiring their transformation into clausal normal form (CNF). Unlike standard resolution, which resolves complementary literals within , non-clausal resolution identifies and resolves positive and negative occurrences of subformulas across formulas, enabling deductions while preserving the original structural complexity. This approach was introduced as a complete theorem-proving procedure for predicate , allowing inferences on unnormalized expressions to maintain . The core of non-clausal resolution is embodied in its binary inference rule: given two formulas ABA \to B and ¬BC\neg B \to C, where BB is a subformula, the resolvent ACA \to C is derived, with appropriate unification if variables are involved in settings. This rule preserves , as the resolvent follows from the premises under classical semantics. Seminal work formalized this as a refutation-complete , integrating simplification steps to handle complex connectives like implications and disjunctions without normalization. A key advantage of non-clausal resolution lies in circumventing the exponential growth in formula size that often accompanies conversion to CNF, particularly for formulas with nested implications or large disjunctive structures. This can lead to more compact proof representations and reduced computational overhead in automated theorem proving for certain problem classes. In practice, it facilitates direct manipulation of input formulas, avoiding the loss of structural information inherent in clausal forms. Non-clausal resolution generalizes clausal resolution by treating clauses as a special case where subformulas are literals, thereby simulating standard binary resolution while permitting broader inferences on non-literal expressions. This flexibility supports more direct proof constructions in scenarios where clausal transformation is inefficient or obscures logical relationships.

Paramodulation

Paramodulation is an inference rule designed to extend resolution-based theorem proving to logics with equality, allowing the efficient handling of equational axioms without expanding them into numerous instances. Introduced by Robinson and Wos, it enables the substitution of terms based on equality facts to derive new clauses that propagate equalities throughout the proof process. The formal paramodulation rule operates on two clauses: an equational clause CstC \vee s \approx t, where ss and tt are terms, and a clause DAD \vee A, where AA is an atom containing the non-variable subterm uu. If there exists a substitution σ\sigma such that sσ=uσs\sigma = u\sigma, the resulting paramodulant clause is CσDσA[tσ]C\sigma \vee D\sigma \vee A[t\sigma]. This rule implicitly applies equality axioms like replacement and congruence, unifying the left-hand side of the equality with a target subterm to replace it with the right-hand side. Paramodulation relies on unification to find the most general unifier σ\sigma for the matching step. To integrate paramodulation with standard resolution and mitigate the of inferences, ordered paramodulation imposes restrictions using a well-founded term ordering >>. Specifically, inferences are limited to cases where the right-hand side t>st > s (or oriented accordingly), and substitution occurs only into maximal positions within selected literals of the target clause, ensuring that derived clauses are strictly smaller than their premises and discarding redundant ones. This ordering simplifies clauses during the proof search and enhances completeness in refutational settings by focusing on irreducible forms. Paramodulation plays a central role in reasoning within equational theories, such as those involving arithmetic (e.g., with equality constraints) or term rewriting systems, where it facilitates the orientation and completion of equations to compute normal forms or decide . For instance, in Knuth-Bendix completion procedures, ordered paramodulation generates critical pairs to build confluent rewrite systems from given equalities. In contrast to standard resolution, which derives new clauses by unifying and eliminating complementary literals to detect contradictions, paramodulation emphasizes term replacement along equality paths, enabling the explicit manipulation of equalities to simplify or normalize expressions rather than solely negating literals.

Properties

In resolution-based theorem proving, ensures that the inference rules derive only logically valid conclusions from given . The core states that every resolvent is a of its parent clauses, and thus if a set of is unsatisfiable, any set of resolvents derived from them is also unsatisfiable. For propositional resolution, soundness can be established by considering the possible assignments in a model. Given two clauses C1=LCC_1 = L \vee C' and C2=¬LDC_2 = \neg L \vee D', where LL is a literal and CC', DD' are disjunctions of other literals, suppose a model MM satisfies both premises. If MM assigns true to LL, then MM must satisfy DD' (since C2C_2 holds), implying MM satisfies the resolvent CDC' \vee D'. Conversely, if MM assigns false to LL, then MM satisfies CC' (from C1C_1), again implying MM satisfies the resolvent. Thus, every model of the premises is a model of the resolvent. This result extends to through the use of Herbrand models and substitutions. In a Herbrand interpretation, ground instances of clauses are evaluated, and resolution preserves because unification ensures that resolvents are instances of logical consequences under any substitution. Specifically, if a set of clauses has a Herbrand model, the resolvents inherit this property, as the inference rule maintains validity across substitutions without introducing new ground atoms that violate the model. For variants of resolution, soundness is similarly preserved with adaptations to their semantics. Non-clausal resolution, which operates on general formulas rather than clauses, maintains implication preservation by using verifiers (such as \bot and \top) in the inference rule, ensuring that resolvents are entailed by the premises in classical . Paramodulation, an extension for handling equality, preserves congruence under equality by simulating resolution on equality axioms; a paramodulant from clauses involving an equality s=ts = t is valid because it corresponds to substituting tt for ss in a way that upholds the model's equivalence classes for equal terms.

Completeness

Resolution is refutationally complete for propositional logic, meaning that if a set of clauses in (CNF) is unsatisfiable, repeated application of the resolution rule will derive the empty clause. This completeness follows from the fact that propositional resolution can systematically enumerate all possible resolvents, and for finite unsatisfiable sets, the empty clause is inevitably reached. Herbrand's theorem provides the foundational link, implying that unsatisfiability in propositional CNF corresponds to the derivability of the empty clause via resolution, as the Herbrand expansion reduces to the propositional case. In , resolution achieves completeness through a two-step argument: first, ground resolution is complete for s of ground s, deriving the empty clause from any unsatisfiable set; second, this ground completeness is lifted to the full setting via unification, which allows matching of non-ground terms to simulate ground instances. J. A. Robinson established this in his seminal 1965 paper, proving that a of s is unsatisfiable some finite number of resolutions yields the empty clause, relying on the to bound the relevant ground instances. Despite this theoretical completeness, resolution does not guarantee termination, even for unsatisfiable sets in , due to the potentially infinite search space from variable instantiations and resolvent generation. For propositional logic, however, the finite nature of formulas ensures termination as a decision procedure. To address non-termination in practice while preserving completeness, strategies such as the set-of-support restriction are employed, which limit resolutions to involve at least one clause from a designated "support" set (typically the negation of the goal), ensuring that all complete proofs remain derivable. Variants of resolution maintain completeness under specific conditions. Non-clausal resolution, which operates directly on formulas without full CNF conversion, is complete when using ordered resolution with an admissible selection function and saturation up to , allowing on non-Horn clauses while preserving refutational power. Similarly, paramodulation extends resolution to equational logic and is complete for refuting unsatisfiable sets in the presence of equality axioms, provided an ordering on terms ensures termination of critical pair computations and saturation techniques eliminate redundant .

Applications

Automated Theorem Proving

Resolution plays a central role in by enabling refutation-based procedures that check the unsatisfiability of clause sets, thereby verifying theorems in both propositional and . In systems, resolution derives new clauses from existing ones until either a contradiction (the empty ) is reached, confirming unsatisfiability, or all possible inferences are exhausted, indicating . This process supports of logical entailments and is foundational to many decidability procedures in . In propositional logic, resolution underlies the core mechanisms of SAT solvers, such as the Davis–Putnam–Logemann–Loveland (DPLL) algorithm and its modern extensions like conflict-driven clause learning (CDCL). Unit propagation in DPLL corresponds to unit resolution, where a single-literal clause forces the assignment of complementary literals in other clauses, efficiently pruning the search space. For first-order logic, SMT solvers integrate resolution in their propositional abstraction layers, combining it with theory-specific reasoning to handle quantifiers and background theories like arithmetic or arrays, allowing scalable checks of satisfiability in richer domains. To enhance efficiency, resolution employs strategies like unit resolution, which restricts inferences to unit clauses; input resolution, which limits resolutions to involve at least one original input clause; and locking resolution, which assigns directional "locks" to literals to prevent redundant inferences and enforce ordering. These strategies reduce the inference space while preserving completeness under certain conditions. Resolution-based theorem proving finds applications in , where it proves properties of programs by encoding them as logical clauses and checking for contradictions; in , by reducing planning problems to theorem proving tasks that derive action sequences; and in hardware , through SAT-based bounded model checking that uses resolution to explore state transitions. Key challenges include the of clauses during , which can lead to exponential time and , and the necessity for literal ordering to prioritize relevant inferences and avoid trivial paths. Techniques like ordered resolution mitigate these by selecting only maximal literals for resolution, but scaling to large problems remains computationally intensive.

Implementations

Prover9 is an automated theorem prover for and equational logic that implements resolution and paramodulation as its primary inference mechanisms. Developed as a successor to the prover, it supports ordered resolution strategies and handles equality through paramodulation, enabling efficient proof search in clausal form. is a high-performance theorem prover for that employs resolution combined with superposition, an ordered variant of paramodulation for handling equality. It uses saturation-based strategies with literal selection heuristics to prioritize inferences, achieving strong results in competitions. In the propositional domain, MiniSat is a compact that relies on unit propagation, a process akin to unit resolution, to simplify formulas by assigning values to variables in single-literal clauses. This technique, integrated with , allows MiniSat to generate resolution-based proofs for unsatisfiability. Glucose, an extension of MiniSat, enhances propositional SAT solving through advanced clause learning while preserving unit propagation inspired by resolution principles. It introduces a scoring mechanism to retain "glue clauses" during search, improving efficiency on crafted and application benchmarks. Resolution techniques are integrated into interactive proof assistants to automate propositional subgoals. In Isabelle/HOL, SAT solvers like zChaff or MiniSat generate resolution-style proofs that are verified within the system, enabling reliable discharge of tautologies. Similarly, Coq's SMTCoq plugin interfaces with external SAT solvers, checking resolution proofs from tools like CVC4 to certify propositional decisions. Post-2020 advancements incorporate to optimize selection in resolution-based provers. The ENIGMA framework in has been enhanced with recursive neural networks for layered classification, improving proof search on SMT-LIB problems by up to 41%. applies to guide inferences in saturation provers, solving over 1,500 problems from corpora while approaching state-of-the-art performance. As of 2025, continued to excel, winning all eight categories in the CADE ATP System Competition (CASC-32), demonstrating ongoing advancements in resolution-based proving. Recent works, such as EvolProver (2025) using evolutionary algorithms for in proof search and Goedel-Prover (2025), a achieving state-of-the-art in generation, highlight hybrid approaches integrating resolution with AI techniques.

References

Add your contribution
Related Hubs
User Avatar
No comments yet.