EC-MHS: Equivalence-Based Compression for Minimal Hitting Set Enumeration in Model-Based Diagnosis

Abstract

Enumerating all inclusion-minimal hitting sets is a fundamental combinatorial task that arises in areas such as model-based diagnosis, hypergraph dualization, and data mining. In conflict-driven model-based diagnosis, exact enumeration becomes a computational bottleneck when both the component set and the diagnosis family are large. Existing exact methods mainly exploit conflict reuse or conflict-family structure, while component equivalence has rarely been integrated into search, output representation, and partition maintenance as a unified mechanism. This paper presents EC-MHS, an equivalence-aware framework for minimal hitting set enumeration in diagnosis. It combines Static Twin Compression (STC), which exploits coverage-signature symmetry among components to reduce the representative search space before enumeration, Dynamic Twin Compression (DTC) to merge candidates whose residual-state symmetry renders them interchangeable during search, a Compact Diagnosis Family Representation (CDFR) for exact weight-based aggregation and lossless class-wise expansion at the STC level, and iSTC to maintain the static partition under monotonic conflict addition. Experiments on ISCAS-85 benchmark circuits show that static equivalence appears in at least 96% of the dataset instances and that STC reduces the number of search candidates by 69–87% before search. On redundancy-rich benchmark instances, DTC reduces runtime by up to 75%, and iSTC maintains the STC partition 24 times faster than a full rebuild.

1. Introduction

Fault diagnosis in large engineered systems, such as digital circuits, avionics, and industrial control systems, is essential for dependable operation because it detects abnormal behavior and isolates it to a limited set of suspect components. Such isolation supports corrective maintenance by reducing downtime and unnecessary component replacement, and by preventing local faults from escalating into system-level failures. Model-based diagnosis (MBD) offers a principled alternative to manually designed troubleshooting rules: it compares observations with an explicit model of system structure and behavior and derives candidate diagnoses from the resulting inconsistencies [1,2,3]. In the classical conflict-driven workflow for consistency-based diagnosis (CBD), a reasoning engine first derives minimal conflict sets, and minimal diagnoses are then obtained by enumerating the corresponding minimal hitting set (MHS) family [1]. Recent work has further extended CBD to cyber-physical systems with hybrid behavior and mode-dependent models [4].

Within this conflict-driven workflow, the two stages are closely related but computationally distinct. Conflict recognition is model- and inference-dependent: a reasoning engine uses the system description and observations to derive behavioral predictions and detect inconsistencies; identifying the resulting minimal conflict sets may, in the worst case, require an exponential search over assumption environments [2]. Candidate generation, by contrast, is model-independent once the minimal conflict family is available: it enumerates minimal diagnoses as the inclusion-minimal hitting sets of that family. Because the number of such sets can itself be exponential, complete enumeration may also require exponential time in the worst case. Accordingly, this study focuses on the second stage and treats the minimal conflict family as given.

Minimal hitting set enumeration is not specific to diagnosis. It is equivalent to minimal transversal generation in hypergraphs and closely related to monotone dualization [5,6,7,8]. It also appears in data mining, computational biology, and knowledge processing [9,10]. Computationally, determining whether a hitting set of bounded size exists is NP-complete [11,12], and even moderate conflict families can induce diagnosis spaces too large to inspect directly. In diagnosis practice, the challenge is therefore twofold: computing all inclusion-minimal diagnoses and returning them in a form that remains usable for ranking, grouping, counting, or selective inspection.

Diagnosis-oriented complete methods address this challenge along several lines. Tree- and DAG-based methods such as HS-tree, HS-DAG, and HST-tree reuse conflict information to avoid redundant search [1,13,14]. Boolean and SAT-oriented methods reformulate diagnosis or hitting set computation into symbolic search problems [15,16,17]. Structure-aware and divide-and-conquer methods exploit join-relation decomposition, special conflict-family topologies such as linear or tree structures, and subset recombination [18,19,20,21]. A diagnosis-oriented empirical comparison by Pill et al. [22] clarified the runtime and memory trade-offs among several complete MHS solvers under both unrestricted and cardinality-bounded settings. Across these lines, the dominant reductions arise from conflict reuse, conflict-family structure, or symbolic reformulation. Complementary diagnosis work has also addressed search-tree reuse across successive measurements, systematic query computation in sequential diagnosis, and efficiency under pseudo-normal observations [23,24,25]. Much less attention has been paid to component-level redundancy as an explicit source of search-space and output-family inflation, even though interchangeable components can enlarge both the search space and the output diagnosis family.

In diagnosis instances, components can be interchangeable in two situations: some share the same conflict-incidence signature from the outset, whereas others become interchangeable only after a partial diagnosis has covered part of the conflict family. Either way, such components are symmetric in the diagnostic sense: any one may replace any other without changing the hitting-set conclusion. This component symmetry is especially natural in engineered systems with repeated functional modules, including digital circuits with replicated logic blocks. In this context, the resulting equivalence classes consist of interchangeable components, as distinct from the conflict clusters termed “equivalence classes” in join-relation decomposition [18]. Exploiting this redundancy can reduce representative search, and it can also compress the diagnosis family itself, which is relevant when subsequent processing operates on grouped or weighted candidates rather than on a complete list of all diagnoses. The objective of this paper is therefore to integrate component equivalence into search, output representation, and partition maintenance as one unified, exactness-preserving mechanism. To this end, EC-MHS (Equivalence-Compressed MHS Solver) is proposed as an exact enumeration framework built around two forms of component equivalence. Static Twin Compression (STC) groups components with identical coverage signatures and searches over one representative per class. Dynamic Twin Compression (DTC) merges candidates that are interchangeable in the current residual state defined by uncovered and private conflicts. EC-MHS returns a Compact Diagnosis Family Representation (CDFR), supporting weight-based processing and, at the STC level, on-demand class-wise expansion. The framework includes iSTC, a lightweight procedure that maintains static equivalence classes under monotonic conflict addition.

EC-MHS performs exact depth-first enumeration over the STC-compressed representative set. Private conflicts maintain inclusion-minimality during search, and a joint-coverability test removes residual states whose remaining candidates cannot cover the uncovered conflicts. Cardinality-bounded enumeration is kept as a secondary mode for diagnosis workflows that first inspect low-cardinality diagnoses. The experiments on ISCAS-85-derived conflict families then evaluate four aspects: the prevalence of component equivalence, the effect of STC across several solvers, the additional savings obtained by DTC after STC, and the cost of maintaining the STC partition incrementally rather than rebuilding it.

Section 2, Section 3, Section 4 and Section 5 define the diagnosis formulation, the compression model, the solver, and the incremental extension. Section 6, Section 7, Section 8 and Section 9 present the experimental evaluation, discuss limitations, review related work, and conclude the paper.

2. Preliminaries and Problem Formulation

2.1. System Model and Conflict Sets

Following the framework of Reiter [1] and its later refinement by de Kleer et al. [3], a system under diagnosis is represented as a triple $(SD,COMPS,OBS)$, where $SD$ is the system description given by first-order sentences, $COMPS$ is a finite set of component identifiers, and $OBS$ is a set of observations. A unary predicate $AB\left(c\right)$ indicates that component c is abnormal.

Definition 1 

(Conflict Set). A conflict set for $(SD,COMPS,OBS)$ is a subset $C\subseteq COMPS$ such that

$$SD\cup OBS\cup \{\neg AB(c)\mid c\in C\}$$

is logically inconsistent. A conflict set C is minimal if no proper subset of C is a conflict set.

Let $\mathcal{F}=\{C_1,C_2,\dots ,C_m\}$ denote the family of all minimal conflict sets for a given diagnosis instance. The set of all components appearing in at least one conflict set is $\bigcup \mathcal{F}={\bigcup }_{i=1}^m{C}_i$. Equivalently, $(\bigcup \mathcal{F},\mathcal{F})$ can be viewed as a hypergraph whose vertices are components and whose hyperedges are (minimal) conflict sets; under this viewpoint, minimal hitting sets are also known as minimal transversals [5,9].

2.2. Hitting Sets and Diagnoses

Definition 2 

(Hitting Set). Let $\mathcal{F}$ be a nonempty family of sets. A set $H\subseteq \bigcup \mathcal{F}$ is a hitting set for $\mathcal{F}$ if $H\cap C\ne \varnothing$ for every $C\in \mathcal{F}$.

Definition 3 

(Minimal Hitting Set). A hitting set H for $\mathcal{F}$ is minimal if no proper subset of H is a hitting set for $\mathcal{F}$.

Throughout this paper, minimality is with respect to set inclusion (inclusion-minimality), not minimum cardinality.

Let $\mathsf{MHS}\left(\mathcal{F}\right)$ denote the family of all minimal hitting sets for $\mathcal{F}$.

A standard characterization of inclusion-minimal hitting sets uses private conflicts (also called private or critical hyperedges in the transversal literature [5,10]).

Definition 4 

(Private Conflict). Let H be a hitting set for $\mathcal{F}$ and let $c\in H$. A conflict set $C\in \mathcal{F}$ is a private conflict of c in H if $C\cap H=\left\{c\right\}$.

Proposition 1 

(Private-conflict characterization). A hitting set H for $\mathcal{F}$ is minimal if and only if every $c\in H$ has at least one private conflict in H.

Proof. 

If H is minimal, then for any $c\in H$, the set $H\setminus \left\{c\right\}$, obtained by removing c from H, is not a hitting set. Hence there exists $C\in \mathcal{F}$ such that $C\cap (H\setminus \{c\left\}\right)=\varnothing$, which implies $C\cap H=\left\{c\right\}$ and therefore C is a private conflict of c. Conversely, if every $c\in H$ has a private conflict, removing any c would leave its private conflict uncovered, so H is minimal.    □

This characterization underlies the minimality checks maintained during depth-first search.

In the diagnosis setting, a hitting set plays the role of a diagnosis candidate, which yields the classical correspondence below.

Theorem 1 

(Reiter [1]). A set $\Delta \subseteq COMPS$ is a (candidate) diagnosis for $(SD,COMPS,OBS)$ if and only if Δ is a hitting set for the family of all minimal conflict sets for $(SD,COMPS,OBS)$. A set Δ is minimal if and only if it is a minimal hitting set for that family.

This theorem reduces conflict-driven diagnosis to hitting set computation: candidate diagnoses correspond to hitting sets, and minimal diagnoses correspond exactly to minimal hitting sets.

Example 1. 

For a pure hitting-set instance, let

$${\mathcal{F}}_0=\{\{a,b,c\},\{b,d\},\{c,d\}\}.$$

The set $\{b,d\}$ is a hitting set because it intersects every set in ${\mathcal{F}}_0$. The set $\{a,b,d\}$ is also a hitting set, but it is not minimal because removing a leaves the hitting set $\{b,d\}$. The complete minimal hitting set family is

$$\mathsf{MHS}\left({\mathcal{F}}_0\right)=\{\{b,c\},\{b,d\},\{a,d\},\{c,d\}\}.$$

For instance, $\{a,d\}$ hits all three sets, and neither $\left\{a\right\}$ nor $\left\{d\right\}$ is a hitting set. This small family has only four components and three sets, yet it already yields four inclusion-minimal hitting sets.

Example 2. 

Figure 1 shows a classical multiplier-adder diagnosis example with three multipliers $M_1$, $M_2$, $M_3$ and two adders $A_1$, $A_2$. The six input terminals A–F have fixed values $2,3,2,3,2,3$, respectively. Under nominal operation, both outputs should be 12. However, the observed outputs are $G=10$ and $H=12$, indicating that at least one component is faulty.

Figure 1. Multiplier-adder example.

For this observation, the resulting minimal conflict family is

$$\mathcal{F}=\{C_1,C_2\},C_1=\{M_1,M_2,A_1\},C_2=\{M_1,M_3,A_1,A_2\}.$$

If all components in $C_1$ operated correctly, then the two inputs of $A_1$ would be the outputs of $M_1$ and $M_2$, each producing $2\times 3=6$, so the model would predict $G=12$, contradicting the observed value $G=10$. Hence, at least one component in $C_1$ must be faulty. Similarly, if all components in $C_2=\{M_1,M_3,A_1,A_2\}$ operated correctly, then $M_1$ would provide one input of $A_1$ as 6, and $M_3$ would provide one input of $A_2$ as 6. Since the observed output at H is 12 and $A_2$ is assumed to operate correctly, the other input of $A_2$ must also be 6. This value is exactly the other input of $A_1$. Therefore, $A_1$ would output $6+6=12$, again contradicting the observed value $G=10$. It follows that each of $C_1$ and $C_2$ must contain at least one faulty component. Both sets are minimal in the sense that removing any component from either set resolves the inconsistency.

