Zero-Suppressed Binary Decision Diagrams

• Zero-Suppressed Binary Decision Diagrams (ZDDs) are a canonical, ordered DAG structure that compactly represents large families of sparse sets using zero-suppression rules.
• They enable orders-of-magnitude compression compared to naive representations, making them ideal for combinatorial optimization, symbolic model checking, and graph algorithms.
• ZDDs support efficient set operations like union, intersection, and difference via recursive apply algorithms with memoization, though some operations can induce exponential complexity.

A zero-suppressed binary decision diagram (ZDD) is a canonical, ordered, directed acyclic graph data structure for compact representation and manipulation of large families of sets. Introduced by Minato in 1993, ZDDs provide a memory-efficient and computationally tractable way to enumerate, store, and operate on extensive sets of sparse combinatorial objects, often enabling orders-of-magnitude compression relative to naïve listing or classical BDDs. ZDDs have become the standard structure for set-family manipulation in combinatorial optimization, symbolic model checking, graph algorithms, statistical mechanics, and circuit synthesis, among others.

1. Fundamental Structure and Semantics

A ZDD over ground set $X = \{x_1, \ldots, x_n\}$ is a rooted, ordered DAG whose internal nodes are labelled by variables $x_i$ (according to a fixed order) and have two outgoing arcs: the 0-arc (exclusion of $x_i$) and the 1-arc (inclusion of $x_i$). The semantics is defined recursively:

• The 1-terminal ($\top$) represents the family $\{\emptyset\}$.
• The 0-terminal ($\bot$) represents the empty family $\emptyset$.
• A non-terminal node $n$ labeled $x$ with lo-child $x_i$0, hi-child $x_i$1 represents $x_i$2.

Paths from the root to $x_i$3 encode exactly the subsets (by variables along which the path takes 1-arcs). Along every root-to-leaf path, variable labels are strictly increasing. The zero-suppression rule asserts that any node whose hi-child is $x_i$4 is spliced out—redirecting all its incoming arcs to its lo-child—ensuring that variables which do not appear at all in a root-to-$x_i$5 path are interpreted as being "absent" in the represented set. Node-sharing merges all isomorphic subgraphs, yielding a canonical, minimized graph per family and variable ordering (Nakamura et al., 2024, Shinohara et al., 2021).

2. Comparison with BDDs and Canonical Reduction Rules

ZDDs are closely related to binary decision diagrams (BDDs), but differ crucially in their asymmetry and reduction principles:

• BDDs use the "don't-care" reduction (eliminate nodes whose 0- and 1-arcs point to the same child), making them symmetric in 0/1.
• ZDDs use "zero-suppression," eliminating nodes where the hi-child is $x_i$6, encoding an implicit default: "unmentioned variables are false."

As a consequence, ZDDs provide drastic compression for families that are sparse (few sets with small size), while BDDs excel for functions/dense set families (Emoto et al., 2024, Kojima, 2018).

Reduction rules for ZDDs:

1. Zero-suppression: hi-child = $x_i$7 $x_i$8 remove node, redirect to lo-child.
2. Node-sharing: merge all nodes with identical labels and children.

These rules ensure uniqueness and canonicity with respect to a variable order.

3. Complexity of ZDD Operations

Set-family algebraic operations—union, intersection, difference, symmetric difference—are implemented via two-way recursive “apply” algorithms with memoization, running in worst-case $x_i$9 time, where $x_i$0 and $x_i$1 are node counts of the operand ZDDs. These operations are worst-case polynomial time in the sizes of the input ZDDs (Nakamura et al., 2024, Shinohara et al., 2021).

However, Nakamura, Nishino & Denzumi (2024) prove that all other set-family operations from Knuth’s library—join, meet, delta, quotient, restrict, minimal, maximal, minimal hitting-set, closure, etc.—can force exponential blow-up in ZDD size even for carefully constructed sparse input ZDDs and under the best possible variable ordering. In particular, many family-algebra operations embed canonical hard structures ($x_i$2, $x_i$3), whose ZDDs have size $x_i$4 for all possible orderings.

Consequently, outside the four “boolean-like” operations, no guarantee of polynomial time in input ZDD size is possible; worst-case exponential space and time are unavoidable for such family operations (Nakamura et al., 2024).

4. Compression, Succinctness, and Advanced Representations

ZDDs provide practical and often dramatic compression of set families. If $x_i$5 is the number of sets in the represented family on $x_i$6 elements, a naïve trie or decision tree would use $x_i$7 nodes. For important combinatorial families (matchings, paths, permutations, k-element subsets), ZDDs often use only $x_i$8 nodes.

