25×40 grid · Depth 2 · KLT phase Z2 · No exact reference possible · Analytically certified
At 1,000 qubits the Hilbert space contains 21000 ≈ 10301 basis states — a number so vast it exceeds the count of atoms in the observable universe by nearly 230 orders of magnitude. No classical computer can store, let alone compute, the exact quantum state.
Yet for a depth-2 circuit on this 25×40 grid, Qumulator's KLT engine returns a certified TVD bound of less than 0.001 in 22 seconds on a single CPU. This certification requires no reference simulation — it is derived analytically from the circuit's Lyapunov spectrum and entropy profile. At depth 2, the circuit sits deep in the Z2 phase (natural depth τ = 0.011 — barely 1% of the way to scrambling), where the entanglement structure is sparse and provably controllable.
| Qubits | Depth | Phase | τ | dsat | TVD bound | Time |
|---|---|---|---|---|---|---|
| 20 | 20 | Z5 (Haar) | 1.000 | 20 | — (exact SV) | 44.7 s |
| 105 | 2 | Z3→Z4 | 0.300 | 52 | < 0.002 | 3.4 s |
| 1,000 | 2 | Z2 | 0.011 | 180 | < 0.001 | 22 s |
Highlighted row = this benchmark. τ = d / dsat.
The analytical TVD certificate is always returned in result.tvd_bound.
At depth 2 on a 1,000-qubit grid, bond dimension χ = 4 is sufficient — the
KLT preflight step selects this automatically based on the Z2 phase classification.
pip install qumulator-sdk
import os
import numpy as np
from qumulator import QumulatorClient
client = QumulatorClient(
api_url=os.environ["QUMULATOR_API_URL"],
api_key=os.environ["QUMULATOR_API_KEY"],
)
# 25×40 grid, depth 2 — 1,000 qubits
nrows, ncols, depth = 25, 40, 2
N = nrows * ncols # 1,000 qubits
rng = np.random.default_rng(99)
instructions = []
for d in range(depth):
# Single-qubit Haar layer
for q in range(N):
instructions.append({"gate": "ry", "qubits": q,
"params": [rng.uniform(0, np.pi)]})
instructions.append({"gate": "rz", "qubits": q,
"params": [rng.uniform(0, 2*np.pi)]})
# CX entangling layer (horizontal bonds on even columns)
for r in range(nrows):
for c in range(0, ncols - 1, 2):
q0 = r * ncols + c
instructions.append({"gate": "cx", "qubits": [q0, q0 + 1]})
result = client.circuit.run(
n_qubits=N,
instructions=instructions,
mode="klt_mps",
bond_dim=4, # auto-selected for Z2 phase; set explicitly here
shots=2048,
seed=99,
return_entropy_map=True,
)
print(f"KLT phase : {result.klt_phase}") # → Z2
print(f"Mean entropy : {result.mean_entropy:.3f} bits/qubit") # → 0.160
print(f"Certified TVD : < {result.tvd_bound:.4f}") # → < 0.0010
print(f"Natural depth τ : {result.natural_depth:.3f}") # → 0.011
print(f"Saturation depth : {result.saturation_depth}") # → 180
print(f"Bond dimension : {result.bond_dim_used}") # → 4
print(f"Exact ref needed : No — 2^1000 ≈ 10^301 dimensions")
The number 21000 ≈ 10301 dwarfs the estimated number of atoms in the observable universe (1080) by 221 orders of magnitude. Storing a single complex amplitude per basis state at 64-bit precision would require ≈ 10292 GB of memory — more than all storage media ever manufactured by a similar margin. Classical brute-force simulation of this system is not merely impractical: it is physically impossible.
The KLT analytical certificate sidesteps this entirely. The TVD bound follows from the circuit's entropy profile and Lyapunov exponent alone — both quantities computable in O(N × χ² × d) time, polynomial in all parameters. For this benchmark, that computation completes in 22 seconds.