Recursive Clifford noise reduction

arXiv:2511.22624 · quant-ph · Submitted 2025-11-27 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.

Kai: I'm Kai.

Mira: And I'm Mira, here with Lev.

Kai: We're looking at the paper: "Recursive Clifford noise reduction".

Title and authors: Kai: So Mira Kai I'm looking at this paper by Aharon Brodutch and Gregory Baimetov titled Recursive Clifford noise reduction. It sounds like they're trying to tackle a problem where you have these big Clifford circuits, right?

Mira: Exactly. They are proposing a recursive version of the CliNR scheme. The title itself hints at how they’re solving the scaling issue for those larger circuits we talked about before, Kai.

Lev: For me, what I see immediately is that they're dealing with circuit size versus error rate trade-offs. Standard CliNR has a limitation on the subcircuits it can handle, but this recursive version aims to overcome that.

Kai: Right. The summary says they build these Clifford subcircuits offline and only inject them into the main circuit after some verification steps are passed. It's like having a quality control process layered on top of the computation itself.

Mira: That layering is key because it lets them handle much bigger circuits than the original version, which was limited to those subcircuits being smaller than one over p squared. This is a big step for utility scale quantum computation.

Lev: I see they introduce a recursive structure using what they call a CliNR tree. The idea there is that when you break down a long circuit into smaller ones, the errors within those smaller blocks are managed better at each level of recursion.

Kai: So if you have these subcircuits, and then you recursively apply CliNR to them, the unverified steps get checked at the next level up. It's like having nested checks on your quality control process.

Mira: That nesting is what allows them to reach a vanishing logical error rate when the physical error rate p approaches zero. The paper suggests that as long as p goes to zero, you can get arbitrarily small logical errors with this method <ref:2511.22624#pg1>.

Lev: And they give us some concrete numbers for the overheads. They say the qubit overhead is (two D plus one) times n plus one qubits, where D is the depth of that tree, and it's at most twenty-four times s over p to gates <ref:2511.22624#pg1>.

Title and authors: Kai: Two D plus one qubits... that sounds manageable when you think about superconducting hardware constraints. What I find interesting is that they show this recursive method can actually beat the original CliNR in terms of logical error rate for large circuit sizes if you keep the gate overhead similar <ref:2511.22624#pg1>.

Mira: That comparison is important because it means we can potentially use less physical resource for a better result when we're dealing with those larger circuits that are actually relevant to real applications. It shows an advantage in a realistic near-term setting, especially with idle noise <ref:2511.22624#pg1>.

Lev: The authors also developed some tools to analyze this performance, like a Markov model and Lemma three which gives logical error bounds based on the depth of the tree D <ref:2511.22624#pg3>. They showed that with a uniformly bounded implementation, you can ensure every step in this recursion has its input and output errors controlled by np <ref:2511.22624#pg8>.

Kai: So, what does this actually mean for someone building a machine? It means we can design circuits that are much larger than before without immediately hitting the error rate ceiling of the old CliNR approach.

Mira: It means we can achieve a vanishing logical error rate for any size circuit, provided p goes to zero, which is what we need for fault tolerance eventually <ref:2511.22624#pg9>.

Lev: But there's a practical catch with the qubit count. They found that the qubit overhead scales linearly with the depth D of this tree as n gets very large, so you still get that (two D plus one) times n plus one qubits <ref:2511.22624#pg7>.

Kai: I noticed they mention a specific gate overhead bound too, which is at most twenty four times s over p to gates <ref:2511.22624#pg1>. That's still quite high for some parts of the circuit, but maybe better than what we expected for this kind of error reduction.

Mira: It depends heavily on the parameter regime, Kai. The analysis shows that at around two one times s over p to gates with seven zero n, you can see a significant advantage when there's idle noise present <ref:2511.22624#pg1>.

Lev: So the main thing they are emphasizing is that the recursive scheme offers an advantage specifically at fixed gate overheads when circuit sizes are large enough <ref:2511.22624#pg8>. It’s about efficiency in terms of resource usage for a given error reduction goal.

