LimTDD: Local Invertible Map Tensor Decision Diagram

• LimTDD is a tensor and quantum-state decision diagram that extends TDDs by attaching local invertible maps to merge substructures up to isomorphism.
• It employs a rigorous normalization routine based on the XP-stabilizer group to canonicalize edge weights and enable efficient node merging.
• Empirical evaluations demonstrate that LimTDD achieves exponential compression with faster simulation and quantum state preparation compared to TDD and LIMDD.

LimTDD, short for Local Invertible Map Tensor Decision Diagram, is a decision-diagram framework for tensor and quantum-state representation that extends Tensor Decision Diagrams (TDDs) by attaching local invertible maps to edges so that substructures that are identical only up to tensor isomorphism can be merged. In the formulation introduced in 2025, LimTDD integrates the tensor-network expansion perspective of TDD with the merging-up-to-isomorphism perspective of LIMDD, generalizing beyond Pauli-based symmetries through the XP-stabilizer group and supporting normalization, slicing, addition, and contraction for quantum circuit simulation and verification (Hong et al., 1 Apr 2025). Subsequent work uses LimTDD as the core representation for quantum state preparation, including algorithms for no-ancilla, one-ancilla, and many-ancilla settings (Hong et al., 19 Jul 2025).

1. Origins and relation to prior representations

LimTDD arises from two antecedents. First, a TDD over an index set $S$ is a rooted, weighted DAG

$\mathcal F=(V,E,\idx,\low,\high,\w),$

where each nonterminal node is labeled by an index, has a 0-edge and a 1-edge, and each edge carries a complex weight. Its semantics follows Shannon-style expansion: $(v)=\w(v\!\to\!\low(v))\,\overline{x}_v\,(\low(v))+\w(v\!\to\!\high(v))\,x_v\,(\high(v)),$ and the whole diagram represents

$(\mathcal F)=w_{\mathcal F}\cdot(r_{\mathcal F}).$

TDDs compress tensors by sharing identical sub-tensors (Hong et al., 1 Apr 2025).

Second, a local invertible map (LIM) on $n$ Boolean indices or qubits has the form

$$O=\lambda\,O_n\otimes\cdots\otimes O_1 \qquad (\lambda\in\mathbb C,\;O_i\in GL(2,\mathbb C)),$$

and two rank-$n$ tensors or $n$-qubit states are LIM-isomorphic if one can be obtained from the other by such an operator. In decision-diagram terms, attaching $O$ to an edge records equality “up to a local change of basis,” enabling node merging beyond literal equality (Hong et al., 1 Apr 2025).

The 2025 LimTDD paper positions this construction relative to prior DD families in a strict containment sense. TDD is recovered as the special case with $\mathcal G=\mathbb C\cdot I$, while LIMDD corresponds to the case where $\mathcal F=(V,E,\idx,\low,\high,\w),$0 is the Pauli stabilizer group. Unlike LIMDD, which applies Pauli operators to quantum states, LimTDD generalizes the approach using the XP-stabilizer group, with the stated goal of broader applicability (Hong et al., 1 Apr 2025).

2. Formal definition and semantics

A $\mathcal F=(V,E,\idx,\low,\high,\w),$1-LimTDD over an index set $\mathcal F=(V,E,\idx,\low,\high,\w),$2 is defined as a rooted DAG

$\mathcal F=(V,E,\idx,\low,\high,\w),$3

or, in a more expanded notation,

$\mathcal F=(V,E,\idx,\low,\high,\w),$4

where $\mathcal F=(V,E,\idx,\low,\high,\w),$5 is the set of nonterminal nodes, $\mathcal F=(V,E,\idx,\low,\high,\w),$6 is the unique terminal node labeled by the scalar $\mathcal F=(V,E,\idx,\low,\high,\w),$7, $\mathcal F=(V,E,\idx,\low,\high,\w),$8 assigns indices to nonterminal nodes, $\mathcal F=(V,E,\idx,\low,\high,\w),$9 and $(v)=\w(v\!\to\!\low(v))\,\overline{x}_v\,(\low(v))+\w(v\!\to\!\high(v))\,x_v\,(\high(v)),$0 define 0- and 1-successors, and each edge weight lies in a subgroup $(v)=\w(v\!\to\!\low(v))\,\overline{x}_v\,(\low(v))+\w(v\!\to\!\high(v))\,x_v\,(\high(v)),$1 of local invertible maps (Hong et al., 19 Jul 2025).

