Remove deprecated use of Frac

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)))

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,15 +451,15 @@ 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
 
 function AbstractAlgebra.promote_rule(::Type{FFET}, ::Type{U}) where {T, FFET<:VarietyFunctionFieldElem{T}, U<:RingElement}
   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 
 

experimental/Schemes/Types.jl

@@ -38,15 +38,15 @@ end
 ########################################################################
 # Elements of VarietyFunctionFields                                    #
 ########################################################################
-mutable struct VarietyFunctionFieldElem{FracType<:AbstractAlgebra.Generic.Frac,
+mutable struct VarietyFunctionFieldElem{FracType<:AbstractAlgebra.Generic.FracFieldElem,
                                         ParentType<:VarietyFunctionField
                                        }
   KK::ParentType
   f::FracType
 
   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")

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)

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))

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)}()

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)

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)

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)

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
 

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

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