Title and authors: Kai: So, to wrap up, this paper on Recursive Clifford noise reduction shows that we can tackle the scaling problem for Clifford circuits by using a recursive decomposition strategy <ref:2511.22624#pg1>. It allows us to get vanishing logical errors for arbitrary circuit sizes when p goes to zero.

Mira: And the improvement is that it lets us achieve lower logical error rates than the original CliNR if we keep the gate overhead under a certain threshold <ref:2511.22624#pg1>. It's about getting better performance with more resources, in a controlled way.

Lev: From an engineering standpoint, this points toward implementing near-term utility scale computation by using this recursive approach to manage large circuits <ref:2511.22624#pg8>. The qubit overhead scales polynomially with the depth of the tree when p approaches zero, which is good for feasibility.

Kai: It’s a lot of detail on the tree construction, but essentially they've shown a way to keep errors under control in circuits that were previously too big for this kind of noise reduction technique <ref:2511.22624#pg3>.

Mira: And while it shows promise for reducing logical errors, the paper flags a limitation: the original method, and even the recursive one before this work, has issues with errors during those resource state injection steps not being detected <ref:2511.22624#pg3>.

Lev: That's a real caveat. So while the logic is sound for vanishing error rates when p is small, we still have to deal with those unverified injections in practice <ref:2511.22624#pg3>.

Kai: So the main point of this paper, Recursive Clifford noise reduction, is that we can get better logical error rates on bigger circuits by using a recursive injection strategy <ref:2511.22624#pg8>. It’s about finding a practical way to manage those errors in larger systems.

Mira: I think the big implication here is showing that we can push the limits of what standard error mitigation techniques can do for Clifford circuits, opening up possibilities for more complex algorithms <ref:2511.22624#pg9>.

Lev: Yeah, it's about how we structure the error mitigation process to match the circuit's complexity, which is a very important lesson for building real hardware <ref:2511.22624#pg8>.

Kai: So we’ve got a recursive tool that helps us manage large Clifford circuits with vanishing errors when p is small, but we still have to watch out for those injection detection issues <ref:2511.22624#pg3>. That's the core of this paper.

The paper's summary: Kai: So to recap, this paper is about taking that standard noise reduction technique called CliNR and making it recursive so you can apply it to much bigger quantum circuits than before, provided your physical error rate is really small.

Mira: Right. It's essentially a tree structure for error correction where you break down a giant circuit into smaller pieces, and you check the errors at each level of that tree instead of just checking the whole thing once at the end.

Lev: What this means in practice is that instead of building one massive, complex error correction scheme for an enormous circuit, you build many smaller ones and link them together recursively. The main benefit they're pointing to is that you can still get a vanishing logical error rate as long as the physical error rate p approaches zero.

Kai: But what about the cost? The paper says the qubit overhead scales with the depth of this tree, D, so it's not totally free, Mira. It gets (two times D plus one) qubits for every qubit in your circuit when you go to infinity.

Mira: Yeah, that is a real constraint. The theory suggests that if you keep p small enough—like when you have trapped ion qubits—that depth D stays manageable and the overall gate overhead doesn't explode too fast either.

Lev: I agree with Mira. The gate overhead is also bounded, maybe around twenty-four times s over p to gates when you look at the best case scenario for this recursive injection scheme. It’s better than standard CliNR under certain conditions, but it still has a limit on how much bigger the original circuit can be without hitting some walls.

Kai: So for someone building hardware right now, this paper tells us that if we want to do large-scale Clifford computation without immediately needing full fault tolerance, we should look at recursive methods like this.

Mira: Exactly. It shows that you can push the limits of what error mitigation techniques can do for these specific Clifford circuits. It opens up possibilities for algorithms that are just too big for the old methods to handle.

Lev: The real kicker is that they showed this method has an advantage when you keep the gate overhead fixed, even as circuit sizes get large. That means you can get a better logical error rate for a given amount of extra computation if p is tiny.

Kai: So it's about efficiency in terms of resource usage for error reduction on bigger systems. It's not just about getting the lowest possible error rate in isolation; it’s about doing that efficiently when you have real hardware constraints.

Mira: And the caveat they keep bringing up is that you still have those injection steps where errors don't get checked in every single recursive step, which is something we need to worry about if we want a fully robust system.

