Temp TRS Update

Author: esabo

src/Classical/TwistedReedSolomon.jl

@@ -0,0 +1,112 @@
+# Copyright (c) 2024 Eric Sabo
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+#############################
+        # constructors
+#############################
+
+"""
+    TwistedReedSolomonCode(k::Int, α::Vector{T}, t::Vector{Int}, h::Vector{Int}, η::Vector{T}) where T <: CTFieldElem
+
+Return the twisted Reed-Solomon code defined in `https://arxiv.org/abs/2107.06945`.
+"""
+function TwistedReedSolomonCode(k::Int, α::Vector{T}, t::Vector{Int}, h::Vector{Int}, η::Vector{T}) where T <: CTFieldElem
+    
+    l = length(t)
+    l == length(h) || throw(ArgumentError("Input vectors `t`, `h`, and `η` must have the same length"))
+    l == length(η) || throw(ArgumentError("Input vectors `t`, `h`, and `η` must have the same length"))
+    length(unique(collect(zip(h, t)))) == l || throw(ArgumentError("The tuples `(h[i], t[i])` must be distinct"))
+    n = length(α)
+    length(unique(α)) == n || throw(ArgumentError("The elements of `α` must be distinct"))
+    1 ≤ k ≤ n || throw(DomainError(k, "The dimension of the code must satisfy `1 ≤ k ≤ length(α)`"))
+    all(1 ≤ x ≤ n - k for x in t) || throw(DomainError(t, "Elements of `t` must satsify `1 ≤ t[i] ≤ n - k`"))
+    all(0 ≤ x ≤ k - 1 for x in h) || throw(DomainError(h, "Elements of `h` must satsify `0 ≤ h[i] ≤ k - 1`"))
+    F = parent(α[1])
+    all(parent(x) == F for x in α) || throw(DomainError(α, "All elements of `α` must be over the same base ring"))
+    all(parent(x) == F for x in η) || throw(DomainError(η, "All elements of `η` must be over the same base ring as the elements of `α`"))
+
+    _, x = polynomial_ring(F, :x)
+    G = zero_matrix(F, k, n)
+    for i in 0:k - 1
+        g_i = x^i
+        for j in 1:l
+            h[j] == i && (g_i += η[j] * x^(k - 1 + t[j]);)
+        end
+        
+        for c in 1:n
+            G[i + 1, c] = g_i(α[c])
+        end
+    end
+    display(G)
+
+    t_dual = k .- h
+    h_dual = (n - k) .- t
+    H = zero_matrix(F, n - k, n)
+    for i in 0:n - k - 1
+        g_i = x^i
+        for j in 1:l
+            h_dual[j] == i && (g_i += -η[j] * x^(n - k - 1 + t_dual[j]);)
+        end
+        
+        for c in 1:n
+            H[i + 1, c] = g_i(α[c])
+        end
+    end
+    println(" ")
+    display(H)
+
+    println(" ")
+    display(G * transpose(H))
+
+    C = LinearCode(G, H, false)
+    return TwistedReedSolomonCode(C.F, C.n, C.k, C.d, C.l_bound, C.u_bound, C.G, C.H, C.G_stand, C.H_stand, C.P_stand, C.weight_enum, α, t, h, η, l)
+end
+
+#############################
+      # getter functions
+#############################
+
+"""
+    twist_vector(C::AbstractTwistedReedSolomonCode)
+
+Return the twist vector of `C`.
+"""
+twist_vector(C::AbstractTwistedReedSolomonCode) = C.t
+
+"""
+    hook_vector(C::AbstractTwistedReedSolomonCode)
+
+Return the hook vector of `C`.
+"""
+hook_vector(C::AbstractTwistedReedSolomonCode) = C.h
+
+"""
+    coefficient_vector(C::AbstractTwistedReedSolomonCode)
+
+Return the coefficient vector of `C`.
+"""
+coefficient_vector(C::AbstractTwistedReedSolomonCode) = C.η
+
+"""
+    number_of_twists(C::AbstractTwistedReedSolomonCode)
+
+Return the number of twists of `C`.
+"""
+number_of_twists(C::AbstractTwistedReedSolomonCode) = C.l
+
+#############################
+      # setter functions
+#############################
+
+#############################
+     # general functions
+#############################
+
+# TODO check if all of these are in linear_code and branches on type
+# TODO can do better wrt d, bounds, and weight enumerator
+function dual(C::AbstractTwistedReedSolomonCode)
+    return TwistedReedSolomonCode(C.F, C.n, C.n - C.k, missing, 1, C.n, C.H, C.G, C.H_stand, C.G_stand, C.P_stand, missing, C.α, C.k .- C.h, (C.n - C.k) .- C.t, -C.η, C.l)
+end

