Google Willow and the Multiverse Myth: Inside the 10-Septillion-Year Quantum Supremacy Benchmark

Technical breakdown

Written by Abrar Akhunji

In December 2024, Google Quantum AI published experimental results for its sixth-generation superconducting quantum processor, codenamed Willow.

The primary computational demonstration was executed using Random Circuit Sampling (RCS), a benchmark designed specifically to probe the boundaries of classical computational intractability. Operating across 105 physical qubits at circuit depth $d = 24$, Willow generated millions of projective measurement bitstrings in under 300 seconds.

Google's theoretical analysis concluded that reproducing the identical output probability distribution on the world's premier classical supercomputer (Frontier at Oak Ridge National Laboratory, delivering 1.2 exaFLOPs of peak FP64 throughput) would require approximately $10^{25}$ years (10 septillion years).

Shortly after the announcement, public discourse was dominated by a philosophical extrapolation: did Willow's computational speedup provide empirical proof of the existence of a physical multiverse?

To separate physical reality from metaphysical speculation, systems engineers and physicists must dissect the exact mathematical mechanics of the benchmark, the limitations of classical tensor network contraction, the epistemological foundations of quantum interpretations, and the authentic engineering milestone that Willow actually achieved: below-threshold quantum error correction.

The Architecture of the Willow Processor

Willow represents a major leap in superconducting transmon engineering. The chip features 105 frequency-tunable superconducting qubits arranged on a two-dimensional square lattice with dynamic capacitive couplers:

+----------------------------------------------------------------------------------------------------+
|                         GOOGLE WILLOW 105-QUBIT HARDWARE TOPOLOGY                                  |
+----------------------------------------------------------------------------------------------------+

       (Q)---[C]---(Q)---[C]---(Q)---[C]---(Q)---[C]---(Q)  ... [105 Transmon Qubits]
        |           |           |           |           |
       [C]         [C]         [C]         [C]         [C]   ... [Tunable Capacitive Couplers]
        |           |           |           |           |
       (Q)---[C]---(Q)---[C]---(Q)---[C]---(Q)---[C]---(Q)
        |           |           |           |           |
       ...         ...         ...         ...         ...   ... Operating Temperature: 15 mK
       
  Physical Layer Specifications:
  - Qubit Technology: Superconducting Aluminum/Niobium Transmons (Josephson Junctions)
  - Qubit Grid: Planar square geometry optimized for rotated surface codes
  - Operating Frequency: 4.5 GHz to 6.5 GHz (individually frequency-tunable via flux bias lines)
  - Single-Qubit Gate Fidelity: 99.94% (Clifford Pauli-frame randomized benchmarking)
  - Two-Qubit Controlled-Z (CZ) Fidelity: 99.72% (median across all active pairs)
  - State Preparation & Measurement (SPAM) Error: < 0.6%

The defining hardware advance in Willow is the dramatic reduction of parasitic crosstalk and dielectric loss.

In earlier chips (such as the 53-qubit Sycamore in 2019), simultaneous two-qubit operations suffered severe frequency collisions and spectator qubit dephasing, causing two-qubit error rates to climb toward 0.8% to 1.2%.

Willow integrates revised bump-bonding metallurgy, shielding cavities, and dynamic coupler biasing that suppresses idle residual $ZZ$ coupling to sub-kilohertz levels. This brings the median two-qubit gate error rate down to $0.28%$ (99.72% fidelity) across simultaneous multi-qubit execution.

The Mathematics of Random Circuit Sampling (RCS)

Random Circuit Sampling is not an arbitrary synthetic benchmark; it is mathematically constructed to maximize quantum circuit entanglement while eliminating any algebraic symmetries that classical shortcuts (such as the Fast Fourier Transform or stabilizer tableaus) could exploit.

An $n$-qubit quantum register begins in the all-zero state $|0\rangle^{\otimes n}$.

The circuit applies an alternating sequence of $d$ layers:

1. Single-Qubit Gate Layers: Randomly chosen single-qubit rotations from the set $\{\sqrt{X}, \sqrt{Y}, \sqrt{W}\}$, where $W = (X+Y)/\sqrt{2}$, applied to every qubit independently to create continuous superposition.
2. Two-Qubit Entangling Layers: Controlled-Z ($CZ$) or dynamic FSim gates applied across non-overlapping pairs of adjacent qubits following a fixed four-pattern tiling schedule (North, South, East, West).

