Tree Decision Diagrams (TDD) Overview

• Tree Decision Diagrams (TDDs) are canonical Boolean-function representations that replace linear variable orders with tree-structured decompositions (vtree), enhancing succinctness on tree-like instances.
• They support tractable operations such as model counting, enumeration, conditioning, and efficient conjunction/disjunction, making them ideal for bounded-treewidth CNF compilation.
• TDDs maintain canonicity and minimality under a fixed vtree and can be efficiently translated to structured d-DNNF, although they differ from SDDs, decision trees, and tensor decision diagrams.

Tree Decision Diagrams (TDDs) are a representation of Boolean functions introduced as a canonical generalization of ordered binary decision diagrams (OBDDs). They replace the linear variable order of OBDDs by a vtree $T$, i.e., a rooted binary tree over the variables, and can be viewed as a restriction of structured d-DNNF that respects that vtree. For a fixed vtree, TDDs retain the core tractability properties associated with OBDDs—including model counting, enumeration, conditioning, negation, and apply—while being more succinct on structurally tree-like instances; in particular, CNF formulas of treewidth $k$ admit TDD representations of fixed-parameter tractable size, a phenomenon known to be impossible for OBDDs (Capelli et al., 7 Apr 2026).

1. Terminology and definitional scope

The term “TDD” is not uniform across the literature, and the distinction is material.

Usage	Meaning	Source
TDD	Tree Decision Diagram, a Boolean-function formalism over a vtree	(Capelli et al., 7 Apr 2026)
TDD	Not defined as a formalism; closest notions are decision trees and vtree-structured circuits	(Amarilli et al., 2024)
TDD	Tensor Decision Diagram, for tensor and quantum-circuit representations, not Tree Decision Diagram	(Hong et al., 1 Apr 2025)

In the strict Boolean-function sense, a TDD is the formalism of (Capelli et al., 7 Apr 2026). In that work, TDDs are positioned between OBDDs and general structured d-DNNF: they are more general than the former because they allow tree-shaped variable decomposition rather than a single chain, but more restrictive than the latter because their internal organization is syntactically constrained by the vtree.

A common misconception is to equate TDDs with ordinary decision trees. The survey in (Amarilli et al., 2024) makes clear that decision trees are tree-shaped binary decision diagrams without sharing, whereas the TDD of (Capelli et al., 7 Apr 2026) is a layered-by-vtree DAG formalism with shared substructure. Another source of confusion is the acronym collision with Tensor Decision Diagrams in quantum-information work; (Hong et al., 1 Apr 2025) explicitly states that its “TDD” refers to tensors rather than tree-guided Boolean decision structures.

2. Formal structure and semantics

Let $T$ be a vtree over variables $X$. A non-deterministic TDD (nTDD) respecting $T$ is a pair $C=(N,E)$ whose nodes are partitioned by vtree node,

$N=\biguplus_{t\in T} N_t,$

with one distinguished output node $\out\in N_r$, where $r$ is the root of $T$ (Capelli et al., 7 Apr 2026).

At a leaf $k$0 labeled by variable $k$1, each node in $k$2 is labeled by one of

$k$3

If $k$4 is internal with children $k$5, then each node $k$6 stores a set of allowed child pairs

$k$7

The semantics is bottom-up. Each $k$8-node $k$9 computes a Boolean function over $T$0, and for internal $T$1,

$T$2

Because $T$3 and $T$4 are disjoint, these conjunctions are decomposable.

The model admits a certificate semantics. A certificate for an assignment $T$5 selects exactly one node $T$6 in each layer $T$7, such that the chosen leaves are compatible with $T$8 and each chosen internal node contains the chosen children as an input pair. The paper proves that $T$9 is a model of $X$0 if and only if $X$1 has a certificate for $X$2 (Capelli et al., 7 Apr 2026).

A deterministic TDD is an nTDD satisfying layerwise syntactic determinism. At leaves, no two nodes of $X$3 can be simultaneously satisfiable; at internal nodes, for all distinct $X$4,

$X$5

This yields a stronger semantic property: for every vtree node $X$6 and distinct $X$7-nodes $X$8, the functions $X$9 and $T$0 have disjoint models. Hence every satisfying assignment has a unique certificate.

Two structural parameters are central. The size of an nTDD $T$1 is

$T$2

and the width is

$T$3

If the width is $T$4, then

$T$5

because the vtree has at most $T$6 nodes and each $T$7-node can contain at most $T$8 child-pairs (Capelli et al., 7 Apr 2026).

3. Canonicality, minimality, and tractable operations

For a fixed vtree, TDDs are canonical in the strong sense that every Boolean function has a unique minimal TDD representation up to isomorphism (Capelli et al., 7 Apr 2026). This parallels the canonicity of OBDDs under a fixed variable order, but over a tree-structured decomposition.