Any diagnosis candidate must intersect every conflict set in $\mathcal{F}$; otherwise, some conflict set would remain unhit. Hence, the minimal diagnosis candidates are obtained by identifying the minimal hitting sets of $\mathcal{F}$. Since

$$C_1\cap C_2=\{M_1,A_1\},$$

the singleton sets $\left\{M_1\right\}$ and $\left\{A_1\right\}$ already hit both conflict sets, so they are minimal hitting sets. If neither $M_1$ nor $A_1$ is selected, then one element must be chosen from $C_1\setminus C_2=\left\{M_2\right\}$ and one from $C_2\setminus C_1=\{M_3,A_2\}$. This yields exactly two additional minimal hitting sets, namely $\{M_2,M_3\}$ and $\{M_2,A_2\}$. Therefore,

$$\mathsf{MHS}\left(\mathcal{F}\right)=\left\{\left\{M_1\right\},\left\{A_1\right\},\{M_2,M_3\},\{M_2,A_2\}\right\},$$

and these sets are exactly the minimal diagnosis candidates for this instance.

Thus, even this five-component example yields four inclusion-minimal diagnosis candidates. The growth is much sharper in larger benchmark circuits: for example, the ISCAS-85-derived instance c1355.020 used in Section 6.3 has 4,327,270 expanded minimal hitting sets. Exact enumeration of such families, and compact representation of their output, is the computational problem addressed in this paper.

2.3. Problem Setting and Output Regimes

Two operating modes are common in diagnosis practice. When the diagnosis family remains manageable, full exact enumeration is preferred because it preserves the complete candidate set for later discrimination and validation. When the family becomes too large, one often restricts attention to minimal diagnoses with $\left|H\right|\le K$, since single-fault and other low-cardinality explanations are usually examined first. This bound does not change inclusion-minimality; it only limits which minimal diagnoses are enumerated. The present framework covers both unbounded and cardinality-bounded settings.

When the diagnosis family is large, output representation also becomes part of the computational problem, because explicitly enumerating every minimal diagnosis can dominate the cost. Diagnosis workflows often rank candidates by prior probability, group them by shared components, or inspect only a small subset for measurement-based refinement; see de Kleer and Williams [2] and de Kleer [26]. A compact but exact representation is therefore useful even when enumeration remains complete.

Accordingly, a compact representative-based output is adopted rather than immediate complete enumeration of every diagnosis. Section 4.4 formalizes this Compact Diagnosis Family Representation (CDFR), and Section 3 and Section 4 develop the equivalence notions and search procedure on which it relies.

3. Static Twin Compression

Static Twin Compression exploits the fact that components with identical conflict-coverage patterns are interchangeable with respect to hitting set membership. If two components c and $c^{\prime }$ appear in exactly the same conflicts, then for any minimal hitting set H containing c, the set $(H\setminus \left\{c\right\})\cup \left\{c^{\prime }\right\}$ is also a minimal hitting set, and vice versa.

Definition 5 

(Coverage Signature). The coverage signature of a component c with respect to conflict family $\mathcal{F}=\{C_1,\dots ,C_m\}$ is the set $\sigma \left(c\right)=\{i\in \{1,\dots ,m\}\mid c\in C_i\}$.

Definition 6 

(Static Twin Equivalence). Two components c and $c^{\prime }$ are static twins (also known as twin vertices in hypergraph terminology) if $\sigma \left(c\right)=\sigma \left(c^{\prime }\right)$.

• Static twin classes.

Static twin equivalence partitions the component set into classes of interchangeable components. Let $\left[c\right]$ denote the equivalence class containing c, and let $\left|\right[c\left]\right|$ denote its cardinality.

• STC example.

For

$${\mathcal{F}}_{\mathrm{stc}}=\{\{u,v,x\},\{u,v,y\},\{x,y\}\},$$

the coverage signatures are

$$\sigma \left(u\right)=\sigma \left(v\right)=\{1,2\},\sigma \left(x\right)=\{1,3\},\sigma \left(y\right)=\{2,3\}.$$

STC places u and v in one equivalence class, $\left[u\right]=\{u,v\}$, and keeps x and y as singleton classes. In the original component space,

$$\mathsf{MHS}\left({\mathcal{F}}_{\mathrm{stc}}\right)=\{\{u,x\},\{u,y\},\{v,x\},\{v,y\},\{x,y\}\}.$$

In the representative space with u as the class representative, the corresponding representative diagnoses are

$$\left\{\right\{u,x\},\{u,y\},\{x,y\left\}\right\}.$$

The first two records have STC weight 2 because u can be replaced by either member of $\left[u\right]$, whereas $\{x,y\}$ has weight 1. The total weight is therefore $2+2+1=5$, matching the number of original minimal hitting sets.

Proposition 2. 

Let c and $c^{\prime }$ be static twins, and let H satisfy $c\in H$ and $c^{\prime }\notin H$. Then, H is a minimal hitting set for $\mathcal{F}$ if and only if $(H\setminus \left\{c\right\})\cup \left\{c^{\prime }\right\}$ is a minimal hitting set for $\mathcal{F}$.

Proof. 

Let $H^{\prime }=(H\setminus \left\{c\right\})\cup \left\{c^{\prime }\right\}$. Since $c\in H$ and $c^{\prime }\notin H$, the set $H^{\prime }$ is obtained from H by replacing c with $c^{\prime }$. Because $\sigma \left(c\right)=\sigma \left(c^{\prime }\right)$, this replacement preserves conflict coverage, so H is a hitting set if and only if $H^{\prime }$ is. Now assume that H is minimal. If $H^{\prime }$ were not minimal, then there would exist some $d\in H^{\prime }$ such that $H^{\prime }\setminus \left\{d\right\}$ is still a hitting set. If $d=c^{\prime }$, then replacing $c^{\prime }$ back by c shows that $H\setminus \left\{c\right\}$ is a hitting set. If $d\ne c^{\prime }$, then $d\in H\setminus \left\{c\right\}$, and replacing $c^{\prime }$ back by c shows that $H\setminus \left\{d\right\}$ is a hitting set. Both cases contradict the minimality of H. Hence $H^{\prime }$ is minimal. The converse direction is symmetric.    □

EC-MHS exploits this result by searching over one representative per static class while retaining the class membership information for later use. The precise weight and expansion semantics of those classes are formalized in Section 4.4.

4. The EC-MHS Algorithm

4.1. Dynamic Twin Compression

STC captures equivalence that is determined by the entire input conflict family and remains fixed throughout the search. Additional equivalence may arise during search, when components with different global signatures become indistinguishable in the residual subproblem. Dynamic Twin Compression (DTC) targets this state-dependent redundancy inside the EC-MHS solver.

During depth-first search (DFS), a partial solution P determines two aspects of the remaining subproblem: which conflicts are still uncovered and which selected components still have private-conflict witnesses of minimality. EC-MHS abstracts this information into the following residual state.

Definition 7 

(Residual State). Given a partial solution P and a conflict family $\mathcal{F}=\{C_1,\dots ,C_m\}$, the residual state consists of:

• The set of uncovered conflict indices: $\mathcal{U}\left(P\right)=\{i\in \{1,\dots ,m\}\mid C_i\cap P=\varnothing \}$.
• The set of private conflict indices: $\mathcal{P}\left(P\right)=\{i\in \{1,\dots ,m\}\mid |C_i\cap P|=1\}$.

The uncovered conflicts encode the remaining coverage requirement, whereas the private conflicts encode the active minimality witnesses for the selected components.

Definition 8 

(Dynamic Signature). The dynamic signature of a candidate component c with respect to residual state $(\mathcal{U},\mathcal{P})$ is the pair $\delta \left(c\right)=({\sigma }_U\left(c\right),{\sigma }_P\left(c\right))$, where ${\sigma }_U\left(c\right)=\sigma \left(c\right)\cap \mathcal{U}$ and ${\sigma }_P\left(c\right)=\sigma \left(c\right)\cap \mathcal{P}$.

Together with ${\sigma }_U\left(c\right)$, the set ${\sigma }_P\left(c\right)$ determines how selecting c changes the EC-MHS search state: ${\sigma }_P\left(c\right)$ identifies which current private-conflict witnesses are invalidated, whereas ${\sigma }_U\left(c\right)$ identifies the newly covered conflicts from which fresh witnesses may arise.

Definition 9 

(Dynamic Twin Equivalence). Two candidate components c and $c^{\prime }$ are dynamic twins with respect to the current residual state if $\delta \left(c\right)=\delta \left(c^{\prime }\right)$.

• DTC example.

Consider

$${\mathcal{F}}_{\mathrm{dtc}}=\{\{t,p,c\},\{t,p,d\},\{t,w_1\},\{t,w_2\},\{p,u\},\{c,c^{\prime }\},\{d,v\}\}.$$

Using the identifier tie-break $t\prec p\prec c\prec d\prec c^{\prime }\prec u\prec v\prec w_1\prec w_2$, the residual-coverage order first selects t. After branching on p at $P=\left\{t\right\}$, the raw child pool for $P=\{t,p\}$ is $[c,d,c^{\prime },v]$. At this state,

$$\mathcal{U}\left(P\right)=\{6,7\},\mathcal{P}\left(P\right)=\{3,4,5\},$$

and

$$\delta \left(c\right)=\delta \left(c^{\prime }\right)=(\left\{6\right\},\varnothing ),\delta \left(d\right)=\delta \left(v\right)=(\left\{7\right\},\varnothing ).$$

Thus, d lies between c and $c^{\prime }$ in the raw pool and can occur with either of them in a minimal extension. If DTC is activated at this node, it groups the pool before the child call. Retaining c and d, each with weight 2, yields the record $\{t,p,c,d\}$ with weight 4, representing

$$\{t,p,c,d\},\{t,p,c,v\},\{t,p,c^{\prime },d\},\{t,p,c^{\prime },v\}.$$

Dynamic twins have the following exchange property within a branch-local candidate pool.

Proposition 3 

(Dynamic-twin exchange). Let P be the partial solution at which DTC is applied, and let G be a group of distinct candidates in the same branch-local raw pool with an identical dynamic signature with respect to $\left(\mathcal{U}\right(P),\mathcal{P}(P\left)\right)$. Selecting any member of G gives the same uncovered and private-conflict index sets; only the ownership of the newly private conflicts is assigned to a different selected member. Moreover, for distinct $c,c^{\prime }\in G$ and every set Q of additional candidates with $Q\cap (P\cup G)=\varnothing$, $P\cup Q\cup \left\{c\right\}$ is an inclusion-minimal hitting set if and only if $P\cup Q\cup \left\{c^{\prime }\right\}$ is. No inclusion-minimal hitting set extending P contains more than one member of G. If c and $c^{\prime }$ remain unselected at a descendant partial solution $P^{\prime }\supseteq P$, they remain dynamic twins with respect to $(\mathcal{U}\left(P^{\prime }\right),\mathcal{P}\left(P^{\prime }\right))$.

Proof. 

Equality of ${\sigma }_U$ implies that two members of G cover the same currently uncovered conflicts, and equality of ${\sigma }_P$ implies that they invalidate the same current private conflicts. The two selections therefore give the same residual conflict-index sets.

Let $H=P\cup Q\cup \left\{c\right\}$ be an inclusion-minimal hitting set and set $H^{\prime }=P\cup Q\cup \left\{c^{\prime }\right\}$. Conflicts outside $\mathcal{U}\left(P\right)$ remain hit by P, and equal incidence on $\mathcal{U}\left(P\right)$ shows that $H^{\prime }$ is a hitting set. Every member of H has a private conflict. A private conflict of a member of P belongs to $\mathcal{P}\left(P\right)$, whereas a private conflict of a member of $Q\cup \left\{c\right\}$ belongs to $\mathcal{U}\left(P\right)$. Equality of the two signature components preserves the private conflicts of all members of $P\cup Q$, and a private conflict of c becomes a private conflict of $c^{\prime }$. Hence $H^{\prime }$ is inclusion-minimal. The converse is symmetric.

