A Measured Quantum–Classical Resource Asymmetry on IBM Kingston: Empirical Grounding for the Computational Argument in the Quantum-Simulator Hypothesis

Amit Brahmbhatt Quantum-Clarity LLC Email: [e-mail] Date: April 2026 Platform: IBM Kingston (156-qubit Heron r3 heavy-hex superconducting processor) Related deposits: PBR-inspired entanglement validation — Zenodo DOI 10.5281/zenodo.17883261 Y⊗Z stabilizer prior art — Zenodo DOI 10.5281/zenodo.18498540 Y⊗Z Kingston validation — Zenodo DOI 10.5281/zenodo.19478241 Drift-robust methodology paper — Zenodo DOI 10.5281/zenodo.19673112 FR full-range measurement — Zenodo DOI 10.5281/zenodo.19682679 Abstract We measure on-hardware the computational resource cost of executing a scaling family of random native-edge quantum circuits on the 156-qubit IBM Kingston superconducting processor, at five sizes N ∈ {10, 20, 30, 40, 50} with circuit depth 30, and contrast that measured quantum cost with the state-vector memory cost required for exact classical simulation of the same circuits. The quantum gate count grows approximately linearly with N, from 321 gates at N = 10 to 1904 gates at N = 50, a factor of 5.9 across the range. The classical state-vector memory cost grows exponentially as 16 × 2^N bytes, from 16 KB at N = 10 to 16 PB at N = 50, a factor of approximately 10^12. Kingston consumed 7 seconds of authoritative billed quantum-processor time to execute all five circuits at 2000 shots each, producing well-defined measured expectation values of the Z observable on one designated qubit at every N. We do not interpret this result as a test of the simulation hypothesis. We do interpret it as an on-hardware empirical grounding for the computational-complexity argument that if physical reality were being simulated externally, the simulator would overwhelmingly more likely be quantum than classical — because classical simulation of quantum-entangled systems at any non-trivial scale is intractable in a precise, measured, and monotonically-worsening sense that this experiment documents directly. Total billed quantum-processor time for the experiment was 7 seconds against an annual allocation of 10,800 seconds. Plain-Language Summary Every time a quantum computer runs a circuit with N qubits, the amount of computer memory that would be needed to faithfully reproduce that same circuit on a classical computer doubles for each additional qubit. This is not a matter of clever engineering that future chips will eventually overcome. It is a mathematical consequence of how quantum mechanics works. At 50 qubits the classical memory requirement already exceeds what any single classical computer can hold. At 300 qubits it exceeds the number of atoms in the observable universe. This experiment is a small, deliberate measurement of that divergence on a real quantum processor. We ran the same kind of random quantum circuit at five different sizes — 10, 20, 30, 40, and 50 qubits — on IBM's 156-qubit Kingston machine. For the quantum machine, the cost of each circuit grew only modestly with size: about six times more operations when we went from 10 qubits to 50 qubits. For a hypothetical classical computer trying to reproduce the same work exactly, the cost grew by a factor of roughly one trillion over the same range. The total time IBM billed us for running the whole experiment, at all five sizes together, was seven seconds. This paper does not claim that our universe is a simulation. Perhaps it is, perhaps it is not; no experiment that we or anyone else has performed can settle that question, and this one does not either. What this paper does is make a specific, narrower point. People sometimes speculate that if our universe is being computed by some larger system, that larger system would need to be quantum rather than classical, because the classical alternative would be impossibly resource-hungry. This speculation is usually left as a thought experiment. We provide the measurement that turns it from speculation into something with an empirical anchor: the resource gap between quantum and classical execution is real, it is measurable on present-day hardware, and it grows exponentially fast. Everything beyond that measurement — whether the universe is simulated at all, and if so by what — remains a philosophical question, not a scientific one. 1. Introduction A recurring speculation in popular discussions of physics is that our universe might be computed by some form of external substrate. The simulation hypothesis in its philosophical form (Bostrom 2003) argues on statistical grounds that such a state of affairs is not implausible. A narrower and more specific claim appears in the quantum-information literature: if physical reality were being simulated, the simulator would almost certainly have to be a quantum computer rather than a classical one. Lloyd (2006) develops versions of this argument; Feynman's 1982 remarks on the impossibility of efficient classical simulation of quantum systems are its modern origin. The computational argument runs roughly as follows. Our universe exhibits quantum entanglement at macroscopic scale, established by Bell inequality violations and by routine experimental confirmations of quantum theory across every domain in which it has been tested. Exact classical simulation of a quantum system of N entangled particles requires resources that scale as 2^N — a consequence of the dimensionality of the associated Hilbert space. At the scale of the observable universe, even storing the state vector would require more classical bits than there are particles in the universe. A quantum simulator, by contrast, can in principle simulate a quantum system with resources polynomial in the system size, exactly because the simulator's own substrate supports superposition and entanglement natively. If a simulator exists, these facts taken together strongly favor a quantum substrate over a classical one. The argument is typically made as a thought experiment supported by scaling estimates rather than by direct measurement. The purpose of the present experiment is to ground the argument in an on-hardware, documented measurement: a scaling family of random quantum circuits at sizes from N = 10 to N = 50 qubits, executed on a real 156-qubit superconducting quantum processor, with the measured quantum cost and the exact classical cost tabulated directly. No new theoretical claim is advanced. What is new is the replacement of scaling estimates with scaling measurements. The experiment is deliberately narrow in scope. It does not test whether our universe is being simulated; that question is empirically inaccessible as currently formulated, as discussed further in Section 5. It does not test whether Kingston outperforms any specific classical supercomputer on a specific benchmark; the "quantum supremacy" literature addresses that question with large-scale comparisons beyond our scope. What the present experiment does test is whether the quantum-versus-classical resource asymmetry predicted by theory is observable at modest qubit counts on present-day hardware, and whether it scales in the direction the theory says it should. Both questions are answered affirmatively and quantitatively. The experiment builds on prior work by the author on the same processor. The drift-robust submission methodology established in the methodology record (Brahmbhatt 2026c) is reused here to ensure that the scaling comparison is not confounded by time-correlated artifacts. The FR full-range measurement (Brahmbhatt 2026d) on the same processor one day earlier provides an independent same-week cross-check that the Kingston backend is behaving nominally. The present experiment uses no proprietary gate sequences and no Y⊗Z protected encodings; the circuits are generic random single-qubit rotations interleaved with CZ on native edges, chosen precisely so that the measured asymmetry is a universal statement about quantum-versus-classical computation rather than a feature of any specific architecture. 2. Experimental Design Five random quantum circuits were constructed, one at each N ∈ {10, 20, 30, 40, 50}. Each circuit applies 30 layers of alternating single-qubit and two-qubit operations. In each layer, every qubit receives a random choice of SX, Rz(random angle), or X (uniform selection from the three), and then a non-overlapping matching of native Kingston coupling-map edges is selected and a CZ is applied on each selected pair. The overall circuit structure is a depth-30 random Clifford-plus-rotation brickwork on native connectivity. Circuit construction is deterministic given the fixed random seed (20260421), so the circuit family is fully reproducible from the deposited data. The qubit subgraph at each N was selected at runtime by reading Kingston's live coupling map and qubit properties, filtering qubits with T1 above 50 percent of the chip-mean T1, and growing a connected subgraph starting from the qubit with the best-quality neighborhood and expanding via breadth-first search preferring low-error edges. The five resulting subgraphs are nested — the N = 20 subgraph contains the N = 10 subgraph, the N = 30 subgraph contains the N = 20, and so on. This nesting is incidental to the BFS growth procedure but makes the scaling comparison somewhat cleaner: each larger circuit adds qubits to the previous one rather than moving to an unrelated region of the chip. The native-edge restriction on CZ gate placement is enforced by construction: in the random circuit builder, CZ gates are only emitted on pairs that exist as edges on Kingston's live heavy-hex coupling graph. This choice avoids SWAP insertion during transpilation, which was verified by inspection of the transpiled circuits (zero SWAPs inserted across all five circuits). The cost of the restriction is that the quantum circuits are not fully connected in the way a tensor-network-hostile quantum-supremacy benchmark would be; this is addressed in Section 5 where we discuss how depth rather than connectivity carries the classical-hardness argument in the present setup. The observable measured on each circuit is the Z-basis marginal on logical qubit 0 (physically, the seed qubit of each subgraph), read out as ⟨Z⟩ = (N₀ − N₁) / N_shots. No error mitigation is applied to the observable itself; the full Kingston mitigation stack (XY4 dynamical decoupling and Pauli twirling with 32 randomizations on both gates and measurements) is active during execution, consistent with the other Kingston deposits from the same author. All five circuits were submitted in a single job with randomized circuit order (fixed seed, 20260421) following the time-interleaving protocol established in Brahmbhatt (2026c). The job was executed on April 22, 2026, returning 16.9 seconds of wall-clock elapsed time. The IBM Runtime portal reported 7 seconds of authoritative billed quantum-processor time for the job, which is the figure used throughout the remainder of the paper; the wall-clock figure includes queue management and result serialization that are not part of the on-chip execution cost. 3. Results Table 1 summarizes the scaling comparison across the five qubit sizes. N Qubits used Native edges CZ gates 1-qubit gates Total ops Classical state-vector memory 10 10 9 90 231 321 16 KB 20 20 19 216 521 737 16 MB 30 30 29 338 794 1132 16 GB 40 40 39 437 1021 1458 16 TB 50 50 50 558 1346 1904 16 PB Table 1. Resource-cost comparison for the scaling family. "Total ops" is the sum of two-qubit and single-qubit gates per circuit as reported by the post-transpilation operation count. "Classical state-vector memory" is the exact memory required to store the 2^N complex-double-precision amplitudes of the corresponding pure quantum state, 16 × 2^N bytes, and represents the strict lower bound on the memory cost of exact classical simulation by state-vector methods. Across N = 10 to N = 50, the quantum gate count grows from 321 to 1904 — a factor of 5.9, approximately linear in N. Across the same range, the classical state-vector memory requirement grows from 16 KB to 16 PB — a factor of 10^12, exponential in N. The ratio of the two growth factors is approximately 10^12 / 6 ≈ 2 × 10^11. Expressed plainly: as we add 40 qubits to the system, the classical resource requirement grows roughly 200 billion times faster than the quantum resource requirement. This is the central measured finding of the paper. Figure R1 (provided as a separate file in this deposit) visualizes the scaling comparison on a logarithmic vertical axis, with the quantum gate count and the classical state-vector memory plotted as a function of N on a common scale. The quantum curve is visibly close to a straight line on log-linear axes, consistent with linear (or at most polynomial) scaling. The classical curve is precisely a straight line on the same axes with slope log₂(2) per qubit, consistent with the exact doubling at each qubit added. The two curves diverge by eight orders of magnitude across the 40-qubit span from N = 10 to N = 50. Figure R2 (provided as a separate file in this deposit) breaks the quantum gate count down into its CZ (two-qubit) and single-qubit components at each N, demonstrating that both components scale approximately linearly with qubit count. The CZ count grows at approximately 11 additional CZ gates per qubit added; the single-qubit gate count grows at approximately 28 additional single-qubit gates per qubit added. Figure R3 (provided as a separate file in this deposit) displays the measured Z-basis expectation value on logical qubit 0 at each N, with statistical error bars derived from the 2000 shots sampled at each circuit. The measured values range from −0.005 at N = 10 to +0.044 at N = 20, with four of the five points consistent with zero within one standard deviation and one point (N = 20) approximately 2σ above zero. This clustering near zero is expected and is in fact diagnostic: a depth-30 random circuit approximates a scrambling unitary, under which the Z-basis marginal on any particular qubit approaches the uniform distribution of P(0) = P(1) = 1/2, corresponding to ⟨Z⟩ = 0. The small residual deviations from zero are consistent with the known dephasing and readout-error floor of Kingston at the depths involved. The scientific point that this figure supports is not that any particular ⟨Z⟩ value is predicted or verified; it is that Kingston produces a well-defined measurement outcome at every N, in essentially constant execution time per circuit, with statistical uncertainty bounded by the shot-noise limit. The classical cost of producing that same well-defined measurement outcome by exact simulation is given by the corresponding row of Table 1 and reaches 16 petabytes of memory at N = 50. The total billed quantum-processor time for the experiment, covering all five circuits and all 10,000 aggregated shots, was 7 seconds. 4. Scaling Analysis The measured scaling factors for the two resource-cost metrics are as follows. For the quantum gate count, a least-squares fit of log₁₀(total ops) against N across the five data points yields a slope of approximately 0.02 per qubit, consistent with linear scaling total_ops ≈ C × N for some constant C near 35. For the classical state-vector memory, the theoretical relation is exact: log₂(memory_bytes) = 4 + N, corresponding to an additive 1 bit per qubit added on the log-base-2 scale. On a log-base-10 scale, the gap between the two resource metrics grows at approximately 0.28 decades per qubit (one factor of 2 doubling being approximately 0.301 decades, minus the ~0.02 decades per qubit of quantum growth). Over the 40-qubit span from N = 10 to N = 50, this corresponds to a gap widening by approximately 11 decades — the 10^11 asymmetry factor reported in Section 3. We note that state-vector memory is a deliberately conservative lower bound on the classical simulation cost. More sophisticated classical approaches such as tensor-network contraction, stabilizer simulation, or Schrödinger–Feynman path-summation methods can in some cases achieve better-than-exponential scaling for circuits of restricted structure (shallow depth, low entanglement, Clifford-dominated content). The present circuits are deliberately chosen to be poorly suited to these shortcuts: the depth of 30 exceeds typical stabilizer-simulator-friendly regimes, the single-qubit gate mixture is dominated by non-Clifford Rz rotations at random angles, and the native-edge connectivity on the heavy-hex graph produces enough entanglement structure at depth 30 to challenge tensor-network methods at the larger N values. We do not formally prove classical-hardness of the specific circuits used; we note only that state-vector memory is the most favorable case for classical simulation, and the asymmetry we measure is against that favorable case. 5. Interpretation and Scope We emphasize two separations of scope that this paper maintains carefully, because both separations have direct bearing on how the result should and should not be cited. 5.1 Separation of measurement from simulation hypothesis This experiment does not test whether our universe is a simulation. The simulation hypothesis, as classically formulated by Bostrom (2003) and elaborated in various forms since, is empirically underdetermined: any experiment conducted inside a faithful simulation reproduces the physics of the simulated universe, and a faithful quantum simulation of a quantum universe is by definition indistinguishable from a non-simulated quantum universe by experiments internal to it. We therefore take no position, by way of this experiment, on whether our universe is being simulated. Perhaps it is; perhaps it is not; the present measurement does not move the needle in either direction on that question. What the experiment does is measure a specific computational fact: the ratio between the on-hardware quantum cost and the exact classical cost of producing a well-defined measurement outcome on a scaling family of random quantum circuits. That ratio grows exponentially with system size in a manner predicted by standard quantum-information theory and previously verified only via theoretical scaling estimates or very-large-scale quantum-supremacy benchmarks. Our contribution is the modest-scale, low-QPU-budget, on-hardware documentation of the same scaling in a form that is reproducible and directly inspectable by any interested party. 5.2 Conditional relevance to the quantum-simulator hypothesis The computational-complexity argument that if a simulator exists, then it is overwhelmingly more likely to be quantum than classical, rests on exactly the kind of scaling asymmetry measured here. The argument's strength does not depend on our experiment in the sense that the asymmetry is theoretically established without new measurement; but the argument's rhetorical accessibility is substantially improved when one can point to a direct on-hardware measurement rather than a thought experiment. A sceptic who doubts that classical simulation of quantum systems is practically intractable at scale can be pointed to Table 1 of the present paper and observe that even at N = 50 — a small system by any physical standard, smaller than the number of atoms in a biological molecule — the classical memory requirement already exceeds any single classical computer's capacity. Nothing in Section 3 or Section 4 requires belief in the simulation hypothesis to be meaningful. The measurement stands on its own as a scaling-asymmetry result on present-day quantum hardware. The connection to the simulation-hypothesis discussion is that the measurement also serves as a concrete empirical anchor for a specific argument in that discussion — namely, the argument about what substrate could plausibly support a universe-scale simulation. 5.3 What this experiment does not show For completeness, we list explicitly several claims that this experiment does not support, to pre-empt misreadings: The experiment does not show that our universe is a simulation. The experiment does not show that our universe is not a simulation. The experiment does not show quantum supremacy or quantum advantage over any specific classical algorithm or supercomputer; the five circuits used here are all classically tractable on a sufficiently large workstation or cluster, and only the scaling behavior — not the absolute size — motivates the paper. The experiment does not claim priority for the scaling argument; the exponential-classical versus polynomial-quantum scaling has been known since Feynman (1982) and is textbook material in quantum information theory. The experiment does not constitute new evidence for quantum mechanics; standard quantum mechanics is presupposed throughout. What the experiment contributes is a specific piece of measurement in service of rhetorical clarity and accessible reproducibility: a short, cheap, on-hardware demonstration of the scaling asymmetry, in a form that readers can verify against the deposited raw data. 6. Conclusion Across a five-point scaling family of random native-edge quantum circuits at qubit counts from 10 to 50 on the 156-qubit IBM Kingston processor, the quantum gate count grew by a factor of approximately 5.9 while the exact classical state-vector memory cost grew by a factor of approximately 10^12 for the same circuits. The measured ratio of classical-to-quantum cost growth factors across the 40-qubit span is approximately 2 × 10^11. Kingston executed all five circuits in 7 seconds of authoritative billed quantum-processor time, producing well-defined Z-basis expectation values at every N. The measurement is consistent with standard quantum-information theory and with prior theoretical estimates; its contribution is empirical rather than theoretical. The intended use of the result is as a direct, low-cost, reproducible anchor for the computational-complexity argument — often made informally in discussions of the quantum-simulator hypothesis — that classical simulation of quantum-entangled systems is intractable in a measured sense that worsens exponentially with system size. We emphasize that the experiment makes no claim about whether our universe is or is not being simulated; the present measurement is orthogonal to that question. Total experimental cost: 7 seconds of billed quantum-processor time on a single submitted job. 7. Plain-Language Results and Significance The measured finding of this experiment, in everyday terms, is as follows. We gave IBM's quantum computer five different problems to solve, ranging from small (10 qubits) to moderate (50 qubits). For the quantum computer, the effort required scaled up gently — roughly six times more operations for the biggest problem than the smallest. For a classical computer asked to reproduce exactly the same work, the effort required scaled up astronomically — roughly a trillion times more work for the biggest problem than the smallest. The quantum computer finished all five problems together in seven seconds. A classical computer would have needed, for the largest of the five alone, enough memory to hold 16 petabytes of data. What this means in concrete terms: if someone wanted to build a machine that could compute the physics of entangled quantum systems at realistic scale, a classical machine cannot do the job. Not because of engineering limits that better chips will eventually overcome, but because the mathematical cost grows faster than anything physically achievable in classical hardware. A quantum machine can do the job, because its underlying substrate is itself quantum and grows its capacity naturally with its size. This observation does not prove that our universe is a simulation. It does not prove that our universe is not a simulation. What it does do is give teeth to an informal philosophical argument. Sometimes people wonder whether our universe might be the output of some kind of vast computation happening on a substrate we cannot directly access. If such a substrate exists, the present experiment shows quantitatively, on real hardware, that it cannot be a classical computer of any plausible size or design. The classical option fails not by a small margin but by margins that double with every additional quantum particle being simulated. Quantum substrates suffer no such exponential penalty. So: if there is such a substrate, it is, by the same logic the experiment makes concrete, much more likely to be quantum than classical. Whether there is any such substrate at all — whether our universe is a simulation in any meaningful sense — remains a question that no experiment anyone has yet devised can answer. We take no position on it. What we report is one piece of measured evidence about what kind of substrate, hypothetically, could support a simulation like ours, presented in a form that a curious reader can verify for themselves by downloading the data files from this deposit. In keeping with the stance that has guided our previous deposits on the same processor: our task is to let the computations tell the truth. The computations here tell us, quantitatively and reproducibly, that quantum and classical substrates are not merely different in degree when it comes to simulating quantum reality. They are different in kind, by factors that grow without bound. Whatever broader conclusions one draws from that fact — if any — must still honor what the measurement actually does and does not show. Data Availability The raw experimental output JSON (qc_asymmetry_kingston_20260422_094716.json) containing the full per-circuit results (aggregated Z-basis counts, assigned qubit subgraphs at each N, circuit and transpilation metadata, mitigation stack configuration, randomization seeds) is deposited alongside this manuscript in the same Zenodo record. The three figures reproduced in this manuscript are included as separate files at the deposit. Experimental and analysis scripts are not included in the deposit; interested researchers may contact the author directly. Acknowledgments The author thanks IBM Quantum for access to the Kingston backend. The hardware-adaptive layout discovery and live-coupling-map driven circuit construction reused in this experiment were developed in prior work (Brahmbhatt 2026a, 2026b) and applied without modification. The drift-robust submission protocol applied here (randomized time-interleaving of circuit submission with fixed seed) was established in the methodology record (Brahmbhatt 2026c) and is reused here to ensure the scaling comparison is not confounded by time-correlated backend artifacts. Critical review during the design of this experiment sharpened the scope separation between what the measurement does and does not demonstrate, as reflected in Sections 5.1–5.3, and is gratefully acknowledged. References Bostrom, N. (2003). Are you living in a computer simulation? Philosophical Quarterly 53, 243–255. Brahmbhatt, A. (2025). Experimental Validation of Quantum Entanglement on IBM's 156-Qubit Heron Processor: A PBR-Inspired Test of Wave Function Realism. Zenodo DOI: 10.5281/zenodo.17883261. Brahmbhatt, A. (2026a). QuantaCore: A Y⊗Z Stabilizer Basis Migration Architecture for Fault-Tolerant Modular Quantum Computing. U.S. Provisional Patent 63/952,786. Zenodo prior art record DOI: 10.5281/zenodo.18498540. Brahmbhatt, A. (2026b). Y⊗Z Orthogonal Stabilizer Validation on the 156-qubit IBM Kingston Processor. Zenodo DOI: 10.5281/zenodo.19478241. Brahmbhatt, A. (2026c). Drift-Robust Multi-Time Probes on IBM Kingston: Frauchiger–Renner Baseline, Apparent Non-Markovian Signatures, and the Role of Randomized Sampling. Zenodo DOI: 10.5281/zenodo.19673112. Brahmbhatt, A. (2026d). Full-Range Validation of the Frauchiger–Renner Joint-Outcome Probability on a 156-Qubit Superconducting Quantum Processor. Zenodo DOI: 10.5281/zenodo.19682679. Feynman, R. P. (1982). Simulating physics with computers. International Journal of Theoretical Physics 21, 467–488. Lloyd, S. (2006). Programming the Universe: A Quantum Computer Scientist Takes On the Cosmos. New York: Alfred A. Knopf.