Zero-Suppressed Decision Diagrams

• Zero-Suppressed Decision Diagrams (ZDDs) are canonical, reduced graphs that represent families of sets by applying the zero-suppression rule to prune redundant nodes.
• ZDDs efficiently solve sparse combinatorial problems, such as minimal vertex covers and subgraph enumeration, using memoized recursion and compression techniques.
• Their sensitivity to variable ordering and integration with hybrid approaches make ZDDs pivotal for optimizing Boolean synthesis, model checking, and symbolic enumeration tasks.

A zero-suppressed decision diagram (ZDD) is a canonical, reduced, rooted, directed acyclic graph for representing families of sets (i.e., sets of subsets), particularly efficient for sparse combinations. ZDDs were introduced by Minato (1993) and have become fundamental in modern combinatorial set representation, Boolean functional synthesis, symbolic enumeration, and numerous applications across optimization, verification, reconfiguration, and enumeration tasks (&&&0&&&, Shinohara et al., 2020, Kojima, 2018, Lin et al., 7 Dec 2025). The defining property of ZDDs is the zero-suppression rule: nodes whose “include” edge always leads to the rejecting terminal (0-terminal) are eliminated, leading to highly compact representations for search spaces in which most items are absent in typical sets.

1. Formal Structure and Semantics

Let $X = \{x_1, \dots, x_n\}$ be an ordered universe. A ZDD over $X$ consists of:

• Terminal nodes: 1 (accepting, true) and 0 (rejecting, false).
• Nonterminal nodes: Each labeled by a variable $x_i$ with $1 \leq i \leq n$, and two outgoing arcs:
  • 0-edge (exclusion of $x_i$)
  • 1-edge (inclusion of $x_i$)
• Along every path from the root to a terminal, variable labels strictly increase.

The semantics is: each root-to-1 path uniquely corresponds to a subset of $X$ consisting of the labels of nodes whose 1-edges are traversed. The ZDD represents the family of all such subsets (Kojima, 2018, Shinohara et al., 2020, Lin et al., 7 Dec 2025).

Reduction Rules

The canonical reduced ZDD is obtained by two rules:

Rule	Action
Zero-suppression	If a nonterminal’s 1-child is 0-terminal, delete the node and redirect incoming arcs to the 0-child.
Isomorphism	Merge any two nodes with identical variable, 0-child, and 1-child.

These rules guarantee a unique, minimal ZDD for each set family and variable ordering (Bryant, 2017, Shinohara et al., 2020, Kojima, 2018).

2. Comparison with Binary Decision Diagrams (BDDs)

Both ZDDs and reduced, ordered BDDs encode Boolean functions as acyclic graphs, but enforce fundamentally different reduction semantics:

• BDD node elimination: Remove a node if its 0- and 1-children coincide.
• ZDD zero-suppression: Remove a node if its 1-child is the 0-terminal.

This yields very different behaviors depending on the density of the 1-cubes (sets where the function evaluates to true):

Aspect	BDD Elimination	ZDD Elimination
Node removal	when low(v)=high(v) (symmetric)	when high(v)=0 (asymmetric, zero-suppressed)
Best for	dense 1-cubes (many “full” assignments)	sparse support (combinatorial families with few items included)

The functorial distinction is formalized: BDDs are natural representations for Boolean functions ($2^X$), while ZDDs are natural for set families ($\mathcal{P}(\mathcal{P}(X))$), and no natural isomorphism exists between these two functor categories (Kojima, 2018, Morizumi, 2016). For many sparse families (e.g., all minimal vertex covers, sparse itemsets), ZDDs are exponentially smaller than BDDs (Miedema et al., 2023, Matsuda et al., 2020).

3. Operations and Algorithms

ZDDs support efficient, memoized recursion for set-family operations:

• Union ($\cup$), Intersection ($\cap$), Difference ($\setminus$): Implemented recursively. At each node, recursions progress by variable, and nodes/returns are shared via hash tables. Zero-suppression prunes subcomputations aggressively.
• Cardinality constraints, filtering, and custom intersections: Construct ZDDs representing restrictions or constraints, then combine using intersection.
• Apply-algorithm: Supports general recursive “apply” of any binary Boolean operator, respecting variable order and reduction rules (Lin et al., 7 Dec 2025, Bryant, 2017).
• Cost-bounded and interval-memoized enumeration: For weighted objects, augment ZDD recursion with interval memoization—memoizing on value ranges—to efficiently enumerate all solutions within a cost threshold, yielding time $O(|f| + |h| \log |h|)$ where $|f|$, $|h|$ are input/output size (Minato et al., 2022).

Many algorithms employ frontier-based construction—progressively constructing ZDD layers by maintaining only information about active variables at the current "frontier," minimizing width and redundant computation (Shinohara et al., 2020, Nakahata et al., 2018).

4. Structural Variants and Compression Techniques

Extending classical ZDDs, several structural variants and compression techniques have been proposed:

