Clause Cuts: Structure & Applications

• Clause cuts are operations that exploit clause structure in logical systems to optimize search, proof maintenance, and constraint solving.
• They are applied in contexts such as CDCL SAT solving, MILP for MaxSAT, and proof theory to control clause deletion, retention, and scheduling.
• These methods yield performance gains by balancing hard elimination with soft prioritization and by decomposing global reasoning into local, manageable tasks.

Clause cuts are operations that exploit clause structure to restrict search, strengthen relaxations, or modularize reasoning. Across the literature, the expression appears in several non-identical senses: deletion or retention of learnt clauses in CDCL, cuts in implication or conflict graphs that induce learned clauses, analytically restricted cuts in proof theory, linear cuts derived from implied CNF clauses for MILP, and clause-local decompositions that avoid monolithic global operators (Cai et al., 24 Feb 2026, Beame et al., 2011, Ciabattoni et al., 2023, Engelhardt et al., 25 Sep 2025, Tulsi, 2015). The common theme is that clause-level structure is treated as an explicit control surface rather than as a passive encoding artifact.

1. Scope of the notion

In SAT and MaxSAT, clause cuts usually refer to decisions about which clauses are kept, deleted, learned, or converted into valid inequalities. In theorem proving and proof theory, the same expression is closest to cuts determined by clause- or formula-level structure, including conflict-graph cuts, plural cuts, and cut restrictions to analytic formulas. In model checking and related systems, the term is most naturally associated with maintaining a clause frontier between layers or frames. This suggests a family resemblance rather than a single standardized definition.

Context	Operative object	Function
CDCL and preprocessing	Learnt or redundant clauses	Delete, retain, or simplify clauses
Clause learning	Cut in a conflict graph	Generate a learned clause
Proof theory	Cut formula or plural cut graph	Restrict or analyze proof structure
MILP for MaxSAT	Clause-implied inequality	Tighten the LP relaxation

A recurrent distinction is between hard elimination and soft prioritization. Some methods remove clauses outright, as in covered clause elimination or blocked clause elimination. Others leave clauses available but reduce their scheduling frequency, as in layered clause selection for theory reasoning. A second recurrent distinction is between explicit clauses already present in a CNF and implied clauses that are not written in the input but are logically entailed and can still be exploited as cuts (Heule et al., 2010, Gleiss et al., 2020, Engelhardt et al., 25 Sep 2025).

2. Clause cuts in SAT, MaxSAT, and counting

In CDCL SAT solving, clause cuts are a central performance mechanism because every conflict may generate a new learnt clause, while unbounded growth increases memory usage, watch-list size, Boolean Constraint Propagation cost, and conflict-analysis overhead. The mainstream metric for clause quality has long been Literal Block Distance, defined as the number of distinct decision levels among the literals of a clause. For complex arithmetic circuit verification, especially multipliers, the 2026 rethinking paper reports that LBD effectively collapses into clause length, so clause reduction ceases to capture dynamic usefulness. Its replacement is a two-stage LBD-free policy. Each learnt clause $c$ receives $score(c)\gets 1$ on creation, is incremented whenever it participates in BCP or conflict analysis, and is aged every $T$ conflicts by $score(c)\gets \max\{0,score(c)-1\}$. At reduction time, Stage 1 keeps all clauses with positive score and forms the zero-score pool $\mathcal{Z}=\{c\mid score(c)=0\}$; Stage 2 sorts $\mathcal{Z}$ by descending clause length and deletes a dynamic fraction of that pool. On multiplier instances, the paper reports for kissat $56\to 60$ solved and PAR-2 $2841.65\to 1724.01$, and for MiniSat $15\to 29$ solved with speedups up to $5.74\times$ (Cai et al., 24 Feb 2026).

A different line treats clause cuts as satisfiability-preserving simplifications of CNF itself. Covered Clause Elimination generalizes blocked clause elimination by computing, for a clause $score(c)\gets 1$0 and literal $score(c)\gets 1$1, the resolution-candidate set

