Quantum Decision Diagram Simulation

• Quantum decision diagram simulation is a method that represents quantum states, matrices, or tensors as canonical reduced directed acyclic graphs with weighted edges to exploit structural redundancy.
• It employs recursive decomposition, normalization, and memoization to execute tasks such as gate application, measurement, and equivalence checking with reduced computational cost.
• Hybrid techniques like tensor-centric, path-integral, and Schrödinger–Feynman variants further enhance performance, noise handling, and distributed execution for complex quantum circuits.

Quantum decision diagram simulation is a family of exact and approximate classical methods for quantum-circuit analysis in which states, operators, tensors, or path-integral expressions are represented by reduced directed acyclic graphs with weighted edges rather than dense arrays. In the standard QMDD-style formulation, state vectors and matrices are recursively decomposed along qubit variables; in tensor-centric and path-integral variants, the same principle is extended to higher-rank tensors or to Boolean functions whose weighted counts reproduce amplitudes. The central objective is to exploit structural redundancy, scalar-factor normalization, and canonical sharing so that simulation cost depends on diagram size rather than directly on $2^n$ or $2^{2n}$, while retaining exact linear-algebra semantics for tasks such as gate application, measurement, verification, and equivalence checking (Zulehner et al., 2017, Wille et al., 2021, Hong et al., 2020).

1. Formal representations and semantics

The canonical starting point is the QMDD-style representation of an $n$-qubit state $|\psi\rangle \in \mathbb{C}^{2^n}$ as a rooted DAG with one non-terminal level per qubit and a single terminal node. Each non-terminal state node has two outgoing edges, corresponding to the $0$- and $1$-branches of a Shannon-like decomposition, and each edge carries a complex weight. Matrix DDs use the analogous block decomposition

$$U= \begin{bmatrix} U_{00} & U_{01}\ U_{10} & U_{11} \end{bmatrix},$$

with four outgoing edges per node for the four submatrices. In both cases, an amplitude or matrix entry is obtained as the product of edge weights along the corresponding root-to-terminal path (Zulehner et al., 2017, Burgholzer et al., 2022).

For tensor-centric simulation, the same idea is formulated over binary-index tensors $\phi:\{0,1\}^I \to \mathbb{C}$. A Tensor Decision Diagram (TDD) applies the Boole–Shannon expansion

$$\phi = \bar{x}\cdot (\phi|_{x=0}) + x\cdot (\phi|_{x=1}),$$

and represents a tensor as a rooted DAG with two outgoing edges per non-terminal node, terminal nodes labeled by complex constants, and weighted edges. If $v$ is a node labeled by $2^{2n}$0, then

$2^{2n}$1

and the represented tensor is the root weight times $2^{2n}$2 (Hong et al., 2020).

A distinct but related line of work replaces state or tensor objects by a path-integral exponent. FeynmanDD compiles a circuit into a sum-of-powers expression and stores the exponent as a multi-terminal BDD. After substitution of boundary variables, amplitudes take the form

$2^{2n}$3

where $2^{2n}$4 is the number of assignments mapping the exponent to residue $2^{2n}$5. This turns simulation into weighted counting on a decision diagram rather than direct state manipulation (Wang et al., 10 Sep 2025).

2. Canonicity, normalization, and native operations

Decision-diagram simulation depends on canonical reduction. In QMDD-style structures, equivalent sub-vectors or sub-matrices are shared by a unique table, while common scalar factors are extracted into edge weights under a normalization scheme. The consequence is that equality of represented objects reduces to graph identity under a fixed variable order (Zulehner et al., 2017, Wille et al., 2021).

TDDs make this canonicalization explicit through normal tensors, bottom-up normalization, and reduction rules. A tensor is called normal if it is zero or its pivot entry equals $2^{2n}$6; every non-normal tensor can be written uniquely as $2^{2n}$7. Bottom-up normalization enforces local rules such as turning nonzero terminals into terminal-$2^{2n}$8 with incoming weight adjustment and shifting one outgoing edge weight of a non-terminal to $2^{2n}$9. Reduction then merges terminal-$n$0 nodes, redirects zero-weight edges, bypasses redundant nodes, and merges isomorphic nodes. For a fixed variable order, the reduced ordered TDD is unique (Hong et al., 2020).