If a minimal extension contained two members of G, a private conflict of either member would belong to $\mathcal{U}\left(P\right)$. Equality of ${\sigma }_U$ would force that conflict to contain the other member as well, a contradiction. Finally, for a descendant $P^{\prime }$, $\mathcal{U}\left(P^{\prime }\right)\subseteq \mathcal{U}\left(P\right)$. Every conflict in $\mathcal{P}\left(P^{\prime }\right)$ was either uncovered or private at P; equal incidence on both sets therefore preserves the dynamic signature of any two unselected members of G.    □

In Algorithm 1, P denotes the state after the current branch update. The raw child pool is first obtained from one suffix of the parent pool. When DTC is activated, it groups candidates within this pool and removes the non-retained members before the pool is reordered and passed to the child call. Candidates between two group members that survive the residual-coverage filter remain available as part of Q, whereas a removed member is absent from the entire child pool. The exchange and exclusion properties therefore allow one retained branch, with the summed candidate weight, to represent all choices from the group.

In the solver, DTC groups candidates by these dynamic signatures and retains one member per group. The carried weights of all group members are summed into the retained entry; the resulting output-weight semantics are formalized in Section 4.4. Because signature construction incurs nontrivial overhead, the activation policy and state-maintenance scheme are handled by the search procedure below.

Algorithm 1 Main procedure of EC-MHS

Require:  Minimal conflict family $\mathcal{F}$; optional fixed cardinality budget K; configuration $\Theta$ Ensure:  CDFR record multiset $\mathcal{O}$   1: Build component-to-conflict incidence lists   2: Compute STC classes by coverage signature; initialize ordered representative pool $\mathcal{R}$ with $\omega \left(c\right)=\left|\right[c\left]\right|$ for every $c\in \mathcal{R}$   3: Initialize output multiset $\mathcal{O}\leftarrow \varnothing$, the empty-path coverage/private-conflict state, and DFS state $(P,\mathcal{U},\mathcal{T},w)\leftarrow (\varnothing ,\{1,\dots ,m\},\mathcal{R},1)$   4: procedure DFS($P,\mathcal{U},\mathcal{T},w$)   5:     if the optional cutoff rule rejects the current branch then   6:         return   7:     end if   8:     for all $c\in \mathcal{T}$ in coverage-driven order do   9:         Apply c: update covered counts and private-conflict owners; set ${\mathcal{U}}^{\prime }\leftarrow \mathcal{U}\setminus {\sigma }_U\left(c\right)$ 10:         if some component in $P\cup \left\{c\right\}$ has no private conflict then 11:            Roll back c and continue 12:         end if 13:         if ${\mathcal{U}}^{\prime }=\varnothing$ then 14:            if all selected components still own a private conflict then 15:                Output record $(P\cup \{c\},w·\omega (c\left)\right)$ 16:            end if 17:            Roll back c and continue 18:         end if 19:         Build the raw child pool $\widehat{\mathcal{T}}\leftarrow \{d\in \mathcal{T}\mid {\mathrm{ord}}_{\mathcal{T}}\left(d\right)>{\mathrm{ord}}_{\mathcal{T}}\left(c\right),{\sigma }_U\left(d\right)\ne \varnothing \}$ 20:         ${\mathcal{T}}^{\prime }\leftarrow \widehat{\mathcal{T}}$ 21:         if DTC activation conditions in $\Theta$ are satisfied then 22:            Bucket $\widehat{\mathcal{T}}$ by hash of $({\sigma }_U,{\sigma }_P)$ and resolve each bucket by exact comparison 23:            For each confirmed group G, retain its first member $g^{★}$, set $\omega \left(g^{★}\right)\leftarrow {\sum }_{d\in G}\omega \left(d\right)$, and remove $G\setminus \left\{g^{★}\right\}$ from ${\mathcal{T}}^{\prime }$ 24:         end if 25:         if ${\bigcup }_{d\in {\mathcal{T}}^{\prime }}{\sigma }_U\left(d\right)={\mathcal{U}}^{\prime }$ then 26:            Deterministically reorder ${\mathcal{T}}^{\prime }$ using the residual-coverage heuristic 27:            DFS($P\cup \left\{c\right\},{\mathcal{U}}^{\prime },{\mathcal{T}}^{\prime },w·\omega \left(c\right)$) 28:         end if 29:         Roll back c 30:     end for 31: end procedure 32: DFS($P,\mathcal{U},\mathcal{T},w$) 33: return$\mathcal{O}$

4.2. Algorithm Overview

EC-MHS is an exact depth-first enumerator over the STC-compressed set of representatives. Given a family $\mathcal{F}=\{C_1,\dots ,C_m\}$ of minimal conflict sets, it proceeds through four stages: incidence preprocessing, STC grouping, depth-first enumeration with pruning and optional dynamic merging, and output of representative diagnoses with weights.

Figure 2 summarizes these stages together with the separate iSTC update path. The iSTC branch in the figure corresponds to the sequential setting of Section 5: after a new conflict is added, iSTC locally refines the STC partition and prepares the representative pool for a subsequent EC-MHS run.

Figure 2. Overall framework of EC-MHS. STC compresses components with identical coverage signatures before search; DTC merges residual-state-equivalent candidates during search; CDFR records representative diagnoses with weights; and iSTC incrementally refines the STC partition under monotonic conflict addition.

The preprocessing stage builds a sparse component-to-conflict incidence representation and computes the statistics needed by the search heuristic. STC then groups components with identical coverage signatures and retains one representative per class for recursion while preserving the class members for later expansion.

Let $\mathcal{R}$ denote the initial representative pool. At each DFS node with partial solution P, EC-MHS maintains the uncovered conflict set $\mathcal{U}\left(P\right)$, the private-conflict ownership state, the surviving candidate pool $\mathcal{T}\left(P\right)$, and the path weight $w\left(P\right)$. The candidate pool is placed in a deterministic node-local order using the residual-coverage heuristic. The position of c in this pool is denoted by ${\mathrm{ord}}_{\mathcal{T}}\left(c\right)$. After branching on c, only later entries in the current pool are eligible for the raw child pool; the retained child pool is reordered before the recursive call.

Each pool entry c carries a weight $\omega \left(c\right)$, initialized by $\omega \left(c\right)=\left|\right[c\left]\right|$. If DTC confirms a group G and retains $g^{★}$, the retained entry receives

$${\omega }_{\mathrm{new}}\left(g^{★}\right)=\sum _{d\in G}{\omega }_{\mathrm{old}}\left(d\right).$$

The retained member is the first member of G encountered in the deterministic scan of the branch-local raw pool. An unselected entry carries its weight into descendant pools. When all conflicts are covered and minimality is confirmed, the solver outputs a CDFR record rather than immediately expanding all represented diagnoses. Algorithm 1 summarizes the main control flow. Table 1 lists the default DTC activation and adaptive-control settings used in the experiments.

Table 1. Default DTC activation and adaptive-control settings used in experiments.

Setting	Meaning	Default
$d_{\min }$	minimum DFS depth for DTC activation	2
$n_{\min }$	minimum candidate-pool size for DTC activation	8
$u_{\max }$	maximum residual uncovered conflicts for DTC activation	128
$s_{\max }$	maximum residual private conflicts for DTC activation	256
${\rho }_{\min }$	minimum branch-reduction ratio for adaptive DTC	0.05
$N_{\mathrm{early}}$	early adaptive cutoff: ratio $<0.01$ after $N_{\mathrm{early}}$ attempts per depth	8
$N_{\mathrm{level}}$	depth-level adaptive cutoff: ratio $<{\rho }_{\min }$ after $N_{\mathrm{level}}$ attempts per depth	32

4.3. Search Core: Depth-First Enumeration with Pruning

EC-MHS enumerates minimal hitting sets through depth-first search over partial solutions. At a node with partial solution P, uncovered conflicts $\mathcal{U}\left(P\right)$, ordered candidate pool $\mathcal{T}\left(P\right)$, and path weight $w\left(P\right)$, the solver maintains the exact uncovered and private-conflict states. The pool contains the representatives that still cover an uncovered conflict and remain eligible under the node-local suffix rule. Its order is deterministic but local to the current node.

To avoid duplicate enumeration, the loop scans this order without modifying the parent pool and forms each raw child pool only from the suffix after the selected candidate c. Candidates with an empty residual coverage signature are then removed. The dynamic signatures are evaluated after this branch update. DTC, when activated, groups this single raw pool and removes its non-retained members. The retained pool is then reordered by the residual-coverage heuristic and passed to the child call.

The residual-coverage heuristic orders candidates in decreasing order of the number of currently uncovered conflicts they cover, breaking ties in favor of a smaller sum of uncovered-conflict sizes to prioritize candidates that cover smaller, more constrained conflicts. The branch update modifies the conflict-coverage counts, uncovered-conflict set, and private-conflict ownership state in place; all changes are rolled back before the loop advances to its next candidate.

Minimality is enforced during the DFS traversal through private conflicts. By Proposition 1, every selected component in an inclusion-minimal hitting set must own at least one private conflict. EC-MHS therefore tracks, for each path component, how many currently private conflicts it owns. When a new candidate c is added to P, conflicts that were previously private for some other component $c^{\prime }$ may become multiply covered, causing $c^{\prime }$ to lose a witness. If the private-conflict count of any path component drops to zero, the branch cannot lead to an inclusion-minimal hitting set and is pruned immediately.

Proposition 4. 

If some component $c^{\prime }$ in partial solution P has no private conflict, then no extension of P to a complete hitting set is minimal.

Proof. 

If $c^{\prime }$ has no private conflict, every conflict containing $c^{\prime }$ is also hit by at least one other component in P. Removing $c^{\prime }$ from any extension would still yield a hitting set, contradicting minimality.    □

At leaf nodes where all conflicts are covered, EC-MHS performs the corresponding final test: the solution is output only if every selected component still owns at least one private conflict.

Minimality pruning is complemented by a feasibility test on the residual candidate pool. Even if the current partial solution remains minimality-consistent, the search may reach a state where the remaining candidates cannot collectively cover all uncovered conflicts. Joint coverability pruning detects infeasibility and prunes the branch before recursion.

Definition 10 

(Joint Coverability). The residual candidate pool is jointly coverable at node P if

$$\bigcup _{c\in \mathcal{T}\left(P\right)}{\sigma }_U\left(c\right)=\mathcal{U}\left(P\right).$$

EC-MHS checks this condition with an epoch-based marking scheme. Let $M\left[i\right]$ denote the current mark of conflict $C_i$, and let E be the current epoch. At a search node, the solver increments E once; for every candidate $c\in \mathcal{T}\left(P\right)$ and every $i\in {\sigma }_U\left(c\right)$, it sets $M\left[i\right]\leftarrow E$. If fewer than $\left|\mathcal{U}\right(P\left)\right|$ uncovered conflicts receive mark E, the branch is infeasible and is pruned before recursion.

This check has linear cost in the total size of candidate coverage lists and is performed once per search node.

EC-MHS also supports a bounded exact enumeration mode, motivated by diagnosis workflows that inspect low-cardinality explanations first [16,26]. In that mode, the cutoff restricts the target family to $\{H\in \mathsf{MHS}(\mathcal{F})\mid |H|\le K\}$. DTC is attempted only when the residual state is large enough to justify the cost of signature construction: Table 1 sets minimum DFS depth and candidate-pool size thresholds together with upper bounds on residual uncovered and private conflicts, and adaptive branch-reduction checks disable DTC at depths where the observed merge benefit does not justify its computational cost.

Let r denote the number of STC representatives and let $L={\sum }_{C\in \mathcal{F}}\left|C\right|$ be the total incidence size of the input conflict family.

Proposition 5. 

STC preprocessing runs in $O\left(L\right)$ expected time using signature hashing and requires $O(L+r)$ space for the compressed representative set. The DFS part of EC-MHS remains worst-case exponential, exploring at most $O\left(2^r\right)$ representative subsets. At each search node, candidate maintenance, joint coverability checking, and DTC grouping cost $O\left(L_n\right)$, where $L_n$ is the total incidence size of the surviving candidates at that node. Hence the worst-case search time is bounded by $O\left(L{2}^r\right)$. Excluding the output CDFR records and any optional stored DTC trace information, the working memory is $O(L+m+r+h)$, where h is the current DFS depth.

Proof. 

