---
title: Tree Decision Diagrams (TDD) Overview
url: https://www.emergentmind.com/topics/tree-decision-diagrams-tdd
type: topic
---

# Tree Decision Diagrams (TDD) Overview

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 [2604.05537].

## 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 | [2604.05537] |
| **TDD** | Not defined as a formalism; closest notions are decision trees and vtree-structured circuits | [2404.09674] |
| **TDD** | Tensor Decision Diagram, for tensor and quantum-circuit representations, not Tree Decision Diagram | [2504.01168] |

In the strict Boolean-function sense, a TDD is the formalism of [2604.05537]. 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 [2404.09674] makes clear that decision trees are tree-shaped binary decision diagrams without sharing, whereas the TDD of [2604.05537] 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; [2504.01168] 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\) [2604.05537].

At a leaf \(t\) labeled by variable \(x\), each node in \(N_t\) is labeled by one of
\[
x,\ \neg x,\ 1,\ 0.
\]
If \(t\) is internal with children \(t_1,t_2\), then each node \(g\in N_t\) stores a set of allowed child pairs
\[
E(g)\subseteq N_{t_1}\times N_{t_2}.
\]
The semantics is bottom-up. Each \(t\)-node \(g\) computes a Boolean function over \(X_t=\var(t)\), and for internal \(t\),
\[
f_g = \bigvee_{(g_1,g_2)\in E(g)} (f_{g_1}\wedge f_{g_2}).
\]
Because \(X_{t_1}\) and \(X_{t_2}\) are disjoint, these conjunctions are decomposable.

The model admits a certificate semantics. A certificate for an assignment \(\tau\) selects exactly one node \(g_t^\mathcal P\) in each layer \(N_t\), such that the chosen leaves are compatible with \(\tau\) and each chosen internal node contains the chosen children as an input pair. The paper proves that \(\tau\) is a model of \(C\) if and only if \(C\) has a certificate for \(\tau\) [2604.05537].

