A Herculean task: Classical simulation of quantum computers

Xiaosi Xu,1 Simon Benjamin,2 Jinzhao Sun,3 Xiao Yuan,4, 5 and Pan Zhang6, 7, 8
1
Graduate School of China Academy of Engineering Physics, Beijing 100193, China
2
Department of Materials, University of Oxford, Parks Road, Oxford OX1 3PH, United Kingdom
3
QOLS, Blackett Laboratory, Imperial College London, London SW7 2AZ, United Kingdom
4
Center on Frontiers of Computing Studies, Peking University, Beijing 100871, China
5
School of Computer Science, Peking University, Beijing 100871, China
6
CAS Key Laboratory for Theoretical Physics, Institute of Theoretical Physics,
Chinese Academy of Sciences, Beijing 100190, China
7
School of Fundamental Physics and Mathematical Sciences,
Hangzhou Institute for Advanced Study, UCAS, Hangzhou 310024, China
8
International Center for Theoretical Physics Asia-Pacific, Beijing/Hangzhou, China
arXiv:2302.08880v1 [quant-ph] 17 Feb 2023

In the effort to develop useful quantum computers, simulating quantum machines with conven-
tional computing resources is a key capability. Such simulations will always face limits, preventing
the emulation of quantum computers of substantial scale; but by pushing the envelope as far as
possible through optimal choices of algorithms and hardware, the value of the simulator tool is
maximized. This work reviews the state-of-the-art numerical simulation methods, i.e., the classical
algorithms that emulate quantum computer evolution under specific operations. We focus on the
mainstream state-vector and tensor-network paradigms, while briefly mentioning alternative meth-
ods. Moreover, we review the diverse applications of simulation across different facets of quantum
computer development, such as understanding the fundamental difference between quantum and
classical computations, exploring algorithm design spaces for quantum advantage, predicting quan-
tum processor performance at the design stage, and characterizing fabricated devices efficiently for
fast iterations. This review complements recent surveys on today’s tools and implementations; here,
we seek to acquaint the reader with an essential understanding of the theoretical basis of classical
simulations, detailed discussions on the advantages and limitations of different methods, and the
demands and challenges arising from practical use cases.

I. INTRODUCTION

The invention of classical computers is undoubtedly one of the most significant breakthroughs in human history, and
has brought revolutionary change to almost every aspect of life. Despite the remarkable success, classical computers
are limited by memory and run time for many vital problems. On the other hand, quantum computers are believed
to be able to bypass this scaling issue in various important cases and consequently there is the prospect that quantum
processors will surpass classical systems in certain tasks. This concept is known as “quantum advantage”. Recent
advancements in quantum hardware have resulted in the creation of quantum processors with hundreds of qubits, and
there have been multiple claims that quantum advantage has been achieved with various types of quantum devices [1–
3]. These achievements signify the beginning of the era of noisy intermediate-scale quantum (NISQ) devices.
In the efforts to push the field forward, classical computations play an essential role in assisting and accelerating
the development of quantum computers. One can distinguish two basic categories:
1. Classical simulation is a fundamental aspect of understanding and design of quantum hardware, frequently
serving as the only means to validate these quantum systems;
2. Quantum algorithms can be implemented on classical simulators for testing and verification purposes while full-
fledged quantum computers are beyond reach. Classical simulators emulate the behavior of quantum computers
and simulate the processes as if running on a real quantum device.
Despite the development of numerous efficient classical simulators, there is a persistent need to simulate larger quantum
systems. As quantum hardware has progressed to the point where it is no longer amenable to classical simulation[1, 3,
4], advancements in simulation capabilities that allow for the modeling of larger subsystems can offer valuable insights
into many-body interactions, resulting in more accurate predictions of the performance of quantum algorithms and
the behavior of quantum systems themselves.
Furthermore, it is important to continually push the limits of classical simulation, in order to understand the
boundary between classical and quantum computations and to define the thresholds for practical quantum advantage.
This review examines practical use cases in quantum computer development that drive the demand for faster
classical simulation of larger quantum systems, ranging from quantum processor design [5–7], hardware validations [8,
9], and characterizations [10, 11], to quantum algorithm design and validation [12–15], and quantum advantage
demonstrations [1–3].
 2

As different use cases focus on different aspects of the quantum system, a large variety of classical methods exist
that cannot be fully described in this single review. This review prioritizes the most general and widely-accepted
circuit-based simulation methods for digital (versus analog) quantum computation, while others aimed for specific
hardware including adiabatic simulation [16] and continuous variables [17] are beyond the scope of this review.
There are several targets for classically simulating quantum computers. A seemingly natural choice is obtaining full
information content of the final quantum state |ψi; however, due to the exponential computational cost and memory
requirement, this is affordable only for circuits with a small number of qubits. In many application scenarios, storing
the entire state is unnecessary. For example, for stabilizer circuits that are commonly used in quantum error correction,
one can convert the final-state-finding problem to the update of the set of Pauli operators that stabilize the state, using
computational resources scaling polynomially to the number of qubits. In variational quantum eigensolver (VQE) [18]
and quantum approximate optimization algorithm (QAOA) [19] simulations, as only the energy expectation is needed,
circuits can be computed using, e.g., tensor network contractions with very limited storage [20, 21]. In fact, many
simulation methods have purpose-driven designs, and thus are appropriate for some specific application regime.
For most application regimes, the different simulation methods can be categorized into four groups: exact and
approximate, noiseless and noisy methods. As the names suggest, exact methods output accurate computation
results, while approaches to get approximate results also exist with the benefit of cost reduction. Investigations into
the in-principle performance of ideal hardware will employ a noiseless circuit, while noise should be considered in a
more realistic scenario. Table 1 summarizes the important measures for different classical simulation methods.

Table I. Comparison between different simulation methods, where N is the number of qubits,
m is the number of gates, χ is the bond dimension of MPS, mT is the number of T gates in
the circuit, and W denotes the tree-width of the graph associated with the quantum circuit.

Approx. or Noiseless
Methods Memory Run time exact or noisy Application regime
State- worst General, good for
Full vector worst O(2N ) O(m2N ) Exact Noiseless# small circuits*
state Density- worst worst General, good for
matrix O(22N ) O(m22N ) Exact Both small circuits+
General, good for
MPS state/MPO O(N χ2 ) O(N χ6 ) Approx. Noisy shallow circuits
General, good for
Tensor network On demand O(eW ) Both Both shallow circuits
Circuits dominated
with Clifford gates,
Stabilizer O(emT ) O(emT ) Approx. Both particularly in QEC
#
State-vector simulators can also be used to simulate noisy circuits to get an approximate
result with the Monte Carlo method.
*
Circuits with N > 32 with the state-vector simulator should generally run on an HPC server.
+
Circuits with N > 16 with the density-matrix simulator should generally run on an HPC
server.

II. SIMULATION METHODS

A. Full state

The straightforward approach to simulate a quantum circuit is to record the full information of the quantum state
and the changes as it evolves. Methods of full-state simulation include exact representations such as state vector and
density matrix, and approximate ones such as matrix product state (operator) and neural network.

1. Exact methods

In the state-vector formalism, the state of an N -qubit quantum register is represented by a 2N -dimensional vector
of complex values. Performing universal quantum computation on a digital quantum computer involves a sequence of
 3

unitary operations applied to a quantum state. The full-state simulator, or Schrödinger simulator, takes the brute-
force method to simulate a quantum circuit, where the entire vector of a quantum state is recorded and updated
during the simulation process. The update of a quantum state can be done efficiently for gates in the Clifford group,
as suggested by the Gottesman-Knill theorem. For example, for X and CNOT gates, one only needs to swap the
amplitudes. However, the realization of universal quantum computation requires an additional non-Clifford gate, the
common choice of which is the T gate. In the worst case with arbitrary unitary gates, the time and memory cost
of a full-state simulation scale exponentially with the number of qubits. Typically 16 bytes are needed per complex
number and thus an N -qubit full-state vector in a naive implementation requires 2N +4 bytes, equivalent to 2N +4−30
GB of memory needed to perform such simulation. As a result, a personal laptop equipped with 16 GB of memory
will be capable of simulating up to about 30 qubits.

Box 1: Quantum gates, channels and circuits

The matrix form of some important quantum gates:

   
        1 0 0 0 1 0 0 0
0 1 1 1 1 0 1 0 0 1 0 0 0 1 0 0
X= , H = √12 , S= , T= , CNOT =  , CZ =  .
1 0 1 −1 0 i 0 eiπ/4 0 0 0 1 0 0 1 0
0 0 1 0 0 0 0 −1

Clifford gates: quantum gates that belong to the Clifford group, which is a group of unitary operators that
can map Pauli gates to Pauli gates.

Kraus channel: a quantum channel that is described by Kraus representation, where the state ρ is evolved
P P
under ξ(ρ) = k Kk ρKk† . The {Kk } are called Kraus operators; and ξ is trace preserving if k Kk† Kk = 1.

Quantum circuit: Best illustrated by an example; the circuit below generates a GHZ state.
|0i H

|000i+|111i
|0i H H √
2

|0i H H

In a more realistic scenario where noise is considered, one can perform an exact simulation with a mixed-state
simulator. In this case, the state is expressed in the form of a density matrix and evolves under Kraus channels. The
complexity of mixed-state simulations scales O(m22N ) where m is the number of quantum gates.
With the demanding memory cost as the system size increases, full-state simulators are not capable of simulating
large quantum circuits. On the other hand, some approximations can be made to enable simulations of larger quantum
systems at the cost of accuracy or run time. One ubiquitous example is modeling noisy circuits using the Monte Carlo
method with a pure-state simulator, where the aggregated result of an adequate number of trials can well-approximate
the exact result. This method can be further optimized to reduce the computational redundancy by pre-analyzing the
noisy circuit and recording the most commonly-appearing intermediate state under noise [22]. Besides, various efforts
have been made at the algorithmic level to optimize the full-state simulation. These include an adaptive encoding
scheme [23] based on the polar representation that can reduce the memory to store a quantum state, at the cost of
increasing the run time to perform the encoding and decoding steps; and a low-rank decomposition method [24] to
simulate noisy quantum circuits with density-matrix evolution where the density matrix is decomposed into a low-rank
matrix with the most important columns.
Other algorithmic optimizations include methods designed for special-purpose simulations [25, 26] or for circuits
with a specific structure [27, 28]. Moreover, optimizations at the implementation levels are also employed in practice,
including parallelization using multithread [23], acceleration with GPUs [29], simulation reordering [30], etc.

2. Approximate methods

In many quantum applications of interest, evolved quantum states are highly-structured and of low Schmidt rank,
leading to a significant reduction in space and time complexity when storing and evolving them [28]. A widely used
approach in quantum information and quantum many-body physics is matrix product states (MPS) [31, 32] (also known
 4

as tensor train in mathematics [33, 34]), and its mixed-state analog is matrix product operator (MPO) [35], which is
closely related to the density matrix renormalization group (DMRG) method [36]. The MPS method represents the
state using the contraction of three-way tensors with size 2χ2 (and matrices on the boundary), as depicted in Box
2.

Box 2: Tensor Network Diagram