+----------------------------------------------------------------------------------------------------+
|                         DEPTH-24 RANDOM CIRCUIT INTERLEAVING TIMELINE                              |
+----------------------------------------------------------------------------------------------------+

  Cycle 1:  [ 1-Qubit Rotations (All Qubits) ] ===> [ CZ Entangling Gates: Pattern A (North-South) ]
  Cycle 2:  [ 1-Qubit Rotations (All Qubits) ] ===> [ CZ Entangling Gates: Pattern B (East-West)   ]
  Cycle 3:  [ 1-Qubit Rotations (All Qubits) ] ===> [ CZ Entangling Gates: Pattern C (Diagonal)    ]
  ...
  Cycle 24: [ Final Basis Rotation           ] ===> [ Simultaneous Projective Z-Measurement        ]

At depth $d = 24$, the circuit implements a pseudo-random unitary operator $U$ sampled from the Haar measure over the unitary group $\mathcal{U}(2^n)$.

The output state vector $|\psi\rangle$ is an entangled linear combination across all $2^n$ basis bitstrings $x \in \{0, 1\}^n$:

$$|\psi\rangle = U |0\rangle^{\otimes n} = \sum_{x \in \{0,1\}^n} \alpha_x |x\rangle$$

where $\alpha_x = \langle x | \psi \rangle \in \mathbb{C}$ is the complex probability amplitude for bitstring $x$.

According to the Porter-Thomas distribution of quantum chaotic states, the probability distribution $p(x) = |\alpha_x|^2$ over the $2^n$ possible outcomes is not uniform.

Instead, due to constructive and destructive interference, the probability density function $P(p)$ follows an exponential distribution:

$$P(p) = 2^n e^{-2^n p}$$

When Willow executes a projective measurement in the computational basis, it samples a bitstring $x_i$ with probability $p(x_i)$. Because the circuit is deterministic for a fixed seed, bitstrings with higher amplitudes ($p(x) > 1/2^n$) appear more frequently than bitstrings with destructive interference ($p(x) \to 0$).

Derivation of the 10-Septillion-Year Classical Barrier

Where does the astronomical figure of 10 septillion years ($10^{25}$ years) originate?

Classical computers simulate quantum systems through two primary methodologies: State Vector Evolution and Tensor Network Contraction.

1. The State Vector Memory Wall

To simulate an $n=105$ qubit circuit by storing the state vector, a classical system must store $2^{105}$ complex numbers.

$$\text{Total Amplitudes} = 2^{105} \approx 4.056 \times 10^{31} \text{ complex states}$$

Assuming single-precision complex numbers (8 bytes per amplitude: 4 bytes real, 4 bytes imaginary):

$$\text{Required Memory} = 4.056 \times 10^{31} \times 8 \text{ bytes} \approx 3.245 \times 10^{32} \text{ bytes} = 3.245 \times 10^{17} \text{ Exabytes}$$

For context, the total storage capacity of all data centers, hard drives, and flash chips constructed on Earth is estimated at approximately 150 Zettabytes ($1.5 \times 10^5$ Exabytes).

Direct state-vector simulation of 105 qubits would require more than two trillion times the entire digital storage of human civilization. Full state vector simulation is physically impossible in the observable universe.

2. Tensor Network Contraction Complexity

To bypass storing the full state vector, modern classical simulators represent the circuit as a tensor network. Each gate is a tensor, and computing the probability of a single output bitstring $x$ corresponds to contracting a tensor network graph $G = (V, E)$.

+----------------------------------------------------------------------------------------------------+
|                  TENSOR NETWORK CONTRACTION: TREEWIDTH EXPONENTIAL BOTTLENECK                      |
+----------------------------------------------------------------------------------------------------+

  Grid Dimension: 105 Qubits (approx. 10 x 11 lattice)
  Circuit Depth:  d = 24 interleaved cycles
  Tensor Vertices: |V| approx. 2,600 tensors
  Graph Treewidth: tw(G) approx. 48 to 54
  
  Contraction Flops Scaling:
  FLOPs_classical = O( 2^{tw(G)} x |V| ) approx. O( 2^{54} ) operations PER BITSTRING!

