Non-Clifford Gates between Stabilizer Codes via Non-Abelian Topological Order

Background & Academic Lineage

The problem of implementing non-Clifford logical gates between stabilizer codes emerged from the broader field of topological quantum computation. The core idea is to leverage the robust properties of topological order, where information is encoded in non-global properties of the system, making it inherently protected against local noise. This concept was pioneered by X.-G. Wen and Q. Niu in the early 1990s [1,2] and significantly advanced by A. Kitaev with his proposal for fault-tolerant quantum computation using anyons [3].

Historically, the focus for universal topological quantum computation has been on manipulating non-Abelian anyons through braiding and fusion measurements [3,11-13]. While there has been significant theoretical progress and some recent experimental breakthroughs in preparing and manipulating non-Abelian anyons [10], achieving a fully fault-tolerant method for their control remains a substantial open challenge. This "pain point" of experimental difficulty and the lack of robust fault-tolerant control for dynamic anyon operations (braiding and fusion) is what motivated the authors to explore alternative protocols. They aim to achieve non-Clifford logical gates by utilizing non-Abelian topological order as a static intermediate resource rather than relying on the complex, dynamic control of anyon braiding and fusion. This approach simplifies the error correction process by keeping the underlying qudit surface codes in their ground state throughout the operation.

Intuitive Domain Terms

• Topological Order: Imagine a very special kind of material where information isn't stored in individual atoms, but in the collective, "knotted" patterns of the entire material. Even if you poke or prod individual atoms, the overall "knot" remains stable and the information is preserved. This robustness against local disturbances is the essence of topological order, making it ideal for protecting quantum information.
• Non-Clifford Gates: Think of quantum computers as having a basic set of "easy" operations (Clifford gates), like simple flips or rotations, that are relatively straightforward to perform and correct errors for. However, to unlock the full power of quantum computing and perform any possible calculation, you need more complex, "hard" operations (non-Clifford gates). This paper is all about finding new ways to implement these crucial "hard" operations.
• Anyons (Abelian/Non-Abelian): These are exotic "quasiparticles" that can only exist in two-dimensional systems. Unlike regular particles, when two anyons swap places, their quantum state can change in a peculiar way. Abelian anyons are like two identical coins: if you swap them, nothing fundamentally changes. Non-Abelian anyons, however, are more like two intertwined ribbons: if you swap them, the way they're braided can change, and this change can store information, making them a powerful tool for quantum computation.
• Stabilizer Codes / Surface Codes: Picture a large grid of quantum bits (qubits) on a surface. Stabilizer codes, like surface codes, are clever ways to arrange and measure these qubits collectively. Instead of checking each qubit individually, you check groups of them. If an error occurs, these group measurements (syndromes) tell you where the error is without revealing the precious quantum information itself, allowing for correction. They create a "safe zone" for quantum data.

Notation Table

Notation	Description

Problem Definition & Constraints

Core Problem Formulation & The Dilemma

The central problem addressed by this paper is the implementation of non-Clifford logical gates between Abelian qudit surface codes in a fault-tolerant manner.

The Input/Current State consists of Abelian qudit surface codes, specifically a $\mathbb{Z}_2$ qubit surface code and a $\mathbb{Z}_3$ qutrit surface code, each initialized in an arbitrary logical state (Page 2). These codes are known for their robustness in quantum memory but are limited to performing Clifford gates.

The Output/Goal State is the successful execution of a non-Clifford logical gate between these codes. The primary example detailed is a controlled-charge-conjugation (CC) gate, which transforms basis states as $CC: |ab\rangle \rightarrow |a^{(-1)^b}\rangle$, where $a \in \mathbb{Z}_3$ is the target qutrit and $b \in \mathbb{Z}_2$ is the control qubit (Page 2, Eq. 2). More generaly, the protocol aims to implement controlled-anyon automorphism gates $C_\psi$ (Page 3, Eq. 3). The key is to achieve this while maintaining the fault-tolerance properties inherent to topological codes.

