add GB, HGP, and LP unit tests from lit

Author: esabo

src/utils.jl

@@ -286,27 +286,11 @@ end
 _Flint_matrix_element_to_Julia_int(x::fpMatrix, i::Int, j::Int) = ccall((:nmod_mat_get_entry,
     Oscar.Nemo.libflint), Int, (Ref{fpMatrix}, Int, Int), x, i - 1 , j - 1)
 
-_Flint_matrix_element_to_Julia_int(x::FqMatrix, i::Int, j::Int) = ccall((:nmod_mat_get_entry,
-    Oscar.Nemo.libflint), Int, (Ref{FqMatrix}, Int, Int), x, i - 1 , j - 1)
-
 _Flint_matrix_to_Julia_int_matrix(A) = [ _Flint_matrix_element_to_Julia_int(A, i, j) for i in
     1:nrows(A), j in 1:ncols(A)]
 
-# function _Flint_matrix_to_Julia_int_vector(A)
-#     # (nr == 1 || nc == 1) || throw(ArgumentError("Cannot cast matrix to vector"))
-#     return _Flint_matrix_element_to_Julia_int(A, 1, 1)
-# end
 _Flint_matrix_to_Julia_int_vector(A) = vec(_Flint_matrix_to_Julia_int_matrix(A))
 
-_Flint_matrix_element_to_Julia_int(x::fpMatrix, i::Int, j::Int) = ccall((:nmod_mat_get_entry,
-    Oscar.Nemo.libflint), Int, (Ref{fpMatrix}, Int, Int), x, i - 1 , j - 1)
-
-_Flint_matrix_element_to_Julia_int(x::FqMatrix, i::Int, j::Int) = ccall((:nmod_mat_get_entry,
-    Oscar.Nemo.libflint), Int, (Ref{FqMatrix}, Int, Int), x, i - 1 , j - 1)
-
-_Flint_matrix_to_Julia_int_matrix(A) = [ _Flint_matrix_element_to_Julia_int(A, i, j) for i in
-    1:nrows(A), j in 1:ncols(A)]
-
 function _Flint_matrix_to_Julia_bit_matrix(A::CTMatrixTypes)
     order(base_ring(A)) == 2 || throw(DomainError(A, "Only works for binary matrices"))
     BitMatrix(_Flint_matrix_to_Julia_int_matrix(A))
@@ -1148,6 +1132,24 @@ function load_alist(file::String)
     return mat
 end
 
+# TODO polish this and add/export
+# function save_mtx(h, path, info)
+#     m, n = size(h)
+#     num_nonzero = sum(count(!=(0), h, dims=2))
+#     open(path, "w") do io
+#         write(io, "%%MatrixMarket matrix coordinate integer general\n")
+#         write(io, "%%$(info)")
+#         write(io, "\n$m $n $(num_nonzero)\n")
+#         for i in 1:m
+#             for j in 1:n
+#                 if h[i, j] == 1
+#                     write(io, "$i $j 1\n")
+#                 end
+#             end
+#         end
+#     end
+# end
+
 #############################
   # Quantum Helper Functions
 #############################

test/Classical/quasi-cyclic_code_test.jl

@@ -13,5 +13,86 @@
         v = [matrix(F, 1, 4, [1, 0, 1, 1]), matrix(F, 1, 4, [0, 0, 0, 1]), matrix(F, 1, 4, [1, 1, 1, 1]), matrix(F, 1, 4, [0, 0, 0, 0])]
         C2 = QuasiCyclicCode(v, 2, true)
         @test are_equivalent(C, C2)
+
+        # Quantum LDPC Codes with Almost Linear Minimum Distance
+        # Example 1
+        F = Oscar.Nemo.Native.GF(2)
+        S, x = polynomial_ring(F, :x)
+        l = 31
+        R = ResidueRing(S, x^l - 1)
+        A = matrix(R, 3, 5,
+            [x, x^2, x^4, x^8, x^16,
+             x^5, x^10, x^20, x^9, x^18,
+             x^25, x^19, x^7, x^14, x^28])
+        C = QuasiCyclicCode(A, true)
+        @test length(C) == 155
+        @test dimension(C) == 64
+        @test index(C) == 5
+
+        # TODO I have the following code for something, check the papers and make tests out of them
+        # A_tr = CodingTheory._CT_adjoint(A)
+        # LiftedProductCode(A, A_tr)
+
+
+        # Bias-Tailored Quantum LDPC Codes
+        # Example 2.2
+        # l = 3
+        # R = ResidueRing(S, x^l - 1)
+        # A = matrix(R, 2, 3, [x + x^2, 1, 0, 0, 1 + x^2, x^2])
+        # lift(A)
+        # weightmatrix(A)
+
+        # # julia> lift(A)
+        # # [0   1   1   1   0   0   0   0   0]
+        # # [1   0   1   0   1   0   0   0   0]
+        # # [1   1   0   0   0   1   0   0   0]
+        # # [0   0   0   1   1   0   0   1   0]
+        # # [0   0   0   0   1   1   0   0   1]
+        # # [0   0   0   1   0   1   1   0   0]
+        # #
+        # # julia> weightmatrix(A)
+        # # 2×3 Matrix{Int64}:
+        # #  2  1  0
+        # #  0  2  1
+
+        # # Example 3.3
+        # l = 13
+        # R = ResidueRing(S, x^l - 1)
+        # A = matrix(R, 4, 4,
+        #     [1, x^2, x^6, x,
+        #      x^12, x^5, x^12, x^5,
+        #      x^2, 1, x^9, x^5,
+        #      x^7, x^11, x^9, x])
+        # A_tr = CodingTheory._CT_adjoint(A)
+        # code = LiftedQuasiCyclicLiftedProductCode(A, A_tr)
+
+        # # TODO should remove from classical but put where?
+        # # TODO this example was never finished because of the original paper? or is wrong?
+        # # Quasi-cyclic constructions of quantum codes
+        # # Example 1
+        # n = 151
+        # q = 2
+        # deg = ord(n, q)
+        # E = GF(2, 15, :α)
+        # S, x = polynomial_ring(E, :x)
+        # β = α^(div(q^deg - 1, n))
+        # def_set_f = cyclotomic_coset(2, q, n)
+        # f = CodingTheory._generator_polynomial(S, β, def_set_f)
+        # def_set_g = [def_set_f; cyclotomic_coset(10, q, n)]
+        # g = CodingTheory._generator_polynomial(S, β, def_set_g)
+        # h = x + 1
+        # R, _ = residue_ring(S, x^n - 1)
+        # G1 = CodingTheory._generator_matrix(E, n, n - length(def_set_f), f);
+        # G3 = CodingTheory._generator_matrix(E, n, n - length(def_set_f) - 1, f * h);
+        # G2 = CodingTheory._generator_matrix(E, n, n - length(def_set_g), g);
+        # # G1 = polytocircmatrix(R(f));
+        # # G3 = polytocircmatrix(R(f * h));
+        # # G2 = polytocircmatrix(R(g));
+        # # cannot concatenate G1 and G3, although in the paper G1 and G2 are defined
+        # # but G3 is never actually specified
+        # stabs = vcat(hcat(G1, G3), hcat(zero(G2), G2))
+        # Q = QuantumCode(change_base_ring(F, stabs), true)
+        # # @test length(Q) ==
+        # # @test dimension(Q) == 
     end
 end