The time complexity of contracting a tensor network scales exponentially with the treewidth $\text{tw}(G)$ of the graph:

$$\mathcal{C}_{\text{contract}} \propto 2^{\text{tw}(G)}$$

For a $10 \times 11$ qubit lattice at depth 24, the treewidth is bounded by the cross-sectional cut of the space-time volume: $\text{tw}(G) \ge \min(n, d \times \sqrt{n}) \approx 50$.

To calculate the probability of a single bitstring, the contraction requires approximately $2^{54} \approx 1.8 \times 10^{16}$ floating-point operations.

However, Random Circuit Sampling does not require a single amplitude; it requires generating millions of independent, uncorrelated samples from the global distribution.

Sampling using classical tensor networks requires techniques like Markov Chain Monte Carlo (MCMC) or slicing along contraction indices:

• Slicing reduces memory requirements by splitting the network into $2^S$ independent sub-networks.
• For Willow at $n=105, d=24$, slicing the network to fit within the 9.2 Petabytes of aggregate High-Bandwidth Memory available on the Frontier supercomputer requires selecting at least $S \ge 40$ slicing indices.
• The total operation count scales to:

$$\text{Total FLOPs}_{\text{Frontier}} \approx 2^{40} \times 2^{44} \approx 2^{84} \approx 1.93 \times 10^{25} \text{ FLOPs}$$

Frontier executes $1.2 \times 10^{18}$ FLOPs per second at 100% theoretical peak efficiency:

$$\text{Time}_{\text{Frontier}} = \frac{1.93 \times 10^{25} \text{ FLOPs}}{1.2 \times 10^{18} \text{ FLOPs/sec}} \approx 1.6 \times 10^7 \text{ seconds} \approx 0.5 \text{ years for a single batch}$$

When scaled to the full sampling fidelity across millions of bitstrings without statistical bias, the required tensor network slicing trees expand past $10^{42}$ operations, pushing classical runtimes into the $10^{25}$ year horizon.

Willow generated these samples in under 300 seconds using a continuous physical refrigeration budget of 15 kilowatts.

The Multiverse Debate: David Deutsch vs. Scott Aaronson

The vastness of this $10^{25}$-year gap reignited the philosophical debate over the foundations of quantum mechanics.

David Deutsch's Many-Worlds Argument

In his 1997 treatise The Fabric of Reality, British physicist David Deutsch proposed an argument that has become a touchstone for advocates of Hugh Everett's Many-Worlds Interpretation (MWI):

"To those who still cling to a single-universe ontology, I issue this challenge: explain how Shor's algorithm works. When a quantum computer factors a 250-digit number, it performs more computational steps than there are subatomic particles in the observable universe. Where were those steps performed? If they were not performed in parallel universes, where were they performed?"

Following Willow's 10-septillion-year benchmark, Google Quantum AI leadership invoked Deutsch's reasoning, suggesting that the processor's speed lends empirical weight to the existence of an Everettian multiverse. The intuitive appeal is obvious: if our universe cannot store the numbers or execute the arithmetic in classical time, the computation must be farmed out across $10^{31}$ parallel branches of reality that subsequently recombine.

+----------------------------------------------------------------------------------------------------+
|                         DEUTSCH'S MANY-WORLDS VIEW VS LINEAR HILBERT SPACE                         |
+----------------------------------------------------------------------------------------------------+

  David Deutsch's Many-Worlds Narrative:
  Universe 1:  [ Qubit State 000...000 ] ===\
  Universe 2:  [ Qubit State 000...001 ] ====\
  Universe 3:  [ Qubit State 000...010 ] =====> [ Multiverse Recombination ] ===> Final Bitstring
  ...                                   ====/
  Universe N:  [ Qubit State 111...111 ] ===/   (Requires 10^31 physical universes!)

  --------------------------------------------------------------------------------------------------

  Aaronson's Quantum Complexity Reality:
  Single Universe: [ Unified Quantum State Vector |psi> in C^{2^n} ]
  - The state vector is a SINGLE physical wave in a high-dimensional mathematical space.
  - Operations are linear unitary matrix multiplications: |psi_final> = U |psi_init>.
  - Fundamental distinction: Amplitudes can be NEGATIVE or COMPLEX, canceling each other out!
  - Parallel universes cannot explain cancellation (you cannot have -1 universes).