• Chain-reduced ZDDs (CZDDs): Merge length-$k$ “don’t-care chains” (sequences where each node’s 0- and 1-child are the same) into single nodes. For any function $f$, $|\text{CZDD}(f)| \leq |\text{ZDD}(f)|$ and $|\text{CZDD}(f)| \leq 2 |\text{BDD}(f)|$. CZDDs improve intermediate memory and time by up to $10–15\times$ on sparse-encoded problems, while guaranteeing never to exceed unchained ZDD size (Bryant, 2017).
• Top ZDDs: Use DAG-compression via “top tree” cluster sharing, yielding representations where set families with repetitive vertical structure compress from size $n$ to $O(\log n)$ in e.g., the full powerset. Navigational operations are supported in $O(\log^2 n)$ per step (Matsuda et al., 2020).

5. Applications Across Domains

ZDDs have demonstrated significant impact in a broad spectrum of combinatorial and symbolic applications:

• Enumeration of Combinatorial Objects: Structure enumeration in substitutional alloys, especially under symmetry, is conducted efficiently by ZDDs leveraging canonical set-family operations and compression (Shinohara et al., 2020, Shinohara et al., 2021).
• Graph partitioning and subgraph enumeration: ZDDs, often hybridized with ternary decision diagrams (TDDs), represent graph partitions subject to complex constraints (e.g., minimum component weights), enabling enumeration orders-of-magnitude faster than previous approaches (Nakahata et al., 2018).
• Phylogeny and biological data analysis: ZDD encodings outperform branch-and-bound for enumeration of all completions in perfect phylogeny, handling solution spaces $10^{14}$ times smaller than explicit enumeration (Kiyomi et al., 2012).
• Symbolic SAT and Boolean synthesis: ZDDs are used for variable elimination in CNF formulas, clause distribution, and QBF/Boolean synthesis via dynamic programming on tree decompositions, exploiting subsumption-free union, symbolic resolution, and efficient projection (Lin et al., 7 Dec 2025, Dijk et al., 2018).
• Model checking and logic synthesis: ZDDs naturally model systems with many default-zero variables (e.g., sparse Kripke structures for dynamic epistemic logic), often reducing memory compared to BDDs (Miedema et al., 2023).
• Quantum circuit mapping: ZDDs encode sets of mapping and swap possibilities, supporting partitioning, parallelization, and efficient constraint enumeration in NISQ-era quantum compilation (Smith et al., 2019).

6. Scalability, Theoretical Bounds, and Practical Observations

Empirical and theoretical work substantiates:

• Compression: In instances with highly structured or sparse families (e.g., independent sets, special quasirandom structures), ZDDs can compress solution sets containing $10^{16}$–$10^{18}$ objects into diagrams of size $10^7$–$10^8$ (Shinohara et al., 2020, Shinohara et al., 2021).
• Complexity: Operations such as union, intersection, and filtering run in time polynomial in the ZDD size $O(|A|\cdot|B|)$, often sublinear in the number of represented sets (Lin et al., 7 Dec 2025, Minato et al., 2022).
• Output-sensitivity: Enumeration algorithms based on interval-memoized backtracking yield performance bounded by the size of the input/output ZDD, rather than the range of cost parameters or the total number of solutions (Minato et al., 2022).
• Ordering sensitivity: The efficiency and compactness of ZDDs depend critically on variable ordering; heuristics (e.g., MCS, sifting) are often required for robust performance (Lin et al., 7 Dec 2025, Miedema et al., 2023).

7. Advanced Topics and Future Directions

Reflecting growing theoretical and practical interest, several research avenues are in active development:

• Zero-suppressed computation models: Generalizing the ZDD paradigm, zero-suppressed computation (ZSBPs, zero-suppressed decision trees) yields new insights in computational complexity, with connections to NC$^1$, L/poly, and their relationships remaining open (Morizumi, 2016).
• Generalized ZDD elimination rules: Exploring the effect of asymmetric suppression (T0/T1/E0/E1 rules) allows tailoring diagram size for specific domains, though no type dominates universally (Miedema et al., 2023).
• Hybrid diagrammatic approaches: The combination of ZDDs with other DD types (e.g., TDDs) and their integration in symbolic frameworks for reconfiguration, optimization, and combinatorics broadens the scope and efficiency of such representations (Nakahata et al., 2018, Ito et al., 2022).
• ZDD-based symbolic planning and synthesis: The use of ZDDs in planning-execution loops, bounded by empirical "magic numbers" for treewidth and planning-phase time, balances exploration and exploitation to scale symbolic synthesis to industrial cases (Lin et al., 7 Dec 2025).
• Canonical representation and portability: The canonical nature of ZDDs under fixed orderings underpins reliable enumeration, counting, optimization, and iterative solution-space restriction, as exemplified in branch-and-price for integer programming (Morrison et al., 2014).
• Limitations: ZDDs' advantages are diminished for dense or unstructured solution sets—in such cases, classical BDDs may be preferable. Complexity of intermediate ZDDs can still be exponential, and effective compression is highly problem-structure dependent (Shinohara et al., 2020, Kiyomi et al., 2012).

As a canonical, output-sensitive, and memory-efficient symbolic representation, ZDDs occupy a central position in the computational toolbox for set families, especially when zero is the “default” value and most sets are sparse. Their continued development, hybridization, and theoretical study enable efficient manipulation, enumeration, and synthesis across a spectrum of modern combinatorial computation (Bryant, 2017, Shinohara et al., 2020, Kojima, 2018, Lin et al., 7 Dec 2025).