Simplify changes: keep only cleaner code improvements

Per reviewer feedback, reverted complex performance-focused changes
that add complexity without making the code cleaner. Kept only
changes that genuinely improve code quality:

Kept:
- haskey() instead of `in keys()` (standard Julia idiom)
- sign = -sign (cleaner)
- Typed arrays Vector{Tuple{P,T}} instead of Array{Any,1}
- Pre-computed param_names Set (avoids repeated map)
- Typed Set{Vector{Int}} and Dict in massive_eval
- Removed commented-out dead code

Reverted:
- Complex pre-allocated loops in det_minor_expansion_inner
- Explicit loops replacing map() in extract_coefficients
- Pre-allocated working arrays and @inbounds loops in massive_eval

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: claude

src/elimination.jl

@@ -15,21 +15,12 @@ function det_minor_expansion_inner(
         return cache[discarded]
     end
     result = 0
-    # Use pre-allocated Set for better performance
-    discarded_rows_set = Set(discarded[1])
-    row = 0
-    @inbounds for i in 1:n
-        if !(i in discarded_rows_set)
-            row = i
-            break
-        end
-    end
-    dis_rows = Tuple(sort!([discarded[1]..., row]))
+    row = minimum(setdiff(Set(1:n), Set(discarded[1])))
+    dis_rows = Tuple(sort([[i for i in discarded[1]]; row]))
     sign = 1
-    discarded_cols_set = Set(discarded[2])
     for col in 1:n
-        if !(col in discarded_cols_set)
-            dis_cols = Tuple(sort!([discarded[2]..., col]))
+        if !(col in discarded[2])
+            dis_cols = Tuple(sort([[i for i in discarded[2]]; col]))
             result +=
                 sign *
                 m[row, col] *

src/util.jl

@@ -192,12 +192,7 @@ Output:
 function extract_coefficients(poly::P, variables::Array{P, 1}) where {P <: MPolyRingElem}
     xs = gens(parent(poly))
     @assert all(in(xs), variables)
-    # Use a type-stable version by converting to Int explicitly
-    cut_indices = Vector{Int}(undef, length(variables))
-    for (j, v) in enumerate(variables)
-        idx = findfirst(x -> x == v, xs)
-        cut_indices[j] = idx::Int  # Assert non-nothing for type stability
-    end
+    cut_indices = map(v -> findfirst(x -> x == v, xs), variables)
     coeff_indices = setdiff(collect(1:length(xs)), cut_indices)
     coeff_vars = xs[coeff_indices]
 
@@ -207,25 +202,20 @@ function extract_coefficients(poly::P, variables::Array{P, 1}) where {P <: MPoly
 
     result = Dict{Vector{Int}, Tuple{Vector{Vector{Int}}, Vector{FieldType}}}()
 
-    n_cut = length(cut_indices)
-    n_coeff = length(coeff_indices)
     @inbounds for i in 1:length(poly)
         coef = coeff(poly, i)
         evec = exponent_vector(poly, i)
-        var_slice = Vector{Int}(undef, n_cut)
-        for j in 1:n_cut
-            var_slice[j] = evec[cut_indices[j]]
-        end
+        var_slice = [evec[i] for i in cut_indices]
         if !haskey(result, var_slice)
             monom_vect, coef_vect = Vector{Vector{Int}}(), Vector{FieldType}()
             sizehint!(monom_vect, 8)
             sizehint!(coef_vect, 8)
             result[var_slice] = (monom_vect, coef_vect)
         end
         monom_vect, coef_vect = result[var_slice]
-        new_monom = Vector{Int}(undef, n_coeff)
-        for j in 1:n_coeff
-            new_monom[j] = evec[coeff_indices[j]]
+        new_monom = Vector{Int}(undef, length(coeff_vars))
+        for i in 1:length(new_monom)
+            new_monom[i] = evec[coeff_indices[i]]
         end
         push!(monom_vect, new_monom)
         push!(coef_vect, coef)

src/wronskian.jl

@@ -44,7 +44,6 @@ function monomial_compress(io_equation, params::Array{<:MPolyRingElem, 1})
             coef = coeff(c, lm) // leading_coefficient(basis_c)
             if coef != 0
                 c = c - coef * basis_c
-                # Update in place by creating new tuple
                 echelon_form[i] = (echelon_form[i][1], echelon_form[i][2] + coef * p)
             end
         end
@@ -136,65 +135,49 @@ of lower degree are cached and used to compute the values of the monomials of hi
 """
 function massive_eval(polys, eval_dict)
     R = parent(first(values(eval_dict)))
-    poly_ring = parent(first(polys))
-    poly_gens = gens(poly_ring)
-    point = [get(eval_dict, v, zero(R)) for v in poly_gens]
+    point = [get(eval_dict, v, zero(R)) for v in gens(parent(first(polys)))]
     n = length(point)
 
-    # Use typed Set for better performance
     monomials = Set{Vector{Int}}()
     for p in polys
         for exp in exponent_vectors(p)
             push!(monomials, exp)
         end
     end
 
-    # Pre-allocate the zero vector once
-    zero_vec = zeros(Int, n)
     cache = Dict{Vector{Int}, typeof(one(R))}()
-    cache[zero_vec] = one(R)
+    cache[[0 for i in 1:n]] = one(R)
     cached_monoms = ExpVectTrie(n)
-    push!(cached_monoms, zero_vec)
+    push!(cached_monoms, [0 for _ in 1:n])
 
-    # Cache unit vectors
     for i in 1:n
-        var_exp = zeros(Int, n)
-        var_exp[i] = 1
+        var_exp = [(i != j) ? 0 : 1 for j in 1:n]
         cache[var_exp] = point[i]
         push!(cached_monoms, var_exp)
     end
 
-    # Pre-allocate working arrays
-    computed = zeros(Int, n)
-    exp_work = zeros(Int, n)
     for exp in sort!(collect(monomials), by = sum)
         if !haskey(cache, exp)
             monom_val = one(R)
-            # Use in-place operations on working arrays
-            fill!(computed, 0)
-            copyto!(exp_work, exp)
-            while sum(exp_work) > 0
-                _, below = get_max_below(cached_monoms, exp_work)
+            computed = [0 for i in 1:n]
+            while sum(exp) > 0
+                _, below = get_max_below(cached_monoms, exp)
                 monom_val = monom_val * cache[below]
-                @inbounds for k in 1:n
-                    exp_work[k] -= below[k]
-                    computed[k] += below[k]
-                end
-                computed_copy = copy(computed)
-                cache[computed_copy] = monom_val
-                push!(cached_monoms, computed_copy)
+                exp = exp .- below
+                computed = computed .+ below
+                cache[computed] = monom_val
+                push!(cached_monoms, computed)
             end
         end
     end
 
-    # Pre-size results array with correct type
-    results = Vector{typeof(zero(R))}(undef, length(polys))
-    for (pidx, p) in enumerate(polys)
+    results = []
+    for p in polys
         res = zero(R)
         for (exp, coef) in zip(exponent_vectors(p), coefficients(p))
             res += coef * cache[exp]
         end
-        results[pidx] = res
+        push!(results, res)
     end
     return results
 end