We introduce a coefficient-decoupled matrix product operator (MPO) representation for Pauli-sum operators that separates reusable symbolic operator support from a tunable coefficient bridge across a fixed bipartition. This representation provides a direct interface to linear-combination-of-unitaries (LCU) circuits: the symbolic left/right dictionaries define a static \textsc{Select} oracle that is compiled once, while coefficient updates modify only a dynamic \textsc{Prep} oracle. As a proof of concept, we construct compact state-adapted Pauli pools by sampling Pauli strings from a pretrained matrix product state (MPS), pruning them to a fixed symbolic pool, optimizing only their coefficients, and transferring the resulting weights directly to the LCU interface. The resulting workflow provides a reusable classical-to-quantum compilation strategy in which the symbolic operator structure is compiled once, and subsequent updates are confined to a low-dimensional coefficient object.
We introduce a coefficient-decoupled matrix product operator (MPO) representation for Pauli-sum operators that separates reusable symbolic operator support from a tunable coefficient bridge across a fixed bipartition. This representation provides a direct interface to linear-combination-of-unitaries (LCU) circuits: the symbolic left/right dictionaries define a static \textsc{Select} oracle that is compiled once, while coefficient updates modify only a dynamic \textsc{Prep} oracle. As a proof of concept, we construct compact state-adapted Pauli pools by sampling Pauli strings from a pretrained matrix product state (MPS), pruning them to a fixed symbolic pool, optimizing only their coefficients, and transferring the resulting weights directly to the LCU interface. The resulting workflow provides a reusable classical-to-quantum compilation strategy in which the symbolic operator structure is compiled once, and subsequent updates are confined to a low-dimensional coefficient object.
We develop a block-encoding compiler that treats matrix product operators as compressed, virtual-path linear combination of unitaries programs. The compiler constructs conditional PREP and local SELECT stages directly from a parent matrix product operator, establishing tensor networks as structured quantum intermediate representations that can be efficiently compiled to block-encoded circuits. We apply the construction to real-time evolution in the Heisenberg chain and two perturbed Heisenberg-family models. Across the regimes studied, the compressed, approximately unitary propagator MPOs retain mild bond dimension and LCU normalization. Relative to an LCU that explicitly lists the O(NK) Pauli-product branches of an order-K truncated Taylor polynomial, our virtual-transition implementation replaces combinatorial branch enumeration by a circuit complexity scaling as O(αMPONχ2), approaching O(Nχ2) when αMPO remains mild. We numerically characterize how truncation order, bond-dimension budget, and system size affect approximation error, normalization, and compiler cost. These results demonstrate how classically compressed tensor-network representations can serve as quantum compiler intermediate representations for block encoding and opens new avenues to accelerate quantum algorithms.
Matrix product operators (MPOs) are a standard representation for structured operators in tensor-network simulations and quantum computing applications. However, converting symbolic descriptions of Hamiltonians and cost functions into MPO representations often requires substantial manual implementation, making the process error-prone and difficult to reproduce. This paper presents autotn, an open-source Python software tool that converts symbolic operator rules into MPO representations. Users define local operators and interaction rules in a high-level format, and the software generates the corresponding MPO along with validation utilities. In doing so, the software follows an automata-inspired approach that identifies repeated patterns in the symbolic description of the operator and reuses them to build a compact tensor-network representation, avoiding the need to construct each tensor by hand. The current implementation of autotn supports both diagonal operators, commonly encountered in combinatorial optimization problems, and general local matrix operators used in quantum many-body physics. The software is demonstrated on Max-Cut cost operators, long-range XX+YY+Z spin Hamiltonians, and quantum clock models. By providing a reproducible workflow from symbolic model specification to validated MPO construction, autotn reduces the engineering effort required to develop, verify, and compare MPO constructions.
Preconditioning is a fundamental technique for accelerating classical linear system solvers, and understanding when its benefits persist in quantum linear system (QLS) solvers is important for assessing the practical resource requirements of quantum linear algebra. In QLS algorithms, however, the potential advantage of preconditioning may be offset by the normalization overhead incurred by composing separate block-encodings of the system matrix and the preconditioner, as observed in recent work. This limitation leaves open whether additional algebraic structure can make preconditioning effective in quantum access models. Motivated by this question, we show that Pauli-structured representations of both the system matrix and the preconditioner allow the preconditioned operator to be accessed through regrouped Pauli expansions. In this setting, algebraic regrouping of Pauli products can reduce the Pauli coefficient weight of the preconditioned operator, thereby altering the normalization parameters relevant to quantum algorithms. We derive explicit size and coefficient-weight bounds for the regrouped Pauli representations, and we trace their consequences for both direct block-encoding constructions and randomized Pauli linear system solvers. These results identify when Pauli-structured preconditioning can reduce the effective complexity parameters of QLS algorithms, rather than merely improving the classical condition number. Numerical experiments on a finite-dimensional synthetic benchmark show reductions in norm-aware direct block-encoding diagnostics and in the randomized QLS per-sample depth proxy.
Abstract Analysis of quantum processes, especially in the context of noise, errors, and decoherence is essential for the improvement of quantum devices. An intuitive representation of those processes modeled by quantum channels are Pauli transfer matrices. They display the action of a linear map in the n-qubit Pauli basis in a way, that is more intuitive, since Pauli strings are more tangible objects than the standard basis matrices. We set out to investigate classical algorithms that convert the various representations into Pauli transfer matrices. We propose new algorithms that make explicit use of the tensor product structure of the Pauli basis. They convert a quantum channel in a given representation (Chi or process matrix, Choi matrix, superoperator, or Kraus operators) to the corresponding Pauli transfer matrix. Moreover, the underlying principle can also be used to calculate the Pauli transfer matrix of other linear operations over n-qubit matrices such as left-, right-, and sandwich multiplication as well as forming the (anti-)commutator with a given operator. Finally, we investigate the runtime of these algorithms, derive their asymptotic scaling and demonstrate improved performance using instances with up to seven qubits.
Dynamic circuits use real-time outcomes of mid-circuit measurements, processed by a classical controller, to adapt subsequent operations during circuit execution. This additional flexibility over static circuits comes at a price. Mid-circuit measurements are typically slower and noisier than unitary gates. Furthermore, classical feedforward requires exchanging information between the quantum processor (QPU) and the classical controller, introducing latency that erodes the practical performance of dynamic circuits. We propose a compile-time optimization framework that reduces the use of classical controls in dynamic circuits while preserving their semantics. At its core, the framework uses a static analysis that symbolically executes the circuit by propagating classical information alongside the quantum state. By combining this classical-quantum information with the Probabilistic Circuit Model extended with probabilistic controls that emulate classical feedforward, we obtain an intermediate probabilistic representation of the dynamic circuit. In this representation, mid-circuit measurements and classically controlled operations can be removed or rewritten as purely unitary operations and probabilistic components. Compared to existing compile-time optimizations that target only mid-circuit measurements, our method applies to a broader class of dynamic circuits expressible in modern quantum programming languages. We evaluated our framework on randomly generated dynamic circuits, achieving about 50% classical feedforward reduction and even higher reductions in favorable settings.
We present a novel framework for Linear Combination of Unitaries (LCU)-style decomposition tailored to structured sparse matrices, which frequently arise in the numerical solution of partial differential equations (PDEs). While LCU is a foundational primitive in both variational and fault-tolerant quantum algorithms, conventional approaches based on the Pauli basis can require a number of terms that scales quadratically with matrix size. We introduce the Sigma basis, a compact set of simple, non-unitary operators that can better capture sparsity and structure, enabling decompositions with only polylogarithmic scaling in the number of terms. We develop both numerical and semi-analytical methods for computing Sigma basis decompositions of arbitrary matrices. Given this new basis is comprised of non-unitary operators, we leverage the concept of unitary completion to design efficient quantum circuits for evaluating observables in variational quantum algorithms and for constructing block encodings in fault-tolerant quantum algorithms. We compare our method to related techniques like unitary dilation, and demonstrate its effectiveness through several PDE examples, showing exponential improvements in decomposition size while retaining circuit efficiency.