CFLOBDD: Hierarchical Boolean Function Compression

• CFLOBDDs are a compressed representation of Boolean functions that use hierarchical procedure calls to reuse subcomputations effectively.
• They achieve exponential compression over BDDs in best-case families while maintaining a worst-case cubic overhead when using fixed variable ordering.
• Applications in quantum simulation and machine-code model checking demonstrate their scalability and highlight open research directions in optimization and reordering.

Context-Free-Language Ordered Binary Decision Diagrams (CFLOBDDs) are a compressed representation of Boolean functions introduced as a plug-compatible alternative to Binary Decision Diagrams (BDDs). They are intended for representing Boolean functions, matrices, graphs, relations, and related objects in a highly compressed fashion, while preserving many of the favorable operational properties associated with BDDs. Their distinguishing feature is a hierarchical mechanism for reusing sub-decision-diagrams as standalone “procedures,” which can yield an exponential reduction in size relative to BDDs in the best case and a double-exponential reduction relative to decision trees in the best case (Sistla et al., 2022).

1. Origin, motivation, and scope

CFLOBDDs were introduced by Sistla, Chaudhuri, and Reps as a “plug-compatible” enhancement of Ordered Binary Decision Diagrams in which one permits a very restricted form of procedure call (Zhi et al., 2024). The motivation is the classical tension between canonicity and compression in symbolic representations: ordinary ordered BDDs exploit maximal DAG sharing, but their reuse is limited to shared subgraphs. CFLOBDDs add a second reuse mechanism, namely hierarchical reuse through procedure-like calls, so that repeated subcomputations can be packaged and invoked across contexts rather than merely duplicated or shared as literal sub-DAGs.

This design objective is reflected in the original formulation. The structure is presented as useful for representing functions, matrices, graphs, and relations, and as having the potential to permit applications to execute much faster and handle much larger problem instances than had previously been possible (Sistla et al., 2022). A later characterization describes a CFLOBDD, roughly speaking, as a finite, acyclic, non-recursive hierarchical finite-state machine with additional restrictions, which places it conceptually between classical decision diagrams and more structured automata-theoretic models (Sistla et al., 15 May 2026).

The scope of the formalism broadened quickly. Subsequent work developed weighted variants for functions of type $\mathbb{B}^n \rightarrow D$, analyzed worst-case size relationships with BDDs, investigated the role of linear structure, and deployed the representation in both quantum-circuit simulation and bounded model checking of machine code (Sistla et al., 2023).

2. Structural organization

In the fixed-order setting, the comparison class used in the theoretical literature is the ordinary OBDD or its reduced form. An OBDD for a Boolean function $f(x_0,\dots,x_{n-1})$ is a rooted DAG in which every nonterminal node tests exactly one variable in a fixed ordering $\mathit{Ord}$ and has two outgoing edges, while maximal sub-DAG sharing is enforced. A CFLOBDD for the same function and the same order $\mathit{Ord}$ is instead described as a bounded-size, single-entry, multi-exit hierarchical finite-state machine built by decomposing the decision tree for $f$ into a hierarchy of “groupings” at levels $0$ through $k$ (Zhi et al., 2024).

The level structure is central. Level-0 groupings are either fork groupings, with one exit for $0$ and one for $1$, or don’t-care groupings, with a single exit shared by both outcomes. For each level $\ell \ge 1$, a level-$f(x_0,\dots,x_{n-1})$0 grouping contains an A-connection, which is one call to a level-$f(x_0,\dots,x_{n-1})$1 grouping, and for each of its middle vertices a B-connection, which is another call to a level-$f(x_0,\dots,x_{n-1})$2 grouping, together with matching return edges. At the top level, each exit of the outermost grouping is attached to a terminal value by a value edge (Zhi et al., 2024).

Two principles regulate this hierarchy. The matched-path principle ensures that calls and returns nest properly, and the contextual-interpretation principle ensures that level-0 groupings interpret successive Boolean variables in order (Zhi et al., 2024). These conditions explain the “context-free-language” aspect of the formalism: evaluation follows a disciplined call/return structure rather than a purely flat traversal. Under suitable structural invariants, later work states that this organization yields a unique CFLOBDD $f(x_0,\dots,x_{n-1})$3 for each function $f(x_0,\dots,x_{n-1})$4 and variable order $f(x_0,\dots,x_{n-1})$5 (Zhi et al., 2024).

