A canonical generalization of OBDD

Abstract: We introduce Tree Decision Diagrams (TDD) as a model for Boolean functions that generalizes OBDD. They can be seen as a restriction of structured d-DNNF; that is, d-DNNF that respect a vtree $T$. We show that TDDs enjoy the same tractability properties as OBDD, such as model counting, enumeration, conditioning, and apply, and are more succinct. In particular, we show that CNF formulas of treewidth $k$ can be represented by TDDs of FPT size, which is known to be impossible for OBDD. We study the complexity of compiling CNF formulas into deterministic TDDs via bottom-up compilation and relate the complexity of this approach with the notion of factor width introduced by Bova and Szeider.

• The paper introduces Tree Decision Diagrams (TDDs) as a canonical language that generalizes OBDDs, offering minimal representations with efficient apply and negation operations.
• It demonstrates that TDDs support polynomial-time model counting, conditioning, and singleton forgetting, ensuring tractable operations on bounded-treewidth instances.
• The study connects factor width and treewidth parameters to TDD size, presenting a bottom-up compilation approach that achieves exponential succinctness improvements over OBDDs.

Tree Decision Diagrams: A Canonical Generalization of OBDD

Introduction and Motivation

The paper introduces Tree Decision Diagrams (TDDs) as a canonical knowledge compilation language, generalizing Ordered Binary Decision Diagrams (OBDDs). TDDs interpolate between the succinctness of DNNF—especially structured and deterministic DNNF (d-DNNF)—and the extensive tractability of OBDDs, inheriting key attractive properties such as efficient canonical minimization, polynomial-time apply algorithms, tractable conditioning and negation, while being exponentially more succinct than OBDDs for bounded-treewidth inputs.

Knowledge compilation has long revolved around balancing two axes: succinctness and tractable queries/transformations. OBDDs enable tractable model counting, enumeration, equivalence checking, conditioning, and most importantly, a canonical minimal form. However, the OBDD representation is intractably large for many natural inputs, particularly those with high structural width. In contrast, DNNFs (and their structured/deterministic variants) are more succinct but generally lack minimal canonical forms and efficient apply/negation. SDDs offer a compromise but their canonical forms can be exponentially larger than the minimal equivalent.

TDDs: Definition and Structural Properties

The paper formalizes TDDs as follows. Fix a vtree $T$ over variable set $X$. An nTDD (nondeterministic TDD) is a layered graph respecting $T$ where each node at a vtree node $t$ is labeled either by a literal/constant (at leaves) or receives (uniquely) pairs of child nodes (at internal nodes), exactly paralleling structured DNNFs. Deterministic TDDs add the crucial property that, for any $t$-node, the functions computed are mutually disjoint, guaranteeing certificates for models are unique.

This determinism is syntactic (unlike d-DNNF), allowing efficient recognition and construction. The TDD semantics makes alternation with d-DNNF precise: every TDD can be efficiently interpreted as a structured d-DNNF, and in fact, every function represented by a TDD can be represented as such.

The certificate-based semantics enables efficient model checking, certificate extraction, and enumeration.

Figure 1: A vtree, an nTDD respecting it, and its corresponding structured DNNF.

Efficient Transformations and Queries

Crucially, TDDs maintain the tractability of all standard queries and most important transformations known from OBDDs:

• Model counting and enumeration are both tractable.
• Conditioning/scarification and singleton forgetting (existential quantification of one variable) are polynomial-time (as in OBDDs, SDDs).
• Apply for bounded conjunction/disjunction (i.e., binary connectives) is polynomial-time, in contrast to SDNNF and SDD canonizations, with a strong canonicity guarantee.
• Negation is supported in polytime—TDDs are closed under negation, as with OBDDs but unlike d-DNNF. Negation is achieved via circuit completion and node merging.
• The language is complete: every Boolean function can be represented as a TDD over any fixed vtree.

Forgetting (quantifying out several variables) is efficient for nTDDs but breaks determinism; quantification can only be kept deterministic with exponential blowup, aligning with lower bounds from OBDD and d-DNNF theory.

Bottom-Up Compilation and Treewidth

The TDD framework admits a bottom-up compilation paradigm: given basic representations for constraints (clauses/circuits), apply and minimize are used to construct TDDs for conjunctions efficiently, following standard patterns from OBDD/SDD but overcoming their key blow-up limitations. The TDD minimization and canonicity are crucial: after each binary conjunction, the size is kept at the minimal canonical value, avoiding the pathologies of SDDs where canonization can yield size explosions.