A
<latexit sha1_base64="K9tF4jJzObPOo63BzXI/oQt4724=">AAACzXicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVlx484K9oG2yGQ6rcHJg2QilKpbf8Ct/pb4B/oX3hlTUIvohCRnzr3nzNx7vVj6qXKc14I1NT0zO1ecLy0sLi2vlFfXmmmUJVw0eCSjpO2xVEg/FA3lKynacSJY4EnR8q6PdLx1I5LUj8IzNYxFN2CD0O/7nCmizjsBU1ecSfvwslxxqo5Z9iRwc1BBvupR+QUd9BCBI0MAgRCKsARDSs8FXDiIietiRFxCyDdxgTuUSJtRlqAMRuw1fQe0u8jZkPbaMzVqTqdIehNS2tgiTUR5CWF9mm3imXHW7G/eI+Op7zakv5d7BcQqXBH7l26c+V+drkWhjwNTg081xYbR1fHcJTNd0Te3v1SlyCEmTuMexRPC3CjHfbaNJjW1694yE38zmZrVe57nZnjXt6QBuz/HOQmaO1V3r+qe7lZqTj7qIjawiW2a5z5qOEYdDfIO8YgnPFsnVmbdWvefqVYh16zj27IePgA3i5Lq</latexit>

B C
<latexit sha1_base64="+S3EpXLAd0HdlePegpNqJhY6W/4=">AAACzXicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVl0484K9oG2yGQ6rcHJg2QilKpbf8Ct/pb4B/oX3hlTUIvohCRnzr3nzNx7vVj6qXKc14I1NT0zO1ecLy0sLi2vlFfXmmmUJVw0eCSjpO2xVEg/FA3lKynacSJY4EnR8q6PdLx1I5LUj8IzNYxFN2CD0O/7nCmizjsBU1ecSfvwslxxqo5Z9iRwc1BBvupR+QUd9BCBI0MAgRCKsARDSs8FXDiIietiRFxCyDdxgTuUSJtRlqAMRuw1fQe0u8jZkPbaMzVqTqdIehNS2tgiTUR5CWF9mm3imXHW7G/eI+Op7zakv5d7BcQqXBH7l26c+V+drkWhjwNTg081xYbR1fHcJTNd0Te3v1SlyCEmTuMexRPC3CjHfbaNJjW1694yE38zmZrVe57nZnjXt6QBuz/HOQmaO1V3r+qe7lZqTj7qIjawiW2a5z5qOEYdDfIO8YgnPFsnVmbdWvefqVYh16zj27IePgA565Lr</latexit> <latexit sha1_base64="eOoTF6pq5LsPyB2qylnp98J6iZQ=">AAACzXicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVnoxp0V7ANrkcl0WgfzIpkIperWH3CrvyX+gf6Fd8YU1CI6IcmZc+85M/deL/ZlqhzntWDNzM7NLxQXS0vLK6tr5fWNVhplCRdNHvlR0vFYKnwZiqaSyhedOBEs8HzR9q7rOt6+EUkqo/BMjWLRC9gwlAPJmSLq/CJg6ooz365flitO1THLngZuDirIVyMqv+ACfUTgyBBAIIQi7IMhpacLFw5i4noYE5cQkiYucIcSaTPKEpTBiL2m75B23ZwNaa89U6PmdIpPb0JKGzukiSgvIaxPs008M86a/c17bDz13Ub093KvgFiFK2L/0k0y/6vTtSgMcGRqkFRTbBhdHc9dMtMVfXP7S1WKHGLiNO5TPCHMjXLSZ9toUlO77i0z8TeTqVm953luhnd9Sxqw+3Oc06C1V3UPqu7pfqXm5KMuYgvb2KV5HqKGYzTQJO8Qj3jCs3ViZdatdf+ZahVyzSa+LevhAzxLkuw=</latexit>

i ↵ i
<latexit sha1_base64="YWnQqMVNmAxH0HDfLFUQlmEeVtM=">AAACxHicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVkQxGUL9gG1SDKd1qHTJEwmQin6A27128Q/0L/wzpiCWkQnJDlz7j1n5t4bJlKk2vNeC87C4tLySnG1tLa+sblV3t5ppXGmGG+yWMaqEwYplyLiTS205J1E8WAcSt4OR+cm3r7jKhVxdKUnCe+Ng2EkBoIFmqiGuClXvKpnlzsP/BxUkK96XH7BNfqIwZBhDI4ImrBEgJSeLnx4SIjrYUqcIiRsnOMeJdJmlMUpIyB2RN8h7bo5G9HeeKZWzegUSa8ipYsD0sSUpwib01wbz6yzYX/znlpPc7cJ/cPca0ysxi2xf+lmmf/VmVo0BjizNQiqKbGMqY7lLpntirm5+6UqTQ4JcQb3Ka4IM6uc9dm1mtTWbnob2PibzTSs2bM8N8O7uSUN2P85znnQOqr6J1W/cVypefmoi9jDPg5pnqeo4RJ1NK33I57w7Fw40kmd7DPVKeSaXXxbzsMHRAqPYg==</latexit> <latexit sha1_base64="YWnQqMVNmAxH0HDfLFUQlmEeVtM=">AAACxHicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVkQxGUL9gG1SDKd1qHTJEwmQin6A27128Q/0L/wzpiCWkQnJDlz7j1n5t4bJlKk2vNeC87C4tLySnG1tLa+sblV3t5ppXGmGG+yWMaqEwYplyLiTS205J1E8WAcSt4OR+cm3r7jKhVxdKUnCe+Ng2EkBoIFmqiGuClXvKpnlzsP/BxUkK96XH7BNfqIwZBhDI4ImrBEgJSeLnx4SIjrYUqcIiRsnOMeJdJmlMUpIyB2RN8h7bo5G9HeeKZWzegUSa8ipYsD0sSUpwib01wbz6yzYX/znlpPc7cJ/cPca0ysxi2xf+lmmf/VmVo0BjizNQiqKbGMqY7lLpntirm5+6UqTQ4JcQb3Ka4IM6uc9dm1mtTWbnob2PibzTSs2bM8N8O7uSUN2P85znnQOqr6J1W/cVypefmoi9jDPg5pnqeo4RJ1NK33I57w7Fw40kmd7DPVKeSaXXxbzsMHRAqPYg==</latexit>

l l
<latexit sha1_base64="7PuhJC0zpFY2Gu00KpkZZovbhIA=">AAACxHicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVkQxGUL9gG1SDKd1tBpEjIToRT9Abf6beIf6F94Z5yCWkQnJDlz7j1n5t4bpiKSyvNeC87C4tLySnG1tLa+sblV3t5pySTPGG+yRCRZJwwkF1HMmypSgnfSjAfjUPB2ODrX8fYdz2SUxFdqkvLeOBjG0SBigSKqIW7KFa/qmeXOA9+CCuyqJ+UXXKOPBAw5xuCIoQgLBJD0dOHDQ0pcD1PiMkKRiXPco0TanLI4ZQTEjug7pF3XsjHttac0akanCHozUro4IE1CeRlhfZpr4rlx1uxv3lPjqe82oX9ovcbEKtwS+5dulvlfna5FYYAzU0NENaWG0dUx65Kbruibu1+qUuSQEqdxn+IZYWaUsz67RiNN7bq3gYm/mUzN6j2zuTne9S1pwP7Pcc6D1lHVP6n6jeNKzbOjLmIP+zikeZ6ihkvU0TTej3jCs3PhCEc6+WeqU7CaXXxbzsMHSyqPZQ==</latexit> <latexit sha1_base64="7PuhJC0zpFY2Gu00KpkZZovbhIA=">AAACxHicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVkQxGUL9gG1SDKd1tBpEjIToRT9Abf6beIf6F94Z5yCWkQnJDlz7j1n5t4bpiKSyvNeC87C4tLySnG1tLa+sblV3t5pySTPGG+yRCRZJwwkF1HMmypSgnfSjAfjUPB2ODrX8fYdz2SUxFdqkvLeOBjG0SBigSKqIW7KFa/qmeXOA9+CCuyqJ+UXXKOPBAw5xuCIoQgLBJD0dOHDQ0pcD1PiMkKRiXPco0TanLI4ZQTEjug7pF3XsjHttac0akanCHozUro4IE1CeRlhfZpr4rlx1uxv3lPjqe82oX9ovcbEKtwS+5dulvlfna5FYYAzU0NENaWG0dUx65Kbruibu1+qUuSQEqdxn+IZYWaUsz67RiNN7bq3gYm/mUzN6j2zuTne9S1pwP7Pcc6D1lHVP6n6jeNKzbOjLmIP+zikeZ6ihkvU0TTej3jCs3PhCEc6+WeqU7CaXXxbzsMHSyqPZQ==</latexit>

<latexit sha1_base64="KI7m725LZTjlItB3U/p/0lEwkuY=">AAACyXicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVlwI7ipYB/QFplMp+1omsRkItbiyh9wqz8m/oH+hXfGFNQiOiHJmXPvOTP3Xi/yZaIc5zVnzczOzS/kFwtLyyura8X1jXoSpjEXNR76Ydz0WCJ8GYiaksoXzSgWbOj5ouFdHet440bEiQyDczWKRGfI+oHsSc4UUfU286MBuyiWnLJjlj0N3AyUkK1qWHxBG12E4EgxhEAARdgHQ0JPCy4cRMR1MCYuJiRNXOAeBdKmlCUogxF7Rd8+7VoZG9BeeyZGzekUn96YlDZ2SBNSXkxYn2abeGqcNfub99h46ruN6O9lXkNiFQbE/qWbZP5Xp2tR6OHI1CCppsgwujqeuaSmK/rm9peqFDlExGncpXhMmBvlpM+20SSmdt1bZuJvJlOzes+z3BTv+pY0YPfnOKdBfa/sHpTds/1SxclGnccWtrFL8zxEBSeookbel3jEE56tU+vaurXuPlOtXKbZxLdlPXwAtmWRjQ==</latexit>

j
<latexit sha1_base64="cAmzrHvACccFM8trmnbopBcAZ/8=">AAACxHicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVkQxGUL9gFaJEmndew0CZOJUIr+gFv9NvEP9C+8M05BLaITkpw5954zc+8NU8Ez5XmvBWdufmFxqbhcWlldW98ob261siSXEWtGiUhkJwwyJnjMmoorwTqpZMEoFKwdDk91vH3HZMaT+EKNU9YdBYOY93kUKKIat9flilf1zHJngW9BBXbVk/ILrtBDggg5RmCIoQgLBMjouYQPDylxXUyIk4S4iTPco0TanLIYZQTEDuk7oN2lZWPaa8/MqCM6RdArSelijzQJ5UnC+jTXxHPjrNnfvCfGU99tTP/Qeo2IVbgh9i/dNPO/Ol2LQh8npgZONaWG0dVF1iU3XdE3d79UpcghJU7jHsUl4cgop312jSYzteveBib+ZjI1q/eRzc3xrm9JA/Z/jnMWtA6q/lHVbxxWap4ddRE72MU+zfMYNZyjjqbxfsQTnp0zRziZk3+mOgWr2ca35Tx8AEZqj2M=</latexit>