The minimality theorem is phrased via subfunctions. For a Boolean function $T$9 and vtree node $C=(N,E)$0, let $C=(N,E)$1 denote the number of non-trivial $C=(N,E)$2-subfunctions of $C=(N,E)$3. Then every TDD computing $C=(N,E)$4 needs at least $C=(N,E)$5 many $C=(N,E)$6-nodes, and the minimized TDD has exactly $C=(N,E)$7 many $C=(N,E)$8-nodes. This gives a semantic characterization of width and underlies a polynomial-time minimization algorithm.

The tractability profile closely matches OBDD. Because every TDD can be translated in linear time into a structured d-DNNF respecting the same vtree, standard structured-d-DNNF queries transfer. In particular, model counting is polynomial-time, model enumeration has polynomial preprocessing and delay $C=(N,E)$9, and given an assignment $N=\biguplus_{t\in T} N_t,$0, one can construct the unique certificate or reject in time $N=\biguplus_{t\in T} N_t,$1 (Capelli et al., 7 Apr 2026).

The main efficient transformations are likewise inherited or reproved in TDD-specific form. Conditioning is supported: given a TDD $N=\biguplus_{t\in T} N_t,$2 of width $N=\biguplus_{t\in T} N_t,$3, one can build in time $N=\biguplus_{t\in T} N_t,$4 a TDD $N=\biguplus_{t\in T} N_t,$5 of size at most $N=\biguplus_{t\in T} N_t,$6 and width at most $N=\biguplus_{t\in T} N_t,$7 computing $N=\biguplus_{t\in T} N_t,$8, respecting $N=\biguplus_{t\in T} N_t,$9. Negation is supported after making the diagram full; given width $\out\in N_r$0, one can construct a TDD for $\out\in N_r$1 of width at most $\out\in N_r$2, size at most $\out\in N_r$3, in time $\out\in N_r$4. Bounded conjunction is implemented by a product construction: if $\out\in N_r$5 and $\out\in N_r$6 have widths $\out\in N_r$7 and $\out\in N_r$8, one can build a TDD for $\out\in N_r$9 in time $r$0, with size at most $r$1 and width at most $r$2. Bounded disjunction follows via De Morgan, and singleton forgetting follows from

$r$3

The principal limitation is full forgetting. If one allows non-deterministic TDDs, forgetting a variable set $r$4 can be done in time $r$5 without increasing width or size. However, determinism may be lost, so deterministic TDDs are not closed under general forgetting in polynomial time (Capelli et al., 7 Apr 2026). Another practical restriction is that efficient apply-style operations assume that the inputs respect the same vtree.

4. Succinctness, factor width, and compilation from CNF

The central succinctness gain of TDD over OBDD arises from replacing a linear order by a vtree. OBDDs are exactly the special case of TDDs over linear vtrees: given an OBDD $r$6 over order $r$7, one can construct an equivalent TDD respecting a corresponding linear vtree in time $r$8, with size at most $r$9; conversely, a TDD over a linear vtree can be turned into an OBDD in time $T$0 (Capelli et al., 7 Apr 2026).

This generalization yields strict succinctness gains. There exists a family $T$1 of CNFs with polynomial-size TDDs but for which every OBDD has size at least $T$2. The separation is obtained by combining Razgon’s lower bound for OBDDs on bounded-treewidth CNFs with the TDD upper bound below (Capelli et al., 7 Apr 2026).

The key combinatorial invariant is factor width. For Boolean function $T$3 and vtree $T$4,

$T$5

where $T$6 is the number of non-trivial $T$7-subfunctions. The smallest TDD respecting $T$8 has width exactly $T$9, and size $k$00. In this sense, factor width is the precise TDD analogue of classical OBDD subfunction width.

The paper studies a bottom-up CNF compilation algorithm:

1. start with a TDD for constant $k$01;
2. for each clause $k$02, compile $k$03 into a TDD;
3. conjoin with the current TDD using apply;
4. minimize after each conjunction.

Each clause can be compiled into a TDD of width $k$04 over the chosen vtree in $k$05 time. The resulting complexity is

$k$06

where

$k$07

Thus the running time is governed not only by the final formula but by the largest factor width encountered during intermediate conjunctions (Capelli et al., 7 Apr 2026).

For bounded-treewidth CNFs, the paper proves fixed-parameter tractability. Given a CNF formula $k$08 of primal or incidence treewidth $k$09, one can construct a TDD of width at most $k$10 computing $k$11 in time

$k$12

where $k$13 is the number of variables and $k$14 the number of clauses. This implies FPT-size deterministic TDDs for bounded-treewidth CNFs and is the main formal basis for the claim that TDDs can represent classes of formulas efficiently that are provably hard for OBDDs (Capelli et al., 7 Apr 2026).

5. Position among decision diagrams, circuits, and automata

