change to DelfosseReichardt after community feedback, there is a gene…

…ralized reed-muller code and the second author name is now included in the code similar to Reed-Muller

src/ecc/ECC.jl

@@ -29,7 +29,7 @@ export parity_checks, parity_checks_x, parity_checks_z, iscss,
     Shor9, Steane7, Cleve8, Perfect5, Bitflip3,
     Toric, Gottesman, Surface, Concat, CircuitCode, QuantumReedMuller,
     LPCode, two_block_group_algebra_codes, generalized_bicycle_codes, bicycle_codes,
-    haah_cubic_codes, DelfosseGeneralizedReedMuller,
+    haah_cubic_codes, DelfosseReichardt,
     random_brickwork_circuit_code, random_all_to_all_circuit_code,
     evaluate_decoder,
     CommutationCheckECCSetup, NaiveSyndromeECCSetup, ShorSyndromeECCSetup,
@@ -385,7 +385,7 @@ include("codes/surface.jl")
 include("codes/concat.jl")
 include("codes/random_circuit.jl")
 include("codes/quantumreedmuller.jl")
-include("codes/delfossegeneralized_reedmuller.jl")
+include("codes/delfosse_reichardt_code.jl")
 include("codes/classical/reedmuller.jl")
 include("codes/classical/recursivereedmuller.jl")
 include("codes/classical/bch.jl")

src/ecc/codes/delfossegeneralized_reedmuller.jl → src/ecc/codes/delfosse_reichardt_code.jl

@@ -1,15 +1,15 @@
 """
-The `[[8rp, (8r − 2)p − 2m, 4]]` Delfosse Genneralized Reed-Muller code is derived from
-the classical Reed-Muller code and is used to construct quantum stabilizer code. 
+The `[[8rp, (8r − 2)p − 2m, 4]]` Delfosse-Reichardt code is derived from the classical
+Reed-Muller code and is used to construct quantum stabilizer code. 
 
 Delfosse and Reichardt utilize the `[8, 4, 4]` Reed-Muller code to construct `[[8p, 6(p−1), 4]]`
 self-dual CSS quantum codes for `p≥2`, and the `[16, 11, 4]` Reed-Muller code to construct
 `[[16p, 14p − 8, 4]]` self-dual CSS quantum codes for `p≥1`. To improve the generality of
 the code construction, we proposed that these codes be generalized using the Reed-Muller code
 as the base matrix. Rather than hardcoding the `[8, 4, 4]` or `[16, 11, 4]` Reed-Muller codes,
 users should be able to input parameters `r` and `m`, thus enhancing the versatility of the
-code. This leads to the following generalized code: `[[8rp, (8r − 2)p − 2m, 4]]` Delfosse
-Generalized Reed-Muller code.
+code. This leads to the following generalized code: `[[8rp, (8r − 2)p − 2m, 4]]` Delfosse-Reichardt
+code.
 
 The `[[8p, 6(p − 1), 4]]` and `[[16p, 14p − 8, 4]]` codes were introduced by Delfosse and
 Reichardt in the paper *Short Shor-style syndrome sequences* [delfosse2020short](@cite). The
@@ -24,7 +24,7 @@ julia> using QuantumClifford; using QuantumClifford.ECC; # hide
 
 julia> p = 2; r = 1; m = 3;
 
-julia> c = parity_checks(DelfosseGeneralizedReedMuller(p,r,m))
+julia> c = parity_checks(DelfosseReichardt(p,r,m))
 + XXXXXXXX________
 + ________XXXXXXXX
 + XXXX____XXXX____
@@ -49,7 +49,7 @@ julia> using QuantumClifford; using QuantumClifford.ECC; # hide
 
 julia> p = 2; r = 2; m = 4;
 
-julia> c = parity_checks(DelfosseGeneralizedReedMuller(p,r,m))
+julia> c = parity_checks(DelfosseReichardt(p,r,m))
 + XXXXXXXXXXXXXXXX________________
 + ________________XXXXXXXXXXXXXXXX
 + XXXXXXXX________XXXXXXXX________
@@ -67,11 +67,11 @@ julia> code_n(c), code_k(c)
 (32, 20)
 ```
 """
-struct DelfosseGeneralizedReedMuller <: AbstractECC
+struct DelfosseReichardt <: AbstractECC
     blocks::Int
     r::Int
     m::Int
-    function DelfosseGeneralizedReedMuller(blocks,r,m)
+    function DelfosseReichardt(blocks,r,m)
         blocks < 2 && throw(ArgumentError("The number of blocks must be at least 2 to construct a valid code."))
         if r < 0 || r > m
             throw(ArgumentError("Invalid parameters: r must be non-negative and r ≤ m in order to valid code."))
