→ Exam

Passed the exam in the afternoon on March 6, 2025! | Slides

Proposal¶

Title¶

Efficient Quantum Error Correction via Non-Unital Channels and Algorithmic Cooling

Abstract¶

The realization of fault-tolerant quantum computation fundamentally depends on the implementation of effective quantum error correction (QEC) techniques to mitigate the influence of noise in quantum systems. Conventional QEC protocols, while robust, are often hindered by the frequent necessity of resetting ancillary qubits, resulting in significant overheads in terms of quantum resources and operational complexity. In this proposal, I explore the integration of non-unital channels with algorithmic cooling (AC) as a potential framework for efficient QEC, aimed at minimizing these resource-intensive requirements.

Non-unital channels are characterized by their entropy-reducing properties, which positions them as a compelling component in enhancing QEC protocols. By incorporating these channels with AC, this work endeavors to develop a self-contained mechanism for cooling ancillary qubits, thereby eliminating the need for continual external resetting. This approach draws conceptual parallels to the operation of a quantum refrigerator but is specifically adapted for applicability within near-term quantum computational architectures.

The proposed research will focus on the practical feasibility of these integrated techniques, particularly in the context of realistic gate imperfections and the resource limitations intrinsic to current quantum processors. Through a comprehensive analysis of these factors, I intend to elucidate the technical obstacles and identify potential optimizations that could enable more resource-efficient QEC. Ultimately, this work aims to contribute to the realization of fault-tolerant quantum computation, particularly in the context of near-term quantum devices.

Candidacy Exam¶

Committee¶

Prof. Liang Jiang liangjiang@uchicago.edu
Prof. Aashish Clerk aaclerk@uchicago.edu
Prof. Andrew Cleland anc@uchicago.edu

Date and Time¶

Thursday March 6, 2025 | 02:00 PM - 04:00 PM

Location¶

MeMo 123

Requirements¶

Coursework¶

Term	Course	Title	Professor	Grade
2023 AUT	MENG 31400	Advanced Quantum Engineering	Tian Zhong	A-
2023 AUT	MENG 36500	Quantum Optics	Alexander High	A
2023 AUT	MENG 37500	Quantum Measurements and Metrology	Peter Maurer	A
2024 WIN	MENG 37400	Advanced Quantum Information and Computation	Liang Jiang	A
2024 SPR	CMSC 39100	Phys of Computation	Bill Fefferman	A
2024 SUM	DIGS 30000	Digital Humanities	Clovis Gladstone	A
2024 SUM	PLSC 30901	Game Theory	Monika Nalepa	A
2024 AUT	PHYS 34100	Grad Quantum Mechanics-1	Jeffrey Harvey	A
2025 WIN	PHYS 34200	Grad Quantum Mechanics-2	Jeffrey Harvey	A

green : Thematic courses.
blue : In-Depth courses.
red : Broad Electives courses.

Slides¶

Slides on Cloudflare

Flow (chain of thought)

畫一個樹狀圖branches: 有 q Communication, q Sensing, q Computation. 我的research is in the branch of q Computation; 接下來再往下分 physical levels 和 logical levels. 我的research is in between of the physical levels and logical

my presentation will be broken down into 3 parts:

a short introduction on what's been done? (previuos papers)
what's my contributions / some preliminary results? (actually all from IBM 😭)
what's the thing I am going to do in the future?

My project is not on Q communication, it's on Q. computation. it's built on top of (這一頁可以做一個表格):

Gottesman & Ben-Or's Quantum Refrigerator in 2013,
and Moussa's On Heat-Bath Algorithmic Cooling and its Implementation in Solid-State NMR, and Algorithmic Cooling of Spins: A Practicable Method for Increasing Polarization
and the recent IBM paper 2024.

To explain the common ideas of these papers, I am gonna start it this way:

the reason we are doing error correction and mitigation today, is because noise destructs the output of quantum computation.
to be more precisely, it has been shown in some paper (cite some here) that without QEC, the output flattens after some depth (cite some paper, maybe from Bill fefferman?) 可以從introduction第一段最後一句給出: As a result, the output of such noisy random circuits approaches a uniform distribution exponentially with increasing circuit depth [6, 7, 14, 15], rendering circuits with superlogarithmic depth classically simulable.
but actually, the main idea of this whole project is to ask ourselves again: how long can we do quantum computation (depth), under the influence of noise, without performing active QEC cycle (that invloves mid-circuit measurement)? (可以放google willow的paper's supplementary material page 11右下角的 "要improve decoding latency" 的那句話)
it turns out that we cannot answer to this question without first knowing which kind of noise we are dealing with throughout the course of computation.

so, as you can see from the title, I am gonna utilize the Nonunital noise, which is defined as the kind of noise which does not preserve the identity operator, to make our computation depth longer.

when I say "longer", I mean the depth can be scaled from blablabla (log, see the abstract) to blablabla (好像是any, but comes with the N and D overhead) (as will be shown in latter slides).
and the reason why we classifies noise based on whether they preserve the identity operator or not, is because the identity operator corresponds to the maximum mixed state, which is also the state with the highest possible entropy. So if a channel do not preserves the identity operator, it means that it may sometimes reduce the entropy of the input state, which is somehow equivalent to increasing the information that a quantum system may carry over time.
but of course, we cannot just use the nonunital noise as it is, because the information it gives us is often not the information we want at the end of the computation. So we will have to be clever and design a way to extract and manipulate the information that the nonunital noise gives us, to make it become meaningful at the end of our computation.
and so In this project, I will illustrate a scheme that combines the nonunital noise with algorithmic cooling and the concatenated QEC code scheme, to achieve this goal.

and another thing I want to say about this project is that it's also closely related to the real-world scenarios, because actually in various platforms, nonunital noise is more significant than the unital noise. For example (這邊可以做一個表):

in blablabla system we have amplitude damping or photon scattering or blablabla, which causes nonunital noise. (use the table from perplexity/chatgpt)
list experimental papers that shows nonunital being magnitude larger than unital noise (numbers, can search with gpt).

And now, maybe you have also noticed from my title that I mentioned "algorithmic cooling". and this, is somehow a gadget that can be used in combintaion with the nonunital noise:

So basically, algorithmic cooling represents a family of quantum circuits, consists of unitary gates, which can boost the polarization of a qubit.
and by saying "polarization", I mean the population difference between the qubit being in the 0 state or 1 state, which is essentially the z-projection of the Bloch vector (which take values from -1 to 1) if we first diagonalize that qubit in computational basis.
But if you look at our final goal, which is to get a qubit with maximum polarization of 1, you might think: why don't we just measure that qubit in the computational basis and, if it's 0 then we're good and if it's 1 then flip it back to 0? That's because: we cannot forget that in this entire setting, we restrict ourselves to NOT use mid-circuit measurements, which is also kind of relevant to today's platforms' capability (meas + feed forward time can't catch up on the speed of pure quantum computing, 這邊show google's paper's supple material).
so in this case, what algo-cooling does, for example, is that if we feed in 5 qubits with polarization all being 0.1, then at the end we can get 1 qubit with polarization 0.9 and the other 4 qubits with polarization 0.01 (near max-mixed state) (of course this number is exaggerated, but you get the idea). And during this process we only need unitary gates, no mid-circuit meas. needed.

but you might wonder: WHY do we wanna boost the polarization of a qubit?

remember our final goal is to do QC for as long depth as possible, and in order to do this, we can achieve this goal in a 2-step-logic:
first, we can use QEC code that does not require mid-circuit meas. This scheme do exist (show出那篇PRX Quantum, and in the later slide I will demonstrate with 713 code), but in order to accomplish that, we will need continuous fresh supply of qubits initialized in the ket0 state during the course of computation.
And also on the other hand, we all know in fault-tolerant QC, we can draw from a set of logical gates that enables universal computation. for example, H, CNOT, T, S or Toffoli gates.
and if now, we intoduce another psuedo-logical gate into this pack of cards, called "RESET" gate, which its action is to take a qubit as input and "magically" restore that qubit in the ket0 state, if we can do this, then we satisfy the requirement for implementing the QEC code.

So I am gonna describe the 2-step-logic in this way:

throughout this project, our first step is to check the feasibility of creating such a "RESET" gate, and moreover we can even give an instance of construction for such pseduo-logic gate.
And our second step is to show that, with the help of this "RESET" gate, we can achieve a longer depth of computation, under the influence of nonunital noise, without the need of mid-circuit measurement.
And I will show the feasibility of this using a concatenated code scheme in the latter slides.
For both of these steps, I will calculate the qubit (width) overhead and the depth (time) overhead for realizing respective goals. And at the end we can consolidate overheads from both steps to see if the scheme is feasible and efficient.

First we start from building this RESET pseduo-logic gate: (and here we remind you again the goal is to take N-qubit as input (all in polarization of same value, of course less than 1) and spit out at least one qubit in the ket0 state (or as pure as possible) and leave the other qubits in a "i don't care" state., by using only unitary gates)

now I am gonna demonstrate with a toy model.
if we only has 1 qubit as input, then apparently we cannot boost its polarization using unitary gates because unitary gates preserves the length of Bloch vector.
if we have 2 qubits as input, for example we have input polarization: (0.2, 0.2), do you think it's possible to output something like (0.21, 0.19)? No! (then I can tell them the same thing I said to Sagar on Saturday: spectrum preserve blablabla, permutation blablabla, 畫一個集合的圖, classical permutation把unitary transformatino包起來, 所以既然permutation做不到的, 那unitary也做不到)
so, with the same logic from the explanation, we show that it is possible to boost the first qubit's polarization of the given 3 qubits in theory. And in practice we can give an actual gate sequence, for example (like the cnot and CSWAP).
so we start from 3 qubtis. plot the boost line for this 3-qubit Q.Compressor.
it can take any value of polarization as input, and output the first qubit with a boosted polarization as this line shows. (with the other 2 qubits in a "i don't care" state)
if the boosted polarization is not enough close to 1 yet, then we can take that outputed qubit as the input of next round of Q.Compressor, and repeat the process, and so on. This is essentially a concatenated Q.Compressor scheme. (IBM called it a compund Q.Compressor)
graphically, this is equal to climbing a ladder sandwiched between the convex curve and the line x=y between 0 to 1 region.
you might think now oh! then we can start from any state and arrive at 1 if we have enough cycles of Q.Compressor. But actually we have missed the worst possible case: which is we start from the maximally mixed state, and we can never get out of it.(in theory)
so this is where nonunital noise comes into play.

