Make compatible with AA 0.41 and Nemo 0.44

Project.toml

@@ -1,6 +1,6 @@
 name = "Hecke"
 uuid = "3e1990a7-5d81-5526-99ce-9ba3ff248f21"
-version = "0.30.11"
+version = "0.31.0-DEV"
 
 [deps]
 AbstractAlgebra = "c3fe647b-3220-5bb0-a1ea-a7954cac585d"
@@ -28,7 +28,7 @@ GAPExt = "GAP"
 PolymakeExt = "Polymake"
 
 [compat]
-AbstractAlgebra = "^0.40.9"
+AbstractAlgebra = "^0.41.0"
 Dates = "1.6"
 Distributed = "1.6"
 GAP = "0.9.6, 0.10, 0.11"
@@ -37,7 +37,7 @@ LazyArtifacts = "1.6"
 Libdl = "1.6"
 LinearAlgebra = "1.6"
 Markdown = "1.6"
-Nemo = "^0.43.3"
+Nemo = "^0.44.0"
 Pkg = "1.6"
 Polymake = "0.10, 0.11"
 Printf = "1.6"

src/AlgAss/AlgAss.jl

@@ -24,6 +24,8 @@ end
 
 base_ring(A::StructureConstantAlgebra{T}) where {T} = A.base_ring::parent_type(T)
 
+base_ring_type(::Type{StructureConstantAlgebra{T}}) where {T} = parent_type(T)
+
 has_one(A::StructureConstantAlgebra) = A.has_one
 
 iszero(A::StructureConstantAlgebra) = A.iszero

src/AlgAss/AlgGrp.jl

@@ -8,6 +8,8 @@ denominator_of_multiplication_table(A::GroupAlgebra{QQFieldElem}) = one(ZZ)
 
 base_ring(A::GroupAlgebra{T}) where {T} = A.base_ring::parent_type(T)
 
+base_ring_type(::Type{GroupAlgebra{T}}) where {T} = parent_type(T)
+
 Generic.dim(A::GroupAlgebra) = size(multiplication_table(A, copy = false), 1)
 
 elem_type(::Type{GroupAlgebra{T, S, R}}) where {T, S, R} = GroupAlgebraElem{T, GroupAlgebra{T, S, R}}