k X
<latexit sha1_base64="dDKskAYKHSMD1w2hFDX0ezAQFSk=">AAACxHicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVkQxGUL9gG1SDKd1qFpEmYmQin6A27128Q/0L/wzpiCWkQnJDlz7j1n5t4bppFQ2vNeC87C4tLySnG1tLa+sblV3t5pqSSTjDdZEiWyEwaKRyLmTS10xDup5ME4jHg7HJ2bePuOSyWS+EpPUt4bB8NYDAQLNFGN0U254lU9u9x54OeggnzVk/ILrtFHAoYMY3DE0IQjBFD0dOHDQ0pcD1PiJCFh4xz3KJE2oyxOGQGxI/oOadfN2Zj2xlNZNaNTInolKV0ckCahPEnYnObaeGadDfub99R6mrtN6B/mXmNiNW6J/Us3y/yvztSiMcCZrUFQTallTHUsd8lsV8zN3S9VaXJIiTO4T3FJmFnlrM+u1Shbu+ltYONvNtOwZs/y3Azv5pY0YP/nOOdB66jqn1T9xnGl5uWjLmIP+zikeZ6ihkvU0bTej3jCs3PhRI5yss9Up5BrdvFtOQ8fSMqPZA==</latexit>

j
<latexit sha1_base64="cAmzrHvACccFM8trmnbopBcAZ/8=">AAACxHicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVkQxGUL9gFaJEmndew0CZOJUIr+gFv9NvEP9C+8M05BLaITkpw5954zc+8NU8Ez5XmvBWdufmFxqbhcWlldW98ob261siSXEWtGiUhkJwwyJnjMmoorwTqpZMEoFKwdDk91vH3HZMaT+EKNU9YdBYOY93kUKKIat9flilf1zHJngW9BBXbVk/ILrtBDggg5RmCIoQgLBMjouYQPDylxXUyIk4S4iTPco0TanLIYZQTEDuk7oN2lZWPaa8/MqCM6RdArSelijzQJ5UnC+jTXxHPjrNnfvCfGU99tTP/Qeo2IVbgh9i/dNPO/Ol2LQh8npgZONaWG0dVF1iU3XdE3d79UpcghJU7jHsUl4cgop312jSYzteveBib+ZjI1q/eRzc3xrm9JA/Z/jnMWtA6q/lHVbxxWap4ddRE72MU+zfMYNZyjjqbxfsQTnp0zRziZk3+mOgWr2ca35Tx8AEZqj2M=</latexit>

k
<latexit sha1_base64="dDKskAYKHSMD1w2hFDX0ezAQFSk=">AAACxHicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVkQxGUL9gG1SDKd1qFpEmYmQin6A27128Q/0L/wzpiCWkQnJDlz7j1n5t4bppFQ2vNeC87C4tLySnG1tLa+sblV3t5pqSSTjDdZEiWyEwaKRyLmTS10xDup5ME4jHg7HJ2bePuOSyWS+EpPUt4bB8NYDAQLNFGN0U254lU9u9x54OeggnzVk/ILrtFHAoYMY3DE0IQjBFD0dOHDQ0pcD1PiJCFh4xz3KJE2oyxOGQGxI/oOadfN2Zj2xlNZNaNTInolKV0ckCahPEnYnObaeGadDfub99R6mrtN6B/mXmNiNW6J/Us3y/yvztSiMcCZrUFQTallTHUsd8lsV8zN3S9VaXJIiTO4T3FJmFnlrM+u1Shbu+ltYONvNtOwZs/y3Azv5pY0YP/nOOdB66jqn1T9xnGl5uWjLmIP+zikeZ6ihkvU0bTej3jCs3PhRI5yss9Up5BrdvFtOQ8fSMqPZA==</latexit>

<latexit sha1_base64="pzq+kz8Sil+tlmfVnJyNFYidUbI=">AAADD3icjVHLSsQwFD3W93vUpZviILgaWhF1I/jYiCsFRwVHhjRGJ076oE0FGeYj/BN37sStP6C40qX+hTexIz4QTWl7cu45J7lJkCiZac977HK6e3r7+gcGh4ZHRsfGSxOTe1mcp1xUeazi9CBgmVAyElUttRIHSSpYGCixHzQ3TH3/XKSZjKNdfZGIo5CdRvJEcqaJqpe2alke1ls1ppIGa9dCphucKXet3pJn38n1js5tqvbKB71htMTUS2Wv4tnh/gR+AcooxnZcekANx4jBkSOEQARNWIEho+cQPjwkxB2hRVxKSNq6QBtD5M1JJUjBiG3S95RmhwUb0dxkZtbNaRVFb0pOF7PkiUmXEjarubae22TD/pbdsplmbxf0D4qskFiNBrF/+TrK//pMLxonWLY9SOopsYzpjhcpuT0Vs3P3U1eaEhLiDD6mekqYW2fnnF3ryWzv5myZrb9YpWHNnBfaHK9ml3TB/vfr/An25iv+YsXfWSivrhdXPYBpzGCO7nMJq9jENqqUfYV7POHZuXSunRvn9l3qdBWeKXwZzt0bAk6uwg==</latexit>

scalar vector matrix 3-way tensor Aij↵ B↵kl = Cijkl

↵

<latexit sha1_base64="xvGl0PYz5BSHIsNFrk8fuv6bucE=">AAACzXicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVlw484K9oFtKZPptA3Ni2QilFq3/oBb/S3xD/QvvDOmoBbRCUnOnHvPmbn3OpHnJtKyXnPGwuLS8kp+tbC2vrG5VdzeqSdhGnNR46EXxk2HJcJzA1GTrvREM4oF8x1PNJzRuYo3bkWcuGFwLceR6PhsELh9lzNJ1E2bedGQdSf2tFssWWVLL3Me2BkoIVvVsPiCNnoIwZHCh0AASdgDQ0JPCzYsRMR1MCEuJuTquMAUBdKmlCUogxE7ou+Adq2MDWivPBOt5nSKR29MShMHpAkpLyasTjN1PNXOiv3Ne6I91d3G9HcyL59YiSGxf+lmmf/VqVok+jjTNbhUU6QZVR3PXFLdFXVz80tVkhwi4hTuUTwmzLVy1mdTaxJdu+ot0/E3nalYtedZbop3dUsasP1znPOgflS2T8r21XGpYmWjzmMP+zikeZ6iggtUUSPvAI94wrNxaaTGnXH/mWrkMs0uvi3j4QP8oZM9</latexit>

↵1 <latexit sha1_base64="+C7u3w1DIgvipR8VhNFsJj5adnQ=">AAACzXicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVlw484K9oFtKZPptA3Ni2QilFq3/oBb/S3xD/QvvDOmoBbRCUnOnHvPmbn3OpHnJtKyXnPGwuLS8kp+tbC2vrG5VdzeqSdhGnNR46EXxk2HJcJzA1GTrvREM4oF8x1PNJzRuYo3bkWcuGFwLceR6PhsELh9lzNJ1E2bedGQdSdH026xZJUtvcx5YGeghGxVw+IL2ughBEcKHwIBJGEPDAk9LdiwEBHXwYS4mJCr4wJTFEibUpagDEbsiL4D2rUyNqC98ky0mtMpHr0xKU0ckCakvJiwOs3U8VQ7K/Y374n2VHcb09/JvHxiJYbE/qWbZf5Xp2qR6ONM1+BSTZFmVHU8c0l1V9TNzS9VSXKIiFO4R/GYMNfKWZ9NrUl07aq3TMffdKZi1Z5nuSne1S1pwPbPcc6D+lHZPinbV8elipWNOo897OOQ5nmKCi5QRY28AzziCc/GpZEad8b9Z6qRyzS7+LaMhw//ApM+</latexit>

↵2 <latexit sha1_base64="GedUqrynM7F7dHFYKg8g4f7WDd8=">AAACz3icjVHLSsNAFD2Nr1pfVZdugkVwY0mKqMuCG5ct2Ae0pUzSaRuaJmEyUUqpuPUH3OpfiX+gf+GdMQW1iE5Icubce87MvdeJfC+WlvWaMZaWV1bXsuu5jc2t7Z387l49DhPh8pob+qFoOizmvhfwmvSkz5uR4Gzs+LzhjC5VvHHDReyFwbWcRLwzZoPA63suk0S128yPhqw7DU5Ks26+YBUtvcxFYKeggHRVwvwL2ughhIsEY3AEkIR9MMT0tGDDQkRcB1PiBCFPxzlmyJE2oSxOGYzYEX0HtGulbEB75RlrtUun+PQKUpo4Ik1IeYKwOs3U8UQ7K/Y376n2VHeb0N9JvcbESgyJ/Us3z/yvTtUi0ceFrsGjmiLNqOrc1CXRXVE3N79UJckhIk7hHsUFYVcr5302tSbWtaveMh1/05mKVXs3zU3wrm5JA7Z/jnMR1EtF+6xoV08LZSsddRYHOMQxzfMcZVyhghp5R3jEE56NqnFr3Bn3n6lGJtXs49syHj4AwwKT7Q==</latexit>

↵n 2
<latexit sha1_base64="jF+y3EV2jh32LfiN8li2xuY/klk=">AAACz3icjVHLSsNAFD3GV62vqks3wSK4sSQi6rLgxmUL9gFtKZN02obmxWSilFJx6w+41b8S/0D/wjtjCmoRnZDkzLn3nJl7rxP7XiIt63XBWFxaXlnNreXXNza3tgs7u/UkSoXLa27kR6LpsIT7Xshr0pM+b8aCs8DxecMZXap444aLxIvCazmOeSdgg9Drey6TRLXbzI+HrDsJj+1pt1C0SpZe5jywM1BEtipR4QVt9BDBRYoAHCEkYR8MCT0t2LAQE9fBhDhByNNxjinypE0pi1MGI3ZE3wHtWhkb0l55Jlrt0ik+vYKUJg5JE1GeIKxOM3U81c6K/c17oj3V3cb0dzKvgFiJIbF/6WaZ/9WpWiT6uNA1eFRTrBlVnZu5pLor6ubml6okOcTEKdyjuCDsauWsz6bWJLp21Vum4286U7Fq72a5Kd7VLWnA9s9xzoP6Sck+K9nV02LZykadwz4OcETzPEcZV6igRt4xHvGEZ6Nq3Bp3xv1nqrGQafbwbRkPH8Chk+w=</latexit>

↵n 1

<latexit sha1_base64="mv3LazbaBAHnlVOCKkm2jnJw57c=">AAACxnicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVlw02VF+4BaSjKd1qF5MZkopQj+gFv9NPEP9C+8M6agFtEJSc6ce8+Zuff6SSBS5TivBWthcWl5pbhaWlvf2Nwqb++00jiTjDdZHMSy43spD0TEm0qogHcSyb3QD3jbH5/rePuWy1TE0ZWaJLwXeqNIDAXzFFGXad/tlytO1THLngduDirIVyMuv+AaA8RgyBCCI4IiHMBDSk8XLhwkxPUwJU4SEibOcY8SaTPK4pThETum74h23ZyNaK89U6NmdEpArySljQPSxJQnCevTbBPPjLNmf/OeGk99twn9/dwrJFbhhti/dLPM/+p0LQpDnJkaBNWUGEZXx3KXzHRF39z+UpUih4Q4jQcUl4SZUc76bBtNamrXvfVM/M1kalbvWZ6b4V3fkgbs/hznPGgdVd2TqntxXKk5+aiL2MM+Dmmep6ihjgaa5D3CI57wbNWtyMqsu89Uq5BrdvFtWQ8f/qCQEA==</latexit>