Key results:

• CNF formulas of bounded (primal or incidence) treewidth $k$ can be compiled into TDDs of size $2^{O(k)}n$ in time $2^{O(k)}mn$, with $n$ variables and $m$ clauses. This is not possible for OBDDs (requiring super-polynomial size even for logarithmic treewidth).
• For circuits of graph/treewidth $X$0, a single exponential bound $X$1 on TDD width is achieved, improving previous bounds for structured DNNFs and enabling efficient compilation from bounded-treewidth circuits.

The theoretical backbone is the factor width parameter, a generalization of subfunction-count width (as in OBDD analysis), shown to fully characterize TDD size; for bounded-treewidth, factor width is single-exponential in $X$2 for any induced subfunction.

Figure 2: Primal and incidence graphs for a CNF, central to analysis of treewidth-based compilation.

Figure 3: Tree decompositions for primal and incidence graphs, guiding the vtree selections for TDD compilation.

Canonicity and Minimization

TDDs admit polynomial-time minimization procedures, yielding canonical minimal forms: any equivalent TDD (for a fixed vtree) reduces, after a finite sequence of "twin contractions," to a unique (up to isomorphism) smallest TDD. This is distinct from SDDs where canonization can yield exponentially larger representations. The minimal TDD's width at each vtree node equals the number of nontrivial distinct cofactor subfunctions at that point; this matches classic OBDD subfunction analysis, now extended to the general vtree context.

Minimization supports practical applications such as efficient equivalence checking, membership testing, and, crucially, $X$3-style learning algorithms for TDDs (analogue of Angluin's method for automata/OBDDs), with both membership and equivalence query routines running in time polynomial in final size.

Comparison to Other Models

TDDs strictly generalize OBDDs: TDDs over linear vtrees are in bijection (up to reversal) with OBDD representations. Conversely, TDDs can exponentially outperform OBDDs on bounded-treewidth input (OBDDs require super-polynomial size for such instances [Razgon14]).

Figure 4: An OBDD (left) and its equivalent TDD representation (right), illustrating structural correspondence.

SDDs and TDDs share similarities (canonicalization, apply), but TDD canonical forms are always minimal, while SDDs canonization can be exponentially larger. TDDs can represent functions requiring polynomial-sized SDDs, but there exist functions (notably, hidden weighted bit HWB) for which TDDs are exponentially larger than SDDs; SDDs are strictly more succinct in the worst case.

Structured d-DNNF circuits can simulate TDDs, but the converse does not hold in terms of size bounds or tractability of minimize/apply. TDDs are closed under negation, unlike structured d-DNNFs [Vinall-Smeeth24].

Practical and Theoretical Implications

The introduction of TDDs establishes a data structure unifying the most favorable algorithmic guarantees from OBDDs (tractable queries, canonical minimal forms, efficient apply/negation) with the succinctness benefits for structured instances previously only accessible to non-canonical (d-)DNNFs or exponentially-larger canonical forms (SDDs).

Practically, these developments empower scalable bottom-up knowledge compilation for constraint systems, model counting, probabilistic reasoning, and database lineage beyond the OBDD barrier, as long as input instances exhibit appropriate structural width (treewidth, circuit width, etc.). The canonicity and minimization underpin efficient update, equivalence, and learning algorithms—critical for database management, symbolic AI, and verification.

Theoretically, the analysis firmly connects knowledge compilation width parameters (factor width, treewidth) to succinct canonical representations, and the explicit comparisons demarcate the terrain between TDDs, OBDDs, SDDs, and DNNF variants. The modular bottom-up approach for TDDs also hints at further extensions (relaxing smoothness, alternative vtree optimization), and prompts study of the complexity of rebalancing/restructuring for different vtrees.

Conclusion

Tree Decision Diagrams establish TDDs as a canonical, tractable, and structurally robust knowledge compilation language, strictly more powerful than OBDDs, complementing and extending the strengths of SDDs and structured d-DNNF. The notion of canonical minimization matching subfunction counts, efficient apply/negation, and tractable compilation from bounded-width instances provides a new foundation for scalable symbolic reasoning tasks. Several directions remain, notably practical compiler development, heuristic/optimized vtree selection, extensions to richer query settings, and understanding canonical succinctness in larger fragments (2604.05537).