correctness tests for classical ECCs

Author: Fe-r-oz

test/runtests.jl

@@ -55,6 +55,12 @@ testfilter = ti -> begin
         push!(exclude, :ecc)
     end
 
+    if get(ENV, "CECC_TEST", "") == "true"
+        return :cecc in ti.tags
+    else
+        push!(exclude, :cecc)
+    end
+
     if CUDA_flag
         return :cuda in ti.tags
     else

test/test_cecc.jl

@@ -0,0 +1,24 @@
+@testitem "CECC" tags=[:cecc] begin
+    using Nemo
+    using QuantumClifford.ECC
+    using QuantumClifford.ECC: AbstractCECC, QECCore
+
+    include("test_cecc_base.jl")
+
+    codes = all_testable_classical_code_instances()
+
+    @testset "correctness checks for classical ECCs" begin
+        for code in codes
+            H = parity_matrix(code)
+            n, k, s  = code_n(code), code_k(code), size(H, 1)
+            @test all(col -> any(H[:, col] .!= 0), 1:n)
+            @test size(H, 1) <= size(H, 2) && size(H, 2) == n
+            H = matrix(GF(2), H)
+            computed_rank = rank(H)
+            @test n - k == computed_rank
+            @test computed_rank <= s && computed_rank <= n
+            @test n > 0 && k > 0 && k <= n
+            @test 0 < k/n <= 1.0
+        end
+    end
+end

test/test_cecc_base.jl

@@ -0,0 +1,78 @@
+using Test
+using QuantumClifford.ECC.QECCore
+using QuantumClifford
+using QuantumClifford.ECC
+using QuantumClifford.ECC: BCH
+using InteractiveUtils
+using SparseArrays
+
+import Nemo: GF, matrix, rank, finite_field, polynomial_ring
+import LinearAlgebra
+
+# generate instances of all implemented codes to make sure nothing skips being checked
+
+# Goppa Codes
+m₁ = 4
+t₁ = 2
+F, α = finite_field(2, m₁, :α)
+R, x = polynomial_ring(F, :x)
+g₁ = x^2 + x + α^3
+L₁ = [α^i for i in 2:13]
+
+m₂ = 6
+F, α = finite_field(2, m₂, :α)
+R, x = polynomial_ring(F, :x)
+t₂ = 9
+g₂ = x^t₂ + 1
+
+m₃ = 3
+F, α = finite_field(2, m₃, :α)
+R, x = polynomial_ring(F, :x)
+t₃ = 2
+g₃ = x^t₃ + x + 1
+
+m₄ = 4
+t₄ = 2
+F, α = finite_field(2, m₄, :α)
+R, z = polynomial_ring(F, :z)
+g₄ = z^2 + α^7*z + 1
+L₄ = [α^i for i in 2:13]
+
+const classical_code_instance_args = Dict(
+    :RepCode => [3, 4, 5, 6, 7, 8, 9, 10],
+    :BCH => [(3, 1), (3, 2), (4, 1), (4, 1), (5, 1), (5, 2), (6, 1), (6, 2)],
+    :ReedMuller => [(1, 3), (1, 4), (2, 3), (1, 5), (2, 4), (2, 5), (3, 5)],
+    :RecursiveReedMuller => [(1, 3), (1, 4), (2, 3), (1, 5), (2, 4), (2, 5), (3, 5)],
+    :Golay => [(23), (24)],
+    :Hamming => [2, 3, 4, 5, 6, 7, 8],
+    :GallagerLDPC => [(3, 3, 4), (3, 4, 5), (4, 5, 7), (4, 6, 7)],
+    :GoppaCode => [(m₁, t₁, g₁, L₁), (m₂, t₂, g₂), (m₃, t₃, g₃), (m₄, t₄, g₄, L₄)]
+)
+
+function all_testable_classical_code_instances(;maxn=nothing)
+    types_to_check = subtypes(AbstractCECC)
+    all_concrete_types = Type[]
+    
+    while !isempty(types_to_check)
+        current = popfirst!(types_to_check)
+        if isabstracttype(current)
+            append!(types_to_check, subtypes(current))
+        else
+            push!(all_concrete_types, current)
+        end
+    end
+    codeinstances = []
+    for t in all_concrete_types
+        t_name = Symbol(split(string(t), ".")[end])
+        for args in get(classical_code_instance_args, t_name, [])
+            try
+                codeinstance = t(args...)
+                !isnothing(maxn) && code_n(codeinstance) > maxn && continue
+                push!(codeinstances, codeinstance)
+            catch e
+                @warn "Failed to create $t with args $args: $e"
+            end
+        end
+    end
+    return codeinstances
+end