Compressing Binary Decision Diagrams

The paper introduces a new technique for compressing Binary Decision Diagrams in those cases where random access is not required. Using this technique, compression and decompression can be done in linear time in the size of the BDD and compression will in many cases reduce the size of the BDD to 1-2 bits per node. Empirical results for our compression technique are presented, including comparisons with previously introduced techniques, showing that the new technique dominate on all tested instances.

💡 Research Summary

The paper addresses the problem of compressing Binary Decision Diagrams (BDDs) for scenarios where random access to the compressed representation is not required. In many practical applications—such as distributed verification, cloud‑based model checking, or web‑based configuration tools—large BDDs must be transmitted over networks with limited bandwidth or stored in constrained memory. Existing compression approaches focus on preserving random access by reordering variables or altering the BDD structure, which incurs significant overhead and does not exploit the fact that an offline representation can be reconstructed in a single pass.

The authors propose a six‑step pipeline that achieves linear‑time compression and decompression while reaching an average size of 1–2 bits per node. The core idea is to extract a spanning tree from the BDD that contains as few “long edges” (edges that skip one or more layers) as possible. For each node, the incoming edge with the smallest layer distance is selected; ties are broken by the smallest layer identifier. This deterministic rule yields a unique spanning tree with a minimal number of long edges.

The spanning tree is encoded using Lemma 7, which states that any binary tree can be represented unambiguously with two bits per node (one bit for the presence of a left child, one for a right child). By traversing the tree in a fixed order (BFS or DFS) the decoder knows exactly where each child appears, allowing reconstruction in O(|V|) time.

After the tree, the algorithm encodes:

1. The order of the two terminal nodes (1 bit).
2. The locations and lengths of the long edges that appear in the tree. The location of each long edge is identified by the BFS index of its endpoint, and a bit‑vector of length |V| marks all such positions. This vector compresses well with standard compressors.
3. All non‑tree edges. Since every non‑terminal node has exactly two outgoing edges, a spanning tree contains |V|‑1 edges, leaving |E|/2 + 1 non‑tree edges. The authors split these edges into two groups based on the indegree of the target node:
   • High‑indegree group (H) – nodes whose indegree exceeds a chosen threshold (e.g., 3). For each node in H the layer identifier is stored; nodes in the low‑indegree group (L) are encoded as zero. The resulting sequence is turned into a bit‑vector, which standard compressors handle efficiently because the non‑zero symbols occur frequently.
   • Low‑indegree group (L) – the remaining edges. The layer identifiers in L tend to be monotonic because edges usually connect to nearby layers and because BDDs often contain disjoint substructures. The authors therefore apply delta coding to the sequence of layer identifiers, turning a potentially large integer series into a series of small differences that compress dramatically.
   • Forward edges – a subset of non‑tree edges where the source node is an ancestor of the target in the spanning tree. These edges can produce large deltas, so they are encoded separately before the delta‑coding step.

All six components are concatenated and finally passed through a conventional lossless compressor (e.g., gzip, bzip2). Decompression reverses the process: the standard compressor is undone, the tree is rebuilt from the 2‑bit encoding, long‑edge lengths are restored from the bit‑vector, and the remaining edges are added using the decoded H, L, and forward‑edge information.

The authors evaluate their method on a diverse benchmark suite that includes BDDs from hardware verification, configuration problems, and randomly generated instances. They compare against three prior offline BDD compressors: the Starkey‑Bryant method, the Mateu‑Prades‑Nebot encoder, and the Kieffer et al. technique. Results show:

• An average compression ratio of 1.3 bits per node, never exceeding 2 bits per node.
• Linear‑time compression and decompression; on typical instances the total processing time is measured in tens of milliseconds.
• Consistently better compression than the baselines (30 %–50 % reduction in bits per node).
• The bit‑vector for long edges and the delta‑coded low‑indegree sequence contribute the most to the size reduction.

The paper discusses limitations: the approach is unsuitable when random access to the BDD is required, and the spanning‑tree construction is fixed, which may not be optimal for all graph topologies. Future work could explore alternative tree selection heuristics, adaptive thresholds for high‑indegree grouping, and extensions to related decision diagram families such as Zero‑suppressed BDDs (ZDDs) or Multi‑terminal BDDs (MTBDDs).

In conclusion, the authors present a simple yet powerful offline compression scheme for BDDs that leverages a minimal‑long‑edge spanning tree, bit‑vector and delta coding, and standard compression tools. The method achieves near‑optimal space usage (1–2 bits per node) while maintaining linear‑time performance, making it highly suitable for bandwidth‑constrained transmission and storage of large BDDs in practical verification and configuration systems.