Logical Clifford gates via automorphisms of stabilizer codes

[Fe-r-oz]

Is your feature request related to a problem? Please describe.

The paper, Fault-Tolerant Logical Clifford Gates from Code Automorphisms, implements fault-tolerant logical Clifford gates on stabilizer codes by mapping them to binary linear codes, determining the code's automorphism group, and applying constraints based on Clifford operators. It calculates automorphism group generators, translates them into physical circuits, and computes the necessary Pauli corrections. The method also determines the logical action of these gates. SWAP-transversal gates are identified via automorphisms of the corresponding binary linear code. Leon’s algorithm, implemented in GAP/Guava and MAGMA, is used to find the automorphism group generators for the binary error correcting code. The paper uses MAGMA for computing the automorphism group of stabilizer codes.

The schematic presents the simplified view of overall approach:

flowchart TD
    T([Stabilizer Tableaux]) --> S([Symplectic Representation])
    S --> P([Permutation Automorphisms <br> Aut⟨G⟩])
    P --> R([Restrict to SWAP + Clifford gates <br>Aut⟨G⟩ ∩ Aut⟨B⟩])
    R --> S2([Symplectic Representation])
    S2 --> C([Pauli Correction])
    C --> L([Logical Action])
    L --> CI([Circuit Implementation])

Loading

The "symplectic representation" is just the binary Pauli representation. Example: symplectic representation of [[5,1,3]] code (Eq. 5)

julia> stab_to_gf2(parity_checks(Perfect5()))
4×10 Matrix{Bool}:
 1  0  0  1  0  0  1  1  0  0
 0  1  0  0  1  0  0  1  1  0
 1  0  1  0  0  0  0  0  1  1
 0  1  0  1  0  1  0  0  0  1

The standard form of [[5,1,3]] code (Eq. 6)

julia> standard_form = stab_to_gf2(canonicalize!(parity_checks(Perfect5())))
4×10 Matrix{Bool}:
 1  0  0  0  1  1  1  0  1  1
 0  1  0  0  1  0  0  1  1  0
 0  0  1  0  1  1  1  0  0  0
 0  0  0  1  1  1  0  1  1  1

The Pauli logical operator basis (Eq. 7)

julia> Lx = stab_to_gf2(logicalxview(canonicalize!(MixedDestabilizer(parity_checks(Perfect5())))))
1×10 Matrix{Bool}:
 0  0  0  0  1  1  0  0  1  0

julia> Lz = stab_to_gf2(logicalzview(canonicalize!(MixedDestabilizer(parity_checks(Perfect5())))))
1×10 Matrix{Bool}:
 0  0  0  0  0  1  1  1  1  1

The order of the automorphism group and the generators of Aut: The order of the automorphism group can be computed using GAP/Guava via Oscar. An example is the automorphism group of the [7, 4, 3] Hamming code, which has an order of 168.

julia> o = Oscar.GAP.Globals.Size(Oscar.GAP.Globals.PermutationAutomorphismGroup(Oscar.GAP.Globals.HammingCode(3, Oscar.GAP.Globals.GF(2))));

julia> o
168

Similarly, we can find the generators of the automorphism group using GAP/Guava via Oscar.

julia> gens = Oscar.GAP.Globals.GeneratorsOfGroup(Oscar.GAP.Globals.PermutationAutomorphismGroup(Oscar.GAP.Globals.HammingCode(3, Oscar.GAP.Globals.GF(2))));

