Return to Answer

In a topological code where you're doing gates by code deformation, there's no real distinction between idling and doing Clifford operations. Furthermore, Clifford operations can be sequenced through space instead of through time so they can't really slow down the execution of the algorithm. So you might as well just go slightly lower level and focus on how many logical qubits you are protecting for how many surface code cycles while the non-Cliffords are worked through.

You estimate space usage by knowing how many logical qubits are needed and how much overhead is needed for things like routing and how many magic state factories you're going to be running in parallel.

You estimate time by knowing how many non-Cliffords operations you have, and how long it will take for the factories to provide all of them (and also how long the serial chains can be vs the reaction time of the control system).

With those two quantities you can know how many logical-qubit-rounds need to be protected. For example, if you're gonna run for an hour and you do one surface code cycle per microsecond and there are 1000 logical qubits then the algorithm has roughly 10 billion logical qubit cycles to protect. So you pick a code distance that suppresses error rates below 1 in 10 billion.

For example, here is a figure of activity over ~150 microseconds of an addition from https://arxiv.org/abs/1905.09749:

The red boxes are magic state factories for Toffoli gates. The stuff outside the red boxes is qubits sitting idle waiting to be operated on. Just outside the red boxes you can see them being routed into the hallways between the red boxes. The stuff between the red boxes is a bunch of routing, a bunch of conditional corrections for the gate teleportation through the magic states, and, hidden away inside each of the blue boxes, contributing almost nothing... the two Clifford gates per ripple carry step from Cucarro's adder.

This is why only the non-Clifford gates matter. Because all the ceremony around getting them done so often just completely determines how the computation is laid out. The Cliffords from the original circuit are almost after-thoughts in comparison.

To be extremely concrete: if you are counting Cliffords before you start counting routing overhead, you are almost certainly doing things in the wrong order. Routing overhead is way more significant, and it is completely invisible in the original circuits before being compiled down into the surface code.

In a topological code where you're doing gates by code deformation, there's no real distinction between idling and doing Clifford operations. Furthermore, Clifford operations can be sequenced through space instead of through time so they can't really slow down the execution of the algorithm. So you might as well just go slightly lower level and focus on how many logical qubits you are protecting for how many surface code cycles while the non-Cliffords are worked through.

You estimate space usage by knowing how many logical qubits are needed and how much overhead is needed for things like routing and how many magic state factories you're going to be running in parallel.

You estimate time by knowing how many non-Cliffords operations you have, and how long it will take for the factories to provide all of them (and also how long the serial chains can be vs the reaction time of the control system).

With those two quantities you can know how many logical-qubit-rounds need to be protected. For example, if you're gonna run for an hour and you do one surface code cycle per microsecond and there are 1000 logical qubits then the algorithm has roughly 10 billion logical qubit cycles to protect. So you pick a code distance that suppresses error rates below 1 in 10 billion.

For example, here is a figure of activity over ~150 microseconds of an addition from https://arxiv.org/abs/1905.09749:

The red boxes are magic state factories for Toffoli gates. The stuff outside the red boxes is qubits sitting idle waiting to be operated on. Just outside the red boxes you can see them being routed into the hallways between the red boxes. The stuff between the red boxes is a bunch of routing, a bunch of conditional corrections for the gate teleportation through the magic states, and, hidden away inside each of the blue boxes, contributing almost nothing... the two Clifford gates per ripple carry step from Cucarro's adder.

This is why only the non-Clifford gates matter. Because all the ceremony around getting them done so often determine how the computation is laid out. The Cliffords from the original circuit are almost after-thoughts in comparison. Storage time of idle qubits does matter, but you determine that time based on how long the non-Clifford operations take.

To be extremely concrete: if you are counting Cliffords before you start counting routing overhead or storage overhead, you are almost certainly doing things in the wrong order. Routing overhead is way more significant than Clifford gates, and it is completely invisible in the original circuits before being compiled down into the surface code.

In a topological code where you're doing gates by code deformation, there's no real distinction between idling and doing Clifford operations. Furthermore, Clifford operations can be sequenced through space instead of through time so they can't really slow down the execution of the algorithm. So you might as well just go slightly lower level and focus on how many logical qubits you are protecting for how many surface code cycles while the non-Cliffords are worked through.

You estimate space usage by knowing how many logical qubits are needed and how much overhead is needed for things like routing and how many magic state factories you're going to be running in parallel.

You estimate time by knowing how many non-Cliffords operations you have, and how long it will take for the factories to provide all of them (and also how long the serial chains can be vs the reaction time of the control system).

With those two quantities you can know how many logical-qubit-rounds need to be protected. For example, if you're gonna run for an hour and you do one surface code cycle per microsecond and there are 1000 logical qubits then the algorithm has roughly 10 billion logical qubit cycles to protect. So you pick a code distance that suppresses error rates below 1 in 10 billion.

For example, here is a figure of activity during an addition from https://arxiv.org/abs/1905.09749:

The red boxes are magic state factories for Toffoli gates. The stuff outside the red boxes is qubits sitting idle waiting to be operated on. Just outside the red boxes you can see them being routed into the hallways between the red boxes. The stuff between the red boxes is a bunch of routing, a bunch of conditional corrections for the gate teleportation through the magic states, and, hidden away inside each of the blue boxes, contributing almost nothing... the two Clifford gates per ripple carry step from Cucarro's adder.

