1. Introduction
Circumscription is a foundational formalism of non-monotonic reasoning. It was introduced to represent closed-world and common-sense assumptions by minimizing designated predicates subject to a background theory [
1,
2,
3,
4]. In the propositional setting, the atoms are divided into minimized, varied, and fixed classes. A selected model admits no strictly preferable competing model that preserves the fixed part of the interpretation while decreasing the minimized part; the varied atoms remain unconstrained by the comparison. This semantics provides a concise account of defeasible conclusions, but it also makes model checking a global task over alternative interpretations.
Most computational work on propositional circumscription has therefore concentrated on deciding whether a candidate is minimal, generating circumscribed models, or compiling circumscription into another reasoning formalism. Representative approaches employ predicate elimination, translations to logic programming, SAT- and MaxSAT-based encodings, or structural restrictions on the input theory [
5,
6,
7,
8,
9,
10]. The complexity of the underlying inference and candidate-model checking tasks has been analyzed separately for propositional circumscription and closely related closed-world formalisms [
11,
12,
13]. These methods provide powerful decision procedures. A Boolean answer alone, however, does not show which clauses force the minimized atoms of the candidate, how the relevant constraints interact, or how the result can be checked independently of the solver that produced it.
Recent research in mathematical logic has examined formal relationships between axiomatic and rule-based presentations, cut-free proof systems, and algorithmic model checking. Borrego-Díaz et al. [
14] establish conservativity results for theories extended by conditional axioms and their associated inference rules. Lin and Ma [
15] develop cut-free Gentzen sequent calculi for tense logics. In a different setting, Yu et al. [
16] define a fuzzy computation-tree temporal logic with quality constraints and provide a model-checking algorithm together with its complexity analysis. These studies concern logical formalisms distinct from circumscription and are cited as recent examples of mathematical investigations into proof systems and logical decision procedures. The present work focuses specifically on candidate-relative certification for propositional circumscription, where a global minimality judgment is decomposed into local entailment obligations that can be independently reconstructed and checked.
This limitation is significant in verification-oriented applications. A result used in formal verification, knowledge-base maintenance, or solver validation should preferably be accompanied by a finite object whose correctness can be checked by a separate and comparatively simple procedure. For circumscription, such an object must retain the connection between the global minimality condition and the original clauses. Merely returning a collection of clauses is insufficient: the certificate must identify the obligation proved by those clauses and specify how a sequence of local proofs establishes the global result. We refer to a certificate with this property as replayable.
The starting point of this paper is the minimal-reduct characterization of propositional circumscription [
17]. Let
be a clause theory, let
P and
Z denote the minimized and varied atoms, respectively, and let
M be a candidate interpretation. The characterization reduces circumscription model checking to a classical entailment:
The reduct discards clauses and literals that cannot participate in an admissible countermodel below the candidate. The remaining entailment is still global, but it has a purely propositional form and is therefore a suitable object for structural analysis.
Our aim is to decompose this entailment into a sequence of smaller obligations without weakening the equivalence above. This cannot be achieved by an arbitrary partition of the residual clauses. A correct decomposition must identify the part of the reduct relevant to a current block of minimized atoms, establish that clauses outside that part cannot affect the local entailment, and preserve the remaining global obligation after the verified atoms have been contracted. The construction must also account for source components containing only varied literals and must maintain a precise correspondence between residual clauses and their origins in the input theory. These requirements specify the mathematical conditions under which the decomposition is valid.
We organize the residual dependencies through a collapsed negative dependency graph. Its strongly connected components represent groups of literals tied by cyclic negative dependencies. At each stage, source components whose labels are disjoint from the current verification target are pruned from the working graph. A remaining source component with non-empty target intersection then determines the next local obligation together with the residual clauses in its dependency scope. After that obligation has been certified, the verified minimized atoms are contracted, the reduct and graph are recomputed, and the construction continues. The main theorem proves that this process terminates and that the resulting local obligations are jointly equivalent to the original reduct entailment.
The proof separates four issues that are easily conflated in an algorithmic description. First, pruning must expose a source with a non-empty minimized target whenever such targets remain. Second, the selected scope must be semantically closed for the local obligation. Third, contraction must preserve exactly the unresolved part of the global entailment. Fourth, clause origins must remain well defined when residual clauses are simplified, deleted, or merged. Formalizing these points yields a decomposition theorem, a sound and complete checking procedure, and an implementation-independent replay relation.
A successful run records the selected components and clause supports needed for their local entailments. During replay, the checker reconstructs the current reduct, graph, scope, and target from the candidate and the previously verified steps. Consequently, the persistent certificate need not store implementation-specific graph identifiers or intermediate residual theories. A failed local obligation produces a local countermodel, which supplies a checkable explanation of why the corresponding global test fails.
We consider two certification strategies. The direct SAT-based strategy checks each scoped entailment and retains the complete scoped support. The MUS-based strategy extracts an inclusion-minimal unsatisfiable subtheory before mapping the selected residual clauses back to their original clauses. Both strategies implement the same semantics and return the same checking result. Their difference concerns the proof object: MUS extraction usually provides a much smaller certificate at the cost of additional computation. Accordingly, the proposed framework is intended for local and replayable certification. It is not claimed to improve the running time of a global reduct checker when only the Boolean decision is required. The term local certification refers to the construction and independent validation of local proof obligations; the candidate interpretation itself is not modified.
The principal contributions are as follows.
- (i)
We give a graph-theoretic decomposition of the minimal-reduct entailment used in propositional circumscription checking. The formal development includes source exposure after pruning, semantic separation of local scopes, and preservation under successive contraction.
- (ii)
We derive a sound and complete source-component checker and define an origin-preserving certificate format with an independent replay procedure. The construction specifies a canonical encoding of stage-local dependency blocks and a representative origin map that remains well defined under residual simplification and duplicate-clause merging.
- (iii)
We instantiate the framework with SAT-based and MUS-based certification and compare both variants with the global reduct criterion on random and industrial CNF benchmarks. The evaluation measures decision agreement, locality, certificate size, replayability, and computational overhead.
The remainder of the paper is organized as follows.
Section 2 reviews circumscription computation, minimal reducts, graph-based minimal-model construction, structural decomposition, and certificate-oriented reasoning.
Section 3 introduces the formal setting.
Section 4 develops the graph construction and proves the decomposition results.
Section 5 presents the checker, certificate format, and certification procedures.
Section 6 reports the experimental evaluation.
Section 7 discusses the scope and limitations of the framework, and
Section 8 concludes the paper.
2. Related Work
Circumscription was introduced by McCarthy as a second-order formalization of predicate minimization and subsequently developed as a general mechanism for non-monotonic knowledge representation [
2,
3]. Its computational study has included predicate elimination, reductions to propositional satisfiability, complexity analyses, candidate-model checking, and translations into logic programming [
5,
6,
7,
8,
9,
18,
19,
20,
21]. Eiter and Gottlob characterize the complexity of propositional circumscription and extended closed-world reasoning [
11], while Cadoli studies the complexity of checking models of circumscriptive formulae [
12]. A broader account of complexity results for non-monotonic logics is given by Cadoli and Schaerf [
13]. Related closed-world formalisms include the weak generalized closed-world assumption of Rajasekar et al. [
22]. These works principally address the computation or complexity of circumscribed and closed-world consequences, rather than the construction of replayable local certificates for a fixed candidate model.
Reduct constructions provide a closely related semantic technique. They are fundamental to stable-model semantics, and their relationship with circumscription has been investigated in both propositional and first-order settings [
23,
24]. Dependency graphs and loop formulas further expose cyclic structure and reduce non-monotonic conditions to classical constraints [
25]. For propositional circumscription, the minimal reduct of [
17] is defined relative to a candidate interpretation and isolates the residual constraints relevant to the existence of a strictly preferred model. This characterization converts candidate minimality into a classical entailment problem.
Structural decomposition has also been studied extensively in logic programming and minimal-model reasoning. Dependency-based methods divide a reasoning task according to strongly connected components, program modules, or problem-specific structural partitions [
26,
27,
28]. In answer set programming, such methods are generally formulated with respect to stable-model semantics and the rule dependency structure of the input program. Their purpose ranges from modular evaluation to search-space reduction and distributed solving.
A particularly relevant contribution is the graph-based construction of minimal models proposed by Angiulli et al. [
29]. Their framework considers positive propositional theories represented by rules and forms a super-dependency graph from the strongly connected components of the associated atom–clause dependency graph. Given a source component
S, the projected theory
is solved first; if
X is a minimal model of
, the assignment on
S is propagated by
. Their composition theorem shows that
X can be combined with a minimal model of the reduced theory to obtain a minimal model of
T. Iteration yields the algorithm
ModuMin. Its worst-case bound is expressed in terms of the largest component on which a complete minimal-model procedure is required, and source theories belonging to the HCF or HEF classes can be handled in polynomial time by the incomplete subprocedure used in the algorithm. Distinct non-trivial sources may be processed in parallel, and the residual theory is independent of the order in which the corresponding reductions are applied. The same paper derives an ordinary minimal-model checking procedure by restricting a positive theory to subsets of a candidate model and invoking
ModuMin. It also observes that, although
ModuMin always returns a minimal model, it need not generate every minimal model; sufficient conditions for generative completeness are formulated through the modular and one-source-head properties.
Proof-producing reasoning provides a complementary line of work. From a proof-complexity perspective, Beyersdorff and Chew [
30] compare sequent-style and tableau calculi for propositional circumscription and establish strict separations in proof strength and exponential lower bounds for selected systems. Their analysis concerns the size of formal derivations, whereas the present work constructs candidate-relative local supports that can be reconstructed and replayed from the original theory.
SAT and MaxSAT cores, proof logging, and inconsistency certificates supply evidence that can be checked independently of the original solver [
31,
32,
33,
34,
35]. At the level of mathematical proof systems, conservativity between axiomatic and rule-based presentations and cut-free sequent calculi provide related accounts of how semantic validity can be represented by explicit derivations [
14,
15]. These results do not yield circumscription certificates, but they clarify the distinction between a semantic consequence and a structured proof object witnessing that consequence. Justifications, explanations, and witness structures have likewise been developed for answer-set semantics [
36,
37,
38,
39,
40,
41]. These approaches establish the broader methodological basis for replacing an unverifiable Boolean answer with a compact semantic or solver-level object.
The closest connection with [
29] concerns recursive graph-guided simplification. Both frameworks use a condensation DAG, select structurally exposed components, and simplify a residual theory after processing the selected component. The invariant maintained by the recursion is different. In the construction of Angiulli et al., the selected source is assigned a locally computed minimal model, and the composition theorem preserves the existence and minimality of the model assembled from the local assignment and a residual minimal model. In the present setting, the candidate interpretation is fixed before decomposition. A selected component
C is accepted only after the scoped entailment establishes that every model of the corresponding local reduct satisfies every atom in
. Contraction therefore records a proved consequence of the reduct; it does not select a local assignment from among alternative minimal models.
This difference prevents a direct application of the minimal-model construction theorem to the minimal reduct. The framework of Angiulli et al. uses positive theories and ordinary set-inclusion minimality over all atoms. A minimal reduct in the present setting may contain constraint clauses and signed occurrences of varied atoms, while the circumscription order minimizes only the atoms in
P and leaves the atoms in
Z free to change. Treating the reduct as an ordinary minimal-model problem would consequently minimize the varied atoms as well, unless an additional semantic encoding were introduced. More importantly, the target condition is the skeptical entailment
. Computing one minimal model of the reduct cannot decide this condition, since another minimal model may omit an atom of
. The auxiliary checking construction of [
29] addresses ordinary minimality of a fixed model by restricting the search to its subsets; it does not provide a decomposition of this candidate-relative entailment with varied atoms.
The graph-theoretic locality required by the two methods also differs. In [
29], a source is an SCC of the atom–clause dependency graph, and the local theory is the projection whose clauses use only atoms of that source. In the collapsed negative dependency graph used here, the vertex set is
, where
R is the current verification target. After empty sources are pruned, a component containing minimized atoms may remain dependent on ancestors consisting solely of varied literals. Its local obligation must therefore be evaluated over an atom-completed ancestor scope rather than over the component projection alone. The scoped-countermodel extension lemma supplies the formal condition under which clauses outside that scope are irrelevant to the selected entailment. After a successful obligation,
is removed from
R, and both the reduct and its graph are recomputed; correctness is derived from the two model-transfer propositions, without assuming the commutativity property of the Reduce steps established for parallel sources in [
29].
These distinctions also delimit the algorithmic claims. The component-sensitive bound and the HCF/HEF tractability results of ModuMin concern the construction of a minimal model of a positive theory and do not transfer to the local entailment tests considered here, which retain the complexity of propositional entailment and may incur further cost from MUS extraction. The purpose of the present decomposition is therefore structural localization and independently replayable certification. It yields a sound and complete decision procedure for the fixed circumscription candidate, together with an origin-preserving sequence of local supports or a scoped countermodel. This contrasts with the generative objective of ModuMin, whose output is a minimal model and whose ability to generate all minimal models requires additional structural conditions.
3. Preliminaries
Let
be a propositional language over a finite set
of atoms. The constants ⊥ and ⊤ are also allowed. A literal is an atom
or its negation
. A clause is a finite set of literals, identified with the disjunction of its elements. The empty clause is identified with ⊥. A clause theory is a finite set of clauses, identified with their conjunction. For a clause
, we write
For
, let
,
,
, and
. An interpretation is identified with the set of atoms assigned true. Classical satisfaction is denoted by ⊧.
As usual in propositional circumscription, quantification over propositional variables is shorthand for expansion over the truth constants. Thus, if is a propositional formula, denotes , and is defined dually. The notation extends componentwise to tuples.
In the following, tuples of atoms are used for simultaneous replacement. We identify a tuple with the corresponding set when this causes no confusion. For instance, if and , then expressions such as , , and refer to the underlying sets of atoms. If and are tuples of propositional variables of the same lengths as P and Z, respectively, then denotes the result of simultaneously replacing every in by and every by . Atoms outside are not replaced.
For tuples
and
, define
Thus
is a formula expressing that the comparison tuple is componentwise no larger than
P and strictly smaller in at least one component.
Example 1.
Let , , and clause theoryWhen simultaneous replacement is used, take the displayed orders and . If and , then is the clause theoryNo atom outside occurs in this example; in general, such atoms are not replaced.
Definition 1
(Parallel circumscription)
. Let P and Z be disjoint tuples of atoms, and be a propositional formula. The parallel circumscription of P in φ with Z allowed to vary isWhen , we write .
The atoms in P are minimized, the atoms in Z are varied, and the atoms in are fixed. The following model-theoretic order is the semantic counterpart of the syntactic comparison .
Definition 2
(Interpretation ordering)
. Let be disjoint, and be interpretations. We write ifWe write if and .
The relation separates the two semantic requirements of circumscription: containment on the minimized atoms and agreement on the fixed atoms. Its strict part therefore identifies exactly the interpretations that can refute the minimality of a candidate. The next definition uses this order to state the model condition independently of the second-order presentation in Definition 1.
Definition 3
(Circumscription model). An interpretation M is a model of , written , if and there is no model N of φ such that .
Definitions 1–3 give syntactic and model-theoretic presentations of the same minimization principle. The model-theoretic form will be used in the reduct proofs, because it makes the construction of a smaller countermodel explicit. The following example isolates the role of the varied atoms in that comparison.
Example 2
(Effect of varied atoms)
. Let , , and clause theoryThe interpretation satisfies φ. However, also satisfies φ, andThus . The atom is allowed to change because it is varied, while the minimized atoms in P become strictly smaller. Hence M is not a model of .
The syntactic formula and the semantic relation will be used in different contexts: the former occurs in the second-order definition of circumscription, while the latter compares interpretations. In the decomposition and certification sections, denotes the current verification target. Initially ; after a certified block is contracted, the target is updated to . When a statement concerns an arbitrary set , this is specified explicitly. In , R denotes the set of minimized atoms, and atoms in are treated as fixed.
3.1. Minimal Reducts
The minimal reduct used below is the reduct for propositional circumscription introduced in [
17]. It is used here as a model-checking device: relative to a candidate interpretation, it keeps precisely the residual clauses that may still rule out interpretations smaller under
.
Definition 4
(Minimal reduct)
. Let φ be a clause theory over , which are all disjoint, and be an interpretation. For each clause , defineprovided that the following conditions hold:- (i)
;
- (ii)
;
- (iii)
.
If one of these conditions fails, set , meaning that the clause is omitted from the reduct. The minimal reduct of φ with respect to is The three side conditions distinguish the literals that can be evaluated from those that must remain in the residual theory. Condition (i) removes clauses already satisfied by a minimized atom that is false in the candidate; conditions (ii) and (iii) evaluate the fixed atoms according to M. The retained clause therefore contains only literals whose values may still vary in a comparison below M.
Every atom occurring in the reduct belongs to . Fixed atoms are evaluated according to M, and minimized atoms false in M cannot become true in an interpretation smaller than M on P.
Example 3.
Let , , and clause theoryFor the candidate interpretation , we have , and there are no fixed atoms in this example. Hence each clause satisfies the side conditions of Definition 4, andFor comparison, if , then . The clauses , , and are omitted by condition (i), while reduces to . ThusThe reduct is therefore determined jointly by the candidate interpretation and by the roles of minimized and varied atoms.
Propositions 1 and 2 establish the two model-transfer directions used in the reduct characterization.
Proposition 1
(Preservation of smaller models)
. Let φ be a clause theory over , with disjoint atom sets, ,
If and , then .
Proof. Let
be derived from a clause
. Thus
and the three side conditions in Definition 4 hold for
. Suppose, for a contradiction, that
. Then
We show that all omitted literals of
are false in
N as well. Since
, we have
and
. For positive atoms omitted from
,
The part in
is false in
N because
, and the fixed part
is false in
N by agreement with
M together with condition (ii), namely
. Hence no positive literal of
is true in
N.
For negative literals omitted from , condition (i) gives ; hence no negative minimized atom false in M is omitted. The remaining omitted negative atoms are fixed atoms outside . By the fixed-atom agreement between N and M, condition (iii), , implies that each such atom is true in N. Therefore every omitted negative literal is false in N. Together with , this yields , contradicting . Thus , and since was arbitrary, . □
The converse transfer is stated next for an arbitrary set of minimized atoms.
Proposition 2
(Lifting reduct models)
. Let φ be a clause theory over , with disjoint atom sets, ,
If and , then .
Proof. Let . We prove that .
If , then . Since is obtained from by deleting literals and leaving the retained literals unchanged, any retained literal satisfying the reduct clause is also a literal of . Hence .
It remains to consider the case . Then at least one side condition in Definition 4 fails. If condition (i) fails, there is an atom . Since , we have , and therefore the literal satisfies . If condition (ii) fails, there is an atom . Because p is fixed with respect to , the equality gives , so p satisfies . If condition (iii) fails, there is an atom . Again p is fixed, whence , and satisfies . In all cases . Since was arbitrary, . □
The preceding propositions establish the semantic correspondence needed for model checking. A strictly smaller model of the original theory satisfies the reduct, while an appropriately bounded model of the reduct lifts to a model of the original theory. The next proposition records a separate stability property: once atoms have been removed from the minimized set, recomputing the reduct does not depend on whether the removal is performed in one step or in several steps.
The reduct is compositional under successive restriction of the set of minimized atoms.
Proposition 3
(Iterated reduct consistency)
. Let φ be a clause theory over , with disjoint atom sets, ,
Thenwhere equivalence is understood after removing clauses reduced to ⊤ and ignoring duplicate clauses. More generally, if , then Proof. It is enough to prove the general statement. Fix a clause . The one-step reduct retains exactly the literals of whose atoms belong to , provided that no omitted literal is already forced to make true or false by the side conditions of Definition 4.
Consider instead the two-step reduction through
. The first reduction retains only literals over
. The second reduction then evaluates every atom in
according to
M and retains only literals over
. Since
, a positive occurrence of an atom in
is treated exactly as a fixed positive atom true in
M, and a negative occurrence of such an atom is treated exactly as a fixed negative literal false in
M. Therefore the side conditions that omit a clause in the two-step procedure are triggered precisely in the cases in which the corresponding side condition is triggered by the one-step reduction to
. If the clause is not omitted, the retained literals after both procedures are precisely
Thus the two reductions produce the same residual clause, or both omit it. Applying this clause-wise argument to every
proves the claim. □
Combining Propositions 1 and 2 yields the following characterization.
Theorem 1
(Reduct characterization)
. Let φ be a clause theory over , with disjoint atom sets, ,
The following statements are equivalent:- (i)
;
- (ii)
;
- (iii)
.
Proof. Assume first that
and that (ii) fails. Then there is an interpretation
I satisfying
and falsifying some
. Define
The reduct contains only atoms from
, so
. Moreover,
, and the containment on
P is strict because
. By Proposition 2,
. Hence
is a smaller model of the original theory, contradicting
.
Conversely, assume (ii), and suppose that M is not a circumscription model. Then there exists such that . By Proposition 1, . Since , some atom in is false in N, contradicting (ii). Thus (i) and (ii) are equivalent. Finally, (ii) implies (iii) because every atom of is entailed by , while for each the interpretation M is a model of and falsifies p; hence . The converse implication is immediate. This proves the theorem. □
Theorem 1 is the semantic point of departure for the remainder of the paper. It replaces comparison with all -smaller models by a single classical entailment problem. The decomposition developed below therefore has to preserve the models of the minimal reduct and the entailment of the atoms in .
Example 4
(Cont. Example 3)
. Let . Since , the interpretation is a model of the reduct. In particular,
Therefore . By Theorem 1, M is not a circumscription model. This is the entailment-form version of the comparison from Example 2.
By Theorem 1, model checking is reduced to a classical entailment over the minimal reduct. The dependency structure used below is defined on the literals represented by the vertex set .
3.2. Dependency Graphs
We use the negative dependency convention of [
25,
26].
In the graph below, minimized atoms occur as positive vertices, whereas varied atoms occur as both signed vertices. Membership in induced subtheories is determined by underlying atoms.
Definition 5 ((Negative) dependency graph).
Let φ be a clause theory and P and Z be two disjoint sets of atoms. The negative dependency graph of φ on P with Z is the directed graph whereandHere is identified with z for . Thus, for example, a clause containing z and p induces the edge .
An edge records that a clause can transmit the failure of to the requirement represented by . Strongly connected components collect mutually dependent signed vertices, and the collapsed DAG orders the resulting dependency blocks. This order will later determine which sets of minimized atoms may be verified and contracted first.
Given a circumscription
and a non-empty set
,
L is called a
loop of
if, for any
, there exists a path of non-zero length from
p to
q in
such that all vertices in the path belong to
Given a directed graph
, the
collapsed dependency graph of
G is the directed acyclic graph (DAG) defined as follows:
is the set of strongly connected components (SCCs) of G. That is, every is a maximal subgraph of G such that has a path from any vertex to every other vertex in . When no confusion arises, we also denote such a component by its vertex set .
consists of all edges such that , , and there exist vertices and with .
For a clause theory
and two disjoint sets of atoms
, we write
instead of
. When a strongly connected component
C is used as a vertex of a collapsed dependency graph,
denotes the set of original graph vertices represented by
C.
A source S of is called empty if . For a component S of , let denote the set of clauses such that every vertex of whose underlying atom occurs in belongs to S. Here the polarity of the occurrence in is ignored: if an atom p appears in either as p or as , then the graph vertices whose underlying atom is p are treated as occurring in .
Example 5.
Let , , andTake . Then ,
Thus has vertex setThe clauses and induce the edges and , respectively. The clause induces the edge . The clause contains , and hence induces edges from to the literals occurring with , in particular .
The solid part of Figure 1 shows the negative dependency graph . The dashed boxes denote the vertices of the collapsed dependency graph , obtained by contracting strongly connected components.
For a component
C of a collapsed dependency graph
, let
be the set of its ancestor components. First form the raw ancestor set
The scope used in local obligations is the atom-completed ancestor scope
Thus, whenever one signed vertex of a varied atom is needed in a scope, the other signed vertex is included as well. The set
is a set of graph vertices, not a tuple and not necessarily a set of atoms. To speak about a local obligation for a component, we also need to restrict the reduct to the clauses whose graph vertices lie within a chosen scope.
Definition 6
(Induced subtheory)
. Let φ be a clause theory, be disjoint atom sets, ,
and . Let . The induced subtheory of ψ on U isIn this definition, occurrence is tested at the atom level rather than at the signed-literal level. Thus, if an atom p occurs in α either as p or as , then the graph vertices whose underlying atom is p are all relevant to the membership test for .
Example 6
(Cont. Example 5)
. Let and . The clauses and involve only the atoms and , while involves and . The clause involves the atoms and . Since is varied, both graph vertices and are relevant whenever the atom occurs, regardless of the polarity of its occurrence in the clause. Consequently, ifthenbecause also depends on the varied-atom vertices and . Ifthen .
4. Decomposition of Reduct Entailment
By Theorem 1, model checking for
M is equivalent to the residual entailment
. We decompose this entailment by the collapsed dependency graph of the reduct. The decomposition is candidate-dependent, since the graph is computed after the minimal reduct has been formed [
17,
25,
26].
The argument is developed in three stages. First, the collapsed graph induces an ordered partition of the minimized atoms occurring in the candidate. Second, a constructive countermodel-extension lemma identifies when the entailment for one graph component can be checked on its ancestor scope. Third, two reduct-transfer propositions justify contracting a verified block and continuing with the remaining blocks. This separation keeps the graph argument and the contraction argument logically distinct.
Throughout this section, put
A dependency partition of
R must respect the topological order of
; this is the condition under which verified blocks may be contracted without changing the residual test for later blocks.
Definition 7
(Dependency partition)
. Let φ be a clause theory over , with disjoint atom sets, ,
and be the collapsed dependency graph. Choose any topological ordering of the components in . Remove all empty intersections , and write the remaining non-empty sets, in the induced order, asThe sequence is called a dependency partition of R with Z for the reduct ψ. Each block is the intersection of R with one strongly connected component of , and the order of the blocks respects the topological order of .
The partition is determined by dependency, not by an arbitrary grouping of R. Atoms in the same block are mutually dependent in the negative dependency graph, while the order between blocks is inherited from the condensation DAG. The prefix preceding a block therefore consists exactly of the minimized atoms whose dependency position permits them to be contracted before that block is considered.
For
, let
The set
contains the target atoms verified before the block
. For each component, the checker must justify only the minimized atoms that occur in that component. The next definition names this target and the corresponding local entailment condition.
Definition 8
(Local verification obligation)
. Let φ be a clause theory over , with disjoint atom sets, ,
and . Let C be a vertex of the collapsed dependency graph . DefineIf , the local verification obligation associated with C isIf , then C carries no local verification obligation.
For component selection, the algorithm works on a copy of the collapsed DAG. It repeatedly deletes current source components whose labels are disjoint from the current verification target, and then selects a source component whose label intersects that target. The scope of the selected component is computed in the original collapsed graph.
The decomposition results below use several closely related objects derived from the current reduct. To make their roles explicit before the main locality lemma and decomposition theorems,
Table 1 summarizes the notation used throughout this section. Every entry has already been defined above or in
Section 3; the table introduces no additional mathematical objects.
Lemma 1
(Lifting a scoped countermodel)
. Let φ be a clause theory over , let be disjoint sets of atoms, and let with . PutFor a component C of , letand let be the set of underlying atoms represented in U. Ifthen there exist an atom and an interpretation I such thatand the interpretationsatisfies ψ. In particular, .
Proof. Choose
for which
. Among the models
I of
with
, choose one minimizing, under set inclusion, the set
Every vertex in
is the completion-added signed vertex of a varied atom; its complementary signed vertex belongs to
A.
We first show that . Suppose otherwise, and let be obtained from I by restoring, to their values in M, all varied atoms whose M-true signed vertices belong to . The atom p is unchanged. Assume that some clause is falsified by . Since , the clause contains a literal , for some , that is true under I and false under . On the other hand, ; hence contains a literal that is true under M. The literal is false under . Its atom was therefore not restored, and the corresponding signed vertex does not belong to . Since , this vertex belongs to U. It cannot lie in , because then it would belong to . Thus .
The clause contains both and . By Definition 5, the graph contains the edge . Since , the component containing l is an ancestor of C, and hence , contradicting . Therefore . Moreover, and , contradicting the choice of I. Hence .
Define
J by (
8). Suppose that
for some
. The interpretation
M satisfies every clause of
: for each retained reduct clause, the side conditions in Definition 4 ensure that every deleted literal is false under
M. Thus
contains a literal
such that
. Since
J agrees with
M outside
, the underlying atom of
belongs to
. The corresponding signed vertex is false under
I. Because
, this vertex belongs to
A.
The clause cannot belong to , because and I and J agree on . Hence contains a literal whose underlying atom lies outside . Since and J agrees with M outside , we have . The signed vertex l lies outside U. However, , so Definition 5 yields the edge . As , this makes l an ancestor of C, contradicting . Therefore . Finally, , so . □
The construction in Lemma 1 is the nontrivial direction of locality. It shows that a failure of the scoped obligation is a genuine failure of the full residual entailment, with the falsified minimized atom preserved. The converse direction requires only the set inclusion , and the two directions are summarized in the following corollary.
Corollary 1
(Scoped entailment)
. Under the assumptions of Lemma 1,
Proof. The implication from right to left follows from . For the converse, assume . By Lemma 1, there exists a model J of that falsifies an atom of . Hence . □
Example 7
(Cont. Example 5)
. LetIn the collapsed dependency graph , let , , , and be the vertices satisfyingThe component corresponds to the strongly connected component formed by and , while is the singleton component containing . The edge in induces an edge in . The edge induces an edge .
Hence the non-empty minimized components, ordered according to the collapsed dependency graph, give the dependency partitionFor the first component , the local target isThe scope of contains the vertices needed to express the clauses relevant to . In this example,
Therefore the induced local theory isThe corresponding local verification obligation isthat is,
The interpretation satisfies and falsifies , so the obligation fails. The graph determines the component, and the local verification consists of the entailment over its induced subtheory.
The next two propositions establish model transfer between an uncontracted reduct and the reduct obtained after removing the verified blocks from the set of minimized atoms.
Proposition 4.
Let φ be a clause theory over , with disjoint atom sets, ,
and be a dependency partition of R with Z for ψ. For , letIf , then .
Proof. Let
, and
be a clause from which
is derived. Put
when this clause is not omitted in
. Since
, moving from
P to
treats the atoms of
as fixed true atoms.
If belongs to , then . The clause is obtained from by possibly adding literals whose atoms are in . Hence unless all satisfying literals of were removed by the contraction. This cannot happen: any positive atom from is true in , while any negative literal over is false and therefore irrelevant to satisfaction. Thus .
If , then some side condition for fails. Since is present in , conditions involving fixed atoms outside cannot be responsible for the failure. Nor can condition (i) fail because all atoms of are true in M. The only possible new failure is condition (ii), caused by a positive occurrence of an atom in . Such an atom occurs positively in and is true in . Hence in this case as well. Since was arbitrary, . □
The converse transfer holds for models containing the previously verified atoms.
Proposition 5.
Let φ be a clause theory over , with disjoint atom sets, ,
and be a dependency partition of R with Z for ψ. For some , letIf and , then .
Proof. Let , and be the original clause from which it is derived. We compare with the clause obtained from in .
First, cannot be omitted. If condition (i) failed for the set P of minimized atoms, then it would also fail for , except possibly through an atom of ; but , so no such atom is in . If condition (ii) or (iii) failed because of a fixed atom outside , the same failure would occur for . If condition (ii) failed because of a positive atom in , then would be omitted by the contracted reduct, contrary to the choice of . Thus .
Since , we have . The only literals present in but absent from have atoms in . Positive literals over cannot occur, because would then have been omitted by condition (ii) for the contracted reduct. Negative literals over , if present in , are false in N because . Therefore must be witnessed by a literal already present in . Hence . Since was arbitrary, . □
Propositions 4 and 5 yield the layer decomposition.
The blocks in the following theorem are not an arbitrary set partition. By Definition 7, they are obtained by intersecting R with the SCCs of the negative dependency graph and retaining the order induced by a topological ordering of the collapsed graph. Thus the partition appearing in the statement is graph-derived. Once this ordered partition is fixed, the semantic equivalence below follows from the two model-transfer propositions. The additional graph-theoretic argument required for locality is given afterwards, when a full residual entailment is replaced by an entailment over the ancestor scope of a selected source component.
Theorem 2
(Decomposition of reduct entailment)
. Let φ be a clause theory over , withs disjoint atom sets, ,
and be a dependency partition of R with Z for ψ. For , letThenif and only if, for every ,
Proof. By Theorem 1, it is enough to prove that
is equivalent to the family of obligations (
10). By Definition 7,
and the order of these blocks is inherited from the collapsed dependency graph. The proof below uses this ordered partition together with the extension and restriction properties of the reduct.
Assume first that
. Suppose, for a contradiction, that (
10) fails for some
i. Then there exists an interpretation
N such that
By Proposition 4,
. Since
, the interpretation
still falsifies some atom of
. This contradicts
, because
.
Conversely, assume that all obligations (
10) hold. Let
. We prove by induction on
i that
For
, we have
, so the first obligation says
, and hence
. For the induction step, assume
. By Proposition 5,
The
i-th obligation then gives
. Thus
. By induction,
. Since
N was an arbitrary model of the original reduct,
, as required. □
Theorem 2 treats all blocks of a dependency partition simultaneously. For the algorithm, the relevant statement is the corresponding one-step decomposition. Given the atoms already verified, the next result identifies a source block with a non-empty target intersection, replaces its full residual entailment by the scoped obligation, and separates the remaining target into the next reduct.
Theorem 3
(Source-component decomposition)
. Let φ be a clause theory over , let be disjoint sets of atoms, and let . Letand putAssume that , and letStarting from a working copy of , at each round delete all current source components D satisfying . Let C be a source component of the resulting graph such thatDefineThen Proof. We first verify that the selection of C is well defined. The collapsed component graph is a finite DAG, and every deleted source component has label disjoint from R. Hence no component containing an atom of R is removed. Since , a target-bearing component remains. Repeated deletion must therefore expose a source component C satisfying .
Let
. Since
,
By Definition 4, atoms of
produce the same reduction whether they are treated as minimized atoms false in
M or as fixed atoms false in
M. Consequently,
Thus Corollary 1 applies to the current residual theory.
Every deleted component was a source at the stage at which it was removed. Hence the deleted components can be placed before C in a topological ordering of . After blocks with empty intersection with R are omitted, Definition 7 yields a dependency partition whose first block is . Thus the two model-transfer propositions apply to the theory , with minimized set and first contracted block .
Assume first that
. Corollary 1 gives
Let
. Proposition 4, applied to the first block
, yields
Therefore
. Since
, it follows that
. Hence
Conversely, assume that
Let
. By Corollary 1,
, and therefore
. Proposition 5 then gives
. The second entailment implies
, whence
. Since
N was arbitrary,
. This proves (
11). □
Example 8
(Source-component checking)
. LetandConsiderThen . The minimal reduct of φ with respect to isSincethe collapsed dependency graph contains two non-empty minimized components. Let and be the corresponding vertices of , withThus a source-component order gives the dependency partitionA corresponding negative dependency graph is shown in Figure 2.
For the first component , the local target isIts scope in the collapsed dependency graph isIndeed, induces the edge , so both signed vertices of the varied atom enter the atom-completed ancestor scope. Nevertheless, is not a clause of the induced subtheory because it also contains the atom , which lies outside this scope. Hence the induced local theory isThe first local verification obligation is thereforethat is,
After this local obligation is certified, the verified atom is contracted. The next residual reduct isThis residual reduct entailsThus the global entailmentis checked in two source-component steps:Thus the source-component form verifies the global reduct entailment through successive local obligations and residual-reduct recomputation.
Section 5 augments these obligations with origin-preserving supports and scoped countermodels.
5. Checking Algorithm and Origin-Based Local Certification
The checker repeatedly applies the one-step equivalence of Theorem 3. At each successful step, it certifies the current scoped obligation, contracts the corresponding block, and recomputes the residual reduct. The procedure LocalCertify returns an origin-preserving support or a scoped countermodel.
A certificate fragment is recorded over the original theory. For a local residual theory , the returned support is a set such that replaying through the current reduct and scope yields an unsatisfiable target-negation test. Hence is a primitive-clause support for the local entailment.
5.1. Origin-Preserving Certificates and Failure Packages
During the iterative checking process, every residual clause is represented by at least one clause of the original theory. The certificate records one such representative because the checker constructs one sufficient certificate and does not enumerate all possible supports.
Let
be the source component selected at iteration
i, and let
The certificate stores
, rather than an SCC identifier. During replay, the verifier reconstructs
,
, and the collapsed graph. Since
and strongly connected components partition the graph vertices, any atom of
identifies a unique current component. The verifier then checks that its intersection with
is exactly
, and that it is selectable after the repeated removal of source components disjoint from
. Thus the encoding is independent of transient SCC numbers and of any ordering on atom names.
The component field and the clause field serve different purposes. The block reconstructs the graph position of the local obligation, whereas the origin map reconstructs a sufficient set of original clauses. Since the checker seeks one replayable support, one representative origin for each residual clause is sufficient.
For every residual theory
, let
be a representative origin map. For a set
, write
Initially, for every
, choose an arbitrary original clause
whose reduction is
, and set
. Let
denote the clause-level result of applying the next reduct step to
. For every
, choose an arbitrary clause
such that
, and define
If several residual clauses produce the same clause
, one predecessor is selected as its representative. If a clause reduces to ⊤, it is omitted and produces no entry in
. The representative choice may be made deterministic, for example by selecting the first predecessor in the fixed input-clause order.
This representative choice is sufficient because the checker seeks one original-clause support for each local entailment. It does not enumerate all supports or all provenance alternatives. For every selected residual clause, reducing its representative origin at the same stage reproduces that residual clause; consequently, replay soundness is independent of which representative was chosen.
Proposition 3, together with the same clause-wise observation used in (
12), gives
where duplicate clauses are ignored. Hence each residual theory has the form required by Corollary 1.
Definition 9
(Origin-preserving decomposition certificate)
. Let φ be a clause theory over , let be disjoint atom sets, and let . PutAn origin-preserving decomposition certificate
for M with respect to is a finite sequencewhere every is a finite non-empty set of atoms and every is a set of clauses of φ. The sequence is valid if there exist residual theories , verification targets , and representative origin maps satisfying the following conditions for every .
LetThe non-empty set identifies a component of throughStarting from a working copy of , at each round delete all current source components whose labels are disjoint from ; validity requires that be a source of the resulting graph. DefineThe support field satisfiesFinally,
the representative origin map is updated by the predecessor rule above, and The certificate therefore stores neither SCC identifiers nor scopes. The prefix reconstructs the residual state at stage i; the current non-empty set identifies ; and and are derived from the recomputed graph and theory. The validity test also checks that the reconstructed component is eligible for source selection at that stage.
A successful fragment establishes an entailment by an unsatisfiable support. When the local test is satisfiable, a counterexample is given by a model of the scoped theory together with the negation of the local target. The following definition specifies the data required to replay such a failure.
Definition 10
(Failure package)
. Suppose the checker has successfully produced the prefixand has thereby reconstructed the current state . Let . A failure package at stage i is a triplewhere identifies the current component by . Starting from a working copy of , at each round delete all source components whose labels are disjoint from ; validity requires that be a source of the resulting graph. PutThe package is valid if the prefix is replay-valid andThus the prefix reconstructs the residual stage, replaces a transient SCC identifier, and witnesses failure of the reconstructed local obligation.
Corollary 2
(Soundness of a local failure package)
. Let be a valid failure package at stage i, with reconstructed state . ThenMoreover, there exists an interpretation satisfying and falsifying an atom of . Writing the targets stored in the prefix as , defineThenConsequently, .
Proof. Validity gives and Corollary 1 therefore yields Lemma 1 constructs a model of that falsifies an atom of . For each preceding stage , Proposition 4 gives from The targets in the prefix are pairwise disjoint from , because each successful stage removes its target from the next verification set. Hence adding does not change the atom of falsified by . It follows that and The conclusion follows from Theorem 1. □
Successful and failed local checks therefore have dual replay objects. A successful fragment records an original-clause unsatisfiability support. A failure package records the successful prefix needed to reconstruct the residual state together with a satisfying assignment for the local counterexample theory.
5.2. The Local Certification Procedure
Let
be a local residual clause theory,
be a non-empty set of atoms, and
be the restriction of the current origin map to clauses of
. The local verification problem is
Equivalently, with
the local obligation holds exactly when
. A model of
is a local counterexample.
The procedure
LocalCertify, where
, checks the satisfiability of
. If it is satisfiable, the procedure returns a countermodel. If it is unsatisfiable, the procedure first obtains a residual support
and then maps that support back to the original theory by setting
In
, take
. In
, choose an inclusion-minimal residual subtheory
with
. An optional second minimization may be applied to
at the original-clause level; soundness requires only the displayed unsatisfiability condition.
Example 9.
Using Example 8, consider the first block for the interpretation . The local target is , and the induced local residual theory isThe residual clause is obtained from the original clauseby evaluating the fixed atom under the candidate interpretation. Hence the origin map sends to the original clause , and sends to the original clause . Sincethe local obligation holds. The origin-preserving certificate fragment stores the following original clause support:During replay, κ reduces on the same scope to the residual support ; adjoining yields an unsatisfiable theory.
Proposition 6.
Let λ be a local residual theory at a stage with verification target R, scope U, and origin map ω. Let , and letIf Algorithm 1 returns , thenConsequently,
If it returns , then | Algorithm 1: LocalCertify |
![Axioms 15 00521 i001 Axioms 15 00521 i001]() |
Proof. If the algorithm returns
, then
, which immediately gives the stated local countermodel property. If the algorithm returns
, it has selected a residual support
such that
and then mapped
H back to original clauses through
. By the defining invariant of the representative origin map, reducing each clause in
at the same stage and restricting to the same scope reproduces the corresponding clause of
H. Hence
H is contained in the replayed residual support, and
This implies
, and therefore
. □
5.3. Main Checker
Algorithm 1 certifies a single source-component obligation. We now combine these local checks into a complete checker for the fixed candidate interpretation M. At the beginning of each iteration, the checker maintains the set R of minimized atoms that remain to be certified, the current residual reduct , a representative origin map from clauses of to clauses of , and the certificate prefix already obtained. It exposes a source component whose label intersects R, constructs the corresponding ancestor scope, and invokes Algorithm 1 on the induced local theory. A successful local check appends the fragment and contracts ; a failed check returns the replay-valid prefix together with the current local countermodel, as specified in Definition 10. Algorithm 2 gives the resulting iterative procedure and implements the source-component decomposition established in Theorem 3.
| Algorithm 2: CheckMinMRCirc |
![Axioms 15 00521 i002 Axioms 15 00521 i002]() |
After deleting from R, the update is correct by Proposition 3. The representative origin map records one provenance choice for each residual clause and does not alter the entailment test.
Example 10.
Run Algorithm 2 on Example 8 with and . The first selected source component has target and local residual theoryAs shown in Example 9, this local obligation is certified by the original supportThe checker records , contracts , and recomputes the residual reduct. The next non-empty source component has target , scope , and local residual theoryAn inclusion-minimal original support isAt the second stage,
andAfter contracting , the verification target is empty and the checker returns , whereReplay first reconstructs the stage-zero scope and verifiesIt then contracts , reconstructs and , and verifies the second unsatisfiability condition displayed above. Thus the example traces the complete sequence from the initial reduct through component selection, support generation, contraction, and certificate replay.
The parameter t affects only support extraction. The SAT variant uses ; the MUS variant chooses an inclusion-minimal with . In both cases, the stored support is .
Theorem 4
(Soundness and completeness)
. Let φ be a clause theory over , be disjoint atom sets, , and . Then Algorithm 2 on input returnsif and only ifEquivalently, it returnsonly ifMoreover, every successful certificate fragment in is a subset of the original clause theory φ whose replayed reduct certifies the corresponding local target.
Proof. By Theorem 1,
At each iteration, Theorem 3 gives the one-step equivalence between the current residual entailment, the scoped obligation, and the entailment for the next reduct. Since every successful step removes a non-empty block from the finite target, repeated application of the theorem reduces the initial entailment to the conjunction of the scoped obligations generated by Algorithm 2. Proposition 6 shows that a return value
establishes the corresponding obligation and that
supplies a model of its negation. Therefore the algorithm returns
exactly when every generated obligation holds. The inclusion
and the replay condition follow from Definition 9 and Proposition 6. □
The correctness theorem separates the semantic decision from the form of the recorded support. SAT and MUS certification establish the same local entailments and therefore induce the same Boolean result; they differ only in the residual support selected for replay.
Remark 1.
The semantics is independent of the certification mode. A certificate stores ; its validity is the stage-specific replay condition in Definition 9.
6. Experimental Evaluation
The experimental evaluation addresses Boolean agreement with the global reduct criterion, the relative size of scoped obligations, the size of origin-preserving supports, and certificate replayability.
6.1. Evaluation Questions
- Q1.
Do the decomposition variants agree with the global entailment test?
- Q2.
What fraction of the current residual reduct occurs in a scoped obligation?
- Q3.
How do SAT and MUS certification compare in accumulated support size?
- Q4.
Does every returned certificate satisfy the replay condition?
6.2. Methods
The following methods are compared.
- (i)
- (ii)
Decomp-SAT executes Algorithm 2 with and retains the complete local residual theory as the residual support.
- (iii)
Decomp-MUS executes the same algorithm with and extracts an inclusion-minimal residual support before applying the origin map.
6.3. Instances and Implementation
The benchmark set comprises 5445 solved random 3CNF instances and 462 solved industrial CNF instances derived from the data used in [
17]. Each input is a quadruple
with
. The experiments therefore isolate the model-checking and certificate-generation phases.
All runs were performed on an Intel(R) Core(TM) i7-10700F CPU at 2.90 GHz with 8 physical cores, 16 logical cores, and 32 GB of memory under Ubuntu 26.04. PicoSAT 960 was used for both the global entailment test and every local SAT call, while the PicoMUS utility distributed with PicoSAT 960 was used for MUS extraction. The three methods were run sequentially on the same inputs and machine; no portfolio execution or parallel solver calls were used. At each iteration, all current source components disjoint from the target were removed round by round from a working copy of the collapsed graph. The checker recorded the selected component through the set ; replay reconstructed the current graph and verified that the recorded component was selectable by the same procedure. When several predecessor clauses produced the same residual clause, the implementation selected the first predecessor in the fixed input-clause order. The selected target block was stored in the certificate, so replay did not depend on an external ordering of source components; representative-origin propagation was deterministic.
Reported runtimes are arithmetic means over solved instances and include the complete execution of each compared method. Certificate-size and replay statistics are computed over runs that returned a successful certificate; a replay success is counted only when every fragment of that certificate passes the stage-specific unsatisfiability test. The benchmark collections form fixed corpora rather than samples drawn for statistical inference. Accordingly, the reported means, maxima, factors, and percentage reductions are interpreted as descriptive summaries of these corpora; no population-level confidence claim is made.
6.4. Measurements
For each instance, we record the Boolean result and runtime of each method. For
we record
,
,
,
, the number of SCCs, and the largest SCC. At iteration
i, we record
For a successful certificate
we record
The summation counts a clause once for each certificate fragment in which it occurs. Replay verifies, for every
,
6.5. Results
Table 2 reports agreement with the global criterion and mean runtime.
Table 3 reports the initial reduct and graph statistics.
Table 4 gives the scoped-obligation statistics.
Table 5 reports support size and replay.
6.6. Analysis
All 5907 instances satisfy
Hence all three methods return identical Boolean values on the complete test set.
The mean initial reduct ratios are for random 3CNF and for industrial CNF. The corresponding mean scoped ratios are and . The mean target sizes are and . These ratios quantify the mean fraction of the current residual theory retained by a source-component obligation. The maximum industrial scoped theory contains clauses, indicating that a large SCC or ancestor scope can eliminate most of the potential localization.
For random 3CNF, MUS extraction decreases the mean accumulated support from to ; the mean SAT support is therefore times the mean MUS support, corresponding to a reduction of approximately . For industrial CNF, the mean decreases from to ; the mean SAT support is times the mean MUS support, and the relative reduction is approximately . Every returned certificate satisfies the replay condition.
The runtime data distinguish Boolean decision from certificate construction. GlobalReduct performs a single entailment test. The decomposition methods also construct scopes, recompute reducts, maintain origin maps, and replay local supports; Decomp-MUS additionally performs MUS extraction. The measurements therefore identify the intended trade-off: the global criterion remains the faster procedure when only the Boolean decision is required, whereas the decomposition methods incur additional cost to produce local, replayable proof objects.
7. Discussion
The extent of localization is governed by the collapsed graph , where and , together with the corresponding residual graphs at later stages. Small selected components with small ancestor scopes induce local theories substantially smaller than the current residual reduct. Conversely, a dominant SCC or a large ancestor scope yields an obligation close in size to the current residual theory. This limitation follows directly from the scope definition and is reflected in the maximum industrial scoped-theory size.
The certificate is independent of transient SCC and clause identifiers. Each fragment stores a stage-local dependency block and a set . Replay reconstructs the residual state from the preceding blocks, identifies the current component , derives its scope and local theory, and then verifies the stage-specific unsatisfiability condition. A single representative origin per residual clause is sufficient because the checker constructs one support and does not enumerate all provenance alternatives.
The current implementation recomputes the residual reduct and collapsed graph after every successful obligation. It also performs MUS extraction independently at each stage. Incremental reduct maintenance, incremental SCC updates, and proof-producing SAT/MUS interfaces are the principal directions for reducing this overhead.
8. Conclusions
We established a source-component decomposition of the minimal-reduct entailment characterizing propositional circumscription models. The repeated deletion of target-free source components guarantees that a target-bearing source is eventually exposed whenever the current verification target is non-empty. The scoped-countermodel extension lemma establishes semantic locality over ancestor scopes, and the contraction results yield equivalence between the sequence of scoped obligations and the global entailment.
The resulting algorithm is sound and complete. A successful run returns
with a formally specified replay condition. A failed run returns the replayable successful prefix, the stage-local target at which checking fails, and a scoped countermodel.
On the evaluated instances, the SAT and MUS variants agree with the global criterion, and every returned certificate satisfies the replay condition. MUS extraction yields substantially smaller original-clause supports at the cost of higher runtime.
The following directions warrant further investigation.
- (i)
Incremental maintenance. Develop incremental algorithms for maintaining the residual reduct and collapsed dependency graph. A corresponding complexity analysis should bound the update cost in terms of the clauses and strongly connected components affected by each contraction.
- (ii)
Parallel certification. Investigate parallel certification of incomparable source components. Correctness requires sufficient conditions under which local contractions commute and independently generated certificate fragments admit deterministic composition.
- (iii)
Extensions of the semantic setting. Extend the decomposition to prioritized or nested circumscription and, over finite or bounded domains, to first-order circumscription. Such extensions require suitable reduct characterizations and scope-preservation theorems.