Component	Role
$(v)=\w(v\!\to\!\low(v))\,\overline{x}_v\,(\low(v))+\w(v\!\to\!\high(v))\,x_v\,(\high(v)),$2	Unique terminal node with semantics $(v)=\w(v\!\to\!\low(v))\,\overline{x}_v\,(\low(v))+\w(v\!\to\!\high(v))\,x_v\,(\high(v)),$3
$(v)=\w(v\!\to\!\low(v))\,\overline{x}_v\,(\low(v))+\w(v\!\to\!\high(v))\,x_v\,(\high(v)),$4	Variable or qubit ordering on nonterminal nodes
$(v)=\w(v\!\to\!\low(v))\,\overline{x}_v\,(\low(v))+\w(v\!\to\!\high(v))\,x_v\,(\high(v)),$5	0- and 1-successors
$(v)=\w(v\!\to\!\low(v))\,\overline{x}_v\,(\low(v))+\w(v\!\to\!\high(v))\,x_v\,(\high(v)),$6	Edge label in $(v)=\w(v\!\to\!\low(v))\,\overline{x}_v\,(\low(v))+\w(v\!\to\!\high(v))\,x_v\,(\high(v)),$7
Root edge	Carries the global weight

The semantics used in the quantum-state preparation papers is

$(v)=\w(v\!\to\!\low(v))\,\overline{x}_v\,(\low(v))+\w(v\!\to\!\high(v))\,x_v\,(\high(v)),$8

with the represented state given by $(v)=\w(v\!\to\!\low(v))\,\overline{x}_v\,(\low(v))+\w(v\!\to\!\high(v))\,x_v\,(\high(v)),$9 (Hong et al., 19 Jul 2025). In the tensor-oriented presentation, the root semantics is inherited from TDD, except that the edge weights are now LIMs or XP-operators rather than complex scalars (Hong et al., 1 Apr 2025).

Two reduction rules are central. First, one merges isomorphic subgraphs if low- and high-subtrees agree up to an operator in $(\mathcal F)=w_{\mathcal F}\cdot(r_{\mathcal F}).$0. Second, one normalizes edge weights so that the 0-edge weight is the identity, absorbing scalars through the incoming edge (Hong et al., 19 Jul 2025). This suggests that LimTDD’s compactness derives not only from DAG sharing, as in classical DDs, but from quotienting the represented tensor by a local-isomorphism relation.

3. XP-stabilizer restriction and canonical normalization

The general LIM group is too large for efficient canonicalization. The framework therefore restricts local operators to the XP-stabilizer group of precision $(\mathcal F)=w_{\mathcal F}\cdot(r_{\mathcal F}).$1, with $(\mathcal F)=w_{\mathcal F}\cdot(r_{\mathcal F}).$2, where an $(\mathcal F)=w_{\mathcal F}\cdot(r_{\mathcal F}).$3-qubit XP-operator is

$(\mathcal F)=w_{\mathcal F}\cdot(r_{\mathcal F}).$4

The paper states that its subgroup of stabilizers is finite and admits a unique canonical generator set, which makes it suitable for normalization (Hong et al., 1 Apr 2025).

The local normalization routine, denoted $(\mathcal F)=w_{\mathcal F}\cdot(r_{\mathcal F}).$5, is invoked whenever a node is created from children $(\mathcal F)=w_{\mathcal F}\cdot(r_{\mathcal F}).$6 and $(\mathcal F)=w_{\mathcal F}\cdot(r_{\mathcal F}).$7 at index $(\mathcal F)=w_{\mathcal F}\cdot(r_{\mathcal F}).$8. The procedure fixes one edge weight to $(\mathcal F)=w_{\mathcal F}\cdot(r_{\mathcal F}).$9, enforces canonical ordering, and chooses the lexicographically smallest representative in

$n$0