A deterministic TDD is an nTDD satisfying layerwise syntactic determinism. At leaves, no two nodes of \(N_t\) can be simultaneously satisfiable; at internal nodes, for all distinct \(g,g'\in N_t\),
\[
E(g)\cap E(g')=\emptyset.
\]
This yields a stronger semantic property: for every vtree node \(t\) and distinct \(t\)-nodes \(g,g'\), the functions \(f_g\) and \(f_{g'}\) have disjoint models. Hence every satisfying assignment has a unique certificate.

Two structural parameters are central. The **size** of an nTDD \(C=(N,E)\) is
\[
|C| := \sum_{n\in N} |E(n)|,
\]
and the **width** is
\[
\max_{t\in T} |N_t|.
\]
If the width is \(k\), then
\[
|C| \le 2|X|\cdot k^2,
\]
because the vtree has at most \(2|X|\) nodes and each \(t\)-node can contain at most \(k^2\) child-pairs [2604.05537].

## 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 [2604.05537]. 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 \(f\) and vtree node \(t\), let \(S_t\) denote the number of non-trivial \(X_t\)-subfunctions of \(f\). Then every TDD computing \(f\) needs at least \(S_t\) many \(t\)-nodes, and the minimized TDD has exactly \(S_t\) many \(t\)-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 \(O(|X|)\), and given an assignment \(\tau\), one can construct the unique certificate or reject in time \(O(|X|)\) [2604.05537].

The main efficient transformations are likewise inherited or reproved in TDD-specific form. Conditioning is supported: given a TDD \(C\) of width \(k\), one can build in time \(O(|C|)\) a TDD \(C'\) of size at most \(|C|\) and width at most \(k\) computing \(f_C[x/b]\), respecting \(T\setminus x\). Negation is supported after making the diagram full; given width \(k\), one can construct a TDD for \(\neg C\) of width at most \(k+1\), size at most \(|C|+2|X|\cdot k^2\), in time \(O(k^2|X|)\). Bounded conjunction is implemented by a product construction: if \(C_1\) and \(C_2\) have widths \(k\) and \(k'\), one can build a TDD for \(C_1\wedge C_2\) in time \(O(|C_1||C_2|)\), with size at most \(|C_1||C_2|\) and width at most \(kk'\). Bounded disjunction follows via De Morgan, and singleton forgetting follows from
\[
\exists x.f = f[x/0]\vee f[x/1].
\]

The principal limitation is full forgetting. If one allows non-deterministic TDDs, forgetting a variable set \(Y\) can be done in time \(O(|C|)\) without increasing width or size. However, determinism may be lost, so deterministic TDDs are not closed under general forgetting in polynomial time [2604.05537]. 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 \(C\) over order \(\pi=(x_1,\dots,x_n)\), one can construct an equivalent TDD respecting a corresponding linear vtree in time \(O(|C|)\), with size at most \(3|C|\); conversely, a TDD over a linear vtree can be turned into an OBDD in time \(O(|C|)\) [2604.05537].

This generalization yields strict succinctness gains. There exists a family \((F_n)\) of CNFs with polynomial-size TDDs but for which every OBDD has size at least \(n^{c\log n}\). The separation is obtained by combining Razgon’s lower bound for OBDDs on bounded-treewidth CNFs with the TDD upper bound below [2604.05537].

The key combinatorial invariant is **factor width**. For Boolean function \(f\) and vtree \(T\),
\[
\fw{f}[T] := \max_t S_t,
\]
where \(S_t\) is the number of non-trivial \(X_t\)-subfunctions. The smallest TDD respecting \(T\) has width exactly \(\fw{f}[T]\), and size \(O(|X|\cdot \fw{f}[T])\). 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 \(1\);
2. for each clause \(c_i\), compile \(c_i\) 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 \(2\) over the chosen vtree in \(O(|X|)\) time. The resulting complexity is
\[
m\cdot |X| \cdot \poly(k),
\]
where
\[
k = \max_{i=1}^m \fw{c_1\wedge \cdots \wedge c_i}[T].
\]
Thus the running time is governed not only by the final formula but by the largest factor width encountered during intermediate conjunctions [2604.05537].

For bounded-treewidth CNFs, the paper proves fixed-parameter tractability. Given a CNF formula \(F\) of primal or incidence treewidth \(k\), one can construct a TDD of width at most \(2^k\) computing \(F\) in time
\[
2^{O(k)}\cdot mn,
\]
where \(n\) is the number of variables and \(m\) 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 [2604.05537].

## 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 \(C\) respecting \(T\), one can construct in time \(O(|C|)\) a structured d-DNNF \(C'\) respecting \(T\) and computing the same function. The containment is strict: the Hidden Weighted Bit function \(\HWB_n\) has polynomial-size structured d-DNNF, whereas every TDD requires exponential size, because
\[
\fw{\HWB_n}\ge 2^{cn}.
\]
Hence TDDs gain succinctness over OBDDs without reaching the generality of all structured d-DNNF [2604.05537].

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 \(\HWB_n\) gives polynomial-size SDDs where TDDs are exponential. TDDs can be translated to SDDs with quadratic overhead,
\[
|C'| = O(|C|^2),
\]
though generally not on the same vtree [2604.05537].

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 [2404.09674]. 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 [1301.6704]. That work is not about TDDs in the formal sense of [2604.05537], 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 [2404.09674], 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 [2604.05537]. 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 \(0.809\) for multivariate ODDs versus \(0.799\) for multivariate optimal decision trees, with a paired Wilcoxon signed-rank test yielding \(p=0.000895\) [2205.14500]. 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 [2504.01168]. 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 [2604.05537] provides the fixed-vtree, canonical, minimal Boolean representation now denoted by TDD.

Source: https://www.emergentmind.com/topics/tree-decision-diagrams-tdd