The STC preprocessing stage scans each incidence once to build component signatures and class memberships, which yields $O\left(L\right)$ expected time with hash-based grouping. The DFS enumerator branches only over representatives, so the number of visited subsets is at most the size of the power set of the representative set, namely $2^r$. For a fixed node, all state updates and pruning checks scan only the conflicts incident to the surviving candidates; this is $O\left(L_n\right)$ and $L_n\le L$. DTC adds signature construction and exact verification on the same surviving incidences, so it does not worsen the asymptotic per-node bound. The incidence lists require $O\left(L\right)$ storage, the per-conflict coverage and ownership arrays require $O\left(m\right)$, the representative and class metadata require $O\left(r\right)$, and the recursion stack contributes $O\left(h\right)$. Multiplying the worst-case node count by the worst-case per-node cost yields $O\left(L{2}^r\right)$.    □

Accordingly, EC-MHS remains an exact MHS enumerator with worst-case exponential search complexity. Its structural advantage lies in replacing the original component count by the representative count r when STC is effective, while DTC reduces the realized search tree rather than the asymptotic worst-case bound.

4.4. Compact Diagnosis Family Representation

EC-MHS reports minimal diagnoses in a compact representative–weight form. This subsection defines the representation, its weight, and its expansion and weight-based processing properties.

Definition 11 

(CDFR Record). A CDFR record is a pair $(R,w)$ in which $R=\{r_1,r_2,\dots ,r_k\}$ is a representative diagnosis, i.e., a minimal hitting set expressed over selected STC class representatives, and $w\in {\mathbb{Z}}^{+}$ is the number of concrete diagnoses that R represents. For brevity, w is called the weight of the record.

The weight is determined by the equivalence-class structure: under STC it is the product of selected class sizes, and under DTC it also includes the sizes of dynamically merged groups.

Let $\mathcal{O}$ denote the multiset of all output records. The following invariant holds:

$$\sum _{(R,w)\in \mathcal{O}}w=\left|\mathsf{MHS}\left(\mathcal{F}\right)\right|$$

(1)

in unbounded mode, or $\left|\right\{H\in \mathsf{MHS}\left(\mathcal{F}\right)\mid \left|H\right|\le K\left\}\right|$ when a fixed cardinality budget K is imposed.

Recall from Section 3 that STC partitions the component set into static equivalence classes by coverage signature. For each class representative r, let $\left[r\right]$ denote its static equivalence class (stored explicitly or reconstructed deterministically from the input conflict family), which enables lossless expansion of representative diagnoses.

Definition 12 

(STC Diagnosis Family). For a representative diagnosis $R=\{r_1,r_2,\dots ,r_k\}$, the STC diagnosis family is the set of concrete diagnoses obtained by choosing one member from each static class:

$${\mathcal{D}}_{\mathrm{STC}}\left(R\right)=\left\{\{c_1,\dots ,c_k\}\mid c_i\in \left[r_i\right]\mathrm{for}i=1,\dots ,k\right\}.$$

(2)

Definition 13 

(STC Weight). The STC weight of R is defined as

$$w_{\mathrm{STC}}\left(R\right)={\displaystyle \prod _{i=1}^k}\left|\left[r_i\right]\right|.$$

(3)

The record weight counts represented diagnoses; it is not a fault probability. Component-specific failure priors may be used in downstream probabilistic diagnosis [2], but EC-MHS makes no equal-prior assumption; components in the same static twin class may have different failure priors. If a chosen probabilistic model assigns probability $\mathrm{Pr}\left(H\right)$ to each concrete diagnosis H, the probability mass of the represented STC family is

$$\mathrm{Pr}\left({\mathcal{D}}_{\mathrm{STC}}\left(R\right)\right)=\sum _{H\in {\mathcal{D}}_{\mathrm{STC}}\left(R\right)}\mathrm{Pr}\left(H\right),$$

rather than being inferred from the record weight. Static twins may therefore be interchangeable for MHS enumeration while remaining probabilistically distinguishable.

Proposition 6 

(STC Expansion Correctness). Every element of ${\mathcal{D}}_{\mathrm{STC}}\left(R\right)$ is a minimal hitting set for $\mathcal{F}$, and distinct elements of ${\mathcal{D}}_{\mathrm{STC}}\left(R\right)$ are distinct minimal hitting sets.

Proof. 

All components in $\left[r_i\right]$ share the same coverage signature as $r_i$. Therefore, for any $H\in {\mathcal{D}}_{\mathrm{STC}}\left(R\right)$, replacing each representative $r_i$ with the chosen $c_i\in \left[r_i\right]$ preserves conflict coverage, so H hits all conflicts in $\mathcal{F}$. For minimality, assume H is not inclusion-minimal; then there exists $c_i\in H$ such that $H\setminus \left\{c_i\right\}$ still hits all conflicts. Replacing every remaining $c_j\in H\setminus \left\{c_i\right\}$ by the corresponding representative $r_j$ preserves coverage, implying that $R\setminus \left\{r_i\right\}$ is a hitting set, contradicting the minimality of R. Distinctness follows because the static classes form a partition, so different class-member selections yield different sets.    □

When DTC is enabled, each candidate carries the weight defined in Section 4.2. Consider an output path that selects $(r_1,\dots ,r_k)$, and let ${\omega }_i\left(r_i\right)$ be the carried weight of $r_i$ when it is selected. Equivalently, if $A_i$ is the set of original STC representatives accumulated into this entry, then ${\omega }_i\left(r_i\right)={\sum }_{a\in A_i}\left|\left[a\right]\right|$. The record weight is

$$w={\displaystyle \prod _{i=1}^k}{\omega }_i\left(r_i\right)={\displaystyle \prod _{i=1}^k}\left(\sum _{a\in A_i}\left|\left[a\right]\right|\right).$$

(4)

The sets $A_i$ are disjoint: grouping transfers represented alternatives to one retained entry and removes the other entries, while a selected entry is not passed to descendant pools. By Proposition 3, the alternatives represented by each selected entry are interchangeable for every fixed choice from the other entries. Equation (4) therefore counts every represented diagnosis exactly once, including when a weighted candidate is selected at a later depth or participates in a later DTC merge.

• Optional DTC merge trace.

A CDFR record $(R,w)$ may optionally be accompanied by a merge trace T that records the retained representative and the merged dynamic-twin group at each DTC merge point. The base record preserves the exact aggregate weight; storing T additionally records the merge history needed for later retrieval of individual diagnoses merged by DTC.

The CDFR format supports weight-based processing directly on $\mathcal{O}$ without enumerating the full diagnosis family: record weights w can be aggregated over records with the same $\left|R\right|$ to obtain cardinality-stratified summaries, and concrete diagnoses can be expanded on demand by class-wise expansion of a chosen representative R at the STC level. STC-level expansion (Equations (2) and (3)) is lossless because $\left[r\right]$ is explicitly recorded for each representative, or can be reconstructed deterministically from the input conflict family. The base DTC representation, by contrast, is exact for weight-based aggregation but does not by itself identify the merged alternatives at each DTC step; retrieval of individual diagnoses merged by DTC therefore depends on either the optional merge trace or a separate retrieval procedure.

Theorem 2 

(Soundness and completeness of EC-MHS under CDFR semantics). Given a family $\mathcal{F}$ of minimal conflict sets, the CDFR output of EC-MHS induces exactly $\mathsf{MHS}\left(\mathcal{F}\right)$ in unbounded mode. Every output record corresponds only to inclusion-minimal hitting sets, and every inclusion-minimal hitting set of $\mathcal{F}$ is represented by some output record. Without DTC, each record $(R,w)$ is losslessly expandable by STC-level expansion and satisfies $w=|{\mathcal{D}}_{\mathrm{STC}}\left(R\right)|$. With DTC enabled, w remains exact for counting and weight-based aggregation, and retrieval of individual diagnoses merged by DTC requires either the optional merge trace or a separate retrieval procedure. Under a fixed cardinality budget K, the same statements hold for the restricted family $\{H\in \mathsf{MHS}(\mathcal{F})\mid |H|\le K\}$.

Proof. 

Proposition  2 justifies searching over one representative per STC class. At any DFS node, fix the deterministic order of its current candidate pool. For a minimal representative extension of the current prefix, the earliest remaining member is examined by the loop, and every other member lies in its suffix. Each of those members has a private conflict in the complete minimal solution that is not hit by the updated prefix, so it survives the ${\sigma }_U\ne \varnothing$ filter. Repeating this node-local argument reaches the representative solution, while the earliest-member choice makes its path unique. Reordering a child pool does not affect the argument because the order is fixed within that child call.

Private-conflict pruning and joint coverability remove only prefixes that cannot be extended to an inclusion-minimal hitting set, so every output leaf is sound and no minimal representative solution is lost. When DTC is applied, Proposition 3 shows that replacing a group member by the retained member preserves the complete minimal extension and that no such extension contains two members of the group. Its persistence statement preserves this exchange relation until an unselected weighted candidate is selected or merged again. The carried-weight recurrence and Equation (4) therefore account for every represented choice exactly once. Skipping DTC at any node simply leaves these choices explicit and does not affect soundness or completeness. Proposition 6 then gives the stated CDFR semantics. The same reasoning applies under the fixed cardinality bound K, because every exchange is a one-for-one component replacement.    □

The correctness of EC-MHS therefore relies on the maintained STC partition and on the residual-state semantics used by DTC. In sequential settings with monotonic conflict addition, the first structure that must be updated is that STC partition, which motivates the next section.

5. Incremental Maintenance of the STC Partition

In many MBD workflows, new tests or observations yield additional conflict sets. Incremental STC (iSTC) is introduced as an incremental update procedure for the STC equivalence partition under monotonic conflict addition. It does not maintain the minimal hitting-set family itself, but updates the equivalence structure upon which a subsequent EC-MHS enumeration relies. The update cost is proportional to the size of the newly added conflict, without requiring a full recomputation from scratch.

5.1. Problem Setting

The monotonic setting is defined as follows. An existing conflict family $\mathcal{F}=\{C_1,\dots ,C_m\}$ is extended by a newly added conflict $C_{\mathrm{new}}$ (indexed as $C_{m+1}$), yielding ${\mathcal{F}}^{+}=\mathcal{F}\cup \left\{C_{\mathrm{new}}\right\}$ over the same global component set $\mathcal{C}$.

Recall from Section 3 that the coverage signature of a component $c\in \mathcal{C}$ with respect to $\mathcal{F}$ is ${\sigma }_{\mathcal{F}}\left(c\right)=\{i\in \{1,\dots ,m\}\mid c\in C_i\}$, and STC induces a partition of $\mathcal{C}$ into equivalence classes ${\left[c\right]}_{\mathcal{F}}=\{c^{\prime }\in \mathcal{C}\mid {\sigma }_{\mathcal{F}}\left(c^{\prime }\right)={\sigma }_{\mathcal{F}}\left(c\right)\}$. For brevity, when $\mathcal{F}$ is clear from context the abbreviated notations $\sigma \left(c\right)$ and $\left[c\right]$ are used.

5.2. Incremental Class Refinement

The key observation is that adding a new conflict extends each component’s coverage signature by exactly one binary attribute (membership vs. non-membership in $C_{\mathrm{new}}$), hence the STC partition can only be refined—no classes are merged.

Definition 14 

(Hit/Miss/Split Classification). Let G be an STC class under $\mathcal{F}$ and define $s\left(G\right)=|G\cap C_{\mathrm{new}}|$. The class G is a miss class if $s\left(G\right)=0$, a hit class if $s\left(G\right)=\left|G\right|$, and a split class if $0<s\left(G\right)<\left|G\right|$.

Proposition 7 

(Refinement Property of STC under Conflict Addition). Let $\Pi \left(\mathcal{F}\right)$ be the STC partition induced by ${\sigma }_{\mathcal{F}}(·)$, and let $\Pi \left({\mathcal{F}}^{+}\right)$ be the STC partition induced by ${\sigma }_{{\mathcal{F}}^{+}}(·)$. Then $\Pi \left({\mathcal{F}}^{+}\right)$ is a refinement of $\Pi \left(\mathcal{F}\right)$. More precisely, every miss class or hit class $G\in \Pi \left(\mathcal{F}\right)$ remains intact in $\Pi \left({\mathcal{F}}^{+}\right)$, whereas every split class partitions into exactly two subclasses, namely $G_1=G\cap C_{\mathrm{new}}$ and $G_0=G\setminus C_{\mathrm{new}}$.

