Improved Simulation of

Stabilizer Circuits
0 0 1 0 0 +ZI
0 1 0 0 0 +IX
1 0 0 0 0 +XI
0 0 0 1 0 +IZ

Scott Aaronson (UC Berkeley)

Joint work with Daniel Gottesman (Perimeter)
 Quantum Computing:
New Challenges for Computer
Architecture
• Can’t speculate on a measurement and
then roll back
• Cache coherence protocols violate no-
cloning theorem
• How do you design and debug circuits that you
can’t even simulate efficiently with existing tools?
Our Approach: Start With A Subset
of Quantum Computations
Stabilizers (Gottesman 1996): Beautiful formalism
that captures much (but not all) of quantum weirdness
– Linear error-correcting codes
– Teleportation
– Dense quantum coding
– GHZ (Greenberger-Horne-Zeilinger) paradox
Gates Allowed In Stabilizer Circuits
1. Controlled-NOT
|00|00, |01|01, |
10|11, |11|10
AMAZING FACT
These gates are NOT
2. Hadamarduniversal—Gottesman
|0(|0+|1)/2
&
|1
Knill showed (|0-|1)/2
how to
H simulate them quickly on a
1 classical
0 computer
3. Phase = To see why we|0|0, |1i|1
need some
0 i
group theory…
P
4. Measurement of a single qubit
 Pauli Matrices: Collect ‘Em All
1 0 0 1 0 -i 1 0
I= X= Y= Z=
0 1 1 0 i 0 0 -1
X2=Y2=Z2=I XY=iZ YZ=iX ZX=iY
XZ=-iY ZY=-iX YX=-iZ

Unitary matrix U stabilizes a quantum state | if U|

 = |. Stabilizers of | form a group

X stabilizes |0+|1 -X stabilizes |0+|1

Y stabilizes |0+i|1 -Y stabilizes |0-i|1
Z stabilizes |0 -Z stabilizes |1
 Gottesman-Knill Theorem
If | can be produced from the all-0 state by just
CNOT, Hadamard, and phase gates, then | is
stabilized by 2n tensor products of Pauli matrices or
their opposites (where n = number of qubits)

So the stabilizer group is generated by log(2 n)=n

such tensor products

Indeed, | is then uniquely determined by these

generators, so we call | a stabilizer state
Goal: Using a classical computer, simulate an n-
qubit CNOT/Hadamard/Phase computer.
Gottesman & Knill’s solution: Keep track of n
generators of the stabilizer group
Each generator uses 2n+1 bits: 2 for each Pauli
matrix and 1 for the sign. So n(2n+1) bits total
Example: CNOT(12)
|01+|11 |01+|10
+XI Updating stabilizers
+X
-IZ takes only O(n) steps X
OUCH! -ZZ
But measurement takes O(n3) steps by Gaussian
elimination
Our Faster, Easier-To-Implement
Tableau Algorithm
Idea: Instead of n(2n+1) bits, store 2n(2n+1) bits
• n stabilizers S1,…,Sn, 2n+1 bits each Together
generate
• n “destabilizers” D1,…,Dn
full Pauli
group

Maintain the following invariants:

• Di’s commute with each other
• Si anticommutes with Di
• Si commutes with Dj for ij
 I: xij=0, zij=0 + phase: ri=0
X: xij=1, zij=0 - phase: ri=1
Y: xij=1, zij=1
Z: xij=0, zij=1

State: |00
xij bits zij bits ri bits

Destabilizers D1
1 0 0 0 0 +XI
D2 0 1 0 0 0 +IX
Stabilizers S1
0 0 1 0 0 +ZI
S2 0 0 0 1 0 +IZ
Hadamard on qubit a:
For all i{1,…,2n}, swap xia with zia, and set
ri := ri  xiazia

State: |00
Destabilizers
1 0 0 0 0 +XI
0 1 0 0 0 +IX
Stabilizers
0 0 1 0 0 +ZI
0 0 0 1 0 +IZ
 State: |00+|10
Destabilizers
0 0 1 0 0 +ZI
0 1 0 0 0 +IX
Stabilizers
1 0 0 0 0 +XI
0 0 0 1 0 +IZ
CNOT from qubit a to qubit b:
For all i{1,…,2n}, set xib := xib  xia and
zia := zia  zib

