Update wording

src/Fraction.jl

@@ -823,7 +823,7 @@ that it will always be returned by a call to the constructor when the same
 base ring $R$ is supplied.
 """
 function fraction_field(R::Ring; cached::Bool=true)
-   @req !is_trivial(R) "The zero is currently not supported as a coefficient ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
    return Generic.fraction_field(R; cached=cached)
 end
 

src/FreeAssociativeAlgebra.jl

@@ -270,7 +270,7 @@ function free_associative_algebra(
   s::Vector{Symbol};
   cached::Bool = true,
 )
-  @req !is_trivial(R) "The zero is currently not supported as a coefficient ring."
+  @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
   parent_obj = Generic.FreeAssociativeAlgebra{elem_type(R)}(R, s, cached)
   return (parent_obj, gens(parent_obj))
 end

src/LaurentPoly.jl

@@ -40,6 +40,6 @@ julia> rand(R, -3:3, -9:9)
 ```
 """
 function laurent_polynomial_ring(R::Ring, s::VarName; cached::Bool = true)
-   @req !is_trivial(R) "The zero is currently not supported as a coefficient ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
    return Generic.laurent_polynomial_ring(R, Symbol(s); cached)
 end

src/LaurentSeries.jl

@@ -25,7 +25,7 @@ precision in future will return the same parent object and generator. If
 caching of the parent object is not required, `cached` can be set to `false`.
 """
 function laurent_series_ring(R::Ring, prec::Int, s::VarName; cached::Bool=true)
-   @req !is_trivial(R) "The zero is currently not supported as a coefficient ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
    return Generic.laurent_series_ring(R, prec, Symbol(s); cached)
 end
 

src/MPoly.jl

@@ -1509,6 +1509,6 @@ Like [`polynomial_ring(R::Ring, s::Vector{Symbol})`](@ref) but return only the
 multivariate polynomial ring.
 """
 function polynomial_ring_only(R::T, s::Vector{Symbol}; internal_ordering::Symbol=:lex, cached::Bool=true) where T<:Ring
-   @req !is_trivial(R) "The zero is currently not supported as a coefficient ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
    return mpoly_ring_type(T)(R, s, internal_ordering, cached)
 end

src/MatRing.jl

@@ -441,6 +441,6 @@ Return parent object corresponding to the ring of $n\times n$ matrices over
 the ring $R$.
 """
 function matrix_ring(R::NCRing, n::Int)
-   @req !is_trivial(R) "The zero is currently not supported as a base ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as base ring."
    return Generic.matrix_ring(R, n)
 end

src/Matrix.jl

@@ -6633,7 +6633,7 @@ randmat_with_rank(S::MatSpace{T}, rank::Int, v...) where {T <: RingElement} =
 Constructs the matrix over $R$ with entries as in `arr`.
 """
 function matrix(R::NCRing, arr::AbstractMatrix{T}) where {T}
-   @req !is_trivial(R) "The zero is currently not supported as a base ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as base ring."
    if elem_type(R) === T && all(e -> parent(e) === R, arr)
       z = Generic.MatSpaceElem{elem_type(R)}(R, arr)
       return z
@@ -6644,7 +6644,7 @@ function matrix(R::NCRing, arr::AbstractMatrix{T}) where {T}
 end
 
 function matrix(R::NCRing, arr::MatElem)
-   @req !is_trivial(R) "The zero is currently not supported as a base ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as base ring."
    return map_entries(R, arr)
 end
 
@@ -6683,7 +6683,7 @@ Constructs the $r \times c$ matrix over $R$, where the entries are taken
 row-wise from `arr`.
 """
 function matrix(R::NCRing, r::Int, c::Int, arr::AbstractVecOrMat{T}) where T
-   @req !is_trivial(R) "The zero is currently not supported as a base ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as base ring."
    _check_dim(r, c, arr)
    ndims(arr) == 2 && return matrix(R, arr)
    if elem_type(R) === T && all(e -> parent(e) === R, arr)
@@ -7065,7 +7065,7 @@ the ring $R$.
 function matrix_space(R::NCRing, r::Int, c::Int; cached::Bool = true)
   # TODO: the 'cached' argument is ignored and mainly here for backwards compatibility
   # (and perhaps future compatibility, in case we need it again)
-  @req !is_trivial(R) "The zero is currently not supported as a base ring."
+  @req !is_trivial(R) "Zero rings are currently not supported as base ring."
   (r < 0 || c < 0) && error("Dimensions must be non-negative")
   T = elem_type(R)
   return MatSpace{T}(R, r, c)

src/NCPoly.jl

@@ -765,7 +765,7 @@ Like [`polynomial_ring(R::NCRing, s::Symbol)`](@ref) but return only the
 polynomial ring.
 """
 function polynomial_ring_only(R::T, s::Symbol; cached::Bool=true) where T<:NCRing
-   @req !is_trivial(R) "The zero is currently not supported as a coefficient ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
    return dense_poly_ring_type(T)(R, s, cached)
 end
 

src/PuiseuxSeries.jl

