Ron Cohen

16 ביולי 2022

Google Quantum AI has just now published **a historical landmark** [1] -

*"The first experimental demonstration where quantum error correction begins to improve performance with increasing qubit number, illuminating the path to reaching the logical error rates required for computation."*

If you are constant readers of the newsletter, you already understand the importance of this landmark, but you probably still want to know what Google means by **Surface Code.** As you can understand **from the logo** of the newsletter, this is precisely what I aimed to explain to you in this newsletter.

So what's behind Duffy Duck? You probably understand what a **stabilizer **is if you read the last article.** But restrict yourself look at a 1-dimensional** string of qubits with stabilizers limited to the neighbor on the right and left?

Perskil said in his article from 1997 [2] that **Topological Quantum Computation** can be more fault tolerant than conventional approaches. Once our information is **encoded on some large structure**, it is **less sensitive to local errors**, and the whole structure does not broke. Think of a string with a loop. Minor changes will not change the fact that it is only one loop. It will be used to create a **new kind of Quantum Error Correction scheme**.

So, surface code deals with** tying strings from one side to another**. Those strings are made of a |1⟩ of a qubit. The basic idea is to tie strings from one surface side to another. We **encode the information in the place where they are linked**. There is a vast difference between what you can do by tying a string __from one side to another__ -

than tying the string __from both ends to the same side__ -

Surface Codes use this fact to **encode fault tolerant |0⟩ and |1⟩**. For example, if we consider pink dots as |1⟩ and white dots as |0⟩, a term in the__ logical |0⟩L__ state can look like :

While its __twin term in the logical |1⟩L __state will look like this:

Notice that the second one was created **by tearing the string and reattaching** it on both ends.

__Let's see another example__. When a term in the |0⟩L that looks like this string -

Its twin term in the |1⟩L state will look like this -

The big picture is that the whole state of logical |0⟩L and |1⟩L will look like a **superposition of all possible strings** between the surface's left and right walls.

On the other side, the 2 states are very **well distinguished **because we need a long chain of X flips (logical X gate) to change the |0⟩L into the |1⟩L state (and vice versa). **This unique property promises that random unwanted X flips are unlikely to create such a long chain of X flips because of a very low probability of happening.** This is what makes the surface code so immune to faults.

In the following articles, we will see more examples and understand how surface codes create those states of superposition of strings **using stabilizers** that we already discussed.

*Stay tuned...*

##### References

[1] Acharya, Rajeev et al. "Suppressing quantum errors by scaling a surface code logical qubit." 2022.