s1 <latexit sha1_base64="wdpmRmzWyPBhOpCBgcBZG/KMVYo=">AAACxnicjVHLSsNAFD2Nr1pfVZdugkVwVZIi6rLgpsuKthVqKUk6rUPzIjNRShH8Abf6aeIf6F94Z5yCWkQnJDlz7j1n5t7rpyEX0nFeC9bC4tLySnG1tLa+sblV3t5piyTPAtYKkjDJrnxPsJDHrCW5DNlVmjEv8kPW8cdnKt65ZZngSXwpJynrRd4o5kMeeJKoC9Gv9csVp+roZc8D14AKzGom5RdcY4AEAXJEYIghCYfwIOjpwoWDlLgepsRlhLiOM9yjRNqcshhleMSO6TuiXdewMe2Vp9DqgE4J6c1IaeOANAnlZYTVabaO59pZsb95T7WnutuE/r7xioiVuCH2L90s8786VYvEEKe6Bk41pZpR1QXGJdddUTe3v1QlySElTuEBxTPCgVbO+mxrjdC1q956Ov6mMxWr9oHJzfGubkkDdn+Ocx60a1X3uOqeH1Xqjhl1EXvYxyHN8wR1NNBEi7xHeMQTnq2GFVu5dfeZahWMZhfflvXwAQEPkBE=</latexit>

s2 s3<latexit sha1_base64="xj/pPNoODH/Qs2U9aDXJJ7Gi1Hw=">AAACxnicjVHLSsNAFD2Nr1pfVZdugkVwVRIVdVlw02VF+4BaSjKd1qF5kZkoUgR/wK1+mvgH+hfeGVNQi+iEJGfOvefM3Hv9JBBSOc5rwZqbX1hcKi6XVlbX1jfKm1stGWcp400WB3Ha8T3JAxHxphIq4J0k5V7oB7ztj890vH3DUyni6FLdJbwXeqNIDAXzFFEXsn/YL1ecqmOWPQvcHFSQr0ZcfsEVBojBkCEERwRFOIAHSU8XLhwkxPUwIS4lJEyc4x4l0maUxSnDI3ZM3xHtujkb0V57SqNmdEpAb0pKG3ukiSkvJaxPs008M86a/c17Yjz13e7o7+deIbEK18T+pZtm/lena1EY4tTUIKimxDC6Opa7ZKYr+ub2l6oUOSTEaTygeEqYGeW0z7bRSFO77q1n4m8mU7N6z/LcDO/6ljRg9+c4Z0HroOoeV93zo0rNyUddxA52sU/zPEENdTTQJO8RHvGEZ6tuRVZm3X6mWoVcs41vy3r4AANvkBI=</latexit>

sn
<latexit sha1_base64="mcSs3JRANQ58FFe83yEhIvH0emk=">AAACynicjVHLSsNAFD2Nr1pfVZdugkVwY0lE1GXBjQsXFewDailJOq1D0yRMJkIJ3fkDbvXDxD/Qv/DOOAW1iE5Icubcc+7MvddPQp5Kx3ktWAuLS8srxdXS2vrG5lZ5e6eZxpkIWCOIw1i0fS9lIY9YQ3IZsnYimDf2Q9byRxcq3rpnIuVxdCMnCeuOvWHEBzzwJFGttJdHR8fTXrniVB297HngGlCBWfW4/IJb9BEjQIYxGCJIwiE8pPR04MJBQlwXOXGCENdxhilK5M1IxUjhETui75B2HcNGtFc5U+0O6JSQXkFOGwfkiUknCKvTbB3PdGbF/pY71znV3Sb0902uMbESd8T+5Zsp/+tTtUgMcK5r4FRTohlVXWCyZLor6ub2l6okZUiIU7hPcUE40M5Zn23tSXXtqreejr9ppWLVPjDaDO/qljRg9+c450HzuOqeVt3rk0rNMaMuYg/7OKR5nqGGS9TR0FU+4gnP1pUlrImVf0qtgvHs4tuyHj4AXJGRzA==</latexit>

2 sn <latexit sha1_base64="MFyfbLmIFd7ZzWuXB5IyJy0vJMk=">AAACynicjVHLSsNAFD2Nr1pfVZdugkVwY0lE1GXBjQsXFewDailJOq2haRJmJkIJ3fkDbvXDxD/Qv/DOOAW1iE5Icubcc+7MvddPo1BIx3ktWAuLS8srxdXS2vrG5lZ5e6cpkowHrBEkUcLbvidYFMasIUMZsXbKmTf2I9byRxcq3rpnXIRJfCMnKeuOvWEcDsLAk0S1RC+Pj9xpr1xxqo5e9jxwDajArHpSfsEt+kgQIMMYDDEk4QgeBD0duHCQEtdFThwnFOo4wxQl8makYqTwiB3Rd0i7jmFj2qucQrsDOiWil5PTxgF5EtJxwuo0W8cznVmxv+XOdU51twn9fZNrTKzEHbF/+WbK//pULRIDnOsaQqop1YyqLjBZMt0VdXP7S1WSMqTEKdynOCccaOesz7b2CF276q2n429aqVi1D4w2w7u6JQ3Y/TnOedA8rrqnVff6pFJzzKiL2MM+DmmeZ6jhEnU0dJWPeMKzdWVxa2Lln1KrYDy7+Lashw9aMJHL</latexit>

1 sn
<latexit sha1_base64="sJiLa8oVjzjNJ+bL0+WTryQO2jE=">AAACyHicjVHLSsNAFD2Nr1pfVZdugkVwVRIRdVlwI64qmLZQS0mm0zo0TUIyUUrpxh9wq18m/oH+hXfGKahFdEKSM+fec2buvUESikw6zmvBWlhcWl4prpbW1jc2t8rbO40szlPGPRaHcdoK/IyHIuKeFDLkrSTl/igIeTMYnqt4846nmYijazlOeGfkDyLRF8yXRHlZdxJNu+WKU3X0sueBa0AFZtXj8gtu0EMMhhwjcESQhEP4yOhpw4WDhLgOJsSlhISOc0xRIm1OWZwyfGKH9B3Qrm3YiPbKM9NqRqeE9KaktHFAmpjyUsLqNFvHc+2s2N+8J9pT3W1M/8B4jYiVuCX2L90s8786VYtEH2e6BkE1JZpR1THjkuuuqJvbX6qS5JAQp3CP4ilhppWzPttak+naVW99HX/TmYpVe2Zyc7yrW9KA3Z/jnAeNo6p7UnWvjis1x4y6iD3s45DmeYoaLlCHR94Cj3jCs3VpJda9Nf5MtQpGs4tvy3r4ACtOkVk=</latexit>

X X X
<latexit sha1_base64="D/aFTa5Shp8HDfEl0IMOVrTuZ5g=">AAAD1HicjVHBbtQwEJ00QEuBdluOXCJWSFtpWcURolwqFXHh2ErstlLTRo7X7Vp1nCh2kKqQE+qVH+AK34T4A/iLjr2JukuFwFGS8Zv33szYaSGFNmH401vx791/sLr2cP3R4ycbm72t7YnOq5LxMctlXh6nVHMpFB8bYSQ/LkpOs1Tyo/Tync0ffeSlFrn6YK4KfprRCyXOBaMGoWTL24gLLQY6IUOdRMOYTXOjMVQ7e7GusqSOqSxmNCF7pDmrYzYTCWmWMtFtJmo6gyVGrV6S5pbltk2cUTNjVAZvz+oB2WmS2vbQVWssGlm0Q4YL6aiZl3FadFvgoTl2oedFhosNOEu1TCVzKnajclVlKS+TXj8chW4FdwPSBn1o10He+wExTCEHBhVkwEGBwVgCBY3PCRAIoUDsFGrESoyEy3NoYB21FbI4Miiil/i9wN1JiyrcW0/t1AyrSHxLVAbwAjU58kqMbbXA5SvnbNG/edfO0/Z2hf+09coQNTBD9F+6jvm/OjuLgXN442YQOFPhEDsda10qdyq282BhKoMOBWI2nmK+xJg5ZXfOgdNoN7s9W+ryvxzTonbPWm4Fv22XeMHkz+u8G0yiEXk9Ioev+vthe9Vr8AyewwDvcxf24T0cwBiYV3lfvW/ed3/if/I/+9dz6orXap7C0vK/3AAOEvJa</latexit>

1 2 n 1

(s1 , s2 , · · · , sn ) = ,··· , A(1) (2) (n

s1 ,↵1 A↵1 ,s1 ,↵2 · · · A↵n
1)
2 ,sn 1 ,↵n 1
A(n)
↵n 1 ,sn
↵1 =1 ↵2 =1 ↵n 1 =1

Top: Diagram notations for tensors with different orders, and an example of contraction of two tensors.
Bottom: A matrix product state. {A(i) } are three-way tensors (and matrices on the two boundaries), each of
which has dimension di χ2 , with di denoting the local dimension of physical indices si and χ is the dimension of
virtual indices α1 , α2 , · · · .

In Box 2, {A(i) } are three-way tensors (and matrices on the two boundaries), each of which has dimension di χ2 ,
with di denoting the local dimension of physical indices si and χ is the dimension of virtual indices α1 , α2 , · · · . As
such, the MPS method is one of the simplest examples of tensor networks, with the difference that the state is evolved
from the initial state to the final state, while the tensor network contraction method, which will be introduced in the
next subsection, can employ general contraction orders.
Compared with the state-vector method, the MPS representation reduces the number of parameters from 2n to
roughly 2nχ2 (with di = 2) at the cost of expressing only an approximation of the state with rather low entangle-
ments [28]. It has been shown that the MPS method and its variant, the group MPS method, can efficiently simulate
random circuits with controlled-Z gates and random Haar gates [37]. Further developments of the MPS simulation
method [38] manually close some qubits in the final state and combines the Markov chain Monte-Carlo sampling tech-
nique to investigate more challenging random circuits with the fSim gates, obtaining a cross-entropy benchmarking
(XEB: a protocol introduced as a proxy to fidelity) that is similar to quantum hardware experiments on the Sycamore
circuits [1] with simplified connection patterns.
Another way to approximate the state vector is by using neural networks [39, 40]. In contrast to the MPS method
which explores intrinsic low-rank structures, neural network states exhibit a much higher rank of a tensor. However,
it is difficult to apply unitary operators U to the state neural network states |ψi exactly. A solution is to choose
neural networks that are easy to sample so that one can construct a loss function using samples for characterizing the
distance between the old state |ψi and new states U |ψi after applying unitary operators, provided with sparse U and
|ψi, and then optimize the loss function to approximate the new state using neural networks. In Refs. [41, 42], specific
neural networks, restricted Boltzmann machines (RBM) [43, 44] have been employed to approximately represent and
evolve the quantum state. It has been shown that it is convenient for simulating quantum circuits with two-qubit gates
that have a diagonal matrix representation, e.g., controlled-Z gates and the gates in QAOA. However, minimizing the
loss function introduces difficulties of non-convex optimizations, which heavily reduces the efficiency of the approach.

B. Tensor networks
 5

Box 3: Pictorial illustration of the tensor network of a quantum circuit

