7
$\begingroup$

A common task to perform during quantum computation on the surface code is moving qubits from one place to another. There are standard ways to do this within the surface code, but I was wondering what the actual fundamental limits are. If we forget about the fact that we're using the surface code, and just focus on the fact that we have a planar grid of noisy qubits with nearest-neighbor connections, and a fast classical computer noting measurements and generally helping out, how fast can we move quantum information across that patch?

Given an operation failure rate $\epsilon$, a patch of length L and height H, and the ability operations in parallel with some duration T, how long does it take to move N qubits from the left side of the patch to the right side of the patch?

Improve this question
$\endgroup$
7
  • 1
    $\begingroup$ In the setting you describe in the last paragraph, why not prepare entangled states beforehand and teleport? $\endgroup$
    – Norbert Schuch
    Commented Nov 18, 2018 at 11:04
  • $\begingroup$ @NorbertSchuch Sure, that's a valid strategy, except you don't start with pre-prepared entanglement between the left and right halve sides. You have to set it up by communicating quantum information over the patch. Which comes back to the original question of what the quantum bandwidth is. $\endgroup$
    – Craig Gidney
    Commented Nov 18, 2018 at 19:43
  • $\begingroup$ Well, I'm trying to understand the rules of the game more precisely. Is it a fair setting to say that input data (qubits) are provided on the qubits in the leftmost column on demand, and read out on demand from the rightmost column, and you want to know the rate at which you can transfer a large number N>>L,H of qubits? Are all operations (=two-qubit Hamiltonians) allowed? $\endgroup$
    – Norbert Schuch
    Commented Nov 18, 2018 at 22:19
  • $\begingroup$ @NorbertSchuch Within the LxH patch, all single-qubit operations including measurement are allowed. All two-qubit operations are allowed, but only between adjacent qubits. Every operation takes time T. Operations can be performed in parallel if they affect disjoint qubits. The sender and receiver are on opposite sides of the patch. They are arbitrarily powerful quantum computers. They can communicate classically, and they can interact with the outermost layer of qubits on their side of the patch. There is an arbitrarily powerful classical computer to process measurement results and choreograph $\endgroup$
    – Craig Gidney
    Commented Nov 19, 2018 at 4:46
  • $\begingroup$ Ah. So any operation, but constant time? Why not interactions which I can switch on/off? $\endgroup$
    – Norbert Schuch
    Commented Nov 19, 2018 at 11:18

1 Answer 1

Reset to default
0
$\begingroup$

1 Cell Movement

The steps to move qubit in only 1 cell are:

1 - Finish full-cycle finish in all array
2 – before next cycle start – instruct software – "don’t mesure Z stab below"
3 – Also 2 X stabs are converted – 4 CNOTs -> 3
4 – Get X6 (measure X of Q6) used to track erros + influence new X_L
5 – turn on the Z stab above + arms of X stabs
6 – perform surface code cycle
7 – wait (d-1) cycles to establish stab value in time

enter image description here

L Cells Movement

Multi_cell movement, done very quick because you turn the stabilizers off very quickly, in total $d+1$ cycles (2 for the turn on and off, + $(d-1)$ to stabilize fault-tolerance), and not dependent on the length of movement $L$. The time per each stabilizer cycle is limited mainly by the measurement time. All you have to make sure that your $\epsilon$ - the rate of physical failure, will be below the threshold

refer to the article "Surface codes: Towards practical large-scale quantum computation" to see more details

enter image description here

Improve this answer
$\endgroup$
1
  • $\begingroup$ This is an example of a standard way to move the logical qubit. Which is perfectly reasonable, but in the question I do specify that I'm not interested in the standard ways of moving the qubits but rather in the fundamental limits. For example, by repeatedly distilling Bell pairs instead of moving important data, you can use error detection instead of just error correction. Which should be more efficient. Or you could reduce the code distance of the surface code then concatenate on a block code in order to reach an ultimately better coding rate. $\endgroup$
    – Craig Gidney
    Commented Feb 21, 2022 at 10:41

Not the answer you're looking for? Browse other questions tagged or ask your own question.