@@ -80,11 +80,11 @@ struct DelfosseGeneralizedReedMuller <: AbstractECC
     end
 end
 
-function iscss(::Type{DelfosseGeneralizedReedMuller})
+function iscss(::Type{DelfosseReichardt})
     return true
 end
 
-function _generalize_ReedMuller_code(blocks::Int, r::Int, m::Int)
+function _generalize_delfosse_reichardt_code(blocks::Int, r::Int, m::Int)
     # base matrix: Reed-Muller paritycheck matrix
     H = parity_checks(ReedMuller(r,m))
     r, c = size(H)
@@ -111,17 +111,17 @@ function _generalize_ReedMuller_code(blocks::Int, r::Int, m::Int)
     return extended_H
 end
 
-function parity_checks(c::DelfosseGeneralizedReedMuller)
-    extended_mat = _generalize_ReedMuller_code(c.blocks, c.r, c.m)
+function parity_checks(c::DelfosseReichardt)
+    extended_mat = _generalize_delfosse_reichardt_code(c.blocks, c.r, c.m)
     hx, hz = extended_mat, extended_mat
     code = CSS(hx, hz)
     Stabilizer(code)
 end
 
-code_n(c::DelfosseGeneralizedReedMuller) = 8*c.blocks*c.r
+code_n(c::DelfosseReichardt) = 8*c.blocks*c.r
 
-code_k(c::DelfosseGeneralizedReedMuller) = (8*c.r − 2)*c.blocks − 2*c.m
+code_k(c::DelfosseReichardt) = (8*c.r − 2)*c.blocks − 2*c.m
 
-parity_checks_x(c::DelfosseGeneralizedReedMuller) = _generalize_ReedMuller_code(c.blocks, c.r, c.m)
+parity_checks_x(c::DelfosseReichardt) = _generalize_delfosse_reichardt_code(c.blocks, c.r, c.m)
 
-parity_checks_z(c::DelfosseGeneralizedReedMuller) = _generalize_ReedMuller_code(c.blocks, c.r, c.m)
+parity_checks_z(c::DelfosseReichardt) = _generalize_delfosse_reichardt_code(c.blocks, c.r, c.m)

test/test_ecc_delfosse_generalized_reedmuller.jl → test/test_ecc_delfosse_reichardt.jl

@@ -1,9 +1,9 @@
-@testitem "ECC [[8rp, (8r − 2)p − 2m, 4]] Delfosse Generalized ReedMuller code" begin
+@testitem "ECC [[8rp, (8r − 2)p − 2m, 4]] Delfosse-Reichardt code" begin
 
     using LinearAlgebra
     using QuantumClifford
     using QuantumClifford.ECC
-    using QuantumClifford.ECC: DelfosseGeneralizedReedMuller, _generalize_ReedMuller_code
+    using QuantumClifford.ECC: DelfosseReichardt, _generalize_delfosse_reichardt_code
     using Nemo: matrix, GF, echelon_form
 
     @testset "Testing [[8rp, (8r − 2)p − 2m, 4]] DelfosseRepCode properties" begin
@@ -15,7 +15,7 @@
                 p = i
                 n = 8*r*p
                 k = (8*r-2)*p-2*m
-                stab = parity_checks(DelfosseGeneralizedReedMuller(p,r,m))
+                stab = parity_checks(DelfosseReichardt(p,r,m))
                 H = stab_to_gf2(stab)
                 mat = matrix(GF(2), H)
                 computed_rank = rank(mat)
@@ -31,7 +31,7 @@
                 p = i
                 n = 8*r*p
                 k = (8*r-2)*p-2*m
-                stab = parity_checks(DelfosseGeneralizedReedMuller(p,r,m))
+                stab = parity_checks(DelfosseReichardt(p,r,m))
                 H = stab_to_gf2(stab)
                 mat = matrix(GF(2), H)
                 computed_rank = rank(mat)
@@ -49,6 +49,6 @@
                      0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1;
                      0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1;
                      0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1];
-       @test echelon_form(matrix(GF(2), Matrix{Int}(_generalize_ReedMuller_code(blocks,r,m)))) == echelon_form(matrix(GF(2), mat_paper))
+       @test echelon_form(matrix(GF(2), Matrix{Int}(_generalize_delfosse_reichardt_code(blocks,r,m)))) == echelon_form(matrix(GF(2), mat_paper))
     end
 end