src/Classical/cyclic_code.jl

@@ -94,13 +94,14 @@ function CyclicCode(q::Int, n::Int, cosets::Vector{Vector{Int}})
         H, G_stand, H_stand, P, missing)
 end
 
+# TODO should define this instead over a residue ring such that n is already defined?
 """
-    CyclicCode(n::Int, g::FqPolyRingElem)
+    CyclicCode(n::Int, g::Union{fpPolyRingElem, FqPolyRingElem})
 
 Return the length `n` cyclic code generated by the polynomial `g`.
 """
-function CyclicCode(n::Int, g::FqPolyRingElem)
-    n <= 1 && throw(DomainError("Invalid parameters passed to CyclicCode constructor: n = $n."))
+function CyclicCode(n::Int, g::Union{fpPolyRingElem, FqPolyRingElem})
+    is_positive(n) || throw(DomainError("Invalid parameters passed to CyclicCode constructor: n = $n."))
     R = parent(g)
     flag, h = divides(gen(R)^n - 1, g)
     flag || throw(ArgumentError("Given polynomial does not divide x^$n - 1."))
@@ -119,13 +120,19 @@ function CyclicCode(n::Int, g::FqPolyRingElem)
     β = α^(div(q^deg - 1, n))
     ord_E = Int(order(E))
     R_E, y = polynomial_ring(E, :y)
-    g_E = R_E([E(i) for i in collect(coefficients(g))])
+    if t == 1 && typeof(g) == fpPolyRingElem
+        g_E = R_E(E.(lift.(Ref(ZZ), collect(coefficients(g)))))
+    else
+        g_E = R_E([E(i) for i in collect(coefficients(g))])
+    end
     # _, h = divides(gen(R_E)^n - 1, g_E)
 
+    # TODO doesn't work for large fields
     dic = Dict{FqFieldElem, Int}()
     for i in 0:ord_E - 1
         dic[β^i] = i
     end
+    
     cosets = defining_set(sort!([dic[rt] for rt in roots(g_E)]), q, n, false)
     def_set = sort!(reduce(vcat, cosets))
     k = n - length(def_set)
@@ -145,7 +152,7 @@ function CyclicCode(n::Int, g::FqPolyRingElem)
     iszero(G * tr_H) || error("Generator and parity check matrices are not transpose orthogonal.")
 
     if t == 1
-        F = GF(p)
+        F = Oscar.Nemo.Native.GF(p)
         G = change_base_ring(F, G)
         H = change_base_ring(F, H)
         G_stand = change_base_ring(F, G_stand)
@@ -378,6 +385,29 @@ Return the cyclic code whose roots are the quadratic residues of `q`, `n`.
 """
 QuadraticResidueCode(q::Int, n::Int) = CyclicCode(q, n, [quadratic_residues(q, n)])
 
+"""
+    FireCode(p::Union{fpPolyRingElem, FqPolyRingElem}, l::Int)
+
+Return the fire code with generator polynomial `(x^(2l - 1) + 1) * p`.
+"""
+function FireCode(p::Union{fpPolyRingElem, FqPolyRingElem}, l::Int)
+    # F = base_ring(p)
+    # Int(order(F)) == 2 || throw(ArgumentError("Fire codes are only defined over `GF(2)`."))
+    Oscar.is_irreducible(p) || throw(ArgumentError("The polynomial `p` must be irreducible over `GF(2)`."))
+    m = degree(p)
+    x = gen(parent(p))
+    1 ≤ l ≤ m || throw(DomainError(l, "This construction requires 1 ≤ l ≤ degree(p)."))
+    isone(gcd(p, x^(2l - 1) + 1)) || throw(ArgumentError("This construction requires `gcd(p, x^(2l - 1) + 1) = 1`."))
+    g = (x^(2l - 1) + 1) * p
+
+    n = -1
+    for i in 1:3000
+        flag, _ = divides(x^i - 1, g)
+        flag && (n = i; break)
+    end
+    n == -1 && error("Unable to find the period of the generator polynomial in 3000 iterations.")
+    return CyclicCode(n, g)
+end
 #TODO: cyclic code constructors from zeros and nonzeros
 
 #############################
@@ -487,52 +517,6 @@ BCH_bound(C::AbstractCyclicCode) = C.δ
 # """
 # HT_bound(C::AbstractCyclicCode) = C.HT
 
