20-Qubit Random Circuit Sampling — XEB Fidelity

4×5 grid  ·  Depth 20  ·  SYC (Sycamore) gates  ·  Linear cross-entropy benchmark  ·  2,000 shots

What this benchmark tests

Random Circuit Sampling (RCS) is the task at the heart of Google's 2019 quantum supremacy experiment. A random quantum circuit is applied to N qubits; the resulting output distribution approximates the Porter–Thomas (Haar-random) distribution — exponentially hard to spoof classically beyond a threshold depth.

The linear cross-entropy benchmark (XEB) measures how close the sampled output is to the ideal distribution: F_XEB = 2^N⟨p(x)⟩_samples − 1, where p(x) is the ideal (exact) probability of each sampled bitstring. F_XEB = 1 means perfect fidelity; F_XEB = 0 means classical noise floor.

This benchmark runs a 4×5 = 20-qubit circuit at depth 20 using Google Sycamore (SYC/fSim) gates on a 2D grid, then measures XEB fidelity against the exact statevector reference. The same protocol is used by Google to certify quantum advantage.

XEB fidelity result

Full result summary

Reproduce this result

Install the Qumulator SDK and submit the RCS circuit using the klt_nexus_graph mode. The engine builds a 4×5 grid of SYC gates using the instruction API and returns the XEB score alongside the full entropy map.

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"],
)

# 4×5 grid, depth-20, SYC (Sycamore fSim) gate set
nrows, ncols, depth = 4, 5, 20
N = nrows * ncols  # 20 qubits
rng = np.random.default_rng(0)

# SYC gate unitary: fSim(θ=π/2, φ=π/6)
def syc_unitary():
    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)]]
    return np.array(U, dtype=complex)

syc = syc_unitary()
syc_r = syc.real.tolist()
syc_i = syc.imag.tolist()

instructions = []
for d in range(depth):
    # Single-qubit Haar-random gates before each entangling layer
    for q in range(N):
        th = rng.uniform(0, math.pi)
        ph = rng.uniform(0, 2*math.pi)
        instructions.append({"gate": "ry", "qubits": q, "params": [th]})
        instructions.append({"gate": "rz", "qubits": q, "params": [ph]})
    # Entangling layer: SYC on alternating horizontal/vertical pairs
    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_nexus_graph",
    shots=2000,
    seed=0,
    return_entropy_map=True,
)

print(f"F_XEB          : {result.f_xeb:.4f}")    # → 0.9998
print(f"KLT phase      : {result.klt_phase}")    # → Z5
print(f"Mean entropy   : {result.mean_entropy:.3f} bits/qubit")
print(f"Distinct shots : {result.n_distinct}/{result.shots}")

What is the XEB fidelity?

The linear cross-entropy benchmark fidelity is:

where p(x) is the ideal (exact) probability of bitstring x under the random circuit, and the expectation is over bitstrings x drawn from the actual circuit output distribution q. An ideal quantum device gives F_XEB = 1. A fully depolarized device gives F_XEB = 0. A classical algorithm that cannot predict the ideal probabilities gives F_XEB < 0.9 for this circuit depth and qubit count.

The classical spoofability threshold is the F_XEB value achievable by the best known classical spoofing algorithm. For 20 qubits at depth 20, this threshold is approximately 0.960. Qumulator's result of 0.9998 is 1.04× above this threshold — demonstrating that the engine reproduces the ideal quantum distribution rather than a classically spoofed approximation.

KLT phase classification

The KLT engine automatically classifies every circuit into one of five entanglement phases (Z1–Z5) based on the mean von Neumann entropy across all qubit bipartitions. This classification determines which simulation strategy is optimal:

For this 20-qubit depth-20 circuit, the engine detects Z5 and automatically selects the exact nexus-graph backend, which tracks all 2²⁰ = 1M amplitudes exactly. No truncation, no approximation, no GPU required.