Merge pull request #2107 from Nemocas/mh/ideals

Add `is_subset` and membership test via `in` to `Generic.Ideal`; deprecate `contains`

Author: fingolfin

docs/src/ideal.md

@@ -116,7 +116,7 @@ ideals.
 ### Containment
 
 ```@docs
-contains(::Generic.Ideal{T}, ::Generic.Ideal{T}) where T <: RingElement
+is_subset(::Generic.Ideal{T}, ::Generic.Ideal{T}) where T <: RingElement
 ```
 
 ```@docs
@@ -146,10 +146,10 @@ AbstractAlgebra.Generic.Ideal{AbstractAlgebra.Generic.Poly{BigInt}}(Univariate p
 julia> J = Generic.Ideal(R, W)
 AbstractAlgebra.Generic.Ideal{AbstractAlgebra.Generic.Poly{BigInt}}(Univariate polynomial ring in x over integers, AbstractAlgebra.Generic.Poly{BigInt}[282, 3*x + 255, x^2 + 107])
 
-julia> contains(J, I)
+julia> is_subset(I, J)
 false
 
-julia> contains(I, J)
+julia> is_subset(J, I)
 true
 
 julia> intersect(I, J) == J

src/Deprecations.jl

@@ -62,3 +62,7 @@ end
 
 # deprecated in 0.45.0
 @deprecate test_iterate ConformanceTests.test_iterate
+
+# deprecated in 0.45.2
+import Base: contains
+@deprecate contains(I::Ideal{T}, J::Ideal{T}) where {T <: RingElement} issubset(J, I)

src/generic/Ideal.jl

@@ -2071,14 +2071,27 @@ end
 ###############################################################################
 
 @doc raw"""
-    normal_form(p::U, I::Ideal{U}) where {T <: RingElement, U <: Union{AbstractAlgebra.PolyRingElem{T}, AbstractAlgebra.MPolyRingElem{T}}}
+    normal_form(p::U, I::Ideal{U}) where {U}
 
 Return the normal form of the polynomial `p` with respect to the ideal `I`.
 """
-function normal_form(p::U, I::Ideal{U}) where {T <: RingElement, U <: Union{AbstractAlgebra.PolyRingElem{T}, AbstractAlgebra.MPolyRingElem{T}}}
+function normal_form(p::U, I::Ideal{U}) where {U}
+   is_zero(p) && return copy(p)
+   is_zero(I) && return copy(p)
    return normal_form(p, gens(I))
 end
 
+function normal_form(p::U, I::Ideal{U}) where {U <: FieldElem}
+   iszero(I) && return copy(p)
+   return zero(p)
+end
+
+function normal_form(p::U, I::Ideal{U}) where {U <: Integer}
+   iszero(I) && return copy(p)
+   m = only(gens(I))
+   return rem(p, m, RoundDown)
+end
+
 ###############################################################################
 #
 #   Comparison
@@ -2095,31 +2108,17 @@ end
 #
 ###############################################################################
 
+function Base.in(v::T, I::Ideal{T}) where T <: RingElement
+  return is_zero(normal_form(v, I))
+end
+
 @doc raw"""
-    Base.contains(I::Ideal{T}, J::Ideal{T}) where T <: RingElement
+    Base.issubset(I::Ideal{T}, J::Ideal{T}) where T <: RingElement
 
-Return `true` if the ideal `J` is contained in the ideal `I`.
+Return `true` if the ideal `I` is a subset of the ideal `J`.
 """
-function Base.contains(I::Ideal{T}, J::Ideal{T}) where T <: RingElement
-   G1 = gens(J)
-   G2 = gens(I)
-   if isempty(G1)
-      return true
-   end
-   if isempty(G2)
-      return false
-   end
-   return divides(G1[1], G2[1])[1]
-end
-
-function Base.contains(I::Ideal{T}, J::Ideal{T}) where {U <: RingElement, T <: Union{AbstractAlgebra.PolyRingElem{U}, AbstractAlgebra.MPolyRingElem{U}}}
-   G = gens(J)
-   for v in G
-      if !iszero(normal_form(v, I))
-         return false
-      end
-   end
-   return true
+function Base.issubset(I::Ideal{T}, J::Ideal{T}) where T <: RingElement
+   return all(in(J), gens(I))
 end
 
 ###############################################################################
@@ -2160,9 +2159,9 @@ function intersect(I::Ideal{T}, J::Ideal{T}) where {U <: FieldElement, T <: Abst
 end
 
 function intersect(I::Ideal{T}, J::Ideal{T}) where {U <: RingElement, T <: AbstractAlgebra.PolyRingElem{U}}
-   if contains(I, J)
+   if is_subset(J, I)
       return J
-   elseif contains(J, I)
+   elseif is_subset(I, J)
       return I
    end
    S = base_ring(I) # poly ring
@@ -2183,9 +2182,9 @@ function intersect(I::Ideal{T}, J::Ideal{T}) where {U <: RingElement, T <: Abstr
 end
 
 function intersect(I::Ideal{T}, J::Ideal{T}) where {U <: RingElement, T <: AbstractAlgebra.MPolyRingElem{U}}
-   if contains(I, J)
+   if is_subset(J, I)
       return J
-   elseif contains(J, I)
+   elseif is_subset(I, J)
       return I
    end
    S = base_ring(I) # poly ring