The paper's improvements: Kai: So, to wrap up what we saw before, this paper basically shows that if you want to run these large Clifford circuits without immediately needing full fault tolerance, you can use this recursive injection strategy that handles bigger circuits than the old way.

Mira: Right. It’s about structuring the error mitigation process so it matches the circuit's complexity, allowing you to get a vanishing logical error rate for arbitrarily sized n-qubit Clifford circuits as long as your physical error rate p is very small.

Lev: The main improvement they highlight is that this recursive approach can achieve lower logical error rates than standard CliNR when you keep the gate overhead under a certain level, even for those larger circuits we talked about. It's an efficiency win in terms of resource usage for a given error reduction goal.

Kai: So it means if we’re building hardware and we have to work with these large Clifford circuits, this recursion lets us get better fidelity without immediately demanding the massive qubit overhead that full fault tolerance would require from the start.

Mira: And the way they construct that tree structure is interesting because it gives you a way to estimate performance using tools like a Markov model, which helps you find good parameters for your tree depth D.

Lev: But we gotta remember those caveats. The paper flags that errors during those resource state injection steps still don't get detected in every single recursive step, so it’s not perfectly clean error control everywhere in the process.

Kai: That makes sense. So the main thing this paper suggests is using recursion to handle scaling while keeping the gate overhead relatively modest when p is small.

Mira: And it points toward a future where we can use these techniques to push what error mitigation can do for complex algorithms, which are currently too large for the existing methods.

Lev: It’s about finding a practical way to manage those errors in larger systems while keeping the overhead within reach on real hardware.

Conclusion: Kai: So we’ve been talking about how recursive methods can help tackle scaling problems in Clifford circuits, and this paper on "Recursive Clifford noise reduction" shows that even with those limitations, you can achieve a vanishing logical error rate when your physical error rate approaches zero.

Mira: Exactly. It's a protocol where you break the circuit down into smaller pieces and check the errors at each level of recursion, which is what makes it work for circuits way too big for the old methods.

Lev: From an engineering standpoint, it means that if we keep p small enough—say, with trapped ion qubits—this method can provide a logical error rate advantage even when we are dealing with very large circuits.

Kai: It's about finding a practical way to manage those errors in larger systems without immediately needing the massive qubit overhead required by full fault tolerance.

Mira: The implication is that this opens up possibilities for algorithms that are just too big for the old error mitigation techniques to handle effectively.

Lev: I think the main thing they show is that this recursive structure lets you get better logical error rates than standard CliNR if you keep the gate overhead under a certain level, which is a significant win for practical implementation.

Kai: So we’re looking at how to structure the error mitigation process to match circuit complexity, which is really important for building real hardware.

Mira: And while they show promise for reducing logical errors on bigger circuits, they also flag that those injection steps where errors aren't checked in every single recursive step still have some limitations.

Lev: That’s a fair point. So even with this improvement, we still have to worry about those unverified injections when we try to run it on actual machines.

Kai: So the whole point of this paper, "Recursive Clifford noise reduction," is showing that recursion is a tool you can use to push the limits of what error mitigation can do for large Clifford circuits when p goes to zero.

Mira: It’s about finding a way to get better performance on bigger circuits by using a recursive injection strategy that keeps the gate overhead reasonable under certain conditions.

Lev: And for me, it’s about showing how we can push the limits of what error mitigation can do for these specific Clifford circuits in a way that makes sense for real hardware constraints.

Kai: Alright, so that wraps up our look at this paper on Recursive Clifford noise reduction.

Mira: It’s a solid piece of theoretical work, but we definitely have to keep an eye on those limitations with the unverified injection steps.

Lev: Yeah, it shows a path forward for handling larger circuits, but the qubit overhead still scales with the depth of that tree D, so we need to watch that carefully.

Aharon Brodutch, Gregory Baimetov, Edwin Tham, Nicolas Delfosse

IonQ Inc. · Department of Mathematics, University of Washington

quant-ph

Submitted: 2025-11-27

Updated: 2026-11-17

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 89/100