A common misunderstanding is to treat CFLOBDDs as merely “larger BDDs.” The later formal accounts instead portray them as hierarchical machines whose expressive advantage comes from constrained procedural reuse, not from abandoning ordered decision semantics altogether. That is why they are presented as plug-compatible rather than as an unrelated symbolic formalism.

3. Size relationships with BDDs

The original CFLOBDD work established best-case families exhibiting an inherent exponential separation between CFLOBDDs and BDDs. In particular, there exist families of functions $f(x_0,\dots,x_{n-1})$6 for which, for all $f(x_0,\dots,x_{n-1})$7, the CFLOBDD for $f(x_0,\dots,x_{n-1})$8 under a particular variable order is exponentially more succinct than any BDD for $f(x_0,\dots,x_{n-1})$9, regardless of variable order (Zhi et al., 2024). This best-case separation is one of the central reasons CFLOBDDs attracted attention.

A different question, addressed later, concerns worst-case overhead in the opposite direction: whether there might exist a family of functions for which BDDs are exponentially more succinct than any corresponding CFLOBDD. The answer given in the fixed-order setting is negative. If $\mathit{Ord}$0 is a BDD for a function $\mathit{Ord}$1 of size $\mathit{Ord}$2 using variable ordering $\mathit{Ord}$3, then the size of the CFLOBDD $\mathit{Ord}$4 for $\mathit{Ord}$5 using the same order is bounded by

$\mathit{Ord}$6

The same work further states that this bound is tight: there exists a family of functions for which $\mathit{Ord}$7 grows as $\mathit{Ord}$8 (Zhi et al., 2024).

The proof strategy is structurally informative. It defines a relation $\mathit{Ord}$9 between OBDD nodes and CFLOBDD groupings, shows that whenever the depth $\mathit{Ord}$0 is a multiple of $\mathit{Ord}$1 there is a unique level-$\mathit{Ord}$2 grouping associated with $\mathit{Ord}$3, and thereby obtains a mapping

$\mathit{Ord}$4

Using this correspondence, the argument counts groupings, vertices, and edges separately, obtaining $\mathit{Ord}$5 groupings, $\mathit{Ord}$6 vertices, and $\mathit{Ord}$7 edges (Zhi et al., 2024).

The matching lower bound is realized by a family $\mathit{Ord}$8 on $\mathit{Ord}$9 variables that checks equality across three disjoint $f$0-bit blocks:

$f$1

Under a deliberately chosen ordering, the OBDD size is $f$2, while the corresponding CFLOBDD size is $f$3 (Zhi et al., 2024). The significance of this result is twofold. First, it rules out an exponential worst-case disadvantage for CFLOBDDs under fixed order. Second, it shows that no subcubic universal bound is possible in that regime.

The same analysis also identifies the crucial assumption: the OBDD and CFLOBDD use the same variable ordering. Allowing the CFLOBDD to reoptimize its order might reduce the blow-up, but this is explicitly left open (Zhi et al., 2024).

4. Weighted variants and the role of linear structure

The weighted extension, Weighted Context-Free-Language Ordered BDDs (WCFLOBDDs), generalizes the formalism from Boolean outputs to functions $f$4. WCFLOBDDs are described as a hierarchically structured decision diagram akin to Weighted BDDs enhanced with a procedure-call mechanism. For some functions, they are exponentially more succinct than WBDDs, and they are presented as potentially beneficial when the image $f$5 has many different values (Sistla et al., 2023).

In quantum-circuit simulation, WCFLOBDDs outperform WBDDs on certain benchmarks. With a 15-minute timeout, the number of qubits handled by WCFLOBDDs is reported as $f$6–$f$7 that of WBDDs and $f$8–$f$9 that of CFLOBDDs. The same paper characterizes this outcome as providing “the best of both worlds” from the standpoint of problem size measured in qubits, while noting that running-time results are more nuanced (Sistla et al., 2023).

