---
title: 'QolDDer: Canonical Pauli-LIMDD Simulator'
url: https://www.emergentmind.com/topics/qoldder
type: topic
---

# QolDDer: Canonical Pauli-LIMDD Simulator

Searching arXiv for the QolDDer paper and closely related LIMDD/QMDD simulators for citation support.
tool call: arxiv_search({"query":"arXiv:2606.24789 OR title:\"Faster algorithm for achieving minimal-size quantum decision diagrams\"","max_results":5,"sort_by":"relevance"})
tool call: arxiv_search({"query":"\"Faster algorithm for achieving minimal-size quantum decision diagrams\"","max_results":10,"sort_by":"relevance"})
QolDDer is a quantum-circuit simulator whose core data structure is the Pauli Local-Invertible-Map Decision Diagram (Pauli-LIMDD). It is designed to make the theoretical compression and runtime advantages of LIMDDs usable in practice by providing a fast, fully canonical implementation, with a new normal-form algorithm at its core. In the formulation reported in "Faster algorithm for achieving minimal-size quantum decision diagrams" [2606.24789], QolDDer is implemented from scratch in C/C++, built on top of a separate C library called PauliLim, and targeted especially at Clifford circuits and some high-\(T\)-count regimes where Pauli-structured compression is consequential.

## 1. Decision-diagram setting and the Pauli-LIMDD model

Quantum decision diagrams represent vectors and matrices as directed acyclic graphs obtained from a Shannon-like recursive decomposition. For an \(n\)-qubit pure state \(\ket{\psi}\in \mathbb{C}^{2^n}\), the decomposition
\[
\ket{\psi}=\ket{0}\otimes\ket{\psi_0}+\ket{1}\otimes\ket{\psi_1}
\]
induces a node with a low edge to a representation of \(\ket{\psi_0}\) and a high edge to a representation of \(\ket{\psi_1}\), while a terminal node represents the scalar \(1\). The operational value of the representation comes from canonicity: if every subvector has a unique canonical form, then identical or equivalent subvectors share nodes, and linear-algebra operations such as matrix–vector multiplication can be executed directly on the compressed structure [2606.24789].

Within this family, Quantum Multiple-Valued Decision Diagrams merge nodes only when their subvectors differ by a global complex scalar,
\[
\ket{\phi}=\lambda\ket{\psi}.
\]
Local-Invertible Map Decision Diagrams generalize this criterion. An \(n\)-qubit local invertible map is
\[
L=L_1\otimes L_2\otimes \dots \otimes L_n,\qquad L_i\in GL(2,\mathbb{C}),
\]
and two subvectors are LIM-equivalent when \(\ket{\phi}=L\ket{\psi}\). LIMDDs therefore subsume scalar-based DDs by allowing node merging under a strictly richer equivalence relation.

QolDDer specializes this framework to Pauli-LIMDDs. A Pauli word has the form
\[
P=P_1\otimes \dots \otimes P_n,\qquad P_i\in\{I,X,Y,Z\},
\]
possibly multiplied by a phase \(\lambda\in\{\pm 1,\pm i\}\). A Pauli-LIM is then \(\alpha P\), where \(\alpha\in\mathbb{C}\) and \(P\in Pauli_n\), and two states are Pauli-equivalent if
\[
\ket{\phi}=\alpha P\ket{\psi}.
\]
This restriction is structurally aligned with stabilizer and Clifford formalisms: stabilizer groups are subgroups of the Pauli group, and Clifford gates conjugate Pauli operators to Pauli operators. The cited work states that LIMDDs, and in particular Pauli-LIMDDs, have proven exponential compression and simulation advantages over QMDDs, ADDs, matrix-product-state approaches, and even stabilizer-plus-\(T\) techniques for certain Clifford+\(T\) circuits, but that these advantages depend on achieving a canonical and minimal representation in practice.

## 2. Canonical reduction and the normal-form problem

QolDDer’s central design goal is a fully canonical Pauli-LIMDD implementation: every node is maintained in a unique normal form so that equivalent nodes are merged and the resulting diagram is minimal modulo Pauli-LIM equivalence. The difficulty is that many graph encodings can denote the same state because scalar factors can move through the graph, children can be swapped, zero edges can point to arbitrary nodes, and local Pauli actions create further representational freedom [2606.24789].