The missing link or mathematical gap that this paper attempts to bridge is a practical and fault-tolerant method for generating non-Clifford gates using topological quantum computation. Previous research has largely focused on schemes involving the braiding and fusion measurements of non-Abelian anyons (Page 1). However, a fully fault-tolerant method for controlling these dynamic anyonic operations remains an open challenge (Page 1). This paper proposes an alternative: using non-Abelian topological order as a static intermediate resource to mediate these gates, thereby avoiding the complex and error-prone dynamic manipulation of anyons (Page 2).

The painful trade-off or dilemma that has trapped previous researchers lies in the conflict between achieving universal quantum computation (which necessitates non-Clifford gates) and maintaining fault tolerance. Schemes based on anyon braiding offer universal computation but face significant experiemental and theoretical hurdles in achieving fault-tolerant control (Page 1). The dilemma is that increasing computational power (non-Clifford gates) typically comes at the cost of decreased robustness or increased complexity in error correction. This paper attempts to resolve this by leveraging the static properties of non-Abelian topological order, which allows the Abelian qudit surface codes to remain in their ground state throughout the process, simplifying the decoding procedure (Page 2).

Constraints & Failure Modes

The problem of implementing fault-tolerant non-Clifford gates is made insanely difficult by several harsh, realistic constraints:

• Experimental Challenge of Non-Abelian Anyon Control: A major practical constraint is the difficulty in experimentally preparing and manipulating non-Abelian anyons in a fault-tolerant manner. While progress has been made, a complete solution remains elusive (Page 1). This difficulty motivates the paper's static resource approach.
• Nonlocality of the Gauging Map: The $\mathbb{Z}_2$ gauging map, a core component of the protocol, is inherently nonlocal. If applied all at once, errors could propagate nonlocally, making fault-tolerance analysis and correction extremely challenging (Page 12). This necessitates a column-by-column application of the gauging map, which adds procedural complexity.
• Complexity of Non-Abelian Decoders: Developing decoders for non-Abelian topological orders is significantly more complex than for Abelian codes. While the paper proposes a "relatively simple" heralded decoding scheme for the $\mathbb{D}(S_3)$ quantum double, it acknowledges that a detailed numerical analysis of its error threshold against single qubit and qutrit errors is left for future work (Page 3, Page 12). This indicates that robust fault tolerance for these systems is still a hard, open problem.
• Error Propagation and Nonlocal Errors: Errors occuring before the gauging map can transform into nonlocal errors within the $\mathbb{D}(S_3)$ code if not corrected promptly and locally. For instance, a $\mathbb{Z}_e$ error in the $\mathbb{Z}_3$ code can become an operator conditioned on a nonlocal string if the $\mathbb{S}_3$ code is prepared all at once (Page 12). This demands a careful, column-by-column error correction strategy to localize errors.
• Generalized Decoders for Qudit Codes: Standard decoders designed for qubit surface codes are not directly applicable to qudit surface codes, requiring the development and use of more generalized decoding algorithms (Page 12).
• Measurement Errors and Circuit-Level Noise: The paper explicitly defers a detailed analysis of measurement errors and circuit-level noise within the protocol to future work (Page 3). These are critical practical constraints in any quantum computation, and their full impact on the fault tolerance of this specific protocol is yet to be quantified.
• Cyclicity of Anyons: The correction of certain non-Abelian anyons, specifically C and F anyons, requires multiple rounds of correction due to their cyclic nature, adding complexity to the decoding process (Page 13).

Why This Approach

The Inevitability of the Choice

The authors' choice of leveraging non-Abelian topological order as a static intermediate resource for implementing non-Clifford logical gates was not merely an option, but a strategic necessity driven by the inherent challenges of alternative approaches to universal topological quantum computation. The paper explicitly highlights that while "one promising approach... is to utilize the topological properties of non-Abelian anyons [3]," the standard method of achieving this—through "braiding and fusion measurements of non-Abelian anyons [3,11-13]"—remains an "open challenge" for a fully fault-tolerant implementation (Page 1). This realization marks the exact moment traditional "SOTA" methods, in this context referring to dynamic anyon manipulation, were deemed insufficient for a practical, fault-tolerant scheme on near-term devices.