A separate line of work examines whether the compression of CFLOBDDs comes only from hierarchy or also from a deeper linear discipline. That study connects CFLOBDDs to Nested-Word Automata and Visibly Pushdown Automata through the notion of linear structure, and argues that linear structure, together with hierarchical structure, plays a crucial role in enabling efficient function compression. It further reports that removing linearity leads to a significant blowup in representation size and degraded performance in quantum-circuit simulation (Sistla et al., 15 May 2026).

This addresses a common oversimplification. It is tempting to attribute all gains solely to “procedure calls.” The later analysis suggests that the ordered linear organization of those calls is not incidental; rather, it is part of what makes the representation effective.

5. Quantum-circuit simulation

Quantum simulation was the first major application highlighted for CFLOBDDs. The original paper reports that, for several standard problems, the improvement in scalability over BDD-based simulation is “quite dramatic.” Specifically, the number of qubits handled by CFLOBDDs was larger than with BDDs by a factor of $0$0 for GHZ, $0$1 for Bernstein–Vazirani, $0$2 for Deutsch–Jozsa, and $0$3 for Grover’s algorithm. Under a 15-minute timeout, the corresponding CFLOBDD limits were $0$4 qubits for GHZ, $0$5 for BV, $0$6 for DJ, and $0$7 for Grover’s algorithm (Sistla et al., 2022).

The Quasimodo tool paper situates CFLOBDDs within a broader symbolic-simulation ecosystem. Quasimodo is described as an extensible, open-source Python library for symbolic simulation of quantum circuits, checking properties of circuit outputs, and debugging quantum circuits, with selectable backends including unweighted BDDs, weighted BDDs, and CFLOBDDs (Sistla et al., 2023). This is important because it presents CFLOBDDs not only as a theoretical data structure but also as an interchangeable backend in a practical research tool.

Reported benchmark data in Quasimodo show the performance profile more granularly. For GHZ with $0$8 qubits, the wall-clock times are listed as $0$9 for CFLOBDD, $k$0 for BDD, and $k$1 for WBDD; for GHZ with $k$2 qubits, the corresponding times are $k$3, $k$4, and $k$5. For Bernstein–Vazirani with $k$6 qubits, CFLOBDD is listed at $k$7 while the BDD backend times out, whereas WBDD runs in $k$8. For Deutsch–Jozsa with $k$9 qubits, CFLOBDD is listed at $0$0, BDD times out, and WBDD takes $0$1 (Sistla et al., 2023).

The same benchmarks also show that CFLOBDDs are not uniformly superior on every quantum workload. For QFT, Grover, and Shor-style workloads, weighted representations can be faster, and some CFLOBDD runs time out (Sistla et al., 2023). The broader picture is therefore not that CFLOBDDs dominate all symbolic simulators, but that they are especially effective when the circuit family contains the kind of repeated structure that their hierarchical reuse can exploit.

6. Machine-code model checking and symbolic execution

CFLOBDDs have also been pushed into software verification, specifically bounded model checking of RISC-V machine code. In that setting, the tools rotor and bitme were developed for model generation and bounded model checking, respectively. The modeling target for rotor is RISC-V restricted to integer arithmetic, motivated by the claim that RISC-V integer semantics is essentially equivalent to established SMT semantics over bitvectors and arrays of bitvectors (Bolotina et al., 13 Jul 2025).

The methodological shift is notable. Rather than relying primarily on SMT solvers and treating symbolic reasoning at source or IR level, the approach aims to push reasoning down to machine-code level and offload reasoning into SMT solvers and other solver technology only when needed. Bitme implements algebraic decision diagrams and CFLOBDDs—under the name CFLOBVDDs—and uses them to propagate program input through models, “essentially generalizing constant propagation to domain propagation.” SMT solvers are invoked only when model input cannot be propagated (Bolotina et al., 13 Jul 2025).