The canonical reduced form used for Pauli-LIMDDs is defined by four conditions. First, zero-edge normalization requires that if either child edge has label \(0\), then both children are set to the same node. Second, low precedence fixes the ambiguity induced by top-qubit \(X\) actions by imposing a total order \(\preceq\) and requiring
\[
low(v)\preceq high(v).
\]
Third, low factoring requires that any LIM common to both children be factored upward, so that the low-edge label is the identity \(I_n\) whenever it is nonzero. Fourth, high determinism removes the residual ambiguity in the high-edge label by choosing the lexicographically minimal Pauli-LIM in an appropriate coset. Nodes satisfying all four conditions, together with recursive reduction of parents and children, are reduced; nodes satisfying only the first three are semi-reduced.

The theorem reused from the earlier LIMDD work is the structural basis of QolDDer’s minimality guarantee: two reduced Pauli-LIMDDs have the same root node if and only if they represent Pauli-equivalent states. This identifies node identity with Pauli equivalence and implies minimal-size representations modulo that equivalence relation.

The difficult step is high determinism. For a semi-reduced node
\[
u:=\lnode{I}{v_0}{\beta B}{v_1},
\]
representing
\[
\ket{u}=\ket{0}\otimes \ket{v_0}+\ket{1}\otimes \beta B\ket{v_1},
\]
the problem is to rewrite it as
\[
u_{\mathrm{can}}:=\lnode{I}{v_0}{\alpha A}{v_1},
\]
with \(\ket{u_{\mathrm{can}}}\) Pauli-equivalent to \(\ket{u}\) and \(\alpha A\) minimal under a fixed total order on Pauli-LIMs. The canonical high label is defined by
\[
\alpha A=\min_{\substack{s, x \in \{0, 1\},\ g\in Stab(v_0),\, h \in Stab(v_1)}}
\{(-1)^s \cdot \beta^{(-1)^x}\, g B h \mid x \neq 1 \text{ if } v_0 \neq v_1\},
\]
where \(Stab(v)\) is the Pauli stabilizer group of node \(v\). The earlier implementation strategy had worst-case \(O(n^3)\) cost per node even in the single-child case \(v_0=v_1\), and this repeated normal-form computation was identified as the practical bottleneck.

## 3. Zassenhaus-based high determinism and stabilizer maintenance

The main algorithmic contribution in QolDDer is a new high-determinism algorithm based on an adaptation of the Zassenhaus algorithm for intersections and sums of vector subspaces. The reported complexity is a worst-case improvement from \(O(n^3)\) to \(O(n^2)\) for an \(n\)-qubit node with a single child, while preserving the \(O(n^3)\) bound for nodes with two distinct children, albeit with less overhead and a simpler implementation [2606.24789].

The implementation represents Pauli words in binary form. For an \(n\)-qubit Pauli word \(P\),
\[
revbin(P_1\otimes \dots \otimes P_n)=(x_n,\dots,x_1,z_n,\dots,z_1)\in\{0,1\}^{2n},
\]
with
\[
I\simeq(0,0),\quad X\simeq(1,0),\quad Z\simeq(0,1),\quad Y\simeq(1,1).
\]
For signed words \((-1)^sP\), an additional sign bit \(s\) is appended, yielding vectors of length \(2n+1\). Stabilizer generators are therefore stored as binary matrices and reduced to row-echelon form using a variant of Gaussian elimination based on Aaronson–Gottesman rowsum rules.

In the two-child case, the task is to compute
\[
(g_{\min},h_{\min})=\arg\min_{g\in\langle S_0\rangle,\, h\in\langle S_1\rangle} word(gBh),
\]
given row-echelon generating sets for \(Stab(v_0)\) and \(Stab(v_1)\). The algorithm constructs a Zassenhaus matrix with left, middle, and right registers encoding Pauli words and the corresponding stabilizer elements. Gaussian elimination on the left register preserves the invariant
\[
k=word(gh)
\]
for every row \((k,g,h)\). After appending a row for \(B\), a minimal-vector-in-coset sweep through the left register yields the lexicographically minimal representative in
\[
word(B)+\langle word(g)\mid g\in\langle S_0\rangle\rangle+\langle word(h)\mid h\in\langle S_1\rangle\rangle,
\]
which is exactly \(word(g_{\min}Bh_{\min})\). The scalar factor \(\alpha\) is then fixed by trying the four combinations of \(x,s\in\{0,1\}\). The asymptotic cost is
\[
O\bigl(n(|S_0|+|S_1|)^2\bigr)\subseteq O(n^3).
\]