Proof. 

For any $c\in \mathcal{C}$, the updated signature satisfies:

$${\sigma }_{{\mathcal{F}}^{+}}\left(c\right)=\left\{\begin{array}{cc}{\sigma }_{\mathcal{F}}\left(c\right)\hfill & \mathrm{if}c\notin C_{\mathrm{new}},\hfill \\ {\sigma }_{\mathcal{F}}\left(c\right)\cup \{m+1\}\hfill & \mathrm{if}c\in C_{\mathrm{new}}.\hfill \end{array}\right.$$

Thus, for any two components $c,c^{\prime }$ in the same class under $\mathcal{F}$ (i.e., ${\sigma }_{\mathcal{F}}\left(c\right)={\sigma }_{\mathcal{F}}\left(c^{\prime }\right)$), they remain equivalent under ${\mathcal{F}}^{+}$ if and only if they have the same membership in $C_{\mathrm{new}}$. Hence each old class either remains intact (if all members agree on membership) or splits into exactly the two subsets induced by membership in $C_{\mathrm{new}}$.    □

An immediate operational consequence is that only classes touched by components already present in the current partition need refinement. Under the fixed-component-set setting, each touched split class creates exactly one new class, so the number of new classes created from old classes equals the number of split classes and is at most $|C_{\mathrm{new}}|$.

• Sparse implementation.

Proposition 7 is stated for a fixed component set $\mathcal{C}$. In a sparse implementation that stores only components already present in the current partition, adding $C_{\mathrm{new}}$ may introduce previously unseen components. With respect to the existing conflict family, those components share an identical empty coverage signature and therefore form one additional class whenever they are nonempty. Accordingly, the observed partition-count increment becomes

$$|\Pi \left({\mathcal{F}}^{+}\right)|-|\Pi \left(\mathcal{F}\right)|=\mathrm{Splits}+\eta ,\eta \in \{0,1\},$$

where $\eta =1$ iff $C_{\mathrm{new}}$ contains previously unseen components. Under the fixed-component-set setting of Proposition 7, $\eta =0$.

5.3. Incremental STC Algorithm

Algorithm 2 performs local partition refinement by scanning $C_{\mathrm{new}}$ once and refining only the affected classes. The algorithm assumes the auxiliary data structures maintained by STC preprocessing: ClassOf$\left[c\right]$ maps each component currently present in the partition to its class identifier, Members$\left[g\right]$ stores the member list of class g, and Size$\left[g\right]$ = | Members$\left[g\right]|$. In such a sparse implementation, components that first appear in $C_{\mathrm{new}}$ need not yet belong to dom(ClassOf); the algorithm therefore collects them separately and inserts them as one additional class before processing previously existing classes affected by $C_{\mathrm{new}}$. In the implementation, Touched is a sparse class-indexed container, and each member list supports $O\left(1\right)$ amortized move/remove operations through swap-delete arrays or an equivalent back-pointer-based scheme. Representative selection follows the same policy as in STC, for example by choosing the minimum identifier in each class.

Algorithm 2 Incremental STC Refinement (iSTC) under adding $C_{\mathrm{new}}$

Require:  Current STC partition under $\mathcal{F}$: ClassOf on currently present components, Members, Size; new conflict $C_{\mathrm{new}}$ Ensure:  Refined STC partition under ${\mathcal{F}}^{+}=\mathcal{F}\cup \left\{C_{\mathrm{new}}\right\}$   1: Touched $\leftarrow$ empty hash map from class-id to list   2: Unseen $\leftarrow$ empty list   3: for all $c\in C_{\mathrm{new}}$  do   4:     if $c\in$ dom(ClassOf) then   5:         $g\leftarrow$ ClassOf[c]   6:         append c to Touched$\left[g\right]$   7:     else   8:         append c to Unseen   9:     end if 10: end for 11: if |Unseen|  $>0$ then 12:     Create new class id $g_u$ 13:     Members$\left[g_u\right]\leftarrow$Unseen, Size$\left[g_u\right]\leftarrow$|Unseen| 14:     for all $c\in$ Unseen do 15:         ClassOf$\left[c\right]\leftarrow g_u$ 16:     end for 17:     Select/update representative for $g_u$ 18: end if 19: for all class ids g in Touched do 20:     $S\leftarrow$Touched[g]                                                                               ▹S = Members$\left[g\right]\cap C_{\mathrm{new}}$ 21:     if $0<\left|S\right|<$ Size[g] then                                                                                      ▹ Split case 22:         Create new class id $g_1$ 23:         Members$\left[g_1\right]\leftarrow S$, Size$\left[g_1\right]\leftarrow \left|S\right|$ 24:         for all $c\in S$ do 25:            ClassOf$\left[c\right]\leftarrow g_1$ 26:            Remove c from Members$\left[g\right]$ 27:         end for 28:         Size$\left[g\right]\leftarrow$ Size $\left[g\right]-\left|S\right|$ 29:         Select/update representatives for g and $g_1$ 30:     end if 31: end for

Proposition 8 

(Time and Space Complexity). Assuming $O\left(1\right)$ expected-time updates for Touched and $O\left(1\right)$ amortized move/remove operations on Members (for example, via swap-delete with back-pointers), Algorithm 2 runs in $O\left(\right|C_{\mathrm{new}}\left|\right)$ expected time and uses $O\left(\right|C_{\mathrm{new}}\left|\right)$ additional temporary space.

Proof. 

Each component in $C_{\mathrm{new}}$ is processed once to populate Touched or Unseen. A touched component is moved at most once, and only components in $C_{\mathrm{new}}$ can be moved out of their old class. If Unseen is nonempty, its members are scanned once more to initialize the optional additional class. Under the stated data-structure assumptions, those operations cost $O\left(1\right)$ amortized each, so the total number of updates is $O\left(\right|C_{\mathrm{new}}\left|\right)$. The temporary storage Touched together with Unseen stores at most the elements of $C_{\mathrm{new}}$. □

• Impact on CDFR.

iSTC preserves the static equivalence structure on which STC-level CDFR semantics depend. Let $(R,w)$ be a CDFR record where $R=\{r_1,\dots ,r_k\}$ is a representative diagnosis and $w_{\mathrm{STC}}\left(R\right)={\prod }_{i=1}^k\left|\left[r_i\right]\right|$ is its STC weight.

When a class $G=\left[r\right]$ is split by $C_{\mathrm{new}}$ into $G_0$ and $G_1$ (Proposition 7), the STC-level diagnosis family ${\mathcal{D}}_{\mathrm{STC}}\left(R\right)$ is correspondingly refined by replacing the factor G with the disjoint union $G_0\uplus G_1$. Defining $R^{\left(0\right)}=(R\setminus \left\{r\right\})\cup \left\{r_0\right\}$ and $R^{\left(1\right)}=(R\setminus \left\{r\right\})\cup \left\{r_1\right\}$, where $r_0\in G_0$ and $r_1\in G_1$ are the updated class representatives, the following weight conservation identity holds.

Proposition 9 

(STC Weight Conservation under a Split). Let R be a representative diagnosis containing a representative r of class G. If G splits into $G_0$ and $G_1$, then

$$w_{\mathrm{STC}}\left(R^{\left(0\right)}\right)+w_{\mathrm{STC}}\left(R^{\left(1\right)}\right)=w_{\mathrm{STC}}\left(R\right),$$

where $w_{\mathrm{STC}}(·)$ is computed using the updated class sizes.

Proof. 

Let $\Gamma ={\prod }_{h\in R\setminus \left\{r\right\}}\left|\left[h\right]\right|$. Then $w_{\mathrm{STC}}\left(R\right)=\left|G\right|\Gamma$, $w_{\mathrm{STC}}\left(R^{\left(0\right)}\right)=\left|G_0\right|\Gamma$, and $w_{\mathrm{STC}}\left(R^{\left(1\right)}\right)=\left|G_1\right|\Gamma$. Since $\left|G\right|=|G_0|+|G_1|$, the identity follows. □

If several representatives occurring in R belong to classes split by $C_{\mathrm{new}}$, the same refinement applies independently to each affected factor. Iterating Proposition 9 over all affected classes therefore yields a disjoint family of refined descendant records whose STC weights sum to the original $w_{\mathrm{STC}}\left(R\right)$.

• Scope boundary.

iSTC updates the STC partition rather than the MHS family itself. After conflict addition, stored CDFR records that reference affected classes must be reinterpreted or regenerated against the refined partition; whether a previously stored diagnosis remains valid depends on the updated conflict family. Conflict removal or modification is outside the present scope. Once the refined partition is available, a subsequent EC-MHS run can reuse the updated class structure after refreshing the representative view and the associated incidence-based search metadata.

6. Experimental Evaluation

STC, DTC, and iSTC are evaluated on ISCAS-85-derived conflict families and on a deterministic synthetic experiment to measure prevalence, runtime impact, and partition-maintenance cost in the studied circuit-diagnosis setting. Section 6.2 reports prevalence statistics over the studied ISCAS-85-derived benchmark set, whereas Section 6.3, Section 6.4 and Section 6.5 use selected instances to examine, respectively, the effect of STC as a preprocessing layer across solver paradigms, the effect of dynamic redundancy on DTC, and the cost of incremental partition maintenance.

6.1. Experimental Setup

All experiments were conducted on a machine running Windows 11, equipped with an Intel Core i7-13700H processor and 16 GB RAM. The implementation is written in C++ and compiled with MSVC 2017 in 64-bit release mode. EC-MHS and the baseline implementations of HS-DAG, Bool, and MHS² were run in single-threaded mode. Wall-clock time was measured at microsecond resolution using a high-resolution system timer. Unless otherwise stated, runtimes are reported in seconds and are medians of three runs. A timeout threshold of 600 s is imposed per instance; entries exceeding this limit are marked “–,” whereas “!” denotes memory exhaustion. Unless otherwise stated, the default DTC activation and adaptive-control settings are summarized in Table 1.

EC-MHS is compared with two primary exact baselines and one additional reference from the heuristic/distributed line. HS-DAG represents the tree/DAG-based search paradigm that extends Reiter [1] through subproblem reuse, while Lin and Jiang [15] and Pill and Quaritsch [16] represent the Boolean formula-transformation line and have shown strong unbounded enumeration performance. As the heuristic/distributed reference, the public MHS² implementation of Cardoso and Abreu [27,28] is used. The comparison therefore spans tree/DAG-based exact search, Boolean reformulation, and heuristic/parallel search while keeping those paradigms distinct from equivalence-aware compressed enumeration.

In the STC-enabled baseline runs, the internal logic of HS-DAG, Bool, and MHS² is not altered. The conflict family is first split by join-relation connectivity, each block is mapped to its representative-only STC view, and the original baseline is invoked on that compressed block, with duplicate representative conflicts removed when the baseline requires a deduplicated conflict list. The purpose of this setup is to test STC as an exact external preprocessing layer rather than to redesign the baselines themselves. These baselines do not use DTC or CDFR; they enumerate representative solutions on the STC-compressed representative set, and the expanded counts reported here are computed afterward from the recorded STC class sizes. Section 6.3 evaluates this preprocessing setup on the selected implementations.

ISCAS-85 benchmark circuits. Following the established practice in diagnosis algorithm evaluation [18,19,20], the experiments use conflict families derived from the ISCAS-85 combinational benchmark circuits [29]. These circuits were proposed at the 1985 International Symposium on Circuits and Systems as a standardized testbed for test generation. All circuits are purely combinational with no memory elements, and their flattened gate-level structures are well-suited for model-based diagnosis analysis. Conflict families were generated using the NGDE tool [30] from fault-injection scenarios established in DXC’09 [31]. Table 2 summarizes the circuit characteristics.

Table 2. ISCAS-85 circuit models. |IN|, |OUT|, |GATES|, VAR, and CLA denote the number of input lines, output lines, logic gates, propositional variables, and clauses in the conjunctive normal form (CNF) model, respectively.

Circuit	|IN|	|OUT|	|GATES|	VAR	CLA
74182	9	5	19	47	75
74L85	11	3	33	77	118
74283	9	5	36	81	122
74181	14	8	65	144	228
c432	36	7	160	356	1028
c499	41	32	202	445	1428
c880	60	26	383	826	2224
c1355	41	32	546	1133	3220
c1908	33	25	880	1793	4756
c2670	233	140	1193	2695	6538
c3540	50	22	1669	3388	9216
c5315	178	123	2307	4792	13,386
c6288	32	32	2416	4864	14,432
c7552	207	108	3512	7232	19,312

The tested conflict families span a wide range of scales, from small instances with tens of conflicts and fewer than 200 components to large instances with hundreds of conflicts and more than 3000 components.

Synthetic data. For the DTC evaluation (Section 6.4), a deterministic synthetic generator with a tunable responder count $\rho$ is additionally used to control the level of dynamic redundancy. It is intended to isolate dynamic equivalence effects rather than mimic a new application domain.

Across the experiments, the reported quantities are runtime, the number of DFS nodes visited by EC-MHS, the expanded MHS count $\left|\mathsf{MHS}\right(\mathcal{F}\left)\right|$ obtained as ${\sum }_{(R,w)\in \mathcal{O}}w$, the number of representative diagnoses in the compressed output, STC preprocessing time, and time-saving and node-saving ratios where appropriate. On every instance where multiple solvers completed, the expanded MHS counts agreed across solvers.

6.2. Prevalence of Equivalence Structure in ISCAS-85 Benchmarks

Static and dynamic equivalence prevalence is measured on ISCAS-85-derived conflict families. The goal is to establish whether the structures exploited by STC and DTC are common in the studied circuit-diagnosis setting. The statistics below are computed over 1237 conflict families from nine nontrivial ISCAS-85 circuits; the four smallest 74xx circuits are omitted because equivalence is universally present at that scale, and c6288 contributes only one family in the available benchmark set. This parallels the prevalence analyses reported for linear and tree conflict structures [19,20], but shifts the focus to component equivalence.

Prevalence is quantified with four metrics. The STC Existence Rate $R_{\mathrm{exist}}^{\mathrm{STC}}$ is the percentage of conflict families in which at least one pair of static twins exists, i.e., where the number of STC equivalence classes is strictly less than the number of distinct components ($\left|R\right|<\left|U\right|$):

$$R_{\mathrm{exist}}^{\mathrm{STC}}={\displaystyle \frac{\left|\right\{\mathcal{F}:\left|R\right(\mathcal{F}\left)\right|<\left|U\right(\mathcal{F}\left)\right|\left\}\right|}{\left|\mathrm{All}\mathrm{families}\right|}}\times 100\%.$$

(5)

This metric captures presence rather than strength: it asks only whether any static compression is available. The Static Compression Degree (SCD) for a conflict family $\mathcal{F}$ with $\left|U\right|$ distinct components and $\left|R\right|$ equivalence class representatives is

$$\mathrm{SCD}\left(\mathcal{F}\right)=\left(1-{\displaystyle \frac{\left|R\right|}{\left|U\right|}}\right)\times 100\%.$$

(6)

This quantity measures the fraction of distinct components eliminated from the representative search set by STC, and higher SCD means a smaller representative set before search. The per-circuit average is reported across all families. The DTC Prevalence Rate $P_{\mathrm{DTC}}$ is the percentage of conflict families in which at least one effective dynamic merge occurs during search within a time limit of 30 s, and the Average Branching Reduction (ABR) is the ratio of the total original candidate count to the total post-merge representative count over all visited nodes:

$$\mathrm{ABR}\left(\mathcal{F}\right)={\displaystyle \frac{{\sum }_{n\in S}C\left(n\right)}{{\sum }_{n\in S}R\left(n\right)}},$$

(7)

where S is the set of visited nodes, $C\left(n\right)$ is the pre-merge candidate count at node n, and $R\left(n\right)$ is the post-merge representative count. A value of $\mathrm{ABR}=1.0$ indicates no dynamic equivalence, whereas $\mathrm{ABR}>1.0$ indicates that dynamic-signature grouping reduces the aggregate candidate width over the visited states. Equivalently, $\mathrm{ABR}=1.318$ means that the aggregate pre-merge candidate count over the visited nodes is 1.318 times the corresponding post-merge representative count. Both $P_{\mathrm{DTC}}$ and ABR are computed by a dedicated instrumented search that applies dynamic-signature grouping unconditionally at every visited node within the 30 s limit; they therefore quantify the raw dynamic equivalence present in an instance, independently of the activation and adaptive-control settings in Table 1, which govern only when the solver exploits that equivalence.

Table 3 reports the resulting per-circuit prevalence statistics.

Table 3. Prevalence of equivalence structure across nine ISCAS-85 circuits (1237 families in total).

Circuit	${\mathit{R}}_{\mathbf{exist}}^{\mathbf{STC}}$ (%)	Avg. SCD (%)	${\mathit{P}}_{\mathbf{DTC}}$ (%)	Avg. ABR
c432	100.00	71.31	80.00	1.146
c499	100.00	68.94	83.69	1.045
c880	100.00	78.69	54.04	1.077
c1355	100.00	87.21	78.57	1.131
c1908	100.00	81.37	93.70	1.260
c2670	96.43	78.06	68.45	1.154
c3540	100.00	84.30	80.56	1.318
c5315	100.00	77.10	81.85	1.110
c7552	98.30	86.21	92.61	1.295

STC is nearly universal in the tested ISCAS-85 families. Static twins appear in at least 96% of all tested conflict families across every reported circuit, and the average SCD ranges from 68.94% (c499) to 87.21% (c1355). In other words, STC typically reduces the number of search candidates by 69–87% before search. Because these figures are computed over the full per-circuit family sets rather than over selected case studies, they establish redundancy among components as a property of the benchmark set rather than of a few isolated instances.

DTC is also widespread, with prevalence between 54% and 94% and ABR between 1.045 and 1.318. The per-node compression is modest in absolute terms, but it compounds on deeper search trees: the circuits with the largest ABR values, especially c1908 and c3540, correspond to the strongest runtime gains in Section 6.4.

6.3. Evaluation of Static Twin Compression

STC is evaluated as the exact external preprocessing layer described in Section 6.1, applied ahead of an unmodified downstream solver.

For each selected conflict family, each of the four algorithms—EC-MHS, HS-DAG, Bool, and MHS²—is run in two modes: (i) with STC, where each block is first mapped to its representative-only conflict family, and (ii) without STC, where the solver operates directly on the original, uncompressed conflict family. The STC preprocessing time is measured separately and included in the total runtime of the STC-enabled configuration. Table 4 reports a selected set of 25 instances chosen to cover 12 circuits, several compression regimes, and multiple cases near the time or memory limits; 74181 contributes three instances and each of the other included circuits contributes two. Because Table 4 evaluates STC as preprocessing, differences among the four +STC columns reflect solver-internal efficiency after the same representative reduction.

Table 4. Effect of STC on MHS algorithm performance. Runtimes are in seconds. “–” denotes timeout at 600 s; “!” denotes memory exhaustion. In each +STC column, the value after the slash, when present, is the saved ratio relative to the corresponding −STC runtime.

Instance	$\left|\mathsf{MHS}\right|$	N	${\mathit{T}}_{\mathbf{STC}}$	EC-MHS		HS-DAG		Bool		MHS2
				−STC	+STC/Saved	−STC	+STC/Saved	−STC	+STC/Saved	−STC	+STC/Saved
74181.030	5070	39	0.000032	0.00020	0.000057/71.5%	2.73	0.00067/99.98%	0.10	0.0011/98.9%	0.0075	0.00019/97.5%
74181.040	33,480	116	0.000039	0.00077	0.00010/87.0%	–	0.026	1.15	0.0043/99.6%	0.061	0.0010/98.4%
74181.053	83,176	1459	0.000048	0.0078	0.00050/93.6%	–	344.05	253.40	0.054/99.98%	3.08	0.037/98.8%
74L85.020	239	32	0.000018	0.000042	0.000034/19.0%	0.0049	0.00037/92.4%	0.0034	0.00081/76.2%	0.00057	0.00014/75.4%
74L85.025	298	19	0.000020	0.000052	0.000036/30.8%	0.0047	0.00014/97.0%	0.0070	0.00055/92.1%	0.0011	0.00011/90.0%
74283.020	1690	208	0.000030	0.00019	0.000082/56.8%	10.17	0.018/99.8%	0.034	0.0042/87.6%	0.0068	0.00099/85.4%
74283.029	1425	69	0.000030	0.00026	0.000063/75.8%	2.54	0.0070/99.7%	0.11	0.0019/98.3%	0.0092	0.00040/95.7%
c432.009	436	2	0.000027	0.000054	0.000034/37.0%	0.00036	0.000050/86.1%	0.0098	0.00019/98.1%	0.00029	0.000056/80.7%
c432.012	10,197	101	0.000046	0.00056	0.000085/84.8%	82.46	0.0051/99.99%	4.19	0.0024/99.9%	0.048	0.00043/99.1%
c499.010	2582	12	0.000022	0.00013	0.000033/74.6%	0.085	0.00011/99.9%	0.12	0.00038/99.7%	0.0054	0.000094/98.3%
c499.020	77,716	15	0.000028	0.0036	0.000042/98.8%	36.44	0.00026/99.99%	196.33	0.00074/99.99%	0.40	0.00017/99.96%
c880.009	46	2	0.000014	0.000025	0.000021/16.0%	0.00013	0.000038/70.8%	0.00052	0.00013/75.0%	0.000073	0.000038/47.9%
c880.020	189,826	206	0.000056	0.0049	0.00011/97.8%	–	0.015	–	0.0065	0.65	0.00079/99.9%
c1355.020	4,327,270	19	0.000053	0.17	0.000066/99.96%	–	0.00019	!	0.00065	–	0.00016
c1355.030	2,373,991	10	0.000057	0.091	0.000068/99.93%	–	0.00014	!	0.00048	–	0.00017
c1908.020	47,375	35	0.000026	0.0020	0.000043/97.9%	225.16	0.00035/99.99%	322.16	0.00097/99.99%	0.19	0.00017/99.9%
c1908.023	11,719,960	2102	0.00017	0.64	0.00040/99.9%	–	–	!	0.073	–	0.056
c2670.042	4960	6	0.000040	0.000081	0.000054/33.3%	0.00039	0.000088/77.4%	0.0040	0.00036/91.0%	0.00026	0.000093/64.2%
c2670.045	26,768	723	0.000066	0.0019	0.00035/81.6%	–	0.55	84.78	0.043/99.95%	0.48	0.0070/98.5%
c3540.009	86	6	0.000024	0.000048	0.000032/33.3%	0.00099	0.000067/93.2%	0.0015	0.00026/82.7%	0.00012	0.000063/47.5%
c3540.015	13,889,700	138	0.00015	0.0098	0.00018/98.2%	–	0.011	–	0.0048	18.94	0.00094/99.99%
c5315.005	50	4	0.000024	0.000046	0.000031/32.6%	0.00027	0.000058/78.5%	0.0011	0.00026/76.4%	0.00020	0.000058/71.0%
c5315.020	4,016,000	428	0.000087	0.0045	0.00016/96.4%	–	0.11	–	0.026	6.78	0.0023/99.97%
c7552.001	712	31	0.00010	0.00023	0.00011/52.2%	–	0.00045	0.076	0.00093/98.8%	3.81	0.00027/99.99%
c7552.004	17,272	148	0.00017	0.0012	0.00020/83.3%	–	0.018	49.17	0.0044/99.99%	–	0.00075

For each instance, the table lists the dataset identifier, the expanded MHS count $\left|\mathsf{MHS}\right(\mathcal{F}\left)\right|$, the representative MHS count after STC compression (N), the STC preprocessing time, and the runtime of each algorithm with and without STC.

On the reported instances, STC preprocessing remains below 0.2 ms (typically 20–170 μs). Within that scope, the preprocessing cost remains small relative to enumeration time. A jointly solved pair is a row in which both the +STC and −STC configurations completed for the same solver. Across jointly solved pairs, the median speedups are $5.4\times$ for EC-MHS, $198.2\times$ for HS-DAG, $81.7\times$ for Bool, and $57.4\times$ for MHS². All jointly solved pairs favor STC; the smallest gains occur only in microsecond-scale cases, where the fixed preprocessing overhead of STC is least amortized.

The median speedup is smallest for EC-MHS because its DFS core with private-conflict and joint-coverability pruning is already efficient even on the uncompressed family. The largest median speedup appears for HS-DAG, whose DAG search is especially sensitive to the number of component labels available for branching. Bool and MHS² also benefit substantially, showing that STC acts as a portable exact preprocessing layer rather than a solver-specific optimization.

STC therefore improves all jointly solved pairs on the reported instances, often by orders of magnitude. On c1355.020 ($\left|\mathsf{MHS}\right|=4,327,270$, compressed to 19 representatives), HS-DAG with STC completes in 0.19 ms whereas the uncompressed run times out, while Bool with STC completes in 0.65 ms whereas the uncompressed run exhausts memory. The compression of the output family is also substantial: c1355.020 reduces 4,327,270 expanded diagnoses to 19 representative records, and c499.020 reduces 77,716 to 15. This gap between $\left|\mathsf{MHS}\right|$ and N directly measures the output compression achieved by CDFR on these instances.

Under the fixed 600 s/16 GB environment, STC also changes which difficult instances remain tractable. On c1908.023, c1355.020, c3540.015, c5315.020, and c7552.004, at least two of the three baselines fail without STC but complete with it.

Appendix A (Table A1) reports the corresponding process-level memory measurements for all 25 instances. For the three uncompressed Bool runs marked by memory exhaustion, the recorded peaks were approximately 14,000 MiB, whereas the corresponding STC-enabled runs completed with peaks of 30.2–79.9 MiB.

6.4. Evaluation of Dynamic Twin Compression

DTC is evaluated in two complementary settings: (1) a deterministic synthetic generator that isolates the effect of varying dynamic redundancy levels, and (2) ISCAS-85 benchmark instances.

Controlled synthetic data are used to study DTC as a function of dynamic equivalence intensity. The synthetic generator creates conflict families with a tunable responder count $\rho \in \{0,1,\dots ,20\}$ while fixing two trigger components, 30 background components, 40 background conflicts, and background density 0.20. For each trigger, $\rho$ responder components are created so that they remain distinct under STC because of trigger-specific difference conflicts, but are merged by DTC after the trigger is chosen and those difference conflicts are covered. For the nonzero values of $\rho$ reported in Table 5, the candidate pool within the trigger structure remains above the activation thresholds in Table 1 after a trigger is selected; DTC therefore merges the interchangeable responders along subsequent search paths. As $\rho$ increases, the amount of dynamic equivalence redundancy grows from absent ($\rho =0$) to substantial ($\rho =20$). This construction therefore isolates the effect of DTC from STC: the responder components remain distinct before search, so only DTC can merge them once the appropriate residual state appears.

Table 5. Runtime (s) on synthetic data with varying Responder parameter $\rho$.

$\mathit{\rho }$	No-DTC	DTC (Adaptive)	Always-on DTC
0	0.0144	0.0146	0.0283
5	0.0146	0.0146	0.0291
10	0.0240	0.0160	0.0328
13	0.1390	0.0255	0.0408
15	0.6705	0.0402	0.0502
17	3.3994	0.0532	0.0686
20	39.239	0.0981	0.1037

Three configurations are compared: no-DTC, which disables DTC entirely and leaves only STC active; DTC (adaptive), which uses the adaptive overhead-control strategy described in Section 4; and always-on DTC, which forces DTC at every eligible node without adaptive disabling. Figure 3 shows the runtime curves and Table 5 lists representative values.

Figure 3. DTC performance on synthetic data. (a) Absolute runtime (log scale) vs. Responder parameter $\rho$ for three configurations. (b) Relative runtime ratios (no-DTC/DTC and always-on DTC/DTC) vs. $\rho$.

Without DTC, runtime grows from 0.014 s at $\rho =0$ to 39.24 s at $\rho =20$ as each additional responder expands the search tree. With adaptive DTC, runtime grows only from 0.015 s to 0.098 s over the same range, for a speedup of up to $400\times$ at $\rho =20$. When no dynamic redundancy is present ($\rho =0$), adaptive DTC is almost indistinguishable from no-DTC, whereas always-on DTC incurs a fixed signature-computation overhead. As $\rho$ increases, the no-DTC/DTC ratio rises monotonically, which is the expected pattern if DTC is exploiting the controlled increase in dynamic redundancy.

The always-on DTC variant is consistently slower than adaptive DTC by roughly 1.05–2.05×, especially at low $\rho$ where dynamic equivalence is sparse and signature overhead is not yet amortized. The difference diminishes as $\rho$ increases and the compression benefit dominates the overhead. Adaptive DTC therefore performs as designed: it is nearly neutral when no dynamic equivalence is available and increasingly beneficial as dynamic redundancy becomes denser.

These synthetic results also give a controlled scalability view: as the responder count $\rho$ grows linearly, no-DTC search must still explore the distinct responder choices once they become relevant to the residual subproblem, whereas adaptive DTC merges those residual-state-equivalent choices so that the effective branching factor grows much more slowly. This behavior matches the role of equivalence compression in EC-MHS: STC reduces the representative universe before search, whereas DTC further reduces the realized branching structure when dynamic equivalence appears along a search path.

The evaluation then proceeds to ISCAS-85 benchmark conflict families. In all experiments below, STC is enabled in both configurations, so the comparison isolates the additional contribution of adaptive DTC relative to STC-only search. Table 6 reports ten illustrative instances spanning low-, medium-, and high-gain regimes among the runs that completed in both modes.

Table 6. Effect of DTC on ISCAS-85 instances. STC is enabled in both configurations.

Instance	Time (s)		DFS Nodes		Time	Nodes
	DTC on	DTC off	DTC on	DTC off	Saved	Saved
c1355.060	0.002196	0.002567	6899	8862	14.5%	22.2%
c1908.043	0.117000	0.143700	154,091	329,252	18.6%	53.2%
c1908.060	21.720000	85.389800	34,978,004	136,095,668	74.6%	74.3%
c3540.028	8.385600	32.033400	15,575,472	70,618,914	73.8%	77.9%
c3540.094	201.383500	475.035600	339,857,333	1,254,152,675	57.6%	72.9%
c5315.312	0.803139	0.871181	3,356,580	4,281,966	7.8%	21.6%
c5315.331	0.807634	0.879524	3,356,592	4,281,978	8.2%	21.6%
c7552.118	0.039786	0.042567	135,661	243,158	6.5%	44.2%
c880.235	0.491297	0.513290	1,936,131	2,230,507	4.3%	13.2%
c880.241	0.491938	0.519655	1,936,135	2,230,511	5.3%	13.2%

For each instance, the table lists the runtime, DFS node count, and the percentage of time and nodes saved by enabling DTC.

On the reported instances, DTC reduces runtime in every listed case and reduces explored nodes at the same time. The median savings are 11.3% in runtime and 33.2% in DFS nodes, while the largest redundancy-rich instances reach 58–75% runtime savings. The strongest gains occur on c1908.060, c3540.028, and c3540.094, where the search trees are deep enough for moderate per-level branching reductions to accumulate.

Node reduction reflects the algorithmic benefit of dynamic equivalence. Runtime reduction additionally accounts for signature construction and grouping overhead. This is why c1908.043 saves 53.2% of nodes but only 18.6% of runtime, while on c1908.060 and c3540.028, the heavier per-node search cost allows the time savings to track the node savings much more closely. The c3540.094 case is particularly notable: runtime decreases from 475 s to 201 s, shifting the instance from near the timeout threshold to a tractable level.

6.5. Evaluation of Incremental STC

When a new conflict is acquired in the sequential setting of Section 5, the STC partition must be updated before re-enumeration. The experiments below measure the cost of this update, isolating partition maintenance rather than end-to-end incremental diagnosis.

For each test instance, a conflict family $\mathcal{F}$ is selected from the ISCAS-85 dataset, one conflict is removed to obtain a reduced family ${\mathcal{F}}^{-}$, and full STC construction is performed on ${\mathcal{F}}^{-}$, yielding the baseline partition with $\left|G\right|$ classes. Eighteen instances are reported, two from each of nine circuits, chosen to cover different partition sizes and split counts. The removed conflict is then added back and two update routes are compared. The first is a full STC rebuild on the updated family $\mathcal{F}$, which produces $|G^{+}|$ classes and whose time $T_{\mathrm{STC}}$ includes recomputing all coverage signatures and regrouping. The second applies Algorithm 2 to refine the existing partition using only the new conflict $C_{\mathrm{new}}$, producing the same $|G^{+}|$ classes with update time $T_{\mathrm{iSTC}}$. For every instance, the two routes are verified to produce identical partitions, including both class counts and class memberships.

Table 7 reports the results. Here, Splits counts only previously existing classes in the baseline partition on ${\mathcal{F}}^{-}$ that are split by $C_{\mathrm{new}}$. Because the implementation stores the partition sparsely over the components already present in ${\mathcal{F}}^{-}$, some rows also create one additional class from previously unseen components in $C_{\mathrm{new}}\setminus \bigcup {\mathcal{F}}^{-}$. Thus the observed relation is $|G^{+}|-|G|=\mathrm{Splits}+\eta$ with $\eta \in \{0,1\}$.

Table 7. iSTC incremental update efficiency compared to a full STC rebuild.

Instance	$\left|\mathcal{F}\right|$	$\left|\mathit{G}\right|$	$|{\mathit{G}}^{+}|$	Splits	${\mathit{T}}_{\mathbf{STC}}$(μs)	${\mathit{T}}_{\mathbf{iSTC}}$(μs)
c432.040	35	49	50	1	168	7
c432.041	20	31	33	2	108	9
c499.088	33	39	43	3	153	8
c499.099	53	54	56	2	178	9
c880.241	47	78	83	5	169	10
c880.244	36	47	48	1	174	6
c1355.121	59	59	61	2	425	10
c1355.122	65	62	64	1	480	17
c1908.050	34	67	70	2	501	16
c1908.052	60	128	131	2	870	35
c2670.249	39	67	71	3	312	31
c2670.251	38	59	61	1	165	7
c3540.053	24	63	70	6	416	28
c3540.063	30	84	85	1	777	30
c5315.355	54	100	102	1	331	8
c5315.370	58	86	89	2	275	13
c7552.162	33	67	68	1	483	17
c7552.239	45	83	86	2	489	26

Across the 18 tested instances, iSTC achieves a mean speedup of $24.0\times$ and a median speedup of $23.8\times$ over a full STC rebuild. The pattern matches the complexity analysis: the cost of a full rebuild grows with the whole conflict family, whereas iSTC depends only on the size of the added conflict and the classes it touches. Larger instances can benefit more, and updates that split only one or two classes are particularly cheap.

The experimental data support the locality assumption underlying iSTC. The new conflict splits only 1–6 previously existing classes out of 31–128 total; in the rows with $\eta =1$, it also creates one additional class from previously unseen components. Thus, most of the partition remains untouched after each update. In every case, iSTC produces the same partition as a full rebuild, and subsequent MHS enumeration yields identical CDFR outputs. On the tested platform, the update takes 6–35 μs instead of the 108–870 μs required for a full rebuild. Although both routes remain sub-millisecond on these instances, the difference becomes relevant in sequential workflows that refresh the STC partition many times.

7. Discussion and Limitations

EC-MHS benefits from redundancy among components rather than from a specific conflict-family topology assumption. In the studied ISCAS-85-derived families, the high prevalence of STC and the observed DTC node savings indicate that interchangeable components are common across the tested circuits. At the same time, the gap between node reduction and runtime reduction in Section 6.4 makes the main trade-off of DTC explicit: dynamic merging can substantially shrink the search tree on redundancy-rich instances, but signature construction and grouping still impose overhead when residual redundancy is weak. The adaptive triggering policy mitigates that overhead without changing the exactness of the solver.

Beyond the measured savings, these results have both theoretical and practical implications. Theoretically, they identify component-side equivalence as a compression axis complementary to the conflict-side structure exploited by decomposition- and topology-based methods. Practically, the preprocessing gains from STC in Section 6.3 show that STC can be inserted as a preprocessing stage before existing MHS engines without changing their internal search logic, provided that class weights are retained for weight-based processing and expansion. For diagnosis engineers working under limited inspection budgets, CDFR replaces a complete expanded diagnosis list with representative diagnoses and exact weights, so storage, count-based ranking, and selective inspection can operate on a short representative list rather than on millions of concrete diagnoses. In a preliminary application to electromechanical systems, practicing diagnosis engineers in our group found class-level inspection workable in their setting and reported that it helped them avoid information overload, improved the perceived responsiveness of the diagnostic system, and made structural patterns in the diagnosis results easier to identify.

The component-side equivalence exploited by STC also has a direct group-theoretic interpretation. Let ${\mathcal{H}}_{\mathcal{F}}=(\bigcup \mathcal{F},\mathcal{F})$ be the conflict hypergraph. If c and $c^{\prime }$ are static twins, the transposition $\left(c{c}^{\prime }\right)$ fixes every hyperedge setwise and hence belongs to the full automorphism group $\mathrm{Aut}\left({\mathcal{H}}_{\mathcal{F}}\right)$; more generally, the direct product of the symmetric groups acting within the STC classes is a subgroup of $\mathrm{Aut}\left({\mathcal{H}}_{\mathcal{F}}\right)$ [32]. Each STC class is therefore contained in an automorphism orbit, but the two partitions need not coincide: a general automorphism may move several vertices and permute hyperedges simultaneously, whereas STC requires independent class-wise substitution, which gives the product weights used by CDFR. DTC is instead tied to the current residual coverage and minimality state, rather than to a global automorphism of ${\mathcal{H}}_{\mathcal{F}}$. Future work may exploit coordinated automorphisms beyond static twins and investigate weak symmetry through approximate equivalence measured by a small signature difference $|\sigma \left(c\right)▵\sigma \left(c^{\prime }\right)|$, or through partial overlap between dynamic signatures. Such approximate relations could guide branch ordering or candidate clustering; using them for compression while retaining exact enumeration would require an additional verification condition.

The runtime and node-reduction evidence in this paper remains centered on the ISCAS-85-derived circuit instances and the controlled synthetic experiment. To examine whether component equivalence is confined to that setting, Appendix B (Table A2) presents a structural analysis of 19 set families from three established MHS benchmark collections: accidents, E. coli metabolic networks, and OCSANA signaling networks [9]. Static twins occur in all 19 instances, with SCD values ranging from 10.00% to 88.69%; dynamic-twin groups were detected within the 30 s window in 16 instances. These results broaden the structural evidence for component-side equivalence beyond circuit diagnosis, although its prevalence and strength vary across the three collections.

8. Related Work

Minimal hitting set enumeration lies at the intersection of diagnosis, combinatorics, and hypergraph algorithms. In the hypergraph literature, the same object is usually called a minimal transversal, and foundational results connect diagnosis-oriented MHS generation to monotone dualization and transversal hypergraph computation [5,6,7,8,10]. Within this broader context, the discussion below focuses on the diagnosis-oriented algorithmic paradigms most relevant to EC-MHS.

Some diagnosis approaches bypass the conflict-first workflow and derive diagnoses more directly from consistency reasoning. A dynamic theorem-proving procedure for consistency-based diagnosis was proposed by Zhang et al. [33], and direct diagnosis generation for high-cardinality faults in knowledge-base debugging was proposed by Shchekotykhin et al. [34]. These methods do not require minimal hitting set computation, whereas EC-MHS is a conflict-based exact enumerator for the inclusion-minimal hitting set family. The remainder of this section reviews the conflict-based paradigms most closely related to this paper.

8.1. Exact Enumeration Methods

Reiter’s HS-tree [1] is the foundational algorithm for diagnosis-oriented MHS enumeration. It constructs a search tree in which each node is labeled with a conflict set, and each branch corresponds to selecting a component from that conflict to include in the partial hitting set. Greiner et al. [13] corrected and generalized this idea in HS-DAG by reusing previously computed subproblems inside a DAG. Wotawa [14] proposed HST-tree to reduce redundant conflict checks through a different node-labeling strategy, and later work refined these tree-search methods with stronger pruning and bookkeeping [35]. Recent diagnosis-search work has also targeted other resource dimensions. DynamicHS [23] reuses and adapts the hitting-set search tree across successive measurements in sequential diagnosis, whereas Rodler [36] studies memory-limited best-first diagnosis enumeration. These advances address state reuse and memory control rather than the component-equivalence compression studied here.

These methods are well suited for diagnosis with incrementally generated conflicts, and they naturally support cardinality-bounded search through depth limits. However, they do not exploit equivalence among components, and their performance can degrade when many components share the same coverage patterns.

Lin and Jiang [15] introduced a Boolean algebraic approach that encodes the conflict family as a disjunctive normal form (DNF) and applies recursive transformation rules to derive a formula encoding the minimal hitting sets. Pill and Quaritsch [16] later strengthened this line with improved decision heuristics and more effective termination criteria for cardinality-bounded search. The Boolean approach offers strong performance in unbounded enumeration but requires post-processing to extract individual hitting sets from the resulting formula, and its bounded-mode performance can be less competitive than tree-based methods when strict cardinality limits are imposed.

A related but distinct objective is to find minimum-cardinality or otherwise preferred diagnoses without enumerating the full inclusion-minimal family. Cost-guided best-first diagnosis search has been explored in model-based embedded systems by Williams and Ragno [37]. de Kleer [26] introduced depth-first hitting-set algorithms that use dual-space reduction, branch-and-bound, and cardinality ranking to produce minimum-cardinality diagnoses efficiently and, in an anytime mode, to extend the ranked output further. SAT-based diagnosis methods such as that of Metodi et al. [17] likewise target preferred diagnoses efficiently, especially under minimum-cardinality objectives. These methods are highly relevant when prioritization is the goal, but their primary target differs from the target of EC-MHS: EC-MHS seeks an exact compact representation of the entire inclusion-minimal diagnosis family, not only a preferred or minimum-cardinality prefix.

A different but relevant line treats compact representation of the solution family itself as a primary objective. Wild [38] develops a wildcard-based framework for compressed MHS enumeration in general hypergraphs. It first uses the transversal e-algorithm to represent the full hitting-set family as disjoint semifinal $012e$-rows, whose inclusion-minimal members form semifinal $01g$-rows; these are then classified and, where necessary, filtered or refined to isolate the MHSes. In its analysis of exact hitting sets, Wild also defines the global hyperedge-incidence equivalence underlying STC, although the g-bubbles used for general MHS compression need not be classes of that relation. In EC-MHS, STC applies this equivalence before DFS, DTC merges residual-state-equivalent candidates during DFS, CDFR attaches exact weights to representative diagnoses, and iSTC maintains the static partition under monotonic conflict addition.

8.2. Structure-Aware and Search-Guided Methods

Several algorithms exploit structural properties of the conflict family to accelerate complete enumeration. Zhao and Ouyang [18] partition the conflict family into disjoint clusters based on join relations among conflicts; the “equivalence classes” in that work are therefore conflict clusters rather than classes of interchangeable components. Zhao et al. [21] study subset recombination to reduce merge costs in divide-and-conquer enumeration. Zhao [19] and Zhao et al. [20] go further by exploiting linear or tree-shaped adjacency among conflicts, using conflict-family topology to simplify the merge step between subproblems. These methods can provide substantial speedups when the assumed decomposition or topology is present, but their performance gains arise from conflict-family structure. EC-MHS is complementary: it compresses the representative search space within each block rather than replacing such decompositions. In the experiments reported in Section 6, each conflict family is first partitioned into independent blocks by join-relation connectivity, and STC then operates within each block.

Heuristic guidance is often introduced either to approximate large instances or to prioritize search. Greedy stochastic diagnosis search and low-cost heuristic approximation of minimal hitting set search have been explored by Feldman et al. [39] and Abreu and van Gemund [40], respectively. Cardoso and Abreu [27] extend this line to MapReduce-style distributed MHS search. Parallel exact diagnosis computation on multi-core architectures has likewise been studied for Reiter-style search by Jannach et al. [41]. A publicly available MHS² implementation additionally offers ambiguity-group removal, which collapses identical component-activation columns before search and reports the retained representatives together with the omitted group members; the remaining candidates can therefore be generated by substitution [28]. On a conflict-incidence matrix, STC and ambiguity-group removal perform the same static representative-column reduction; under STC, each EC-MHS CDFR record carries the product of the selected class sizes as its weight—the exact number of concrete diagnoses represented by that record—whereas the MHS² implementation reports representative candidates and substitution groups separately. DTC and iSTC extend component equivalence beyond this static reduction to residual-state merging during search and incremental partition maintenance, respectively.

A particularly relevant comparative study from the diagnosis community is the empirical evaluation of complete MHS algorithms by Pill et al. [22]. That work compares HS-DAG, HST-tree, Boolean, SAT-based, and related approaches from a diagnostic perspective and analyzes the effect of cardinality bounds. The experiments in this paper are complementary: rather than benchmarking known solvers in isolation, they examine how equivalence compression changes search cost and output structure across solvers.

The STC partition is mathematically the identification of twin vertices in the component–conflict incidence structure: two components are static twins exactly when they appear in the same conflict sets, or equivalently, when they have the same coverage signature. EC-MHS builds on this interchangeability across search, output, and incremental maintenance, so the twin-vertex idea is the entry point of a solver and output framework, not only a preprocessing shortcut.

Table 8 also separates EC-MHS from incremental diagnosis methods. DynamicHS maintains a hitting-set search tree across successive measurements and supports online conflict generation. EC-MHS instead operates on pre-computed conflict families and maintains only the STC partition under monotonic conflict addition. Lin and Jiang [15] also describe an algebraic update identity when a conflict is added to a Boolean MHS formula, but that operation does not maintain a search state or an equivalence partition. It is therefore different from iSTC and from the incremental distributed algorithm of Zhao and Ouyang [18].

Table 8. Comparison of EC-MHS with representative diagnosis-oriented MHS methods. “Online conflicts” indicates whether conflict sets can be generated during search rather than pre-computed. Boldface identifies the proposed EC-MHS method and its characteristics.

Method	Paradigm	Online Conflicts	Component Equiv.	Compact Output	Incremental
HS-tree	Tree search	Yes	No	No	No
HS-DAG	DAG search	Yes	No	No	No
Bool	Boolean formula	No	No	No	No
MHS2	Heuristic DFS	No	Static (optional)	Representatives + groups	No
Join-relation	Decomposition	No	No	Tuple representation	Partial
DynamicHS	Stateful tree	Yes	No	No	Yes
EC-MHS	DFS & Equivalence	No	Yes (STC+DTC)	Yes (CDFR)	Partial (iSTC)

Viewed through Rodler’s taxonomy [42], EC-MHS is a conflict-dependent, sound, complete, multiple-solution, one-shot diagnosis enumerator operating on pre-computed conflicts. Within this space, its distinctive feature is equivalence-based compression with explicitly defined compressed-output semantics, making it complementary to stateful sequential diagnosis methods that reuse search structure across successive measurements. MHS² is included in Table 8 as a heuristic reference. With cutoffs disabled, its public implementation supports sound and complete enumeration; enabling a cutoff sacrifices completeness and, except for the cardinality cutoff, soundness [28].

9. Conclusions

This paper presented EC-MHS, an exact minimal hitting set enumerator for model-based diagnosis that exploits component equivalence through STC, DTC, CDFR, and iSTC while preserving inclusion-minimality semantics. On ISCAS-85-derived conflict families, STC reduces the number of search candidates by 69–87% before search, DTC reduces runtime by up to 75% on redundancy-rich benchmark instances, and iSTC maintains the STC partition $24\times$ faster than a full rebuild. CDFR preserves exact counts and supports weight-based aggregation. STC-only records are losslessly expandable class-wise, whereas retrieving individual diagnoses merged by DTC requires the optional merge trace or a separate retrieval procedure.

From a symmetry perspective, the equivalence structures exploited by EC-MHS reflect a concrete form of component symmetry in the system under diagnosis. Components sharing the same coverage signature are interchangeable with respect to all conflict sets. In practical circuits and other engineered systems, such component symmetry can arise from replicated functional modules, parallel signal paths, or identical gate structures. The prevalence data in Section 6.2 shows that this symmetry is widespread in the tested circuit-diagnosis instances, and the preliminary structural analysis in Appendix B indicates that it is also prevalent in real-world set families from data mining and computational biology.

Future work should extend the empirical evaluation beyond the studied circuit-diagnosis setting, especially to knowledge-base debugging, software fault localization, and other diagnosis domains with different conflict-generation mechanisms. Another direction is incremental MHS solving that updates not only the STC partition but also the represented diagnosis family. A third direction is to integrate equivalence-based compression with sequential diagnosis methods that generate conflicts across successive measurements and incorporate component-specific failure priors for probabilistic diagnosis ranking and measurement selection. Practical retrieval procedures for individual diagnoses merged by DTC should also be studied, especially when storing a complete merge trace is too costly.