Compiling Quantum Regular Language States

State preparation compilers for quantum computers typically sit at two extremes: general-purpose routines that treat the target as an opaque amplitude vector, and bespoke constructions for a handful of well-known state families. We ask whether a compiler can instead accept simple, structure-aware specifications while providing predictable resource guarantees. We answer this by designing and implementing a quantum state-preparation compiler for regular language states (RLS): uniform superpositions over bitstrings accepted by a regular description, and their complements. Users describe the target state via (i) a finite set of bitstrings, (ii) a regular expression, or (iii) a deterministic finite automaton (DFA), optionally with a complement flag. By translating the input to a DFA, minimizing it, and mapping it to an optimal matrix product state (MPS), the compiler obtains an intermediate representation (IR) that exposes and compresses hidden structure. The efficient DFA representation and minimization offloads expensive linear algebra computation in exchange of simpler automata manipulations. The combination of the regular-language frontend and this IR gives concise specifications not only for RLS but also for their complements that might otherwise require exponentially large state descriptions. This enables state preparation of an RLS or its complement with the same asymptotic resources and compile time. We outline two hardware-aware backends: SeqRLSP, which yields linear-depth, ancilla-free circuits for linear nearest-neighbor architectures via sequential generation, and TreeRLSP, which achieves logarithmic depth on all-to-all connectivity via a tree tensor network. We prove depth and gate-count bounds scaling with the system size and the state’s maximal Schmidt rank, and we give explicit compile-time bounds that expose the benefit of our approach. We implement and evaluate the pipeline.

💡 Research Summary

The paper introduces a novel quantum state‑preparation compiler that targets a broad yet well‑structured class of states called Regular Language States (RLS). An RLS is defined as the uniform superposition over all N‑bit strings that belong to a regular language, together with its complement (the uniform superposition over strings that do not belong to the language). This definition subsumes many familiar families such as GHZ, W, Dicke, fixed‑parity, and simple prefix/suffix states, while also allowing compact specifications for exponentially large supports via regular expressions, deterministic finite automata (DFA), or explicit string sets.

The compiler pipeline consists of four stages. First, the user supplies a description in one of the three accepted forms; the front‑end converts any input into a DFA. Second, the DFA is minimized using classical automata‑theoretic algorithms (e.g., Hopcroft’s algorithm), which reduces the number of states and therefore the subsequent tensor‑network bond dimension. Third, the minimized DFA is translated into an optimal matrix‑product state (MPS). The correspondence between DFA transitions and MPS tensors is exact: each DFA state becomes a virtual index, and each transition contributes a rank‑3 tensor. This step yields a set of local unitaries {U₁,…,U_k} that, when applied sequentially, generate the target state from the all‑zero register. Finally, a hardware‑aware back‑end maps these unitaries to a concrete quantum circuit.

Two back‑ends are presented. SeqRLSP is designed for linear‑nearest‑neighbour (LNN) architectures. It implements the MPS by scanning from left to right, using only 1‑ and 2‑qubit gates and no ancilla qubits. The resulting circuit depth scales linearly with the number of qubits N and with the maximal Schmidt rank χ of the target state (depth O(N·χ)). TreeRLSP targets all‑to‑all connectivity. It reorganizes the MPS into a binary tree tensor network, allowing parallel application of unitaries. Consequently, depth becomes logarithmic in N (depth O(log N·χ)) while the total gate count remains O(N·χ²). Both back‑ends inherit a resource bound that depends solely on χ, which is at most the number of DFA states after minimization.

The authors prove several theoretical results. Theorem 1 gives a worst‑case compile‑time bound that is polynomial in the size of the input DFA, independent of the exponential Hilbert‑space dimension. Theorem 2 shows that taking the complement of a regular language increases the maximal Schmidt rank by at most one, so the asymptotic quantum cost of preparing a complement state is unchanged. Theorems 3 and 4 provide explicit depth and gate‑count formulas in terms of N and χ for SeqRLSP and TreeRLSP, respectively. These results demonstrate that the compiler offers predictable, provable performance guarantees, a property lacking in existing general‑purpose state‑preparation tools.

Experimental evaluation benchmarks the compiler against three baselines: (i) Qiskit’s generic state‑preparation routine (which scales with 2ᴺ), (ii) Qiskit’s sparse‑state module (which scales with the number of non‑zero amplitudes), and (iii) hand‑crafted specialized circuits for Dicke and W states. Test families include Dicke states, W states, random uniform superpositions over regular languages, and their complements. Across all cases, both SeqRLSP and TreeRLSP achieve dramatically lower circuit depth and gate count, while also reducing compile time by one to two orders of magnitude. Notably, for complement states the compiler avoids the exponential blow‑up that would occur if one enumerated the forbidden strings, confirming the theoretical claim that complements are equally cheap to prepare.

The paper’s contributions can be summarized as follows: (1) a user‑friendly, structure‑aware specification language for quantum states based on regular expressions, DFAs, or explicit string sets; (2) a complete end‑to‑end compiler that bridges formal‑language theory, tensor‑network representations, and quantum circuit synthesis; (3) rigorous resource and compile‑time bounds that depend only on the maximal Schmidt rank χ; (4) a proof that complements incur no asymptotic penalty; and (5) a practical implementation that outperforms existing methods on a wide range of benchmarks.

Future directions suggested include extending the framework to non‑regular languages (e.g., context‑free languages), handling non‑uniform amplitudes (weighted regular languages), integrating error‑mitigation or fault‑tolerant synthesis, and developing interactive, just‑in‑time compilation for dynamic quantum algorithms. By turning regular‑language descriptions into efficient quantum circuits, the work opens a new pathway for high‑level quantum programming that automatically exploits hidden structure, potentially benefiting applications such as data loading, quantum machine learning, and variational algorithms.