Knowledge compilation languages as proof systems

In this paper, we study proof systems in the sense of Cook-Reckhow for problems that are higher in the polynomial hierarchy than coNP, in particular, #SAT and maxSAT. We start by explaining how the notion of Cook-Reckhow proof systems can be apply to these problems and show how one can twist existing languages in knowledge compilation such as decision DNNF so that they can be seen as proof systems for problems such as #SAT and maxSAT.

💡 Research Summary

The paper investigates Cook‑Reckhow proof systems for problems that lie above coNP in the polynomial hierarchy, specifically #SAT (model counting) and MaxSAT (maximum satisfiable clauses). It begins by recalling the definition of a Cook‑Reckhow proof system: a polynomial‑time computable, surjective mapping from a set of strings (certificates) to the language of interest, such that verification of a certificate can be done in polynomial time. Applying this to #SAT and MaxSAT means designing certificates that simultaneously encode a CNF formula and its exact number of solutions (or maximal number of simultaneously satisfiable clauses) and can be checked efficiently.

A naïve approach—listing all satisfying assignments and providing a resolution proof of unsatisfiability for the complement—fails because the certificate size can be exponential. To obtain succinct certificates, the authors turn to knowledge compilation, particularly decision Decomposable Negation Normal Form (dec‑DNNF). A dec‑DNNF is a directed acyclic graph where each internal node is either a decision node (testing a variable once per path) or an AND‑node whose two sub‑circuits operate on disjoint variable sets. This structure guarantees tractability of several queries: model counting (MC), clause entailment (CE), and maximal Hamming weight (HW) can all be solved in linear time in the size of the dec‑DNNF (Theorem 1). Moreover, checking whether a dec‑DNNF entails a CNF can be done by testing entailment of each clause (Corollary 1).

However, verifying that a given CNF F entails a dec‑DNNF D (i.e., F ⇒ D) is coNP‑complete (Theorem 2). This obstacle prevents direct use of arbitrary dec‑DNNFs as certificates. To overcome it, the authors introduce certified dec‑DNNF, a restricted form where every 0‑sink (representing falsity) is labeled with a clause Cα. The circuit is correct if, for any assignment τ that leads to a 0‑sink α, the clause Cα is falsified by τ. This mirrors the well‑known correspondence between regular resolution proofs and read‑once branching programs. Crucially, correctness of a certified dec‑DNNF can be checked in polynomial time (Theorem 3) by ensuring that each clause‑labelled sink is reachable only via paths that force the falsifying literal.

The authors prove that for a correct certified dec‑DNNF D, the conjunction of all its sink‑clauses, denoted F(D), logically entails D (Theorem 4). Consequently, if every clause of F(D) already appears in the original CNF F, then F entails D, and together with D ⇒ F (checked via Corollary 1) we obtain logical equivalence F ⇔ D.

Using these ingredients, the paper defines a proof system for #SAT, called kcps‑#SAT. A certificate for a CNF F with exactly k solutions consists of a correct certified dec‑DNNF D such that:

1. All clauses labeling 0‑sinks belong to F,
2. D computes the same Boolean function as F,
3. D has exactly k satisfying assignments.

Verification proceeds by (i) checking correctness of D (Theorem 3), (ii) verifying D ⇒ F and that the sink clauses are in F (Corollary 1 and the clause‑inclusion condition), which together guarantee D ⇔ F, and (iii) counting the models of D using Theorem 1 to obtain k. All steps run in time linear in the size of D and F, yielding a polynomial‑time verifiable proof system.

The authors note that many modern #SAT solvers (SharpSAT, Cachet, c2d, D4, DMC) already construct a dec‑DNNF implicitly during exhaustive DPLL‑style search. When a branch leads to a falsified clause, the corresponding 0‑sink could be labeled with that clause, turning the produced circuit into a certified dec‑DNNF without extra effort. Thus, existing tools can be extended to output formal certificates for #SAT.

For MaxSAT, the paper adopts a standard reduction: each original clause C is augmented with a fresh selector variable s_C, forming an extended formula ˜F = ⋁_{C∈F}(C ∨ ¬s_C). The maximum number of simultaneously satisfiable clauses equals the maximum number of selector variables set to true in a satisfying assignment of ˜F. Since the HW query on a dec‑DNNF is tractable (Theorem 1), a certified dec‑DNNF D that computes ˜F yields a proof system kcps‑MaxSAT. A certificate is a correct certified dec‑DNNF D whose sink clauses are among those of ˜F and that computes ˜F. Verification mirrors the #SAT case: check correctness, equivalence, and then compute the maximal Hamming weight of the selector variables. The authors are unaware of any existing MaxSAT solver that explicitly uses this approach, suggesting a new direction for solver design.

In summary, the paper makes three principal contributions:

1. It formalizes Cook‑Reckhow proof systems for #SAT and MaxSAT.
2. It introduces certified dec‑DNNF, a succinct, efficiently verifiable representation that bridges knowledge compilation and proof complexity.
3. It shows how existing model‑counting solvers already generate the underlying structures, and how a simple augmentation (labeling 0‑sinks) yields formal certificates, thereby connecting theoretical proof systems with practical algorithms.

This work deepens the relationship between knowledge compilation and proof complexity, providing a concrete, polynomial‑time verifiable proof framework for counting and optimization problems beyond NP, and opening avenues for both theoretical investigation and practical implementation in SAT‑related tooling.