# Partial Quantifier Elimination With Learning

## TL;DR

This paper introduces an improved Partial Quantifier Elimination algorithm that learns and reuses D-sequents, enabling more efficient verification tasks like equivalence checking and model checking.

## Contribution

The paper presents a new PQE algorithm that learns and reuses D-sequents, and proves clauses redundantly one by one, enhancing efficiency over previous methods.

## Key findings

- The new algorithm outperforms its predecessor in experiments.
- Reusing learned D-sequents improves efficiency.
- Clause-by-clause redundancy proof allows early backtracking.

## Abstract

We consider a modification of the Quantifier Elimination (QE) problem called Partial QE (PQE). In PQE, only a small part of the formula is taken out of the scope of quantifiers. The appeal of PQE is that many verification problems, e.g. equivalence checking and model checking, reduce to PQE and the latter is much easier than complete QE. Earlier, we introduced a PQE algorithm based on the machinery of D-sequents. A D-sequent is a record stating that a clause is redundant in a quantified CNF formula in a specified subspace. To make this algorithm efficient, it is important to reuse learned D-sequents. However, reusing D-sequents is not as easy as conflict clauses in SAT-solvers because redundancy is a structural rather than a semantic property. Earlier, we modified the definition of D-sequents to enable their safe reusing. In this paper, we present a PQE algorithm based on new D-sequents. It is different from its predecessor in two aspects. First, the new algorithm can learn and reuse D-sequents. Second, it proves clauses redundant one by one and thus backtracks as soon as the current target clause is proved redundant in the current subspace. This makes the new PQE algorithm similar to a SAT-solver that backtracks as soon as just one clause is falsified. We show experimentally that the new PQE algorithm outperforms its predecessor.