# Scalable Unitary State-Encoding for Generic Large Data

Quantum.world

> Delivers deterministic amplitude-encoding circuits with low two-qubit cost and tensor-network construction beyond classical memory, giving protocol builders a scalable state-preparation route.

**arXiv**: 2611.09760

**Published**: 2026-11-06

**Authors**: Vittorio Pagni, Peter K. Schuhmacher, Michael Felderer, Michael Epping, Kevin Lively

## AI summary

## Overview

**Research area:** Quantum computing, specifically quantum state preparation (amplitude encoding of classical data into quantum states) and quantum circuit compilation.

**Technical level:** Advanced. The paper assumes familiarity with quantum circuits, multi-controlled rotation gates, the Walsh–Hadamard transform and tensor networks. The authors state that the main body is intended as an accessible overview, with detailed derivations deferred to the Supplemental Material.

**Scope (one sentence):** The paper introduces two complementary algorithms, plus a hybrid of the two, that simplify fully controlled multiplexer circuits in state-preparation ladders into one- and two-qubit gates, and benchmarks their circuit depth against the Qiskit state-preparation method and on IQM hardware.

## What This Paper Is About

Many quantum algorithms only deliver their promised speedup if classical data can be loaded into a quantum state efficiently — if preparing the input state costs as much as, or more than, the algorithm saves, the advantage disappears before the computation starts. Existing generic (data-agnostic) state-preparation methods based on fully controlled multiplexers have formal depth guarantees but are impractical: they require computing and storing exponentially many rotation angles and offer no efficient way to find and remove redundant multi-controlled gates. This paper provides scalable, deterministic amplitude-encoding methods that reduce gate depth substantially while keeping encoding fidelity under control, and that can operate on data too large to hold in classical memory by using tensor-network representations.

## Key Contributions

1. **Binary-Tree Boolean Encoder (BT-BE):** A method that performs a finite-precision binary decomposition of continuous rotation angles into fixed-angle Boolean masks, then formally maps the elimination of redundant gate controls onto a Boolean logic minimization problem — specifically the Disjoint Sum of Products simplification problem, which the authors note is NP-hard. The resulting multi-controlled rotations are synthesized into an elementary gate basis using the KG24 method.
2. **Binary-Tree Walsh–Hadamard Transform (BT-WHT):** A second, complementary method that uses a single ancilla qubit to convert multi-controlled rotation gates into a sequence of one- and two-qubit operations, exploiting sparsity in the Walsh–Hadamard spectrum of the gate angles. It addresses only the most significant spectral coefficients rather than all 2^l angles.
3. **Tensor-train scalability:** The full BT-WHT pipeline is formulated to operate directly on data in Tensor Train (Matrix Product State) representation, including via Tensor Cross Interpolation, reducing memory requirements from O(2^l) to O(2lχ²) for multiplexer angle vectors controlling l qubits with Tensor Train bond dimension χ. This allows encoding of arbitrary queryable functions or data sets that cannot be held densely in classical memory.
4. **BT-Hybrid and empirical characterization:** A hybrid scheme that switches to the Tensor Train route once the layer index l exceeds a chosen threshold, benchmarked across a broad range of function classes with total circuit depth characterized in an all-to-all connectivity graph as a function of system size and target fidelity.

## Main Findings

- **Depth reduction versus Qiskit:** Hybridizing the two methods gives up to orders of magnitude improvement in circuit depth at equivalent state fidelity compared with the default state-preparation method in the Qiskit package.
- **Deterministic and measurement-free:** The approaches require no amplitude amplification and no mid-circuit measurement, and are described as deterministic and scalable.
- **Truncation gives controlled error:** Discarding binary-tree subtrees whose conditional probability weight is δ and renormalizing the remaining state produces a squared overlap of 1 − δ with the original state, giving a tunable trade-off between circuit depth and encoding fidelity.
- **Boolean simplification is NP-hard:** The gate-control elimination step is shown to be equivalent to Disjoint Sum of Products Boolean simplification, meaning the simplification subproblem is formally hard in general, which motivates the heuristic and structured approaches used.
- **Approximation error of the finite basis:** The binary angle decomposition with basis angles a_i = 2π/2^i has a per-angle truncation error of order O(π/2^L), and one multiplexer with 2^l arbitrary angles is replaced by at most L multiplexers with fixed angles.
- **Tensor Train memory scaling:** Tensor Train storage requires N_TT = Σ_q 2χ_{q−1}χ_q ≤ 2nχ² coefficients instead of 2^n complex coefficients for a dense vector.
- **Hardware demonstration:** The encoder was demonstrated on IQM hardware with square lattice connectivity, and the authors report excellent fidelity even with minimal noise mitigation. The specific fidelity values, qubit counts and benchmark instance sizes are not reported in the available text.

## Methodology in Plain English

The starting point is a standard way of building a quantum state: arrange the amplitudes in a binary tree, where each node stores a rotation angle that splits probability between the "0" branch and the "1" branch. Each level of the tree corresponds to one layer of a "multiplexer ladder" circuit — a stack of fully controlled rotations, with 2^l angles at layer l, encoding the magnitudes (via R_y rotations) and then the phases (via R_z rotations). A generic n-qubit state has 2(2^n − 1) free real parameters, matching this parametrization.