or in $n$1 when $n$2, while absorbing overall phases into the parent’s incoming weight (Hong et al., 1 Apr 2025).

The main recursive construction routine expands the smallest index, generates the two cofactors, and then calls $n$3. Slicing descends to the first node labeled by the target variable, applies any $n$4-swap or $n$5-phase at the root, and returns the appropriate child; if the variable lies below the root index, the algorithm recurses on both branches and renormalizes. Addition first coerces one root weight to $n$6, absorbs the relative LIM into the other operand, and either adds root weights directly when the structures coincide up to stabilizers or recurses on slices followed by $n$7. Contraction generalizes the usual TDD rule by summing over a contracted variable and otherwise rebuilding the node via local normalization (Hong et al., 1 Apr 2025).

The papers describe these routines as recursively implemented with hash-table memoization. In the state-construction report, hash-consing and isomorphism checking are said to be implementable in $n$8 expected time using a hash table keyed by the 5-tuple $n$9 (Hong et al., 19 Jul 2025).

4. Compactness theorems and asymptotic behavior

The central structural guarantee is the isomorphic-nodes theorem. For tensors $$O=\lambda\,O_n\otimes\cdots\otimes O_1 \qquad (\lambda\in\mathbb C,\;O_i\in GL(2,\mathbb C)),$$0 and $$O=\lambda\,O_n\otimes\cdots\otimes O_1 \qquad (\lambda\in\mathbb C,\;O_i\in GL(2,\mathbb C)),$$1 on the same indices with LimTDDs $$O=\lambda\,O_n\otimes\cdots\otimes O_1 \qquad (\lambda\in\mathbb C,\;O_i\in GL(2,\mathbb C)),$$2 and $$O=\lambda\,O_n\otimes\cdots\otimes O_1 \qquad (\lambda\in\mathbb C,\;O_i\in GL(2,\mathbb C)),$$3,

$$O=\lambda\,O_n\otimes\cdots\otimes O_1 \qquad (\lambda\in\mathbb C,\;O_i\in GL(2,\mathbb C)),$$4

for some $$O=\lambda\,O_n\otimes\cdots\otimes O_1 \qquad (\lambda\in\mathbb C,\;O_i\in GL(2,\mathbb C)),$$5 and $$O=\lambda\,O_n\otimes\cdots\otimes O_1 \qquad (\lambda\in\mathbb C,\;O_i\in GL(2,\mathbb C)),$$6. The stated consequence is that any two isomorphic sub-tensors collapse to the same node (Hong et al., 1 Apr 2025).

A corollary gives the pointwise compactness relation

$$O=\lambda\,O_n\otimes\cdots\otimes O_1 \qquad (\lambda\in\mathbb C,\;O_i\in GL(2,\mathbb C)),$$7

In that sense, LimTDD subsumes both TDD and LIMDD as special cases while preserving their general representational setting (Hong et al., 1 Apr 2025).

Best-case separations are explicitly exponential. The LimTDD paper states that certain tensor families, including QFT circuits and controlled-phase cascades, admit a “tower” representation of size $$O=\lambda\,O_n\otimes\cdots\otimes O_1 \qquad (\lambda\in\mathbb C,\;O_i\in GL(2,\mathbb C)),$$8, while TDD or LIMDD remain $$O=\lambda\,O_n\otimes\cdots\otimes O_1 \qquad (\lambda\in\mathbb C,\;O_i\in GL(2,\mathbb C)),$$9 (Hong et al., 1 Apr 2025). The state-preparation report gives a more explicit family, the complete-graph CZ states

$n$0

for which the reduced ADD representation has $n$1 distinct paths, while the LimTDD representation has exactly $n$2 nodes and a single reduced path (Hong et al., 19 Jul 2025). A plausible implication is that the effective compression mechanism is not merely subtree reuse but repeated absorption of systematic local phase structure into edge labels.

5. Experimental performance in simulation and functionality construction

The original implementation is reported in C++ with XP-stabilizers of precision up to $n$3, and is compared against publicly available TDD and LIMDD engines on random Clifford+T circuits and standard benchmarks including QFT, GHZ, Grover, QPE (exact/inexact), and graph-state instances. The recorded metrics are maximum node count during simulation, total execution time, and memory footprint (Hong et al., 1 Apr 2025).

