A Decidable Class of Nested Iterated Schemata (extended version)

Many problems can be specified by patterns of propositional formulae depending on a parameter, e.g. the specification of a circuit usually depends on the number of bits of its input. We define a logic whose formulae, called “iterated schemata”, allow to express such patterns. Schemata extend propositional logic with indexed propositions, e.g. P_i, P_i+1, P_1, and with generalized connectives, e.g. /\i=1..n or i=1..n (called “iterations”) where n is an (unbound) integer variable called a “parameter”. The expressive power of iterated schemata is strictly greater than propositional logic: it is even out of the scope of first-order logic. We define a proof procedure, called DPLL*, that can prove that a schema is satisfiable for at least one value of its parameter, in the spirit of the DPLL procedure. However the converse problem, i.e. proving that a schema is unsatisfiable for every value of the parameter, is undecidable so DPLL* does not terminate in general. Still, we prove that it terminates for schemata of a syntactic subclass called “regularly nested”. This is the first non trivial class for which DPLL* is proved to terminate. Furthermore the class of regularly nested schemata is the first decidable class to allow nesting of iterations, i.e. to allow schemata of the form /\i=1..n (/\j=1..n …).

💡 Research Summary

The paper introduces a logical formalism called “iterated schemata” designed to capture families of propositional formulas that depend on an integer parameter. A schema consists of indexed propositional atoms (e.g., P_i, P_{i+1}) together with generalized connectives V_i|C and W_i|C, which respectively denote bounded conjunctions (∧) and disjunctions (∨) over a domain C expressed as a linear integer constraint. This allows one to describe, in a compact way, specifications such as an n‑bit adder, the n‑queens problem, or pigeon‑hole principles, where the number of components grows with the parameter.

Semantically, a schema S is interpreted by first choosing a ground substitution (environment) ρ for all free integer variables (the parameters) that satisfies the global constraint C_S. The schema is then instantiated into an ordinary propositional formula |S|_ρ by expanding each iteration according to the concrete values of the bound variables. The usual propositional truth‑valuation then determines whether the instantiated formula is true. A schema is satisfiable iff there exists some environment ρ and a propositional model of |S|_ρ.

The authors recall that the general (un)satisfiability problem for schemata is undecidable: the set of unsatisfiable schemata is not recursively enumerable, so no refutationally complete calculus can exist. Their earlier procedure, STAB, terminates only when a satisfying instance is found; it may diverge on unsatisfiable schemata.

To address this limitation they propose DPLL*, an extension of the classic DPLL SAT‑solver. DPLL* retains the core DPLL operations—splitting on a literal, unit propagation, and clause learning—but lifts them to the level of schemata. The key innovations are:

1. Iteration handling – When a literal involving an indexed atom is assigned, DPLL* propagates the assignment to all occurrences of that atom inside any iteration whose index matches the assigned value.
2. Empty‑iteration detection – If the domain C of an iteration becomes unsatisfiable under the current environment, the whole iteration can be removed (treated as false for ∨‑iterations or true for ∧‑iterations).
3. Cycle detection – During proof search DPLL* records schematic sub‑goals. If the same sub‑goal reappears, the procedure recognises a loop and stops expanding that branch. This is essential for guaranteeing termination on certain classes.

Despite these mechanisms, DPLL* does not terminate on arbitrary schemata because the underlying problem is undecidable. The authors therefore define a syntactic subclass called regularly nested schemata. A schema belongs to this class if:

• Every iteration is of the form V_i|e₁≤i≤e₂ or W_i|e₁≤i≤e₂ where e₁, e₂ are linear expressions over the parameters, and the intervals are nested in a well‑founded manner (inner intervals are contained in outer ones).
• Bound variables of different iterations never clash, and each iteration’s domain is a conjunction of linear constraints that involve only the current bound variable and the global parameters.
• The overall constraint C_S is a conjunction of linear inequalities over the parameters, guaranteeing that the set of admissible parameter values is effectively computable.

Within this subclass, the authors prove that DPLL* always terminates. The proof proceeds by showing that each application of the rules strictly reduces a well‑founded measure that combines (i) the maximal depth of nested iterations, (ii) the size of the current domain constraints, and (iii) the number of distinct schematic sub‑goals generated. Cycle detection guarantees that no infinite sequence of identical sub‑goals can occur, while the bounded nature of the domains ensures that each iteration can be unfolded only finitely many times before becoming empty.

The paper demonstrates the practical relevance of the theory with two case studies:

• Carry‑propagate adder – The adder schema contains a top‑level conjunction over i=1..n of “Sum_i ∧ Carry_i” together with definitions of Sum_i and Carry_i that themselves involve bounded iterations. DPLL* successfully propagates assignments through the nested iterations and terminates, whereas STAB would get stuck at the root level.
• Binary multiplier – The multiplier is expressed as a double‑nested sum of partial products, leading to iterations of the form ∧{i=1}^n (B_i ⇒ Add(S_i, A·2^{i‑1}, S{i+1})) and further nested iterations inside the Add schema. Again DPLL* handles the nesting by locally expanding the inner Add schema while keeping the outer sum symbolic, and terminates.

Finally, the authors discuss how the decidability of linear integer arithmetic allows efficient computation of the set L(S) = { literals L | L positively occurs in every grounding of S }. This set can be used for preprocessing, clause learning, and for generating useful invariants about the schema.

In summary, the paper makes three major contributions: (1) a formal language for parameterised propositional families that exceeds the expressive power of propositional and first‑order logic; (2) the DPLL* proof procedure that extends SAT solving techniques to this language; and (3) the identification of the regularly nested class, the first non‑trivial decidable subclass that permits arbitrary nesting of iterations. These results open the way for automated reasoning tools that can directly verify parameterised hardware designs, combinatorial families, and other infinite families of propositional specifications without resorting to exhaustive instantiation.