The primitive operations are addition, multiplication, contraction, tensor product, and measurement. Matrix–vector multiplication follows the block recurrence

$n$1

and DD implementations memoize recursive subcalls in computed tables keyed by operand identities. For QMDD-style simulation, the dominant cost is roughly proportional to the product of DD sizes of the operands. For TDDs, Add(F,G) has complexity $n$2, while contraction has worst-case $n$3; tensor product is often $n$4, and in favorable index orders can be reduced to $n$5 (Burgholzer et al., 2022, Hong et al., 2020).

Measurement is also formulated natively on diagrams. In state DDs, the probability of a branch is obtained from squared magnitudes of edge weights combined with recursive subtree norms. In mixed-dimensional DDs, per-node normalization makes the squared magnitudes of outgoing edge weights a proper probability distribution, yielding an $n$6 top-down sampling algorithm. Post-measurement updates are implemented by zeroing incompatible branches and renormalizing the remaining path (Zulehner et al., 2017, Mato et al., 2023).

3. Simulation paths, contraction order, and circuit partitioning

A fundamental insight of later work is that DD efficiency depends not only on representation but also on the order in which operations are parenthesized. Given a circuit $n$7 and an initial state, there are many admissible simulation paths: gates may be applied sequentially, grouped into intermediate matrix products, or scheduled according to a task DAG. A simple cost proxy is

$n$8

with memory governed by the peak size of intermediate DDs. For difficult circuits, especially verification workloads involving $n$9, a suitable path can change the practical complexity by orders of magnitude (Burgholzer et al., 2022).

This observation led to a direct transfer of tensor-network planning ideas. DDSIM, within the Munich Quantum Toolkit, can translate CoTenGra contraction plans into DD task graphs and execute them with Taskflow. The same work introduced a dedicated heuristic for equivalence checking that alternates gates from a circuit $|\psi\rangle \in \mathbb{C}^{2^n}$0 and the inverse of its compiled version $|\psi\rangle \in \mathbb{C}^{2^n}$1, using expected decomposition lengths to keep intermediates near identity. Experimental results showed that tensor-network-informed paths often yield speedups of several factors, while the dedicated verification heuristic frequently yields speedups of several orders of magnitude (Burgholzer et al., 2022).

Related reordering strategies target gate semantics rather than parenthesization. For entangled QFT and QPE, explicit SWAP gates can destroy DD sharing because they permute the diagram’s variable order. A semantics-preserving “reorder trick” therefore replaces each SWAP by an update to a logical-to-physical qubit-label permutation $|\psi\rangle \in \mathbb{C}^{2^n}$2, so that no SWAP operator is ever applied to the DD itself. On 19-qubit QPE, this achieved a speedup of $|\psi\rangle \in \mathbb{C}^{2^n}$3 over the CoTenGra-optimized baseline (Shen et al., 2022).

Tensor-centric DD simulation introduces a complementary notion of partitioning. TDD circuit construction can split circuits horizontally and vertically so that only a controlled number of CNOTs cross a cut. Two schemes were evaluated: Scheme I, based on a horizontal split and vertical cuts, and Scheme II, which introduces small “envelopes” to isolate interactions. In the reported experiments, Scheme II generally reduced peak intermediate sizes, and runtime reductions of at least $|\psi\rangle \in \mathbb{C}^{2^n}$4 versus no-partition TDD were observed on many benchmarks (Hong et al., 2020).

A further generalization is the hybrid Schrödinger–Feynman scheme. Here a cut divides the qubits into two blocks, only cross-cut gates are decomposed by Schmidt-like expansions, and each assignment of Schmidt terms produces two independent DD simulations on the left and right blocks. The assignments are embarrassingly parallel. The reported implementation simulated certain hard circuits within minutes that could not be simulated in a whole day previously, and an amplitude-extraction-plus-array-accumulation variant removed the DD-addition bottleneck (Burgholzer et al., 2021).

4. Variant families and generalizations

The field now contains several distinct DD families, each tuned to a different notion of structure.

Variant	Primary object	Distinctive property
QMDD / QuIDD	State vectors and matrices	Weighted reduced DAGs for qubit-wise decomposition
TDD / FTDD	Tensors and tensor networks	Shannon expansion on tensor indices with contraction-centric operations
LIMDD	States modulo local invertible maps	Merges states equivalent up to local Paulis
Mixed-dimensional DD	Qubit–qudit systems	Node arity equals local subsystem dimension
FeynmanDD MTBDD	SOP exponents	Converts simulation to residue counting