The implementation details emphasize engineering for reuse and caching. Inputs can be grouped in chunks of $0$2, $0$3, $0$4, or $0$5 bits. Every node is canonicalized via a global unique table, every APPLY, JOIN, and RESTRICT call is memoized in a computed cache, and the original quadratic step in rule matching is replaced by direct production indexing so that the match-and-merge step becomes linear rather than quadratic in node size. Under perfect hashing and caching, APPLY and JOIN are reported to run in $0$6 time, while RESTRICT runs in $0$7 time (Bolotina et al., 13 Jul 2025).

The empirical picture is mixed but informative. In a microbenchmark suite of $0$8 small RISC-V programs with a timeout of $0$9, SMT alone completes only $1$0 programs, and constant propagation completes the same $1$1; ROABVDDs finish $1$2 under $1$3 and $1$4 under $1$5; CFLOBVDDs finish $1$6 under $1$7 and $1$8 under $1$9 (Bolotina et al., 13 Jul 2025). Thus the completion counts are similar between the two diagrammatic backends, but not identical.

The scalability experiments are particularly relevant to CFLOBDD-style reuse. In one synthetic benchmark, ROABVDD runtime grows from $\ell \ge 1$0 at $\ell \ge 1$1 to $\ell \ge 1$2 at $\ell \ge 1$3, while memory grows from $\ell \ge 1$4 to $\ell \ge 1$5; CFLOBVDD runtime grows from $\ell \ge 1$6 to $\ell \ge 1$7, while memory grows only from $\ell \ge 1$8 to $\ell \ge 1$9. In another benchmark, ROABVDD runtime grows from $f(x_0,\dots,x_{n-1})$00 to $f(x_0,\dots,x_{n-1})$01 and memory from $f(x_0,\dots,x_{n-1})$02 to $f(x_0,\dots,x_{n-1})$03, whereas CFLOBVDD runtime grows from $f(x_0,\dots,x_{n-1})$04 to $f(x_0,\dots,x_{n-1})$05 and memory from $f(x_0,\dots,x_{n-1})$06 to $f(x_0,\dots,x_{n-1})$07 (Bolotina et al., 13 Jul 2025). The stated interpretation is that CFLOBVDDs incur a nearly constant runtime premium over ROABVDDs but dramatically reduce peak memory growth.

7. Limitations, misconceptions, and open directions

The literature identifies several boundary conditions for CFLOBDD effectiveness. One misconception is that CFLOBDDs are simply “always smaller” than BDDs. The more precise statement is asymmetric: there are best-case families with exponential savings over BDDs, but under the same variable ordering the worst-case overhead over a BDD is polynomial and in fact cubic, not unboundedly worse (Zhi et al., 2024).

Another misconception is that hierarchical reuse alone explains their performance. Later work explicitly argues that linear structure, alongside hierarchy, is crucial, and that removing linearity causes significant blowup and degraded quantum-simulation performance (Sistla et al., 15 May 2026). This suggests that the formal gains of CFLOBDDs depend on a combination of nesting discipline and ordering discipline rather than on procedure calls in isolation.

The application papers also delimit where compression may fail. Quasimodo notes that CFLOBDDs can still blow up if the circuit has very little regularity, such as a random unitary, and that qubit permutation and dynamic reordering remain unexplored for the CFLOBDD backend. The same source identifies handling mid-circuit measurements efficiently, possibly via new “partial-collapse” primitives, and extensions to higher-branching or direct cloning of subgraphs as open areas (Sistla et al., 2023).

A further open issue comes from the size-theoretic side: the $f(x_0,\dots,x_{n-1})$08 guarantee depends on using the same variable ordering in both the OBDD and the CFLOBDD. Whether allowing the CFLOBDD to reoptimize its order can materially reduce the worst-case blow-up remains open (Zhi et al., 2024). This is a technically important qualification, because variable order is often decisive in BDD practice, and there is no indication in the available results that CFLOBDDs eliminate that sensitivity altogether.

Taken together, these results place CFLOBDDs in a specific niche within symbolic computation. They strictly generalize fixed-order BDD-style representations by adding restricted procedural reuse; they can produce exponential compression on families with repeated structure; they admit a tight cubic upper bound relative to same-order BDDs in the worst case; and they have already been shown relevant in both quantum simulation and machine-code model checking (Sistla et al., 2022).