@@ -16,8 +18,8 @@ order_type(::GroupAlgebra{QQFieldElem, S, R}) where { S, R } = AlgAssAbsOrd{Grou
 
 order_type(::Type{GroupAlgebra{QQFieldElem, S, R}}) where { S, R } = AlgAssAbsOrd{GroupAlgebra{QQFieldElem, S, R}, elem_type(GroupAlgebra{QQFieldElem, S, R})}
 
-order_type(::GroupAlgebra{T, S, R}) where { T <: NumFieldElem, S, R } = AlgAssRelOrd{T, fractional_ideal_type(order_type(parent_type(T)))}
-order_type(::Type{GroupAlgebra{T, S, R}}) where { T <: NumFieldElem, S, R } = AlgAssRelOrd{T, fractional_ideal_type(order_type(parent_type(T)))}
+order_type(::GroupAlgebra{T, S, R}) where { T <: NumFieldElem, S, R } = AlgAssRelOrd{T, fractional_ideal_type(order_type(parent_type(T))), GroupAlgebra{T, S, R}}
+order_type(::Type{GroupAlgebra{T, S, R}}) where { T <: NumFieldElem, S, R } = AlgAssRelOrd{T, fractional_ideal_type(order_type(parent_type(T))), GroupAlgebra{T, S, R}}
 
 @doc raw"""
     group(A::GroupAlgebra) -> Group

src/AlgAss/AlgMat.jl

@@ -10,6 +10,8 @@ dim(A::MatAlgebra) = A.dim
 
 base_ring(A::MatAlgebra{T, S}) where {T, S} = A.base_ring::parent_type(T)
 
+base_ring_type(::Type{MatAlgebra{T, S}}) where {T, S} = parent_type(T)
+
 coefficient_ring(A::MatAlgebra) = A.coefficient_ring
 
 basis(A::MatAlgebra) = A.basis

src/AlgAss/AlgQuat.jl

@@ -47,6 +47,8 @@ dim(A::QuaternionAlgebra) = 4
 
 base_ring(A::QuaternionAlgebra{T}) where {T} = A.base_ring::parent_type(T)
 
+base_ring_type(::Type{QuaternionAlgebra{T}}) where {T} = parent_type(T)
+
 multiplication_table(A::QuaternionAlgebra; copy = false) = A.mult_table
 
 standard_form(A::QuaternionAlgebra) = A.std

src/AlgAssAbsOrd/Order.jl

@@ -23,6 +23,8 @@ _algebra(O::AlgAssAbsOrd) = algebra(O)
 
 base_ring(O::AlgAssAbsOrd) = FlintZZ
 
+base_ring_type(::Type{AlgAssAbsOrd}) = ZZRing
+
 @doc raw"""
     is_commutative(O::AlgAssAbsOrd) -> Bool
 

src/AlgAssAbsOrd/PicardGroup.jl

@@ -19,8 +19,6 @@ function modulus(f::MapRayClassGroupAlg{S, T}) where {S, T}
   return f.modulus::elem_type(base_ring_type(T))
 end
 
-base_ring_type(::Type{FacElemMon{S}}) where {S} = S
-
 mutable struct MapPicardGrp{S, T} <: Map{S, T, HeckeMap, MapPicardGrp}
   header::MapHeader{S, T}
 

src/AlgAssRelOrd/Order.jl

@@ -20,6 +20,8 @@ Returns an order $R$ in the base ring of the algebra of $O$, such that $O$ is an
 """
 base_ring(O::AlgAssRelOrd) = order(basis_pmatrix(O, copy = false).coeffs[1])
 
+base_ring_type(::Type{<:AlgAssRelOrd{S, T, U}}) where {S, T, U} = order_type(base_ring_type(U))
+
 @doc raw"""
     is_commutative(O::AlgAssRelOrd) -> Bool
 

src/GenOrd/GenOrd.jl

@@ -76,6 +76,8 @@ end
 
 base_ring(O::GenOrd) = O.R
 
+base_ring_type(::Type{GenOrd{S, T}}) where {S, T} = T
+
 coefficient_ring(O::GenOrd) = O.R
 
 field(O::GenOrd) = O.F

src/GrpAb/ChainComplex.jl

@@ -325,6 +325,8 @@ map_type(C::ComplexOfMorphisms) = valtype(C.maps)
 
 Hecke.base_ring(::FinGenAbGroup) = ZZ
 
+Hecke.base_ring_type(::Type{FinGenAbGroup}) = ZZRing
+
 function pres_show(io::IO, C::ComplexOfMorphisms)
   name_mod = String[]
   rank_mod = Int[]

src/GrpAb/stable_sub.jl

@@ -11,6 +11,10 @@ function base_ring(M::ZpnGModule)
   return M.R
 end
 
+function base_ring_type(::Type{ZpnGModule})
+  return Nemo.zzModRing
+end
+
 function show(io::IO, M::ZpnGModule)
   print(io, "Module over Z/", M.R.n, "Z with structure ", M.V)
 end

src/LocalField/map.jl

@@ -10,7 +10,7 @@ mutable struct LocalFieldMor{S, T, U, V, W} <: Map{S, T, HeckeMap, LocalFieldMor
   inverse_data::V
   absolute_basis::Vector{W}
   absolute_basis_matrix_image::Generic.MatSpaceElem{PadicFieldElem}
-  solve_context::Solve.SolveCtx{PadicFieldElem, Generic.MatSpaceElem{PadicFieldElem}, Solve.LazyTransposeMatElem{PadicFieldElem, Generic.MatSpaceElem{PadicFieldElem}}}
+  solve_context::Solve.SolveCtx{PadicFieldElem, Generic.MatSpaceElem{PadicFieldElem}, Generic.MatSpaceElem{PadicFieldElem}, Solve.LazyTransposeMatElem{PadicFieldElem, Generic.MatSpaceElem{PadicFieldElem}}}
 
   function LocalFieldMor{S, T, U, V}() where {S, T, U, V}
     z = new{S, T, U, V, elem_type(S)}()

src/Map/NumField.jl

@@ -109,7 +109,7 @@ mutable struct NumFieldHom{S, T, U, V, W} <: Map{S, T, HeckeMap, NumFieldHom}
   inverse_data::V
   absolute_basis::Vector{W}
   absolute_basis_matrix_image::QQMatrix
-  solve_context::Solve.SolveCtx{QQFieldElem, QQMatrix, QQMatrix}
+  solve_context::Solve.SolveCtx{QQFieldElem, QQMatrix, QQMatrix, QQMatrix}
 
   function NumFieldHom{S, T, U, V}() where {S, T, U, V}
     z = new{S, T, U, V, elem_type(S)}()

src/Misc/FactoredElem.jl

@@ -178,6 +178,8 @@ parent(x::FacElem) = x.parent
 
 base_ring(x::FacElemMon) = x.base_ring
 
+base_ring_type(::Type{FacElemMon{S}}) where {S} = S
+
 base_ring(x::FacElem) = base_ring(parent(x))
 
 base(x::FacElem) = keys(x.fac)

src/Misc/PIDIdeal.jl

@@ -7,6 +7,8 @@ end
 
 base_ring(x::PIDIdeal) = parent(x.gen)
 
+base_ring_type(::Type{PIDIdeal{T}}) where {T} = parent_type(T)
+
 _can_canonicalize(::Type{ZZRingElem}) = true
 
 _can_canonicalize(::Type{<:PolyRingElem{T}}) where {T <: FieldElem} = true

src/Misc/PseudoPolynomial.jl

@@ -15,6 +15,8 @@ iszero(f::PseudoPoly) = iszero(polynomial(f))
 
 base_ring(f::PseudoPoly) = parent(polynomial(f))
 
+base_ring_type(::Type{PseudoPoly{S, T}}) where {S, T} = parent_type(S)
+
 pseudo_polynomial(f, A) = PseudoPoly(f, A)
 
 polynomial(f::PseudoPoly) = f.poly

src/NumField/Embedded.jl

@@ -59,6 +59,10 @@ elem_type(::Type{EmbeddedNumField{S, E}}) where {S, E} = EmbeddedNumFieldElem{el
 
 parent_type(::Type{EmbeddedNumFieldElem{T}}) where {T} = EmbeddedNumField{parent_type(T), embedding_type(parent_type(T))}
 
+base_ring(::EmbeddedNumField) = FlintQQ
+
+base_ring_type(::Type{<:EmbeddedNumField}) = QQField
+
 data(x::EmbeddedNumFieldElem) = x.element
 
 function embedded_field(K::SimpleNumField, i::NumFieldEmb)
@@ -213,8 +217,8 @@ is_negative(x::EmbeddedNumFieldElem) = x < 0
 #
 ################################################################################
 
-function sign(x::EmbeddedNumFieldElem) 
-  if is_zero(x) 
+function sign(x::EmbeddedNumFieldElem)
+  if is_zero(x)
     return x
   end
   if x > 0

src/NumField/NfAbs/NonSimple.jl

@@ -34,6 +34,8 @@
 
 @inline base_ring(K::AbsNonSimpleNumField) = FlintQQ
 
+@inline base_ring_type(K::AbsNonSimpleNumField) = QQField
+
 @inline base_field(K::AbsNonSimpleNumField) = FlintQQ
 
 @inline degree(K::AbsNonSimpleNumField) = K.degree

src/NumFieldOrd/NfOrd/LinearAlgebra.jl

@@ -268,6 +268,8 @@ This function returns the $R$ that was used to defined $M$.
 """
 base_ring(M::PMat{T, S}) where {T, S} = nrows(M) >= 1 ? order(M.coeffs[1]) : M.base_ring::order_type(parent_type(T))
 
+base_ring_type(::Type{PMat{T, S}}) where {T, S} = order_type(parent_type(T))
+
 function pseudo_matrix(m::AbstractAlgebra.MatElem{T}, c::Vector{S}) where {T, S}
   # sanity checks
   @assert nrows(m) == length(c)
@@ -1577,6 +1579,8 @@ end
 
 base_ring(M::ModDed) = M.base_ring
 
+base_ring_type(::Type{ModDed}) = AbsSimpleNumFieldOrder
+
 function show(io::IO, M::ModDed)
    print(io, "Module over $(M.base_ring) with defining pseudo-matrix")
    for i in 1:nrows(M.pmatrix.matrix)

src/NumFieldOrd/NfOrd/NfOrd.jl

@@ -50,7 +50,9 @@ fractional_ideal_type(::AbsNumFieldOrder{S, T}) where {S, T} = AbsSimpleNumField
 
 fractional_ideal_type(::Type{AbsNumFieldOrder{S, T}}) where {S, T} = AbsSimpleNumFieldOrderFractionalIdeal
 
-Nemo.base_ring(::AbsNumFieldOrder) = FlintZZ
+base_ring(::AbsNumFieldOrder) = FlintZZ
+
+base_ring_type(::Type{<:AbsNumFieldOrder}) = ZZRing
 
 @doc raw"""
     parent(O::AbsNumFieldOrder) -> AbsNumFieldOrderSet

src/NumFieldOrd/NfOrd/ResidueRing.jl

@@ -53,6 +53,8 @@ end
 
 base_ring(Q::AbsOrdQuoRing) = Q.base_ring
 
+base_ring_type(::Type{AbsOrdQuoRing{S, T}}) where {S, T} = S
+
 ideal(Q::AbsOrdQuoRing) = Q.ideal
 
 basis_matrix(Q::AbsOrdQuoRing) = Q.basis_matrix

src/NumFieldOrd/NfRelOrd/NfRelOrd.jl

@@ -20,6 +20,8 @@ parent(O::RelNumFieldOrder) = O.parent
 
 base_ring(O::RelNumFieldOrder) = order(pseudo_basis(O, copy = false)[1][2])
 
+base_ring_type(::Type{RelNumFieldOrder{T, S, U}}) where {T, S, U} = order_type(base_ring_type(NumField{T}))
+
 elem_type(::Type{RelNumFieldOrder{T, S, U}}) where {T, S, U} = RelNumFieldOrderElem{T, U}
 
 ideal_type(::RelNumFieldOrder{T, S, U}) where {T, S, U} = RelNumFieldOrderIdeal{T, S, U}

src/NumFieldOrd/NfRelOrd/ResidueRing.jl

@@ -11,6 +11,8 @@ end
 
 base_ring(Q::RelOrdQuoRing) = Q.base_ring
 
+base_ring_type(::Type{RelOrdQuoRing{T1, T2, T3}}) where {T1, T2, T3} = T1
+
 ideal(Q::RelOrdQuoRing) = Q.ideal
 
 basis_pmatrix(Q::RelOrdQuoRing) = Q.basis_pmatrix

src/QuadForm/Quad/Spaces.jl

@@ -2068,6 +2068,7 @@ end
 local_quad_space_class(K, prime::IntegerUnion, n, d, hasse_inv, k)=local_quad_space_class(K,ideal(ZZ,prime),n,d,hasse_inv,k)
 
 base_ring(G::LocalQuadSpaceCls) = G.K
+base_ring_type(::Type{LocalQuadSpaceCls{S, T, U}}) where {S, T, U} = S
 prime(G::LocalQuadSpaceCls) = G.p
 
 @doc raw"""
@@ -2406,6 +2407,8 @@ det_ndeg(g::QuadSpaceCls) = det_nondegenerate_part(g)
 
 base_ring(g::QuadSpaceCls) = g.K
 
+base_ring_type(::Type{QuadSpaceCls{S, T, U, V}}) where {S, T, U, V} = S
+
 @doc raw"""
     dim_radical(g::QuadSpaceCls) -> Int
 

src/QuadForm/Quad/ZLattices.jl

@@ -13,6 +13,8 @@ ambient_space(L::ZZLat) = L.space
 
 base_ring(L::ZZLat) = FlintZZ
 
+base_ring_type(::Type{ZZLat}) = ZZRing
+
 base_field(L::ZZLat) = base_ring(gram_matrix(ambient_space(L)))
 
 ################################################################################

src/QuadForm/QuadBin.jl

@@ -92,6 +92,8 @@ end
 
 base_ring(f::QuadBin{T}) where {T} = f.base_ring::parent_type(T)
 
+base_ring_type(::Type{QuadBin{T}}) where {T} = parent_type(T)
+
 ###############################################################################
 #
 #   Coefficients

src/RCF/class_fields.jl

@@ -62,6 +62,8 @@ function base_ring(A::ClassField)
   return order(codomain(A.rayclassgroupmap))
 end
 
+base_ring_type(A::ClassField) = AbsNumFieldOrder{AbsSimpleNumField, AbsSimpleNumFieldElem}
+
 @doc raw"""
     base_field(A::ClassField)
 

src/Sparse/Matrix.jl

@@ -17,6 +17,8 @@ end
 
 base_ring(A::SMatSpace{T}) where {T} = A.base_ring::parent_type(T)
 
+base_ring_type(::Type{SMatSpace{T}}) where {T} = parent_type(T)
+
 parent(A::SMat) = SMatSpace(base_ring(A), A.r, A.c)
 
 base_ring(A::SMat{T}) where {T} = A.base_ring::parent_type(T)

src/Sparse/Row.jl

@@ -25,6 +25,8 @@ function base_ring(A::SRow{T}) where {T}
   end
 end
 
+base_ring_type(::Type{SRow{T}}) where {T} = parent_type(T)
+
 ==(x::SRow{T}, y::SRow{T}) where {T} = (x.pos == y.pos) && (x.values == y.values)
 
 ################################################################################