This is why only the non-Clifford gates matter. Because all the ceremony around getting them done so often just completely determines how the computation is laid out. The Cliffords from the original circuit are almost after-thoughts in comparison.

To be extremely concrete: if you are counting Cliffords before you start counting routing overhead, you are almost certainly doing things in the wrong order. Routing overhead is way more significant, and it is completely invisible in the original circuits before being compiled down into the surface code.

In a topological code where you're doing gates by code deformation, there's no real distinction between idling and doing Clifford operations. Furthermore, Clifford operations can be sequenced through space instead of through time so they can't really slow down the execution of the algorithm. So you might as well just go slightly lower level and focus on how many logical qubits you are protecting for how many surface code cycles while the non-Cliffords are worked through.

You estimate space usage by knowing how many logical qubits are needed and how much overhead is needed for things like routing and how many magic state factories you're going to be running in parallel.

You estimate time by knowing how many non-Cliffords operations you have, and how long it will take for the factories to provide all of them (and also how long the serial chains can be vs the reaction time of the control system).

With those two quantities you can know how many logical-qubit-rounds need to be protected. For example, if you're gonna run for an hour and you do one surface code cycle per microsecond and there are 1000 logical qubits then the algorithm has roughly 10 billion logical qubit cycles to protect. So you pick a code distance that suppresses error rates below 1 in 10 billion.

For example, here is a figure of activity over ~150 microseconds of an addition from https://arxiv.org/abs/1905.09749:

The red boxes are magic state factories for Toffoli gates. The stuff outside the red boxes is qubits sitting idle waiting to be operated on. Just outside the red boxes you can see them being routed into the hallways between the red boxes. The stuff between the red boxes is a bunch of routing, a bunch of conditional corrections for the gate teleportation through the magic states, and, hidden away inside each of the blue boxes, contributing almost nothing... the two Clifford gates per ripple carry step from Cucarro's adder.

This is why only the non-Clifford gates matter. Because all the ceremony around getting them done so often just completely determines how the computation is laid out. The Cliffords from the original circuit are almost after-thoughts in comparison.

To be extremely concrete: if you are counting Cliffords before you start counting routing overhead, you are almost certainly doing things in the wrong order. Routing overhead is way more significant, and it is completely invisible in the original circuits before being compiled down into the surface code.

In a topological code where you're doing gates by code deformation, there's no real distinction between idling and doing Clifford operations. Furthermore, Clifford operations can be sequenced through space instead of through time so they can't really slow down the execution of the algorithm. So you might as well just go slightly lower level and focus on how many logical qubits you are protecting for how many surface code cycles while the non-Cliffords are worked through.

You estimate space usage by knowing how many logical qubits are needed and how much overhead is needed for things like routing and how many magic state factories you're going to be running in parallel.

You estimate time by knowing how many non-Cliffords operations you have, and how long it will take for the factories to provide all of them (and also how long the serial chains can be vs the reaction time of the control system).

With those two quantities you can know how many logical-qubit-rounds need to be protected. For example, if you're gonna run for an hour and you do one surface code cycle per microsecond and there are 1000 logical qubits then the algorithm has roughly 10 billion logical qubit cycles to protect. So you pick a code distance that suppresses error rates below 1 in 10 billion.

In a topological code where you're doing gates by code deformation, there's no real distinction between idling and doing Clifford operations. Furthermore, Clifford operations can be sequenced through space instead of through time so they can't really slow down the execution of the algorithm. So you might as well just go slightly lower level and focus on how many logical qubits you are protecting for how many surface code cycles while the non-Cliffords are worked through.

You estimate space usage by knowing how many logical qubits are needed and how much overhead is needed for things like routing and how many magic state factories you're going to be running in parallel.

You estimate time by knowing how many non-Cliffords operations you have, and how long it will take for the factories to provide all of them (and also how long the serial chains can be vs the reaction time of the control system).

With those two quantities you can know how many logical-qubit-rounds need to be protected. For example, if you're gonna run for an hour and you do one surface code cycle per microsecond and there are 1000 logical qubits then the algorithm has roughly 10 billion logical qubit cycles to protect. So you pick a code distance that suppresses error rates below 1 in 10 billion.

For example, here is a figure of activity during an addition from https://arxiv.org/abs/1905.09749:

The red boxes are magic state factories for Toffoli gates. The stuff outside the red boxes is qubits sitting idle waiting to be operated on. Just outside the red boxes you can see them being routed into the hallways between the red boxes. The stuff between the red boxes is a bunch of routing, a bunch of conditional corrections for the gate teleportation through the magic states, and, hidden away inside each of the blue boxes, contributing almost nothing... the two Clifford gates per ripple carry step from Cucarro's adder.

This is why only the non-Clifford gates matter. Because all the ceremony around getting them done so often just completely determines how the computation is laid out. The Cliffords from the original circuit are almost after-thoughts in comparison.

To be extremely concrete: if you are counting Cliffords before you start counting routing overhead, you are almost certainly doing things in the wrong order. Routing overhead is way more significant, and it is completely invisible in the original circuits before being compiled down into the surface code.