$score(c)\gets 1$2

and the resolution intersection

$score(c)\gets 1$3

Covered literal addition repeatedly augments $score(c)\gets 1$4 by such intersections until fixpoint, yielding $score(c)\gets 1$5; $score(c)\gets 1$6 is covered if $score(c)\gets 1$7 is blocked. This gives CCE, together with HCCE and ACCE by combining covered literal addition with hidden or asymmetric literal addition. The paper proves that CCE is confluent and that CCE, HCCE, and ACCE are respectively more effective than BCE, HBCE, and ABCE (Heule et al., 2010).

For projected model counting, ordinary blocked clause elimination is unsound because it may change the number of models. The 2024 paper shows that if a non-tautological clause $score(c)\gets 1$8 is blocked by a literal $score(c)\gets 1$9 with $T$0, then

$T$1

so the projected count is preserved. The implementation maintains protectedTriple objects of the form $T$2, together with a watch structure that tracks whether some active witness clause still prevents $T$3 from being blocked. Integrated into d4, dynamic BCE improves $T$4 solved instances for baseline d4 to $T$5 for d4+BCE_i, while memory outs drop from $T$6 to $T$7 (Lagniez et al., 2024).

In MILP formulations of MaxSAT, Clause Cuts are linear inequalities obtained from clauses logically implied by a CNF. For a clause $T$8, the associated clause inequality is

$T$9

If $score(c)\gets \max\{0,score(c)-1\}$0, that inequality is valid for the CNF-constrained binary feasible set. The paper uses LP-integral variables as assumptions for a SAT solver; when the induced partial assignment is infeasible, the corresponding no-good cut

$score(c)\gets \max\{0,score(c)-1\}$1

is strengthened by minimizing the unsatisfiable core or by exploiting clauses learned by CDCL. Two separation procedures are introduced: ICCA, based on the integral part of the LP solution, and LCCA, based on learned clauses. On SATLIB benchmarks, the method yields speedups of up to two orders of magnitude relative to Gurobi 12, takes only $score(c)\gets \max\{0,score(c)-1\}$2 of Gurobi’s runtime on the full set, and $score(c)\gets \max\{0,score(c)-1\}$3 of RC2’s runtime (Engelhardt et al., 25 Sep 2025).

3. Conflict-graph cuts and learned clauses

In clause learning, the closest exact formal object to a clause cut is a cut in a conflict graph. An implication graph is a directed acyclic graph whose nodes are decision and implied literals; a conflict graph is a subgraph containing $score(c)\gets \max\{0,score(c)-1\}$4, exactly one conflict variable, and only nodes that have a path to $score(c)\gets \max\{0,score(c)-1\}$5. The paper states that one may pick any cut that has all decision variables on the reason side and $score(c)\gets \max\{0,score(c)-1\}$6 together with at least one conflict literal on the conflict side. The reason-side frontier then determines a cause of the conflict, and negating those frontier literals yields the associated conflict clause (Beame et al., 2011).

This viewpoint unifies several standard learning schemes. Decision learning, rel-sat, and UIP-based schemes differ only by which cut they select in the same conflict graph. The paper also introduces FirstNewCut, which starts from a cut whose conflict side contains $score(c)\gets \max\{0,score(c)-1\}$7 and a conflict literal, then moves the cut backward only until the minimized associated clause is not already known. The learned clause always has a trivial resolution derivation from known clauses, so conflict-graph cuts and resolution derivations are directly linked (Beame et al., 2011).

At proof-complexity level, the same work defines clause learning as a proof system $score(c)\gets \max\{0,score(c)-1\}$8 and relates it to resolution. It proves that $score(c)\gets \max\{0,score(c)-1\}$9 using FirstNewCut can yield exponentially shorter proofs than tree-like, regular, and Davis–Putnam resolution, and that a slight variant $\mathcal{Z}=\{c\mid score(c)=0\}$0 with unlimited restarts is polynomially equivalent to general resolution. In that sense, cut selection in conflict graphs is not merely a heuristic engineering detail; it controls the strength of clause learning as a proof system (Beame et al., 2011).

