---
title: Local Invertible Map Decision Diagram (LIMDD)
url: https://www.emergentmind.com/topics/local-invertible-map-decision-diagram-limdd
type: topic
---

# Local Invertible Map Decision Diagram (LIMDD)

Searching arXiv for LIMDD-related papers to ground the article in current literature.
A **Local Invertible Map Decision Diagram (LIMDD)** is a quantum decision-diagram data structure that represents quantum states by merging sub-vectors not only when they are identical up to a complex scalar, as in conventional quantum multiple-valued decision diagrams (QMDDs), but also when they are equivalent up to a tensor product of single-qubit invertible maps [2108.00931]. In its principal form, the **Pauli-LIMDD**, the local maps are Pauli operators multiplied by a nonzero complex scalar, so the structure canonically factors out local Pauli equivalences between recursively defined substates [2108.00931]. This stronger equivalence relation was introduced to bridge the gap between DD-based simulation and the stabilizer formalism, especially for circuit families where standard DDs remain exponentially large even though the underlying states are classically tractable in other representations [2108.00931]. Subsequent work focused on making Pauli-LIMDDs practically canonical and efficient, culminating in a normal-form algorithm and implementation that realize the theoretical advantages on Clifford-heavy workloads [2606.24789]. In later tensor-oriented work, LIMDD also serves as the state-specialized antecedent to broader tensor formalisms such as LimTDD, which generalize the same local-isomorphism principle beyond state vectors [2504.01168].

## 1. Definition and semantic model

A LIMDD represents an \(n\)-qubit state as a rooted directed acyclic graph whose recursive semantics follow the Shannon decomposition of a pseudo-Boolean amplitude function [2108.00931, 2606.24789]. If \(\ket{\psi}\in\mathbb C^{2^n}\) is viewed as a function \(\psi:\{0,1\}^n\to\mathbb C\), then one writes
\[
\ket{\psi}=\ket{0}\otimes \ket{\psi_0}+\ket{1}\otimes \ket{\psi_1}.
\]
An internal node stores this decomposition recursively: its low and high successors correspond to the sub-vectors \(\ket{\psi_0}\) and \(\ket{\psi_1}\), while edge labels encode transformations applied to the child state [2606.24789].

The defining distinction from QMDDs is the label set and the induced equivalence relation. In a QMDD, edge labels are complex scalars, and node merging is based on scalar equivalence,
\[
\ket{\phi}= \lambda \ket{\psi},\qquad \lambda\in \mathbb C.
\]
In a LIMDD, edge labels are **local invertible maps (LIMs)**, i.e. tensor products of invertible \(2\times 2\) matrices, and node merging is based on
\[
\ket{\phi}=L\ket{\psi},
\]
where \(L\) is local across qubits [2606.24789]. The 2021 formulation defines an \(n\)-qubit \(G\)-local invertible map as
\[
\mathcal O=\lambda \mathcal O_n\otimes\cdots\otimes \mathcal O_1,
\]
with \(\mathcal O_i\in G\) for a group \(G\) of invertible \(2\times 2\) matrices and \(\lambda\in\mathbb{C}\setminus \{0\}\), and calls two states \(G\)-isomorphic if one is obtained from the other by such a map [2108.00931].

The main instantiation in the foundational and implementation-focused work is the **Pauli-LIMDD**, in which the allowed local maps are Pauli words multiplied by a scalar [2108.00931, 2606.24789]. Since QMDDs are recovered as the special case \(L=\lambda I\), LIMDDs strictly extend scalar-only DD reduction [2606.24789]. This increase in expressiveness is the basis for their stronger compression on families with pervasive local Pauli symmetries.

## 2. Historical motivation and relation to prior decision diagrams

LIMDD was introduced to address a specific limitation of earlier decision-diagram techniques: standard DDs can require exponential size even for stabilizer states [2108.00931]. The 2021 paper proves, in particular, that two-dimensional cluster states require exponentially large QMDDs; the explicit lower bound states that for the \(n\times n\) cluster state \(\ket{G_n}\), every QMDD has at least \(2^{n/12}\) nodes [2108.00931]. This establishes that previous DD families do not contain all stabilizer states as a polynomial-size subclass.

The motivation was therefore to combine two successful ideas that had previously remained separated: DD-based structural sharing and stabilizer-style local symmetry [2108.00931]. LIMDD enlarges the DD merge criterion so that two recursively generated sub-vectors can share a node whenever they differ only by local invertible maps, rather than by a scalar alone. Stabilizer states are especially important in this context because local Pauli actions are pervasive in their recursive structure.