TDDs were introduced to represent tensor networks canonically and to integrate circuit partitioning, contraction, and hyper-edges into a DD formalism (Hong et al., 2020). FTDD subsequently focused on engineering and preprocessing. It introduced the linear-time rank simplification algorithm Tetris and an edge-centric C++ implementation with DD-style unique tables, computed caches, and garbage collection. On redundancy-rich circuits, FTDD reported an average speedup of $|\psi\rangle \in \mathbb{C}^{2^n}$5 over Google’s TensorNetwork library; on Google random quantum circuits it reported $|\psi\rangle \in \mathbb{C}^{2^n}$6 and $|\psi\rangle \in \mathbb{C}^{2^n}$7 speedups over QMDD and a prior TDD implementation, respectively (Zhang et al., 2024).

Mixed-dimensional simulation extends DDs beyond qubits. MiSiM generalizes edge-weighted QMDDs so that level $|\psi\rangle \in \mathbb{C}^{2^n}$8 has $|\psi\rangle \in \mathbb{C}^{2^n}$9 outgoing edges, where $0$0 is the local subsystem dimension. The joint Hilbert space is

$0$1

and the amplitude of a basis index is the product of edge weights along the unique mixed-radix path. Experimental evaluation showed efficient simulation of mixed-dimensional circuits with more than $0$2 qudits (Mato et al., 2023).

LIMDDs enlarge the equivalence relation itself. A $0$3-LIMDD labels edges by local invertible maps $0$4, with the main instantiation using Pauli-generated maps. This allows merging states that are locally Pauli-equivalent, not merely scalar-equivalent. The theory establishes that poly-sized LIMDDs strictly contain the union of stabilizer states and other decision-diagram variants, and that there exist circuits efficiently simulable by LIMDDs whose output states are not succinct for QMDDs, MPS, or stabilizer-rank methods (Vinkhuijzen et al., 2021). A later normal-form algorithm for Pauli-LIMDDs reduced worst-case node-normalization time from $0$5 to $0$6 for single-child nodes, and the QolDDer implementation often outperformed existing LIMDD simulators by an order of magnitude on public benchmarks (Sanders et al., 23 Jun 2026).

FeynmanDD departs even further from conventional state-based DD simulation. Instead of storing the state, it stores a sum-of-powers exponent over Boolean path variables as an MTBDD and evaluates amplitudes or probabilities by counting assignments that map to each terminal value. A subsequent theoretical analysis showed that the MTBDD size is exponential in the linear rank-width of an associated circuit graph, not the treewidth that governs tensor-network methods. Because linear rank-width can be substantially smaller than treewidth, this establishes a regime in which decision-diagram simulation can outperform all tensor-network-based methods for certain circuit families (Wang et al., 10 Sep 2025, Cheng et al., 8 Oct 2025).

5. Noise, verification, and parallel or distributed execution

Quantum DD simulation is not limited to unitary pure-state evolution. One approach to noise uses stochastic trajectories. Instead of evolving density matrices, the simulator samples physically motivated errors during each run and averages quadratic observables across trajectories. For a target accuracy $0$7, confidence $0$8, and $0$9 observables, the required number of samples is

$1$0

The corresponding DD simulator combined compact state/operator representations with independent concurrent trajectories and achieved substantially faster and more scalable noisy simulation for certain circuit families (Grurl et al., 2020).

A second approach simulates decoherence directly at the density-matrix level. States are represented as operator DDs, and noisy channels are applied either by explicit Kraus summation

$1$1

or, more efficiently, by local block updates tailored to single-qubit channels such as phase damping and amplitude damping. The reported “advanced solutions” yielded improvements of several orders of magnitudes compared to a naive consideration of errors (Grurl et al., 2020).

Verification is another major application domain. Canonical reduced DDs make equality checking immediate when two circuits collapse to the same graph. QCEC and related workflows exploit identity-close constructions such as $1$2, and DD-based constrained bisimulation can reduce the state space before simulation. Forward and backward constrained bisimulations compute coarsest quotient spaces that preserve either projected measurements or full recoverability on a constrained input subspace, and the reported prototype showed that this can boost DD-based simulation by several orders of magnitude (Wille et al., 2021, Burgholzer et al., 2023).