@@ -25,7 +25,7 @@ precision in future will return the same parent object and generator. If
 caching of the parent object is not required, `cached` can be set to `false`.
 """
 function puiseux_series_ring(R::Ring, prec::Int, s::VarName; cached::Bool=true)
-   @req !is_trivial(R) "The zero is currently not supported as a coefficient ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
    return Generic.PuiseuxSeriesRing(R, prec, Symbol(s); cached)
 end
 

src/RelSeries.jl

@@ -1474,7 +1474,7 @@ precision in future will return the same parent object and generator. If
 caching of the parent object is not required, `cached` can be set to `false`.
 """
 function power_series_ring(R::Ring, prec::Int, s::VarName; cached::Bool=true, model::Symbol=:capped_relative)
-   @req !is_trivial(R) "The zero is currently not supported as a coefficient ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
    return Generic.power_series_ring(R, prec, Symbol(s); cached, model)
 end
 

src/Residue.jl

@@ -450,7 +450,7 @@ to the constructor with the same base ring $R$ and element $a$. A modulus
 of zero is not supported and throws an exception.
 """
 function residue_ring(R::Ring, a::RingElement; cached::Bool = true)
-   @req !is_trivial(R) "The zero is currently not supported as a base ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as base ring."
    # Modulus of zero cannot be supported. E.g. A C library could not be expected to
    # do matrices over Z/0 using a Z/nZ type. The former is multiprecision, the latter not.
    iszero(a) && throw(DomainError(a, "Modulus must be nonzero"))
@@ -460,7 +460,7 @@ function residue_ring(R::Ring, a::RingElement; cached::Bool = true)
 end
 
 function residue_ring(R::PolyRing, a::RingElement; cached::Bool = true)
-   @req !is_trivial(R) "The zero is currently not supported as a base ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as base ring."
    iszero(a) && throw(DomainError(a, "Modulus must be nonzero"))
    !is_unit(leading_coefficient(a)) && throw(DomainError(a, "Non-invertible leading coefficient"))
    T = elem_type(R)

src/ResidueField.jl

@@ -490,7 +490,7 @@ residue ring parent object is cached and returned for any subsequent calls
 to the constructor with the same base ring $R$ and element $a$.
 """
 function residue_field(R::Ring, a::RingElement; cached::Bool = true)
-   @req !is_trivial(R) "The zero is currently not supported as a base ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as base ring."
    iszero(a) && throw(DivideError())
    T = elem_type(R)
    S = EuclideanRingResidueField{T}(R(a), cached)

src/generic/AbsMSeries.jl

@@ -710,7 +710,7 @@ end
 function power_series_ring(R::AbstractAlgebra.Ring, prec::Vector{Int},
                   s::Vector{Symbol}; cached::Bool=true, model=:capped_absolute)
 
-    @req !is_trivial(R) "The zero is currently not supported as a coefficient ring."
+    @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
     U = elem_type(R)
 
     S, _ = AbstractAlgebra.polynomial_ring(R, s)
@@ -727,7 +727,7 @@ function power_series_ring(R::AbstractAlgebra.Ring, prec::Int,
         s::Vector{Symbol}; weights::Union{Vector{Int}, Nothing}=nothing,
         cached::Bool=true, model=:capped_absolute)
 
-    @req !is_trivial(R) "The zero is currently not supported as a coefficient ring."
+    @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
     U = elem_type(R)
 
     S, _ = AbstractAlgebra.polynomial_ring(R, s)

src/generic/LaurentMPoly.jl

@@ -635,7 +635,7 @@ end
 ###############################################################################
 
 function laurent_polynomial_ring(R::AbstractAlgebra.Ring, s::Vector{Symbol}; cached::Bool = true)
-   @req !is_trivial(R) "The zero is currently not supported as a coefficient ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
    P, x = AbstractAlgebra.polynomial_ring(R, s, cached = cached)
    R = LaurentMPolyWrapRing(P, cached)
    R, map(p -> LaurentMPolyWrap(R, p), x)

src/generic/LaurentPoly.jl

@@ -508,7 +508,7 @@ end
 ###############################################################################
 
 function laurent_polynomial_ring(R::AbstractAlgebra.Ring, s::Symbol; cached::Bool = true)
-   @req !is_trivial(R) "The zero is currently not supported as a coefficient ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
    P, x = AbstractAlgebra.polynomial_ring(R, s, cached = cached)
    R = LaurentPolyWrapRing(P, cached)
    R, LaurentPolyWrap(R, x)

src/generic/RelSeries.jl

@@ -419,7 +419,7 @@ end
 ###############################################################################
 
 function power_series_ring(R::AbstractAlgebra.Ring, prec::Int, s::VarName; cached::Bool=true, model::Symbol=:capped_relative)
-   @req !is_trivial(R) "The zero is currently not supported as a coefficient ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
    T = elem_type(R)
 
    if model == :capped_relative

src/generic/UnivPoly.jl

@@ -1170,7 +1170,7 @@ x*y - z
 ```
 """
 function universal_polynomial_ring(R::Ring; cached::Bool=true, internal_ordering::Symbol=:lex)
-   @req !is_trivial(R) "The zero is currently not supported as a coefficient ring."
+   @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
    T = elem_type(R)
    U = mpoly_type(R)