Instead of directly tackling the complex and experimentally demanding task of braiding non-Abelian anyons, the authors pivoted to a method that prepares non-Abelian topological order as a fixed background or "static intermediate resource." This allows for the extraction of non-Clifford gates without the need for dynamic anyon braiding, thereby circumventing a major experimental hurdle. The use of finite-depth quantum circuits with measurement and feedforward for state preparation and logical state injection further underscores this inevitability, as these techniques are more amenable to current quantum hardware capabilities (Page 1).

Comparative Superiority

This approach offers several qualitative advantages that make it overwhelmingly superior to previous gold standards, particularly those relying on dynamic anyon braiding. Foremost among these is the significant simplification of the error correction process: "A key advantage of our approach is that the qudit surface code remains in its ground state throughout the entire process, thereby simpilfying the decoding procedure" (Page 2). In contrast to schemes where logical information is encoded in the dynamic evolution of anyons, maintaining the Abelian surface codes in their ground states throughout the gate operation drastically reduces the complexity of error detection and correction.

Furthermore, the protocol generalizes previous approaches by providing "a framework that generates a large class of non-Clifford and nondiagonal logical gates between qudit surface codes by gauging the topological symmetry of symmetry-enriched topological orders" (Page 1, Abstract). This structural advantage allows for a broader range of gates than previously explored methods, moving beyond specific instances like the D4 topological order. The proposed heralded decoder for the S3 quantum double is also "relatively simple, utilizing probabilistic syndrome measurements arising from the commuting projector model" (Page 3), which is a qualitative improvement in decoding complexity for non-Abelian systems. By avoiding direct manipulation of non-Abelian anyons, the method sidesteps the intricate control and measurement challenges associated with their braiding and fusion, which are often prone to errors in experiemental setups.

Alignment with Constraints

The chosen method perfectly aligns with the implicit constraints of fault tolerance, universality, and experimental feasibility for near-term quantum devices.

1. Non-Clifford Gate Implementation: The primary goal is to implement non-Clifford gates, which are essential for universal quantum computation. The protocol directly achieves this by leveraging the non-Abelian nature of the D(S3) quantum double to realize a controlled-charge-conjugation (CC) gate, and more generally, controlled-anyon automorphism gates (Page 2, 11).
2. Fault Tolerance: The strategy of keeping the Abelian surface codes in their ground states simplifies error correction, a critical aspect of fault tolerance (Page 2). The column-by-column gauging map is crucial for localizing errors, preventing them from propagating nonlocally and making correction significantly easier (Page 12). While a full numerical analysis of the error threshold is left for future work, the proposed heralded decoding strategy for the D(S3) code is designed to address errors occurring both before and after the gauging map (Page 12).
3. Experimental Feasibility: The protocol relies on "finite-depth quantum circuits with measurement and feedforward" (Page 1), which are techniques compatible with current and near-term quantum hardware. The D(S3) example is specifically highlighted as "most relevant for near-term experiments" (Page 12), aligning with the practical constraint of implementability on existing platforms that have already realized generalized topological orders like the Z3 toric code and D4 quantum double [9,10].
4. Universality: The CC gate, when combined with the Clifford group (assumed to be implementable separately), enables universal quantum computation (Page 3). This ensures that the method contributes to the broader goal of building a universal quantum computer.

Rejection of Alternatives

The paper implicitly rejects approaches that rely on the dynamic braiding and fusion of non-Abelian anyons for computation. As stated in the introduction, "a fully fault-tolerant method for their control remains an open challenge" (Page 1). This highlights the practical difficulties and current limitations of such schemes, which, despite their theoretical promise for universal topological quantum computation, are not yet robust enough for fault-tolerant implementation. By adopting a "static intermediate resource" approach, the authors effectively bypass these challenges, offering a more experimentally viable pathway to harness non-Abelian topological order for quantum computation.

Furthermore, the paper positions its work as a generalization and improvement over existing topological approaches. It notes that its protocols are "more general" and can "extract logical gates from a larger class of quantum double models [27,28]" compared to previous work that focused on specific topological orders like D4 (Page 2). This suggests that while other topological methods exist, the proposed framework offers a broader and more flexible solution for generating non-Clifford gates. The prompt's mention of GANs or Diffusion models is not relevant here, as those are machine learning paradigms entirely outside the scope of topological quantum computation.