Parallelization has historically been difficult because unique tables and computed tables are shared, pointer-heavy data structures. A systematic study of shared-memory strategies compared task graphs, threads, and fibers for DD-based simulation. The recommended configuration used a global unique table with compare-and-swap insertion, adaptive cache placement, and fiber-based inner parallelization. This achieved $1$3-$1$4 times faster simulation of Grover’s algorithm and random circuits than the state-of-the-art single-thread DD-based simulator DDSIM (Li et al., 2023).

Distributed-memory execution extends the same logic to clusters. A multi-node QMDD simulator partitioned the global state into sub-vectors, assigned one sub-vector DD per node, and handled nonlocal gates through ring communication rather than broadcast. Automatic SWAP insertion tailored to DDs further reduced communication. The implementation scaled to $1$5 nodes, delivered up to $1$6 speedup, and completed a $1$7-qubit Shor circuit in $1$8 seconds (Kimura et al., 2024).

6. Empirical regimes, approximate simulation, and limitations

Across the literature, a consistent empirical pattern emerges. DD-based simulation excels when intermediate states or operators exhibit repeated substructures, block-diagonality, diagonal gates, arithmetic regularity, or verification-friendly cancellation. Reported favorable circuit classes include GHZ, W, BV, QFT components, adders, arithmetic blocks, graph states, and many oracle-based constructions (Burgholzer et al., 2022, Hong et al., 2020, Wille et al., 2023).

The original weighted-edge DD simulator of Zulehner and Wille showed linear behavior on entanglement circuits and QFT, and simulated Shor with $1$9 qubits using “slightly more than 20,000” nodes and “within less than a minute” on the reported desktop setup (Zulehner et al., 2017). TDD benchmarks reached BV circuits up to $$U= \begin{bmatrix} U_{00} & U_{01}\ U_{10} & U_{11} \end{bmatrix},$$0 qubits in seconds, and with partitioning handled $$U= \begin{bmatrix} U_{00} & U_{01}\ U_{10} & U_{11} \end{bmatrix},$$1 in at most about $$U= \begin{bmatrix} U_{00} & U_{01}\ U_{10} & U_{11} \end{bmatrix},$$2 seconds while matrix-based tensor methods ran out of memory and QMDD timed out on larger instances (Hong et al., 2020). FTDD later demonstrated that low-level engineering, contraction ordering, and rank simplification can shift DD-based tensor simulation into a regime competitive with or superior to array-based tensor-network methods on redundancy-rich workloads (Zhang et al., 2024).

Approximate simulation is increasingly important when compressibility collapses. Earlier DD approximations removed low-contribution nodes; a later method replaced them with similar nodes instead. The fidelity loss per replacement is

$$U= \begin{bmatrix} U_{00} & U_{01}\ U_{10} & U_{11} \end{bmatrix},$$3

and the replacement search was accelerated with Super-Bit locality-sensitive hashing. On quantum supremacy benchmarks, this produced a better memory–accuracy trade-off than node removal and, for the first time, demonstrated a strong better-than-linear trade-off between memory and fidelity at high circuit depths (Yan et al., 6 Jul 2025).

The principal limitation remains worst-case exponential growth. Highly entangling random circuits, deep supremacy-style workloads, dense nonlocal gates, or poor variable orders can destroy sharing so that DDs approach explicit trees or quad-trees. This is emphasized repeatedly for QMDDs, TDDs, and mixed-dimensional DDs alike (Burgholzer et al., 2022, Hong et al., 2020, Mato et al., 2023). Tensor-network methods may then become preferable, especially when slicing or optimized contraction order makes full-state construction unnecessary.

A second limitation is that ordering and canonicalization costs are themselves nontrivial. Variable-order optimization is NP-hard in both DD and tensor-network settings, and different DD families expose different trade-offs. This suggests that “quantum decision diagram simulation” is best understood not as a single algorithm, but as a methodological spectrum: canonical DAG representations of quantum objects, equipped with normalization, memoization, and structure-aware scheduling, and increasingly combined with tensor-network planning, stochastic noise models, quotient reductions, approximation, and distributed execution. A plausible implication is that future progress will continue to come less from any one DD variant than from hybridization across these techniques.