Source-linked AI summary
Closing the "Quantum Supremacy" Gap: Achieving Real-Time Simulation of a Random Quantum Circuit Using a New Sunway Supercomputer
Yong, Liu, Xin, Liu, Fang, Li, Haohuan Fu, Yuling Yang, Jiawei Song, Pengpeng Zhao, Zhen Wang, Dajia Peng, Huarong Chen, Chu Guo, Heliang Huang, Wenzhao Wu, Dexun Chen
TL;DR
Classical simulation of entangled random quantum circuits faces exponentially increasing resource requirements and a gap with reported quantum-system sampling times. The paper develops a tensor-based Sunway simulator using optimized contraction, large-scale parallelization, fused operations, and mixed precision. It simulates larger circuits and reduces Google Sycamore sampling to 304 seconds, while its efficiency is lower for Sycamore than for 2N×2N lattice circuits.
Problem
Entangled random quantum circuits create exponentially increasing classical storage and computation requirements, making large-scale simulation difficult.
Method
The paper combines tensor-network slicing and contraction-path optimization with large-scale parallelization, fused tensor operations, and mixed precision on Sunway.
Results
304 seconds brings Google Sycamore sampling to a seconds-scale simulation, while the simulator reaches 10×10×(1+40+1) RQCs.
Takeaways & Limitations
The reported results close classical RQC simulation time to the seconds scale for the compared Sycamore sampling task.
Takeaways & Limitations
Sycamore simulation uses the Sunway machine less efficiently than 2N×2N lattice circuits because of imbalanced tensor contractions.
Abstract
from arXiv · showhide
We develop a high-performance tensor-based simulator for random quantum circuits(RQCs) on the new Sunway supercomputer. Our major innovations include: (1) a near-optimal slicing scheme, and a path-optimization strategy that considers both complexity and compute density; (2) a three-level parallelization scheme that scales to about 42 million cores; (3) a fused permutation and multiplication design that improves the compute efficiency for a wide range of tensor contraction scenarios; and (4) a mixed-precision scheme to further improve the performance. Our simulator effectively expands the scope of simulatable RQCs to include the 10*10(qubits)*(1+40+1)(depth) circuit, with a sustained performance of 1.2 Eflops (single-precision), or 4.4 Eflops (mixed-precision)as a new milestone for classical simulation of quantum circuits; and reduces the simulation sampling time of Google Sycamore to 304 seconds, from the previously claimed 10,000 years.
1 Performance Attributes
The simulator is evaluated by whole-application performance, problem size, precision, and system scale, with single- and mixed-precision results reported.
- 1.2 Eflops in single precision and 4.4 Eflops in mixed precision are the reported performance results.
- 10×10 qubits with depth (1 + 40 + 1) is the reported maximum problem size.
- The measurements cover peak performance and time to solution for the whole application.
- The method simulates random quantum circuits by contracting a tensor network.
- The evaluation uses single precision and mixed precision on 107,520 nodes totaling 41,932,800 cores.
2 Overview of the Problem
Random quantum-circuit simulation is difficult because entanglement creates exponentially increasing classical storage and computation requirements. The paper addresses this challenge with a Sunway simulator that combines tensor-network methods, large-scale parallelism, and mixed precision.
- Entangled random quantum circuits require exponentially increasing classical resources, motivating more efficient simulation methods.
- The paper also motivates classical simulation as support for NISQ development and as a source of algorithmic and architectural innovation.
- The work develops a highly efficient random quantum-circuit simulator for the new generation of Sunway supercomputer.
- The design combines near-optimal slicing, compute-density-aware path optimization, parallelization across about 42 million cores, fused tensor operations, and mixed precision.
- The simulator handles a 10×10-qubit circuit with depth (1 + 40 + 1).
- 304 seconds brings Google Sycamore sampling to a seconds-scale simulation time.
3 Current State of the Art
Classical RQC simulation spans state-vector and tensor-network approaches, each addressing large-circuit constraints differently. Prior work advanced circuit size and sampling speed, while this work reports larger circuits and seconds-scale Sycamore sampling.
- 3.1 General Background of RQC: A qubit is represented as a linear combination of the basis states |0⟩ and |1⟩, with normalized coefficients.
- 3.1 General Background of RQC: Random quantum circuits apply random gate sequences whose number of gate levels defines circuit depth.
- 3.1 General Background of RQC: Entanglement makes classical representation require O(2^n) space for n qubits, creating a major simulation challenge.
- 3.2 Existing Efforts on Simulation of RQCs: State-vector simulators store the full quantum state, but their O(2^n) memory requirement limits scalability.
- 3.2 Existing Efforts on Simulation of RQCs: Tensor approaches contract networks whose tensors encode quantum gates, trading full-state storage for contraction computation.
- 3.2 Existing Efforts on Simulation of RQCs: Prior efforts reached 8×8 depth-40 circuits, 10×10 depth-26 circuits, and Sycamore-oriented simulations ranging from days to minutes.
- 3.4 Summary: The reported simulator reaches 10×10 depth (1+40+1) or 20×20 depth (1+16+1) circuits on a classical supercomputer.
- 3.4 Summary: Similar Sycamore samples are reported within seconds instead of years, enabling real-time simulation for current quantum systems.
4 The New-Generation Sunway Supercomputer
The new Sunway system combines a many-core SW26010P architecture with a tensor-based simulation strategy designed to map computation efficiently across its large parallel scale and constrained memory.
- System architecture: Each SW26010P processor contains six core-groups, each with one management processing element and an 8×8 computing processing element cluster.Each core-group has its own memory controller and 16 GB of DDR4 memory.
- System scale: 107,520 SW26010P CPUs provide a parallel scale of 41,932,800 cores for the largest experiment.The system has 96 GB memory and 307.2 GB/s memory bandwidth per node.
- Motivation: The simulation goal is to map a classical-computer-unfriendly RQC problem onto the world’s largest classical computer.The target combines leading RQCs with a supercomputer containing tens of millions of cores.
- Algorithmic challenge: The algorithm must jointly optimize parallelism, compute complexity, memory complexity, and compute-to-memory ratio for the underlying heterogeneous many-core system.This multi-objective mapping challenge motivates the paper’s algorithmic design.
- Algorithmic challenge: The tensor-based approach is chosen because the state-vector method’s strict memory requirement constrains the supported RQC size.The implementation begins with PEPS and uses heuristic and hyper-optimized contraction-path searches.
- Implementation challenges: Efficient execution also requires parallelizing over more than 40 million cores, tuning diverse tensor kernels, and using mixed precision.These requirements span MPI-process decomposition, CG-level distribution, CPE mapping, and performance scaling.
5 Innovations
The innovations reduce tensor-simulation memory demands while preserving near-optimal complexity, improve path and kernel efficiency, and extend classical RQC simulation to larger circuits and faster sampling.
- 5.1 A PEPS-based Simulation Method with an Optimized Slicing Strategy: Slicing reduces tensor memory requirements and converts one contraction into 2^S independent subtasks for large-scale parallel execution.The method balances memory per MPI process against the aggregate compute increase from parallel subtasks.
- 5.1 A PEPS-based Simulation Method with an Optimized Slicing Strategy: O(L^(3N)) computation is retained while space complexity falls from O(L^(2N)) to O(L^(N+b)) after slicing.The design therefore reduces memory requirements while keeping computational complexity near the minimized-space baseline.
- 5.1 A PEPS-based Simulation Method with an Optimized Slicing Strategy: For a 2N×2N network, the heuristic keeps tensor rank within N+b and uses S = 3(N−b)/2 sliced hyperedges.Here b is determined by whether N is odd or even, and the resulting contraction complexity is L^(3(N+b)/2).
- 5.1 A PEPS-based Simulation Method with an Optimized Slicing Strategy: The simulator computes 512 amplitudes per batch with only 0.01% overhead to reduce the cost of producing many samples.The approach addresses the need to simulate more amplitudes for classical correct sampling than for cross-entropy verification.
- 5.2 Searching for Better Contraction Paths with a Reduced Complexity: Contraction-path quality is central because different paths for complex RQC tensor networks can differ in computational complexity by orders of magnitude.The paper treats path selection as a multi-objective problem involving both complexity and tensor ranks suited to the many-core architecture.
- 5.2 Searching for Better Contraction Paths with a Reduced Complexity: Google Sycamore receives a complexity reduction of around a million times, compared with only ten times for the 10×10×(1+40+1) RQC.The result reflects CoTenGra’s better-optimized path for Sycamore relative to the target lattice circuit.
- 5.4 Tensor Contraction Using Fused Permutation and Multiplication: Fusing tensor permutation with multiplication reduces DMA load and store costs while balancing RMA and DMA efficiency.The design targets high-compute-density tensor contractions on the CPE array.
6 Performance Results
The Sunway simulator combines tensor-kernel optimization, slicing-based parallelism, and precision choices to sustain high performance across varied RQC contractions. It scales nearly linearly to 41,932,800 cores while preserving statistical fidelity.
- Accuracy: Both single-precision and mixed-precision simulations fit the theoretical Porter-Thomas distribution and show similar statistical fidelity.The validation uses 12,288 amplitudes from a 10 × 10 × (1 + 16 + 1) RQC.
- Node-level performance: Fused permutation and multiplication reaches over 90% efficiency and nearly 4.4 Tflops for compute-intensive PEPS tensor cases.These cases typically have ranks around 5 and dimension size 32.
- Node-level performance: 0.2 Tflops versus 4.4 Tflops distinguishes memory-bound Sycamore contractions from dense PEPS contractions.Sycamore cases use rank-30 and rank-4 tensors with dimension size 2, but optimization achieves near-full memory-bandwidth utilization.
- Node-level performance: Permutation handling contributes most performance improvement, while aggregating CPE memory requests further optimizes CoTenGra-generated memory-bound cases.The design fuses permutation with multiplication and aggregates loads and stores from different CPEs.
- Scaling: Strong scaling is nearly linear from 199,680 to 41,932,800 cores across three RQC types and both precision configurations.The slicing scheme creates many independent tasks that are distributed across nodes and reduced globally at the end.
- Scaling: Sycamore uses the Sunway machine less efficiently than 2N by 2N lattice circuits because its tensor contractions are imbalanced.The limitation is attributed to the contraction cases generated for Sycamore.
7 Implication
The work maps large RQCs onto about 42 million Sunway cores through combined algorithmic and architectural optimizations. It reaches exascale performance and completes Google Sycamore sampling in 304 seconds, while identifying tensor balance as a remaining constraint.
- Implication: The simulator maps square RQCs from 10×10 qubits at depth (1+40+1) to 20×20 qubits at depth (1+16+1) onto around 42 million cores.The mapping combines algorithmic and architecture-related optimizations.
- Implication: The fused permutation-multiplication workflow improves computing efficiency by around 40% across compute-intensive and memory-bound contraction cases.It removes or hides most data-movement overhead in high-rank permutations.
- Implication: 1.2 Eflops in single precision and 4.4 Eflops in mixed precision are sustained for the 10×10×(1+40+1) circuit.The comparison reports these results alongside earlier work on smaller circuits.
- Implication: 304 seconds is the reported time for sampling Google Sycamore with the simulator.The current performance is constrained by relatively inefficient contraction of CoTenGra-generated tensors, and balanced tensors could improve speed by another factor of 4 to 5.
- Implication: The work combines prior algorithmic improvements with better slicing, contraction paths, and fused tensor operations to bring quantum-system sampling to the scale of seconds.The paper frames this as narrowing the gap between quantum-computing claims and classical simulation time.
- Implication: The authors expect a real-time simulator to support future quantum-system development and potentially accelerate more complex quantum-computing designs.This is presented as a potential consequence rather than a demonstrated outcome.
A Technical Details on Comparing Our Simulator Against the Google Sycamore Quantum Processor
The comparison explains how classical simulation approximates Sycamore’s sampling task by computing amplitudes and then sampling from their probabilities. The reported 304-second run uses a correlated amplitude batch, while related scaling arguments address broader sampling comparisons.
- Comparison setup: Sycamore’s most difficult sampling task is generating 1 million bitstrings from a 20-cycle RQC with estimated XEB fidelity of 0.2%.The low fidelity is noted as arising mainly from quantum-processor error.
- Comparison setup: Classical computers compute amplitudes for bitstrings and then perform an additional sampling process based on those amplitudes.This differs from quantum processors, which directly generate samples through measurement.
- Reported experiment: 304 seconds is the mixed-precision runtime for computing a single large batch of 2^21 correlated amplitudes on Sunway.The experiment targets more than 40,000,000 cores and compares performance with the previous approach.
- Comparison scope: Scaling 304 seconds by 2,000 gives 7 days as a naive comparison for a larger sampling target.The passage contrasts this with the greater information content of 2,000 exact-probability samples.
- Comparison scope: Reuse of intermediate tensor-network results is reported to provide 20x to 10,000x speedups for uncorrelated bitstrings in 12- to 16-cycle RQCs.The comparison concerns later work and a naive approach.
- Numerical experiment: The experiment fixes 32 qubits, exhausts the remaining qubits, and reports an XEB value of 0.741 for the resulting bitstrings.Five amplitudes and their corresponding bitstrings are listed for reference.