Quantum Circuit Proof Notes

I'm going through some lecture notes on quantum computing by Childs. The lecture notes are dense, so I'm rewriting the formulas and adding personal notes to help me understand. On a quantum computer, any unitary operation can be applied to qubits, in theory. This section deals with approximating arbitrary unitary gates.

Preliminaries

A unitary gate corresponds to a unitary matrix: any matrix that meets the following condition.

\begin{equation*}
  UU^{\dagger} = I
\end{equation*}

The adjoint of a unitary gate is its own inverse.

A list of equivalent conditions is availiable on Wikipedia.

Conveniently, the determinent of a unitary matrix is always \[1\].

\begin{equation*}
  ||A|| = 1
\end{equation*}

In the context of quantum computing, this is easy to remember. The application of any quantum circuit starts and ends with a normalized ket, \[\vert \psi \rangle\]. The ket must be normalized, a unit vector, for the sum of all outcome probablities to equal \[1\], unity. Knowing this, it's easy to remember that any quantum circuit must take a normalized input ket to a normalized output ket. A matrix with a determenent of \[1\] is guranteed to preserve the magnitude of its input vector. This is a bit confusing; I've mixed around cause and effect, but it does make it easy to remember that unitary gates have a determenent of \[1\].

Subadditivity of Errors

On an actual quantum computer, actual gate operations are only approximations of ideal gate operations. Unitarity is guranteed, but there will be some error. We can define the error as the determinent of the difference between some desired gate matrix \[A\] and an actual gate matrix \[B\]: that is \[||A - B||\]. If we have a threshold \[\epsilon\], then our approximation is fine so long as \[||A - B|| < \epsilon\].

It is of great interest how the error rate of multiple operations grow. We will prove that the error rate of a sequence of gates within the error threshold is at most the sum of each gate's error rate:

\begin{equation*}
 ||\prod_{n = 1}^{t} A_{i} - \prod_{n = 1}^{t} B_{i} || < \epsilon
\end{equation*}

The proof is by induction.

In the base case, \[t = 1\]. This is trivial.

\begin{equation*}
 ||\prod_{n = 1}^{1} A_{i} - \prod_{n = 1}^{1} B_{i} || = || A_{i} - B_{i} || < \epsilon
\end{equation*}

The recursive case:

\begin{equation*}
 || \prod_{n = k + 1}^{1} A_{i} - \prod_{n = k + 1}^{1} B_{i} ||
\end{equation*}

We can add in these terms because they add to zero.

\begin{equation*}
=   || \prod_{n = k + 1}^{1} A_{i} - A_{k + 1} \\ \prod_{n = k}^{1} B_{i} + A_{k + 1} \prod_{n = k}^{1} B_{i} - \prod_{n = k + 1}^{1} B_{i} ||
\end{equation*}

By the triangle inequality, we know that the sum of the magnitudes is less than or equal to the magnitude of the sum; the sum of a triangles two shortest sides can only be as long as the longest side.

\begin{equation*}
\le || \prod_{n = k + 1}^{1} A_{i} - A_{k + 1} \prod_{n = k}^{1} B_{i} || \, \, \, + \, \, \,  || A_{k + 1} \prod_{n = k}^{1} B_{i} - \prod_{n = k + 1}^{1} B_{i} ||
\end{equation*}

We can factor some terms.

\begin{equation*}
= || (A_{k+1}) (\prod_{n = k}^{1} A_{t} - \prod_{n = k}^{1} B_{t}) || + || \prod_{n = k}^{1} B_{n} (A_{k+1} - B_{k + 1}) ||
\end{equation*}

Now remember that A and B are both guranteed to be unitary. They both have a deteriment of 1. Fortunately, the determinent of products is the product of determinents: || AB || = || A || || B ||.

\begin{equation*}
= || \prod_{n = k}^{1} A_{t} - \prod_{n = k}^{1} B_{t} || + || A_{k+1} - B_{k + 1} ||
\end{equation*}

So we have our recursive case:

\begin{equation*}
 || \prod_{n = k + 1}^{1} A_{i} - \prod_{n = k + 1}^{1} B_{i} || \le || \prod_{n = k}^{1} A_{t} - \prod_{n = k}^{1} B_{t} || + || A_{k+1} - B_{k + 1} ||
\end{equation*}

This shows a linear error growth.

Examples

To drive this home, here's a concrete example with a three gate system.

Suppose we have an ideal program:

\begin{equation*}
A_1 A_2 A_3
\end{equation*}

And an actual program:

\begin{equation*}
B_1 B_2 B_3
\end{equation*}

We assume each gate is within some known error bound.

\begin{equation*}
|| A_1 - B_1 || \le \epsilon
\end{equation*}

\begin{equation*}
|| A_2 - B_2 || \le \epsilon
\end{equation*}

\begin{equation*}
|| A_3 - B_3 || \le \epsilon
\end{equation*}

Now lets expand our program's error rate and see what we get:

\begin{equation*}
|| A_1 A_2 A_3 - B_1 B_2 B_3 || \le || A_1 A_2 - B_1 B_2 || + || A_3 - B_3 ||
\end{equation*}

Let's expand the 2 gate program:

\begin{equation*}
|| A_1 A_2 - B_1 B_2 || \le || A_1 - B_1 || + || A_2 - B_2 ||
\end{equation*}

If we combine the two equations, we see that the error rate of our entire program is less than or equal to the sum of the individual gate error rates.

\begin{equation*}
|| A_1 A_2 A_3 - B_1 B_2 B_3 || \le  || A_1 - B_1 || + || A_2 - B_2 || + || A_3 - B_3 ||
\end{equation*}

This is what was expected. Awesome!

Constructing Qubits

This is under construction.