Tensor networks (TNs) give explicit classical descriptions of structured finite linear maps, while block-encodings (BEs) are the standard quantum access model for such maps. We establish TNs as a universal data interface for quantum algorithms: any explicitly specified TN for an arbitrary finite linear map compiles directly to an explicit qubit BE, with no penalty on the selected-block round trip under faithful compression. Along a chosen sweep, the compiler handles local non-unitarity by exact local dilations and aggregates the resulting post-selection conditions online using logarithmically many additional flag qubits. The chosen sweep incurs three exact, sweep-dependent costs (the accumulated scale, the frontier memory, and the number of genuinely dilated local steps), which the main theorems are stated in terms of. In the bounded-local explicit arithmetic model, this yields linear-time compilation to linear-size circuits with constant-size local gadgets, and hence a constant-factor size correspondence between bounded-local TNs and bounded-local BEs. The same construction gives a selected-block round trip BE->TN->BE: a BE canonically yields a TN for its selected block rather than for an arbitrary unitary extension, which can then be compressed or approximated classically before recompilation. Faithful Schmidt-rank compression transfers monotonically (the scale cost and frontier memory cannot increase, with operator error bounded by the discarded weight), while arbitrary restructuring admits no general scale guarantee, a limitation we show is unavoidable. As consequences and limits of this scale accounting, we characterize exact scale optimality, show that bridge-hourglass forests admit scale-optimal sweeps after exact recursive local bond compression, and prove that certifying unrestricted exact scale optimality is already hard for diagonal MPOs on a path unless P=NP.
Tensor networks (TNs) give explicit classical descriptions of structured finite linear maps, while block-encodings (BEs) are the standard quantum access model for such maps. We establish TNs as a universal data interface for quantum algorithms: any explicitly specified TN for an arbitrary finite linear map compiles directly to an explicit qubit BE, with no penalty on the selected-block round trip under faithful compression. Along a chosen sweep, the compiler handles local non-unitarity by exact local dilations and aggregates the resulting post-selection conditions online using logarithmically many additional flag qubits. The chosen sweep incurs three exact, sweep-dependent costs (the accumulated scale, the frontier memory, and the number of genuinely dilated local steps), which the main theorems are stated in terms of. In the bounded-local explicit arithmetic model, this yields linear-time compilation to linear-size circuits with constant-size local gadgets, and hence a constant-factor size correspondence between bounded-local TNs and bounded-local BEs. The same construction gives a selected-block round trip BE->TN->BE: a BE canonically yields a TN for its selected block rather than for an arbitrary unitary extension, which can then be compressed or approximated classically before recompilation. Faithful Schmidt-rank compression transfers monotonically (the scale cost and frontier memory cannot increase, with operator error bounded by the discarded weight), while arbitrary restructuring admits no general scale guarantee, a limitation we show is unavoidable. As consequences and limits of this scale accounting, we characterize exact scale optimality, show that bridge-hourglass forests admit scale-optimal sweeps after exact recursive local bond compression, and prove that certifying unrestricted exact scale optimality is already hard for diagonal MPOs on a path unless P=NP.
Encoding classical data into quantum states is a central bottleneck in quantum machine learning: many widely used encodings are circuit-inefficient, requiring deep circuits and substantial quantum resources, which limits scalability on quantum hardware. In this work, we propose tensor network-based quantum data encoding (TNQE), a circuit-efficient framework built on structured unitary tensor network (TN) representations. TNQE first represents each classical input via a TN decomposition and then compiles the resulting tensor cores into an encoding circuit through two complementary core-to-circuit strategies. To make this compilation trainable while respecting the unitary nature of quantum operations, we introduce a unitary-aware constraint that parameterizes TN cores as learnable block unitaries, enabling them to be directly optimized and directly encoded as quantum operators. The proposed TNQE framework enables explicit control over circuit depth and qubit resources, allowing the construction of shallow, resource-efficient circuits. Across a range of benchmarks, TNQE achieves encoding circuits as shallow as 0.04× the depth of amplitude encoding, while naturally scaling to high-resolution images (256×256) and demonstrating practical feasibility on real quantum hardware.
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.
We determine the non-Clifford T-gate cost of constructing block encodings of structured fermionic and spin Hamiltonians in a unitary Clifford+T model, when arbitrarily many clean ancillas and unrestricted block-encoding subnormalization are allowed, but without mid-circuit measurements or classical feed-forward. Our main technical tool is an ancilla-compression theorem: any block encoding of an n-qubit operator with a clean ancillas and at most sT gates can be compressed to use at most min{a,n+2s} ancillas, without increasing the absolute error or T-count. For general second-quantized Hamiltonians with bounded one- and two-body coefficients, at operator-norm block-encoding error ε, a volume-covering argument combined with circuit counting gives the worst-case lower bound Ω(n2log(n4/ε)), matching the existing upper bound at fixed precision. For the bond-dependent Kitaev honeycomb family on n spins, we obtain independent lower bounds Ω(n) from stabilizer nullity and Ω(log(1/ε)) from one-qubit state preparation, established using different Hamiltonian instances. Together with an explicit LCU construction, they give the tight worst-case scaling Θ(n+log(1/ε)). As an application, we evaluate the T-count of a Hamiltonian simulation circuit based on quantum singular value transformation, with each block-encoding query compiled separately. When phase synthesis and controlled queries add at most constant-factor overhead, the simulation T-count scales as the query count times the optimal T-count per query.
Abstract Tensor networks (TNs) are a family of computational methods built on graph-structured factorizations of large tensors, which have long represented state-of-the-art methods for the approximate simulation of complex quantum systems on classical computers. The rapid pace of recent advancements in numerical computation, notably the rise of GPU and TPU hardware accelerators, have allowed TN algorithms to scale to even larger quantum simulation problems, and to be employed more broadly for solving machine learning tasks. The ‘quantum-inspired’ nature of TNs permits them to be mapped to parametrized quantum circuits (PQCs), a fact which has inspired recent proposals for enhancing the performance of TN algorithms using near-term quantum devices, as well as enabling joint quantum–classical training frameworks that benefit from the distinct strengths of TN and PQC models. However, the success of any such methods depends on efficient and accurate methods for approximating TN states using realistic quantum circuits, which remains an unresolved question. This work compares a range of novel and previously-developed algorithmic protocols for decomposing matrix product states (MPS) of arbitrary bond dimension into low-depth quantum circuits consisting of stacked linear layers of two-qubit unitaries. These protocols are formed from different combinations of a preexisting analytical decomposition method together with constrained optimization of circuit unitaries, with initialization by the former method helping to avoid poor-quality local minima in the latter optimization process. While all of these protocols have efficient classical runtimes, our experimental results reveal one particular protocol employing sequential growth and optimization of the quantum circuit to outperform all others, with even greater benefits in the setting of limited computational resources. Given these promising results, we expect our proposed decomposition protocol to form a useful ingredient within any joint application of TNs and PQCs, further unlocking the rich and complementary benefits of classical and quantum computation.
Efficient methods to access the entanglement of a quantum many-body state, where the complexity generally scales exponentially with the system size N, have long been a concern. Here we propose the Schmidt tensor network state (Schmidt TNS) that efficiently represents the Schmidt decomposition of finite- and even infinite-size quantum states with nontrivial bipartition boundary. The key idea is to represent the Schmidt coefficients (i.e., entanglement spectrum) and transformations in the decomposition to tensor networks (TNs) with linearly scaled complexity versus N. Specifically, the transformations are written as the TNs formed by local unitary tensors, and the Schmidt coefficients are encoded in a positive-definite matrix product state (MPS). Translational invariance can be imposed on the TNs and MPS for the infinite-size cases. The validity of Schmidt TNS is demonstrated by simulating the ground state of the quasi-one-dimensional spin model with geometrical frustration. Our results show that the MPS encoding the Schmidt coefficients is weakly entangled even when the entanglement entropy of the decomposed state is strong. This justifies the efficiency of using MPS to encode the Schmidt coefficients, and promises an exponential speedup on the full-state sampling tasks.
In optimization, one of the well-known classical algorithms is power iterations, which recovers the dominant eigenvector of a diagonalizable matrix. Since numerous optimization problems can be formulated as an eigenvalue/eigenvector search, this algorithm features wide applicability. Operationally, power iterations perform repeated matrix-to-vector multiplications (\texttt{MatVec}) followed by a renormalization step to converge to the dominant eigenvalue/eigenvector. However, classical tensor network realizations can exhibit worst-case exponential growth of tensor ranks with the number of iterations. We propose a quantum realization offering a possible route around this bottleneck. Our method involves casting low-rank representations---MPO for matrices and MPS for vectors---into quantum circuits. Specifically, we recover a unitary approximation by variationally minimizing the Frobenius distance between a target MPO and an MPO ansatz wherein the tensor cores are constrained to unitaries. Such unitary MPOs can be implemented as quantum circuits with ancillary qubits. With appropriate initialization and post-selection on the ancillary space, we realize a single classical iteration. With our proposed methodology, power iterations can be realized entirely on a quantum computer via repeated, static circuit blocks. By exploiting Riemannian optimization and cross-approximation techniques, our methodology becomes instance-agnostic, allowing one to address black-box optimization of functions admitting low-rank tensor network representations within quantum computing. We emphasize that this work establishes the construction and analyzes its reliable operating conditions; it does not demonstrate an end-to-end computational advantage over classical tensor network optimization, which we discuss explicitly.