For 20-qubit Clifford+T circuits with T-density $n$4, the reported averages are approximately $n$5 s for LimTDD, $n$6 s for TDD, and $n$7 s for LIMDD, with node counts of about $n$8, $n$9, and $n$0, respectively (Hong et al., 1 Apr 2025). For functionality construction on $n$1, TDD uses about $n$2 million nodes whereas LimTDD uses $n$3 nodes, described as about $n$4 compression; the corresponding runtimes are about $n$5 s and $n$6 s (Hong et al., 1 Apr 2025).

For the QFT-entangled circuit family up to $n$7, LimTDD is reported to remain $n$8 in nodes, approximately $n$9–$O$0, while TDD and LIMDD blow up exponentially. At $O$1, the reported timings are $O$2 s for LimTDD, $O$3 s for TDD, and $O$4 s for LIMDD (Hong et al., 1 Apr 2025).

Benchmark setting	LimTDD	Comparator results
20-qubit Clifford+T, T-density $O$5	$O$6 s, $O$7 nodes	TDD $O$8 s, $O$9; LIMDD $\mathcal G=\mathbb C\cdot I$0 s, $\mathcal G=\mathbb C\cdot I$1
Functionality construction $\mathcal G=\mathbb C\cdot I$2	$\mathcal G=\mathbb C\cdot I$3 nodes, $\mathcal G=\mathbb C\cdot I$4 s	TDD $\mathcal G=\mathbb C\cdot I$5 million nodes, $\mathcal G=\mathbb C\cdot I$6 s
QFT-entangled, $\mathcal G=\mathbb C\cdot I$7	$\mathcal G=\mathbb C\cdot I$8 s, $\mathcal G=\mathbb C\cdot I$9–$\mathcal F=(V,E,\idx,\low,\high,\w),$00 nodes	TDD $\mathcal F=(V,E,\idx,\low,\high,\w),$01 s; LIMDD $\mathcal F=(V,E,\idx,\low,\high,\w),$02 s

These results are presented as confirmation that LimTDD often matches or outperforms TDD and LIMDD in both memory and speed, while delivering exponential savings in best cases (Hong et al., 1 Apr 2025).

6. Quantum state preparation based on LimTDD

The state-preparation line of work treats a LimTDD $\mathcal F=(V,E,\idx,\low,\high,\w),$03 for $\mathcal F=(V,E,\idx,\low,\high,\w),$04 as a compressed synthesis scaffold for a circuit $\mathcal F=(V,E,\idx,\low,\high,\w),$05 satisfying

$\mathcal F=(V,E,\idx,\low,\high,\w),$06

The 2025 technical report presents a one-ancilla procedure that recursively cancels incoming-edge maps with controlled $\mathcal F=(V,E,\idx,\low,\high,\w),$07, traverses low and high branches, and applies a 2-qubit rotation to merge outgoing weights into $\mathcal F=(V,E,\idx,\low,\high,\w),$08 (Hong et al., 19 Jul 2025). Its stated gate count is $\mathcal F=(V,E,\idx,\low,\high,\w),$09 multi-qubit gates plus $\mathcal F=(V,E,\idx,\low,\high,\w),$10 3-qubit gates to cancel local operators, where $\mathcal F=(V,E,\idx,\low,\high,\w),$11 is the number of reduced paths; in the best case $\mathcal F=(V,E,\idx,\low,\high,\w),$12, yielding $\mathcal F=(V,E,\idx,\low,\high,\w),$13 gates (Hong et al., 19 Jul 2025).

The extended work generalizes this to four algorithms: StatePre1 with no ancilla, StatePre2 with one ancilla, StatePre3 with sufficiently many ancillae, and StatePre4 as a hybrid strategy (Hong et al., 23 Jul 2025). The no-ancilla algorithm has gate complexity consisting of $\mathcal F=(V,E,\idx,\low,\high,\w),$14 single-qubit gates and

$\mathcal F=(V,E,\idx,\low,\high,\w),$15

