Drop redundant check_parent methods (#1542)

... in favor of generic one from AA 0.41.9
thofma · Jun 12, 2024 · a12d236 · a12d236
1 parent 0ff72f1
commit a12d236
Show file tree

Hide file tree

Showing 13 changed files with 9 additions and 98 deletions.
diff --git a/Project.toml b/Project.toml
@@ -28,7 +28,7 @@ GAPExt = "GAP"
 PolymakeExt = "Polymake"
 
 [compat]
-AbstractAlgebra = "^0.41.5"
+AbstractAlgebra = "^0.41.9"
 Dates = "1.6"
 Distributed = "1.6"
 GAP = "0.9.6, 0.10, 0.11"

diff --git a/examples/Round2.jl b/examples/Round2.jl
@@ -158,8 +158,6 @@ Nemo.canonical_unit(a::OrderElem) = OrderElem(parent(a), ZZRingElem(1))
 
 Base.deepcopy_internal(a::OrderElem, dict::IdDict) = OrderElem(parent(a), Base.deepcopy_internal(a.data, dict))
 
-check_parent(a::OrderElem, b::OrderElem) = parent(a) == parent(b) || error("Incompatible orders")
-
 +(a::OrderElem, b::OrderElem) = check_parent(a, b) && OrderElem(parent(a), a.data + b.data)
 -(a::OrderElem, b::OrderElem) = check_parent(a, b) && OrderElem(parent(a), a.data - b.data)
 -(a::OrderElem) = OrderElem(parent(a), -a.data)
@@ -849,8 +847,6 @@ function expressify(a::HessQRElem; context = nothing)
                               expressify(a.g, context = context)))
 end
 
-check_parent(a::HessQRElem, b::HessQRElem) = parent(a) == parent(b) || error("Incompatible rings")
-
 function Hecke.integral_split(a::Generic.RationalFunctionFieldElem{QQFieldElem}, S::HessQR)
   if iszero(a)
     return zero(S), one(S)

diff --git a/src/AlgAssAbsOrd/Elem.jl b/src/AlgAssAbsOrd/Elem.jl
@@ -4,16 +4,6 @@ parent_type(::Type{AlgAssAbsOrdElem{S, T}}) where {S, T} = AlgAssAbsOrd{S, T}
 
 Base.hash(x::AlgAssAbsOrdElem, h::UInt) = hash(elem_in_algebra(x, copy = false), h)
 
-################################################################################
-#
-#  Parent check
-#
-################################################################################
-
-function check_parent(x::AlgAssAbsOrdElem{S, T}, y::AlgAssAbsOrdElem{S, T}) where {S, T}
-  return parent(x) === parent(y)
-end
-
 ################################################################################
 #
 #  Parent object overloading
@@ -175,12 +165,12 @@ end
 ###############################################################################
 
 function *(x::T, y::T) where { T <: Union{ AlgAssAbsOrdElem, AlgAssRelOrdElem } }
-  !check_parent(x, y) && error("Wrong parents")
+  check_parent(x, y)
   return parent(x)(elem_in_algebra(x, copy = false)*elem_in_algebra(y, copy = false))
 end
 
 function +(x::T, y::T) where { T <: Union{ AlgAssAbsOrdElem, AlgAssRelOrdElem } }
-  !check_parent(x, y) && error("Wrong parents")
+  check_parent(x, y)
   z = parent(x)(elem_in_algebra(x, copy = false) + elem_in_algebra(y, copy = false))
   if x.has_coord && y.has_coord
     z.coordinates = [ x.coordinates[i] + y.coordinates[i] for i = 1:degree(parent(x)) ]