The single-child case admits a sharper reduction. When \(v_0=v_1\), the two stabilizer groups coincide, and the paper uses the identity
\[
\min_{g,h \in \langle S_0\rangle} word(gBh)=\min_{h \in \langle S_0\rangle} word(Bh),
\]
because \(gBh=\pm B(gh)\) and the sign affects only the scalar, not the Pauli-word lexicographic order. This eliminates the full Zassenhaus construction and reduces the problem to minimizing \(word(B)\) in a translate of a subspace using only the rows of \(S_0\). The resulting procedure has cost \(O(n\cdot |S_0|)\), and since \(|S_0|\le n\), the worst-case bound becomes \(O(n^2)\). The paper emphasizes that this case is especially important because strongly compressed DDs frequently contain long chains of nodes with only one nonzero child.

QolDDer also introduces a recursive stabilizer-finding algorithm that reuses the same Zassenhaus-matrix data. For a reduced node
\[
v=\lnode{I}{\phi_0}{\alpha A}{\phi_1},
\]
the stabilizer computation distinguishes \(P_1\in\{I,Z\}\) from \(P_1\in\{X,Y\}\). In the \(Z\)-type case, constraints on the children reduce stabilizer extraction to a subset of child stabilizers, together with the special \(\alpha=0\) case where \(Z\otimes I\) appears. In the \(X/Y\)-type case, the condition forces \(\phi_0=\phi_1\) and \(\alpha\in\{\pm 1,\pm i\}\), yielding a single generator of the form
\[
\begin{pmatrix}0 & \alpha^*\\ \alpha & 0\end{pmatrix}\otimes A.
\]
The complexity matches that of high-determinism minimization: \(O(n^3)\) for two-child nodes, \(O(n^2)\) for single-child nodes, and \(O(n^2)\) when \(\alpha=0\).

## 4. Software architecture, canonicity enforcement, and numerical treatment

QolDDer is organized as a two-layer system. PauliLim, written in C, contains the stabilizer representation, the Zassenhaus-based high-determinism implementation, and the stabilizer-finding routines. QolDDer, written in C/C++, contains the DD graph, the simulation engine, and the integration logic that invokes the algebraic layer during circuit simulation [2606.24789].

A node is identified by its qubit index, the pointers or IDs of its low and high children, and the edge labels—Pauli words and scalars—from the node to its children. After zero-edge normalization, low precedence, low factoring, and high determinism are applied, canonical nodes are stored in a unique-table hash structure. Hash collisions are handled by chaining, and each node receives a unique ID. Because high determinism is enforced immediately after node creation, the stored structure remains reduced at all times, and the node count directly reflects minimality under Pauli equivalence.

