54-Qubit MPS RCS

6×9 grid  ·  Depth 6  ·  MPS(χ=16)  ·  Tier 2 limit (N 21–54, d≤6)

What this benchmark tests

This is the Tier 2 maximum: 54 qubits at depth 6 using the KLT MPS engine. At depth 6, the entanglement entropy per qubit is 0.960 bits — approaching saturation — which places this circuit firmly in the regime where MPS requires approximation. The truncation error of 0.449 reflects controlled bond-dimension compression across 6 entangling layers.

The circuit uses a 6×9 nearest-neighbour grid with alternating horizontal and vertical CX layers (Sycamore-style topology), interleaved with random RZ/RX rotations on all qubits. 2,048 distinct bitstring outcomes were produced from 2,048 shots — confirming the distribution is highly spread across the full Hilbert space.

Result summary

Reproduce this result

Install the Qumulator SDK and run the following. Use mode='tensor' with bond_dim=16 to invoke the KLT MPS engine used in this benchmark.

pip install qumulator

import os, time, math, random
from qumulator import QumulatorClient

client = QumulatorClient(
    api_url=os.environ["QUMULATOR_API_URL"],
    api_key=os.environ["QUMULATOR_API_KEY"],
)

# Tier 2 max: 54-qubit depth-6 RCS on a 6x9 nearest-neighbour grid
N, ROWS, COLS, DEPTH = 54, 6, 9, 6
rng = random.Random(2)

eng = client.circuit.engine(n_qubits=N, mode='tensor', bond_dim=16)

h_even = [(r*COLS+c, r*COLS+c+1) for r in range(ROWS) for c in range(0, COLS-1, 2)]
h_odd  = [(r*COLS+c, r*COLS+c+1) for r in range(ROWS) for c in range(1, COLS-1, 2)]
v_even = [(r*COLS+c, (r+1)*COLS+c) for r in range(0, ROWS-1, 2) for c in range(COLS)]
v_odd  = [(r*COLS+c, (r+1)*COLS+c) for r in range(1, ROWS-1, 2) for c in range(COLS)]
layers = [h_even, v_even, h_odd, v_odd]

for d in range(DEPTH):
    for q in range(N):
        eng.apply('rz', q, params=[rng.uniform(0, 2 * math.pi)])
        eng.apply('rx', q, params=[rng.uniform(0, 2 * math.pi)])
    for q0, q1 in layers[d % 4]:
        eng.apply('cx', [q0, q1])

t0 = time.time()
result = eng.run(shots=2048, seed=2, return_entropy_map=True)
elapsed = time.time() - t0

print(f"Elapsed       : {elapsed:.1f}s")
print(f"Trunc error   : {result.trunc_error:.4f}")
print(f"Mean S        : {sum(result.entropy_map)/N:.3f} bits/qubit")
print(f"Distinct      : {len(result.counts)} / {result.shots}")

MPS at depth 6: approximation in action

At depth 6, the entanglement entropy (0.960 bits/qubit) exceeds what bond dimension χ=16 can represent exactly — log₂(16) = 4 bits per bond. The MPS engine compresses bond matrices using SVD truncation, discarding singular values below the threshold. The cumulative truncation error of 0.449 is the sum of all discarded singular values across the full simulation — a measure of how much information was approximated away.

Despite this approximation, the output distribution is well-spread: all 2,048 shots produced distinct bitstrings, indicating the circuit is generating near-uniform random sampling across 2⁵⁴ possible outcomes — consistent with a highly scrambled quantum state.