@@ -190,7 +180,7 @@ function +(x::T, y::T) where { T <: Union{ AlgAssAbsOrdElem, AlgAssRelOrdElem }
 end
 
 function -(x::T, y::T) where { T <: Union{ AlgAssAbsOrdElem, AlgAssRelOrdElem } }
-  !check_parent(x, y) && error("Wrong parents")
+  check_parent(x, y)
   z = parent(x)(elem_in_algebra(x, copy = false) - elem_in_algebra(y, copy = false))
   if x.has_coord && y.has_coord
     z.coordinates = [ x.coordinates[i] - y.coordinates[i] for i = 1:degree(parent(x)) ]
@@ -213,7 +203,7 @@ end
 
 # Computes a/b if action is :right and b\a if action is :left (and if this is possible)
 function divexact(a::T, b::T, action::Symbol, check::Bool = true) where { T <: Union{ AlgAssAbsOrdElem, AlgAssRelOrdElem } }
-  !check_parent(a, b) && error("Wrong parents")
+  check_parent(a, b)
   O = parent(a)
   c = divexact(elem_in_algebra(a, copy = false), elem_in_algebra(b, copy = false), action)
   if check

diff --git a/src/AlgAssRelOrd/Elem.jl b/src/AlgAssRelOrd/Elem.jl
@@ -9,16 +9,6 @@ Returns the order containing $x$.
 """
 @inline parent(x::AlgAssRelOrdElem) = x.parent
 
-################################################################################
-#
-#  Parent check
-#
-################################################################################
-
-function check_parent(x::AlgAssRelOrdElem{S, T, U}, y::AlgAssRelOrdElem{S, T, U}) where {S, T, U}
-  return parent(x) === parent(y)
-end
-
 ################################################################################
 #
 #  Parent object overloading

diff --git a/src/FunField/DegreeLocalization.jl b/src/FunField/DegreeLocalization.jl
@@ -26,10 +26,6 @@ end
 
 parent(a::KInftyElem{T}) where T <: FieldElement = a.parent
 
-function check_parent(a::KInftyElem{T}, b::KInftyElem{T})  where T <: FieldElement
-  parent(a) != parent(b) && error("Parent objects do not match")
-end
-
 function Base.hash(a::KInftyElem, h::UInt)
   b = 0x32ba43ad011affd1%UInt
   return xor(b, hash(data(a), h))

diff --git a/src/FunField/HessQR.jl b/src/FunField/HessQR.jl
@@ -111,8 +111,6 @@ function expressify(a::HessQRElem; context = nothing)
                               expressify(a.g, context = context)))
 end
 
-check_parent(a::HessQRElem, b::HessQRElem) = parent(a) == parent(b) || error("Incompatible rings")
-
 function Hecke.integral_split(a::Generic.RationalFunctionFieldElem{QQFieldElem}, S::HessQR)
   if iszero(a)
     return zero(S), one(S)

diff --git a/src/GenOrd/GenOrd.jl b/src/GenOrd/GenOrd.jl
@@ -248,17 +248,6 @@ function AbstractAlgebra.promote_rule(::Type{GenOrdElem{S, T}}, ::Type{U}) where
   return Union{}
 end
 
-################################################################################
-#
-#  Parent check
-#
-################################################################################
-
-function check_parent(a::GenOrdElem, b::GenOrdElem)
-  parent(a) == parent(b) || error("Incompatible orders")
-  return nothing
-end
-
 ################################################################################
 #
 #  Arithmetic

diff --git a/src/LocalField/Elem.jl b/src/LocalField/Elem.jl
@@ -398,13 +398,6 @@ function valuation(a::LocalFieldElem{S, UnramifiedLocalField}) where S <: FieldE
   return v
 end
 
-function check_parent(a::LocalFieldElem{S, T}, b::LocalFieldElem{S, T}) where {S <: FieldElem, T <: LocalFieldParameter}
-  if parent(a) !== parent(b)
-    error("Wrong parents!")
-  end
-  return nothing
-end
-
 ################################################################################
 #
 #  Representation matrix

diff --git a/src/Misc/OrdLocalization.jl b/src/Misc/OrdLocalization.jl
@@ -110,11 +110,6 @@ nf(a::OrdLocElem{T}) where {T <: AbsSimpleNumFieldElem} = nf(parent(a))
 
 parent(a::OrdLocElem{T})  where {T <: AbsSimpleNumFieldElem} = a.parent
 
-function check_parent(a::OrdLocElem{T}, b::OrdLocElem{T})  where {T <: AbsSimpleNumFieldElem}
-    parent(a) != parent(b) && error("Parent objects do not match")
-end
-
-
 ###############################################################################
 #
 #   Basic manipulation

diff --git a/src/NumFieldOrd/NfOrd/Elem.jl b/src/NumFieldOrd/NfOrd/Elem.jl
@@ -157,16 +157,6 @@ end
 
 (O::AbsNumFieldOrder)() = AbsNumFieldOrderElem(O)
 
-################################################################################
-#
-#  Parent check
-#
-################################################################################
-
-function check_parent(x::AbsNumFieldOrderElem{S, T}, y::AbsNumFieldOrderElem{S, T}) where {S, T}
-  return parent(x) === parent(y)
-end
-
 ################################################################################
 #
 #  "Assure" functions for fields

diff --git a/src/NumFieldOrd/NfOrd/ResidueRing.jl b/src/NumFieldOrd/NfOrd/ResidueRing.jl
@@ -229,19 +229,6 @@ function lift(a::AbsSimpleNumFieldOrderQuoRingElem)
   return a.elem
 end
 
-################################################################################
-#
-#  Parent check
-#
-################################################################################
-
-function check_parent(x::AbsOrdQuoRingElem, y::AbsOrdQuoRingElem)
-  if parent(x) !== parent(y)
-    error("Elements must have same parents")
-  end
-  return true
-end
-
 ################################################################################
 #
 #  Arithmetic

diff --git a/src/NumFieldOrd/NfRelOrd/ResidueRing.jl b/src/NumFieldOrd/NfRelOrd/ResidueRing.jl
@@ -100,19 +100,6 @@ end
 
 Nemo.residue_ring(O::Union{RelNumFieldOrder, AlgAssRelOrd}, I::Union{RelNumFieldOrderIdeal, AlgAssRelOrdIdl}) = RelOrdQuoRing(O, I)
 
-################################################################################
-#
-#  Parent check
-#
-################################################################################
-
-function check_parent(x::RelOrdQuoRingElem, y::RelOrdQuoRingElem)
-  if parent(x) !== parent(y)
-    error("Elements must have same parents")
-  end
-  return true
-end
-
 ################################################################################
 #
 #  Arithmetic

diff --git a/src/NumFieldOrd/NumFieldOrdElem.jl b/src/NumFieldOrd/NumFieldOrdElem.jl
@@ -88,14 +88,14 @@ end
 ###############################################################################
 
 function *(x::T, y::T) where T <: NumFieldOrderElem
-  @req check_parent(x, y) "Wrong parents"
+  check_parent(x, y)
   z = parent(x)()
   z.elem_in_nf = x.elem_in_nf*y.elem_in_nf
   return z
 end
 
 function +(x::T, y::T) where T <: NumFieldOrderElem
-  @req check_parent(x, y) "Wrong parents"
+  check_parent(x, y)
   z = parent(x)()
   z.elem_in_nf = x.elem_in_nf + y.elem_in_nf
   if x.has_coord && y.has_coord
@@ -107,7 +107,7 @@ function +(x::T, y::T) where T <: NumFieldOrderElem
 end
 
 function -(x::T, y::T) where T <: NumFieldOrderElem
-  @req check_parent(x, y) "Wrong parents"
+  check_parent(x, y)
   z = parent(x)()
   z.elem_in_nf = x.elem_in_nf - y.elem_in_nf
   if x.has_coord && y.has_coord
@@ -118,7 +118,7 @@ function -(x::T, y::T) where T <: NumFieldOrderElem
 end
 
 function divexact(x::T, y::T; check::Bool = true) where T <: NumFieldOrderElem
-  @req check_parent(x, y) "Wrong parents"
+  check_parent(x, y)
   a = divexact(x.elem_in_nf, y.elem_in_nf)
   if check && !(in(a, parent(x)))
     throw(ArgumentError("Quotient not an element of the order."))