---
title: 'LimTDD: Local Invertible Map Tensor Decision Diagram'
url: https://www.emergentmind.com/topics/limtdd
type: topic
---

# LimTDD: Local Invertible Map Tensor Decision Diagram

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 [2504.01168]. Subsequent work uses LimTDD as the core representation for quantum state preparation, including algorithms for no-ancilla, one-ancilla, and many-ancilla settings [2507.14496].

## 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 [2504.01168].

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

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 G\) 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 [2504.01168].

## 2. Formal definition and semantics

A \(\mathcal G\)-LimTDD over an index set \(S\) is defined as a rooted DAG
\[
\mathcal F=(V,E,\idx,\low,\high,\w),
\]
or, in a more expanded notation,
\[
\mathcal F=(V,V_{NT},v_T,\idx,\low,\high,E,w),
\]
where \(V_{NT}\) is the set of nonterminal nodes, \(v_T\) is the unique terminal node labeled by the scalar \(1\), \(\idx\) assigns indices to nonterminal nodes, \(\low\) and \(\high\) define 0- and 1-successors, and each edge weight lies in a subgroup \(\mathcal G\le\mathcal M\) of local invertible maps [2507.14496].

| Component | Role |
|---|---|
| \(v_T\) | Unique terminal node with semantics \(1\) |
| \(\idx\) | Variable or qubit ordering on nonterminal nodes |
| \(\low,\high\) | 0- and 1-successors |
| \(w(e)\) | Edge label in \(\mathcal G\) |
| Root edge | Carries the global weight |

The semantics used in the quantum-state preparation papers is
\[
\lvert e\rangle=w(e)\,\lvert\mathrm{target}(e)\rangle,
\qquad
\lvert v\rangle=\lvert0\rangle\otimes\lvert(v,\low(v))\rangle+\lvert1\rangle\otimes\lvert(v,\high(v))\rangle,
\]
with the represented state given by \(\lvert\psi\rangle=w_r\lvert r\rangle\) [2507.14496]. 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 [2504.01168].

Two reduction rules are central. First, one merges isomorphic subgraphs if low- and high-subtrees agree up to an operator in \(\mathcal G\). Second, one normalizes edge weights so that the 0-edge weight is the identity, absorbing scalars through the incoming edge [2507.14496]. 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 \(N\), with \(\omega=e^{2\pi i/N}\), where an \(n\)-qubit XP-operator is
\[
XP_N(p\mid \mathbf x\mid \mathbf z)
=
\omega^p\bigotimes_{i=1}^n X^{\mathbf x_i}P^{\mathbf z_i}.
\]
The paper states that its subgroup of stabilizers is finite and admits a unique canonical generator set, which makes it suitable for normalization [2504.01168].

The local normalization routine, denoted \(\locnorm(x,\mathcal F_0,\mathcal F_1)\to(w,v)\), is invoked whenever a node is created from children \(\mathcal F_0=(w_0,v_0)\) and \(\mathcal F_1=(w_1,v_1)\) at index \(x\). The procedure fixes one edge weight to \(I\), enforces canonical ordering, and chooses the lexicographically smallest representative in
\[
W_1=\{\,g_1^\dag w_1^\dag w_0\,g_0 : g_i\in Stab(v_i)\,\},
\]
or in \(W_0\cup W_1\) when \(v_0=v_1\), while absorbing overall phases into the parent’s incoming weight [2504.01168].

The main recursive construction routine expands the smallest index, generates the two cofactors, and then calls \(\locnorm\). Slicing descends to the first node labeled by the target variable, applies any \(X\)-swap or \(P\)-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 \(I\), 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 \(\locnorm\). Contraction generalizes the usual TDD rule by summing over a contracted variable and otherwise rebuilding the node via local normalization [2504.01168].

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 \(O(1)\) expected time using a hash table keyed by the 5-tuple \((\idx,\low,\high,w_{\low},w_{\high})\) [2507.14496].

## 4. Compactness theorems and asymptotic behavior

The central structural guarantee is the isomorphic-nodes theorem. For tensors \(\phi\) and \(\gamma\) on the same indices with LimTDDs \(\mathcal F\) and \(\mathcal G\),
\[
\phi=O\,\gamma
\;\Longleftrightarrow\;
r_{\mathcal F}=r_{\mathcal G}
\quad\text{and}\quad
w_{\mathcal F}=O\,w_{\mathcal G}\,g
\]
for some \(O\in\mathcal G\) and \(g\in Stab(\Phi(r_{\mathcal G}))\). The stated consequence is that any two isomorphic sub-tensors collapse to the same node [2504.01168].

A corollary gives the pointwise compactness relation
\[
|\mathrm{LimTDD}(\phi)|\le |\mathrm{TDD}(\phi)|
\quad\text{and}\quad
|\mathrm{LimTDD}(\phi)|\le |\mathrm{LIMDD}(\phi)|.
\]
In that sense, LimTDD subsumes both TDD and LIMDD as special cases while preserving their general representational setting [2504.01168].

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(n)\), while TDD or LIMDD remain \(\Omega(2^n)\) [2504.01168]. The state-preparation report gives a more explicit family, the complete-graph CZ states
\[
\lvert v_n\rangle
=
\frac1{\sqrt2}\Bigl(
\lvert0\rangle\otimes\lvert v_{n-1}\rangle
+
\lvert1\rangle\otimes(Z^{\otimes n-1}\lvert v_{n-1}\rangle)
\Bigr),
\]
for which the reduced ADD representation has \(\Theta(2^{n-1})\) distinct paths, while the LimTDD representation has exactly \(n+1\) nodes and a single reduced path [2507.14496]. 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=2^k\), 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 [2504.01168].