4. Scheduling, prioritization, and clause frontiers

Not all clause cuts are deletions. In saturation-based theorem proving with explicit theory axioms, the issue is often overexposure to theory-heavy derivations rather than permanent redundancy. The layered clause-selection paper proposes a soft search-control mechanism based on nested multi-split queues. Given a feature $\mathcal{Z}=\{c\mid score(c)=0\}$1 and cutoffs $\mathcal{Z}=\{c\mid score(c)=0\}$2 with $\mathcal{Z}=\{c\mid score(c)=0\}$3, it defines nested groups

$\mathcal{Z}=\{c\mid score(c)=0\}$4

selected with frequency $\mathcal{Z}=\{c\mid score(c)=0\}$5. For theory reasoning, the feature is

$\mathcal{Z}=\{c\mid score(c)=0\}$6

where $\mathcal{Z}=\{c\mid score(c)=0\}$7 and $\mathcal{Z}=\{c\mid score(c)=0\}$8 count theory and total axioms in the ancestry of $\mathcal{Z}=\{c\mid score(c)=0\}$9. Clauses are not deleted; they are deprioritized when their derivations are too theory-heavy. On a filtered SMT-LIB benchmark set, configurations such as layered4 improve refutations from $\mathcal{Z}$0 to $\mathcal{Z}$1 (Gleiss et al., 2020).

In IC3/PDR, the relevant clause cut is the frontier between consecutive frames. A clause $\mathcal{Z}$2 can be pushed from $\mathcal{Z}$3 to $\mathcal{Z}$4 if

$\mathcal{Z}$5

equivalently if

$\mathcal{Z}$6

is UNSAT. The triggered pushing method stores, after a failed push, a witness state $\mathcal{Z}$7 satisfying $\mathcal{Z}$8 and reaching a successor that violates $\mathcal{Z}$9. Rechecking pushability is deferred until some newly learned clause $56\to 60$0 invalidates that witness by satisfying

$56\to 60$1

This turns clause propagation into event-driven frontier maintenance. On HWMCC’12, original IC3 solved $56\to 60$2 problems, triggered pushing $56\to 60$3, and triggered pushing plus witness-directed minimization $56\to 60$4 (Suda, 2013).

5. Proof theory: analytic cuts, plural cuts, and clause-based cut elimination

In proof theory proper, clause cuts intersect two different traditions. One is cut restriction: when full cut elimination fails, arbitrary cuts may still be reducible to analytic cuts, i.e. cuts whose cut formula is a subformula of the cut conclusion. The 2022 and 2023 papers define local analyticity in exactly this way and show that calculi such as those for bi-intuitionistic logic and $56\to 60$5, where ordinary cut elimination fails because of context restrictions, can still be transformed into locally analytic proofs. The 2023 paper formulates this uniformly for class-2 standard calculi and proves: every class 2 standard calculus has the analytic cut property (Ciabattoni et al., 2022, Ciabattoni et al., 2023).

A second tradition studies plural cuts, i.e. multiple-conclusion cuts in sequent calculi. Here the central object is no longer a clause database or a learned clause, but an oriented graph induced by the cut structure. The paper on graphs of plural cuts shows that singular cuts yield trees, while plural cuts yield more general graphs underlying polycategories. In the permutation-free planar setting, the relevant graphs are $56\to 60$6-graphs, characterized combinatorially by weak connectedness, asemicyclicity, $56\to 60$7-$56\to 60$8-functionality, and the condition that no bifurcation is transversal (Dosen et al., 2011).

