docs: Returns -> Return (oscar-system#3678)

... and similar

experimental/DoubleAndHyperComplexes/src/Objects/Types.jl

@@ -181,7 +181,7 @@ end
 @doc raw"""
     can_compute_index(D::AbsDoubleComplexOfMorphisms, i::Int, j::Int)
 
-Returns `true` if the entry `D[i, j]` is known or `D` knows how to compute it.
+Return `true` if the entry `D[i, j]` is known or `D` knows how to compute it.
 """
 function can_compute_index(D::AbsDoubleComplexOfMorphisms, i::Int, j::Int)
   can_compute_index(D, (i, j))
@@ -211,7 +211,7 @@ has_horizontal_map(dc::AbsDoubleComplexOfMorphisms, t::Tuple) = has_map(dc, 1, t
 @doc raw"""
     can_compute_horizontal_map(dc::AbsDoubleComplexOfMorphisms, i::Int, j::Int)
 
-Returns `true` if `dc` can compute the horizontal morphism `dc[i, j] → dc[i ± 1, j]`, 
+Return `true` if `dc` can compute the horizontal morphism `dc[i, j] → dc[i ± 1, j]`,
 the sign depending on the `horizontal_direction` of `dc`, and `false` otherwise.
 """
 can_compute_horizontal_map(C::AbsDoubleComplexOfMorphisms, i::Int, j::Int) = can_compute_map(C, 1, (i, j))
@@ -220,7 +220,7 @@ can_compute_horizontal_map(C::AbsDoubleComplexOfMorphisms, t::Tuple) = can_compu
 @doc raw"""
     vertical_map(dc::AbsDoubleComplexOfMorphisms, i::Int, j::Int)
 
-Return the morphism ``dc[i, j] → dc[i, j ± 1]`` (the sign depending on the `vertical_direction` of `dc`). 
+Return the morphism ``dc[i, j] → dc[i, j ± 1]`` (the sign depending on the `vertical_direction` of `dc`).
 """
 vertical_map(C::AbsDoubleComplexOfMorphisms, i::Int, j::Int) = map(C, 2, (i, j))
 vertical_map(C::AbsDoubleComplexOfMorphisms, t::Tuple) = map(C, 2, t)
@@ -240,7 +240,7 @@ has_vertical_map(C::AbsDoubleComplexOfMorphisms, t::Tuple) = has_map(C, 2, t)
 @doc raw"""
     can_compute_vertical_map(dc::AbsDoubleComplexOfMorphisms, i::Int, j::Int)
 
-Returns `true` if `dc` can compute the vertical morphism `dc[i, j] → dc[i, j ± 1]`, 
+Return `true` if `dc` can compute the vertical morphism `dc[i, j] → dc[i, j ± 1]`, 
 the sign depending on the `vertical_direction` of `dc`, and `false` otherwise.
 """
 can_compute_vertical_map(C::AbsDoubleComplexOfMorphisms, i::Int, j::Int) = can_compute_map(C, 2, (i, j))
@@ -278,39 +278,39 @@ is_bounded(dc::AbsDoubleComplexOfMorphisms) = is_horizontally_bounded(dc) && is_
 @doc raw"""
     has_right_bound(D::AbsDoubleComplexOfMorphisms)
 
-Returns `true` if a universal upper bound ``i ≤ B`` for non-zero `D[i, j]` 
+Return `true` if a universal upper bound ``i ≤ B`` for non-zero `D[i, j]`
 is known; `false` otherwise.
 """
 has_right_bound(C::AbsDoubleComplexOfMorphisms) = has_upper_bound(C, 1)
 
 @doc raw"""
     has_left_bound(D::AbsDoubleComplexOfMorphisms)
 
-Returns `true` if a universal upper bound ``B ≤ i`` for non-zero `D[i, j]` 
+Return `true` if a universal upper bound ``B ≤ i`` for non-zero `D[i, j]`
 is known; `false` otherwise.
 """
 has_left_bound(C::AbsDoubleComplexOfMorphisms) = has_lower_bound(C, 1)
 
 @doc raw"""
     has_upper_bound(D::AbsDoubleComplexOfMorphisms)
 
-Returns `true` if a universal upper bound ``j ≤ B`` for non-zero `D[i, j]` 
+Return `true` if a universal upper bound ``j ≤ B`` for non-zero `D[i, j]`
 is known; `false` otherwise.
 """
 has_upper_bound(C::AbsDoubleComplexOfMorphisms) = has_upper_bound(C, 2)
 
 @doc raw"""
     has_lower_bound(D::AbsDoubleComplexOfMorphisms)
 
-Returns `true` if a universal upper bound ``B ≤ j`` for non-zero `D[i, j]` 
+Return `true` if a universal upper bound ``B ≤ j`` for non-zero `D[i, j]`
 is known; `false` otherwise.
 """
 has_lower_bound(C::AbsDoubleComplexOfMorphisms) = has_lower_bound(C, 2)
 
 @doc raw"""
     right_bound(D::AbsDoubleComplexOfMorphisms)
 
-Returns a bound ``B`` such that `D[i, j]` can be assumed to be zero 
+Return a bound ``B`` such that `D[i, j]` can be assumed to be zero
 for ``i > B``. Whether or not requests for `D[i, j]` beyond that bound are 
 legitimate can be checked using `can_compute_index`.
 """
@@ -319,7 +319,7 @@ right_bound(C::AbsDoubleComplexOfMorphisms) = upper_bound(C, 1)
 @doc raw"""
     left_bound(D::AbsDoubleComplexOfMorphisms)
 
-Returns a bound ``B`` such that `D[i, j]` can be assumed to be zero 
+Return a bound ``B`` such that `D[i, j]` can be assumed to be zero 
 for ``i < B``. Whether or not requests for `D[i, j]` beyond that bound are 
 legitimate can be checked using `can_compute_index`.
 """
@@ -328,7 +328,7 @@ left_bound(C::AbsDoubleComplexOfMorphisms) = lower_bound(C, 1)
 @doc raw"""
     upper_bound(D::AbsDoubleComplexOfMorphisms)
 
-Returns a bound ``B`` such that `D[i, j]` can be assumed to be zero 
+Return a bound ``B`` such that `D[i, j]` can be assumed to be zero 
 for ``j > B``. Whether or not requests for `D[i, j]` beyond that bound are 
 legitimate can be checked using `can_compute_index`.
 """
@@ -337,7 +337,7 @@ upper_bound(C::AbsDoubleComplexOfMorphisms) = upper_bound(C, 2)
 @doc raw"""
     lower_bound(D::AbsDoubleComplexOfMorphisms)
 
-Returns a bound ``B`` such that `D[i, j]` can be assumed to be zero 
+Return a bound ``B`` such that `D[i, j]` can be assumed to be zero
 for ``j < B``. Whether or not requests for `D[i, j]` beyond that bound are 
 legitimate can be checked using `can_compute_index`.
 """
@@ -346,7 +346,7 @@ lower_bound(C::AbsDoubleComplexOfMorphisms) = lower_bound(C, 2)
 @doc raw"""
     is_complete(dc::AbsDoubleComplexOfMorphisms)
 
-Returns `true` if for all indices `(i, j)` with `has_index(dc, i, j) = true` and 
+Return `true` if for all indices `(i, j)` with `has_index(dc, i, j) = true` and
 `dc[i, j]` non-zero, the vertex `(i, j)` is lying on an "island" of non-zero entries 
 in the grid of the double complex, which is bounded by either zero entries or 
 entries for indices `(i', j')` where `can_compute_index(dc, i', j') = false`.

experimental/GModule/GModule.jl

@@ -543,7 +543,7 @@ function _character(C::GModule{<:Any, <:AbstractAlgebra.FPModule{<:AbstractAlgeb
 end
 
 """
-Returns Z[G] and a function f that, when applied to a G-module M will return
+Return Z[G] and a function f that, when applied to a G-module M will return
 a map representing the action of Z[G] on M:
 
 f(C) yields the extension of g -> action(C, g)

experimental/LieAlgebras/src/CartanMatrix.jl

@@ -8,7 +8,7 @@
 @doc raw"""
     cartan_matrix(fam::Symbol, rk::Int) -> ZZMatrix
 
-Returns the Cartan matrix of finite type, where `fam` is the family ($A$, $B$, $C$, $D$, $E$, $F$ $G$)
+Return the Cartan matrix of finite type, where `fam` is the family ($A$, $B$, $C$, $D$, $E$, $F$ $G$)
 and `rk` is the rank of the associated the root system; for $B$ and $C$ the rank has to be at least 2, for $D$ at least 4.
 The convention is $(a_{ij}) = (\langle \alpha_i^\vee, \alpha_j \rangle)$ for simple roots $\alpha_i$.
 
@@ -104,7 +104,7 @@ end
 @doc raw"""
     cartan_matrix(type::Tuple{Symbol,Int}...) -> ZZMatrix
 
-Returns a block diagonal matrix of indecomposable Cartan matrices as defined by type.
+Return a block diagonal matrix of indecomposable Cartan matrices as defined by type.
 For allowed values see `cartan_matrix(fam::Symbol, rk::Int)`.
 
 # Example
@@ -251,7 +251,7 @@ end
 @doc raw"""
     cartan_bilinear_form(gcm::ZZMatrix; check::Bool=true) -> ZZMatrix
 
-Returns the matrix of the symmetric bilinear form associated to the Cartan matrix from `cartan_symmetrizer`.
+Return the matrix of the symmetric bilinear form associated to the Cartan matrix from `cartan_symmetrizer`.
 The keyword argument `check` can be set to `false` to skip verification whether `gcm` is indeed a generalized Cartan matrix.
 
 # Example
@@ -273,7 +273,7 @@ end
 @doc raw"""
     cartan_type(gcm::ZZMatrix; check::Bool=true) -> Vector{Tuple{Symbol, Int}}
 
-Returns the Cartan type of a Cartan matrix `gcm` (currently only Cartan matrices of finite type are supported).
+Return the Cartan type of a Cartan matrix `gcm` (currently only Cartan matrices of finite type are supported).
 This function is left inverse to `cartan_matrix`, i.e. in the case of isomorphic types (e.g. $B_2$ and $C_2$)
 the ordering of the roots does matter (see the example below).
 The keyword argument `check` can be set to `false` to skip verification whether `gcm` is indeed a Cartan matrix of finite type.
@@ -300,7 +300,7 @@ end
 @doc raw"""
     cartan_type_with_ordering(gcm::ZZMatrix; check::Bool=true) -> Vector{Tuple{Symbol, Int}}, Vector{Int}
 
-Returns the Cartan type of a Cartan matrix `gcm` together with a vector indicating a canonical ordering
+Return the Cartan type of a Cartan matrix `gcm` together with a vector indicating a canonical ordering
 of the roots in the Dynkin diagram (currently only Cartan matrices of finite type are supported).
 The keyword argument `check` can be set to `false` to skip verification whether `gcm` is indeed a
 Cartan matrix of finite type.

experimental/LieAlgebras/src/CoxeterGroup.jl

@@ -5,7 +5,7 @@ abstract type CoxeterGroup end
 @doc raw"""
     coxeter_from_cartan_matrix(mat::ZZMatrix; check::Bool=true) -> Bool
 
-Returns the Coxeter matrix $m$ associated to the Cartan matrix `gcm`. If there is no relation between $i$ and $j$,
+Return the Coxeter matrix $m$ associated to the Cartan matrix `gcm`. If there is no relation between $i$ and $j$,
 then this will be expressed by $m_{ij} = 0$ (instead of the usual convention $m_{ij} = \infty$).
 The keyword argument `check` can be set to `false` to skip verification whether `gcm` is indeed a generalized Cartan matrix.
 """

experimental/LieAlgebras/src/LinearLieAlgebra.jl

@@ -144,7 +144,7 @@ end
 @doc raw"""
     coerce_to_lie_algebra_elem(L::LinearLieAlgebra{C}, x::MatElem{C}) -> LinearLieAlgebraElem{C}
 
-Returns the element of `L` whose matrix representation corresponds to `x`.
+Return the element of `L` whose matrix representation corresponds to `x`.
 If no such element exists, an error is thrown.
 """
 function coerce_to_lie_algebra_elem(

experimental/LieAlgebras/src/RootSystem.jl

@@ -32,7 +32,7 @@ end
     root_system(cartan_matrix::ZZMatrix; check::Bool=true, detect_type::Bool=true) -> RootSystem
     root_system(cartan_matrix::Matrix{Int}; check::Bool=true, detect_type::Bool=true) -> RootSystem
 
-Constructs the root system defined by the Cartan matrix.
+Construct the root system defined by the Cartan matrix.
 If `check` is `true`, checks that `cartan_matrix` is a generalized Cartan matrix.
 Passing `detect_type=false` will skip the detection of the root system type.
 """
@@ -52,7 +52,7 @@ end
 @doc raw"""
     root_system(fam::Symbol, rk::Int) -> RootSystem
 
-Constructs the root system of the given type. See `cartan_matrix(fam::Symbol, rk::Int)` for allowed combinations.
+Construct the root system of the given type. See `cartan_matrix(fam::Symbol, rk::Int)` for allowed combinations.
 """
 function root_system(fam::Symbol, rk::Int)
   cartan = cartan_matrix(fam, rk)
@@ -95,7 +95,7 @@ end
 @doc raw"""
     cartan_matrix(R::RootSystem) -> ZZMatrix
 
-Returns the Cartan matrix defining `R`.
+Return the Cartan matrix defining `R`.
 """
 function cartan_matrix(R::RootSystem)
   return R.cartan_matrix
@@ -137,7 +137,7 @@ end
 @doc raw"""
     fundamental_weights(R::RootSystem) -> Vector{WeightLatticeElem}
 
-Returns the fundamental weights corresponding to the `simple_roots` of `R`.
+Return the fundamental weights corresponding to the `simple_roots` of `R`.
 """
 function fundamental_weights(R::RootSystem)
   return [fundamental_weight(R, i) for i in 1:rank(R)]
@@ -279,7 +279,7 @@ end
 @doc raw"""
     rank(R::RootSystem) -> Int
 
-Returns the rank of `R`, i.e. the number of simple roots.
+Return the rank of `R`, i.e. the number of simple roots.
 """
 function rank(R::RootSystem)
   return nrows(cartan_matrix(R))
@@ -393,7 +393,7 @@ end
 @doc raw"""
     weyl_group(R::RootSystem) -> WeylGroup
 
-Returns the Weyl group of `R`.
+Return the Weyl group of `R`.
 """
 function weyl_group(R::RootSystem)
   return R.weyl_group::WeylGroup
@@ -402,7 +402,7 @@ end
 @doc raw"""
     weyl_vector(R::RootSystem) -> WeightLatticeElem
 
-Returns the Weyl vector $\rho$ of `R`, which is the sum of all fundamental weights,
+Return the Weyl vector $\rho$ of `R`, which is the sum of all fundamental weights,
 or half the sum of all positive roots.
 """
 function weyl_vector(R::RootSystem)
@@ -458,7 +458,7 @@ end
 @doc raw"""
     getindex(r::RootSpaceElem, i::Int) -> QQRingElem
 
-Returns the coefficient of the `i`-th simple root in `r`.
+Return the coefficient of the `i`-th simple root in `r`.
 """
 function Base.getindex(r::RootSpaceElem, i::Int)
   return coeff(r, i)
@@ -681,7 +681,7 @@ end
 @doc raw"""
     WeightLatticeElem(R::RootSystem, v::Vector{IntegerUnion}) -> WeightLatticeElem
 
-Returns the weight defined by the coefficients `v` of the fundamental weights with respect to the root system `R`.
+Return the weight defined by the coefficients `v` of the fundamental weights with respect to the root system `R`.
 """
 function WeightLatticeElem(R::RootSystem, v::Vector{<:IntegerUnion})
   return WeightLatticeElem(R, matrix(ZZ, rank(R), 1, v))
@@ -724,7 +724,7 @@ end
 @doc raw"""
   getindex(w::WeightLatticeElem, i::Int) -> ZZRingElem
 
-Returns the coefficient of the `i`-th fundamental weight in `w`.
+Return the coefficient of the `i`-th fundamental weight in `w`.
 """
 function Base.getindex(w::WeightLatticeElem, i::Int)
   return coeff(w, i)
@@ -740,7 +740,7 @@ end
 @doc raw"""
     iszero(w::WeightLatticeElem) -> Bool
 
-Returns whether `w` is zero.
+Return whether `w` is zero.
 """
 function Base.iszero(w::WeightLatticeElem)
   return iszero(w.vec)
@@ -757,7 +757,7 @@ end
 @doc raw"""
     conjugate_dominant_weight(w::WeightLatticeElem) -> WeightLatticeElem
 
-Returns the unique dominant weight conjugate to `w`.
+Return the unique dominant weight conjugate to `w`.
 """
 function conjugate_dominant_weight(w::WeightLatticeElem)
   # conj will be the dominant weight conjugate to w
@@ -822,7 +822,7 @@ end
 @doc raw"""
     reflect(w::WeightLatticeElem, s::Int) -> WeightLatticeElem
     
-Returns the `w` reflected at the `s`-th simple root.
+Return the `w` reflected at the `s`-th simple root.
 """
 function reflect(w::WeightLatticeElem, s::Int)
   return reflect!(deepcopy(w), s)

experimental/Schemes/AlgebraicCycles.jl

@@ -446,7 +446,7 @@ end
 @doc raw"""
     irreducible_decomposition(D::AbsAlgebraicCycle)
 
-Returns a divisor ``E`` equal to ``D`` but as a formal sum ``E = ∑ₖ aₖ ⋅ Iₖ``
+Return a divisor ``E`` equal to ``D`` but as a formal sum ``E = ∑ₖ aₖ ⋅ Iₖ``
 where the `components` ``Iₖ`` of ``E`` are all sheaves of prime ideals.
 """
 function irreducible_decomposition(D::AbsAlgebraicCycle)

experimental/Schemes/MorphismFromRationalFunctions.jl

@@ -223,7 +223,7 @@ end
 @doc raw"""
     realize_on_open_subset(Phi::MorphismFromRationalFunctions, U::AbsAffineScheme, V::AbsAffineScheme)
 
-Returns a morphism `f : U' → V` from some `PrincipalOpenSubset` of `U` to `V` such 
+Return a morphism `f : U' → V` from some `PrincipalOpenSubset` of `U` to `V` such
 that the restriction of `Phi` to `U'` is `f`. Note that `U'` need not be maximal 
 with this property!
 """

experimental/Schemes/duValSing.jl

@@ -219,7 +219,7 @@ end
 @doc raw"""
     _check_du_val_at_point(IX:Ideal,Ipt::Ideal)
 
-Returns a tuple `T` with the following data:
+Return a tuple `T` with the following data:
 - `T[1]::Bool` returns whether `V(IX)` has at most a du Val singularity at `V(Ipt)`
 - `T[2]::Tuple` Type of du Val singularity at `V(Ipt)`
 

experimental/StandardFiniteFields/src/StandardFiniteFields.jl

@@ -451,7 +451,7 @@ end
 @doc raw"""
     standard_finite_field(p::Union{ZZRingElem, Integer}, n::Union{ZZRingElem, Integer}) -> FinField
 
-Returns a finite field of order $p^n$.
+Return a finite field of order $p^n$.
 
 # Examples
 ```jldoctest

src/AlgebraicGeometry/Schemes/AffineSchemes/Objects/Constructors.jl

@@ -32,7 +32,7 @@ affine_scheme(kk::Ring, R::Ring) = AffineScheme(kk, R)
 @doc raw"""
     spec(R::MPolyRing, I::MPolyIdeal)
 
-Constructs the affine scheme of the ideal ``I`` in the ring ``R``.
+Construct the affine scheme of the ideal ``I`` in the ring ``R``.
 This is the spectrum of the quotient ring ``R/I``.
 
 # Examples
@@ -184,7 +184,7 @@ end
 @doc raw"""
     affine_space(kk::BRT, var_symbols::Vector{Symbol}) where {BRT<:Ring}
 
-Creates the ``n``-dimensional affine space over a ring ``kk``,
+Create the ``n``-dimensional affine space over a ring ``kk``,
 but allows more flexibility in the choice of variable names.
 The following example demonstrates this.