Scott Aaronson's Complexity Reality Check

Quantum complexity theorist Scott Aaronson (University of Texas at Austin) and mainstream quantum physicists have methodically dismantled the claim that Willow proves a multiverse.

Aaronson's rebuttal rests on three foundational principles:

1. Interpretations are Not Hypotheses: In physical science, an experiment can only decide between two theories if those theories make distinct, testable empirical predictions. The Many-Worlds Interpretation, the Copenhagen Interpretation, the de Broglie-Bohm Pilot-Wave Theory, and Quantum Bayesianism (QBism) all utilize the exact same mathematical formalism of unitary evolution ($|\psi(t)\rangle = e^{-iHt/\hbar} |\psi(0)\rangle$). Every single one of these interpretations predicts the identical Porter-Thomas probability distribution that Willow observed. Willow confirms that standard quantum mechanics does not break down at $n=105$ qubits; it does not and cannot differentiate between interpretations.

2. The Failure of the "Parallel Worlds" Metaphor: The popular idea that quantum computers "try all answers simultaneously in parallel universes" completely misrepresents why quantum computers are fast. If a quantum computer merely evaluated all $2^n$ inputs in parallel worlds, measurement would collapse the state, yielding a completely random outcome with probability $1/2^n$ (which is useless for search or computation). Quantum computing derives its power from interference: probability amplitudes $\alpha_x \in \mathbb{C}$ can be positive, negative, or imaginary:

$$\alpha_x = |\alpha_x| e^{i \theta_x}$$

To solve a problem, an algorithm must choreograph gate sequences such that incorrect computational paths destructively interfere and cancel to zero ($\sum \alpha_{\text{bad}} = 0$), while correct paths constructively interfere ($\sum \alpha_{\text{good}} \to 1$). As Aaronson points out, the concept of "negative parallel universes" canceling each other out has no physical meaning in Everettian mechanics. Interference is a property of waves, not collections of classical universes.

3. Nothing Has Changed Since 1985: David Deutsch formulated the universal quantum Turing machine in 1985, and Peter Shor published his polynomial-time factoring algorithm in 1994. If an engineer is convinced by Deutsch's philosophical argument, they should have been convinced forty years ago by the theoretical existence of quantum interference. Executing the circuit on 105 physical transmons at 15 millikelvin verifies that quantum decoherence can be engineered away; it introduces zero new ontological evidence for parallel worlds.

The Verification Paradox: How Do You Prove a 10-Septillion-Year Result?

An inherent paradox sits at the heart of quantum supremacy claims:

If a classical supercomputer requires 10 septillion years to simulate the quantum output distribution, how can scientists verify that Willow actually performed the computation correctly, rather than outputting meaningless thermal noise?

Google resolves this through Linear Cross-Entropy Benchmarking (XEB) paired with patchy circuit cutting.

+----------------------------------------------------------------------------------------------------+
|                         THE LINEAR CROSS-ENTROPY BENCHMARKING (XEB) PIPELINE                       |
+----------------------------------------------------------------------------------------------------+

                               [ Random Circuit Specification C ]
                                               |
                     +-------------------------+-------------------------+
                     |                                                   |
                     v                                                   v
        [ Willow Quantum Hardware ]                         [ Frontier Supercomputer ]
        - Executes C in 300 seconds                         - Simulates Simplified/Cut Circuit
        - Collects bitstrings {x_1, ..., x_M}               - Computes exact probabilities P(x_i)
                     |                                                   |
                     +-------------------------+-------------------------+
                                               |
                                               v
                          [ Calculate Linear XEB Fidelity F_XEB ]
                          F_XEB = 2^n * (1/M) * Sum( P(x_i) ) - 1
                          - If pure noise:     F_XEB = 0.000
                          - If perfect chip:   F_XEB = 1.000
                          - Willow Measured:   F_XEB = 0.0018  (Signal detected with >50 sigma!)

The Linear XEB fidelity metric $\mathcal{F}_{\text{XEB}}$ is defined as:

$$\mathcal{F}_{\text{XEB}} = 2^n \left( \frac{1}{M} \sum_{i=1}^{M} P(x_i) \right) - 1$$

where $M$ is the number of sampled bitstrings (typically $M \approx 10^7$), and $P(x_i)$ is the classical probability of observing bitstring $x_i$ under an ideal noise-free simulation.