If qubits are located on a 2-D layout, the evolution of the quantum circuit corresponds to a 3-dimensional
tensor network. On the left-hand boundary of the tensor network, the tensors are initial states, which are
usually product states, acting as a set of vectors on the left-hand side of the tensor network. On the right-hand
side, the boundary corresponds to the final state of the quantum circuits. From the left boundary to the right
boundary, there are quantum gates applying unitary transformations: the single-qubit gates are 2 × 2 matrices
and the two-qubit gates are order-4 tensors with dimension 2 × 2 × 2 × 2. In other words, a quantum circuit is
a subset of tensor networks, with the constraint that most of the tensors in the network are unitary. Thus,
some of the circuit-simulation tasks can be converted to the tensor network contraction problem: If the
purpose of the simulation is computing the amplitude of a given bitstring, the problem can be converted to a
tensor network contraction problem with the other boundary (we will term it as “right boundary”) of the
tensor network being “closed” by a tensor product of vectors specified by the bitstring; If the target of
simulation is a full state-vector, the right boundary of the tensor network is “open”, or equivalently, having an
identity matrix of size 2n × 2n as the right boundary.

Tensor network contraction is a powerful method for simulating quantum circuits by representing the state or
operator as a network of smaller tensors, as shown in Box 3. This reduces the memory and computational requirements,
while also taking into account the specific structure of the circuit and qubit interactions. Additionally, the flexibility
of the tensor network representation allows for the use of various contraction strategies, such as approximations and
truncations, which can further increase simulation efficiency, as discussed in Sec. II A 2.
The use of tensor network contraction for simulating quantum circuits has its roots in the pioneering work of
Markov and Shi in 2005 [45], which can be further reduced to node elimination under graphical representation.
While efficient contraction methods exist for highly-structured tensor networks such as MPS and the multi-scale
entanglement renormalization ansatz (MERA) [46], the exact contraction of general tensor networks is known to be
#P-complete [47]. Different simulation tasks specify different choices of boundary conditions for the corresponding
tensor network, and can greatly impact the computational cost of contraction. An open boundary, also known as
full-amplitude simulation, requires a space and time complexity exponential in the number of qubits. In contrast,
a closed boundary, also known as single-amplitude simulation, may require less cost [48]. An intermediate option,
known as the “big-batch” boundary condition [49], can compute a large number of correlated bitstring amplitudes
by separating the final qubits into a closed part and an open part and placing a product of vectors on the closed
qubits and a product of identity matrices on the open qubits. In some circuits, big-batch computation has a similar
contraction cost to single-amplitude simulation and can be used to obtain full amplitudes by enumerating all the
batches. When computing amplitudes for m uncorrelated bitstrings, one can compute amplitudes for each bitstring
individually by repeating contractions m times. To improve efficiency, approaches such as the sparse state method [50]
and the multi-cache method [51] have been introduced, which can compute all the requested amplitudes simultaneously
using just one contraction, avoiding the repetition of contraction for some parts of the tensor network shared by the
computation for each bitstring.
The order in which tensors in a network are contracted can greatly affect the efficiency of the evaluation process.
Different contraction sequences can result in varying levels of computational and storage demands. Finding the optimal
contraction order for a given network can be a complex task, but various heuristic approaches have been proposed to
tackle this challenge [45, 52]. For deep quantum circuits, the trivial contraction order, which starts from the initial
state and progresses to the end state, is typically very close to the optimal order. However, for NISQ circuits, which
are not that deep, the choice of the contraction order can have a significant impact on the computational cost. To
 6

further enhance the capabilities of classical simulation, researchers have been investigating various high-performance
computing techniques. However, the complex data dependencies between tensors can make it challenging to effectively
parallelize the computation. Dynamical slicing methods, as introduced in [20, 53], solve this issue by splitting the
target tensor network into multiple simpler networks with the same structure. This enables perfect parallelization and
results in a significant boost in simulation efficiency. This approach has been widely adopted in various studies, such as
Refs. [21, 48, 51, 53, 54]. Tensor networks can be used not only to compute exact or approximate bitstring amplitudes
and probabilities of the final state, but also to generate samples from a given distribution P (s) with a specified fidelity
or XEB [55]. Existing methods for this purpose include Frugal sampling [21] and Markov-chain Monte-Carlo [38, 50].
These methods leverage the capabilities of tensor networks to provide efficient sampling strategies for quantum circuits.
Furthermore, tensor networks provide a versatile framework for representing both closed and open systems [56],
allowing for easy extension to density matrices and quantum channels [57, 58]. However, their ability to simulate
these systems exactly is still limited by the increasing resource demands.

C. Stabilizers

Although quantum circuits that can be simulated by the general-purpose classical simulators as described above
are limited by size, there are some exceptions. The stabilizer circuit is one non-trivial example that has important
applications in the field of quantum error correction. Stabilizer circuits in general are initialized to be stabilizer states,
which are evolved under stabilizer operations and measured on a Pauli basis. As stabilizer operations are within the
Clifford group, these circuits can be simulated efficiently by a classical computer. A couple of methods, by making
use of the stabilizer tableau, have proven to be effective for the fast simulation of very large stabilizer circuits [59, 60].
However, stabilizer circuits are not universal. To enable universal quantum computation needs an extension -
the use of magic states is a canonical solution. As the cost of simulation scales exponentially with the number
of magic states, when the circuits are dominated by Clifford gates, those circuits can still be simulated efficiently.
There are mainly two classes of methods designed for near-stabilizer circuits, quasiprobability [61–64] and stabilizer-
rank [61, 65–67]. The quasiprobability method for simulating quantum circuits is formalized by Ref. [62], with which
an unbiased estimate of observables or the circuit outcomes can be obtained by sampling quasiprobability distributions
over stabilizer states and operators. Quasiprobability allows the probability representation of a circuit element to be
negative, while the negativity, the amount it deviates from a true probability distribution, serves as a major factor
for the computation cost [62]. Methods based on quasiprobability are natural to simulate noisy circuits; however,
they are usually slower than stabilizer-rank-based methods. The stabilizer rank is defined as the smallest number of
stabilizer states a quantum state can be decomposed into, which measures the simulation complexity. Determining
the stabilizer rank is usually a hard problem [27], and an exact simulation can be costly. This motivates the work of
Ref. [65], which proposes a sparsification method to obtain an approximation of the target state with a decomposition
that contains fewer stabilizer states. This technique is further improved to have a reduced runtime in Ref. [66] and is
generalized to qudits in Ref. [67] and the mixed-state case in Ref. [61].

D. Other methods

There also exist other classical simulation methods. One class of methods is based on the decision diagram [68–73], a
graph-based approach that exploits redundancies of the quantum circuit and hence enables fast simulation of sizeable
complex quantum circuits using limited resources. The state-of-the-art implementation of decision diagrams [72] is
comparable to that of MPS. Recently, a hybrid data structure, the tensor decision diagram [74], was proposed by
combining the ideas of decision diagrams and tensor networks, integrating the flexibility of tensor networks while
overcoming the memory bottleneck using decision diagrams in theory. As yet, only a proof-of-concept implementation
has been done using the tensor decision diagram with up to 21 qubits [74].
Another class of methods targets at non-Clifford circuits. A central ingredient is the computationally tractable (CT)
states, for which the computational measurements on |ψi can be simulated classically and the coefficient in this basis
can be efficiently computed, i.e., (1) it is possible to sample in poly(n) time from the distribution Pr(x) = |hx|ψi|2
on the set of n-bit strings x and (2) the coefficients hx|ψi can be computed in poly(n) time. Ref. [75] shows that if
the state |ψi is CT and if U † OU (circuit U and measurement O) is efficiently computable sparse, then the quantum
computation of the sampling probability can be simulated classically. Here, sparse quantum circuits include Pauli
operators, local operators, and operators that can be written as a polynomial number of Toffoli gates.
There are also simulators specially designed for variational algorithms. The implementation of variational algorithms
requires circuits to have the same structure but different gate parameters, and the circuit outputs can be reused across
simulation runs. In Ref. [76], some techniques in artificial intelligence are used to convert a circuit into an arithmetic
 7

circuit that allows changing parameters and repeated measurements, enabling fast simulation compared with the
general-purpose simulators.

III. APPLICATIONS

Associated with the development of classical simulation methods there has been an emergence of a wide variety
of software toolkits for public use, such as Qiskit [77], ACQDP[54, 58, 78], Cotengra[48], Cirq [79], QuEST [80],
Yao.ji [81], Qjava [82], QETLAB [83]. Those packages cover commonly-used programming platforms and have been
used to explore and demonstrate diverse applications [54, 58, 78]. In this section, we give an overview of the key uses
of classical simulations. These applications can generally be divided into two categories: the development of quantum
hardware and the development of quantum algorithms. It is worth noting that some applications, such as quantum
applications and hardware co-design, may fall into both categories.

Figure 1. Some key applications of classical simulations. Classical simulations can assist hardware development in modeling
hardware control and benchmarks. In the field of quantum error correction and error mitigation, classical simulations are
widely used to test the performance of error correction codes and mitigation strategies under different scenarios. Meanwhile,
quantum algorithms are commonly simulated with classical methods for performance verification. Potential applications and
problems with quantum advantage are also tested and demonstrated with classical simulations.

A. Quantum algorithm development

Classical simulation is predominantly used in the development of quantum algorithms. Through the use of classical
simulation methods, we can:

1. understand the behavior of quantum algorithms under various conditions, identify potential sources of error and
optimize the design and implementation of quantum algorithms;

2. test and debug quantum algorithms before they are run on actual quantum hardware, saving time and resources
in the development process.

3. compare the performance of quantum algorithms to classical algorithms and evaluate the complexity of quantum
algorithms in relation to the size of the input.

These capabilities enable researchers to assess the feasibility of different quantum computing applications on various
architectures and identify areas where quantum algorithms may be particularly advantageous. We will expand upon
this in the following subsections.
 8

1. Quantum algorithm design and verification

One challenge to the development of quantum technology is the lack of so-called killer applications. While certain
well-known quantum algorithms, such as integer factoring and Hamiltonian simulation, have provable performance,
those empirical quantum algorithms may require a platform to verify and validate if they actually work. Specific
examples include an empirical algorithm to distinguish non-isomorphic graphs, with experiments to validate its per-
formance in terms of run time and solution quality [54]. Classical simulation methods are also commonly used to test
their robustness under realistic circumstances, e.g., with noise or gate implementations. Moreover, before algorithms
are implemented on a real device to get a meaningful and reliable result, prototype demonstrations for particular
applications are commonly conducted on classical computers to uncover research in new paradigms and raise interest
across academia and industry for potential applications of quantum computers.

2. Quantum advantage demonstration and validation

