Title

layout: true
<slide-template title="Quantum Computing" subtitle="Quantum Error Correction"></slide-template>

---
class: title-slide, center, middle

<title-slide titletype="Lecture" title="Quantum Computing" modulenumber="(CS5070)" subtitle="Quantum Error Correction"></title-slide>

---
# .darkblue[Error Correction]

.more-condensed.no-margin[
- Physical .darkblue[devices are imperfect]
  - .darkblue[for quantum devices even more] true than for classical devices
- .darkblue[Interactions with the environment]
  - makes .darkblue[errors (like decoherence] for quantum devices.darkblue[) more likely]
- E.darkblue[rror must be controlled or compensated]
   - Probability of one step to succeed: $p$
   - .darkblue[Probability of $t$ steps to succeed: $p^t$]
]
<div class="no-margin textcenter">
<img src="../../img/qc/error/SuccessProbability.svg" align="top" style="width:75%"></img>
</div>

---
# Quantum .darkblue[Error]

.reference[<a href="https://doi.org/10.48550/arXiv.0904.2557" target="_blank">[G'09]</a>]

.more-condensed[
- A .darkblue[quantum error can occur] at any time
  - .darkblue[changing the superposition] $\alpha|0\rangle+\beta|1\rangle$ of a qubit to $\alpha'|0\rangle+\beta'|1\rangle$
  - quantum .darkblue[errors can occur in several qubits] at the same time
- .darkblue[Examples of] single-qubit .darkblue[errors:]
<table class="result tablepadding small-font small-margin-top">
<tbody>
<tr>
<th>Name</th><th>Operator</th><th>Effect on $|0\rangle$</th><th>Effect on $|1\rangle$</th>
</tr>
<tr>
<th>Bit Flip</th><td>$X$</td><td>$X|0\rangle=|1\rangle$</td><td>$X|1\rangle=|0\rangle$</td>
</tr>
<tr>
<th>Phase Flip</th><td>$Z$</td><td>$Z|0\rangle=|0\rangle$</td><td>$Z|1\rangle=-|1\rangle$</td>
</tr>
<tr>
<th>Rotation</th><td>$R_\theta$</td><td>$R_\theta|0\rangle=|0\rangle$</td><td>$R_\theta|1\rangle=e^{i\theta}|1\rangle$</td>
</tr>
<tr>
<th>(Full) Decoherence</th><td colspan="3" class="textcenter">$\alpha|0\rangle+\beta|1\rangle\rightarrow\{|0\rangle,|1\rangle\}$</td>
</tr>
</tbody>
</table>
]

---
# .darkblue[Decoherence]

.reference[<a href="https://doi.org/10.48550/arXiv.1904.04323" target="_blank">[SAG'19]</a> Full adders: <a href="http://www.informatik.uni-bremen.de/rev_lib/function_details.php?id=19" target="_blank">EXORCISM-4 optimized function and ESOPSolver v.0 optimized function: reduction of all NOT gates</a>]

.more-condensed.no-margin[
- [SAG'19] runs .darkblue[amplitude and phase damping simulations]
  - .darkblue[Decoherence] (of amplitude and phase) .darkblue[depends on]
     - <span class="darkblue">type of gate</span>
     - <span class="darkblue">input</span>
     - <span class="darkblue">quantum circuit depth</span>
  - simple (logical) <span class="darkblue">optimizations resulting in lower-depth circuits</span> can <span class="darkblue">improve the decoherence by 20%</span>
     - comparing full adders with depths 6 and 9

<table class="small-margin-top result tablesmallpadding small-font">
<tbody>
<tr>
<th>Input</th><th>Gates/Circuits from lowest to highest (amplitude) decoherence</th>
</tr>
<tr>
<td>$\frac{|000\rangle+|001\rangle+|010\rangle+|011\rangle+|100\rangle+|101\rangle+|110\rangle+|111\rangle}{\sqrt{2^3}}$</td>
<td>Phase, T, Toffoli, Fredkin, CNOT, H<br/>(relatively close together)</td>
</tr>
<tr>
<td>$|110\rangle$</td>
<td>CNOT, H, .em[Others], Toffoli</td>
</tr>
<tr>
<td>$|101\rangle$</td>
<td>H, .em[Others], CNOT</td>
</tr>
<tr>
<td>Any input</td>
<td>Full adders (3 qubits $\rightarrow$ sum+carry):<br/>QCKT-1 (depth 6), QCKT-2 (depth 9)</td>
</tr>
</tbody>
</table>
]

---
# (Simple) .darkblue[Classical Repetition Code]

.more-condensed[
- .darkblue[Classical] data:
  - .darkblue[Repetition code] for correction of a single bit-flip:
     - <span class="darkblue">$0\rightarrow 000$</span>
     - <span class="darkblue">$1\rightarrow 111$</span>
  - A .darkblue[single bit flip error]
     - <span class="darkblue">Choosing the majority</span> of the three bits, e.g. $010 \rightarrow 0$
  - In case of rare errors: 1 error is more likely than 2
]

--
.more-condensed[
- .darkblue[How to adapt] this approach for quantum error correction?
]

---
# .darkblue[Barriers] to Quantum Error Correction

.reference[<a href="https://doi.org/10.48550/arXiv.0904.2557" target="_blank">[G'09]</a>]

.condensed.darkblue[
- Measurement destroys superpositions
- No-cloning theorem prevents repetition
- Correction of multiple types of errors
  - e.g., bit flip and phase errors
- How to correct continuous errors and decoherence?
]

--
.condensed[
- .darkblue[Higher circuit depths due to quantum error correction] approaches
  - .darkblue[Can] state-of-the-art .darkblue[quantum computers process these circuit depths?]
]

---
# .darkblue[Quantum Repetition Code] correcting bit flip errors

---
# .darkblue[Quantum Repetition Code - Generate Code]

<table class="fullwidth">
<tbody>
<tr>
<td class="margin-right" style="width:35.09%">
<img src="../../img/qc/error/ErrorCorrection3Qubits1.svg" align="top" class="fullwidth"></img>
</td>
<td style="width:64.91%">Next step:<br/>.darkblue[How to detect qubit flips without measurement and cloning?]</td>
</tr>
<tr>
<td class="purple small-font">$\alpha|0\rangle+\beta|1\rangle\rightarrow \alpha|000\rangle+\beta|111\rangle$</td>
<td></td>
</tbody>
</table>

---
# .darkblue[Quantum Repetition Code - Error Syndrome]

.reference[<a href="https://doi.org/10.48550/arXiv.0904.2557" target="_blank">[G'09]</a>]

<table class="fullwidth">
<tbody>
<tr>
<td class="margin-right" style="width:77.95%">
<img src="../../img/qc/error/ErrorCorrection3Qubits2.svg" align="top" class="fullwidth"></img>
</td>
<td style="width:22.05%">
<table class="small-font tablesmallpadding result">
<tbody>
<tr>
<th>Input</th><th>Error<br/>Syn-<br/>drome</th><th>Action</th>
</tr>
<tr>
<td>$|000\rangle$</td><td rowspan="2"></td><td rowspan="2"></td>
</tr>
<tr>
<td>$|111\rangle$</td>
</tr>
<tr>
<td>$|010\rangle$</td><td rowspan="2" style="background-color:white"></td><td rowspan="2" style="background-color:white"></td>
</tr>
<tr>
<td>$|101\rangle$</td>
</tr>
<tr>
<td>$|100\rangle$</td><td rowspan="2"></td><td rowspan="2"></td>
</tr>
<tr>
<td>$|011\rangle$</td>
</tr>
<tr>
<td>$|001\rangle$</td><td rowspan="2" style="background-color:white"></td><td rowspan="2" style="background-color:white"></td>
</tr>
<tr>
<td>$|110\rangle$</td>
</tr>
</tbody>
</table>
</td>
</tr>
</tbody>
</table>

---
# .darkblue[Quantum Repetition Code - Error Syndrome]

<table class="fullwidth">
<tbody>
<tr>
<td class="margin-right" style="width:77.95%">
<img src="../../img/qc/error/ErrorCorrection3Qubits2.svg" align="top" class="fullwidth"></img>
</td>
<td style="width:22.05%">
<table class="small-font tablesmallpadding result">
<tbody>
<tr>
<th>Input</th><th>Error<br/>Syn-<br/>drome</th><th>Action</th>
</tr>
<tr>
<td>$|000\rangle$</td><td rowspan="2">$|00\rangle$</td><td rowspan="2">None</td>
</tr>
<tr>
<td>$|111\rangle$</td>
</tr>
<tr>
<td>$|010\rangle$</td><td rowspan="2" style="background-color:white">$|11\rangle$</td><td rowspan="2" style="background-color:white">Flip 2nd qubit</td>
</tr>
<tr>
<td>$|101\rangle$</td>
</tr>
<tr>
<td>$|100\rangle$</td><td rowspan="2">$|10\rangle$</td><td rowspan="2">Flip 1st qubit</td>
</tr>
<tr>
<td>$|011\rangle$</td>
</tr>
<tr>
<td>$|001\rangle$</td><td rowspan="2" style="background-color:white">$|01\rangle$</td><td rowspan="2" style="background-color:white">Flip 3rd qubit</td>
</tr>
<tr>
<td>$|110\rangle$</td>
</tr>
</tbody>
</table>
</td>
</tr>
</tbody>
</table>

--
<div class="textcenter darkblue more-more-condensed small-font">
Action: Partially flip second qubit???
</div>

---
# .darkblue[Quantum Repetition Code - Correcting Error]

--
<div class="textcenter darkblue more-more-condensed no-margin small-font">
Input: <span class="smaller-font">$A\otimes E$</span><br/>
After first CCNOT: <span class="smaller-font">$CCNOT\cdot(A\otimes E)=A\otimes E - (\alpha\cdot\beta^2\cdot|00011\rangle+\beta^3\cdot|01011\rangle) + (\beta^3\cdot|00011\rangle+\alpha\cdot\beta^2\cdot|01011\rangle)$<br/>e.g., $\beta=0.9,\alpha\approx 0.43589$, i.e. $\beta^3=0.729,\alpha\cdot\beta^2\approx 0.353, \beta^3-\alpha\cdot\beta^2\approx 0.376$</span>
</div>

--
<div class="textcenter darkblue more-more-condensed no-margin small-font">
Second and third CCNOT also (slightly) change first and third qubit...
</div>

--
<div class="textcenter darkblue more-more-condensed bold small-margin-top small-font">
Here: correction of 3 repeated qubits.<br/>How to correct only 1 qubit?
</div>

---
# .darkblue[Quantum Repetition Code - Correcting Error]

.reference[Michael A. Nielsen,Isaac L. Chuang. Quantum Computation and Quantum Information. Cambridge University Press, 2000]

.more-more-condensed[
<div class="textcenter">
<img src="../../img/qc/error/CorrectingOneQubit.svg" align="top" style="width:70%"></img>
</div>
<table>
<tbody>
<tr>
<td>
<table class="result tablepadding smaller-font">
<tbody>
<tr>
<th>Input (with errors)</th><th>Error Syndrome</th><th>After Correction</th>
</tr>
<tr>
<td>$|000\rangle$</td><td></td><td></td>
</tr>
<tr>
<td>$|001\rangle$</td><td></td><td></td>
</tr>
<tr>
<td>$|010\rangle$</td><td></td><td></td>
</tr>
<tr>
<td class="darkred bold">$|011\rangle$</td><td class="darkred bold"></td><td class="darkred bold"></td>
</tr>
<tr>
<td class="darkred bold">$|100\rangle$</td><td class="darkred bold"></td><td class="darkred bold"></td>
</tr>
<tr>
<td>$|101\rangle$</td><td></td><td></td>
</tr>
<tr>
<td>$|110\rangle$</td><td></td><td></td>
</tr>
<tr>
<td>$|111\rangle$</td><td></td><td></td>
</tr>
</tbody>
</table>
</td>
<td class="small-font padding-left">
Input (with errors): $\alpha|010\rangle+\beta|011\rangle$<br/>
Error Syndrome:<br/>
After Correction:
</td>
</tbody>
</table>
]

---
# .darkblue[Quantum Repetition Code - Correcting Error]

.reference[Michael A. Nielsen,Isaac L. Chuang. Quantum Computation and Quantum Information. Cambridge University Press, 2000]

.more-more-condensed[
<div class="textcenter">
<img src="../../img/qc/error/CorrectingOneQubit.svg" align="top" style="width:70%"></img>
</div>
<table>
<tbody>
<tr>
<td>
<table class="result tablepadding smaller-font">
<tbody>
<tr>
<th>Input (with errors)</th><th>Error Syndrome</th><th>After Correction</th>
</tr>
<tr>
<td>$|000\rangle$</td><td>$|000\rangle$</td><td>$|000\rangle$</td>
</tr>
<tr>
<td>$|001\rangle$</td><td>$|001\rangle$</td><td>$|001\rangle$</td>
</tr>
<tr>
<td>$|010\rangle$</td><td>$|010\rangle$</td><td>$|010\rangle$</td>
</tr>
<tr>
<td class="darkred bold">$|011\rangle$</td><td class="darkred bold">$|011\rangle$</td><td class="darkred bold">$|111\rangle$</td>
</tr>
<tr>
<td class="darkred bold">$|100\rangle$</td><td class="darkred bold">$|111\rangle$</td><td class="darkred bold">$|011\rangle$</td>
</tr>
<tr>
<td>$|101\rangle$</td><td>$|110\rangle$</td><td>$|110\rangle$</td>
</tr>
<tr>
<td>$|110\rangle$</td><td>$|101\rangle$</td><td>$|101\rangle$</td>
</tr>
<tr>
<td>$|111\rangle$</td><td>$|100\rangle$</td><td>$|100\rangle$</td>
</tr>
</tbody>
</table>
</td>
<td class="small-font padding-left">
Input (with errors): $\alpha|010\rangle+\beta|011\rangle$<br/>
Error Syndrome: $\alpha|010\rangle+\beta|011\rangle$<br/>
After Correction: $\alpha|010\rangle+\beta|111\rangle$
</td>
</tbody>
</table>
]

---
# Correcting .darkblue[Phase Errors]

<div class="more-more-condensed no-margin darkblue">
<ul><li>Hadamard transform $H$ exchanges bit flip and phase errors
  <ul><li>$H(\alpha\cdot|0\rangle+\beta\cdot|1\rangle)=\alpha\cdot|+\rangle+\beta\cdot|-\rangle$</li></ul></li>
<li>NOT $X$ operator in Hadamard basis acts like a phase flip
  <ul><li class="smaller-font">$X\cdot|+\rangle=X\cdot\frac{|0\rangle+|1\rangle}{\sqrt{2}}=\left[\begin{array}{cc}0 & 1 \\ 1 & 0\end{array}\right]\cdot\left[\begin{array}{c}\frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}}\end{array}\right]=\left[\begin{array}{c}\frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}}\end{array}\right]=|+\rangle$</li>
  <li class="smaller-font">$X\cdot|-\rangle=X\cdot\frac{|0\rangle-|1\rangle}{\sqrt{2}}=\left[\begin{array}{cc}0 & 1 \\ 1 & 0\end{array}\right]\cdot\left[\begin{array}{c}\frac{1}{\sqrt{2}} \\ -\frac{1}{\sqrt{2}}\end{array}\right]=\left[\begin{array}{c}-\frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}}\end{array}\right]=-|-\rangle$</li></ul></li>
<li>Pauli $Z$ operator in Hadamard basis acts like a bit flip
  <ul><li class="smaller-font">$Z\cdot|+\rangle=Z\cdot\frac{|0\rangle+|1\rangle}{\sqrt{2}}=\left[\begin{array}{cc}1 & 0 \\ 0 & -1\end{array}\right]\cdot\left[\begin{array}{c}\frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}}\end{array}\right]=\left[\begin{array}{c}\frac{1}{\sqrt{2}} \\ -\frac{1}{\sqrt{2}}\end{array}\right]=|-\rangle$</li>
  <li class="smaller-font">$Z\cdot|-\rangle=Z\cdot\frac{|0\rangle-|1\rangle}{\sqrt{2}}=\left[\begin{array}{cc}1 & 0 \\ 0 & -1\end{array}\right]\cdot\left[\begin{array}{c}\frac{1}{\sqrt{2}} \\ -\frac{1}{\sqrt{2}}\end{array}\right]=\left[\begin{array}{c}\frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}}\end{array}\right]=|+\rangle$</li></ul></li>