For 20-qubit Clifford+T circuits with T-density \(0.02\), the reported averages are approximately \(0.2\) s for LimTDD, \(2.5\) s for TDD, and \(25\) s for LIMDD, with node counts of about \(800\), \(10{,}000\), and \(100{,}000\), respectively [2504.01168]. For functionality construction on \(QFT_{12}\), TDD uses about \(8.4\) million nodes whereas LimTDD uses \(25\) nodes, described as about \(300{,}000\times\) compression; the corresponding runtimes are about \(140\) s and \(0.1\) s [2504.01168].

For the QFT-entangled circuit family up to \(n=15\), LimTDD is reported to remain \(O(n)\) in nodes, approximately \(30\)–\(40\), while TDD and LIMDD blow up exponentially. At \(n=15\), the reported timings are \(0.5\) s for LimTDD, \(8.6\) s for TDD, and \(37\) s for LIMDD [2504.01168].

| Benchmark setting | LimTDD | Comparator results |
|---|---|---|
| 20-qubit Clifford+T, T-density \(0.02\) | \(\approx0.2\) s, \(\approx800\) nodes | TDD \(\approx2.5\) s, \(\approx10{,}000\); LIMDD \(\approx25\) s, \(\approx100{,}000\) |
| Functionality construction \(QFT_{12}\) | \(25\) nodes, \(\approx0.1\) s | TDD \(\approx8.4\) million nodes, \(\approx140\) s |
| QFT-entangled, \(n=15\) | \(0.5\) s, \(\approx30\)–\(40\) nodes | TDD \(8.6\) s; LIMDD \(37\) 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 [2504.01168].

## 6. Quantum state preparation based on LimTDD

The state-preparation line of work treats a LimTDD \(\mathcal F\) for \(\lvert\psi\rangle\) as a compressed synthesis scaffold for a circuit \(C\) satisfying
\[
C\lvert0\rangle^{\otimes n}=\lvert\psi\rangle
\quad\text{or equivalently}\quad
U^\dagger\lvert\psi\rangle=\lvert0\rangle^{\otimes n}.
\]
The 2025 technical report presents a one-ancilla procedure that recursively cancels incoming-edge maps with controlled \(O^\dagger\), traverses low and high branches, and applies a 2-qubit rotation to merge outgoing weights into \(\lvert0\rangle\) [2507.14496]. Its stated gate count is \(O(np)\) multi-qubit gates plus \(O(n^2p)\) 3-qubit gates to cancel local operators, where \(p\) is the number of reduced paths; in the best case \(p=O(n)\), yielding \(O(n^2)\) gates [2507.14496].

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 [2507.17170]. The no-ancilla algorithm has gate complexity consisting of \(n\) single-qubit gates and
\[
\sum_{s=2}^n p\,(n+2-s)
\]
\(s\)-qubit controlled gates. The one-ancilla algorithm uses overall \(O(pn)\) multi-qubit gates plus \(n\) single-qubit gates. The sufficient-ancilla algorithm, with one ancilla per nonterminal node, uses \(O(mn)\) multi-qubit gates and \(n\) single-qubit gates, where \(m=|V_{NT}|\). The hybrid algorithm gives time complexity \(O(m+kp)\) and a trade-off formula parameterized by the number of allocated ancillae [2507.17170].

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 \(52\), \(75\), and \(101\) for LimTDD at \(n=10,12,15\), versus \(1{,}200\), \(3{,}450\), and \(8{,}000\) for ADD, with much larger values for Qiskit and QuICT; LimTDD is stated to surpass others for \(n\gtrsim7\) in CX count and \(n\gtrsim10\) in runtime, while Qiskit and QuICT time out beyond \(n=17,21\), and the ADD method runs out of memory beyond \(n=18\) [2507.14496]. The extended paper reports that, at \(n=15\), the one-ancilla algorithm uses about \(80\) pre-transpile gates versus about \(2500\) for ADD, and the many-ancilla algorithm uses about \(30\) gates versus about \(200\) for FBDD [2507.17170].

## 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 \(|V|=O(n2^n)\) or \(p\approx2^n\). The one-ancilla strategy requires an ancilla qubit, and depth overhead arises from multi-controls. The current subgroup \(\mathcal G\) is restricted to XP-operators; richer local maps may compress more but would require more complex gates [2507.14496].

The proposed extensions are similarly explicit: integration into Qiskit as a native converter, exploration of other subgroups \(\mathcal G\), 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 [2507.14496].

A separate nomenclature point is that the acronym “LimTDD” is also used in an LTE-Advanced survey in the context of dynamic TDD transmissions [2003.08718]. 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 [2504.01168].

Source: https://www.emergentmind.com/topics/limtdd