A key question for the quantum computing field is when, and to what context, quantum computers will outperform
conventional machines. Terms such as ‘quantum supremacy’ (QS) and ‘quantum advantage’ (QA) are typically used
in this discussion. However these terms are often used inconsistently in different papers. QS is deemed to occur
when any task can be performed on a quantum computer with profoundly lower resource costs (primarily, time)
than a classical alternative. The task in question need not be useful and may indeed be defined solely for the QS
demonstration. Somewhat confusingly, some authors use QA as a synonym for QS, finding the word ‘advantage’ less
problematic than ‘supremacy’ in terms of its historical resonance. However, many other authors prefer to reserve
the use of QA to refer to scenarios where the task at hand is actually useful, at least potentially, users beyond the
quantum computing community.
Whether one considers QS or QA, the challenge drives the optimization of classical simulation methods, with the
aim of verifying claim that the quantum system has fundamentally better performance. Validation is critical as new
proposals may not have undergone thorough prior examination, and it is crucial to ensure that research is based on
sound foundations and that results are reliable.
Random circuit sampling (RCS) is a leading proposal to demonstrate that a quantum computer can go beyond
the capability of a conventional machine. A random quantum circuit is used to generate samples from its output
distribution [55, 84]. With a qubit count exceeding 50, it is anticipated that simulating the full state of the system
would require 16 petabytes of memory, which is eight times more than that of the most powerful supercomputer
at the time. The circuit structure is also specifically designed to achieve a large tree width, making it challenging
to simulate using tensor network methods. This is thus a task well-suited to distinguishing between quantum and
classical systems, but is not generally considered useful beyond that context – the random nature of the circuits makes
this so practically by definition.
The initial demonstration of quantum supremacy was conducted by Google in 2019 [1]. Since then, ongoing efforts
have been made to develop classical simulation methods that challenge the validity of the claim. RCS has also become
a benchmark for quantum hardware, as it not only takes into account qubit count, but also qubit quality, which can
be characterized using XEB. The continuous advancements in quantum hardware [3, 4] also push the boundaries of
quantum computing and pose new challenges for classical simulation methods to keep pace.
As an illustration of how classical methods contribute to this task, Box 4 provides further information on the various
strategies used to implement the sampling problem using classical simulation methods.

Box 4: Random circuit sampling and its verifications

Sampling problem of quantum circuits

In the experimental realization, the quantum hardware generates bitstring samples {s} by performing measure-
ments on the states produced by applying the circuit U composed of non-perfect quantum gates with randomly
generated parameters. Owing to noise, the underlying distribution Q(s) of the samples is not the distribution
PU (s) corresponding to the exact final state |ψi. This sampling problem can also be solved using classical algo-
rithms. The most straightforward simulation method is the full-amplitude simulation by storing and evolving
the state vector [55, 85]. But it is not suitable for the sampling problem with a large number of qubits. The
tensor network methods allow computing exact or approximate amplitudes for only part of the bitstrings that
are further used for generating samples and are for the sampling problems with shallow circuits.

Verification of the sampling problem

 9

An important problem is how to characterize the quality of samples generated by quantum hardware or classical
simulation. One seeks to estimate the distance between the generation distribution Q(s) and the true distri-
bution PU (s). In literature, the quality of samples is characterized using the cross entropy benchmark (XEB)
for random circuits where the Porter-Thomas rule holds [1, 55], and is computed using the difference between
cross-entropy of Q(s) and PU (s) and the cross entropy between Q(s) and the uniform distribution. It has been
used for demonstrating meaningful gaps between quantum and classical systems [1, 3, 4]. The exact value of
XEB for large circuits requires one to make comparisons with classical predictions.

Tensor network methods for the sampling problem

Initially, tensor network contraction was used for computing exact bitstring amplitudes (and probabilities) one by
one [20, 86] which were further used for generating samples via e.g. frugal sampling methods [87]. Subsequently,
it has been shown that a small group of k correlated bitstring amplitudes can be computed with almost the
same computational cost for computing a single bitstring amplitude [8]. The approach has been shown to be
very efficient in solving sampling problems for 2D quantum circuits with controlled-Z gates [8, 78, 87, 88].
A breakthrough in the tensor network approach for quantum circuit simulation is the balanced-partitioning-
based approach for finding contraction orders [48, 89]. By combining the partitioning-based contraction-order
finding and frugal sampling, researchers have proposed [21] to generate some perfect samples by repeating the
tensor network contraction many times and mixing with random bitstrings, so as to arrive at a set of samples
with XEB close to Google’s hardware, with a computation time of roughly 20 days on a supercomputer.
If the objective is only obtaining a higher XEB (i.e., spoofing of XEB [90]), the computational cost can be
heavily reduced. It was proposed [91] that a big-batch (e.g., of size 221 ) of correlated bitstrings with exact bit-
string probabilities can be computed efficiently and used for generating correlated samples with XEB much larger
than Google’s hardware XEB. This big-batch approach has also been implemented on a supercomputer [92],
requiring only 304 seconds. Notice that sampling from a big batch of correlated bitstrings gives correlated sam-
ples, which is significantly different from Google’s experiments which produce uncorrelated samples. In [50], the
spare-state method was proposed to obtain one million uncorrelated bitstring samples of the Sycamore circuits
with estimated fidelity greater than Google’s hardware XEB, using a single network contraction.

3. Quantum error correction

As discussed in the previous sections, stabilizer circuits can be simulated efficiently and are widely used in esti-
mating the performance of quantum error correction codes, such as logical error rates and thresholds. The efficient
simulatability is based on the assumption that noise sources can be described by Pauli operators drawn from some
fixed distribution. The premise is good enough to provide conceptual guidance. However, a simple error model cannot
capture the behavior of real quantum hardware, such as qubit idling, photon decay, flux noise, etc. Therefore, a series
of works have been devoted to simulating the surface code under more realistic error models [57, 76, 93, 94] by using
simulation techniques such as density-matrix simulation or a tensor network approach. However, the highest code
distance is simulatable under the surface code architecture and a realistic error model is still limited.
We should note that quantum error correction circuits and NISQ circuits have different parameter regimes in circuit
size and depth. Generally, quantum error correction circuits will be much longer than usual NISQ circuits. This makes
massive parallelization techniques developed for a tensor network approach much less beneficial, but provides more
opportunities for developing new classical simulation techniques.

4. Circuit compilation

Efficient classical simulation of quantum circuits also enables the investigation of circuit compilation, specifically to
compile a unitary or a quantum state with shallow-depth circuits consisting of local gates or others that satisfy certain
hardware restrictions. This is essential for accurate implementations of quantum algorithms and hence is important
for realizing quantum advantage using limited near-term quantum computers. For unitary compilation [95–97], the
task is to optimize an operator U (θ) ~ with classical variables θ,
~ so that it is close to the target unitary V . One can
~ † 2
use |Tr[U (θ) V ]| (or others) as the cost function, which could be obtained via quantum simulators, and maximize it
to compile V . Here the operator U (θ) ~ could be either a parametrized quantum circuit or the Hamiltonian evolution
of the hardware, possibly with implementation restrictions for compilation with a real device. The compiled operator
~ generally has a much shallower quantum circuit, which is more experimentally friendly and more noise-robust.
U (θ)
One can also consider the compilation for specific quantum states, where, in this case, the cost function is replaced
 10

~ † V |ψ0 i|2 for a certain initial state |ψ0 i. The compilation algorithm has been tested for up to 20 qubits
by |hψ0 |U (θ)
using a high-performance classical simulator [98]. Furthermore, classical simulators could be applied for compiling
error correction circuits with shallower depth and hardware-friendly quantum gates. Refs. [99, 100] have shown
the compilation for the five- and seven-qubit codes. More efficient classical simulators are required for the circuit
compilation of larger systems.

B. Quantum hardware development

While quantum algorithm development may receive more attention, the development of quantum hardware is
another vital and growing field that also benefits from classical simulation techniques. Classical simulations can be
used to study a wide range of factors that affect the performance of quantum hardware, such as the effects of noise
and decoherence, the optimization of quantum circuits, and the characterization of fabricated quantum devices. By
using classical simulations, researchers can gain valuable insights into the behavior of quantum systems, test and
debug quantum hardware before it is built for faster iteration, and identify potential challenges and opportunities for
improving quantum hardware.

1. Quantum hardware design

In the development of quantum hardware, the chip design process necessitates a substantial amount of classical
simulation work to evaluate whether a given superconducting circuit design (or other qubit platforms) can perform
high-fidelity quantum operations. The exact diagonalization of the full circuit Hamiltonian becomes computationally
intractable for large systems, highlighting the need for new methods to efficiently model these systems. Recent
work has employed tensor network methods to model superconducting circuits spanning a Hilbert space as large as
15180 [101]. However, while it has been reported that it is feasible to study coherence time using this approach, it
remains highly challenging to accurately model and predict quantum operation fidelities for systems involving a few
dozen qubits.

2. Hardware benchmarking and characterization

Another motivation for the ongoing drive to improve classical simulation methods is to aid in the validation of
quantum hardware. One specific area of focus is the development of quality assurance techniques for quantum
processors. Various metrics have been proposed and extensively used for benchmarking quantum processors, such
as XEB [1] and quantum volume [102]. However, as the system size grows, the exponential computational resources
required for these methods become increasingly demanding. In response, alternative perspectives have been developed
to address this challenge, such as the use of XEB with Clifford circuits [103], which require only modest classical
simulation resources. These efforts aim to provide more efficient and practical ways to evaluate the performance of
quantum processors, and to aid in the ongoing advancement of quantum hardware.

IV. CHALLENGES AND OUTLOOK

Even though quantum computers are anticipated to outperform classical computers ultimately, classical simulations
are still indispensable at the current stage. We have witnessed the development and adoption of various classical
simulation methods for quantum computers, and their wide applications in different tasks in developing quantum
hardware and quantum algorithms. With the fast development of quantum computers, the need for more efficient
classical simulation methods will also rise rapidly.
The fundamental challenge in the classical simulation of quantum systems is the exponential scaling of the resources
required as the quantum system size grows. This is because the quantum state is represented by a complex-valued
wave function, which requires an exponentially large number of complex numbers to describe. As a result, it is
generally very difficult to exactly simulate large quantum systems with classical computers.
There are a number of approximate methods that have been developed to overcome this difficulty and to allow for
the classical simulation of large quantum systems. These methods include MPS/MPO, tensor network, and stabilizer
techniques. However, several challenges arise in the approximate classical simulation methods themselves:
 11

1. Accuracy: One of the main challenges is finding methods that can accurately approximate the simulated quantum
system’s behavior, especially for systems that exhibit complex or highly correlated behavior.

2. Scalability: Another challenge is to find scalable methods that can efficiently simulate larger quantum systems.
Many approximate methods also suffer from exponential scaling, meaning they become impractical for larger
systems.

3. Efficient implementation: A third challenge is to develop efficient algorithms and approaches for implementing
these approximate methods on classical computers.

4. Validation: A final challenge is to validate the accuracy of the approximate methods being used, as it may not
always be possible to exactly simulate the quantum system and compare the results to the approximate solution.

Yet another challenging task in the classical simulation of quantum systems is the development of efficient algorithms
for simulating specific quantum systems or quantum algorithms. While there has been significant progress in this
area, there is still much work to be done to fully understand the capabilities and limitations of classical simulation
for specific types of quantum systems and algorithms.
We hope this review will stimulate further development of classical simulation methods of quantum computers with
new simulation methodologies, optimized implementations, and broader applications; such progress will be ever more
valuable for benchmarking, verifying, and designing quantum computers and algorithms.

ACKNOWLEDGMENTS

The authors thank Tyson Jones and Suguru Endo for early discussions on this review.