• If the quantum processor is completely depolarized by environmental thermal noise, it outputs uniformly distributed bitstrings ($P(x_i) \approx 1/2^n$), yielding $\mathcal{F}_{\text{XEB}} = 2^n(1/2^n) - 1 = 0$.
• If the quantum processor is completely noiseless, bitstrings sample the Porter-Thomas distribution ($P(p) = 2^n e^{-2^n p}$), yielding an expected average probability $\langle P(x) \rangle = 2 / 2^n$, which results in $\mathcal{F}_{\text{XEB}} = 2^n(2/2^n) - 1 = 1$.

The Verification Bridge: Patchy Cuts and Extrapolation

Because $P(x_i)$ cannot be computed classically for the full 105-qubit depth-24 circuit, Google uses three rigorous validation regimes:

1. Elided Circuit Verification: Google removes a small subset of entangling gates along a geometric seam in the 2D lattice. This splits the 105-qubit network into two weakly coupled 52-qubit partitions. Classical supercomputers can simulate these two halves in hours, directly verifying that $\mathcal{F}_{\text{XEB}} > 0$.
2. Low-Depth Truncation: Google runs the full 105-qubit lattice at shallow depths ($d = 8, 12, 14$). Classical tensor network contraction can contract these networks before the treewidth explodes, confirming high fidelity.
3. Component-Level Error Modeling: The overall system fidelity is predicted by multiplying the independent fidelities of all constitutive gates:

$$\mathcal{F}_{\text{predicted}} = \prod_{g \in \text{1Q}} (1 - \epsilon_g) \times \prod_{g \in \text{2Q}} (1 - \epsilon_g) \times \prod_{q \in \text{qubits}} (1 - \epsilon_{\text{SPAM}})$$

In Willow, the measured XEB score across the classically verifiable boundaries matched the predicted multiplicative fidelity within $3%$, providing statistical certainty exceeding $50\sigma$ that the quantum state is coherent and correctly entangled.

The Real Engineering Triumph: Below-Threshold Quantum Error Correction

While the public was captivated by multiverse claims, the quantum computing community celebrated Willow for a completely different achievement: demonstrating scalable, below-threshold quantum error correction (QEC).

For three decades, quantum computing faced what physicists called the fault-tolerance curse: To protect a fragile quantum state, you encode one logical qubit into an ensemble of multiple physical qubits using an error-correcting code (such as the surface code).

However, because physical qubits are inherently noisy, adding more physical qubits introduces more noise channels. In every previous quantum processor, larger codes exhibited worse logical error rates than smaller codes ($\epsilon_{\text{logical}} \text{ grew as distance } d \text{ increased}$).

+----------------------------------------------------------------------------------------------------+
|                         THE HISTORIC SURFACE CODE SCALING BREAKTHROUGH                             |
+----------------------------------------------------------------------------------------------------+

  Previous Generation Hardware (Above Threshold: Lambda < 1.0):
  - Distance-3 Code (17 Physical Qubits):  Logical Error Rate = 1.2%
  - Distance-5 Code (49 Physical Qubits):  Logical Error Rate = 2.8%  (WORSE! Adding qubits added noise!)
  
  Google Willow Hardware (Below Threshold: Lambda = 1.85 > 1.0):
  - Distance-3 Code (17 Physical Qubits):  Logical Error Rate = 0.42%
  - Distance-5 Code (49 Physical Qubits):  Logical Error Rate = 0.23% (BETTER!)
  - Distance-7 Code (97 Physical Qubits):  Logical Error Rate = 0.12% (HALF AGAIN!)

In a rotated surface code, a logical qubit is defined across a $d \times d$ array of physical data qubits, interleaved with syndrome measurement qubits that detect bit-flip ($X$) and phase-flip ($Z$) errors without collapsing the logical state.

The logical error rate $\epsilon_L$ scales according to:

$$\epsilon_L \propto \left( \frac{\epsilon_{\text{physical}}}{\epsilon_{\text{threshold}}} \right)^{\frac{d+1}{2}} = \Lambda^{-\frac{d+1}{2}}$$

Where:

• $d$ is the code distance (the minimum number of physical physical errors required to corrupt the logical state).
• $\epsilon_{\text{threshold}}$ is the fault-tolerance threshold (approximately $0.57%$ for standard surface codes under circuit-level noise).
• $\Lambda = \epsilon_{d-2} / \epsilon_d$ is the error suppression factor.

