Merge pull request #180 from sumiya11/slowly-refactoring-trace

(Slowly) Refactoring F4 trace

Author: sumiya11

benchmark/CI-scripts/.runtests.jl.swp

@@ -27,8 +27,11 @@ function Groebner.io_convert_polynomials_to_ir(
             reverse!(coeffs[i])
         end
     end
-    ring =
-        Groebner.PolyRing(ring.nvars, Groebner.ordering_transform(ring.ord, var_to_index), ring.ch)
+    ring = Groebner.PolyRing(
+        ring.nvars,
+        Groebner.ordering_transform(ring.ord, var_to_index),
+        ring.characteristic
+    )
     options.ordering = Groebner.ordering_transform(options.ordering, var_to_index)
     ring, monoms, coeffs, options
 end

ext/GroebnerDynamicPolynomialsExt.jl

@@ -0,0 +1,39 @@
+using Revise, Groebner, AbstractAlgebra
+
+# 1. Create the system
+k = GF(2^30 + 3)
+sys = sort(Groebner.Examples.katsuran(4, k=k), by=leading_monomial)
+
+# 2. Learn the trace
+trace, gb_truth = groebner_learn(sys)
+
+# 3. Get the F4 matrices
+matrices = Groebner.trace_export_matrices(trace.recorded_traces[UInt32])
+
+# 4. Inspect the data structure
+function make_matrix(sys, matrix)
+    x = gens(parent(sys[1]))
+    make_poly(idx, mult) = sys[idx] * prod(x .^ mult)
+    reducers = map(make_poly, matrix.reducers.index, matrix.reducers.multiplier)
+    to_be_reduced = map(make_poly, matrix.to_be_reduced.index, matrix.to_be_reduced.multiplier)
+    (reducers=reducers, to_be_reduced=to_be_reduced)
+end
+
+matrix_1 = make_matrix(sys, matrices[1])
+@info "The first matrix:" matrix_1.reducers matrix_1.to_be_reduced
+
+# 5. Construct a basis by reducing the matrices
+function follow_the_trace(sys, matrices)
+    gb = sys
+    for matrix in matrices
+        matrix = make_matrix(gb, matrix)
+        # Can be computed via lin-alg
+        reduced = broadcast(AbstractAlgebra.normal_form, matrix.to_be_reduced, Ref(matrix.reducers))
+        gb = vcat(gb, reduced)
+    end
+    gb
+end
+
+gb = follow_the_trace(sys, matrices)
+
+@assert groebner(gb) == gb_truth   # autoreduce by calling `groebner`

scripts/trace_matrices.jl

@@ -78,6 +78,7 @@ end
 # Includes
 
 include("utils/invariants.jl")
+include("utils/tuples.jl")
 include("utils/packed.jl")
 
 # Test systems, such as katsura, cyclic, etc
@@ -135,6 +136,7 @@ include("reconstruction/ratrec.jl")
 
 #= more high level functions =#
 include("groebner/modular.jl")
+include("groebner/wrapped_trace.jl")
 include("groebner/groebner.jl")
 include("groebner/groebner_with_change_matrix.jl")
 include("groebner/learn_apply.jl")

src/Groebner.jl

@@ -170,10 +170,10 @@ function basis_well_formed(ring::PolyRing, basis::Basis, hashtable::MonomialHash
             basis.monoms[i],
             lt=(j, k) -> monom_isless(hashtable.monoms[k], hashtable.monoms[j], ring.ord)
         ) && error("Bad polynomial")
+        iszero(basis.coeffs[i][1]) && error("Leading coefficient is zero")
         for j in 1:length(basis.coeffs[i])
-            iszero(basis.coeffs[i][j]) && error("Coefficient is zero")
             (ring.ground == :zp) &&
-                !(basis.coeffs[i][j] < ring.ch) &&
+                !(-1 < basis.coeffs[i][j] < ring.characteristic) &&
                 error("Coefficients must be normalized")
             (basis.monoms[i][j] > hashtable.load) && error("Bad monomial")
         end

src/f4/basis.jl

@@ -26,7 +26,7 @@ function f4_initialize_structs_with_trace(
         make_monic=make_monic,
         sort_input=sort_input
     )
-    trace = trace_initialize(ring, basis_deepcopy(basis), basis, hashtable, permutation, params)
+    trace = trace_initialize(ring, basis, hashtable, permutation, params)
     trace, basis, pairset, hashtable, permutation
 end
 
@@ -153,21 +153,17 @@ function f4_reducegb_learn!(
     trace.output_nonredundant_indices = copy(basis.nonredundant_indices[1:k])
 end
 
-function f4_learn!(
-    trace::Trace,
-    ring::PolyRing,
-    basis::Basis{C},
-    pairset::Pairset,
-    hashtable::MonomialHashtable{M},
-    params::AlgorithmParameters
-) where {M <: Monom, C <: Coeff}
+function f4_learn!(trace::Trace, pairset::Pairset, params::AlgorithmParameters)
+    ring = trace.ring
+    basis = trace.gb_basis
+    hashtable = trace.hashtable
+
     @invariant basis_well_formed(ring, basis, hashtable)
-    @invariant basis == trace.gb_basis
     @invariant params.reduced
 
     basis_make_monic!(basis, params.arithmetic, params.changematrix)
 
-    matrix = matrix_initialize(ring, C)
+    matrix = matrix_initialize(ring, eltype(eltype(basis.coeffs)))
     update_ht = hashtable_initialize_secondary(hashtable)
     symbol_ht = hashtable_initialize_secondary(hashtable)
 
@@ -480,23 +476,21 @@ function f4_standardize_basis_in_apply!(ring::PolyRing, trace::Trace, arithmetic
     basis_make_monic!(basis, arithmetic, false)
 end
 
-function f4_apply!(
-    trace::Trace,
-    ring::PolyRing,
-    basis::Basis{C},
-    params::AlgorithmParameters
-) where {C <: Coeff}
-    # @invariant basis_well_formed(ring, basis, trace.hashtable)
+function f4_apply!(trace::Trace, params::AlgorithmParameters)
+    ring = trace.ring
+    basis = trace.buf_basis
+    hashtable = trace.hashtable
+
+    @invariant basis_well_formed(ring, basis, trace.hashtable)
     @invariant params.reduced
 
     iters_total = length(trace.matrix_infos) - 1
     iters = 0
-    hashtable = trace.hashtable
 
     basis_make_monic!(basis, params.arithmetic, params.changematrix)
 
     symbol_ht = hashtable_initialize_secondary(hashtable)
-    matrix = matrix_initialize(ring, C)
+    matrix = matrix_initialize(ring, eltype(eltype(basis.coeffs)))
 
     basis_update!(basis, hashtable)