[1] Frank Arute, Kunal Arya, Ryan Babbush, Dave Bacon, Joseph C Bardin, Rami Barends, Rupak Biswas, Sergio Boixo,
Fernando GSL Brandao, David A Buell, et al. Quantum supremacy using a programmable superconducting processor.
Nature, 574(7779):505–510, 2019.
[2] Han-Sen Zhong, Hui Wang, Yu-Hao Deng, Ming-Cheng Chen, Li-Chao Peng, Yi-Han Luo, Jian Qin, Dian Wu, Xing Ding,
Yi Hu, et al. Quantum computational advantage using photons. Science, 370(6523):1460–1463, 2020.
[3] Yulin Wu, Wan-Su Bao, Sirui Cao, Fusheng Chen, Ming-Cheng Chen, Xiawei Chen, Tung-Hsun Chung, Hui Deng, Yajie
Du, Daojin Fan, et al. Strong quantum computational advantage using a superconducting quantum processor. Physical
review letters, 127(18):180501, 2021.
[4] Qingling Zhu, Sirui Cao, Fusheng Chen, Ming-Cheng Chen, Xiawei Chen, Tung-Hsun Chung, Hui Deng, Yajie Du, Daojin
Fan, Ming Gong, et al. Quantum computational advantage via 60-qubit 24-cycle random circuit sampling. Science bulletin,
67(3):240–245, 2022.
[5] Thi Ha Kyaw, Tim Menke, Sukin Sim, Abhinav Anand, Nicolas PD Sawaya, William D Oliver, Gian Giacomo Guerreschi,
and Alán Aspuru-Guzik. Quantum computer-aided design: digital quantum simulation of quantum processors. Physical
Review Applied, 16(4):044042, 2021.
[6] Naomi H Nickerson, Ying Li, and Simon C Benjamin. Topological quantum computing with a very noisy network and
local error rates approaching one percent. Nature communications, 4(1):1756, 2013.
[7] J Eli Bourassa, Rafael N Alexander, Michael Vasmer, Ashlesha Patil, Ilan Tzitrin, Takaya Matsuura, Daiqin Su, Ben Q
Baragiola, Saikat Guha, Guillaume Dauphinais, et al. Blueprint for a scalable photonic fault-tolerant quantum computer.
Quantum, 5:392, 2021.
[8] Benjamin Villalonga, Sergio Boixo, Bron Nelson, Christopher Henze, Eleanor Rieffel, Rupak Biswas, and Salvatore
Mandrà. A flexible high-performance simulator for verifying and benchmarking quantum circuits implemented on real
hardware. npj Quantum Information, 5(1):1–16, 2019.
[9] Alexander McCaskey, Eugene Dumitrescu, Dmitry Liakh, and Travis Humble. Hybrid programming for near-term quan-
tum computing systems. In 2018 IEEE international conference on rebooting computing (ICRC), pages 1–12. IEEE,
2018.
[10] M Ganzhorn, G Salis, DJ Egger, A Fuhrer, M Mergenthaler, C Müller, P Müller, S Paredes, M Pechal, M Werninghaus,
et al. Benchmarking the noise sensitivity of different parametric two-qubit gates in a single superconducting quantum
computing platform. Physical Review Research, 2(3):033447, 2020.
[11] Marcello Benedetti, Delfina Garcia-Pintos, Oscar Perdomo, Vicente Leyton-Ortega, Yunseong Nam, and Alejandro
Perdomo-Ortiz. A generative modeling approach for benchmarking and training shallow quantum circuits. npj Quantum
Information, 5(1):1–9, 2019.
[12] Hsin-Yuan Huang, Richard Kueng, Giacomo Torlai, Victor V Albert, and John Preskill. Provably efficient machine
learning for quantum many-body problems. Science, 377(6613):eabk3333, 2022.
 12

[13] Laura Clinton, Johannes Bausch, and Toby Cubitt. Hamiltonian simulation algorithms for near-term quantum hardware.
Nature communications, 12(1):4989, 2021.
[14] Sirui Lu, Mari Carmen Banuls, and J Ignacio Cirac. Algorithms for quantum simulation at finite energies. PRX Quantum,
2(2):020321, 2021.
[15] Xin Wang, Zhixin Song, and Youle Wang. Variational quantum singular value decomposition. Quantum, 5:483, 2021.
[16] Tameem Albash and Daniel A Lidar. Adiabatic quantum computation. Reviews of Modern Physics, 90(1):015002, 2018.
[17] Samuel L Braunstein and Peter Van Loock. Quantum information with continuous variables. Reviews of modern physics,
77(2):513, 2005.
[18] Marco Cerezo, Andrew Arrasmith, Ryan Babbush, Simon C Benjamin, Suguru Endo, Keisuke Fujii, Jarrod R McClean,
Kosuke Mitarai, Xiao Yuan, Lukasz Cincio, et al. Variational quantum algorithms. Nature Reviews Physics, 3(9):625–644,
2021.
[19] Edward Farhi, Jeffrey Goldstone, and Sam Gutmann. A quantum approximate optimization algorithm. arXiv preprint
arXiv:1411.4028, 2014.
[20] Jianxin Chen, Fang Zhang, Cupjin Huang, Michael Newman, and Yaoyun Shi. Classical simulation of intermediate-size
quantum circuits. arXiv preprint arXiv:1805.01450, 2018.
[21] Cupjin Huang, Fang Zhang, Michael Newman, Junjie Cai, Xun Gao, Zhengxiong Tian, Junyin Wu, Haihong Xu, Huanjun
Yu, Bo Yuan, et al. Classical simulation of quantum supremacy circuits. arXiv preprint arXiv:2005.06787, 2020.
[22] Gushu Li, Yufei Ding, and Yuan Xie. Eliminating redundant computation in noisy quantum computing simulation. In
2020 57th ACM/IEEE Design Automation Conference (DAC), pages 1–6. IEEE, 2020.
[23] Hans De Raedt, Fengping Jin, Dennis Willsch, Madita Willsch, Naoki Yoshioka, Nobuyasu Ito, Shengjun Yuan, and Kristel
Michielsen. Massively parallel quantum computer simulator, eleven years later. Computer Physics Communications,
237:47–61, 2019.
[24] Yi-Ting Chen, Collin Farquhar, and Robert M. Parrish. Low-rank density-matrix evolution for noisy quantum circuits.
npj Quantum Information, 7(1):61, April 2021.
[25] Tyson Jones. Efficient classical calculation of the quantum natural gradient, 2020.
[26] Ivan Kassal, Stephen P Jordan, Peter J Love, Masoud Mohseni, and Alán Aspuru-Guzik. Polynomial-time quantum
algorithm for the simulation of chemical dynamics. Proceedings of the National Academy of Sciences, 105(48):18681–
18686, 2008.
[27] Sergey Bravyi and David Gosset. Improved classical simulation of quantum circuits dominated by clifford gates. Physical
review letters, 116(25):250501, 2016.
[28] Guifré Vidal. Efficient classical simulation of slightly entangled quantum computations. Physical review letters,
91(14):147902, 2003.
[29] Andrei Amariutei and Simona Caraiman. Parallel quantum computer simulation on the gpu. In 15th International
Conference on System Theory, Control and Computing, pages 1–6. IEEE, 2011.
[30] Aneeqa Fatima and Igor L Markov. Faster schrödinger-style simulation of quantum circuits. In 2021 IEEE International
Symposium on High-Performance Computer Architecture (HPCA), pages 194–207. IEEE, 2021.
[31] Román Orús. A practical introduction to tensor networks: Matrix product states and projected entangled pair states.
Annals of Physics, 349:117–158, 2014.
[32] Ulrich Schollwöck. The density-matrix renormalization group in the age of matrix product states. Annals of physics,
326(1):96–192, 2011.
[33] Ivan V Oseledets. Tensor-train decomposition. SIAM Journal on Scientific Computing, 33(5):2295–2317, 2011.
[34] Andrzej Cichocki, Namgil Lee, Ivan Oseledets, Anh-Huy Phan, Qibin Zhao, Danilo P Mandic, et al. Tensor networks for
dimensionality reduction and large-scale optimization: Part 1 low-rank tensor decompositions. Foundations and Trends®
in Machine Learning, 9(4-5):249–429, 2016.
[35] Bogdan Pirvu, Valentin Murg, J Ignacio Cirac, and Frank Verstraete. Matrix product operator representations. New
Journal of Physics, 12(2):025012, 2010.
[36] Steven R White. Density matrix formulation for quantum renormalization groups. Physical review letters, 69(19):2863,
1992.
[37] Yiqing Zhou, E Miles Stoudenmire, and Xavier Waintal. What limits the simulation of quantum computers? Physical
Review X, 10(4):041038, 2020.
[38] Thomas Ayral, Thibaud Louvet, Yiqing Zhou, Cyprien Lambert, E Miles Stoudenmire, and Xavier Waintal. A
density-matrix renormalisation group algorithm for simulating quantum circuits with a finite fidelity. arXiv preprint
arXiv:2207.05612, 2022.
[39] Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep learning. MIT press, 2016.
[40] Christopher M Bishop and Nasser M Nasrabadi. Pattern recognition and machine learning, volume 4. Springer, 2006.
[41] Matija Medvidović and Giuseppe Carleo. Classical variational simulation of the quantum approximate optimization
algorithm. npj Quantum Information, 7(1):1–7, 2021.
[42] Bjarni Jónsson, Bela Bauer, and Giuseppe Carleo. Neural-network states for the classical simulation of quantum com-
puting. arXiv preprint arXiv:1808.05232, 2018.
[43] D. Ackley, G. Hinton, and T. Sejnowski. A learning algorithm for Boltzmann machines. Cognitive Science, 9:147–169,
1985.
[44] Geoffrey E Hinton and Ruslan R Salakhutdinov. Reducing the dimensionality of data with neural networks. Science,
313(5786):504–507, 2006. Publisher: American Association for the Advancement of Science.
[45] Igor L Markov and Yaoyun Shi. Simulating quantum computation by contracting tensor networks. SIAM Journal on
 13

Computing, 38(3):963–981, 2008.

