Approximate State Preparation using MPS

Prepare a target state on hardware by sequentially encoding its matrix-product-state (MPS) representation into a shallow circuit.

The problem it solves

Preparing an arbitrary n-qubit state is exponentially hard. A generic n-qubit state has 2ⁿ complex amplitudes, and exact preparation of such a state generally needs an exponential number of parameters and gates — and the depth, too, grows quickly with system size. For many qubits that is hopeless. But the states we actually care about are rarely generic: the ground states of local, gapped one-dimensional Hamiltonians typically obey an area law — they carry low entanglement and can be efficiently approximated by a small-bond-dimension MPS — and low-entanglement states in general are highly compressible. MPS state preparation is how you cash in that compressibility.

Intuition — entanglement is the real cost

What truly makes state preparation expensive is not the raw count of amplitudes but the entanglement. A state whose entanglement across every left–right cut stays bounded can be written as a matrix product state: a chain of tensors, one per site, linked by bond indices. The dimension χ of those bonds — the bond dimension — measures exactly how much entanglement is carried across each cut. Low entanglement means small χ, and small χ means a compact description.

The idea — bond dimension and sequential encoding

A low-entanglement state has a compact MPS with small bond dimension. Each tensor becomes a few-qubit unitary, so in sequential preparation the number of tensors processed in sequence grows linearly with the system size N — one local unitary per site.

The roles of N and χ are distinct: N sets the number of tensors processed in sequence; χ sets the bond/ancilla dimension (needing roughly ⌈log₂ χ⌉ ancilla qubits). When the isometries / local unitaries are compiled into hardware gates, the local gate count and depth also grow with χ — so χ affects fidelity, ancilla width, and circuit depth together. As long as the target state stays low-entanglement (χ small), the overall cost stays modest — an enormous saving over the exponential cost of generic preparation.

Fidelity versus depth

Truncating the MPS to a finite bond dimension is an approximation: it keeps the χ largest Schmidt coefficients across each cut and discards the rest. The discarded weight at each Schmidt truncation gives the local truncation error of that cut; after many truncations the global fidelity loss must be estimated or bounded cumulatively and is generally not equal to any single discarded weight. A larger χ keeps more of the state — higher overlap with the target — but makes each local unitary wider (and the compilation deeper); a smaller χ gives a shallower circuit at the price of a lower fidelity. The practical recipe is to pick the smallest χ that still meets your overlap target.

What it is — and isn't — good for

• Low-entanglement states only. The method is efficient precisely when χ is small. Volume-law or highly entangled states need a χ that grows exponentially with system size, which erases the advantage entirely.
• It is approximate, not exact. Unless the target genuinely has bounded bond dimension, you are preparing a truncated surrogate, not the exact state.
• It suits chain-like structure. The MPS form mirrors a 1-D arrangement of sites; it is the natural fit for one-dimensional systems and for states with limited long-range entanglement.
• It is a building block. An approximate MPS state often serves as a high-quality starting point for a subsequent variational or evolution step, rather than an end in itself.

Seeing it in code — sequential encoding

Read the snippet against the theory. qalgora.tensor.to_mps(target_state, max_bond_dim=2) compresses the target into an MPS, capping the bond dimension at χ = 2 — this is the fidelity/depth knob. With χ = 2 each tensor maps to a two-qubit unitary, so the loop walks site by site and each qalgora.apply_unitary(gate, q[i], q[i + 1]) applies one local two-qubit unitary synthesized from one MPS tensor — the one-unitary-per-site sequential preparation described above. This snippet is a simplified illustration: a larger χ needs wider local unitaries (more ancilla/bond qubits per step), so the two-qubit form here corresponds specifically to χ = 2.

Sequential encoding

import qalgora

# compress the target into an MPS, then synthesize gates tensor-by-tensor
# (max_bond_dim=2 is a simplified illustration: chi=2 maps to 2-qubit unitaries)
mps = qalgora.tensor.to_mps(target_state, max_bond_dim=2)

@qalgora.kernel
def prepare(mps_gates: list[list[float]]):
    q = qalgora.qvector(len(mps_gates) + 1)
    for i, gate in enumerate(mps_gates):
        qalgora.apply_unitary(gate, q[i], q[i + 1])   # local 2-qubit unitary