⚛️ quantum physics

Exhaustive Optimisation of Automorphism Groups for Stabiliser Codes

This paper introduces a framework leveraging automorphism groups, logical basis choices, and code equivalence to exhaustively identify and optimize all distinct fault-tolerant realizations of logical operations for small stabiliser codes ( $n \leq 7, k \leq 2$ ), providing a comprehensive table of optimal physical circuits beneficial for magic state cultivation and experimental implementation.

Original authors: Aisling Mac Aree, Mark Howard

Published 2026-04-03

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Aisling Mac Aree, Mark Howard

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to send a secret message across a stormy sea. To protect your message from the waves (errors), you don't just write it on a single piece of paper; you encode it into a complex, magical origami structure made of many pieces of paper. This is a Quantum Error-Correcting Code.

However, once your message is safe inside this origami, you still need to do things with it (like read it or change it). These are Logical Operations. The problem is that the ocean is still stormy. If you try to change the message by poking at the origami with a stick, you might accidentally tear it apart, destroying the message.

This paper is like a master guidebook for finding the safest, cheapest, and most efficient way to poke the origami without breaking it.

Here is the breakdown of their discovery, using simple analogies:

1. The Problem: Too Many Ways to Do the Same Thing

Imagine you have a locked box (your quantum code). You want to open it, but you can only use specific tools (physical circuits).

The Issue: There are thousands of different ways to arrange your tools to open the box. Some ways take 10 minutes and use 50 tools. Others take 1 minute and use 5 tools.
The Goal: The authors wanted to find the absolute best way to perform every possible action on the box, considering two different "costs":
1. The "Swapping" Cost: Moving tools around is expensive (like moving furniture in a small room).
2. The "Twisting" Cost: Actually changing the tools (like turning a screwdriver) is also expensive, but sometimes necessary.

2. The Secret Weapon: "Code Equivalence" and "Logical Basis"

The authors realized that the "box" isn't just one static object. It's more like a Rubik's Cube.

Logical Basis (Rotating the Cube): You can look at the cube from the front, the side, or the top. The cube is the same, but the "instructions" to solve it look different depending on how you hold it. The authors realized that by simply rotating your perspective (changing the logical basis), you could find a much easier way to solve the puzzle.
Code Equivalence (Recoloring the Cube): Even better, imagine you have a Rubik's cube where the stickers are slightly different colors, but the mechanics are identical. This is a "different version" of the same code. The authors found that by switching to these "equivalent" versions of the code, they could find physical circuits that were drastically cheaper to build.

The Analogy:
Imagine you need to get from your house to the store.

Standard approach: You walk the same path everyone else walks. It's long and full of traffic (high cost).
This paper's approach: They realized that if you just rearrange your furniture (change the logical basis) or if you move to a house that looks different but is in the same neighborhood (code equivalence), you might find a secret shortcut that cuts your travel time in half.

3. The "Group Theory" Magic

To do this, the authors used advanced math (Group Theory and Symplectic Geometry).

Think of the Automorphism Group as a massive library of "symmetry tricks."
They realized that many of these tricks are actually the same trick, just dressed up differently. They used a concept called Conjugacy Classes to group these tricks together.
The Result: Instead of checking 1,000,000 different paths, they realized they only needed to check the "representative" of each group. If the representative is cheap, the whole group is cheap. This allowed them to search the entire universe of possibilities without getting lost.

4. The Two Metrics (The Scorecards)

They created two ways to score the efficiency of a solution:

Metric 1 (The "Control" Cost): This heavily penalizes moving things around (SWAPs). It's like saying, "Moving a heavy piano is so hard, we'd rather just twist the doorknob 100 times than move the piano." This is great for Magic State Distillation (a specific quantum task where moving parts is very noisy).
Metric 2 (The "Local" Cost): This treats moving things as "free" (because in some quantum hardware, you can just rename the wires without physically moving them). It only counts the actual "twisting" (gates). This is great for experimental hardware where you can physically swap wires easily.

5. The Big Result: The "Menu" of Optimal Circuits

The authors didn't just talk about theory; they did the heavy lifting. They generated a massive table (a "menu") for all small quantum codes (up to 7 qubits).

For every possible logical operation, they found the single best physical circuit to implement it.
They showed that by using their method, you can often reduce the cost of an operation by 50% or more compared to standard methods.

Why Does This Matter?

In the real world, quantum computers are fragile. Every extra gate or every extra "swap" of qubits introduces noise and errors.

For Scientists: This gives them a database of the most efficient circuits to use in their experiments.
For Engineers: It tells them how to build their quantum chips to minimize the number of expensive components needed.
For the Future: It proves that by being clever with math (symmetries and equivalents), we can make quantum computers much more practical and less expensive to run.

In a nutshell: The authors built a GPS for quantum engineers. Instead of driving aimlessly and hoping to find a short route, they mapped out every possible shortcut, showing you exactly how to rearrange your map and your car to get to your destination using the least amount of gas and time.

1. Problem Statement

In fault-tolerant quantum computing, the utility of a quantum error-correcting code depends heavily on which logical operations can be implemented efficiently and fault-tolerantly. While transversal gates are desirable, many logical Clifford operations require complex physical circuits involving qubit permutations (SWAPs) and non-identity Clifford gates.

The core problem addressed is that for a given stabiliser code, there exists a vast family of physical circuits that implement the same logical unitary. The cost of these circuits varies significantly based on:

Choice of Logical Basis: How logical $X$ and $Z$ operators are defined within the code space.
Code Equivalence: Different but mathematically equivalent representations of the same stabiliser code.
Physical Resource Metrics: The specific trade-off between the number of SWAP gates (which become expensive control-SWAPs in measurement protocols) and the number of local Clifford gates.

