20-Qubit Statevector RCS

4×5 grid  ·  Depth 20  ·  Exact statevector  ·  Tier 1 limit (N≤20, d≤20)

What this benchmark tests

This is the Tier 1 maximum: 20 qubits at depth 20, the highest entanglement load the exact statevector engine is permitted to run. At this depth, the quantum state is thoroughly scrambled — all 2²⁰ = 1,048,576 complex amplitudes must be tracked simultaneously with no approximation.

The circuit uses a 4×5 nearest-neighbour grid with alternating horizontal and vertical CX layers (Sycamore-style topology), interleaved with random RZ/RX single-qubit rotations. At depth 20, the entropy per qubit saturates toward its maximum — confirming this is deep in the classically hard regime for MPS simulation.

Result summary

Reproduce this result

Install the Qumulator SDK, set your API credentials, and run the following. Use mode='exact' to invoke the exact statevector engine.

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 1 max: 20-qubit depth-20 RCS on a 4x5 nearest-neighbour grid
N, ROWS, COLS, DEPTH = 20, 4, 5, 20
rng = random.Random(1)

eng = client.circuit.engine(n_qubits=N, mode='exact')

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=1, return_entropy_map=True)
elapsed = time.time() - t0

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

Why statevector is required at depth 20

In a 2D nearest-neighbour circuit, entanglement entropy across any bipartition grows roughly linearly with depth up to saturation. At depth 20, the average per-qubit entropy is 0.937 bits — close to the maximum of 1.0. An MPS with bond dimension χ can represent at most S ≤ log₂χ bits of entanglement per bond. To match depth-20 entropy on this grid, χ would need to exceed 2⁵ = 32 per bond, and accumulated truncation errors compound across all 20 layers — making the MPS result unreliable.

Exact statevector is the correct method here. It tracks all 2²⁰ = 1,048,576 amplitudes exactly, with zero truncation error, at the cost of memory and time that grows exponentially with qubit count. This is why the Tier 1 statevector limit is N≤20.