From edbf62a93aa405f57fcd67f5d5f20013df5c3fdd Mon Sep 17 00:00:00 2001 From: Johannes Schmitt Date: Fri, 16 Feb 2024 13:37:41 +0100 Subject: [PATCH] Remove deprecated functions (#3366) * Remove deprecated use of `Frac` * Remove deprecated use of `chi` * Remove deprecated use of `MPolyElem` --- .../src/LiteratureModels/constructors.jl | 4 ++-- .../FTheoryTools/src/TateModels/attributes.jl | 2 +- .../src/TateModels/constructors.jl | 2 +- .../src/WeierstrassModels/constructors.jl | 2 +- .../src/IntersectionTheory.jl | 2 +- experimental/ModStd/ModStdQt.jl | 14 +++++++------- experimental/Schemes/FunctionFields.jl | 6 +++--- experimental/Schemes/Types.jl | 4 ++-- experimental/Schemes/elliptic_surface.jl | 12 ++++++------ .../Schemes/SpecOpen/Morphisms/Constructors.jl | 4 ++-- .../Schemes/SpecOpen/Rings/Constructors.jl | 18 +++++++++--------- src/InvariantTheory/types.jl | 2 +- src/Rings/FunctionField.jl | 10 +++++----- src/Rings/MPolyQuo.jl | 2 +- src/Rings/localization_interface.jl | 4 ++-- src/Rings/mpoly-graded.jl | 4 ++-- src/Rings/mpoly-ideals.jl | 2 +- src/Rings/mpoly-local.jl | 10 +++++----- src/Rings/mpoly-localizations.jl | 6 +++--- src/Rings/mpolyquo-localizations.jl | 8 ++++---- 20 files changed, 59 insertions(+), 59 deletions(-) diff --git a/experimental/FTheoryTools/src/LiteratureModels/constructors.jl b/experimental/FTheoryTools/src/LiteratureModels/constructors.jl index 00d46b9344d8..87646075844e 100644 --- a/experimental/FTheoryTools/src/LiteratureModels/constructors.jl +++ b/experimental/FTheoryTools/src/LiteratureModels/constructors.jl @@ -297,7 +297,7 @@ function _construct_literature_model_over_concrete_base(model_dict::Dict{String, explicit_model_sections["a6"] = map(a6) # Find defining_section_parametrization - defining_section_parametrization = Dict{String, MPolyElem}() + defining_section_parametrization = Dict{String, MPolyRingElem}() if !("a1" in vars) || (a1 != eval_poly("a1", parent(a1))) defining_section_parametrization["a1"] = a1 end @@ -328,7 +328,7 @@ function _construct_literature_model_over_concrete_base(model_dict::Dict{String, explicit_model_sections["g"] = map(g) # Find defining_section_parametrization - defining_section_parametrization = Dict{String, MPolyElem}() + defining_section_parametrization = Dict{String, MPolyRingElem}() if !("f" in vars) || (f != eval_poly("f", parent(f))) defining_section_parametrization["f"] = f end diff --git a/experimental/FTheoryTools/src/TateModels/attributes.jl b/experimental/FTheoryTools/src/TateModels/attributes.jl index aa56c4712a40..ba8d67c22771 100644 --- a/experimental/FTheoryTools/src/TateModels/attributes.jl +++ b/experimental/FTheoryTools/src/TateModels/attributes.jl @@ -202,7 +202,7 @@ Weierstrass model over a not fully specified base -- SU(5)xU(1) restricted Tate # Compute parametrization of Weierstrass sections parametrization = defining_section_parametrization(t) param_keys = collect(keys(parametrization)) - new_defining_section_parametrization = Dict{String, MPolyElem}() + new_defining_section_parametrization = Dict{String, MPolyRingElem}() if length(param_keys) > 0 # Find ring to evaluate polynomials into R = parent(parametrization[param_keys[1]]) diff --git a/experimental/FTheoryTools/src/TateModels/constructors.jl b/experimental/FTheoryTools/src/TateModels/constructors.jl index 128123c114f9..7c46ae037f2b 100644 --- a/experimental/FTheoryTools/src/TateModels/constructors.jl +++ b/experimental/FTheoryTools/src/TateModels/constructors.jl @@ -168,7 +168,7 @@ function global_tate_model(auxiliary_base_ring::MPolyRing, auxiliary_base_gradin end # Compute defining_section_parametrization - defining_section_parametrization = Dict{String, MPolyElem}() + defining_section_parametrization = Dict{String, MPolyRingElem}() vars_S = [string(k) for k in gens(S)] if !("a1" in vars_S) || (a1 != eval_poly("a1", parent(a1))) defining_section_parametrization["a1"] = a1 diff --git a/experimental/FTheoryTools/src/WeierstrassModels/constructors.jl b/experimental/FTheoryTools/src/WeierstrassModels/constructors.jl index ee0867bad7f6..efa9d92f81c5 100644 --- a/experimental/FTheoryTools/src/WeierstrassModels/constructors.jl +++ b/experimental/FTheoryTools/src/WeierstrassModels/constructors.jl @@ -148,7 +148,7 @@ function weierstrass_model(auxiliary_base_ring::MPolyRing, auxiliary_base_gradin end # Compute defining_section_parametrization - defining_section_parametrization = Dict{String, MPolyElem}() + defining_section_parametrization = Dict{String, MPolyRingElem}() vars_S = [string(k) for k in gens(S)] if !("f" in vars_S) || (f != eval_poly("f", parent(f))) defining_section_parametrization["f"] = f diff --git a/experimental/IntersectionTheory/src/IntersectionTheory.jl b/experimental/IntersectionTheory/src/IntersectionTheory.jl index 3627885cd3f7..562acf03edf3 100644 --- a/experimental/IntersectionTheory/src/IntersectionTheory.jl +++ b/experimental/IntersectionTheory/src/IntersectionTheory.jl @@ -3,7 +3,7 @@ using ..Oscar import Base: +, -, *, ^, ==, div, zero, one, parent import ..Oscar: AffAlgHom, Ring, MPolyDecRingElem, symmetric_power, exterior_power, pullback, canonical_bundle, graph, euler_characteristic, pullback -import ..Oscar: basis, betti, chi, codomain, degree, det, dim, domain, dual, gens, hilbert_polynomial, hom, integral, rank, signature +import ..Oscar: basis, betti, codomain, degree, det, dim, domain, dual, gens, hilbert_polynomial, hom, integral, rank, signature import ..Oscar.AbstractAlgebra: combinations import ..Oscar.AbstractAlgebra.Generic: FunctionalMap diff --git a/experimental/ModStd/ModStdQt.jl b/experimental/ModStd/ModStdQt.jl index d5e71977c2fe..983c9eb0f229 100644 --- a/experimental/ModStd/ModStdQt.jl +++ b/experimental/ModStd/ModStdQt.jl @@ -161,7 +161,7 @@ end mutable struct Vals{T} v::Vector{Vector{T}} nd::Vector{Tuple{<:PolyRingElem{T}, <:PolyRingElem{T}}} - G::RingElem # can be Generic.Frac{<:MPolyRingElem{T}} or PolyRingElem + G::RingElem # can be Generic.FracFieldElem{<:MPolyRingElem{T}} or PolyRingElem function Vals(v::Vector{Vector{S}}) where {S} r = new{S}() r.v = v @@ -275,11 +275,11 @@ function Base.setindex!(v::Vals{T}, c::T, i::Int, j::Int) where {T} v.v[i][j] = c end -function exp_groebner_basis(I::Oscar.MPolyIdeal{<:Generic.MPoly{<:Generic.Frac{QQMPolyRingElem}}}; ord::Symbol = :degrevlex, complete_reduction::Bool = true) +function exp_groebner_basis(I::Oscar.MPolyIdeal{<:Generic.MPoly{<:Generic.FracFieldElem{QQMPolyRingElem}}}; ord::Symbol = :degrevlex, complete_reduction::Bool = true) Oscar.exp_groebner_assure(I, ord, complete_reduction = complete_reduction) end -function exp_groebner_assure(I::Oscar.MPolyIdeal{<:Generic.MPoly{<:Generic.Frac{QQMPolyRingElem}}}, ord::Symbol = :degrevlex; complete_reduction::Bool = true) +function exp_groebner_assure(I::Oscar.MPolyIdeal{<:Generic.MPoly{<:Generic.FracFieldElem{QQMPolyRingElem}}}, ord::Symbol = :degrevlex; complete_reduction::Bool = true) T = QQFieldElem if ord == :degrevlex && isdefined(I, :gb) return I.gb @@ -559,7 +559,7 @@ function _cmp(f::MPolyRingElem, g::MPolyRingElem) end @doc raw""" - factor_absolute(f::MPolyRingElem{Generic.Frac{QQMPolyRingElem}}) + factor_absolute(f::MPolyRingElem{Generic.FracFieldElem{QQMPolyRingElem}}) For an irreducible polynomial in Q[A][X], perform an absolute factorisation, ie. a factorisation in K[X] where K is the @@ -599,7 +599,7 @@ Multivariate polynomial ring in 2 variables X[1], X[2] over residue field of univariate polynomial ring modulo t^2 + a[1] ``` """ -function Oscar.factor_absolute(f::MPolyRingElem{Generic.Frac{QQMPolyRingElem}}) +function Oscar.factor_absolute(f::MPolyRingElem{Generic.FracFieldElem{QQMPolyRingElem}}) Qtx = parent(f) # Q[t1,t2][x1,x2] Qt = base_ring(base_ring(Qtx)) # Q[t1,t2] Rx, x = polynomial_ring(QQ, ngens(Qtx) + ngens(Qt)) # Q[x1,x2,t1,t2] @@ -639,7 +639,7 @@ function Oscar.factor_absolute(f::MPolyRingElem{Generic.Frac{QQMPolyRingElem}}) return an end -function Oscar.is_absolutely_irreducible(f::MPolyRingElem{Generic.Frac{QQMPolyRingElem}}) +function Oscar.is_absolutely_irreducible(f::MPolyRingElem{Generic.FracFieldElem{QQMPolyRingElem}}) lf = factor_absolute(f) @assert length(lf) > 1 return length(lf) == 2 && lf[2][end] == 1 && is_one(lf[2][2]) @@ -852,7 +852,7 @@ function my_reduce(A, d) end function Oscar.lift(f::PolyRingElem, g::PolyRingElem, a::AbsSimpleNumFieldElem, b::AbsSimpleNumFieldElem, V::Vector{QQFieldElem}) - S = base_ring(f) # should be a Frac{MPoly} + S = base_ring(f) # should be a FracFieldElem{MPoly} R = base_ring(S) d_a = reduce(lcm, map(denominator, coefficients(f))) diff --git a/experimental/Schemes/FunctionFields.jl b/experimental/Schemes/FunctionFields.jl index 30917adbb133..4010e36d1171 100644 --- a/experimental/Schemes/FunctionFields.jl +++ b/experimental/Schemes/FunctionFields.jl @@ -290,7 +290,7 @@ function move_representative( return h_generic end -function (KK::VarietyFunctionField)(h::AbstractAlgebra.Generic.Frac; check::Bool=true) +function (KK::VarietyFunctionField)(h::AbstractAlgebra.Generic.FracFieldElem; check::Bool=true) return KK(numerator(h), denominator(h), check=check) end @@ -451,7 +451,7 @@ inv(f::VarietyFunctionFieldElem) = parent(f)(denominator(representative(f)), ) AbstractAlgebra.promote_rule(::Type{T}, ::Type{S}) where {T<:VarietyFunctionFieldElem, S<:Integer} = T -AbstractAlgebra.promote_rule(::Type{T}, ::Type{S}) where {T<:VarietyFunctionFieldElem, S<:AbstractAlgebra.Generic.Frac} = T +AbstractAlgebra.promote_rule(::Type{T}, ::Type{S}) where {T<:VarietyFunctionFieldElem, S<:AbstractAlgebra.Generic.FracFieldElem} = T AbstractAlgebra.promote_rule(::Type{T}, ::Type{T}) where {T<:VarietyFunctionFieldElem} = T @@ -459,7 +459,7 @@ function AbstractAlgebra.promote_rule(::Type{FFET}, ::Type{U}) where {T, FFET<:V promote_rule(T, U) == T ? FFET : Union{} end -function AbstractAlgebra.promote_rule(::Type{FFET}, ::Type{U}) where {T, FFET<:VarietyFunctionFieldElem{AbstractAlgebra.Generic.Frac{T}}, U<:RingElement} +function AbstractAlgebra.promote_rule(::Type{FFET}, ::Type{U}) where {T, FFET<:VarietyFunctionFieldElem{AbstractAlgebra.Generic.FracFieldElem{T}}, U<:RingElement} promote_rule(T, U) == T ? FFET : Union{} end diff --git a/experimental/Schemes/Types.jl b/experimental/Schemes/Types.jl index 18070be54a64..632284775f9d 100644 --- a/experimental/Schemes/Types.jl +++ b/experimental/Schemes/Types.jl @@ -38,7 +38,7 @@ end ######################################################################## # Elements of VarietyFunctionFields # ######################################################################## -mutable struct VarietyFunctionFieldElem{FracType<:AbstractAlgebra.Generic.Frac, +mutable struct VarietyFunctionFieldElem{FracType<:AbstractAlgebra.Generic.FracFieldElem, ParentType<:VarietyFunctionField } KK::ParentType @@ -46,7 +46,7 @@ mutable struct VarietyFunctionFieldElem{FracType<:AbstractAlgebra.Generic.Frac, function VarietyFunctionFieldElem( KK::VarietyFunctionField, - f::AbstractAlgebra.Generic.Frac; + f::AbstractAlgebra.Generic.FracFieldElem; check::Bool=true ) representative_field(KK) == parent(f) || error("element does not have the correct parent") diff --git a/experimental/Schemes/elliptic_surface.jl b/experimental/Schemes/elliptic_surface.jl index fe2c64a2444b..c03058036eb2 100644 --- a/experimental/Schemes/elliptic_surface.jl +++ b/experimental/Schemes/elliptic_surface.jl @@ -96,7 +96,7 @@ Elliptic surface with generic fiber -x^3 + y^2 - t^7 + 2*t^6 - t^5 """ function elliptic_surface(generic_fiber::EllipticCurve{BaseField}, euler_characteristic::Int, mwl_basis::Vector{<:EllipticCurvePoint}=EllipticCurvePoint[]) where { - BaseField <: Frac{<:PolyRingElem{<:FieldElem}}} + BaseField <: FracFieldElem{<:PolyRingElem{<:FieldElem}}} @req all(parent(i)==generic_fiber for i in mwl_basis) "not a vector of points on $(generic_fiber)" S = EllipticSurface(generic_fiber, euler_characteristic, mwl_basis) return S @@ -1154,7 +1154,7 @@ function two_neighbor_step(X::EllipticSurface, F::Vector{QQFieldElem}) # Make sure the coefficient of y² is one (or a square) so that # completing the square works. - c = my_const(coeff(eqn1, [x2, y2], [0, 2]))::AbstractAlgebra.Generic.Frac + c = my_const(coeff(eqn1, [x2, y2], [0, 2]))::AbstractAlgebra.Generic.FracFieldElem eqn1 = inv(unit(factor(c)))*eqn1 eqn2, phi2 = _normalize_hyperelliptic_curve(eqn1) @@ -1166,7 +1166,7 @@ function two_neighbor_step(X::EllipticSurface, F::Vector{QQFieldElem}) # Make sure the coefficient of y² is one (or a square) so that # completing the square works. - c = my_const(coeff(eqn1, [x2, y2], [0, 2]))::AbstractAlgebra.Generic.Frac + c = my_const(coeff(eqn1, [x2, y2], [0, 2]))::AbstractAlgebra.Generic.FracFieldElem eqn1 = inv(unit(factor(c)))*eqn1 eqn2, phi2 = _normalize_hyperelliptic_curve(eqn1) @@ -1593,11 +1593,11 @@ function _is_in_weierstrass_form(f::MPolyRingElem) return f == (-(y^2 + a1*x*y + a3*y) + (x^3 + a2*x^2 + a4*x + a6)) end -function evaluate(f::AbstractAlgebra.Generic.Frac{<:MPolyRingElem}, a::Vector{T}) where {T<:RingElem} +function evaluate(f::AbstractAlgebra.Generic.FracFieldElem{<:MPolyRingElem}, a::Vector{T}) where {T<:RingElem} return evaluate(numerator(f), a)//evaluate(denominator(f), a) end -function evaluate(f::AbstractAlgebra.Generic.Frac{<:PolyRingElem}, a::RingElem) +function evaluate(f::AbstractAlgebra.Generic.FracFieldElem{<:PolyRingElem}, a::RingElem) return evaluate(numerator(f), a)//evaluate(denominator(f), a) end @@ -1640,7 +1640,7 @@ function _elliptic_parameter_conversion(X::EllipticSurface, u::VarietyFunctionFi @assert f == R_to_kkt_frac_XY(f_loc) && _is_in_weierstrass_form(f) "local equation is not in Weierstrass form" a = a_invars(E) - u_loc = u[U]::AbstractAlgebra.Generic.Frac # the representative on the Weierstrass chart + u_loc = u[U]::AbstractAlgebra.Generic.FracFieldElem # the representative on the Weierstrass chart # Set up the ambient_coordinate_ring of the new Weierstrass-chart kkt2, t2 = polynomial_ring(kk, names[3], cached=false) diff --git a/src/AlgebraicGeometry/Schemes/SpecOpen/Morphisms/Constructors.jl b/src/AlgebraicGeometry/Schemes/SpecOpen/Morphisms/Constructors.jl index 752b796d0d15..c97f3311ce03 100644 --- a/src/AlgebraicGeometry/Schemes/SpecOpen/Morphisms/Constructors.jl +++ b/src/AlgebraicGeometry/Schemes/SpecOpen/Morphisms/Constructors.jl @@ -104,7 +104,7 @@ end # functions on the affine patches. # ######################################################################## @doc raw""" - maximal_extension(X::AbsSpec, Y::AbsSpec, f::AbstractAlgebra.Generic.Frac) + maximal_extension(X::AbsSpec, Y::AbsSpec, f::AbstractAlgebra.Generic.FracFieldElem) Given a rational map ``ϕ : X ---> Y ⊂ Spec 𝕜[y₁,…,yₙ]`` of affine schemes determined by ``ϕ*(yⱼ) = fⱼ = aⱼ/bⱼ``, find the maximal open subset ``U⊂ X`` @@ -113,7 +113,7 @@ to which ``ϕ`` can be extended to a regular map ``g : U → Y`` and return ``g` function maximal_extension( X::AbsSpec, Y::AbsSpec, - f::Vector{AbstractAlgebra.Generic.Frac{RET}} + f::Vector{AbstractAlgebra.Generic.FracFieldElem{RET}} ) where {RET<:RingElem} U, g = maximal_extension(X, f) n = length(affine_patches(U)) diff --git a/src/AlgebraicGeometry/Schemes/SpecOpen/Rings/Constructors.jl b/src/AlgebraicGeometry/Schemes/SpecOpen/Rings/Constructors.jl index 8d0ccd373901..c8a6932c4a73 100644 --- a/src/AlgebraicGeometry/Schemes/SpecOpen/Rings/Constructors.jl +++ b/src/AlgebraicGeometry/Schemes/SpecOpen/Rings/Constructors.jl @@ -94,7 +94,7 @@ end # Maximal extensions of rational functions on affine schemes # ######################################################################## @doc raw""" - maximal_extension(X::Spec, f::AbstractAlgebra.Generic.Frac) + maximal_extension(X::Spec, f::AbstractAlgebra.Generic.FracFieldElem) Return the maximal extension of the restriction of ``f`` to a rational function on ``X`` on a maximal domain of @@ -106,7 +106,7 @@ the ring ``𝕜[x₁,…,xₙ]``. """ function maximal_extension( X::AbsSpec{<:Ring, <:MPolyLocRing}, - f::AbstractAlgebra.Generic.Frac{RET} + f::AbstractAlgebra.Generic.FracFieldElem{RET} ) where {RET<:MPolyRingElem} a = numerator(f) @@ -126,7 +126,7 @@ end function maximal_extension( X::AbsSpec{<:Ring, <:MPolyQuoLocRing}, - f::AbstractAlgebra.Generic.Frac{RET} + f::AbstractAlgebra.Generic.FracFieldElem{RET} ) where {RET<:RingElem} a = numerator(f) @@ -141,7 +141,7 @@ end function maximal_extension( X::AbsSpec{<:Ring, <:MPolyQuoRing}, - f::AbstractAlgebra.Generic.Frac{RET} + f::AbstractAlgebra.Generic.FracFieldElem{RET} ) where {RET<:RingElem} a = numerator(f) b = denominator(f) @@ -155,7 +155,7 @@ end function maximal_extension( X::AbsSpec{<:Ring, <:MPolyRing}, - f::AbstractAlgebra.Generic.Frac{RET} + f::AbstractAlgebra.Generic.FracFieldElem{RET} ) where {RET<:RingElem} a = numerator(f) b = denominator(f) @@ -168,7 +168,7 @@ function maximal_extension( end @doc raw""" - maximal_extension(X::Spec, f::Vector{AbstractAlgebra.Generic.Frac}) + maximal_extension(X::Spec, f::Vector{AbstractAlgebra.Generic.FracFieldElem}) Return the extension of the restriction of the ``fᵢ`` as a set of rational functions on ``X`` as *regular* functions to a @@ -180,7 +180,7 @@ be elements of the ring ``𝕜[x₁,…,xₙ]``. """ function maximal_extension( X::AbsSpec{<:Ring, <:AbsLocalizedRing}, - f::Vector{AbstractAlgebra.Generic.Frac{RET}} + f::Vector{AbstractAlgebra.Generic.FracFieldElem{RET}} ) where {RET<:RingElem} if length(f) == 0 return SpecOpen(X), Vector{structure_sheaf_elem_type(X)}() @@ -206,7 +206,7 @@ end function maximal_extension( X::AbsSpec{<:Ring, <:MPolyRing}, - f::Vector{AbstractAlgebra.Generic.Frac{RET}} + f::Vector{AbstractAlgebra.Generic.FracFieldElem{RET}} ) where {RET<:RingElem} if length(f) == 0 return SpecOpen(X), Vector{structure_sheaf_elem_type(X)}() @@ -230,7 +230,7 @@ end function maximal_extension( X::AbsSpec{<:Ring, <:MPolyQuoRing}, - f::Vector{AbstractAlgebra.Generic.Frac{RET}} + f::Vector{AbstractAlgebra.Generic.FracFieldElem{RET}} ) where {RET<:RingElem} if length(f) == 0 return SpecOpen(X), Vector{structure_sheaf_elem_type(X)}() diff --git a/src/InvariantTheory/types.jl b/src/InvariantTheory/types.jl index 157d439dcbf1..299a63eff4a7 100644 --- a/src/InvariantTheory/types.jl +++ b/src/InvariantTheory/types.jl @@ -72,7 +72,7 @@ mutable struct InvRing{FldT, GrpT, PolyRingElemT, PolyRingT, ActionT} reynolds_operator::MapFromFunc{PolyRingT, PolyRingT} - molien_series::Generic.Frac{QQPolyRingElem} + molien_series::Generic.FracFieldElem{QQPolyRingElem} function InvRing(K::FldT, G::GrpT, action::Vector{ActionT}) where {FldT <: Field, GrpT <: AbstractAlgebra.Group, ActionT} n = degree(G) diff --git a/src/Rings/FunctionField.jl b/src/Rings/FunctionField.jl index 17aa3d22e52e..97ea0bc9b1bd 100644 --- a/src/Rings/FunctionField.jl +++ b/src/Rings/FunctionField.jl @@ -9,7 +9,7 @@ function Oscar.singular_coeff_ring(F::AbstractAlgebra.Generic.FracField{T}) wher return Singular.FunctionField(singular_coeff_ring(base_ring(R)), [string(R.S)])[1] end -function (F::Singular.N_FField)(x::AbstractAlgebra.Generic.Frac{T}) where T <: Union{QQPolyRingElem, fpPolyRingElem, FqPolyRingElem} +function (F::Singular.N_FField)(x::AbstractAlgebra.Generic.FracFieldElem{T}) where T <: Union{QQPolyRingElem, fpPolyRingElem, FqPolyRingElem} check_char(F, parent(x)) @req Singular.transcendence_degree(F) == 1 "wrong number of generators" a = Singular.transcendence_basis(F)[1] @@ -29,7 +29,7 @@ function Oscar.singular_coeff_ring(F::AbstractAlgebra.Generic.FracField{T}) wher return Singular.FunctionField(singular_coeff_ring(base_ring(R)), _variables_for_singular(symbols(R)))[1] end -function (F::Singular.N_FField)(x::AbstractAlgebra.Generic.Frac{T}) where T <: Union{QQMPolyRingElem, fpMPolyRingElem, FqMPolyRingElem} +function (F::Singular.N_FField)(x::AbstractAlgebra.Generic.FracFieldElem{T}) where T <: Union{QQMPolyRingElem, fpMPolyRingElem, FqMPolyRingElem} check_char(F, parent(x)) @req Singular.transcendence_degree(F) == ngens(base_ring(parent(x))) "wrong number of generators" a = Singular.transcendence_basis(F) @@ -63,7 +63,7 @@ function (Ox::PolyRing)(f::Singular.spoly) end # coercion -function (F::QQField)(x::AbstractAlgebra.Generic.Frac{T}) where T <: Union{QQPolyRingElem, QQMPolyRingElem} +function (F::QQField)(x::AbstractAlgebra.Generic.FracFieldElem{T}) where T <: Union{QQPolyRingElem, QQMPolyRingElem} num = numerator(x) cst_num = constant_coefficient(num) denom = denominator(x) @@ -76,7 +76,7 @@ function (F::QQField)(x::AbstractAlgebra.Generic.RationalFunctionFieldElem{QQFie return F(x.d) end -function (F::Nemo.fpField)(x::AbstractAlgebra.Generic.Frac{T}) where T <: Union{fpPolyRingElem, fpMPolyRingElem} +function (F::Nemo.fpField)(x::AbstractAlgebra.Generic.FracFieldElem{T}) where T <: Union{fpPolyRingElem, fpMPolyRingElem} num = numerator(x) cst_num = constant_coefficient(num) denom = denominator(x) @@ -85,7 +85,7 @@ function (F::Nemo.fpField)(x::AbstractAlgebra.Generic.Frac{T}) where T <: Union{ F(cst_num) // F(cst_denom) end -function (F::Nemo.FqField)(x::AbstractAlgebra.Generic.Frac{T}) where T <: Union{FqPolyRingElem, FqMPolyRingElem} +function (F::Nemo.FqField)(x::AbstractAlgebra.Generic.FracFieldElem{T}) where T <: Union{FqPolyRingElem, FqMPolyRingElem} num = numerator(x) cst_num = constant_coefficient(num) denom = denominator(x) diff --git a/src/Rings/MPolyQuo.jl b/src/Rings/MPolyQuo.jl index fd27ce7b376f..55f0b89e70e5 100644 --- a/src/Rings/MPolyQuo.jl +++ b/src/Rings/MPolyQuo.jl @@ -1269,7 +1269,7 @@ function vector_space(K::AbstractAlgebra.Field, Q::MPolyQuoRing) end # To fix printing of fraction fields of MPolyQuoRing -function AbstractAlgebra.expressify(a::AbstractAlgebra.Generic.Frac{T}; +function AbstractAlgebra.expressify(a::AbstractAlgebra.Generic.FracFieldElem{T}; context = nothing) where {T <: MPolyQuoRingElem} n = numerator(a, false) d = denominator(a, false) diff --git a/src/Rings/localization_interface.jl b/src/Rings/localization_interface.jl index a09a1e511646..0d3bff66f4aa 100644 --- a/src/Rings/localization_interface.jl +++ b/src/Rings/localization_interface.jl @@ -200,11 +200,11 @@ function localization(R::Ring, U::AbsMultSet) end @doc raw""" - (W::AbsLocalizedRing{RingType, RingElemType, MultSetType})(f::AbstractAlgebra.Generic.Frac{RingElemType}) where {RingType, RingElemType, MultSetType} + (W::AbsLocalizedRing{RingType, RingElemType, MultSetType})(f::AbstractAlgebra.Generic.FracFieldElem{RingElemType}) where {RingType, RingElemType, MultSetType} Converts a fraction f = a//b to an element of the localized ring W. """ -function (W::AbsLocalizedRing{RingType, RingElemType, MultSetType})(f::AbstractAlgebra.Generic.Frac{RingElemType}) where {RingType, RingElemType, MultSetType} +function (W::AbsLocalizedRing{RingType, RingElemType, MultSetType})(f::AbstractAlgebra.Generic.FracFieldElem{RingElemType}) where {RingType, RingElemType, MultSetType} error("conversion for fractions to elements of type $(typeof(W)) is not implemented") end diff --git a/src/Rings/mpoly-graded.jl b/src/Rings/mpoly-graded.jl index 1adbcf1d193f..7eae9699e350 100644 --- a/src/Rings/mpoly-graded.jl +++ b/src/Rings/mpoly-graded.jl @@ -1521,7 +1521,7 @@ function _rational_function_to_power_series(P::QQRelPowerSeriesRing, f) end @doc raw""" - expand(f::Frac{QQPolyRingElem}, d::Int) -> RelPowerSeries + expand(f::FracFieldElem{QQPolyRingElem}, d::Int) -> RelPowerSeries Given a rational function $f$ over the rationals, expand $f$ as a power series up to terms of degree $d$. @@ -1533,7 +1533,7 @@ julia> expand(1//(1 - x^2), 5) 1 + t^2 + t^4 + O(t^6) ``` """ -function expand(f::Generic.Frac{QQPolyRingElem}, d::Int) +function expand(f::Generic.FracFieldElem{QQPolyRingElem}, d::Int) T, t = power_series_ring(QQ, d+1, "t") return _rational_function_to_power_series(T, f) end diff --git a/src/Rings/mpoly-ideals.jl b/src/Rings/mpoly-ideals.jl index 1e8b1ff7bfac..20c1307ad44c 100644 --- a/src/Rings/mpoly-ideals.jl +++ b/src/Rings/mpoly-ideals.jl @@ -2053,7 +2053,7 @@ function flag_pluecker_ideal(F::Field, dimensions::Vector{Int}, n::Int) L2 = reduce(vcat, [subsets(n, d + 1) for d in dimensions]) R, x = polynomial_ring(F, "x" => L; cached=false) - xdict = Dict{Vector{Int},MPolyElem}([L[i] => x[i] for i in 1:length(L)]) + xdict = Dict{Vector{Int},MPolyRingElem}([L[i] => x[i] for i in 1:length(L)]) X = [(a, b) for a in L1, b in L2 if length(b) - length(a) >= 2] diff --git a/src/Rings/mpoly-local.jl b/src/Rings/mpoly-local.jl index f7f2d2639ffd..d6127e138252 100644 --- a/src/Rings/mpoly-local.jl +++ b/src/Rings/mpoly-local.jl @@ -41,15 +41,15 @@ end An element f/g in an instance of `MPolyRingLoc{T}`. The data being stored consists of - * the fraction f/g as an instance of `AbstractAlgebra.Generic.Frac`; + * the fraction f/g as an instance of `AbstractAlgebra.Generic.FracFieldElem`; * the parent instance of `MPolyRingLoc{T}`. """ struct MPolyRingElemLoc{T} <: AbstractAlgebra.RingElem where {T} - frac::AbstractAlgebra.Generic.Frac + frac::AbstractAlgebra.Generic.FracFieldElem parent::MPolyRingLoc{T} # pass with checked = false to skip the non-trivial denominator check - function MPolyRingElemLoc{T}(f::AbstractAlgebra.Generic.Frac, + function MPolyRingElemLoc{T}(f::AbstractAlgebra.Generic.FracFieldElem, p::MPolyRingLoc{T}, checked = true) where {T} R = base_ring(p) B = base_ring(R) @@ -73,7 +73,7 @@ function MPolyRingElemLoc(f::MPolyRingElem{T}, m::Oscar.MPolyIdeal) where {T} return MPolyRingElemLoc{T}(f//R(1), localization(R, m), false) end -function MPolyRingElemLoc(f::AbstractAlgebra.Generic.Frac, m::Oscar.MPolyIdeal) +function MPolyRingElemLoc(f::AbstractAlgebra.Generic.FracFieldElem, m::Oscar.MPolyIdeal) R = parent(numerator(f)) B = base_ring(R) return MPolyRingElemLoc{elem_type(B)}(f, localization(R, m)) @@ -128,7 +128,7 @@ function (W::MPolyRingLoc{T})(f::MPolyRingElem) where {T} return MPolyRingElemLoc{T}(f//one(parent(f)), W) end -function (W::MPolyRingLoc{T})(g::AbstractAlgebra.Generic.Frac) where {T} +function (W::MPolyRingLoc{T})(g::AbstractAlgebra.Generic.FracFieldElem) where {T} return MPolyRingElemLoc{T}(g, W) end diff --git a/src/Rings/mpoly-localizations.jl b/src/Rings/mpoly-localizations.jl index e486f8502322..0f53b1b8a5a3 100644 --- a/src/Rings/mpoly-localizations.jl +++ b/src/Rings/mpoly-localizations.jl @@ -1282,11 +1282,11 @@ mutable struct MPolyLocRingElem{ } W::MPolyLocRing{BaseRingType, BaseRingElemType, RingType, RingElemType, MultSetType} - frac::AbstractAlgebra.Generic.Frac{RingElemType} + frac::AbstractAlgebra.Generic.FracFieldElem{RingElemType} function MPolyLocRingElem( W::MPolyLocRing{BaseRingType, BaseRingElemType, RingType, RingElemType, MultSetType}, - f::AbstractAlgebra.Generic.Frac{RingElemType}; + f::AbstractAlgebra.Generic.FracFieldElem{RingElemType}; check::Bool=true ) where {BaseRingType, BaseRingElemType, RingType, RingElemType, MultSetType} base_ring(parent(f)) == base_ring(W) || error( @@ -1383,7 +1383,7 @@ end RingType, RingElemType, MultSetType - })(f::AbstractAlgebra.Generic.Frac{RingElemType}; check::Bool=true) where { + })(f::AbstractAlgebra.Generic.FracFieldElem{RingElemType}; check::Bool=true) where { BaseRingType, BaseRingElemType, RingType, diff --git a/src/Rings/mpolyquo-localizations.jl b/src/Rings/mpolyquo-localizations.jl index 5b18423b69bf..644e276ad09a 100644 --- a/src/Rings/mpolyquo-localizations.jl +++ b/src/Rings/mpolyquo-localizations.jl @@ -1,4 +1,4 @@ -import AbstractAlgebra: Ring, RingElem, Generic.Frac +import AbstractAlgebra: Ring, RingElem, Generic.FracFieldElem import Base: issubset @@ -363,7 +363,7 @@ function MPolyQuoLocRing(W::MPolyLocRing) return MPolyQuoLocRing(R, I, U, Q, W) end -function Base.in(f::AbstractAlgebra.Generic.Frac{RET}, L::MPolyQuoLocRing{BRT, BRET, RT, RET, MST}) where {BRT, BRET, RT, RET, MST} +function Base.in(f::AbstractAlgebra.Generic.FracFieldElem{RET}, L::MPolyQuoLocRing{BRT, BRET, RT, RET, MST}) where {BRT, BRET, RT, RET, MST} R = base_ring(L) R === parent(numerator(f)) || error("element does not belong to the correct ring") denominator(f) in inverted_set(L) && return true @@ -513,7 +513,7 @@ function (L::MPolyQuoLocRing{ end ### additional conversions -function (L::MPolyQuoLocRing{BRT, BRET, RT, RET, MST})(f::Frac{RET}; check::Bool=true, is_reduced::Bool=false) where {BRT, BRET, RT, RET, MST} +function (L::MPolyQuoLocRing{BRT, BRET, RT, RET, MST})(f::FracFieldElem{RET}; check::Bool=true, is_reduced::Bool=false) where {BRT, BRET, RT, RET, MST} R = base_ring(L) return L(R(numerator(f)), R(denominator(f)), check=check, is_reduced=is_reduced) end @@ -680,7 +680,7 @@ end # to the form [f] = [c]//[dᵏ] with d∈ S. function convert( L::MPolyQuoLocRing{BRT, BRET, RT, RET, MPolyPowersOfElement{BRT, BRET, RT, RET}}, - f::AbstractAlgebra.Generic.Frac{RET} + f::AbstractAlgebra.Generic.FracFieldElem{RET} ) where {BRT, BRET, RT, RET} a = numerator(f) b = denominator(f)