-"""
-    is_narrow_sense(C::AbstractBCHCode)
-
-Return `true` if the BCH code is narrowsense.
-"""
-is_narrowsense(C::AbstractBCHCode) = iszero(C.b) # should we define this as b = 1 instead?
-
-"""
-    is_reversible(C::AbstractCyclicCode)
-
-Return `true` if the cyclic code is reversible.
-"""
-is_reversible(C::AbstractCyclicCode) = [C.n - i for i in C.def_set] ⊆ C.def_set
-
-"""
-    is_degenerate(C::AbstractCyclicCode)
-
-Return `true` if the cyclic code is degenerate.
-
-# Notes
-* A cyclic code is degenerate if the parity-check polynomial divides `x^r - 1` for
-some `r` less than the length of the code.
-"""
-function is_degenerate(C::AbstractCyclicCode)
-    x = gen(C.R)
-    for r in 1:C.n - 1
-        flag, _ = divides(x^r - 1, C.h)
-        flag && return true
-    end
-    return false
-end
-
-"""
-    is_primitive(C::AbstractBCHCode)
-
-Return `true` if the BCH code is primitive.
-"""
-is_primitive(C::AbstractBCHCode) = C.n == Int(order(C.F)) - 1
-
-"""
-    is_antiprimitive(C::AbstractBCHCode)
-
-Return `true` if the BCH code is antiprimitive.
-"""
-is_antiprimitive(C::AbstractBCHCode) = C.n == Int(order(C.F)) + 1
-
 #############################
       # setter functions
 #############################
@@ -814,6 +798,52 @@ function +(C1::AbstractCyclicCode, C2::AbstractCyclicCode)
     end
 end
 
+"""
+    is_narrow_sense(C::AbstractBCHCode)
+
+Return `true` if the BCH code is narrowsense.
+"""
+is_narrowsense(C::AbstractBCHCode) = iszero(C.b) # should we define this as b = 1 instead?
+
+"""
+    is_reversible(C::AbstractCyclicCode)
+
+Return `true` if the cyclic code is reversible.
+"""
+is_reversible(C::AbstractCyclicCode) = [C.n - i for i in C.def_set] ⊆ C.def_set
+
+"""
+    is_degenerate(C::AbstractCyclicCode)
+
+Return `true` if the cyclic code is degenerate.
+
+# Notes
+* A cyclic code is degenerate if the parity-check polynomial divides `x^r - 1` for
+some `r` less than the length of the code.
+"""
+function is_degenerate(C::AbstractCyclicCode)
+    x = gen(C.R)
+    for r in 1:C.n - 1
+        flag, _ = divides(x^r - 1, C.h)
+        flag && return true
+    end
+    return false
+end
+
+"""
+    is_primitive(C::AbstractBCHCode)
+
+Return `true` if the BCH code is primitive.
+"""
+is_primitive(C::AbstractBCHCode) = C.n == Int(order(C.F)) - 1
+
+"""
+    is_antiprimitive(C::AbstractBCHCode)
+
+Return `true` if the BCH code is antiprimitive.
+"""
+is_antiprimitive(C::AbstractBCHCode) = C.n == Int(order(C.F)) + 1
+
 # "Schur products of linear codes: a study of parameters"
 # Diego Mirandola
 # """