Two practical problems arise with this construction. First, the tree has exponentially many nodes. Second, even if the angles are known, each layer naively needs 2^l multi-controlled gates.

The authors attack the first problem by pruning: if an angle is (numerically) 0 or π/2, one entire subtree contains only zero amplitudes and can be dropped, and the resulting state has squared overlap 1 − δ with the target. Pruning near the top of the tree gives exponential compression. When the data is too large to store densely, the angles at deeper layers are never enumerated at all; instead they are computed on demand by querying the amplitude function and fitting a Tensor Train with Tensor Cross Interpolation.

The second problem is attacked with two interchangeable simplifiers for a given angle layer. BT-BE writes each continuous angle as a sum of a few fixed basis angles (negative powers of two times 2π), which turns each layer into a small number of fixed-angle multiplexers. Because rotations about the same axis commute, gates with identical fixed angles can be grouped, and grouping control strings into Boolean subcubes removes redundant controls — exactly the classical logic-minimization problem. BT-WHT instead transforms the vector of angles for a layer into the Walsh–Hadamard basis, keeps only coefficients above a threshold, orders the retained coefficients by Hamming weight to keep the "path" between binary addresses short, and assigns each one a short sequence of one- and two-qubit gates using a single ancilla. Because the Walsh–Hadamard transform acts independently on each Tensor Train core, it can be applied without ever materializing the dense angle vector or enlarging the bond dimension.

The hybrid picks the cheaper route per layer: dense Boolean/Walsh simplification for shallow layers up to a cutoff l_max, and Tensor Train processing beyond it.

## Why This Matters

Encoding cost is a first-order obstacle to end-to-end quantum advantage: the paper argues that a nominal advantage in algorithms such as Harrow–Hassidim–Lloyd and the quantum machine learning methods built on it is already lost if preparing the input state |b⟩ scales as O(N) or polynomially in the N elements. Lower-depth, deterministic encoding with bounded fidelity error is therefore a prerequisite for useful quantum computation, not an optimization detail. The work shortens the time horizon to "robust quantum utility" by making applications executable on current and near-term hardware that would otherwise decohere before the first calculation step.

Real-world applications implied by the paper:

- **Quantum linear algebra and quantum machine learning:** algorithms built on HHL and its refinements, which require efficient loading of a classical right-hand-side vector.
- **Quantum many-body physics and quantum chemistry:** domains the authors name as settings where low-bond-dimension Tensor Train representations are naturally available.
- **Partial differential equation simulation:** also named as a setting where the Tensor Train requirement is not a practical limitation.
- **Near-term hardware demonstrations:** the IQM square-lattice experiment shows the method runs on connectivity-limited devices with minimal noise mitigation, relevant to applications that need shallow circuits on today's machines.

**Industry relevance:** The direct comparison point is Qiskit's default state-preparation method, so the results bear on quantum compiler and SDK toolchains. The ability to encode queryable functions rather than only explicit dense vectors matters for enterprise and scientific workloads where the data-generating function is available but the full array is not. Hardware vendors benefit because reduced two-qubit gate counts and depths translate directly into usable fidelity on noisy devices.

## Future Directions

- **Generalizing beyond Tensor Trains:** The authors note that the tensor-network choice is not fundamental — other networks such as tensor trees, which have better bond-dimension scaling for certain entangled states, also admit Tensor Cross Interpolation for angle construction and are a natural extension.
- **Basis optimization:** Section III.1 notes that the fixed-angle basis (2π/2^i) can be optimized to jointly minimize approximation error and final circuit depth; the systematic choice of that basis remains an open design question.
- **Data with unfavorable structure:** Efficiency depends on the angle tensor admitting an accurate low-bond-dimension representation; for unstructured data the required number of samples and bond dimensions may still become large, leaving the boundary of applicability to be mapped.
- **Broader hardware validation:** The hardware demonstration is on a single square-lattice device; scaling behavior under realistic noise, limited connectivity and routing overhead across other architectures is the obvious next test.

## Target Audience

Quantum algorithm and compiler researchers who need practical, low-depth state preparation; quantum software engineers integrating encoding into SDKs and transpilers; and applied scientists in quantum chemistry, many-body physics or PDE simulation whose data admits low-rank tensor-network structure. Readers without a background in multi-controlled gates, the Walsh–Hadamard transform and Matrix Product States will find the main text readable as an overview but will need the Supplemental Material for the derivations.

## Authors’ abstract

Efficient encoding of data into quantum states remains a fundamental bottleneck in many quantum computing protocols, which would otherwise offer advantages over their classical counterparts. Here, we introduce deterministic and scalable amplitude-encoding methods with low two-qubit gate costs and tunable trade-offs between circuit depth and encoding fidelity. Our approaches require no amplitude amplification or mid-circuit measurement and are capable of encoding arbitrary…

[The full abstract on arXiv](https://arxiv.org/abs/2611.09760)

[Read the original paper](https://arxiv.org/abs/2611.09760)

---

Canonical: https://quantum.world/paper/scalable-unitary-state-encoding-for-generic-large-data-2611.09760