CERES and its schematic extensions make the connection to clauses explicit. For an LK-proof $56\to 60$9, the characteristic clause set $2841.65\to 1724.01$0 is extracted from the ancestors of cut formulas and is always unsatisfiable; a resolution refutation of $2841.65\to 1724.01$1 can then be used to reconstruct an atomic cut normal form. The schematic extensions to proof schemata, $2841.65\to 1724.01$2, and CERESs introduce proof links, schematic characteristic clause sets, and schematic resolution refutations, allowing cut-elimination-by-resolution where ordinary reductive cut elimination fails for inductively defined proofs (Dunchev et al., 2013). Later work shows that, using lazy instantiation of proof links, characteristic clause sets of proof schemata admit the same kind of subsumption control known from ACNF-top analysis in ordinary LK, which is an essential step toward a complete cut-elimination method for proof schemata (Cerna et al., 2017).

A closely related line studies schematic cut elimination directly on extracted clause sets. The ECA-schema paper gives a case where the full schematic CERES pipeline succeeds: a proof schema with recursively many cuts is translated into a schematic characteristic clause set, then into a formal schematic resolution refutation, and finally into a Herbrand system. The clause set is normalized to a named family $2841.65\to 1724.01$3–$2841.65\to 1724.01$4, and the refutation schema $2841.65\to 1724.01$5 is formalized in the object language (Cerna et al., 2016).

Coinductive calculi expose the opposite phenomenon: not every cut can be eliminated. In $2841.65\to 1724.01$6, the paper proves that any proof of

$2841.65\to 1724.01$7

uses the $2841.65\to 1724.01$8 rule. The successful proof cuts with the lemma $2841.65\to 1724.01$9. At the same time, the paper shows that CoLP-style proofs correspond to cut-free $15\to 29$0 proofs with fixpoint terms, and develops coinductive theory exploration heuristics to discover useful cut formulae (Komendantskaya et al., 2020).

6. Clause-local decomposition and structural reorganization

Clause cuts also appear as decompositions that avoid global coupling. In the quantum search algorithm for clause satisfaction problems, the standard Grover oracle would require computing

$15\to 29$1

inside a monolithic phase-marking circuit. The proposed alternative instead introduces commuting clause-local unitaries $15\to 29$2, each acting only on clause $15\to 29$3 and a shared ancilla, and composes them as

$15\to 29$4

This removes the need to couple individual clause circuits through an explicit global AND. The resulting search still has $15\to 29$5 complexity when $15\to 29$6, and for 3SAT the paper argues that typically $15\to 29$7 (Tulsi, 2015).

In logic programming, the semantic problem of cut is tied to clause order and scope. The structured alternative to Prolog replaces common clause-cut idioms by explicit exclusive clauses of the form $5.74\times$8 which act as an if-then-else across clauses: if the head matches and $15\to 29$8 succeeds, then $15\to 29$9 is the only continuation; otherwise control falls through to later clauses. The paper treats this as a structured replacement for most uses of cut, while the more general until construct recovers the full power of Prolog’s cut (Porto, 2011).

A broader structural reading appears in multi-output Tsetlin Machines. The Coalesced Tsetlin Machine does not perform explicit clause deletion, but it reorganizes clause usage by replacing separate clause banks with a shared clause pool $5.74\times$0 and an output-specific weight matrix $5.74\times$1. A single clause can then vote for multiple outputs with different signs and magnitudes. The paper reports that with $5.74\times$2 clauses per class, accuracy rises from $5.74\times$3 to $5.74\times$4 on Fashion-MNIST and from $5.74\times$5 to $5.74\times$6 on Kuzushiji-MNIST, both at $5.74\times$7 kB model size. This suggests that clause sharing can function as clause-budget reallocation when explicit clause cuts are not the relevant operation (Glimsdal et al., 2021).

In all of these settings, clause cuts are best understood as a family of clause-centric transformations whose purpose is to expose structure that a naïve global formulation suppresses. Depending on the domain, the operative move may be deletion, scheduling, frontier maintenance, conflict-graph separation, analytic restriction, or modular decomposition; what remains constant is the attempt to make clause structure computationally decisive rather than merely representational.