1,000-Qubit MPS RCS

25×40 grid  ·  Depth 3  ·  MPS(χ=16)  ·  Tier 4 limit (N 106–1000, d≤3)

What this benchmark tests

This is the Tier 4 maximum — and the largest circuit the platform supports: 1,000 qubits at depth 3 using the KLT MPS engine. The Hilbert space of this system has 2¹⁰⁰⁰ ≈ 10³⁰¹ dimensions. There is no classical computer, past or future, that could store even a single amplitude vector for this system. MPS is the only simulation approach that can handle it.

The circuit runs on a 25×40 nearest-neighbour grid. At depth 3, only one layer of entanglement has propagated through the even, vertical, and odd coupling patterns — the resulting entanglement is shallow enough that bond dimension χ=16 represents the state exactly. The truncation error is 0.000: this is a genuinely exact simulation of 1,000 qubits.

Result summary

Reproduce this result

Install the Qumulator SDK and run the following. Use mode='tensor' with bond_dim=16. Note: this circuit has 1,000 qubits and 3 entangling layers — the instruction list is large. The SDK serialises and submits it automatically.

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 4 max: 1000-qubit depth-3 RCS on a 25x40 nearest-neighbour grid
N, ROWS, COLS, DEPTH = 1000, 25, 40, 3
rng = random.Random(4)

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

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

Why 1,000 qubits at depth 3 is exact

In a nearest-neighbour circuit, entanglement can only propagate one bond per layer. After 3 layers with the Sycamore coupling pattern, only the first coupling sublayer (h_even), the first vertical layer (v_even), and the odd horizontal layer (h_odd) have fired. The maximum entanglement entropy at any bond is bounded by:

S ≤ min(d, w) · log₂(χ_gate)

At depth 3 with CX gates (χ_gate = 2), the maximum bond entropy is S ≤ 3 bits — well within χ=16 (which can represent 4 bits per bond exactly). The MPS truncation is therefore never invoked, giving exact zero truncation error.

This is fundamentally different from the Tier 2 and Tier 3 results, where deeper circuits accumulate non-zero truncation error. At Tier 4 depth limits, the constraint is circuit width (qubit count and communication overhead), not entanglement depth.