TDDs occupy a specific place in the knowledge-compilation landscape. They strictly contain OBDDs under the linear-vtree equivalence above, but they are strictly contained in structured d-DNNF. Given a TDD $k$15 respecting $k$16, one can construct in time $k$17 a structured d-DNNF $k$18 respecting $k$19 and computing the same function. The containment is strict: the Hidden Weighted Bit function $k$20 has polynomial-size structured d-DNNF, whereas every TDD requires exponential size, because

$k$21

Hence TDDs gain succinctness over OBDDs without reaching the generality of all structured d-DNNF (Capelli et al., 7 Apr 2026).

The relation to SDD is more nuanced. TDDs and SDDs are both structured deterministic representations supporting efficient apply-style operations, but their notions of canonicity differ. TDDs are canonical and minimal with respect to a fixed vtree; SDDs have a canonical compressed form for a fixed vtree, but that canonical form need not be minimal and may be exponentially larger than the smallest equivalent SDD. At the same time, SDDs can be exponentially more succinct than TDDs: Bova’s result on $k$22 gives polynomial-size SDDs where TDDs are exponential. TDDs can be translated to SDDs with quadratic overhead,

$k$23

though generally not on the same vtree (Capelli et al., 7 Apr 2026).

The broader tutorial literature situates these connections in a wider circuit-automata picture. The survey “A Circus of Circuits” does not define a formalism called TDD, but it shows that OBDDs correspond to circuits structured by a right-linear v-tree, and that tree automata compile naturally to smooth SDNNF or d-SDNNF rather than to a named TDD class (Amarilli et al., 2024). This is significant because it suggests that TDDs should be read not as isolated diagrams but as a rigid, automata-like layer within the family of vtree-structured deterministic representations.

Historically, related planning formalisms had already demonstrated the value of replacing trees by shared DAGs. SPUDD represents value functions and policies of factored MDPs with algebraic decision diagrams (ADDs), and reports “up to a thirty-fold reduction in the number of nodes required to represent optimal value functions” compared to tree-structured representations, while solving some large structured MDPs exactly (Hoey et al., 2013). That work is not about TDDs in the formal sense of (Capelli et al., 7 Apr 2026), but it exemplifies the same representational principle: identical substructure should be shared rather than duplicated.

6. Related uses, adjacent models, and recurrent misunderstandings

A first misunderstanding is to treat TDD as merely a synonym for “decision tree.” In the terminology of (Amarilli et al., 2024), a deterministic decision tree is a BDD with no sharing and a single source; TDDs, by contrast, are DAGs organized over a vtree with bottom-up pairwise composition. This difference is not cosmetic: it is precisely what allows canonicity, width-based analysis, and fixed-parameter compilation results.

A second misunderstanding is to assume that TDDs dominate all neighboring representations. The formal picture is more balanced. TDDs are more succinct than OBDDs, but not than general structured d-DNNF or SDD in all cases; efficient transformations rely on a fixed common vtree; and general forgetting destroys determinism (Capelli et al., 7 Apr 2026). Compactness therefore depends critically on the quality of the vtree and on whether the target Boolean function aligns with a recursive variable partition.

A third misunderstanding comes from adjacent application domains where “tree-like decision diagrams” appear without adopting the formal TDD definition. In classification, “Optimal Decision Diagrams for Classification” studies optimal decision diagrams (ODDs), not Tree Decision Diagrams, but the model is a rooted DAG with layered structure, bounded width, node sharing, and local branching semantics. The paper emphasizes that the width of a decision diagram is not forced to double with depth and that such models are less prone to data fragmentation; empirically, over 54 UCI datasets, average test accuracy was $k$24 for multivariate ODDs versus $k$25 for multivariate optimal decision trees, with a paired Wilcoxon signed-rank test yielding $k$26 (Florio et al., 2022). This does not make ODDs instances of the Boolean-function TDD formalism, but it does show that the core DAG-sharing idea has migrated into optimization-based machine learning.

A fourth misunderstanding is purely terminological: in quantum computing, “TDD” frequently denotes Tensor Decision Diagram. The LimTDD work is explicit that its TDD is tensorial rather than tree-decomposition-based, and its edge labels are operator-valued rather than Boolean-function states (Hong et al., 1 Apr 2025). The shared acronym obscures a substantive difference in semantics, operations, and application domain.

Taken together, these adjacent literatures suggest two broader conclusions. First, the specific contribution of Tree Decision Diagrams is not simply “using a tree” but combining vtree-guided decomposition, determinism, and canonical minimality in a form that preserves OBDD-style algorithmics. Second, the general idea of replacing duplicated tree structure by shared DAG structure has independent manifestations in planning, classification, and tensor methods, but only the formalism of (Capelli et al., 7 Apr 2026) provides the fixed-vtree, canonical, minimal Boolean representation now denoted by TDD.