julia> gens
GAP: [ (), (4,7)(5,6), (4,5)(6,7), (4,6)(5,7), (2,7)(3,6), (2,7,5)(3,6,4), (2,7,3,6)(4,5), (2,7,4)(3,6,5), (2,3)(6,7), (2,3)(4,7,5,6), (2,3)(4,5), (2,3)(4,6,5,7), (2,4,7)(3,5,6), (2,4,3,5)(6,7), (2,4)(3,5), (2,4,6)(3,5,7), (2,5,3,4)(6,7), (2,5)(3,4), (2,5,6)(3,4,7), (2,5,7)(3,4,6), (2,6)(3,7), (2,6,5)(3,7,4), (2,6,3,7)(4,5), (2,6,4)(3,7,5), (1,7)(3,5), (1,7,6)(3,5,4), (1,7,4)(3,5,6), (1,7,3,5)(4,6), (1,7,2)(3,6,5), (1,7,5,4,3,6,2), (1,7,3,6,4,5,2), (1,7,4,2)(3,6), (1,7,6)(2,3,4), (1,7,5,6,2,3,4), (1,7)(2,3,4,5), (1,7,2,3,4,6,5), (1,7,2,4)(5,6), (1,7)(2,4), (1,7,6)(2,4,5), (1,7,5)(2,4,6), (1,7,6)(2,5,3), (1,7)(2,5,4,3), (1,7,3,2,5,6,4), (1,7,4,6,3,2,5), (1,7,5,3)(2,6), (1,7,2,6,5,4,3), (1,7,4,5,2,6,3), (1,7,3)(2,6,4), (1,2,7)(3,5,6), (1,2,7,6,4,3,5), (1,2,7,4)(3,5), (1,2,7,3,5,4,6), (1,2)(5,6), (1,2)(4,7), (1,2)(4,5,7,6), (1,2)(4,6,7,5), (1,2,3)(5,6,7), (1,2,3)(4,7,6), (1,2,3)(4,5,7), (1,2,3)(4,6,5), (1,2,4)(3,6,5), (1,2,4,3,6,7,5), (1,2,4,5,7,3,6), (1,2,4,7)(3,6), (1,2,5,6)(3,7), (1,2,5)(3,7,4), (1,2,5,3,7,6,4), (1,2,5,4,6,3,7), (1,2,6)(3,4,7), (1,2,6,5)(3,4), (1,2,6,3,4,5,7), (1,2,6,7,5,3,4), (1,3)(5,7), (1,3)(4,7,6,5), (1,3)(4,5,6,7), (1,3)(4,6), (1,3,2)(5,7,6), (1,3,2)(4,7,5), (1,3,2)(4,5,6), (1,3,2)(4,6,7), (1,3,4,2,7,6,5), (1,3,4)(2,7,5), (1,3,4,5,6,2,7), (1,3,4,6)(2,7), (1,3,7,6,5,2,4), (1,3,7,5)(2,4), (1,3,7,2,4,5,6), (1,3,7)(2,4,6), (1,3,6)(2,5,7), (1,3,6,2,5,4,7), (1,3,6,4)(2,5), (1,3,6,7,4,2,5), (1,3,5,7)(2,6), (1,3,5,4,7,2,6), (1,3,5)(2,6,4), (1,3,5,2,6,7,4), (1,4,7)(3,6,5), (1,4,3,6)(5,7), (1,4,5)(3,6,7), (1,4)(3,6), (1,4,7,2)(3,5), (1,4,3,5,7,6,2), (1,4,2)(3,5,6), (1,4,6,7,3,5,2), (1,4,2,3,7,5,6), (1,4)(2,3,7,6), (1,4,5)(2,3,7), (1,4,6,5,2,3,7), (1,4)(2,7), (1,4,2,7)(5,6), (1,4,5)(2,7,6), (1,4,6)(2,7,5), (1,4,7,6,2,5,3), (1,4,3)(2,5,7), (1,4,2,5,6,7,3), (1,4,6,3)(2,5), (1,4,7,5,3,2,6), (1,4,3,2,6,5,7), (1,4,5)(2,6,3), (1,4)(2,6,7,3), (1,5)(3,7), (1,5,6)(3,7,4), (1,5,4)(3,7,6), (1,5,3,7)(4,6), (1,5,7,6,3,4,2), (1,5,6,2)(3,4), (1,5,2)(3,4,7), (1,5,3,4,6,7,2), (1,5)(2,3,6,7), (1,5,4)(2,3,6), (1,5,2,3,6,4,7), (1,5,7,4,2,3,6), (1,5,7,3)(2,4), (1,5,6,7,2,4,3), (1,5,2,4,7,6,3), (1,5,3)(2,4,6), (1,5)(2,7,6,3), (1,5,6,4,3,2,7), (1,5,4)(2,7,3), (1,5,3,2,7,4,6), (1,5)(2,6), (1,5,7)(2,6,4), (1,5,2,6)(4,7), (1,5,4)(2,6,7), (1,6,3,4)(5,7), (1,6)(3,4), (1,6,7)(3,4,5), (1,6,5)(3,4,7), (1,6,5,2)(3,7), (1,6,2)(3,7,4), (1,6,4,5,3,7,2), (1,6,3,7,5,4,2), (1,6,7)(2,3,5), (1,6,2,3,5,7,4), (1,6)(2,3,5,4), (1,6,4,7,2,3,5), (1,6,5,7,3,2,4), (1,6,7)(2,4,3), (1,6)(2,4,5,3), (1,6,3,2,4,7,5), (1,6)(2,5), (1,6,7)(2,5,4), (1,6,4)(2,5,7), (1,6,2,5)(4,7), (1,6,3)(2,7,5), (1,6,4,3)(2,7), (1,6,2,7,4,5,3), (1,6,5,4,2,7,3) ]

In addition, the automorphism group can be formed given the generators we found above:

julia> Aut = Oscar.GAP.Globals.Group(gens);

julia> Aut == Oscar.GAP.Globals.PermutationAutomorphismGroup(Oscar.GAP.Globals.HammingCode(3, Oscar.GAP.Globals.GF(2)))
true

Note: The AutomorphismGroup will be depreciated soon, so we use PermutationAutomorphismGroup, as recommended by Guava.

Describe the solution you’d like

• Logical operators which can be implemented using physical SWAP and H gates
• Logical operators which can be implemented using physical single-qubit Clifford and SWAP gates
• Algorithm 1: Automorphisms of a binary matrix representation of a stabilizer code.
• Algorithm 2: Pauli Correction and Logical Action of a Clifford operator.
• Algorithm 3: Check whether a logical operator can be implemented through automorphisms of the code
• Implement the family of automorphism algorithms given physical gate type, binary representation matrix, transformation matrix and intersect code matrix. Test with [[5,1,3]] code
• Reproduce Table IV: SWAP-transversal Logical Clifford gates of [[4,2,2]] code
• Reproduce Table VI and Table VII: SWAP-transversal gates of [[n,1,d]] codes
• Reproduce Table VIII: Order of automorphism and "logical action" groups for Bivariate Bicycle codes

Describe alternatives you’ve considered

#11 is related, but it focuses on symplectic geometry rather than automorphism groups. Similar work on automorphism groups for logical operator synthesis is mentioned in the aforementioned paper.