Mathematical & Logical Mechanism

The Master Equation

The absolute core of this paper's mechanism, defining the logical action of the Controlled-Charge-Conjugation (CC) gate, is expressed as a transformation of logical basis states. While the paper provides an operator form in Eq. (1), the most direct and intuitive representation of the gate's effect on the encoded quantum information is given by:

$$ CC: |ab\rangle \rightarrow |a^{(-1)^b}\rangle $$

This equation encapsulates how the logical state of a target qutrit is conditionally modified based on the logical state of a control qubit. It's the fundamental rule that dictates the gate's behavior. The paper also generalizes this to a controlled-anyon automorphism gate $C_\psi : |ab\rangle \rightarrow |a^{\psi^b}\rangle$ in Eq. (3), but the CC gate is the primary example detailed.

Term-by-Term Autopsy

Let's dissect the master equation $CC: |ab\rangle \rightarrow |a^{(-1)^b}\rangle$ to understand each component:

• $CC$: This symbol represents the Controlled-Charge-Conjugation gate itself.

  • Mathematical Definition: It's a specific non-Clifford logical quantum gate.
  • Physical/Logical Role: Its purpose is to perform a charge-conjugation operation on a target qutrit, but only if a control qubit is in a particular state. This conditional action is what makes it a "controlled" gate, and its non-Clifford nature makes it a powerful building block for universal quantum computation.
  • Why this choice?: The authors chose this gate because charge-conjugation is a $Z_2$ symmetry of the $Z_3$ qutrit surface code. This symmetry can be "gauged" by coupling it to a $Z_2$ qubit code, leading to the formation of a non-Abelian topological order ($\mathbb{D}(S_3)$) as an intermediate step, which is the central idea of the paper.

• $|ab\rangle$: This represents the input logical state of the combined quantum system before the gate is applied.

  • Mathematical Definition: It's a composite quantum state in Dirac notation, representing the tensor product of a control qubit state and a target qutrit state.
    • $a$: This is the logical state of the target qutrit. Mathematically, $a \in \mathbb{Z}_3 = \{0, 1, 2\}$, representing one of the three computational basis states of a qutrit.
    • $b$: This is the logical state of the control qubit. Mathematically, $b \in \mathbb{Z}_2 = \{0, 1\}$, representing one of the two computational basis states of a qubit.
  • Physical/Logical Role: The logical state $a$ carries the information intended for transformation, encoded within a $\mathbb{Z}_3$ surface code. The logical state $b$ acts as a control signal, encoded within a $\mathbb{Z}_2$ surface code, determining whether the transformation on $a$ occurs.
  • Why this choice?: The use of $\mathbb{Z}_2$ and $\mathbb{Z}_3$ surface codes reflects the specific qudit dimensions (qubit and qutrit) chosen for this example, which are experimentally relevant. The tensor product structure is standard for multi-qudit systems.

• $\rightarrow$: This arrow signifies the transformation or mapping from the input state to the output state.

  • Mathematical Definition: It's a functional operator indicating the result of applying the CC gate.
  • Physical/Logical Role: It simply denotes the "before" and "after" states of the system under the gate's action.

• $|a^{(-1)^b}\rangle$: This represents the output logical state of the combined system after the CC gate operation.

  • Mathematical Definition: This term describes the transformed logical state of the target qutrit, where the transformation is conditional on $b$.
    • If $b=0$: The control qubit is in the logical state $|0\rangle$. In this case, $(-1)^0 = 1$. The target qutrit state becomes $a^1 = a$. This means the target qutrit's state remains unchanged.
    • If $b=1$: The control qubit is in the logical state $|1\rangle$. In this case, $(-1)^1 = -1$. The target qutrit state becomes $a^{-1}$. As defined in the paper, this $a^{-1}$ corresponds to the charge-conjugation operation $C$ on the qutrit, which specifically leaves the $|0\rangle$ state invariant and swaps the $|1\rangle$ and $|2\rangle$ states. So, $C|0\rangle = |0\rangle$, $C|1\rangle = |2\rangle$, and $C|2\rangle = |1\rangle$.
  • Physical/Logical Role: This term is the core of the CC gate's functionality. The control qubit $b$ acts as a switch: if $b=0$, the target qutrit $a$ is left untouched; if $b=1$, the target qutrit $a$ undergoes the charge-conjugation transformation. This conditional operation is the desired logical output of the gate.
  • Why this form?: The notation $a^{(-1)^b}$ is a compact way to represent this conditional operation. It's not meant to imply direct arithmetic exponentiation in $\mathbb{Z}_3$, but rather a symbolic representation of the conditional charge-conjugation. The choice of a state transformation rule (mapping input states to output states) rather than an operator sum or integral is fundamental to defining the logical action of a quantum gate.