State: |00+|10
Destabilizers
0 0 1 0 0 +ZI
0 1 0 0 0 +IX
Stabilizers
1 0 0 0 0 +XI
0 0 0 1 0 +IZ
 State: |00+|11
Destabilizers
0 0 1 0 0 +ZI
0 1 0 0 0 +IX
Stabilizers
1 1 0 0 0 +X
0 0 1 1 0 X
+Z
Phase on qubit a:
For all i{1,…,2n}, set ri := ri  xiazia, then set
zia := zia  xia

State: |00+|11
Destabilizers
0 0 1 0 0 +ZI
0 1 0 0 0 +IX
Stabilizers
1 1 0 0 0 +X
0 0 1 1 0 X
+Z
 State: |00+i|11
Destabilizers
0 0 1 0 0 +ZI
0 1 0 1 0 +IY
Stabilizers
1 1 0 1 0 +X
0 0 1 1 0 Y
+Z
Measurement of qubit a:
If xia=0 for all i{n+1,…,2n}, then outcome will
be deterministic. Otherwise 0 with ½ probability
and 1 with ½ probability.

State: |00+i|11
Destabilizers
0 0 1 0 0 +ZI
0 1 0 1 0 +IY
Stabilizers
1 1 0 1 0 +X
0 0 1 1 0 Y
+Z
Random outcome:
Pick a stabilizer Si such that xia=1 and set Di:=Si.
Then set Si:=Za and output 0 with ½ probability, and
set Si:=-Za and output with ½ probability, where Za is
Z on ath qubit and I elsewhere. Finally, left-multiply
whatever rows don’t commute with Si by Di
State: |11
Destabilizers
1 1 0 1 0 +X
0 1 0 1 0 Y
0 0 1 0 1 +IY
-ZI
Stabilizers
0 0 1 1 0 +Z
Z
Novel part: How to obtain deterministic
measurement outcomes in only O(n2) steps, without
using Gaussian elimination?
Za must commute with stabilizer, so
n

c S
h 1
h h  Za

for a unique choice of c1,…,cn{0,1}. If we can

determine ci’s, then by summing corresponding Sh’s
we learn sign of Za. Now
n n
ci   ch  Di Sh   Di  ch Sh  Di Z a  mod 2 
h 1 h 1

So just have to check if Di commutes with Za, or

 CHP: An interpreter for “quantum assembly
language” programs that implements our
scoreboard algorithm CHP
Example: Quantum Teleportation Code
Alice’s Qubits

| h1
H c12
|0 H c01
h0
m0
m1
c03
|0 H H |
Bob’s Qubits

c14
|0 c42
h2
|0 c32
Prepare Alice’s part Bob’s part h2
EPR pair
S e c on ds p e r m e a s ure m e nt
1
0.9 β=1.2
β=1.1
Performance
0.8
0.7
β=1.0
β=0.9
of CHP
0.6 β=0.8
β=0.7
0.5 β=0.6
0.4
0.3
0.2
0.1
0
200 600 1000 1400 1800 2200 2600 3000
Number of qubits n

Average time needed to simulate a measurement

after applying βnlogn random unitary gates to n
qubits, on a 650MHz Pentium III with 256MB RAM
 Simulating Stabilizer Circuits is
L-Complete
L = class of problems reducible in logarithmic
space to evaluating a circuit of CNOT gates
Natural, well-studied subclass of P
Conjectured that L  P. So our result means
stabilizer circuits probably aren’t even universal for
classical computation!
Simulating L with stabilizer circuits: Obvious
Simulating stabilizer circuits with L : Harder
 Fun With Stabilizers
How many n-qubit stabilizer states are there?
n 1
2 n
 2
k 0
n k
 1  2  1/ 2o 1  n 2

Can we represent mixed states in the stabilizer

formalism?
YES
Can we efficiently compute the inner product
between two stabilizer states?
YES
 Future Directions
• Measurements (at least some) in O(n) steps?
• Apply CHP to quantum error-correction,
studying conjectures about entanglement in
many-qubit systems…
• Efficient minimization of stabilizer circuits?
• Superlinear lower bounds on stabilizer circuit
size?
• Other quantum computations with efficient
classical simulations: bounded entanglement
(Vidal 2003), “matchgates” (Valiant 2001)…