Lifted and lifted product codes via Hecke's GroupAlgebra

Project.toml

@@ -23,7 +23,9 @@ Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 SumTypes = "8e1ec7a9-0e02-4297-b0fe-6433085c89f2"
 
 [weakdeps]
+AbstractAlgebra = "c3fe647b-3220-5bb0-a1ea-a7954cac585d"
 CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
+Hecke = "3e1990a7-5d81-5526-99ce-9ba3ff248f21"
 LDPCDecoders = "3c486d74-64b9-4c60-8b1a-13a564e77efb"
 Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a"
 Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
@@ -33,6 +35,7 @@ QuantumOpticsBase = "4f57444f-1401-5e15-980d-4471b28d5678"
 
 [extensions]
 QuantumCliffordGPUExt = "CUDA"
+QuantumCliffordHeckeExt = ["AbstractAlgebra", "Hecke"]
 QuantumCliffordLDPCDecodersExt = "LDPCDecoders"
 QuantumCliffordMakieExt = "Makie"
 QuantumCliffordPlotsExt = "Plots"
@@ -41,19 +44,21 @@ QuantumCliffordQOpticsExt = "QuantumOpticsBase"
 QuantumCliffordQuantikzExt = "Quantikz"
 
 [compat]
+AbstractAlgebra = "^0.39.0, 0.40, 0.41, 0.42"
 CUDA = "4.4.0, 5"
 Combinatorics = "1.0"
 DataStructures = "0.18"
 DocStringExtensions = "0.9"
 Graphs = "1.9"
+Hecke = "0.28, 0.29, 0.30, 0.31, 0.32, 0.33"
 HostCPUFeatures = "0.1.6"
 ILog2 = "0.2.3"
 InteractiveUtils = "1.9"
 LDPCDecoders = "0.3.1"
 LinearAlgebra = "1.9"
 MacroTools = "0.5.9"
 Makie = "0.20, 0.21"
-Nemo = "0.42, 0.43, 0.44, 0.45, 0.46"
+Nemo = "^0.42.1, 0.43, 0.44, 0.45, 0.46"
 Plots = "1.38.0"
 PrecompileTools = "1.2"
 PyQDecoders = "0.2.1"

docs/src/references.bib

@@ -402,3 +402,55 @@ @inproceedings{brown2013short
   pages = {346--350},
   doi = {10.1109/ISIT.2013.6620245}
 }