Top ZDDs, introduced by Matsuda, Denzumi, and Sadakane, exploit further structure by compressing the ZDD’s DAG via spanning trees and DAG-compression (top-tree/top-DAG structures). For highly regular set families (e.g., full power set), the top ZDD representation can provide exponential space savings, reducing $x_i$9 ZDD nodes to $x_i$0 clusters (Matsuda et al., 2020).

Family	Top ZDD Size	DenseZDD Size	Naïve ZDD Size
Power-set ($x_i$1)	2,297 bytes	4,185 bytes	3,750 bytes
Sliding-window ($x_i$2)	2,551 bytes	32K bytes	1.4M bytes
Grid-paths ($x_i$3)	503K bytes	1.4M bytes	2.1M bytes

Navigational and set-operations are supported in time $x_i$4 per step with top ZDDs (Matsuda et al., 2020).

5. Applications in Combinatorial Optimization and Symbolic Methods

ZDDs are leveraged for exact and efficient enumeration, optimization, and constraint filtering for large combinatorial families.

• Special Quasirandom Structures (SQSs): ZDD-based algorithms efficiently enumerate all substitutional structures for SQS search, supporting constraints for composition, symmetry, and pair correlation, and reducing $x_i$5 candidate sets to a handful of feasible solutions in practice (Shinohara et al., 2021).
• Graph Coloring (Branch-and-Price): Representation of all maximal independent sets via ZDDs enables efficient, incremental modification (restrict to exclude columns), with extremely fast pricing (DP over ZDD in $x_i$6), supporting rapid enumeration and update under branching for integer programming (Morrison et al., 2014).
• Graph Partitioning: Combinations with ternary decision diagrams (TDDs) extend capabilities to signed set constraints, realizing filtering/enumeration over $x_i$7 graph partitions under tight component weight constraints (Nakahata et al., 2018).
• Matroid Oracles: For classes such as uniform, partition, or nested matroids, ZDDs succinctly encode the independence or base family, enabling fast rank computation and membership queries, with formal bounds in terms of matroid connectivity/pathwidth (Emoto et al., 2024).
• Boolean Synthesis and Symbolic Model Checking: ZDDs encode solution "schemes" for quantified Boolean formulas and symbolic DEL models, providing compactness for sparse, highly-constrained systems (Lin et al., 7 Dec 2025, Miedema et al., 2023).

6. Limitations, Complexity, and Theoretical Aspects

Despite their strengths, ZDDs face fundamental hardness for many set-family operations. Any algorithm implementing join, delta, restrict, minimal/maximal, etc., can require a ZDD with exponential node count, and this is independent of variable order or dynamic reordering. Hence, practical usage should restrict to unions, intersections, and differences when scalability in ZDD size is essential (Nakamura et al., 2024).

From a computational complexity view, the zero-suppression principle gives rise to a new class of branching programs (“zero-suppressed branching programs,” ZSBPs), which, depending on constraints (width, read-once), characterize different circuit families (e.g., NC$x_i$8, NC$x_i$9, L/poly) (Morizumi, 2016).

The categorical distinction between BDDs and ZDDs is rooted in naturality: ZDDs are natural as representations of functorial families (sets of sets) under label-relabelling, whereas BDDs are natural for Boolean function semantics (Kojima, 2018).

7. Advanced Extensions and Practical Trade-offs

Chain-reduced ZDDs (CZDDs) generalize standard ZDDs to exploit "don’t-care" chains (not just zero-chains), providing strict size guarantees: the CZDD representation is never larger than the ZDD and at most twice the BDD size, with practical reductions in intermediate operation sizes and run-times, especially in applications with large alphabets or repetitive structure (Bryant, 2017).

Interval-memoized backtracking integrates ZDD search with branch-and-bound and DP, optimizing enumerative tasks under secondary constraints (e.g., total cost) over gigantic solution spaces, and achieving enumeration rates up to $\top$0–$\top$1 solutions/sec in practice (Minato et al., 2022).

In model checking, ZDDs can be selected among several asymmetric suppression variants (T0, T1, E0, E1) to best match the structural sparsity or bias in the function, yielding up to a 2x reduction in memory footprint and comparable speedups (Miedema et al., 2023).

---

References:

(Nakamura et al., 2024, Shinohara et al., 2021, Lin et al., 7 Dec 2025, Matsuda et al., 2020, Emoto et al., 2024, Morrison et al., 2014, Bryant, 2017, Nakahata et al., 2018, Minato et al., 2022, Miedema et al., 2023, Kojima, 2018, Morizumi, 2016, Smith et al., 2019)