Step-by-Step Flow

Imagine a single abstract logical data point, represented by the combined state $|ab\rangle$ of a control qubit and a target qutrit, moving through this protocol like an assembly line:

1. Initial Setup: Our logical data point begins as two separate entities: a logical qubit state $|b\rangle$ encoded in a $\mathbb{Z}_2$ surface code, and a logical qutrit state $|a\rangle$ encoded in a $\mathbb{Z}_3$ surface code. These codes are initially distinct and physically separated.

2. Code Extension and Symmetry Enrichment:

   • First, ancilla qubits are introduced in a region where the $\mathbb{Z}_2$ and $\mathbb{Z}_3$ codes will eventually overlap. These ancillas are prepared in specific product states.
   • Next, a finite-depth quantum circuit, specifically a series of local CC gates ($U_{CC}$ from Eq. (14)), is applied. This circuit acts like a coupling mechanism, entangling the ancilla qubits with the qutrits of the $\mathbb{Z}_3$ code. This step "enriches" the $\mathbb{Z}_3$ code's symmetry by linking its charge-conjugation symmetry to the ancilla qubits.
   • Following this, a "gauging map" is performed. This is a crucial transformation that effectively merges the $\mathbb{Z}_2$ and $\mathbb{Z}_3$ codes in the overlapping region, creating a slab of non-Abelian $\mathbb{D}(S_3)$ topological order. Our logical data point $|ab\rangle$ is now injected into this non-Abelian environment. The logical operators (like $X$ and $Z$) that defined $|a\rangle$ and $|b\rangle$ in their original Abelian codes are transformed into specific anyon lines (e.g., $D$ anyons, $C$ anyons) within the $\mathbb{D}(S_3)$ code.

FIG. 1. Implementation of logical CC gate between D(Z2) and D(Z3) surface codes. (a) The qubit and qutrit surface codes are separately initialized in arbitrary logical states. Depicted are the Z and X logical operators of the qutrit code and the Z and X logical operators of the qubit code. (b) Non-Clifford CC gates between ancilla qubits initialized in the |0⟩and qutrits of the Z3 code. This is the symmetry-enrichment step, where the Z2 charge-conjugation symmetry of the qutrit surface code is coupled to ancilla qubits. (c) Applying the gauging map to the symmetry-enriched Z3 code yields S3 topological order. After applying the gauging map to the entire Z3 code, a S3 quantum double has been prepared with A + B + 2C boundary conditions on the left and right boundaries and A + D + F boundary conditions on the top and bottom boundaries, which are the analogs of rough and smooth boundary conditions for the S3 non-Abelian code. Logical information from both codes is now injected into the S3 code. The X and Z logical operator from the qubit code transform into the B and D anyon operators, respectively, while the Z and the X map to the C and F anyon operators respectively. (d) The ejection of the qubit and qutrit code from the non-Abelian code is done by simply measuring out qubits from the left side of the Z2 code in the Z basis. Measurement outcomes of Z = −1 correspond to the endpoints of ground state D anyon loops terminating at the left boundary. Feedforward is performed to return the stabilizers of the Z3 code back to their original form. (e) Once

