105-Qubit Phase Detection — Z4 Label

7×15 Willow-scale SYC grid  ·  Depth 2  ·  S_mean = 0.732 bits/qubit  ·  Cumulant K = 4

What this benchmark tests

Before simulating a quantum circuit, Qumulator's KLT adaptive engine runs a lightweight preflight analysis that classifies the circuit into one of five entanglement phases (Z1–Z5). This classification — returned alongside every result — determines which simulation backend is invoked and certifies the TVD accuracy of the result without requiring an exponential reference simulation.

This benchmark exercises the phase-detection step on a 105-qubit 7×15 Willow-scale Sycamore (SYC/fSim) circuit at depth 2. At this depth the circuit is partially entangled but has not yet reached the Haar-random plateau — a regime where the KLT adaptive strategy (Z4, cumulant K=4) delivers the highest per-qubit value: small TVD at a fraction of the cost of full statevector simulation.

KLT phase ladder

The KLT engine classifies every circuit into one of five entanglement regimes before simulation:

Full result summary

Reproduce this result

Submit the circuit using return_entropy_map=True to get the KLT phase label alongside the simulation result. The phase label, TVD certificate, and natural depth are returned as first-class fields on every circuit response.

pip install qumulator-sdk

import os, math
import numpy as np
from qumulator import QumulatorClient

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

# 7×15 Willow-scale SYC circuit, depth 2
nrows, ncols, depth = 7, 15, 2
N = nrows * ncols  # 105 qubits
rng = np.random.default_rng(42)

# SYC gate unitary: fSim(θ=π/2, φ=π/6)
def syc():
    th, ph = math.pi/2, math.pi/6
    c, s = math.cos(th), math.sin(th)
    U = [[1,0,0,0],[0,c,-1j*s,0],[0,-1j*s,c,0],[0,0,0,np.exp(-1j*ph)]]
    M = np.array(U, dtype=complex)
    return M.real.tolist(), M.imag.tolist()

syc_r, syc_i = syc()

instructions = []
for d in range(depth):
    # Random single-qubit Haar rotations
    for q in range(N):
        instructions.append({"gate": "ry", "qubits": q, "params": [rng.uniform(0, math.pi)]})
        instructions.append({"gate": "rz", "qubits": q, "params": [rng.uniform(0, 2*math.pi)]})
    # SYC entangling layer (horizontal bonds)
    for r in range(nrows):
        for c in range(ncols - 1):
            q0, q1 = r*ncols+c, r*ncols+c+1
            instructions.append({
                "gate": "unitary", "qubits": [q0, q1],
                "matrix_real": syc_r, "matrix_imag": syc_i,
            })

result = client.circuit.run(
    n_qubits=N,
    instructions=instructions,
    mode="klt_mps",
    bond_dim=64,
    shots=1024,
    seed=42,
    return_entropy_map=True,
)

print(f"KLT phase     : {result.klt_phase}")        # → Z4
print(f"Mean entropy  : {result.mean_entropy:.3f} bits/qubit")  # → 0.732
print(f"Predicted TVD : {result.tvd_bound:.4f}")    # → 0.0014
print(f"Natural depth : {result.natural_depth:.2f}")  # → 0.30
print(f"Cumulant K    : {result.cumulant_level}")    # → 4

Why does phase detection matter?

Classical simulation cost scales exponentially with entanglement. A circuit in Z1 or Z2 can be simulated with bond dimension χ ≤ 8 (seconds, gigabytes). A circuit in Z5 requires full statevector (exponential memory). The phase label routes each circuit to the cheapest correct backend automatically — no manual tuning required.

For this 105-qubit Z4 circuit, the KLT engine selects MPS with χ = 64 and a 4th-order cumulant correction stack. The result carries a TVD accuracy certificate of 0.0014 — meaning the output distribution differs from the ideal quantum output by at most 0.14% in total variation distance. This is returned with every result, no exact reference simulation required.