The representational consequences are formalized strongly in the foundational theory. Every stabilizer state is represented, up to normalization, by a \(\langle X,Y,Z\rangle\)-Tower-LIMDD, and conversely every such tower represents a stabilizer state [2108.00931]. Special subclasses recover graph states and coset states via \(\langle Z\rangle\)- and \(\langle X\rangle\)-tower constructions, respectively [2108.00931]. Together with the QMDD lower bounds, this yields strict asymptotic separation between Pauli-LIMDDs and earlier DD variants.

The same paper further proves that polynomial-size LIMDDs strictly contain the union of stabilizer states and prior DD families by exhibiting **pseudo cluster states**, which have polynomial-size Pauli-LIMDD representations but exponential-size QMDD representations [2108.00931]. The later implementation work frames these results as theoretically established advantages that had not yet fully appeared in practice because complete and efficient canonicity machinery was missing [2606.24789].

## 3. Pauli-LIMDDs and canonical reduction

The central technical issue in LIMDDs is **canonicity**. As with other DDs, practical efficiency depends on converting represented objects into a normal form so that equivalent nodes can be merged via unique-table lookup rather than repeated equivalence testing [2606.24789]. In LIMDDs this is substantially more subtle than in QMDDs because local invertible maps introduce additional representational degrees of freedom.

For Pauli-LIMDDs, prior theory specifies four canonicalization rules that together eliminate all residual freedom for a node with reduced children [2606.24789]:

1. **Zero-edge rule.** If an outgoing label is \(0\), canonicality requires
   \[
   low(v)=high(v)
   \]
   whenever one or both outgoing labels are \(0\).

2. **Low precedence.** Since local \(X\) on the split qubit can swap the low and high branches, canonicality fixes an order
   \[
   low(v)\;\beforeq\; high(v)
   \]
   under a chosen total order on nodes.

3. **Low factoring.** Any LIM common to both outgoing branches can be factored outward, so whenever the low edge is nonzero and points to an \(n\)-qubit child, its label is required to be
   \[
   I_n.
   \]

4. **High determinism.** After the previous rules, the high label may still be non-unique because child stabilizers can modify it without changing the represented state. Canonicality therefore selects the **minimum** valid high label according to a fixed total order on Pauli-LIMs.

A **reduced** LIMDD satisfies all four rules plus the merge rule of no duplicate nodes; a **semi-reduced** LIMDD satisfies everything except high determinism [2606.24789]. Prior theory proves completeness: two reduced LIMDDs have the same root if and only if they represent equivalent states [2606.24789]. In the 2021 formulation, this is expressed as uniqueness of the reduced Pauli-LIMDD representative of each Pauli-isomorphism class [2108.00931].

The hardest step is high determinism. The foundational paper characterizes all eligible high-edge labels in terms of the child stabilizer subgroups and shows that the canonical one is the minimum over all labels obtainable by stabilizer actions, sign changes, and, in the equal-child case, branch exchange [2108.00931]. This is the point at which LIMDD canonicity departs most sharply from ordinary QMDD normalization.

## 4. Normal-form algorithms and stabilizer-based minimization