If $\Lambda < 1$, the hardware is above threshold: increasing code distance degrades performance.

Willow achieved $\Lambda \approx 1.85 > 1.0$ across the full chip.

Moving from a distance-3 code (17 qubits) to a distance-5 code (49 qubits) and a distance-7 code (97 qubits) exponentially suppressed the logical error rate by nearly half with each step.

This is the definitive inflection point in the history of quantum information science: it proves that physical quantum hardware can be scaled arbitrarily large without noise overwhelming the computation.

+----------------------------------------------------------------------------------------------------+
|               TABLE 1: COMPARATIVE ARCHITECTURAL SPECIFICATIONS ACROSS GENERATIONS                 |
+--------------------------+-----------------------+------------------------+------------------------+
| Hardware Specification   | Google Sycamore (2019)| Google Willow (2024)   | Frontier Supercomputer |
+--------------------------+-----------------------+------------------------+------------------------+
| Compute Architecture     | 53 Superconducting Q  | 105 Superconducting Q  | 37,888 AMD MI250X GPUs |
| Operating Temperature    | 20 millikelvin        | 15 millikelvin         | Room Temp (Liquid Cool)|
| Median 2-Qubit Gate Error| 0.85% Error           | 0.28% Error (-67% Drop)| Deterministic Bitwise  |
| Hilbert Space Dimension  | 2^53 (9.0 x 10^15)    | 2^105 (4.0 x 10^31)    | Memory Constrained     |
| Benchmark Execution Time | 200 seconds           | Under 300 seconds      | 10 Septillion Years    |
| QEC Scaling Factor Lambda| 0.92 (Above Threshold)| 1.85 (Below Threshold!)| Not Applicable         |
| Physical Verification    | Full Classical Direct | Patchy Cut XEB Extrap  | Direct Arithmetic Check|
+--------------------------+-----------------------+------------------------+------------------------+

Architectural Dilemmas and Infrastructure Rules of Thumb

For systems engineers, AI infrastructure architects, and technical leaders evaluating quantum-classical integration, Willow provides concrete architectural principles:

1. Decouple Quantum Advantage from General Classical Utility:

   • Anti-Pattern: Assuming that a quantum processor completing a random sampling task in 5 minutes means quantum computers can accelerate standard LLM inference, matrix multiplications, or database lookups today.
   • Rule of Thumb: Random Circuit Sampling is specifically chosen because it matches the natural physics of transmon evolution. It possesses near-zero direct commercial utility. Real-world utility (such as quantum chemistry simulation via VQE, materials science, or Shor's factoring) requires millions of physical qubits operating at code distances $d \ge 27$. Do not plan infrastructure migrations for classical AI workloads based on RCS milestones.

2. Evaluate Quantum Hardware Exclusively by Code Distance Scaling ($\Lambda$):

   • Anti-Pattern: Assessing quantum progress by headline physical qubit counts alone (e.g., comparing a 1,000-qubit processor with 1.5% error rates against a 100-qubit processor with 0.2% error rates).
   • Rule of Thumb: A thousand noisy qubits above threshold ($\Lambda < 1.0$) can never perform fault-tolerant computation. Always evaluate quantum hardware by its error suppression ratio $\Lambda = \epsilon_{d-2}/\epsilon_d$. If $\Lambda \le 1.0$, the device is a physics experiment. Only when $\Lambda > 1.5$ is the hardware architecture capable of serving as a scalable logical co-processor.

3. Treat the Quantum Processor as an Asynchronous PCIe Co-Processor:

   • Anti-Pattern: Expecting quantum processors to operate in a tight synchronous control loop with standard host CPUs without specialized FPGA control orchestration.
   • Rule of Thumb: Quantum state coherence lifetimes ($T_1, T_2$) are measured in tens of microseconds ($T_1 \approx 70\ \mu\text{s}$ on Willow). All pulse sequencing, microwave modulation, and readout thresholding must be handled by dedicated real-time FPGA and RF system-on-chip (RFSoC) controllers operating at sub-10-nanosecond determinism. Treat the dilution refrigerator as an ultra-high-latency network endpoint accessed through batch job submission queues.