From 0e79592d57ead15de089ea9833536ac249117626 Mon Sep 17 00:00:00 2001
From: Max Horn <max@quendi.de>
Date: Fri, 3 May 2024 10:33:39 +0200
Subject: [PATCH] docs: Returns -> Return (#3678)

... and similar
---
 .../src/Objects/Types.jl                      | 26 +++++++++----------
 experimental/GModule/GModule.jl               |  2 +-
 experimental/LieAlgebras/src/CartanMatrix.jl  | 10 +++----
 experimental/LieAlgebras/src/CoxeterGroup.jl  |  2 +-
 .../LieAlgebras/src/LinearLieAlgebra.jl       |  2 +-
 experimental/LieAlgebras/src/RootSystem.jl    | 26 +++++++++----------
 experimental/Schemes/AlgebraicCycles.jl       |  2 +-
 .../Schemes/MorphismFromRationalFunctions.jl  |  2 +-
 experimental/Schemes/duValSing.jl             |  2 +-
 .../src/StandardFiniteFields.jl               |  2 +-
 .../AffineSchemes/Objects/Constructors.jl     |  4 +--
 .../standard_constructions.jl                 | 12 ++++-----
 .../ToricVarieties/ToricSchemes/attributes.jl |  4 +--
 src/Modules/deRhamComplexes.jl                |  4 +--
 src/Rings/orderings.jl                        |  2 +-
 src/TropicalGeometry/groebner_fan.jl          |  2 +-
 16 files changed, 52 insertions(+), 52 deletions(-)

diff --git a/experimental/DoubleAndHyperComplexes/src/Objects/Types.jl b/experimental/DoubleAndHyperComplexes/src/Objects/Types.jl
index 9acd9ee37d1f..3a5486084c1e 100644
--- a/experimental/DoubleAndHyperComplexes/src/Objects/Types.jl
+++ b/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,7 +278,7 @@ 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)
@@ -286,7 +286,7 @@ 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)
@@ -294,7 +294,7 @@ 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)
@@ -302,7 +302,7 @@ 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)
@@ -310,7 +310,7 @@ 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`.
diff --git a/experimental/GModule/GModule.jl b/experimental/GModule/GModule.jl
index d7ca9db9ecef..01b5c6d4cb4f 100644
--- a/experimental/GModule/GModule.jl
+++ b/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)
diff --git a/experimental/LieAlgebras/src/CartanMatrix.jl b/experimental/LieAlgebras/src/CartanMatrix.jl
index fbce231ae372..80cfa71e9683 100644
--- a/experimental/LieAlgebras/src/CartanMatrix.jl
+++ b/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.
diff --git a/experimental/LieAlgebras/src/CoxeterGroup.jl b/experimental/LieAlgebras/src/CoxeterGroup.jl
index 80c7833e0f6b..6d0e908c15de 100644
--- a/experimental/LieAlgebras/src/CoxeterGroup.jl
+++ b/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.
 """
diff --git a/experimental/LieAlgebras/src/LinearLieAlgebra.jl b/experimental/LieAlgebras/src/LinearLieAlgebra.jl
index 5f8443a8e344..960f023c0278 100644
--- a/experimental/LieAlgebras/src/LinearLieAlgebra.jl
+++ b/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(
diff --git a/experimental/LieAlgebras/src/RootSystem.jl b/experimental/LieAlgebras/src/RootSystem.jl
index a28c5b4ad5e2..906572f16837 100644
--- a/experimental/LieAlgebras/src/RootSystem.jl
+++ b/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)
diff --git a/experimental/Schemes/AlgebraicCycles.jl b/experimental/Schemes/AlgebraicCycles.jl
index 3ea04087e933..2e699b2392f1 100644
--- a/experimental/Schemes/AlgebraicCycles.jl
+++ b/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)
diff --git a/experimental/Schemes/MorphismFromRationalFunctions.jl b/experimental/Schemes/MorphismFromRationalFunctions.jl
index cf17cc6bf1f5..a22f2139c2fb 100644
--- a/experimental/Schemes/MorphismFromRationalFunctions.jl
+++ b/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!
 """
diff --git a/experimental/Schemes/duValSing.jl b/experimental/Schemes/duValSing.jl
index 5838df813b9e..a359008e96ee 100644
--- a/experimental/Schemes/duValSing.jl
+++ b/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)`
 