The 2026 paper concentrates on the bottleneck in practical Pauli-LIMDD reduction: the normal-form computation implementing high determinism [2606.24789]. For an \(n\)-qubit semi-reduced node
\[
u:= \lnode{I}{v_0}{\beta B}{v_1},
\]
with \(\beta\in\mathbb C\) and \(B\in Pauli_n\), the canonical reduced form is
\[
u_{\mathrm{can}:=\lnode{I}{v_0}{\alpha A}{v_1},
\]
where \(\alpha A\) is chosen as the minimum over child-stabilizer actions:
\[
\alpha A = \min_{\substack{s,x\in\{0,1\},\ g\in Stab(v_0),\ h\in Stab(v_1)}}
\left\{ (-1)^s \cdot \beta^{(-1)^x} gBh \;\middle|\; x\neq 1 \text{ if } v_0\neq v_1 \right\}.
\tag{1}
\]
The associated state relation is
\[
\ket{u_{\mathrm{can}} = (X\otimes \beta B)^x \cdot (Z^s\otimes g_{\min})\ket{u},
\tag{2}
\]
where \(g_{\min}\in Stab(v_0)\) attains the minimum [2606.24789].

To support exact minimization, the paper uses a total order on Pauli-LIMs based on a binary encoding of Pauli words. The one-qubit Paulis are encoded as
\[
I \simeq (0,0),\quad Z\simeq(0,1),\quad X\simeq(1,0),\quad Y\simeq(1,1),
\]
and for a Pauli word \(P_1\otimes\cdots\otimes P_n\),
\[
revbin{P_1\otimes\cdots\otimes P_n} = (x_n,x_{n-1},\dots,x_1,z_n,z_{n-1},\dots,z_1).
\]
For a Pauli-LIM \(r e^{i\theta}P\), the ordered key is the concatenation of \(revbin(P)\) and \((r,\theta)\); comparison is lexicographic [2606.24789].

A central observation is that any two minimizers yield the same Pauli word up to sign,
\[
gBh = \pm g'Bh'.
\]
This allows a two-stage procedure: first minimize the Pauli word
\[
A = \min_{g\in Stab(v_0),\, h\in Stab(v_1)} word(gBh),
\]
then minimize the scalar \(\alpha\) by checking the four combinations \(x,s\in\{0,1\}\) [2606.24789].

The algorithmic mechanism for word minimization is an adapted **Zassenhaus procedure**. Given row-echelon stabilizer generator sets \(S_0,S_1\) and Pauli word \(B\), the task is
\[
(g_{\min},h_{\min}) = \arg\min_{g\in \langle S_0\rangle,\ h\in \langle S_1\rangle} word(gBh).
\tag{3}
\]
Rather than computing stabilizer intersections or cosets explicitly, the method constructs a three-register Zassenhaus matrix whose left register stores binary Pauli-word vectors and whose middle and right registers track the corresponding group elements from the two child stabilizers [2606.24789]. Gaussian elimination is performed on the left register with row addition defined by Pauli multiplication. Because stabilizer groups are commutative, the elimination is valid and yields rows whose nonzero left parts form a basis of the vector space generated by all possible \(word(gh)\) combinations, while the auxiliary registers retain the corresponding \(g\) and \(h\) factors [2606.24789].

Once that basis is available, the paper appends the row for \(word(B)\) and runs a minimal-vector reduction: scanning pivot columns left to right, it adds a pivot row whenever the bottom row contains a \(1\) in that pivot column. The resulting bottom row is \(word(g_{\min}Bh_{\min})\), and the side registers directly expose the minimizers [2606.24789].

This yields worst-case runtime
\[
O\!\left(n\,(|S_0|+|S_1|)^2\right),
\]
hence at most \(O(n^3)\) because \(|S_0|,|S_1|\le n\) [2606.24789]. The principal improvement appears in the **single-child case** \(v_0=v_1\), where the minimization reduces to
\[
\min_{h\in \langle S_0\rangle} word(Bh),
\]
so the full Zassenhaus computation is unnecessary. The complexity drops to
\[
O(n\,|S_0|),
\]
that is,
\[
O(n^2),
\]
since \(|S_0|\le n\) [2606.24789]. This is the paper’s headline improvement: the worst-case normalization cost for an \(n\)-qubit node with a single child is reduced from \(O(n^3)\) to \(O(n^2)\), while the two-distinct-children case remains \(O(n^3)\) [2606.24789].

## 5. Stabilizer computation, implementation, and numerical handling

High determinism requires stabilizer information for reduced child nodes, so the 2026 work also develops a recursive **stabilizer-finding** algorithm [2606.24789]. For a reduced node
\[
\lnode{I}{\phi_0}{\alpha A}{\phi_1},
\]
with child stabilizer row-echelon generator sets \(S_0,S_1\), the method recursively constructs a generating set for \(Stab(\phi)\). Candidate stabilizers are split according to whether the leading one-qubit Pauli factor lies in \(\{I,Z\}\) or \(\{X,Y\}\), which leads to separate algebraic conditions [2606.24789].

For \(P_1\in\{I,Z\}\), the stabilizer condition becomes
\[
P'\ket{\phi_0}=\ket{\phi_0}, \qquad P'\alpha A\ket{\phi_1}=x\alpha A\ket{\phi_1},
\tag{4}
\]
and when \(\alpha\neq 0\), the generated stabilizers are
\[
\left\{ \begin{pmatrix} 1&0\\ 0&\sigma(g,A)\gamma_g \end{pmatrix} \otimes g \ \middle|\ g\in S' \right\},
\tag{5}
\]
where \(S'\) is a row-echelon generating set of common stabilizers of \(\phi_0\) and \(\phi_1\), and \(\gamma_g\in\{\pm1\}\) satisfies \(g\ket{\phi_1}=\gamma_g\ket{\phi_1}\) [2606.24789]. For distinct children, the computation reuses information already produced during the Zassenhaus-based high-determinism step, specifically the zero-left-register rows, thereby reducing overhead [2606.24789].

For \(P_1\in\{X,Y\}\), the condition reduces to
\[
y^* \alpha P' A \ket{\phi_0} = \ket{\phi_0}.
\tag{6}
\]
A solution exists only if \(\phi_0=\phi_1\) and \(\alpha\in\{\pm1,\pm i\}\), yielding the extra generator
\[
\begin{pmatrix} 0 & \alpha^*\\ \alpha & 0 \end{pmatrix} \otimes A.
\tag{7}
\]
This stabilizer-finding routine inherits the same asymptotic improvement pattern: \(O(n^3)\) for distinct children with \(\alpha\neq 0\), \(O(n^2)\) for the single-child case with \(\alpha\neq 0\), and \(O(n^2)\) when \(\alpha=0\) [2606.24789].

The implementation packages the normal-form machinery as the open-source C library **PauliLim** and integrates it into **QolDDer**, a from-scratch C/C++ Pauli-LIMDD simulator [2606.24789]. The engineering follows standard DD practice: nodes are normalized before insertion, canonical nodes are stored in a hash table, collisions are handled by chaining, each node receives a unique ID from its table position, and those IDs are used when hashing parent nodes [2606.24789]. This realizes a complete canonical Pauli-LIMDD workflow, which the paper contrasts with earlier tools whose canonicity was absent or incomplete.

Because edge labels include complex scalars, numerical handling is critical. QolDDer uses a configurable tolerance
\[
\delta = 10^{-13},
\]
and considers complex numbers \(\alpha,\alpha'\) equivalent when both real and imaginary parts differ by at most \(\delta\) [2606.24789]. To find \(\delta\)-close scalars efficiently, the implementation stores them in a search tree. The paper also mentions a small modification to the normalization rules, inspired by QMDD numerical-stability work, that preserves LIMDD canonicity while mitigating numerical issues [2606.24789].

## 6. Expressiveness, applications, and empirical behavior

The principal theoretical claim about LIMDDs is representational. They can be **exponentially more compact** than conventional DDs on some circuit families, and operation cost in DD-based simulation depends strongly on node count [2606.24789]. The 2021 paper states formal separations showing circuit families for which LIMDD simulation is exponentially faster than QMDDs, matrix-product states, and Clifford+\(T\) stabilizer-decomposition methods, while also proving that LIMDDs are at worst polynomially slower than QMDDs on arbitrary circuits [2108.00931].

Clifford circuits are especially well suited to Pauli-LIMDDs because the representation exploits Pauli-gate equivalence and stabilizer structure directly [2606.24789]. The foundational paper proves that any Clifford gate (\(H,S,\mathrm{CNOT}\)) can be applied in \(\mathcal O(n^4)\) time to any qubits of a LIMDD representing a stabilizer state [2108.00931]. The reason is that stabilizer states admit tower LIMDDs with only \(n\) nonterminal nodes, and the recursive additions induced by Clifford operations collapse into a polynomial number of cache-distinct cases [2108.00931].

LIMDDs are not limited to pure Clifford simulation. The 2021 theory shows circuit families preparing \(\ket{W_n}\) that Pauli-LIMDDs can efficiently simulate, while extended stabilizer-decomposition methods incur exponential cost under ETH-based assumptions [2108.00931]. The 2026 implementation paper similarly emphasizes that Pauli-LIMDDs remain useful on some high-\(T\)-count circuits, though its practical sweet spot is clearly Clifford-heavy structure [2606.24789].

A simple example of the extra merging power is that ordinary DDs treat
\[
\begin{bmatrix}1&2&3&0\end{bmatrix}^{\mathsf T}
\quad\text{and}\quad
\begin{bmatrix}1&2&-3&0\end{bmatrix}^{\mathsf T}
\]
as distinct unless one is a scalar multiple of the other, whereas a LIMDD can merge them because
\[
\begin{bmatrix}1&2&3&0\end{bmatrix}^{\mathsf T}
=
(Z\otimes I)
\begin{bmatrix}1&2&-3&0\end{bmatrix}^{\mathsf T}.
\]
The canonicalization machinery then ensures that among all equivalent placements of this local transformation, exactly one representative is kept [2606.24789].

The empirical evaluation in the 2026 paper targets the gap between theory and implementation. QolDDer is benchmarked against MQT-LIMDD, LimTDD, and the QMDD-based MQT-DDSIM on a synthetic random-Clifford benchmark and on the public MQTBench dataset [2606.24789]. The random-Clifford setup consists of \(100n\) random Clifford gates on \(n=10\) to \(30\) qubits, with 10 instances each and gate set \(\{H,P(\pi/2),CX\}\); all experiments run on an AMD Ryzen 7 9800X3D with 64 GB RAM, a 10-minute timeout, and a 16 GB memory cap [2606.24789].

A particularly informative comparison is between canonical reduced Pauli-LIMDDs and merely semi-reduced ones. The reported result is that **full canonicity significantly lowers node count and simulation time**; on random Clifford circuits, the canonical version is much faster and much smaller [2606.24789]. This directly supports the interpretation that high determinism is not a cosmetic normalization choice but a prerequisite for realizing the compactness promised by the theory.

Against prior LIMDD simulators, QolDDer is reported to be **significantly faster on Clifford circuits** and often **outperforms existing LIMDD tools by an order of magnitude** on public benchmarks [2606.24789]. The paper explicitly states that the implementation “realizes the theoretically-proven advantages of Pauli-LIMDDs on Clifford circuits” [2606.24789].

## 7. Generalizations, limitations, and relation to LimTDD

LIMDD is fundamentally a **state-vector** decision diagram. The LimTDD paper identifies this as a key limitation: LIMDD is “specifically designed for quantum state representations and cannot be directly applied to general tensor representations or quantum circuit functionality computation” [2504.01168]. In that work, LIMDD serves as the nearest prior formalism using local invertible maps for DD compression, while LimTDD generalizes the idea to arbitrary tensors via vectorization and extends the local operator family to the XP-stabilizer group [2504.01168].

The relation among the three frameworks is stated cleanly in the tensor paper. When the allowed group \(\mathcal G\) is restricted to the Pauli group, LimTDD is equivalent to LIMDD representing quantum states; when \(\mathcal G\subset \mathbb C\cdot I\), LimTDD reduces exactly to standard TDD [2504.01168]. This places LIMDD as the state-specialized Pauli-local member of a broader family of local-isomorphism-based DDs.

Within its own scope, however, LIMDD also has important internal limitations. The 2026 implementation work is specifically about **Pauli-LIMDDs**, not more general LIMDD families such as XP/LimTDD variants [2606.24789]. Its main asymptotic improvement applies to the single-child normalization case; the hardest case, nodes with two distinct children, still has worst-case \(O(n^3)\) normalization cost [2606.24789]. More broadly, neither the 2021 theory nor the 2026 implementation suggests that LIMDDs make generic quantum simulation polynomial. Generic addition and generic gate application still have exponential worst-case behavior, just as in other exact DD formalisms [2108.00931].

The literature is also careful about implementation status. The foundational paper develops canonicity and manipulation procedures but is primarily theoretical and algorithmic rather than an empirical systems paper [2108.00931]. The later paper argues that earlier implementations had not fully solved complete canonicity: MQT-LIMDD was only partially canonical and could fail to produce minimal-size LIMDDs, while LimTDD explicitly omitted canonicity guarantees in the sense relevant to Pauli-LIMDD minimality [2606.24789]. This suggests that practical performance comparisons across implementations must be interpreted in light of differing normalization guarantees.

The current trajectory of the field points toward two open directions. One is to extend strong canonicity and efficient normal-form machinery from Pauli-LIMDDs to richer local-map groups [2606.24789]. The other is to transport the local-equivalence paradigm from state simulation to broader linear-algebraic workloads, including tensor-network contraction and circuit functionality analysis, as already pursued by LimTDD [2504.01168]. In this sense, LIMDD occupies a pivotal position: it is both a concrete exact simulator data structure for quantum states and a conceptual prototype for decision diagrams based on local invertible equivalence rather than literal subtree identity.

Source: https://www.emergentmind.com/topics/local-invertible-map-decision-diagram-limdd