[Paper Review] Simulating the Sycamore quantum supremacy circuits

Feng Pan, Pan Zhang|arXiv (Cornell University)|Mar 4, 2021

Quantum Computing Algorithms and Architecture20 references45 citations

TL;DR

The paper proposes a big-head tensor-network method to compute amplitudes and probabilities for a large number of correlated bitstrings in Google's Sycamore circuits, achieving 2,097,152 bitstrings on 53 qubits and 20 cycles using 60 GPUs in about 5 days with high XEB fidelity.

ABSTRACT

We propose a general tensor network method for simulating quantum circuits. The method is massively more efficient in computing a large number of correlated bitstring amplitudes and probabilities than existing methods. As an application, we study the sampling problem of Google's Sycamore circuits, which are believed to be beyond the reach of classical supercomputers and have been used to demonstrate quantum supremacy. Using our method, employing a small computational cluster containing 60 graphical processing units (GPUs), we have generated one million correlated bitstrings with some entries fixed, from the Sycamore circuit with 53 qubits and 20 cycles, with linear cross-entropy benchmark (XEB) fidelity equals 0.739, which is much higher than those in Google's quantum supremacy experiments.

Motivation & Objective

• Develop a general tensor-network framework to simulate quantum circuits with a focus on efficiently computing many correlated bitstring amplitudes and probabilities.
• Address the sampling problem for Google's Sycamore circuits by enabling exact amplitude/probability computation for large bitstring sets.
• Improve scalability over state-vector and traditional tensor-network approaches through subspace enumeration and contraction bottlenecks (big-head simulation).
• Demonstrate practical classical computation of a large number of correlated samples for 53-qubit, 20-cycle Sycamore circuits and compare to hardware-based sampling.

Proposed method

• Represent quantum circuits as tensor networks and contract them to obtain bitstring amplitudes.
• Partition the tensor network into head and tail subgraphs connected by a bottleneck cut to reuse head contractions across many tail configurations.
• Enumerate or slice open qubits to generate 2^n2 correlated bitstrings with controlled space-time complexity.
• Find contraction orders that realize the big-head structure, enabling reuse of head-vector contractions for all s2 configurations.
• Apply dynamic slicing to break large contractions into 2^ne subtasks that fit GPU memory, enabling parallel execution.

Experimental results

Research questions

• RQ1 Can a tensor-network approach efficiently produce a very large set of correlated bitstring amplitudes for deep quantum circuits like Sycamore?
• RQ2 How can contraction orders be engineered to create a bottleneck (big-head) structure allowing reuse of partial contractions across many bitstrings?
• RQ3 What is the trade-off between open-qubit count, memory usage, and time complexity when sampling large numbers of bitstrings?
• RQ4 How does the resulting XEB fidelity of classically generated bitstrings compare to Google's hardware samples?
• RQ5 Is it feasible to scale this approach to large-depth, high-qubit circuits with current GPU resources?

Key findings

• The authors computed exact amplitudes and probabilities for 2,097,152 correlated bitstrings (2^21) from a 53-qubit, 20-cycle Sycamore circuit using a 60-GPU cluster in ~5 days.
• By fixing 32 bits and enumerating 21 remaining bits, they obtained an XEB fidelity of 0.739 on 1,000,000 post-selected bitstrings, surpassing Google’s hardware samples.
• The method achieves an XEB distribution close to Porter-Thomas with F_XEB ≈ -0.000926 for the full 2^21 sample set before post-selection.
• Compared to other methods, their approach yields lower overall computational cost for generating 2 million bitstrings than the Schrödinger-Feynman method reported by Google and the 64-amplitude tensor-network approach, while providing exact amplitudes for all sampled bitstrings.
• The approach is massively parallelizable across GPUs and demonstrates superior performance for generating large correlated bitstring sets, though it remains exponential in depth and qubit count.