diff --git a/experimental/StandardFiniteFields/src/StandardFiniteFields.jl b/experimental/StandardFiniteFields/src/StandardFiniteFields.jl
index a716a1a0f504..08cc6bbacc64 100644
--- a/experimental/StandardFiniteFields/src/StandardFiniteFields.jl
+++ b/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
diff --git a/src/AlgebraicGeometry/Schemes/AffineSchemes/Objects/Constructors.jl b/src/AlgebraicGeometry/Schemes/AffineSchemes/Objects/Constructors.jl
index 43f69a2fbe0e..8b28f4189485 100644
--- a/src/AlgebraicGeometry/Schemes/AffineSchemes/Objects/Constructors.jl
+++ b/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.
 
diff --git a/src/AlgebraicGeometry/ToricVarieties/NormalToricVarieties/standard_constructions.jl b/src/AlgebraicGeometry/ToricVarieties/NormalToricVarieties/standard_constructions.jl
index a1b8d190f7c1..3c137a1b49a6 100644
--- a/src/AlgebraicGeometry/ToricVarieties/NormalToricVarieties/standard_constructions.jl
+++ b/src/AlgebraicGeometry/ToricVarieties/NormalToricVarieties/standard_constructions.jl
@@ -1,7 +1,7 @@
 @doc raw"""
     affine_space(::Type{NormalToricVariety}, d::Int)
 
-Constructs the (toric) affine space of dimension `d`.
+Construct the (toric) affine space of dimension `d`.
 
 # Examples
 ```jldoctest
@@ -70,7 +70,7 @@ end
 @doc raw"""
     hirzebruch_surface(::Type{NormalToricVariety}, r::Int)
 