Existing methods often fail to exhaustively search these degrees of freedom, potentially missing optimal physical implementations for logical gates.

2. Methodology

The authors introduce a theoretical framework that leverages the automorphism groups of associated classical codes to exhaustively enumerate and optimize physical circuits. The methodology proceeds in three main stages:

A. Algebraic Framework

Mapping to Classical Codes: Stabiliser codes are mapped to additive codes over $GF(4)$. The automorphism group $\Gamma(C)$ of the classical code corresponds to the set of physical SWAP-transversal circuits that preserve the code space.
Logical Action: The logical action of an automorphism $\pi$ on a chosen logical basis $B$ is calculated using a trace inner product involving the dual basis. This maps the physical permutation to a logical symplectic matrix $L(\pi, B) \in Sp(2k, 2)$ .
Conjugacy Classes: Logical operations are grouped into conjugacy classes within the symplectic group $Sp(2k, 2)$. The authors prove that changing the logical basis corresponds to conjugating the logical operation. Thus, optimizing over all bases is equivalent to optimizing over the conjugacy class of the logical operation.

B. Exploiting Degrees of Freedom

The framework optimizes over two independent degrees of freedom:

Logical Basis Choice: By selecting a basis $B' = AB$ where $A \in Sp(2k, 2)$ , the authors can access different physical circuits for the same logical operation within a conjugacy class.
Code Equivalence: The authors utilize the Hamming group $Ham(C)$, which includes permutations, field multiplications, and Frobenius automorphisms. They construct a group transversal $T$ (a set of representatives for the quotient $Ham(C)/\Gamma(C)$ ). Applying elements $\tau \in T$ generates distinct but equivalent codes $C' = \tau(C)$ . While the logical action remains invariant, the physical circuit implementation (and its resource cost) changes.

C. Optimization Metrics

The framework optimizes physical circuits against two distinct figures-of-merit:

Metric 1 (Control-Clifford Cost): $7|\pi_\sigma| + |\pi_e|$ $7∣ π_{σ} ∣ + ∣ π_{e} ∣$ .
- $|\pi_\sigma|$ : Number of SWAP gates.
- $|\pi_e|$ : Number of non-identity Clifford gates.
- Rationale: SWAPs are heavily penalized because they become control-SWAPs during logical measurements (e.g., in magic state distillation), requiring significant T-gate overhead.
Metric 2 (Local Clifford Cost): $|\pi_e|$ $∣ π_{e} ∣$ .
- Rationale: Treats SWAPs as zero-cost (relying on qubit relabeling), prioritizing the minimization of local single-qubit gates. This is relevant for architectures where permutations are cheap (e.g., ion traps or specific superconducting layouts).

3. Key Contributions

Exhaustive Search Framework: A systematic method to generate all distinct physical realizations of logical operations by combining code automorphisms, basis changes, and code equivalences.
Theoretical Characterization:
- Theorem 1: Establishes that any valid logical Clifford can be derived from a specific automorphism and basis, and that basis changes act via conjugation.
- Theorem 2: Proves that code equivalence preserves the logical action but alters the physical circuit, allowing access to a larger pool of implementations without changing the logical function.
Conjugacy Class Analysis: Demonstrates that grouping automorphisms by the conjugacy class of their logical action avoids redundant optimization, as all elements in a class are operationally equivalent up to basis relabeling.
Optimization of Small Codes: Application of the framework to all small stabiliser codes with $n \le 7$ and $k \le 2$ drawn from standard quantum databases (QECDB, codetables.de).

4. Results

The authors produced an exhaustive table of optimal physical circuits for small stabiliser codes. Key findings include:

Significant Cost Reductions: By exploiting code equivalence and basis changes, the authors found implementations with drastically lower costs than standard representations.
- Example: For the $[[4, 2, 2]]$ code implementing a specific logical operation in Conjugacy Class 6, the initial cost (Metric 1) was 25. By optimizing the basis, it dropped to 11. By further optimizing via code equivalence (using a transversal element), the cost dropped to 9.
Trade-off Visibility: The results highlight that the optimal circuit for Metric 1 (low SWAPs) is often different from the optimal circuit for Metric 2 (low local Cliffords), providing designers with specific options based on their hardware constraints.
Database Generation: A comprehensive table is provided for codes including $[[4,1,2]]$ , $[[4,2,2]]$ , $[[5,1,2]]$ , $[[5,1,3]]$ , $[[5,2,1]]$ , $[[5,2,2]]$ , $[[6,1,3]]$ , and $[[7,1,3]]$ , listing the generator matrices, physical circuits, and resulting costs.

5. Significance and Impact

Magic State Cultivation: The reduction in Control-Clifford cost (Metric 1) directly benefits Magic State Distillation (MSD) and Cultivation (MSC) protocols, where non-destructive measurement of logical observables is critical. Lower SWAP counts reduce the T-gate overhead and error propagation.
Experimental Design: The results provide concrete, optimized circuit recipes for experimentalists working with small stabiliser codes, particularly for platforms where qubit permutations are low-cost (Metric 2).
Scalability: While currently limited to small codes due to the combinatorial explosion of the automorphism and symplectic groups, the framework is general. The authors suggest future work will focus on algorithmic approaches to handle larger codes ( $n > 7$ ).
Resource Efficiency: The work demonstrates that "logically identical" operations can have vastly different physical costs, emphasizing the need for algebraic symmetry exploitation in compiler design and circuit synthesis.

In conclusion, this paper provides a rigorous mathematical toolkit for navigating the space of physical implementations of logical gates, proving that exhaustive optimization over code equivalence and basis choice yields strictly better resource-efficient circuits for fault-tolerant quantum computing.