1. Logical Transformation within $\mathbb{D}(S_3)$: While the logical data point is encoded in the $\mathbb{D}(S_3)$ topological order, the core logical action of the CC gate takes place. The non-Abelian properties of the $\mathbb{D}(S_3)$ order, combined with the specific gauging and subsequent measurement proces, effectively implement the conditional charge-conjugation. If the control qubit's logical state was $|1\rangle$ (i.e., $b=1$), the logical information corresponding to the target qutrit $|a\rangle$ undergoes a charge-conjugation transformation. If $b=0$, it remains unchanged. This transformation is not a direct unitary application on $|a\rangle$ but emerges from the overall protocol.

FIG. 2. We schematically show the states in the superposition of the D(S3) wavefunction in the Z basis. Each state is a D(Z3) wavefunction with a charge-conjugation domain wall configu- ration applied to the state. After the qubits of the S3 code are measured out in the Z basis, one such state is obtained with the Z = −1 measurement outcomes bounding the domain walls

1. Code Ejection and Feedforward:

   • The system then undergoes a "code ejection" phase, where qubits from the $\mathbb{Z}_2$ code (and later the $\mathbb{D}(S_3)$ code) are measured out column by column in the $Z$ basis. This effectively "ungauges" the system, extracting the logical information back into Abelian surface codes.
   • Measurement outcomes are critical here. For instance, if a $Z=-1$ outcome is observed in a noncontractible line during the ejection, it signifies a logical flip.
   • Based on these measurement outcomes, "feedforward" operations are applied. These are corrective actions (e.g., applying $C$ operations on qutrits or $X$ operations on qubits) to ensure that any unwanted anyons or domain walls created during the ejection are removed or properly accounted for. This step ensures that the logical state is correctly recovered and any errors introduced by the measurement proces are mitigated.

2. Final State: The logical data point emerges from the assembly line, now as $|a^{(-1)^b}\rangle$, encoded back into separate $\mathbb{Z}_2$ and $\mathbb{Z}_3$ surface codes. The control qubit's state $|b\rangle$ is preserved, and the target qutrit's state $|a\rangle$ has been conditionally charge-conjugated, achieving the desired non-Clifford gate.

Optimization Dynamics

The "optimization dynamics" in this context refers less to a continuous parameter tuning and more to the robust maintenance and correction of the quantum state throughout the gate protocol, ensuring the desired logical transformation despite noise. It's about how the system "learns" to stay in a valid topological state or recovers from errors.

• Fault Tolerance through Column-by-Column Processing: A key aspect of the protocol's robustness is its column-by-column approach to code extension and shrinkage. Errors occuring before the gauging map, if applied to the entire code at once, would become highly nonlocal and difficult to correct. By processing column by column, errors remain localized or manifest as local violations of stablizers near the boundaries of the code. This localization simplifies the subsequent error correction, effectively shaping the "error landscape" to be more manageable.

• Heralded $\mathbb{D}(S_3)$ Decoding Strategy: When the system is in the non-Abelian $\mathbb{D}(S_3)$ phase, a specialized "heralded" decoding strategy is employed. This isn't about gradients in a loss landscape, but rather about identifying and neutralizing anyonic excitations (errors) that deviate the system from its ground state.

  1. Syndrome Measurement: The protocol involves measuring the commuting projectors (stabilizers) of the $\mathbb{D}(S_3)$ code. Violations of these stabilizers indicate the presence of anyons (e.g., $B$, $C$, $D$, $F$ anyons), which are the "errors" in this topological context.
  2. Sequential Adaptive Correction: The correction procedure is sequential and adaptive:
     • First, $B_p = -1$ syndromes (associated with $D$ and $E$ anyons) are corrected using $X$ string operators. This might, however, create other anyons ($C$ and $F$).
     • Next, $A_v$ and $B_p$ syndromes (associated with $C$ and $F$ anyons) are addressed. These can be measured simultaneously. The correction involves choosing specific paths to eliminate these syndromes, often using adaptive circuits that apply $Z$ and $Z^\dagger$ operations. This step is crucial because it effectively converts the complex problem of correcting non-Abelian anyons into the simpler task of correcting Abelian anyons.
     • Finally, any remaining Abelian $B$ anyons are corrected using $Z$ string operators, similar to standard $\mathbb{Z}_2$ surface code decoders.
  3. Convergence to Ground State: The "convergence" here means returning the $\mathbb{D}(S_3)$ code to its ground state (a state with no anyonic excitations) after errors have occurred. Each correction step aims to reduce the number or complexity of anyons, effectively "flattening" the error landscape back to the stable, error-free ground state. The "adaptive" nature means that the choice of correction operations is informed by previous measurement outcomes, guiding the system towards the desired state.

