Block algebra for morphing circuits

This paper introduces four block algebra constructions for CNOT-based CSS morphing circuits, including three derived from existing surface and color codes and one novel three-round design, which are instantiated using regular representations of finite groups to relax quantum hardware requirements.

The Gist

The Big Picture: Fixing a Leaky Boat Without Extra Tools

Imagine you are trying to keep a boat (a quantum computer) afloat in a stormy sea (noise and errors). Usually, to fix a leak, you need a spare bucket (an extra "ancilla" qubit) to bail out the water. But what if you don't have any spare buckets?

This paper introduces a clever trick called "Morphing Circuits." Instead of bringing in extra tools, the boat changes its own shape temporarily to bail out the water, then snaps back to its original shape.

• The Problem: Quantum computers are fragile. To check for errors, we usually need extra "helper" qubits to measure the main ones. This requires a lot of hardware connections, which is hard to build.
• The Solution: The "Morphing" technique uses the main qubits themselves as the helpers. The circuit "contracts" the code (squishes parts of the boat together), measures the result, and then "expands" back. This removes the need for extra helper qubits, relaxing the hardware requirements.

The New Tool: "Block Algebra"

The author, Rui Chao, isn't just describing one way to do this; they are creating a universal instruction manual (a new language called "Block Algebra") to design these shape-shifting circuits.

Think of the quantum code as a giant grid of Lego bricks.

• Old Way: You had to look at every single brick and figure out how to move it one by one.
• New Way (Block Algebra): You group the bricks into "blocks" (like pre-assembled Lego sets). Instead of moving individual bricks, you move the whole sets at once.

In this language:

• Permutation Matrices are like "shuffling instructions." They tell you how to swap the positions of the Lego sets.
• Polynomials are like "shuffling recipes" that combine multiple swaps into one big instruction.

By using this algebra, the author can write down four distinct "recipes" for how to morph these circuits, ensuring they work correctly without breaking the quantum information.

The Four Recipes (Constructions)

The paper presents four specific ways to build these morphing circuits, each based on different geometric patterns (like hexagons or squares) found in existing quantum codes.

1. Construction I (The Hex-Grid Recipe):

   • Analogy: Imagine a honeycomb. This recipe takes a known honeycomb pattern and rewrites it using the new "block" language.
   • Result: It confirms that a previous method (by Shaw and Terhal) works perfectly when viewed through this new algebraic lens. It's like realizing a specific dance move is just a special case of a general dance style.

2. Construction II (The 6.6.6 Color Code):

   • Analogy: Think of a colorful mosaic where every tile touches six others. This recipe simplifies the process of "measuring" these tiles by shuffling them in a specific two-step dance.
   • Result: It creates a very efficient circuit where the "shuffling" (connectivity) is kept to a minimum.

3. Construction III (The 4.8.8 Color Code):

   • Analogy: This is like a mosaic made of squares and octagons. The recipe here is slightly more complex, involving two different types of shuffling patterns working together.
   • Result: It offers a different balance of hardware connections, useful for specific types of quantum chips.

4. Construction IV (The Three-Round New Design):

   • Analogy: This is a brand-new recipe, modeled on a 6.6.6 color code but designed to take three steps instead of two.
   • Result: It's a fresh invention by the author, showing that there are still undiscovered ways to morph these circuits efficiently.

The "Connectivity" Score

A major goal of this paper is to reduce connectivity.

• The Metaphor: Imagine a party where everyone needs to talk to everyone else to solve a puzzle. If everyone has to talk to 10 people, it's chaotic and hard to organize (high connectivity). If they only need to talk to 3 people, it's much easier (low connectivity).
• The Claim: The paper calculates exactly how many "conversations" (connections) each of these four recipes requires. They show that by using these block algebra methods, you can keep the number of connections low, which makes building the actual quantum computer easier.

The Proof: Simulations

The author didn't just write down the math; they tested it.

• They used a computer to simulate these circuits with "noise" (simulating a stormy sea).
• They found that these new block-algebra designs successfully protected the quantum information, just like the older methods, but with the advantage of being easier to describe and potentially easier to build.

Summary

In short, this paper says:

1. Morphing circuits are a great way to fix quantum errors without needing extra hardware.
2. Block Algebra is a new, powerful language to design these circuits, treating groups of qubits like single units.
3. The author has written four specific recipes using this language, including one brand-new design.
4. These recipes are mathematically sound and have been tested via simulation to ensure they work in a noisy environment.

The paper is essentially a "cookbook" for building more efficient quantum error-correction circuits, proving that you can get the same protection with less hardware complexity.

Technical Summary

Technical Summary: Block Algebra for Morphing Circuits

Problem Statement

Morphing circuits represent a paradigm shift in quantum error correction (QEC) designed to relax hardware connectivity requirements. Unlike traditional syndrome extraction that relies on extra measurement ancillas, morphing circuits utilize the physical qubits of the stabilizer code itself as temporary measurement workspaces. This is achieved through "contraction rounds" where Clifford gates transform selected stabilizer checks into single-qubit Paulis, which are then measured and reset before the circuit reverses the contraction.

While existing morphing circuits have been demonstrated for specific geometries—such as the hex-grid surface code [MBG23], middle-out color codes [GJ23], and general frameworks for two-block group algebra codes [ST25]—they lack a unified, systematic algebraic description. This absence makes it difficult to generalize these circuits to new code families or to systematically search for optimized parameters. The paper addresses the need for a formalism that can describe these circuits algebraically, facilitating the discovery of new morphing circuits with explicit qubit connectivity degrees.

