Goal of Quantum Advantage Experiment: make a real-world quantum computer to do some task that is believed practically impossible for any classical computer

Google's Team: Oct. 2019, simulated 53-qubit ($^ \times 9 = 54$ but one qubit broke), 1000-gate quantum circuit.

Why is hard to build quantum computer: shielding from outside noise (since they become "trash" if outside noise get entangled with qubits)

It is not hard, though, to prevent accidental "measurement" because... there is no such thing called "measurement", all it really happen is entangle.

Hardness: - implementing 0-qubit "do nothing" gate is hard - implementing 1-qubit gate is not much harder - implementing 2-qubit gates is very hard

A typical setup is to have grids of qubit, and do pair-wise operation like reduction.

Classical Fault Tolerance

Today's computer has gate failure around $p \llless 2^{-64}$ which is not a problem at all.

John von Neumann: universally $\exists p_c > 0$ such that the failure probability of a single classical gate $p < \p_c \implies \text{can make any m-gate circuit into a fault-tolerant version with } O(m \log m) \text{ gates}$

Lower bound is also $\Omega(m \log m)$. The exact value of $p_c$ depends on gate set, noise model, fault-tolerance scheme.

Quantum Fault Tolerance

Quantum Fault-Tolerance Theorem: universally $\exists p_q > 0$ such that the failure probability of a single quantum gate $p < \p_q \implies \text{can make any m-gate circuit into a fault-tolerant version with } O(m \text{poly}(\log m)) \text{ gates}$ where $p_q \simeq 10^{-6}$

However, $10^{-6}$ is very very challenging to achieve. With the fanciest, not a all realistic algorithm (ie. think about having 100+ extra physical qubits packed near one logical qubit for that gate to have such probability), we can only reach $10^{-3}, 10^{-2}$

Steps:

1. Decide a arbitrarily fixed (draw from random) many-qubits unitrary operation $U$ to implement
2. If we feed $|0...0\rangle$ to $U$, then if we measure, we get a probability distribution $P_G$ in $\{0, 1\}^n$ where $n=53 \text{ qubits}$
3. Task: create a machine that output distribution $P_G$ (probability distribution of ground truth)
4. Solution: build an actual quantum computer implementing $U|0...0\rangle$, that will generate distribution $P_Q$, hoping $P_Q \simeq P_G$
5. Assert: no classical computer running less than 10 years could produce $P_C \simeq P_G$

However, Google expected $P_Q$ is no where close to $P_G$, but $P_C$ will perform even worse.

Arbitrary Unitrary: a arbitrary unitrary operation would likely to generate a heavy tail distribution on the output $f(x) = C \cdot e^{-t}/N$ where $x \in \{0, 1\}^n$ is string and $N = 2^n$ is the number of possible strings.

• Median $x$: $P_G(x) \simeq \frac{\ln 2}{N}$

• Expected $x$: $E_{x \sim P_G}[P_G(x)] = \frac{2}{N}$

1. run $P_Q$ 1 million time and average result, they got $\frac{1.002}{N}$ which is just barely better than $\frac{1}{N}$ random guess but "with statistical significance".
2. approximate $P_G$ by making mini version of $P_G$ and show that the average value approach $\frac{2}{N}$ (try brute force using less qubits, try simpler kinds of semirandom circuits there efficient classical algorithm exists)
3. claim for any classical computer, the best we can do is $\frac{1}{N}$.

Some Criticism:

• IBM claimed they can compute all $2^{53}$ values of $P_G(x)$ in a few days, but they never did it

• Classical computer may be able to do better than $\frac{1}{N}$

• Several follow-up paper gave faster algorithm for computing $P_G(x)$ for similar but slightly simpler circuit that models $G$.

Table of Content