-Constructs the r-th Hirzebruch surface.
+Construct the `r`-th Hirzebruch surface.
 
 # Examples
 ```jldoctest
@@ -210,7 +210,7 @@ end
 @doc raw"""
     normal_toric_variety_from_star_triangulation(P::Polyhedron)
 
-Returns a toric variety that was obtained from a fine regular
+Return a toric variety that was obtained from a fine regular
 star triangulation of the lattice points of the polyhedron P.
 This is particularly useful when the lattice points of the
 polyhedron in question admit many triangulations.
@@ -253,7 +253,7 @@ end
 @doc raw"""
     normal_toric_varieties_from_star_triangulations(P::Polyhedron)
 
-Returns the list of toric varieties obtained from fine regular
+Return the list of toric varieties obtained from fine regular
 star triangulations of the polyhedron P. With this we can
 compute the two phases of the famous conifold transition.
 
@@ -308,7 +308,7 @@ end
 @doc raw"""
   normal_toric_variety_from_glsm(charges::ZZMatrix)
 
-This function returns one toric variety with the desired
+Return one toric variety with the desired
 GLSM charges. This can be particularly useful provided that
 there are many such toric varieties.
 
@@ -358,7 +358,7 @@ normal_toric_variety_from_glsm(charges::Vector{Vector{T}}) where {T <: IntegerUn
 @doc raw"""
     normal_toric_varieties_from_glsm(charges::ZZMatrix)
 
-This function returns all toric variety with the desired
+Return all toric variety with the desired
 GLSM charges. This computation may take a long time if
 there are many such toric varieties.
 
diff --git a/src/AlgebraicGeometry/ToricVarieties/ToricSchemes/attributes.jl b/src/AlgebraicGeometry/ToricVarieties/ToricSchemes/attributes.jl
index f1fb6feea73f..641315809f4c 100644
--- a/src/AlgebraicGeometry/ToricVarieties/ToricSchemes/attributes.jl
+++ b/src/AlgebraicGeometry/ToricVarieties/ToricSchemes/attributes.jl
@@ -5,7 +5,7 @@
 @doc raw"""
     forget_toric_structure(X::AffineNormalToricVariety)
 
-Returns a pair `(Y, iso)` where `Y` is a scheme without toric structure,
+Return a pair `(Y, iso)` where `Y` is a scheme without toric structure,
 together with an isomorphism `iso : Y → X`.
 
 # Examples
@@ -32,7 +32,7 @@ end
 @doc raw"""
     forget_toric_structure(X::NormalToricVariety)
 
-Returns a pair `(Y, iso)` where `Y` is a scheme without toric structure,
+Return a pair `(Y, iso)` where `Y` is a scheme without toric structure,
 together with an isomorphism `iso : Y → X`.
 
 # Examples
diff --git a/src/Modules/deRhamComplexes.jl b/src/Modules/deRhamComplexes.jl
index 146bb4609f9f..ebd8475b38e5 100644
--- a/src/Modules/deRhamComplexes.jl
+++ b/src/Modules/deRhamComplexes.jl
@@ -126,7 +126,7 @@ Internal method to check whether a module `M` was created as
 some ``p``-th exterior power of the Kaehler differentials 
 ``Ω¹(R/𝕜)`` of some ``𝕜``-algebra ``R``. 
 
-Returns `(true, R, p)` in the affirmative case and 
+Return `(true, R, p)` in the affirmative case and 
 `(false, base_ring(M), 0)` otherwise.
 """
 function is_kaehler_differential_module(M::ModuleFP)
@@ -138,7 +138,7 @@ end
 @doc raw"""
     de_rham_complex(R::Ring; cached::Bool=true)
 
-Constructs the relative de Rham complex of a ``𝕜``-algebra `R` 
+Construct the relative de Rham complex of a ``𝕜``-algebra `R`
 as a `ComplexOfMorphisms`.
 """
 function de_rham_complex(R::Ring; cached::Bool=true)
diff --git a/src/Rings/orderings.jl b/src/Rings/orderings.jl
index 9e12109a3485..1eaba27347d9 100644
--- a/src/Rings/orderings.jl
+++ b/src/Rings/orderings.jl
@@ -1357,7 +1357,7 @@ end
 @doc raw"""
     simplify(M::MonomialOrdering) -> MonomialOrdering
 
-Returns a matrix ordering with a unique weight matrix.
+Return a matrix ordering with a unique weight matrix.
 """
 function Hecke.simplify(M::MonomialOrdering)
   w = canonical_matrix(M)
diff --git a/src/TropicalGeometry/groebner_fan.jl b/src/TropicalGeometry/groebner_fan.jl
index 9f568b2b92aa..c3fee3760058 100644
--- a/src/TropicalGeometry/groebner_fan.jl
+++ b/src/TropicalGeometry/groebner_fan.jl
@@ -152,7 +152,7 @@ end
 @doc raw"""
     maximal_groebner_cone(G::Oscar.IdealGens{<:MPolyRingElem}; homogeneityWeight::Union{Nothing,Vector{ZZRingElem}}=nothing)
 
-Returns the maximal Groebner cone of a Groebner basis `G`, i.e., the closure of all weight vectors with respect to whose weighted ordering `G` is a Groebner basis (independent of tie-breaker).
+Return the maximal Groebner cone of a Groebner basis `G`, i.e., the closure of all weight vectors with respect to whose weighted ordering `G` is a Groebner basis (independent of tie-breaker).
 
 If `homogeneityWeight==nothing`, assumes that `G` is not quasi-homogeneous, i.e. not homogeneous with respect to any positive weight vector, and returns a cone inside the positive orthant.