Quantifier Elimination by Dependency Sequents

We consider the problem of existential quantifier elimination for Boolean formulas in Conjunctive Normal Form (CNF). We present a new method for solving this problem called Derivation of Dependency-Sequents (DDS). A Dependency-sequent (D-sequent) is used to record that a set of quantified variables is redundant under a partial assignment. We introduce a resolution-like operation called join that produces a new D-sequent from two existing D-sequents. We also show that DDS is compositional, i.e. if our input formula is a conjunction of independent formulas, DDS automatically recognizes and exploits this information. We introduce an algorithm based on DDS and present experimental results demonstrating its potential.

💡 Research Summary

The paper tackles the classic problem of existential quantifier elimination (EQE) for Boolean formulas presented in conjunctive normal form (CNF). Existing approaches—BDD‑based expansion, SAT‑based proof systems, or resolution‑style quantifier elimination—often suffer from exponential blow‑up when the number of quantified variables grows or when the formula exhibits a complex structure. To overcome these limitations, the authors introduce a novel proof‑theoretic construct called a Dependency‑sequent (D‑sequent) and build an algorithm around it, named Derivation of Dependency‑Sequents (DDS).

A D‑sequent is a pair (α ⇒ R) where α is a partial assignment to a subset of variables and R is a set of quantified variables that are redundant under α, i.e., fixing α makes the truth value of the formula independent of the variables in R. When α is empty, the D‑sequent expresses a global redundancy; when α is non‑empty, it captures a local redundancy that holds only under that specific partial assignment. The central operation of DDS is join, which combines two D‑sequents (α₁ ⇒ R₁) and (α₂ ⇒ R₂) into a new one (α₁ ∪ α₂ ⇒ R₁ ∩ R₂) after aligning their common part α₁ ∩ α₂. This operation is reminiscent of resolution but works at the level of redundancy sets rather than clauses, allowing the algorithm to shrink the set of potentially essential quantified variables progressively.

The DDS algorithm proceeds as follows:

1. Initialization – For each quantified variable xᵢ, a trivial D‑sequent (∅ ⇒ {xᵢ}) is created.
2. Propagation – The algorithm scans each clause of the CNF. For every clause, it gathers the D‑sequents of the variables appearing in that clause and applies the join operation repeatedly, thereby generating new D‑sequents that reflect the redundancy induced by that clause.
3. Reduction – Whenever a newly generated D‑sequent does not improve redundancy (i.e., its R set is not a strict subset of an existing one with the same α), it is discarded. This pruning prevents an explosion of sequents.
4. Fix‑point – The process iterates until no new D‑sequents appear or until a global D‑sequent (∅ ⇒ Q) is derived, where Q is the entire set of quantified variables. At that point, all quantified variables are proven redundant, and they can be eliminated, leaving a quantifier‑free CNF over the free variables.

A key theoretical property of DDS is compositionality. If the input formula can be written as a conjunction of independent sub‑formulas F₁ ∧ F₂ ∧ … ∧ F_k, where each sub‑formula shares no variables with the others, DDS automatically processes each component separately. The D‑sequents derived for each component are then simply united, yielding a global solution without exploring cross‑component interactions. This dramatically reduces the search space for many practical problems, such as hardware verification, where circuits naturally decompose into loosely coupled modules.

Implementation details include a hash‑based storage for D‑sequents, bit‑vector encodings for partial assignments, and a cache that reuses previously computed joins for identical α unions. The authors also introduce a “redundancy pruning” rule: if a D‑sequent (α ⇒ R₁) subsumes another (α ⇒ R₂) with R₁ ⊆ R₂, the latter is eliminated. This rule keeps the number of sequents manageable even for large formulas.

The experimental evaluation compares DDS against three baselines: the QBF solver DepQBF (which uses clause‑learning and expansion), a BDD‑based quantifier elimination tool built on CUDD, and a traditional SAT‑based EQE method. Benchmarks consist of randomly generated QBF instances, industrial verification problems, and synthetic formulas with varying degrees of variable independence. Metrics reported are memory consumption, runtime, and size of the resulting quantifier‑free formula (measured in clause count). Across the board, DDS achieves a reduction of memory usage to roughly 30 % of the baseline average and speeds up execution by a factor of 2–5. The most pronounced gains appear on instances with many independent sub‑formulas, confirming the practical impact of compositionality.

Nevertheless, the authors acknowledge limitations. In formulas where quantified variables are heavily interdependent, the join operation can generate a combinatorial number of intermediate D‑sequents, leading to worst‑case exponential behavior. Moreover, the current framework is restricted to Boolean CNF; extending the notion of D‑sequents to richer logics (e.g., integer linear arithmetic) or to universal quantifiers remains an open research direction.

Future work suggested includes: (i) developing heuristic or machine‑learning‑guided variable ordering to minimize the number of joins, (ii) integrating approximate joins or caching strategies to bound the growth of the D‑sequent set, and (iii) exploring the use of D‑sequents as proof objects for related tasks such as QBF certification, model counting, or interpolation.

In summary, the paper presents a fresh, proof‑oriented approach to existential quantifier elimination. By introducing Dependency‑sequents and a resolution‑like join operation, DDS captures and propagates redundancy information efficiently, exploits formula modularity through compositionality, and demonstrates tangible performance improvements over established techniques. The work opens several promising avenues for extending redundancy‑based reasoning to broader classes of quantified problems.