$\mathcal F=(V,E,\idx,\low,\high,\w),$16-qubit controlled gates. The one-ancilla algorithm uses overall $\mathcal F=(V,E,\idx,\low,\high,\w),$17 multi-qubit gates plus $\mathcal F=(V,E,\idx,\low,\high,\w),$18 single-qubit gates. The sufficient-ancilla algorithm, with one ancilla per nonterminal node, uses $\mathcal F=(V,E,\idx,\low,\high,\w),$19 multi-qubit gates and $\mathcal F=(V,E,\idx,\low,\high,\w),$20 single-qubit gates, where $\mathcal F=(V,E,\idx,\low,\high,\w),$21. The hybrid algorithm gives time complexity $\mathcal F=(V,E,\idx,\low,\high,\w),$22 and a trade-off formula parameterized by the number of allocated ancillae (Hong et al., 23 Jul 2025).

Empirically, the state-preparation report compares LimTDD, ADD-based synthesis, Qiskit 2024, and QuICT 2023 on random Clifford+T states. Average CX counts are reported as $\mathcal F=(V,E,\idx,\low,\high,\w),$23, $\mathcal F=(V,E,\idx,\low,\high,\w),$24, and $\mathcal F=(V,E,\idx,\low,\high,\w),$25 for LimTDD at $\mathcal F=(V,E,\idx,\low,\high,\w),$26, versus $\mathcal F=(V,E,\idx,\low,\high,\w),$27, $\mathcal F=(V,E,\idx,\low,\high,\w),$28, and $\mathcal F=(V,E,\idx,\low,\high,\w),$29 for ADD, with much larger values for Qiskit and QuICT; LimTDD is stated to surpass others for $\mathcal F=(V,E,\idx,\low,\high,\w),$30 in CX count and $\mathcal F=(V,E,\idx,\low,\high,\w),$31 in runtime, while Qiskit and QuICT time out beyond $\mathcal F=(V,E,\idx,\low,\high,\w),$32, and the ADD method runs out of memory beyond $\mathcal F=(V,E,\idx,\low,\high,\w),$33 (Hong et al., 19 Jul 2025). The extended paper reports that, at $\mathcal F=(V,E,\idx,\low,\high,\w),$34, the one-ancilla algorithm uses about $\mathcal F=(V,E,\idx,\low,\high,\w),$35 pre-transpile gates versus about $\mathcal F=(V,E,\idx,\low,\high,\w),$36 for ADD, and the many-ancilla algorithm uses about $\mathcal F=(V,E,\idx,\low,\high,\w),$37 gates versus about $\mathcal F=(V,E,\idx,\low,\high,\w),$38 for FBDD (Hong et al., 23 Jul 2025).

7. Limitations, open directions, and naming ambiguity

The limitations stated across the two state-preparation papers are straightforward. In the worst case there may be no effective compression, with $\mathcal F=(V,E,\idx,\low,\high,\w),$39 or $\mathcal F=(V,E,\idx,\low,\high,\w),$40. The one-ancilla strategy requires an ancilla qubit, and depth overhead arises from multi-controls. The current subgroup $\mathcal F=(V,E,\idx,\low,\high,\w),$41 is restricted to XP-operators; richer local maps may compress more but would require more complex gates (Hong et al., 19 Jul 2025).

The proposed extensions are similarly explicit: integration into Qiskit as a native converter, exploration of other subgroups $\mathcal F=(V,E,\idx,\low,\high,\w),$42, application to simulation and verification tasks such as circuit equivalence, automatic heuristic reorderings of indices, integration with hardware-native gate sets and error-mitigation techniques, extension to general unitaries and isometries, and automated identification of state decompositions yielding small LimTDDs (Hong et al., 19 Jul 2025).

A separate nomenclature point is that the acronym “LimTDD” is also used in an LTE-Advanced survey in the context of dynamic TDD transmissions (Ding et al., 2020). That usage concerns adaptive DL/UL subframe allocation in cellular systems rather than Local Invertible Map Tensor Decision Diagrams. In current quantum-computing literature, however, “LimTDD” denotes the compact tensor and quantum-state representation introduced in 2025 and developed for simulation, verification, and quantum state preparation (Hong et al., 1 Apr 2025).