• Feedforward for Logical State Preservation: During the code ejection phase, measurement outcomes are used in a feedforward loop. If measurements indicate a logical flip or the creation of unwanted domain walls (e.g., $Z=-1$ loops), specific logical operations (like $X$ on the $\mathbb{Z}_2$ code or $C$ on the $\mathbb{Z}_3$ code) are applied to correct these issues. This ensures that the overall logical transformation of the CC gate is accurately realized, even in the presence of measurement errors.

Results, Limitations & Conclusion

Experimental Design & Baselines

The paper presents a theoretical protocol for implementing non-Clifford logical gates, rather than a traditional experimental validation with physical hardware and comparative performance metrics. The "experimental design" here refers to the meticulous architectural blueprint of their proposed quantum computation scheme. The authors architected their protocol to "ruthlessly prove" their mathematical claims by detailing a step-by-step transformation of logical operators and stabilizers within a hybrid topological code system.

The core of their approach involves taking two Abelian surface codes—a $\mathbb{Z}_2$ qubit surface code and a $\mathbb{Z}_3$ qutrit surface code, both initialized in arbitrary logical states—and introducing a non-Abelian topological order, specifically the quantum double of $S_3$ ($\mathbb{D}(S_3)$), as an intermediate resource. This is achieved by sliding the $\mathbb{Z}_2$ code over the $\mathbb{Z}_3$ code, sequentially gauging and ungauging the charge-conjugation symmetry of the $\mathbb{Z}_3$ surface code in the overlapping region. This process creates a tripartite system: $\mathbb{Z}_2$, $\mathbb{D}(S_3)$, and $\mathbb{Z}_3$ codes, with gapped domain walls between them.

The "victims" or baseline models, in a conceptual sense, are the existing methods for achieving universal quantum computation that often rely on the direct braiding and fusion measurements of non-Abelian anyons. These methods, while theoretically powerful, face significant experimental challenges in achieving fault tolerance. The authors' protocol implicitly "defeats" these by offering an alternative route that simplifies the error correction procedure, as the Abelian surface codes remain in their ground state throughout the process.

The definitive, undeniable evidence that their core mechanism works in reality is provided through a rigorous mathematical derivation. They precisely show how logical operators of the stabilizer codes (equivalent to Abelian anyon lines) can be deformed across these domain walls into non-Abelian anyon lines of the $S_3$ quantum double. The protocol culminates in the logical action of a controlled-charge-conjugation (CC) gate, where the control qubit is from the $\mathbb{Z}_2$ code and the target qutrit is from the $\mathbb{Z}_3$ code. This is explicitly demonstrated by tracking the transformation of the logical operators: the $Z$ logical operator of the $\mathbb{Z}_2$ code simply extends, while the $X$ logical operator of the $\mathbb{Z}_2$ code transforms into an $X$ operator dressed by $C$ operators (a global charge-conjugation operation on the $\mathbb{Z}_3$ code). Similarly, the $Z$ logical operator of the $\mathbb{Z}_3$ code transforms into $Z$, and the $X$ logical operator of the $\mathbb{Z}_3$ code transforms into an $X$ operator conditioned on nonlocal strings. The final state, after ejecting the codes, precisely implements the CC gate, as shown by the transformation of logical operators $X \rightarrow XC$ and $Z \rightarrow Z$.

What the Evidence Proves

The evidence presented in the paper rigorously proves the feasibility and mechanism of their proposed protocol for implementing non-Clifford logical gates.