</ul>
$\Rightarrow$ Repetition code in Hadamard basis <span class="small-font">$\alpha\cdot|+\rangle+\beta\cdot|-\rangle\rightarrow\alpha\cdot|+++\rangle+\beta\cdot|---\rangle$</span> corrects a phase error!
</div>

---
# Correcting .darkblue[Phase Errors]

- also called .darkblue[Sign Flip Code]

---
# Correcting both .darkblue[Bit and Phase Flips]:<br/>.darkblue[Shor Code]

.reference[<a href="https://doi.org/10.48550/arXiv.0904.2557" target="_blank">[G'09]</a> <a href="https://doi.org/10.1103/PhysRevA.52.R2493" target="_blank">[S'95]</a> <a href="https://www.cs.miami.edu/home/burt/learning/Csc670.052/pR2493_1.pdf" target="_blank">Preprint</a>]

<div class="more-more-condensed darkblue">
<ul><li>Use bit flip code and sign flip code at once (using 9 qubits):<br><span class="small-font">$\alpha\cdot|0\rangle+\beta\cdot|1\rangle\rightarrow\alpha\cdot(|000\rangle+|111\rangle)^{\otimes 3}+\beta\cdot(|000\rangle-|111\rangle)^{\otimes 3}$</span><br/>
<table class="result tablesmallpadding small-margin-bottom small-font">
<tbody>
<tr>
<th>Correction of</th><th>by</th>
</tr>
<tr>
<th>Bit Flip Error</th><td>Repetition of Bit: 000, 111</td>
</tr>
<tr>
<th>Phase/Sign Flip Error</th><td>Repetition of Phase: $+++$, $---$</td>
</tr>
</tbody>
</table>
</li>
<li>Arbitrary error can be modeled by a unitary transform <span class="small-font">$U=c_0\cdot I+c_1\cdot X+c_2\cdot Y+c_3\cdot Z$</span>, where <span class="small-font">$c_0,\cdots,c_3$</span> are complex constants 
<ul><li>Bit Flip Error: <span class="small-font">$U=X$</span></li>
<li>Phase/Sign Flip Error: <span class="small-font">$U=Z$</span></li>
<li>Both Bit and Phase/Sign Flip Errors: <span class="small-font">$U=i\cdot Y$</span>, where <span class="small-font">$Y=i\cdot X\cdot Z$</span></li>
</li>
</ul>
<li>Shor code can correct arbitrary 1-qubit errors due to linearity [G'09]
<ul><li> For small errors <span class="small-font">$\epsilon\cdot (a_X\cdot X+a_Y\cdot Y+a_Z\cdot Z)$</span>, where <span class="small-font">$a_i\in\{0,1\}$</span>:<br/>After error correction the quantum state will be correct within <span class="small-font">$O(\epsilon^2)$</span> [G'09]
</li></ul>
</li>
</ul>
</div>

---
# .darkblue[Quantum circuit of the Shor code]

--
.more-more-condensed[
- There are .darkblue[good codes with less qubits]
  - e.g., .darkblue[5-Qubit Code]
     - <span class="darkblue">smallest quantum error correcting code</span> protecting a logical qubit from any arbitrary single qubit error
]

---
#.darkblue[Quantum Threshold Theorem]<br/>.small-font36[(also called .darkblue[Quantum Fault-Tolerance Theorem])]

.reference[<a href="https://doi.org/10.1017/CBO9780511976667" target="_blank">[NC'00]</a> <a href="https://doi.org/10.1137/S0097539799359385" target="_blank">[AB'08]</a> <a href="https://doi.org/10.1126/science.279.5349.342" target="_blank">[KLZ'98]</a> <a href="https://doi.org/10.1016/S0003-4916(02)00018-0" target="_blank">[K'03]</a> <a href="https://doi.org/10.1109%2FSFCS.1996.548464" target="_blank">[S'96]</a> <a href="https://www.scottaaronson.com/democritus/lec14.html" target="_blank">[AG'06]</a> <a href="https://doi.org/10.1038/s41586-022-05434-1" target="_blank">[A+'23]</a>]

<div class="more-more-condensed darkblue">
<span class="small-font24">
A quantum circuit on .small-font[$n$] qubits and containing $p(n)$ gates may be simulated with probability of error at most .small-font[$\varepsilon$] using .small-font[$O\left(\text{log}^{c}\left(\frac{p(n)}{\varepsilon}\right)\cdot p(n)\right)$] gates (for some constant .small-font[$c$]) on hardware whose components fail with probability at most .small-font[$p$], provided .small-font[$p$] is below some constant threshold, .small-font[$p\lt p_{th}$], and given reasonable assumptions about the noise in the underlying hardware.</span>
</div>

--
<div class="more-more-condensed darkblue">
<ul class="no-margin"><li>$\Rightarrow$ quantum computers can be made fault-tolerant</li>
<li>Result was proven (for various error models) [AB'08] [KLZ'98] [K'03] [S'96], in experiments suppressing logical errors by scaling a quantum error-correcting code [A+'23]</li>
<li><span class="em">"The entire content of the Threshold Theorem is that you're correcting errors faster than they're created. That's the whole point, and the whole non-trivial thing that the theorem shows. That's the problem it solves."</span> [AG'06]</li>
</ul>
</div>

---
# .darkblue[Noisy Intermediate-Scale Quantum (NISQ)]
.reference[<a target="_blank" href="https://doi.org/10.22331/q-2018-08-06-79">[P'18]</a>]

.more-more-condensed.no-margin.darkblue[
<div class="textcenter">
<img src="../../img/qc/intro/NISQ.svg" align="top" width="70%"></img>
</div>

- quantum computers with 50-100 qubits: noise in quantum gates limits the size of quantum circuits that can be executed reliably
- Such NISQ devices may be able to perform tasks which surpass the capabilities of today’s classical digital computers with application areas like quantum chemistry, optimization & machine learning
- 100-qubit quantum computers are (only) intermediate technologies
]

---
# .darkblue[Timeline of \#Qubits vs. Threshold]
.reference[<a href="https://en.wikipedia.org/wiki/List_of_quantum_processors" target="_blank">Data for figure 1</a> <a href="https://research.ibm.com/blog/ibm-quantum-roadmap" target="_blank">2</a> <a href="https://quantumai.google/research" target="_blank">3</a> <a href="https://doi.org/10.1007/s42354-021-0342-8" target="_blank">4</a> <a href="https://www.dwavesys.com/media/xvjpraig/clarity-roadmap_digital_v2.pdf" target="_blank">5</a> <a href="https://education.jlab.org/qa/mathatom_05.html" target="_blank">#Atoms</a> <a href="https://www.popularmechanics.com/space/a27259/how-many-particles-are-in-the-entire-universe/" target="_blank">#Particles</a> <a href="https://doi.org/10.1103%2Fphysreva.80.052312" target="_blank">[FSG'13]</a> <a href="https://doi.org/10.48550/arXiv.0803.0272" target="_blank">ArXiv</a> <a href="https://doi.org/10.1038%2Fnature23460" target="_blank">[CTV'17]</a> <a href="https://arxiv.org/abs/1612.07330" target="_blank">ArXiv</a> <a href="https://doi.org/10.48550/arXiv.1208.0928" target="_blank">[FMC'12]</a> <a href="https://ai.googleblog.com/2023/02/suppressing-quantum-errors-by-scaling.html" target="_blank">[NG'23]</a> <a href="https://doi.org/10.1038/s41586-022-05434-1" target="_blank">[A+'23]</a>]

.more-more-condensed.no-margin.small-font[
<div class="textcenter">
<img src="../../img/qc/intro/YearVersusNumberOfQubits.svg" align="top" width="82%"></img>
</div>
- .darkblue[Threshold] for the surface code: .darkblue[$\approx$ 1%] [FSG'13] .darkblue[$\Rightarrow\approx$ 1,000-10,000 physical qubits per logical data qubit] for the surface code at a 0.1% probability of a depolarizing error [FMC'12][CTV'17] 
- $\varepsilon_X:=$ logical error rate of distance $X$ surface code, today $\frac{\epsilon_3}{\epsilon_5}=1.04$.<br/><span class="darkblue"><span><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mfrac><mrow><msub><mi>ε</mi><mn>3</mn></msub></mrow><mrow><msub><mi>ε</mi><mn>17</mn></msub></mrow></mfrac><mo>=</mo><mn>4</mn></mrow><annotation encoding="application/x-tex">\frac{\varepsilon_3}{\varepsilon_17}=4</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="strut" style="height: 0.711492em;"></span><span class="strut bottom" style="height: 1.15659em; vertical-align: -0.4451em;"></span><span class="base"><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 0.711492em;"><span class="" style="top: -2.655em;"><span class="pstrut" style="height: 3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathit mtight">ε</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 0.317314em;"><span class="" style="top: -2.357em; margin-left: 0em; margin-right: 0.0714286em;"><span class="pstrut" style="height: 2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathrm mtight">17</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height: 0.143em;"></span></span></span></span></span></span></span></span><span class="" style="top: -3.23em;"><span class="pstrut" style="height: 3em;"></span><span class="frac-line hide-tail" style="height: 0.04em;"><svg width="400em" height="400em" viewBox="0 0 400000 400000" preserveAspectRatio="xMinYMin slice"><path d="M0 0 h400000 v400000 h-400000z M0 0 h400000 v400000 h-400000z"></path></svg></span></span><span class="" style="top: -3.4101em;"><span class="pstrut" style="height: 3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathit mtight">ε</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height: 0.317314em;"><span class="" style="top: -2.357em; margin-left: 0em; margin-right: 0.0714286em;"><span class="pstrut" style="height: 2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathrm mtight">3</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height: 0.143em;"></span></span></span></span></span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height: 0.4451em;"></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mrel">=</span><span class="mord mathrm">4</span></span></span></span></span> using 577 physical qubits $\Rightarrow$ logical error rate below 1 in $10^6$</span> [NG'23] [A+'23]
]

---
# .darkblue[Summary & Conclusions]

.more-more-condensed[
- .darkblue[Error] Correction
  - Classical .darkblue[Repetition Code]
  - .darkblue[Barriers] to Quantum Error Correction
  - .darkblue[Quantum Repetition Code]
     - Correcting <span class="darkblue">Bit Flips</span>
     - Correcting <span class="darkblue">Phase/Sign Flips</span>
  - .darkblue[Shor Code] (using 9 qubits)
     - correcting arbitrary 1-qubit errors
  - still codes with less qubits (minimum 5 qubits)
- .darkblue[Quantum Threshold] (/Fault-Tolerance) .darkblue[Theorem]
  - fault-tolerant quantum computers are possible
  - .darkblue[1,000-10,000 physical qubits per logical data qubit] in practice
]