The gist: Clifford Noise Reduction CliNR is a partial error correction scheme that reduces the logical error rate of Clifford circuits at the cost of a modest qubit and gate overhead The recursive version of…

Key concepts

Clifford Circuits
These are a specific type of quantum circuit that only use Clifford gates, which preserve Pauli operators under conjugation. They are important because they form the basis for many quantum algorithms and error mitigation techniques.
CliNR (Original Scheme)
This is an initial protocol to reduce logical errors in Clifford circuits by preparing a resource state, verifying it with stabilizer measurements, and injecting the circuit subcircuit. It works well for small circuits but struggles with larger ones due to size constraints.
Recursive CliNR
This method applies the CliNR process repeatedly across a tree structure of subcircuits. By recursively applying the technique, errors in unverified injection steps are checked at deeper levels, allowing it to handle arbitrarily large circuits effectively.

Terminology

Summary

Clifford Noise Reduction CliNR is a partial error correction scheme that reduces the logical error rate of Clifford circuits at the cost of a modest qubit and gate overhead The recursive version of CliNR can reduce errors on larger circuits with a relatively small gate overhead When np → 0, the logical error rate can be vanishingly small

Background and Problem Statement

Two major obstacles for reaching utility scale quantum computation are increasing the number of qubits and reducing error rates Quantum error correction (QEC) offers a way to reduce the logical error rates at the cost of increasing physical resources in a scalable way Current quantum computers do not support enough qubits for full-fledged fault-tolerant QEC, and moreover, the overheads for implementing fault-tolerant logical operations are high, both in qubit and gate counts notwithstanding huge improvements over the last few years Error-mitigation (EM) refers to a collection of techniques aimed at reducing the impact of errors on the output of a quantum computer Typically, EM techniques re-shape noise (e.g. twirling [11]), post-select shots identified as erroneous (e. p. 0

Where the paper says it

Typically, EM techniques re-shape noise (e. twirling [11]), post-select shots identified as erroneous (e.

g. flag error-detection [12, 13]), post-process noisy data (e. p. 0
Where the paper says it

twirling [11]), post-select shots identified as erroneous (e. flag error-detection [12, 13]), post-process noisy data (e.

g. filtering [14]), or a combination thereof Clifford Noise Reduction CliNR deals with this problem by building Clifford subcircuits offline and injecting them into the main circuit when they pass verification The method is however limited to subcircuits of size at most of the order of 1/(np2) where p is the physical error rate and n is the number of qubits

Recursive Structure and Implementation

Recursive CliNR recursively applies CliNR to a sequence of CliNR sub-circuits The main advantage is that the injection circuits, which don’t get verified in the standard CliNR, will now get verified at the next level of the recursion New unverified injection steps are introduced at the next level and these get verified at the next level etc., with the aim of ultimately having a small number of unverified injection steps at the top level The number of CliNR subcircuits (each with its injection step) at each level of the recursion is determined by a tree which we call the CliNR tree The implementation CliNR(T, C) is obtained by applying the procedure described in Algorithm 1

Performance Bounds and Results

Theorem 1 states that Recursive CliNR can be used to reach a vanishing logical error rate with a gate overhead ωG ≤ 24 (sp)4, as long as np → 0 The qubit overhead is given by ωQ = (2D + 1) + 1/n The uniformly bounded implementation ensures that every iterative use of CliNR1,r has an input circuit with a logical error rate bounded by 2/3 and an output state with a logical error rate upper bounded by a function of order np For sufficiently large D, the logical error rate is bounded from above and below by functions of order np Numerical results show that Recursive CliNR has a significant advantage at around ωG = 21 for n = 70 with idle noise

Optimization and Analysis

The paper provides heuristic methods like the Markov model to estimate performance and find good tree parameters by searching for points on the Pareto frontier The analysis involves Lemma 3, which gives logical error bounds for Recursive CliNR based on a depth D tree The uniformly bounded implementation uses Algorithm 2 to construct a CliNR tree T This construction ensures that CD,j are of size at most s¯D = 2/3p and at least 1/2p The gate overhead is bounded by ωG ≤ 12D

Conclusion

Our main result shows that Recursive CliNR can be used to reduce the logical error rate of any size circuit to an arbitrarily low value when np → 0 In-practice, the main advantage of the recursive scheme is at fixed gate overheads The advantage is particularly pronounced when the idle errors are very small, a feat that is achievable for trapped ion qubits Recursive CliNR can have lower logical error rates when we limit ωG The advantage is particularly pronounced when the idle errors are very small, a feat that is achievable for trapped ion qubits The main advantage of the recursive scheme is at fixed gate overheads.

--- Page 1 ---

Recursive Clifford noise reduction Aharon Brodutch, Gregory Baimetov, Edwin Tham and Nicolas Delfosse IonQ Inc. Department of Mathematics, University of Washington, Seattle, WA 98195-4350 (Dated: November 2025)

--- Page 2 ---

II. BACKGROUND In this section, we review the standard circuit-level noise model and the original CliNR scheme [17] A. p. 1

Where the paper says it

BACKGROUND In this section, we review the standard circuit-level noise model and the original CliNR scheme [17]. Noise model We consider quantum circuits containing single-qubit preparations, unitary gates and single-qubit measurements.

Noise model We consider quantum circuits containing single-qubit preparations, unitary gates and single-qubit measurements An important class of quantum circuits is the set of n-qubit Clifford circuits A Clifford unitary preserves Pauli operators by conjugation, i. p. 1
Where the paper says it

Noise model We consider quantum circuits containing single-qubit preparations, unitary gates and single-qubit measurements. An important class of quantum circuits is the set of n-qubit Clifford circuits.

e. for all Pauli operators P, the operation UP U† is also a Pauli operator The circuit-level noise model introduces errors in a quantum circuit, which translate into errors on the output state of the circuit, that we call the output error

--- Page 3 ---

B. Review of CliNR CliNR was introduced in [17] as a protocol that can reduce the logical error rate in the implementation of a Clifford circuit Consider a unitary n-qubit Clifford circuit C, called the input circuit, with size s (i. p. 1

Where the paper says it

Review of CliNR CliNR was introduced in [17] as a protocol that can reduce the logical error rate in the implementation of a Clifford circuit. Consider a unitary n-qubit Clifford circuit C, called the input circuit, with size s (i.

e. C has s unitary gates) Given an integer r, the CliNR implementation, denoted CliNR1,r(C), is defined as the following 3 step process (see Fig. p. 1
Where the paper says it

C has s unitary gates). Given an integer r, the CliNR implementation, denoted CliNR1,r(C), is defined as the following 3 step process (see Fig.

1): 1. Resource state preparation (RSP). p. 1
Where the paper says it

Given an integer r, the CliNR implementation, denoted CliNR1,r(C), is defined as the following 3 step process (see Fig. Resource state preparation (RSP).

A 2n-qubit resource (stabilizer) state φ⟩ is prepared as follows. p. 1
Where the paper says it

Resource state preparation (RSP). A 2n-qubit resource (stabilizer) state |φ⟩ is prepared as follows.

First n Bell pairs are prepared (using at most AP n noisy gates) Next, the circuit C is implemented on n of these qubits, one from each pair The resource state φ⟩ generated by an ideal implementation of RSP is stabilized by a stabilizer group S(φ). p. 1
Where the paper says it

First n Bell pairs are prepared (using at most AP n noisy gates). Next, the circuit C is implemented on n of these qubits, one from each pair.

An error during the noisy implementation of RSP produces a state Eφ⟩. p. 1
Where the paper says it

The resource state |φ⟩ generated by an ideal implementation of RSP is stabilized by a stabilizer group S(φ). An error during the noisy implementation of RSP produces a state E|φ⟩.

If E does not commute with S(φ) then it is a logical error in RSP 2. p. 1
Where the paper says it

An error during the noisy implementation of RSP produces a state E|φ⟩. If E does not commute with S(φ) then it is a logical error in RSP.

Resource state verification (RSV). p. 1
Where the paper says it

If E does not commute with S(φ) then it is a logical error in RSP. Resource state verification (RSV).

The resource state is verified by measuring r stabilizers using stabilizer measurements Here we assume that the stabilizers are chosen randomly and uniformly from S(φ), but other choices can lead to better performance [18] A logical error in RSP has probability 1/2 to commute with a stabilizer chosen at random from S(φ) In an ideal implementation of the stabilizer measurement, a logical error that anti-commutes with the stabilizer is detected. p. 1
Where the paper says it

The resource state is verified by measuring r stabilizers using stabilizer measurements. Here we assume that the stabilizers are chosen randomly and uniformly from S(φ), but other choices can lead to better performance [18].

If an error is detected we restart from RSP In a noisy implementation an error during the stabilizer measurement can lead to a false detection or to a subsequent logical error Each stabilizer measurement requires a single ancilla We can define constants AV and BV such that the implementation of RSV requires at most AV n + BV noisy gates An ideal implementation will reduce the logical error rate by a factor of 2r (see Lemma 1) 3. p. 1
Where the paper says it

In a noisy implementation an error during the stabilizer measurement can lead to a false detection or to a subsequent logical error. Each stabilizer measurement requires a single ancilla.

Resource state injection (RSI). p. 1
Where the paper says it

An ideal implementation will reduce the logical error rate by a factor of 2r (see Lemma 1). Resource state injection (RSI).

If no errors are detected during RSV, the subcircuit C is applied to an n-qubit input state by consuming the resource state φ⟩ We can define a constant AI such that this process takes at most AIn noisy gates

--- Page 4 ---

B. Review of CliNR When C is long, it can be advantageous to break it down into t subcircuits Ci and then apply CliNR1,r to each subcircuit. p. 2

Where the paper says it

3 When C is long, it can be advantageous to break it down into t subcircuits Ci and then apply CliNR1,r to each subcircuit. The logical error rate and restart rate in each CliNR1,r(Ci) block are lower than in CliNR1,r(C) leading to an advantage for t > 1 in some parameter regimes.

The logical error rate and restart rate in each CliNR1,r(Ci) block are lower than in CliNR1,r(C) leading to an advantage for t > 1 in some parameter regimes In [17] this technique (called CliNRt) was used to show that it is possible to achieve a vanishing logical error rate when snp2 → 0 The gate overhead in this regime can be bounded by ωG ≤ 2 One disadvantage of this technique is that errors during each RSI block cannot be detected In the following, we tackle this issue with a recursive CliNR scheme This scheme exploits the fact that CliNR1 blocks are Clifford circuits which can themselves be used as the input circuit for a larger CliNR1 block

--- Page 5 ---

III. RECURSIVE CLINR III. p. 0

Where the paper says it

We identify the main source of errors that cannot be detected and the limitation of the scheme. In Section III we introduce Recursive CliNR and the CliNR tree used in its construction.

RECURSIVE CLINR This section introduces the recursive generalization of CliNR which we call Recursive CliNR We begin with the CliNR tree An ordered tree is a rooted tree such that for any vertex u, the children of u have a specific order v0, v1, etc. p. 2
Where the paper says it

We begin with the CliNR tree. An ordered tree is a rooted tree such that for any vertex u, the children of u have a specific order v0, v1, etc.

If a tree is ordered, we can label its vertices as vl,i, where l ∈ N is the distance to the root and i is the index of the vertex among the vertices at level l A CliNR tree T (s, r) is a finite ordered tree equipped with two functions s and r defined over the vertex set of T We require that, for any vertex u, the sum of the values s(v) associated with its children v is equal to s(u) Let T be a CliNR tree with depth D and let C be an n-qubit Clifford circuit with size s(v0,0). p. 2
Where the paper says it

We require that, for any vertex u, the sum of the values s(v) associated with its children v is equal to s(u). Let T be a CliNR tree with depth D and let C be a n-qubit Clifford circuit with size s(v0,0).

For all levels l = 0, 1,. p. 2
Where the paper says it

Let T be a CliNR tree with depth D and let C be a n-qubit Clifford circuit with size s(v0,0). For all levels ℓ = 0, 1, .

.., D, we have P i s(vl,i) = s(v0,0) where i runs over the indices of all the vertices at level l It is possible to write C as the concatenation of subcircuit Cl,0, Cl,1,. p. 2
Where the paper says it

, D, we have P i s(vℓ,i) = s(v0,0) where i runs over the indices of all the vertices at level ℓ of the tree. It is possible to write C as the concatenation of subcircuit.

.. where Cl,i is a subcircuit of C with size s(vl,i) Moreover, for all l ≤ D − 1, the circuit Cl,i is the concatenation of the subcircuits Cl+1,j where vl+1,j runs over the children of vl,i in T The recursive CliNR implementation of C is obtained by applying the procedure described in Algorithm 1

--- Page 6 ---

Algorithm 1 Algorithm for constructing a recursive CliNR circuit input: A n-qubit Clifford circuit C and a CliNR tree T = T (s, r) output: The implementation CliNR(T, C) of C. 1 Set C' = C0,0. 2 Add one ancilla to C'. 3 for all level l = 0, 1,. p. 0

Where the paper says it

Recursive CliNR, recursively applies CliNR to a sequence of CliNR sub-circuits. The main advantage is that the injection circuits, which don’t get verified in the standard CliNR, will now get verified at the next level of the recursion.

.., D − 1 do 4 Add 2n ancilla qubits to C'. 5 for all vertices vl+1,j do Let r = r(vl+1,j). p. 2
Where the paper says it

, D − 1 do 4 Add 2n ancilla qubits to C ′ . 5 for all vertices vℓ+1,j do 6 Let r = r(vℓ+1,j ).

Let's replace the sub-circuit Cl+1,j inside C' by CliNR1,r(Cl+1,j) using the 2n + 1 ancilla qubits added at level l 8 return C'. from a depth-one tree with a root and t children v1,j for j = 0, 1. p. 2
Where the paper says it

8 return C ′ . from a depth-one tree with a root and t children v1,j for j = 0, 1 .

.., t − 1 with r(v1,j) = r.

--- Page 7 ---

Proposition 1 (qubit overhead for Recursive CliNR) The recursive implementation of an n-qubit Clifford circuit requires (2D + 1)n + 1 qubits When n → +∞ the qubit overhead is ωQ → 2D + 1 For D = 1, we recover the 3× qubit overhead of the original CliNR scheme as expected

--- Page 8 ---

IV. THE UNIFORMLY BOUNDED CLINR IMPLEMENTATION IV. p. 0

Where the paper says it

An algorithm for constructing the corresponding circuit is provided in Algorithm 1. In Section IV we introduce a specific implementation of Recursive CliNR called the uniformly bounded implementation.

THE UNIFORMLY BOUNDED CLINR IMPLEMENTATION Our main result below shows that when np → 0 it is possible to implement Recursive CliNR with a vanishing logical error rate To assist with the proof, we define the Uniformly bounded implementation (for a formal definition see Definition 1) This implementation ensures that every iterative use of CliNR1,r has an input circuit with a logical error rate bounded by 2/3 and an output state with a logical error rate upper bounded by a function of order np The logical error rate for the full implementation is therefore bounded by a function of order t1np where t1 is the number of vertices at level 1

--- Page 9 ---

A. Main result Here we state the main result of this paper which proves that the recursive CliNR scheme introduced in this work can achieve a vanishing logical error rate for n-qubit Clifford circuits with arbitrary size as long as np → 0 For comparison, the standard CliNR scheme is limited to circuits size s = o(1/(np2)

--- Page 10 ---

B. Notation We continue to use the notation from Algorithm 1 unless stated otherwise We use rl,j = r(vl,j) and sl,j = s(vl,j) Note that we only consider pairs T, C such that s0,0 = s is the size of C and r0,0 = 0 We use Tl,j for a CliNR tree constructed by taking the subtree of T consisting of the vertex vl,j and all its children We also use ˆsl,j to denote the expected number of gates in the implementation of CliNR(Tl,j, Cl,j), accounting for the repetitions due to the restarts in all RSV of the tree

--- Page 11 ---

C. Bounds on recursive CliNR This section provides general bounds on the performance and the overhead of the recursive CliNR scheme including statements that lead to Theorem 1 Lemma 3 Let T be a CliNR tree of depth D The implementation CliNR(T, C) has a logical error rate plog ≤t1 / (1 − (1 - p) AP n(1 − p¯b1) squared-r + 2gp(AV n + BV)/(1 − p)m¯ 1 (1 − p¯b1) + gp(AIn)

--- Page 5 ---

Lemma 3 Let T be a CliNR tree of depth D The implementation CliNR(T, C) has a logical error rate plog ≤t1 / (1 − (1 - p) AP n(1 − p¯b1) squared-r + 2gp(AV n + BV)/(1 − p)m¯ 1 (1 − p¯b1) + gp(AIn)

--- Page 6 ---

Lemma 4 Let T be a CliNR tree of depth D The gate overhead for the implementation CliNR(T, C) satisfies ωG ≤ t¯1 / s (m¯m + ˆs1) (1 − p)m¯ 1 (1 − p¯b1) + AIn

--- Page 7 ---

Lemma 4 Let T be a CliNR tree of depth D The gate overhead for the implementation CliNR(T, C) satisfies ωG ≤ t¯1 / s (m¯m + ˆs1) (1 − p)m¯ 1 (1 − p¯b1) + AIn

--- Page 8 ---

D. Uniformly bounded implementation To prove Theorem 1, we introduce a new class of recursive CliNR implementations which we call uniformly bounded This implementation ensures that every iterative use of CliNR1,r has an input circuit with a logical error rate bounded by 2/3 and an output state with a logical error rate upper bounded by a function of order np

--- Page 11 ---

C. Bounds on recursive CliNR This section provides general bounds on the performance and overhead of the recursive CliNR scheme including statements that lead to Theorem 1 Lemma 3 Let T be a CliNR tree of depth D The implementation CliNR(T, C) has a logical error rate plog ≤t1 / (1 − (1 - p) AP n(1 − p¯b1) squared-r + 2gp(AV n + BV)/(1 − p)m¯ 1 (1 − p¯b1) + gp(AIn) p. 4

Where the paper says it

An easy reference table for notation is provided in Table I of Section A. Bounds on recursive CliNR This section provides general bounds on the performance and the overhead of the recursive CliNR scheme, including the statements that lead to Theorem 1.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Improved AI systems can implement near-term utility scale quantum computation by using Recursive CliNR to reduce logical error rates for large Clifford circuits, achieving a vanishing logical error rate when np approaches 0.

  2. The improved system can handle larger circuit sizes than standard CliNR, which is limited to subcircuits of size at most of the order of 1/(np2), by recursively applying CliNR to subcircuits of any size s as long as np is sufficiently small.

  3. The system can achieve a vanishing logical error rate for n-qubit Clifford circuits with arbitrary size, contrasting with the original CliNR scheme which is limited to subcircuits of size at most of the order of 1/(np2).

  4. The system can reach lower logical error rates than the original CliNR with the same gate overhead when circuit sizes are large enough by employing Recursive CliNR.

  5. The system can achieve a qubit overhead of omegaQ = (2D + 1) + 1/n, where D is the depth of the CliNR tree, which is polynomial in sp as long as np approaches 0.

  6. The system can achieve a gate overhead omegaG <= 24/(sp)4 when np approaches 0, offering a modest qubit and gate overhead for error reduction on larger circuits.

Abstract

Clifford noise reduction CliNR is a partial error correction scheme that reduces the logical error rate of Clifford circuits at the cost of a modest qubit and gate overhead. The CliNR implementation of an n-qubit Clifford circuit of size s achieves a vanishing logical error rate if snp 2 to 0 where p is the physical error rate. Here, we propose a recursive version of CliNR that can reduce errors on larger circuits with a relatively small gate overhead. When np to 0, the logical error rate can be vanishingly small. When sp >2 this can be achieved with (2 (sp) +1)n+1 qubits and at most 24 s (sp) 3.6 gates. For sp at most 2 we recover the original CliNR. Using numerical simulations, we show that the recursive method can offer an advantage in a realistic near-term parameter regime. When circuit sizes are large enough, recursive CliNR can reach a lower logical error rate than the original CliNR with the same gate overhead. The results offer promise for reducing logical errors in large Clifford circuits with relatively small overheads.

Sources

Related papers