1. Non-Clifford Gate Implementation: The central achievement is the successful theoretical demonstration of a logical controlled-charge-conjugation (CC) gate between a qubit and a qutrit surface code. This is a non-Clifford gate, crucial for universal quantum computation. The logical action is precisely defined as $CC: |ab\rangle \rightarrow |aC^{-1}b\rangle$, where $a \in \mathbb{Z}_3$ is the target qutrit and $b \in \mathbb{Z}_2$ is the control qubit.
2. Mechanism via Non-Abelian Topological Order: The protocol leverages the entanglement into a non-Abelian $\mathbb{D}(S_3)$ topological order as an intermediate step. The detailed analysis of how stabilizers (Eqs. 16-21) and logical operators (Eqs. 22-26, 31-32) transform during the symmetry enrichment, gauging, and ejection phases provides concrete mathematical proof that the $\mathbb{D}(S_3)$ code acts as the necessary "computational engine." The transformation of the logical operators from the initial Abelian codes to the final CC gate action is explicitly derived and illustrated.
3. Ground State Preservation: A key advantage, and a proven aspect of their approach, is that the Abelian qudit surface codes remain in their ground state throughout the entire process. This significantly simplifies the error correction procedure compared to schemes that require manipulating anyons in excited states.
4. Generalizability: The authors demonstrate that their protocols are more general, extending to a larger class of quantum double models $\mathbb{D}(G)$, where $G$ is a semidirect product of Abelian groups. This generalization yields controlled-anyon automorphism gates (Eq. 3), indicating a broad applicability of their framework beyond the specific $S_3$ example.
5. Magic State Generation: As a direct consequence of the CC gate, the paper shows how to probabilistically generate magic states for the $\mathbb{Z}_2$ surface code (Appendix G). This is a critical step towards achieving universality, as magic states, combined with Clifford gates, enable universal quantum computation.

The evidence, trough detailed mathematical constructions and logical operator transformations, establishes a robust theoretical foundation for their novel approach to non-Clifford gate implementation.

Limitations & Future Directions

While this paper presents a brilliant and innovative protocol for non-Clifford gates, it also openly acknowledges several limitations and outlines a rich landscape for future research.

One significant area for future work is the numerical analysis of fault tolerance. The authors propose a heralded decoding scheme for the $S_3$ quantum double (Sec. V.B) and present arguments for its fault tolerance against local stochastic Pauli noise. However, a detailed analysis of measurement errors and circuit-level noise within the protocol, along with a numerical calculation of the error threshold for their decoder against qubit and qutrit errors, is explicitly left for future work. This is a crucial step for assessing the practical viability of the protocol on near-term quantum devises.

Another open question pertains to universal quantum computation. While the paper constructs magic states for the $\mathbb{Z}_2$ surface code using their CC gate (Appendix G), a full proof of universality for the $\mathbb{Z}_2 \times \mathbb{Z}_3$ qudit surface code is beyond the scope of this work. Furthermore, the qutrit state obtained in Appendix G (Eq. G6) is not a stabilizer state, and its utility for universal qutrit computation requires further proof. Expanding the scope to rigorously establish universality for the combined system would be a natural next step.

The generalization of the protocol also presents several avenues for exploration. The current work focuses on quantum double models $\mathbb{D}(G)$ where $G$ is a split extension of two Abelian groups. A natural extension is to investigate what gates are obtainable from quantum doubles whose gauge group is a central extension of two Abelian groups. Additionally, exploring whether gates in higher levels of the Clifford hierarchy can be obtained by nesting the split and central extension protocols would be a fascinating theoretical endeavor.

From a theoretical physics perspective, investigating the 3+1D spacetime picture or a topological field theory (TFT) description of their protocol could offer deeper insights. While TFTs for non-Abelian topological orders exist, properly incorporating all anyons and symmetry defects into the TFT framework, especially for non-diagonal gates like the CC gate, remains an open challenge. Bridging this gap could lead to a more unified understanding of topological quantum computation.

Finally, the paper highlights the need for a precise algorithm for determining paths for C anyon pairings in their heralded decoding strategy (Sec. V.B). Developing such an algorithm, potentially leveraging machine learning or advanced graph theory techniques, would be essential for optimizing error correction. Addressing error correction in the presence of measurement errors is also an important open question.

These future directions underscore that while the paper provides a robust theoretical foundation, significant work remains to translate these findings into a fully fault-tolerant and universally capable quantum computing platform.