[46] Glen Evenbly and Guifré Vidal. Tensor network states and geometry. Journal of Statistical Physics, 145:891–918, 2011.
[47] Artur Garcı́a-Sáez and José I Latorre. An exact tensor network for the 3sat problem. Quantum Information & Compu-
tation, 12(3-4):283–292, 2012.
[48] Johnnie Gray and Stefanos Kourtis. Hyper-optimized tensor network contraction. arXiv preprint arXiv:2002.01935, 2020.
[49] Feng Pan and Pan Zhang. Simulation of quantum circuits using the big-batch tensor network method. Physical Review
Letters, 128(3):030501, 2022.
[50] Feng Pan, Keyang Chen, and Pan Zhang. Solving the sampling problem of the sycamore quantum circuits. Physical
Review Letters, 129(9):090502, 2022.
[51] Gleb Kalachev, Pavel Panteleev, and Man-Hong Yung. Recursive multi-tensor contraction for XEB verification of quantum
circuits. arXiv preprint arXiv:2108.05665.
[52] Roman Schutski, Taras Khakhulin, Ivan Oseledets, and Dmitry Kolmakov. Simple heuristics for efficient parallel tensor
contraction and quantum circuit simulation. Physical Review A, 102(6):062614, 2020.
[53] Cupjin Huang, Fang Zhang, Michael Newman, Xiaotong Ni, Dawei Ding, Junjie Cai, Xun Gao, Tenghui Wang, Feng
Wu, Gengyan Zhang, et al. Efficient parallelization of tensor network contraction for simulating quantum computation.
Nature Computational Science, pages 1–10, 2021.
[54] Cupjin Huang, Mario Szegedy, Fang Zhang, Xun Gao, Jianxin Chen, and Yaoyun Shi. Alibaba cloud quantum development
platform: Applications to quantum algorithm design. type: article.
[55] Sergio Boixo, Sergei V Isakov, Vadim N Smelyanskiy, Ryan Babbush, Nan Ding, Zhang Jiang, Michael J Bremner, John M
Martinis, and Hartmut Neven. Characterizing quantum supremacy in near-term devices. Nature Physics, 14(6):595–600,
2018.
[56] Christopher J. Wood, Jacob D. Biamonte, and David G. Cory. Tensor networks and graphical calculus for open quantum
systems. Quantum Info. Comput., 15(9–10):759–811, jul 2015.
[57] Thomas E O’Brien, B Tarasinski, and Leo DiCarlo. Density-matrix simulation of small surface codes under current and
projected experimental noise. npj Quantum Information, 3(1):1–8, 2017.
[58] Cupjin Huang, Xiaotong Ni, Fang Zhang, Michael Newman, Dawei Ding, Xun Gao, Tenghui Wang, Hui-Hai Zhao,
Feng Wu, Gengyan Zhang, Chunqing Deng, Hsiang-Sheng Ku, Jianxin Chen, and Yaoyun Shi. Alibaba cloud quantum
development platform: Surface code simulations with crosstalk. type: article.
[59] Scott Aaronson and Daniel Gottesman. Improved simulation of stabilizer circuits. Phys. Rev. A, 70:052328, Nov 2004.
[60] Craig Gidney. Stim: a fast stabilizer circuit simulator. Quantum, 5:497, July 2021.
[61] James R. Seddon, Bartosz Regula, Hakop Pashayan, Yingkai Ouyang, and Earl T. Campbell. Quantifying quantum
speedups: Improved classical simulation from tighter magic monotones. PRX Quantum, 2:010345, Mar 2021.
[62] Hakop Pashayan, Joel J. Wallman, and Stephen D. Bartlett. Estimating outcome probabilities of quantum circuits using
quasiprobabilities. Phys. Rev. Lett., 115:070501, Aug 2015.
[63] Ryan S. Bennink, Erik M. Ferragut, Travis S. Humble, Jason A. Laska, James J. Nutaro, Mark G. Pleszkoch, and
Raphael C. Pooser. Unbiased simulation of near-clifford quantum circuits. Phys. Rev. A, 95:062337, Jun 2017.
[64] Kaifeng Bu and Dax Enshan Koh. Efficient classical simulation of clifford circuits with nonstabilizer input states. Phys.
Rev. Lett., 123:170502, Oct 2019.
[65] Sergey Bravyi, Dan Browne, Padraic Calpin, Earl Campbell, David Gosset, and Mark Howard. Simulation of quantum
circuits by low-rank stabilizer decompositions. Quantum, 3:181, September 2019.
[66] Hammam Qassim, Joel J. Wallman, and Joseph Emerson. Clifford recompilation for faster classical simulation of quantum
circuits. Quantum, 3:170, August 2019.
[67] Yifei Huang and Peter Love. Approximate stabilizer rank and improved weak simulation of clifford-dominated circuits
for qudits. Phys. Rev. A, 99:052307, May 2019.
[68] Vasilis Samoladas. Improved bdd algorithms for the simulation of quantum circuits. In Dan Halperin and Kurt Mehlhorn,
editors, Algorithms - ESA 2008, pages 720–731, Berlin, Heidelberg, 2008. Springer Berlin Heidelberg.
[69] George F Viamontes, Igor L Markov, and John P Hayes. Quantum circuit simulation. Springer Science & Business Media,
2009.
[70] Hidefumi Hiraishi and Hiroshi Imai. Bdd operations for quantum graph states. In Shigeru Yamashita and Shin-ichi
Minato, editors, Reversible Computation, pages 216–229, Cham, 2014. Springer International Publishing.
[71] Philipp Niemann, Robert Wille, David Michael Miller, Mitchell A. Thornton, and Rolf Drechsler. Qmdds: Efficient
quantum function representation and manipulation. IEEE Transactions on Computer-Aided Design of Integrated Circuits
and Systems, 35(1):86–99, 2016.
[72] Alwin Zulehner and Robert Wille. Advanced simulation of quantum computations. IEEE Transactions on Computer-
Aided Design of Integrated Circuits and Systems, 38:848–859, 2019.
[73] Stefan Hillmich, Igor L Markov, and Robert Wille. Just like the real thing: Fast weak simulation of quantum computation.
In 2020 57th ACM/IEEE Design Automation Conference (DAC), pages 1–6. IEEE, 2020.
[74] Xin Hong, Xiangzhen Zhou, Sanjiang Li, Yuan Feng, and Mingsheng Ying. A tensor network based decision diagram for
representation of quantum circuits. ACM Trans. Des. Autom. Electron. Syst., 27(6), jun 2022.
[75] M. Van den Nest. Simulating quantum computers with probabilistic methods. arXiv e-prints, page arXiv:0911.1624,
November 2009.
[76] Yipeng Huang, Steven Holtzen, Todd Millstein, Guy Van den Broeck, and Margaret Martonosi. Logical abstractions for
noisy variational quantum algorithm simulation. In Proceedings of the 26th ACM International Conference on Architectural
Support for Programming Languages and Operating Systems, pages 456–472, 2021.
 14

[77] Md Sajid Anis, Héctor Abraham, R Agarwal AduOffei, Gabriele Agliardi, Merav Aharoni, Ismail Yunus Akhalwaya, Gadi
Aleksandrowicz, Thomas Alexander, Matthew Amy, Sashwat Anagolum, et al. Qiskit: An open-source framework for
quantum computing, 2021.
[78] Fang Zhang, Cupjin Huang, Michael Newman, Junjie Cai, Huanjun Yu, Zhengxiong Tian, Bo Yuan, Haihong Xu, Junyin
Wu, Xun Gao, et al. Alibaba cloud quantum development platform: Large-scale classical simulation of quantum circuits.
arXiv preprint arXiv:1907.11217, 2019.
[79] Cirq, a python framework for creating, editing, and invoking noisy intermediate scale quantum (nisq) circuits. https:
//github.com/quantumlib/Cirq.
[80] Tyson Jones, Anna Brown, Ian Bush, and Simon C Benjamin. Quest and high performance simulation of quantum
computers. Scientific reports, 9(1):1–11, 2019.
[81] Xiu-Zhe Luo, Jin-Guo Liu, Pan Zhang, and Lei Wang. Yao.jl: Extensible, efficient framework for quantum algorithm
design. arXiv preprint arXiv:1912.10877, 2019.
[82] Juliana Kaizer Vizzotto and Bruno Crestani Calegaro. Qjava: A monadic java library for quantum programming. Revista
de Informática Teórica e Aplicada, 22(1):242–266, 2015.
[83] Nathaniel Johnston, Alessandro Cosentino, and Vincent Russo. Qetlab: Qetlab v0.9, January 2016.
[84] Scott Aaronson and Lijie Chen. Complexity-theoretic foundations of quantum supremacy experiments. arXiv preprint
arXiv:1612.05903, 2016.
[85] Edwin Pednault, John A. Gunnels, Giacomo Nannicini, Lior Horesh, and Robert Wisnieff. Leveraging secondary storage
to simulate deep 54-qubit sycamore circuits, 2019.
[86] Sergio Boixo, Sergei V Isakov, Vadim N Smelyanskiy, and Hartmut Neven. Simulation of low-depth quantum circuits as
complex undirected graphical models. arXiv preprint arXiv:1712.05384, 2017.
[87] Igor L Markov, Aneeqa Fatima, Sergei V Isakov, and Sergio Boixo. Quantum supremacy is both closer and farther than
it appears. arXiv preprint arXiv:1807.10749, 2018.
[88] Chu Guo, Yong Liu, Min Xiong, Shichuan Xue, Xiang Fu, Anqi Huang, Xiaogang Qiang, Ping Xu, Junhua Liu, Shenggen
Zheng, et al. General-purpose quantum circuit simulator with projected entangled-pair states and the quantum supremacy
frontier. arXiv preprint arXiv:1905.08394, 2019.
[89] Stefanos Kourtis, Claudio Chamon, Eduardo R Mucciolo, and Andrei E Ruckenstein. Fast counting with tensor networks.
arXiv preprint arXiv:1805.00475, 2018.
[90] Xun Gao, Marcin Kalinowski, Chi-Ning Chou, Mikhail D Lukin, Boaz Barak, and Soonwon Choi. Limitations of linear
cross-entropy as a measure for quantum advantage. arXiv preprint arXiv:2112.01657, 2021.
[91] Feng Pan and Pan Zhang. Simulating the sycamore quantum supremacy circuits, 2021.
[92] Yong Liu, Xin Liu, Fang Li, Haohuan Fu, Yuling Yang, Jiawei Song, Pengpeng Zhao, Zhen Wang, Dajia Peng, Huarong
Chen, et al. Closing the” quantum supremacy” gap: achieving real-time simulation of a random quantum circuit using a
new sunway supercomputer. In Proceedings of the International Conference for High Performance Computing, Networking,
Storage and Analysis, pages 1–12, 2021.
[93] Yu Tomita and Krysta M Svore. Low-distance surface codes under realistic quantum noise. Physical Review A,
90(6):062320, 2014.
[94] Mitsuki Katsuda, Kosuke Mitarai, and Keisuke Fujii. Simulation and performance analysis of quantum error correction
with a rotated surface code under a realistic noise model. arXiv preprint arXiv:2204.11404, 2022.
[95] Kentaro Heya, Yasunari Suzuki, Yasunobu Nakamura, and Keisuke Fujii. Variational quantum gate optimization, 2018.
[96] Sumeet Khatri, Ryan LaRose, Alexander Poremba, Lukasz Cincio, Andrew T. Sornborger, and Patrick J. Coles. Quantum-
assisted quantum compiling. Quantum, 3:140, may 2019.
[97] Kunal Sharma, Sumeet Khatri, M Cerezo, and Patrick J Coles. Noise resilience of variational quantum compiling. New
Journal of Physics, 22(4):043006, apr 2020.
[98] Tyson Jones and Simon C. Benjamin. Robust quantum compilation and circuit optimisation via energy minimisation.
Quantum, 6:628, January 2022.
[99] Peter D. Johnson, Jonathan Romero, Jonathan Olson, Yudong Cao, and Alán Aspuru-Guzik. Qvector: an algorithm for
device-tailored quantum error correction, 2017.
[100] Xiaosi Xu, Simon C. Benjamin, and Xiao Yuan. Variational circuit compiler for quantum error correction. Phys. Rev.
Applied, 15:034068, Mar 2021.
[101] Agustin Di Paolo, Thomas E Baker, Alexandre Foley, David Sénéchal, and Alexandre Blais. Efficient modeling of
superconducting quantum circuits with tensor networks. npj Quantum Information, 7(1):1–11, 2021.
[102] Andrew W. Cross, Lev S. Bishop, Sarah Sheldon, Paul D. Nation, and Jay M. Gambetta. Validating quantum computers
using randomized model circuits. Phys. Rev. A, 100:032328, Sep 2019.
[103] Jianxin Chen, Dawei Ding, Cupjin Huang, and Linghang Kong. Linear cross entropy benchmarking with clifford circuits.
arXiv preprint arXiv:2206.08293, 2022.