So the idea is: we can utilize nonunital noise to always avoid the worst case scenario: we can first knock the state into a max mixed state (by applying random unitary gates, i mean haar random), then let the qubit settle for an amount of time. When I say "settling" here:

the settling process is to essentially do nothing on the qubit, which only let the nonunital noise acts on the qubit, and we can show that the qubit will be driven away from the maximally mixed state.
show lemma and show the depth overhead of settling process. (there's no qubit overhead for this process)
this ensures we always don't start from the max mixed state.
the key idea which lead to this Lemma is to first characterize the nonunital noise using 2 parameters that are crucial to our project: the noise strength and the fixed-point purity parameter.
define and explain the fixed-point purity parameter. for example, the fixed point for amplitude damping is just the North pole of Bloch Sphere, and that purity is 1. And for the depolarizing channel, the fixed point is the center of the bloch sphere, and that purity is 0.
next define and explain the noise strength. diamond distance. (maybe show the diamond distance between 2 qubit states and the numerical values it can take) and explain that we can somehow engineer the noise strength in some quantum platform?? (Xu Qian's paper?)
i can qualitatively explain the settling time and the achievable polarization of the qubit. (if eta is blablablab or kappa is blablabl then we have higher blablabla)

So now, we gauranteed that we have a non-zero starting point. Then subsequently we can start climbing the ladder of the curve in the Q.Compressor scheme. (I can illustrate that there might be some sweet spot such that the total time of Settling + cQC is minimized. -> can add this into Future plans)

can show that I treat the 2 asymptotic regime separately from the main-rise segment. (use different bounds to make it tighter)
so here is the N-overhead and D-overhead for achieving a desired polarization, if we are given max mixed state as input. Then here is the worst case because we are using the big-O notation (?
so these are essentially how we can construct a RESET gate by the following thought:
if we view it as a pseudo-logical gate, then its behavior is to take one qubit (of any state) as input, and output the same qubit but in the ket0 state. (or as pure as possible), and those qubit- and depth-overheads can be treated as the cost of implementing this pseudo-logical gate. (just like those of implementing H, CNOT, T, S, Toffoli gates)
and of course in reality, we cannot separate this cQC from noise. So after taking this effect of noise into consideration (apply it after each layer of gates), and also considering the time for swapping qubits within the d-dimensional lattice (這裡解釋一下lattice, 最後説説例如google, ibm都是2D的), we arrived at a slightly modified scaling.
I can also qualitatively explain the scaling behavior of the scheme (how eta and kappa affects the performance), and show that it is feasible to achieve the goal of boosting the polarization of a qubit to 1, without the need of mid-circuit measurement.

At this stage I can show that "Quantum Fridge" nice illustration to the professors, and state that the right-half part is completed. And now we move on to the left-half part, which is to show that with the help of this RESET gate, we can achieve a longer depth of computation, under the influence of nonunital noise, without the need of mid-circuit measurement.

this part is more tricky and technical heavy to show to the professors without explicitly writing out the form of logical operators so I will have to somehow be simple and intuitive throughout the presentation, and also considers the common grounds of the professors, say things that they are familiar with and easy to keep up.

can explain how the "2"-factor in the QEC gadget's definition comes from. (because for [[7,1,3]] code, it can correct up to 1 error only, so in order to cause a logical error on that level, we need at least 2 physical errors to happen within the same encoding block)
show the recursive relation of how noise strength within different levels of concatenation scales down.

at the end I somehow modified some of the bounds in that IBM paper (but did not affect the final scaling behavior) In the future, I will try out investigating broader settings of the scheme, because in this projectm for now, I have only proved the "feasibility" of the scheme, but am not sure if the Scaling (bound) is tight yet. So I will try to find out whether there are better ways to implement the scheme, or whether there are better schemes that can achieve the same goal. And maybe do some numerical simulations to see if any asymptotic behaviors emerge.

In this project, I only consider traditional algo-cooling, but maybe we can also do HB-AC, which has a better effect in cooling down (without needing mid-circuit measurement)

do some research on how the 713 code can be realized through majority vote, so that when being asked by the professors, I can answer to the details.

I need to describe more about swapping qubits, like: how the linear length scales with the qubit number (1/d power)

Show that "QEC without mid-circuit measurement" requires the following condition to be satisfied first: transversal CNOT gate, so hence low distance CSS code.

Future directions:

this bound is not tight, so we can try to find a tighter bound.
numerics to see if any asymptotic behavior emerges.
try out HB-AC, which has a better effect in cooling down (without needing mid-circuit measurement)

Thank you for your attention, and I am happy to take any questions.

denote whichever Lemma or Definition on the paper that I am referring to in the slides, so that the professors can follow up.