Methodology

The authors develop a block algebra notation to describe morphing circuits, extending the standard algebraic viewpoint for translation-invariant codes [Haa16, LLSC25, SCB+25].

1. Block Partitioning: Physical qubits and check operators are grouped into blocks of equal size $n$.
2. Algebraic Representation:
   • Monomials ($p, q, \dots$): Represented by $n \times n$ permutation matrices over $\mathbb{F}_2$.
   • Polynomials ($P, Q, \dots$): Represented as formal sums of monomials over $\mathbb{F}_2$.
   • Stabilizer Matrices: The parity-check matrices ($H_X, H_Z$) are expressed as block matrices where entries are polynomials or permutation matrices.
3. Circuit Operations as Algebraic Updates:
   • CNOT layers ($CX(A, p, B)$) act as coupled column operations on the stabilizer matrices.
   • A contraction schedule is modeled as a Gaussian elimination pattern over these block stabilizer matrices.
   • The process transforms the mid-cycle code $C$ into end-cycle codes $C_j$ by eliminating specific rows (checks) to single-column monomial pivots, which correspond to the qubits measured and reset.
4. Translation Invariance: The framework assumes translation-invariant codes (e.g., on a 2D torus), where the geometry is defined by lattice vectors. This allows the promotion of specific translation monomials in known circuits to general polynomial sums, subject only to CSS orthogonality constraints.

Key Contributions

The paper presents four distinct constructions for CNOT-based CSS morphing circuits, all specified in the proposed block algebra notation.

1. Construction I: Generalized Surface-Code Morphing

• Basis: Derived from the hex-grid surface-code circuit [MBG23].
• Form: A $4 \times 4$ block stabilizer matrix involving polynomials $P, Q, R, S$.
• Constraints: Subject to $PR = QS$ and $RP = SQ$ (CSS orthogonality).
• Significance: This construction recovers the morphing circuit for two-block group algebra codes described in Ref. [ST25] but relaxes the implicit weight constraints found in that reference (allowing $|P| \neq |S|$ and $|Q| \neq |R|$).
• Connectivity: $\max\{|P| + |R|, |Q| + |S|\} + 1$.

2. Construction II: Generalized 6.6.6 Color Code

• Basis: Derived from the middle-out color-code circuits [GJ23].
• Form: A $2 \times 4$ block matrix with $H_X = H_Z$.
• Constraints: Subject to $Pq = qP$.
• Significance: Promotes specific translation polynomials to arbitrary polynomials, offering a flexible template for self-dual codes.
• Connectivity: $|P| + 1$.

3. Construction III: Generalized 4.8.8 Color Code

• Basis: Derived from the 4.8.8 color code [GJ23].
• Form: A larger block matrix incorporating two coupled copies of Construction II's structure.
• Constraints: Subject to $Pr = rP$ and $Qr = rQ$.
• Connectivity: $\max\{|P|, |Q|\} + 2$.

4. Construction IV: New Three-Round Construction

• Basis: Modeled on the 6.6.6 color code with six qubits per site.
• Form: A $3 \times 6$ block matrix with $H_X = H_Z$.
• Structure: A three-round contraction schedule ($J=3$) where measured qubit blocks advance cyclically.
• Constraints: Subject to $pq = qp$.
• Connectivity: Fixed at 3.

Numerical Results

The authors instantiated these constructions using regular representations of finite groups to generate concrete quantum codes.

• Code Search: The paper reports five specific mid-cycle codes used in simulations:
  • ST: The [[288, 12, 18]] bivariate bicycle code from Ref. [ST25] (serving as a baseline).
  • I: [[288, 16, 16]] code (Construction I).
  • II: [[260, 10, 14]] code (Construction II).
  • III: [[224, 8, 16]] code (Construction III).
  • IV: [[246, 4, 10]] code (Construction IV).
• Simulation: Circuit-level simulations were performed using the Stim simulator with depolarizing noise. A batched GPU implementation of Relay-BP decoding [MAB+25] was used.
• Performance: The results (Fig. 10) show the block logical error rates per cycle for noise rates $p \in [0.001, 0.004]$. Construction I demonstrates improved logical error rates compared to the ST baseline for the same physical qubit count, while Construction IV achieves a lower connectivity degree (3) at the cost of lower code distance.

Significance and Outlook

The paper claims significance primarily as a unifying framework and a tool for code discovery:

1. Unified Description: It provides a single algebraic language to describe diverse morphing circuits, revealing that known circuits are specific instances of broader polynomial templates.
2. Facilitated Search: By reducing the design of morphing circuits to finding polynomial entries that satisfy commutation constraints, the framework enables numerical searches over finite groups to instantiate new codes with desired connectivity and distance properties.
3. Modest Claims: The authors explicitly note that the relationship between mid-cycle distance ($D$) and end-cycle distances ($D_j$) is not fully understood beyond depth-dependent lower bounds. They also acknowledge that the current constructions have zero encoding rate and that future work is needed to design morphing circuits for high-rate codes.

The paper concludes that while many questions remain open—such as the behavior of $D_j$ under different pivot choices and the extension to subsystem codes—the block algebra formalism offers a promising language for designing logical operations and optimizing quantum error correction circuits.