+
+@article{panteleev2021degenerate,
+  title = {Degenerate {{Quantum LDPC Codes With Good Finite Length Performance}}},
+  author = {Panteleev, Pavel and Kalachev, Gleb},
+  year = {2021},
+  month = nov,
+  journal = {Quantum},
+  volume = {5},
+  eprint = {1904.02703},
+  primaryclass = {quant-ph},
+  pages = {585},
+  issn = {2521-327X},
+  doi = {10.22331/q-2021-11-22-585},
+  archiveprefix = {arXiv}
+}
+
+
+@inproceedings{panteleev2022asymptotically,
+  title = {Asymptotically Good {{Quantum}} and Locally Testable Classical {{LDPC}} Codes},
+  booktitle = {Proceedings of the 54th {{Annual ACM SIGACT Symposium}} on {{Theory}} of {{Computing}}},
+  author = {Panteleev, Pavel and Kalachev, Gleb},
+  year = {2022},
+  month = jun,
+  pages = {375--388},
+  publisher = {ACM},
+  address = {Rome Italy},
+  doi = {10.1145/3519935.3520017},
+  isbn = {978-1-4503-9264-8}
+}
+
+@article{roffe2023bias,
+  title = {Bias-Tailored Quantum {{LDPC}} Codes},
+  author = {Roffe, Joschka and Cohen, Lawrence Z. and Quintavalle, Armanda O. and Chandra, Daryus and Campbell, Earl T.},
+  year = {2023},
+  month = may,
+  journal = {Quantum},
+  volume = {7},
+  pages = {1005},
+  doi = {10.22331/q-2023-05-15-1005}
+}
+
+@article{raveendran2022finite,
+  title = {Finite {{Rate QLDPC-GKP Coding Scheme}} That {{Surpasses}} the {{CSS Hamming Bound}}},
+  author = {Raveendran, Nithin and Rengaswamy, Narayanan and Rozp{\k e}dek, Filip and Raina, Ankur and Jiang, Liang and Vasi{\'c}, Bane},
+  year = {2022},
+  month = jul,
+  journal = {Quantum},
+  volume = {6},
+  pages = {767},
+  issn = {2521-327X},
+  doi = {10.22331/q-2022-07-20-767},
+}

ext/QuantumCliffordHeckeExt/QuantumCliffordHeckeExt.jl

@@ -0,0 +1,19 @@
+module QuantumCliffordHeckeExt
+
+using DocStringExtensions
+
+import QuantumClifford, LinearAlgebra
+import AbstractAlgebra: Group, GroupElem, AdditiveGroup, AdditiveGroupElem
+import Hecke: GroupAlgebra, GroupAlgebraElem, FqFieldElem, representation_matrix, dim, base_ring,
+    multiplication_table, coefficients, abelian_group, group_algebra
+import Base: adjoint
+import Nemo: characteristic, lift, matrix_repr, GF, ZZ
+
+import QuantumClifford.ECC: AbstractECC, CSS, ClassicalCode,
+    hgp, code_k, code_n, code_s, iscss, parity_checks, parity_checks_x, parity_checks_z, parity_checks_xz
+
+include("types.jl")
+include("lifted.jl")
+include("lifted_product.jl")
+
+end # module

ext/QuantumCliffordHeckeExt/lifted.jl

@@ -0,0 +1,97 @@
+"""
+$TYPEDEF
+
+Classical codes lifted over a group algebra, used for lifted product code construction [panteleev2021degenerate](@cite) [panteleev2022asymptotically](@cite).
+
+The parity-check matrix is constructed by applying `repr` to each element of `A`,
+which is mathematically a linear map from a group algebra element to a binary matrix.
+The size of the parity check matrix will enlarged with each element of `A` being inflated into a matrix.
+The procedure is called a lift [panteleev2022asymptotically](@cite).
+
+## Constructors
+
+A lifted code can be constructed via the following approaches:
+
+1. A matrix of group algebra elements.
+
+2. A matrix of group elements, where a group element will be considered as a group algebra element by assigning a unit coefficient.
+
+3. A matrix of integers, where each integer represent the shift of a cyclic permutation. The order of the cyclic permutation should be specified.
+
+The default `GA` is the group algebra of `A[1, 1]`, the default representation is the permutation representation.
+
+## The representation function
+
+In this struct, we use the default representation function `default_repr` to convert a `GF(2)`-group algebra element to a binary matrix.
+The default representation, provided by `Hecke`, is the permutation representation.
+
+We also accept a custom representation function.
+Such a customization would be useful to reduce the number of bits required by the code construction.
+
+For example, if we use a D4 group for lifting. In our default way, the representation will be `8×8` matrices,
+where 8 is the group's order. We can find a `4×4` matrix representation for the group,
+with details in [this discussion](https://github.com/QuantumSavory/QuantumClifford.jl/pull/312#discussion_r1682721136).
+
+See also: [`LPCode`](@ref).
+
+$TYPEDFIELDS
+"""
+struct LiftedCode <: ClassicalCode
+    """the base matrix of the code, whose elements are in a group algebra."""
+    A::GroupAlgebraElemMatrix
+    """the group algebra for which elements in `A` are from."""
+    GA::GroupAlgebra
+    """
+    a function that converts a group algebra element to a binary matrix;
+    default to be the permutation representation for GF(2)-algebra."""
+    repr::Function
+
+    function LiftedCode(A::GroupAlgebraElemMatrix; GA::GroupAlgebra=parent(A[1, 1]), repr::Function)
+        all(elem.parent == GA for elem in A) || error("The base ring of all elements in the code must be the same as the group algebra")
+        new(A, GA, repr)
+    end
+end
+
+default_repr(y::GroupAlgebraElem{FqFieldElem, <: GroupAlgebra}) = Matrix((x -> Bool(Int(lift(ZZ, x)))).(representation_matrix(y)))
+
+"""
+The GroupAlgebraElem with `GF(2)` coefficients can be converted to a permutation matrix by `representation_matrix` provided by Hecke.
+"""
+function LiftedCode(A::Matrix{GroupAlgebraElem{FqFieldElem, <: GroupAlgebra}}; GA::GroupAlgebra=parent(A[1,1]))
+    !(characteristic(base_ring(A[1, 1])) == 2) && error("The default permutation representation applies only to GF(2) group algebra; otherwise, a custom representation function should be provided")
+    LiftedCode(A; GA=GA, repr=default_repr)
+end
+
+function LiftedCode(group_elem_array::Matrix{<: GroupOrAdditiveGroupElem}; GA::GroupAlgebra=group_algebra(GF(2), parent(group_elem_array[1,1])), repr::Union{Function, Nothing}=nothing)
+    A = zeros(GA, size(group_elem_array)...)
+    for i in axes(group_elem_array, 1), j in axes(group_elem_array, 2)
+        A[i, j] = GA[A[i, j]]
+    end
+    if repr === nothing
+        return LiftedCode(A; GA=GA, repr=default_repr)
+    else
+        return LiftedCode(A; GA=GA, repr=repr)
+    end
+end
+
+function LiftedCode(shift_array::Matrix{Int}, l::Int; GA::GroupAlgebra=group_algebra(GF(2), abelian_group(l)))
+    A = zeros(GA, size(shift_array)...)
+    for i in 1:size(shift_array, 1)
+        for j in 1:size(shift_array, 2)
+            A[i, j] = GA[shift_array[i, j]%l+1]
+        end
+    end
+    return LiftedCode(A; GA=GA, repr=default_repr)
+end
+
+function lift(repr::Function, mat::GroupAlgebraElemMatrix)
+    vcat([hcat([repr(mat[i, j]) for j in axes(mat, 2)]...) for i in axes(mat, 1)]...)
+end
+
+function parity_checks(c::LiftedCode)
+    return lift(c.repr, c.A)
+end
+
+code_n(c::LiftedCode) = size(c.A, 2) * size(zero(c.GA), 2)
+
+code_s(c::LiftedCode) = size(c.A, 1) * size(zero(c.GA), 1)

ext/QuantumCliffordHeckeExt/lifted_product.jl

@@ -0,0 +1,182 @@
+"""
+$TYPEDEF
+
+Lifted product codes [panteleev2021degenerate](@cite) [panteleev2022asymptotically](@cite)
+
+A lifted product code is defined by the hypergraph product of a base matrices `A` and the conjugate of another base matrix `B'`.
+Here, the hypergraph product is taken over a group algebra, of which the base matrices are consisting.
+
+The parity check matrix is obtained by applying `repr` to each element of the matrix resulted from the hypergraph product, which is mathematically a linear map from each group algebra element to a binary matrix.
+
+## Constructors
+
+1. Two base matrices of group algebra elements.
+
+2. Two lifted codes, whose base matrices are for quantum code construction. 
+
+3. Two base matrices of group elements, where each group element will be considered as a group algebra element by assigning a unit coefficient.
+
+4. Two base matrices of integers, where each integer represent the shift of a cyclic permutation. The order of the cyclic permutation should be specified.
+
+## Code instances
+
+A [[882, 24, d ≤ 24]] code from Appendix B of [roffe2023bias](@cite).
+We use the the 1st constructor to generate the code and check its length and dimension.
+During the construction, we do arithmetic operations to get the group algebra elements in base matrices `A` and `B`.
+Here `x` is the generator of the group algebra, i.e., offset-1 cyclic permutation, and `GA(1)` is the unit element.
+
+```jldoctest
+julia> ENV["HECKE_PRINT_BANNER"] = "false"; import Hecke: group_algebra, GF, abelian_group, gens; import LinearAlgebra;
+
+julia> l = 63; GA = group_algebra(GF(2), abelian_group(l)); x = gens(GA)[];
+
+julia> A = zeros(GA, 7, 7);
+
+julia> A[LinearAlgebra.diagind(A)] .= x^27;
+
+julia> A[LinearAlgebra.diagind(A, -1)] .= x^54;
+
+julia> A[LinearAlgebra.diagind(A, 6)] .= x^54;
+
+julia> A[LinearAlgebra.diagind(A, -2)] .= GA(1);
+
+julia> A[LinearAlgebra.diagind(A, 5)] .= GA(1);
+
+julia> B = reshape([1 + x + x^6], (1, 1));
+
+julia> c1 = LPCode(A, B);
+
+julia> code_n(c1), code_k(c1)
+(882, 24)
+```
+
+A [[175, 19, d ≤ 0]] code from Eq. (18) in Appendix A of [raveendran2022finite](@cite),
+following the 4th constructor.
+
+```jldoctest
+julia> base_matrix = [0 0 0 0; 0 1 2 5; 0 6 3 1]; l = 7;
+
+julia> c2 = LPCode(base_matrix, l .- base_matrix', l);
+
+julia> code_n(c2), code_k(c2)
+(175, 19)
+```
+
+## Examples of code subfamilies
+
+- When the base matrices of the `LPCode` are one-by-one, the code is called a two-block group-algebra code [`two_block_group_algebra_codes`](@ref).
+- When the base matrices of the `LPCode` are one-by-one and their elements are sums of cyclic permutations, the code is called a generalized bicycle code [`generalized_bicycle_codes`](@ref).
+- When the two matrices are adjoint to each other, the code is called a bicycle code [`bicycle_codes`](@ref).
+
+## The representation function
+
+In this struct, we use the default representation function `default_repr` to convert a `GF(2)`-group algebra element to a binary matrix.
+The default representation, provided by `Hecke`, is the permutation representation.
+
+We also accept a custom representation function. The reasons are detailed in [`LiftedCode`](@ref).
+
+See also: [`LiftedCode`](@ref), [`two_block_group_algebra_codes`](@ref), [`generalized_bicycle_codes`](@ref), [`bicycle_codes`](@ref).
+
+$TYPEDFIELDS
+"""
+struct LPCode <: AbstractECC
+    """the first base matrix of the code, whose elements are in a group algebra."""
+    A::GroupAlgebraElemMatrix
+    """the second base matrix of the code, whose elements are in the same group algebra as `A`."""
+    B::GroupAlgebraElemMatrix
+    """the group algebra for which elements in `A` and `B` are from."""
+    GA::GroupAlgebra
+    """
+    a function that converts a group algebra element to a binary matrix;
+    default to be the permutation representation for GF(2)-algebra."""
+    repr::Function
+
+    function LPCode(A::GroupAlgebraElemMatrix, B::GroupAlgebraElemMatrix; GA::GroupAlgebra=parent(A[1,1]), repr::Function)
+        all(elem.parent == GA for elem in A) && all(elem.parent == GA for elem in B) || error("The base rings of all elements in both matrices must be the same as the group algebra")
+        new(A, B, GA, repr)
+    end
+
+    function LPCode(c₁::LiftedCode, c₂::LiftedCode; GA::GroupAlgebra=c₁.GA, repr::Function=c₁.repr)
+        # we are using the group algebra and the representation function of the first lifted code
+        c₁.GA == GA && c₂.GA == GA || error("The base rings of both lifted codes must be the same as the group algebra")
+        new(c₁.A, c₂.A, GA, repr)
+    end
+end
+
+function LPCode(A::FqFieldGroupAlgebraElemMatrix, B::FqFieldGroupAlgebraElemMatrix; GA::GroupAlgebra=parent(A[1,1]))
+    LPCode(LiftedCode(A; GA=GA, repr=default_repr), LiftedCode(B; GA=GA, repr=default_repr); GA=GA, repr=default_repr)
+end
+
+function LPCode(group_elem_array1::Matrix{<: GroupOrAdditiveGroupElem}, group_elem_array2::Matrix{<: GroupOrAdditiveGroupElem}; GA::GroupAlgebra=group_algebra(GF(2), parent(group_elem_array1[1,1])))
+    LPCode(LiftedCode(group_elem_array1; GA=GA), LiftedCode(group_elem_array2; GA=GA); GA=GA, repr=default_repr)
+end
+
+function LPCode(shift_array1::Matrix{Int}, shift_array2::Matrix{Int}, l::Int; GA::GroupAlgebra=group_algebra(GF(2), abelian_group(l)))
+    LPCode(LiftedCode(shift_array1, l; GA=GA), LiftedCode(shift_array2, l; GA=GA); GA=GA, repr=default_repr)
+end
+
+iscss(::Type{LPCode}) = true
+
+function parity_checks_xz(c::LPCode)
+    hx, hz = hgp(c.A, c.B')
+    hx, hz = lift(c.repr, hx), lift(c.repr, hz)
+    return hx, hz
+end
+
+parity_checks_x(c::LPCode) = parity_checks_xz(c)[1]
+
+parity_checks_z(c::LPCode) = parity_checks_xz(c)[2]
+
+parity_checks(c::LPCode) = parity_checks(CSS(parity_checks_xz(c)...))
+
+code_n(c::LPCode) = size(c.repr(zero(c.GA)), 2) * (size(c.A, 2) * size(c.B, 1) + size(c.A, 1) * size(c.B, 2))
+
+code_s(c::LPCode) = size(c.repr(zero(c.GA)), 1) * (size(c.A, 1) * size(c.B, 1) + size(c.A, 2) * size(c.B, 2))
+
+"""
+Two-block group algebra (2GBA) codes, which are a special case of lifted product codes
+from two group algebra elements `a` and `b`, used as `1x1` base matrices.
+
+See also: [`LPCode`](@ref), [`generalized_bicycle_codes`](@ref), [`bicycle_codes`](@ref)
+"""
+function two_block_group_algebra_codes(a::GroupAlgebraElem, b::GroupAlgebraElem)
+    A = reshape([a], (1, 1))
+    B = reshape([b], (1, 1))
+    LPCode(A, B)
+end
+
+"""
+Generalized bicycle codes, which are a special case of 2GBA codes (and therefore of lifted product codes).
+Here the group is chosen as the cyclic group of order `l`,
+and the base matrices `a` and `b` are the sum of the group algebra elements corresponding to the shifts `a_shifts` and `b_shifts`.
+
+See also: [`two_block_group_algebra_codes`](@ref), [`bicycle_codes`](@ref).
+
+A [[254, 28, 14 ≤ d ≤ 20]] code from (A1) in Appendix B of [panteleev2021degenerate](@cite).
+
+```jldoctest
+julia> c = generalized_bicycle_codes([0, 15, 20, 28, 66], [0, 58, 59, 100, 121], 127);
+
+julia> code_n(c), code_k(c)
+(254, 28)
+```
+"""
+function generalized_bicycle_codes(a_shifts::Array{Int}, b_shifts::Array{Int}, l::Int)
+    GA = group_algebra(GF(2), abelian_group(l))
+    a = sum(GA[n%l+1] for n in a_shifts)
+    b = sum(GA[n%l+1] for n in b_shifts)
+    two_block_group_algebra_codes(a, b)
+end
+
+"""
+Bicycle codes are a special case of generalized bicycle codes,
+where `a` and `b` are conjugate to each other.
+The order of the cyclic group is `l`, and the shifts `a_shifts` and `b_shifts` are reverse to each other.
+
+See also: [`two_block_group_algebra_codes`](@ref), [`generalized_bicycle_codes`](@ref).
+"""
+function bicycle_codes(a_shifts::Array{Int}, l::Int)
+    GA = group_algebra(GF(2), abelian_group(l))
+    a = sum(GA[n÷l+1] for n in a_shifts)
+    two_block_group_algebra_codes(a, a')
+end