Some more fixes

experimental/DoubleAndHyperComplexes/src/Morphisms/simplified_complexes.jl

@@ -509,12 +509,22 @@ function _simplify_matrix!(A::SMat; find_pivot=nothing)
     end
 
     # Adjust Sinv_transp
-    inc_row = sum(a*Sinv_transp[i] for (i, a) in a_col_del; init=sparse_row(R))
+    #inc_row = sum(a*Sinv_transp[i] for (i, a) in a_col_del; init=sparse_row(R))
+    inc_row = sparse_row(R)
+    for (i, a) in a_col_del
+      #is_zero(Sinv_transp[i]) && continue # can not be true since S is invertible
+      Hecke.add_scaled_row!(Sinv_transp[i], inc_row, a)
+    end
     Hecke.add_scaled_row!(inc_row, Sinv_transp[p], uinv)
 
     # Adjust T
     #T[q] = T[q] + sum(uinv*a*T[i] for (i, a) in a_row_del; init=sparse_row(R))
-    Hecke.add_scaled_row!(sum(a*T[i] for (i, a) in a_row_del if !iszero(T[i]); init=sparse_row(R)), T[q], uinv)
+    inc_row = sparse_row(R)
+    for (i, a) in a_row_del
+      # is_zero(T[i]) && continue # can not be true since T is invertible
+      Hecke.add_scaled_row!(T[i], inc_row, a)
+    end
+    Hecke.add_scaled_row!(inc_row, T[q], uinv)
 
     # Adjust Tinv_transp
     v = deepcopy(Tinv_transp[q])

src/Rings/mpoly-ideals.jl

@@ -572,7 +572,19 @@ Ideal generated by
   3*a*b*c
 ```
 """
-@attr T function radical(I::T) where {T <: MPolyIdeal}
+@attr MPolyIdeal{T} function radical(I::MPolyIdeal{T}) where {T <: MPolyRingElem}
+  # Calling `elimpart` (within `simplify`) turns out to significantly speed things up in many cases.
+  R = base_ring(I)
+  Q, pr = quo(R, I)
+  S, iso, iso_inv = simplify(Q)
+  J = modulus(S)
+  pre_res = _compute_radical(J)
+  res = ideal(R, elem_type(R)[lift(iso_inv(S(g))) for g in gens(pre_res)]) + I
+  set_attribute!(res, :is_radical=>true)
+  return res
+end
+
+function _compute_radical(I::T) where {T <: MPolyIdeal}
   R = base_ring(I)
   if isa(base_ring(R), NumField) && !isa(base_ring(R), AbsSimpleNumField)
     A, mA = absolute_simple_field(base_ring(R))
@@ -629,7 +641,7 @@ end
 
 function map_coefficients(mp, I::MPolyIdeal; parent = nothing)
   if parent === nothing
-    parent = Oscar.parent(map_coefficients(mp, gen(I, 1)))
+    parent = Oscar.parent(map_coefficients(mp, zero(base_ring(I))))
   end
   return ideal(parent, [map_coefficients(mp, g, parent = parent) for g = gens(I)])
 end
@@ -642,12 +654,10 @@ Return whether `I` is a radical ideal.
 Computes the radical.
 """
 @attr Bool function is_radical(I::MPolyIdeal)
-  if has_attribute(I, :is_prime) && is_prime(I)
-    return true
-  end
-
-  return I == radical(I)
+  has_attribute(I, :is_prime) && return is_prime(I)
+  return is_subset(radical(I), I)
 end
+
 #######################################################
 @doc raw"""
     primary_decomposition(I::MPolyIdeal; algorithm = :GTZ, cache=true)
@@ -1149,7 +1159,14 @@ function minimal_primes(
       end
       J = K
     end
-    result = unique!(filter!(!is_one, vcat([minimal_primes(j; algorithm, factor_generators=false) for j in J]...)))
+    # unique! seems to fail here. We have to do it manually.
+    pre_result = filter!(!is_one, vcat([minimal_primes(j; algorithm, factor_generators=false) for j in J]...))
+    result = typeof(I)[]
+    for p in pre_result
+      p in result && continue
+      push!(result, p)
+    end
+
     # The list might not consist of minimal primes only. We have to discard the embedded ones
     final_list = typeof(I)[]
     for p in result
@@ -1209,7 +1226,7 @@ julia> L = equidimensional_decomposition_weak(I)
  Ideal with 1 generator
 ```
 """
-@attr Any function equidimensional_decomposition_weak(I::MPolyIdeal)
+@attr Vector{typeof(I)} function equidimensional_decomposition_weak(I::MPolyIdeal)
   R = base_ring(I)
   iszero(I) && return [I]
   @req coefficient_ring(R) isa AbstractAlgebra.Field "The coefficient ring must be a field"
@@ -1235,7 +1252,7 @@ julia> L = equidimensional_decomposition_weak(I)
   return V
 end
 
-@attr Any function equidimensional_decomposition_weak(
+@attr Vector{typeof(I)} function equidimensional_decomposition_weak(
     I::MPolyIdeal{T}
   ) where {U<:Union{AbsSimpleNumFieldElem, <:Hecke.RelSimpleNumFieldElem}, T<:MPolyRingElem{U}}
   R = base_ring(I)