The implementation also addresses finite-precision issues. LIM scalars lie in \(\mathbb{C}\) and are represented in double precision. Since values such as \(1/\sqrt{2}\) and \(\cos(\pi/4)\) need not be bitwise identical after floating-point evaluation, literal comparison would prevent correct node merging. QolDDer therefore uses a configurable threshold \(\delta\), with default \(10^{-13}\), and treats \(\alpha\) and \(\alpha'\) as equivalent when
\[
|\Re(\alpha-\alpha')|\le \delta,\qquad |\Im(\alpha-\alpha')|\le \delta.
\]
Scalars are stored in a separate search tree keyed by their floating-point value modulo this tolerance. The implementation also adopts a small modification of the LIMDD normalization rules, described as analogous to a known modification for QMDDs, to reduce numerical-error accumulation without breaking canonicity.

The circuit-simulation workflow follows the DD paradigm closely. The simulator starts from the all-zero state as a minimal Pauli-LIMDD. For each gate, it performs structured matrix–vector multiplication directly on the diagram, and every newly created node is immediately normalized by the linear-time transformations, passed through the PauliLim high-determinism routine, and looked up in the unique table for reuse or insertion. The paper attributes much of the practical speedup to the fact that realistic compressed diagrams often trigger the \(O(n^2)\) single-child path rather than the full \(O(n^3)\) case.

## 5. Benchmarks, comparative performance, and the role of full canonicity

The reported evaluation compares QolDDer against three tools: MQT-LIMDD, described as an earlier Pauli-LIMDD implementation built on top of the QMDD simulator MQT-DDSIM and implementing canonicity only partially; LimTDD, described as a generalized LIMDD implementation allowing more general XP-LIMs but deliberately without canonicity; and MQT-DDSIM itself, a mature QMDD-based simulator [2606.24789].

Two benchmark families are used. The first consists of random Clifford circuits, labeled “random-clifford,” for \(n=10,\dots,30\) qubits, each containing \(100n\) gates drawn uniformly from \(\{H, P(\pi/2), \mathrm{CX}\}\), with 10 instances per size. The second is MQTBench, described as a public benchmark suite covering arithmetic, oracle, QFT-type, and related circuits. Experiments run on an AMD Ryzen 7 9800X3D CPU with 64 GB RAM, subject to a 10-minute timeout and a 16 GB memory limit.

A central empirical finding concerns the effect of high determinism itself. The paper compares QolDDer with high determinism enabled against a variant using only semi-reduced nodes. On the random Clifford benchmarks, both runtime and final node count fall significantly below the diagonal \(x=y\) line on log–log plots when full canonicity is used. The reported interpretation is that canonical Pauli-LIMDDs both run markedly faster and use significantly fewer nodes, often by factors approaching or exceeding an order of magnitude. The paper further notes that the plots appear roughly linear or slightly sublinear in log–log space, which suggests that enforcing full canonicity yields at least polynomial, and sometimes near-linear, gains as circuits grow.

This evidence is used to support a specific corrective point: the proven exponential advantage of Pauli-LIMDDs does not automatically appear in practice unless the representation is actually canonical and minimal. QolDDer is presented precisely as the implementation in which that theoretical advantage becomes observable. On random Clifford circuits, the paper states that QolDDer realizes the theoretically proven exponential advantage of Pauli-LIMDDs over QMDDs, maintaining compact diagrams where QMDD-based MQT-DDSIM shows exponential growth in node count and runtime. Relative to MQT-LIMDD and LimTDD, QolDDer is reported to be significantly faster on such circuits, often by about an order of magnitude on medium- to large-size instances, with the explanation that partial or absent canonicity allows unnecessary node growth.

On the more heterogeneous MQTBench suite, QolDDer often outperforms the LIMDD-based comparison tools. The paper also notes that it is not always the absolute fastest simulator for every circuit type, but argues that canonical Pauli-LIMDDs are competitive with mature QMDD code and dramatically better in their intended operating regimes, especially Clifford and certain structured Clifford+\(T\) cases.

## 6. Guarantees, limitations, and broader significance

The implementation comes with three explicit classes of guarantees. First, correctness: the simulator output is validated by comparing vectorized states against MQT-DDSIM and LimTDD for all MQTBench circuits up to 10 qubits, and partially up to 20 qubits, with matching amplitudes up to numerical precision. Second, canonicity and minimality: because reduced Pauli-LIMDDs are unique modulo Pauli-LIM equivalence, QolDDer’s diagrams have the minimal number of nodes among Pauli-LIMDDs representing the same state. Third, complexity: high-determinism minimization and stabilizer finding are at most \(O(n^3)\) per node, while the dominant routines become \(O(n^2)\) in the single-child case [2606.24789].

The regimes in which QolDDer should excel are stated explicitly. These include Clifford or near-Clifford circuits, circuits with strong Pauli symmetry, and families where many states differ only by local Pauli operations, such as W-state preparation circuits and certain entangled resource states. Another favorable structural condition is the frequent presence of single-child nodes, because the improved \(O(n^2)\) path is then repeatedly exercised. In these settings, the cited work states that QolDDer can be exponentially faster than QMDDs and other data-structure-based simulators, while also outperforming prior LIMDD prototypes due to cheaper canonicalization.

The limitations are equally clear. For nodes with two distinct children and large stabilizer sets, the worst-case \(O(n^3)\) cost remains. The method is tailored to Pauli-LIMs, so circuits that require more general non-Pauli local maps may be better served by other DD variants such as XP-LIM-based approaches. As with all DD-based methods, some circuit families still generate exponentially large compressed structures, in which case QolDDer also incurs exponential time and memory usage. Numerical limitations remain possible in extremely deep circuits or adversarial uses of non-Clifford phases, despite the tolerance-based equality mechanism.

The broader significance attributed to QolDDer is that LIM-based decision diagrams need not remain a purely theoretical compression device. The work is presented as showing that LIMDDs are implementable in a fully canonical and efficient manner, and that the theoretical exponential advantages of Pauli-LIMDDs can be realized in practice. The paper further points to broader linear-algebra applications, to generalized LIMDDs beyond the Pauli setting, to the possibility of improving the two-child complexity bound, to hybrid simulators that switch representations across circuit segments, and to uses in design and verification tasks such as circuit equivalence checking, state-pattern recognition, and reasoning about stabilizer codes. A plausible implication is that QolDDer is significant not only as a simulator, but also as a concrete algorithmic foundation for canonical LIM-based representations in quantum and other linear-algebraic computation.

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