Fixed grammatical errors at multiple points in English documentation

src/doc/en/developer/coding_in_other.rst

@@ -714,7 +714,7 @@ dumps the user into an Octave interactive shell:
 
             OUTPUT:
 
-            An list x (if it exists) which solves M*x = b
+            A list x (if it exists) which solves M*x = b
 
             EXAMPLES::
 

src/doc/en/developer/review.rst

@@ -134,7 +134,7 @@ the patches have been applied to a given release, the issue would
 remain in limbo.
 
 **No Patch Bombs**: Code that goes into Sage is peer-reviewed. If
-you show up with an 80,000 lines of code bundle that completely
+you show up with 80,000 lines of code bundle that completely
 rips out a subsystem and replaces it with something else, you can
 imagine that the review process will be a little tedious. These
 huge patch bombs are problematic for several reasons and we prefer

src/doc/en/reference/coercion/index.rst

@@ -323,7 +323,7 @@ Methods to implement
   the function is called on the potential codomain.  To indicate that
   there is no coercion from S to R (self), return ``False`` or
   ``None``. This is the default behavior.  If there is a coercion,
-  return ``True`` (in which case an morphism using
+  return ``True`` (in which case a morphism using
   ``R._element_constructor_`` will be created) or an actual
   :class:`Morphism` object with S as the domain and R as the codomain.
 

src/doc/en/thematic_tutorials/explicit_methods_in_number_theory/elliptic_curves.rst

@@ -5,7 +5,7 @@ Cremona's Databases
 -------------------
 
 Cremona's databases of elliptic curves are part of Sage. The curves up
-to conductor 10,000 come standard with Sage, and an there is an optional
+to conductor 10,000 come standard with Sage, and there is an optional
 download to gain access to his complete tables. From a shell, you
 should run ::
 

src/doc/en/thematic_tutorials/numerical_sage/f2py.rst

@@ -204,7 +204,7 @@ you only care about its value before the function is called not
 afterwards. So in the above n tells us how many fiboncci numbers to
 compute we need to specify this as an input, however we don't need
 to get n back as it doesn't contain anything new. Similarly A is
-intent(out) so we don't need A to have an specific value
+intent(out) so we don't need A to have a specific value
 beforehand, we just care about the contents afterwards. F2py
 generates a Python function so you only pass those declared
 intent(in) and supplies empty workspaces for the remaining

src/doc/en/thematic_tutorials/sandpile.rst

@@ -2865,7 +2865,7 @@ SandpileConfig
 
 **\***
 
-   If ``other`` is an configuration, the recurrent element equivalent
+   If ``other`` is a configuration, the recurrent element equivalent
    to the sum.  If ``other`` is an integer, the sum of configuration with
    itself ``other`` times.
 

src/sage/algebras/commutative_dga.py

@@ -3030,7 +3030,7 @@ def is_cohomologous_to(self, other):
 
         def cohomology_class(self):
             r"""
-            Return the cohomology class of an homogeneous cycle, as an element
+            Return the cohomology class of a homogeneous cycle, as an element
             of the corresponding cohomology group.
 
             EXAMPLES::

src/sage/algebras/hecke_algebras/cubic_hecke_algebra.py

@@ -1457,7 +1457,7 @@ def one_basis(self):
     def _an_element_(self):
         r"""
         Overwrite the original method from :mod:`~sage.combinat.free_module`
-        to obtain an more interesting element for ``TestSuite``.
+        to obtain a more interesting element for ``TestSuite``.
 
         EXAMPLES::
 
@@ -2230,7 +2230,7 @@ def _braid_image_by_basis_extension(self, braid_tietze):
             sage: CHA5._basis_extension           # optional - database_cubic_hecke
             [[4], [-4], [4, 1]]
 
-        case where the braid already has an corresponding basis element::
+        case where the braid already has a corresponding basis element::
 
             sage: CHA5._braid_image_by_basis_extension((1,)) # optional - database_cubic_hecke
             c0

src/sage/algebras/quantum_groups/fock_space.py

@@ -166,7 +166,7 @@ class FockSpace(Parent, UniqueRepresentation):
 
     To go between the canonical basis and the natural basis, for level 1
     Fock space, we follow the LLT algorithm [LLT1996]_. Indeed, we first
-    construct an basis `\{ A(\nu) \}` that is an approximation to the
+    construct a basis `\{ A(\nu) \}` that is an approximation to the
     lower global crystal basis, in the sense that it is bar-invariant,
     and then use Gaussian elimination to construct the lower global
     crystal basis. For higher level Fock space, we follow [Fayers2010]_,

src/sage/calculus/interpolators.pyx

@@ -55,7 +55,7 @@ def polygon_spline(pts):
         ....:                 [lambda x: ps.derivative(real(x))], 0)
         sage: show(m.plot_colored() + m.plot_spiderweb())                               # needs sage.plot
 
-    Polygon approximation of an circle::
+    Polygon approximation of a circle::
 
         sage: pts = [e^(I*t / 25) for t in range(25)]
         sage: ps = polygon_spline(pts)

src/sage/categories/category_with_axiom.py

@@ -500,7 +500,7 @@ class from the base category class::
       (bilinearity). Of course this should be implemented at the level
       of :class:`~.magmatic_algebras.MagmaticAlgebras`, if not higher.
 
-    - :class:`Bialgebras`: defining an bialgebra as an algebra and
+    - :class:`Bialgebras`: defining a bialgebra as an algebra and
       coalgebra where the coproduct is a morphism for the product.
 
     - :class:`Bimodules`: defining a bimodule as a left and right
@@ -2667,7 +2667,7 @@ def Blue_extra_super_categories(self):
         This currently fails because ``Blahs`` is the category where
         the axiom ``Blue`` is defined, and the specifications
         currently impose that a category defining an axiom should also
-        implement it (here in an category with axiom
+        implement it (here in a category with axiom
         ``Blahs.Blue``). In practice, due to this violation of the
         specifications, the axiom is lost during the join calculation.
 

src/sage/categories/complex_reflection_groups.py

@@ -21,7 +21,7 @@ class ComplexReflectionGroups(Category_singleton):
     The category of complex reflection groups.
 
     Let `V` be a complex vector space. A *complex reflection* is an
-    element of `\operatorname{GL}(V)` fixing an hyperplane pointwise
+    element of `\operatorname{GL}(V)` fixing a hyperplane pointwise
     and acting by multiplication by a root of unity on a complementary
     line.
 

src/sage/categories/covariant_functorial_construction.py

@@ -96,7 +96,7 @@ class CovariantFunctorialConstruction(UniqueRepresentation, SageObject):
        specify information and generic operations for elements of this
        category.
 
-     - ``_functor_name`` - an string which specifies the name of the
+     - ``_functor_name`` - a string which specifies the name of the
        functor, and also (when relevant) of the method on parents and
        elements used for calling the construction.
 

src/sage/categories/discrete_valuation.py

@@ -263,7 +263,7 @@ def residue_field(self):
 
         def _matrix_hessenbergize(self, H):
             r"""
-            Replace `H` with an Hessenberg form of it.
+            Replace `H` with a Hessenberg form of it.
 
             EXAMPLES::
 

src/sage/categories/magmas.py

@@ -438,7 +438,7 @@ class CartesianProducts(CartesianProductsCategory):
             def extra_super_categories(self):
                 r"""
                 Implement the fact that a Cartesian product of commutative
-                additive magmas is still an commutative additive magmas.
+                additive magmas is still a commutative additive magmas.
 
                 EXAMPLES::
 

src/sage/categories/modules_with_basis.py

@@ -1081,7 +1081,7 @@ def sum_of_monomials(self):
 
             INPUT:
 
-            - ``indices`` -- an list (or iterable) of indices of basis
+            - ``indices`` -- a list (or iterable) of indices of basis
               elements
 
             EXAMPLES::

src/sage/categories/quotient_fields.py

@@ -632,7 +632,7 @@ def _derivative(self, var=None):
             Returns the derivative of this rational function with respect to the
             variable ``var``.
 
-            Over an ring with a working gcd implementation, the derivative of a
+            Over a ring with a working gcd implementation, the derivative of a
             fraction `f/g`, supposed to be given in lowest terms, is computed as
             `(f'(g/d) - f(g'/d))/(g(g'/d))`, where `d` is a greatest common
             divisor of `f` and `g`.

src/sage/coding/channel.py

@@ -454,12 +454,12 @@ class ErrorErasureChannel(Channel):
     - ``space`` -- the input and output space
 
     - ``number_errors`` -- the number of errors created in each transmitted
-      message. It can be either an integer of a tuple. If an tuple is passed as
+      message. It can be either an integer of a tuple. If a tuple is passed as
       an argument, the number of errors will be a random integer between the
       two bounds of this tuple.
 
     - ``number_erasures`` -- the number of erasures created in each transmitted
-      message. It can be either an integer of a tuple. If an tuple is passed as an
+      message. It can be either an integer of a tuple. If a tuple is passed as an
       argument, the number of erasures will be a random integer between the
       two bounds of this tuple.
 
@@ -564,7 +564,7 @@ def transmit_unsafe(self, message):
         Return ``message`` with as many errors as ``self._number_errors`` in it,
         and as many erasures as ``self._number_erasures`` in it.
 
-        If ``self._number_errors`` was passed as an tuple for the number of errors, it will
+        If ``self._number_errors`` was passed as a tuple for the number of errors, it will
         pick a random integer between the bounds of the tuple and use it as the number of errors.
         It does the same with ``self._number_erasures``.
 

src/sage/coding/decoder.py

@@ -31,7 +31,7 @@ class Decoder(SageObject):
     Every decoder class for linear codes (of any metric) should inherit from
     this abstract class.
 
-    To implement an decoder, you need to:
+    To implement a decoder, you need to:
 
     - inherit from :class:`Decoder`
 

src/sage/coding/reed_muller_code.py

@@ -906,7 +906,7 @@ def unencode_nocheck(self, c):
 
         OUTPUT:
 
-        - An polynomial of degree less than ``self.code().order()``.
+        - A polynomial of degree less than ``self.code().order()``.
 
         EXAMPLES::
 

src/sage/coding/subfield_subcode.py

@@ -38,7 +38,7 @@ class SubfieldSubcode(AbstractLinearCode):
 
     - ``subfield`` -- the base field of ``self``.
 
-    - ``embedding`` -- (default: ``None``) an homomorphism from ``subfield`` to
+    - ``embedding`` -- (default: ``None``) a homomorphism from ``subfield`` to
       ``original_code``'s base field. If ``None`` is provided, it will default
       to the first homomorphism of the list of homomorphisms Sage can build.
 

src/sage/combinat/abstract_tree.py

@@ -1359,10 +1359,10 @@ def canonical_labelling(self, shift=1):
 
     def to_hexacode(self):
         r"""
-        Transform a tree into an hexadecimal string.
+        Transform a tree into a hexadecimal string.
 
         The definition of the hexacode is recursive. The first letter is
-        the valence of the root as an hexadecimal (up to 15), followed by
+        the valence of the root as a hexadecimal (up to 15), followed by
         the concatenation of the hexacodes of the subtrees.
 
         This method only works for trees where every vertex has
@@ -2461,11 +2461,11 @@ def map_labels(self, f):
 
 def from_hexacode(ch, parent=None, label='@'):
     r"""
-    Transform an hexadecimal string into a tree.
+    Transform a hexadecimal string into a tree.
 
     INPUT:
 
-    - ``ch`` -- an hexadecimal string
+    - ``ch`` -- a hexadecimal string
 
     - ``parent`` -- kind of trees to be produced. If ``None``, this will
       be ``LabelledOrderedTrees``
@@ -2511,11 +2511,11 @@ def from_hexacode(ch, parent=None, label='@'):
 
 def _from_hexacode_aux(ch, parent, label='@'):
     r"""
-    Transform an hexadecimal string into a tree and a remainder string.
+    Transform a hexadecimal string into a tree and a remainder string.
 
     INPUT:
 
-    - ``ch`` -- an hexadecimal string
+    - ``ch`` -- a hexadecimal string
 
     - ``parent`` -- kind of trees to be produced.
 

src/sage/combinat/crystals/fully_commutative_stable_grothendieck.py

@@ -768,7 +768,7 @@ def _check_decreasing_hecke_factorization(t):
     """
     if not isinstance(t, DecreasingHeckeFactorization):
         if not isinstance(t, (tuple, list)):
-            raise ValueError("t should be an list or tuple")
+            raise ValueError("t should be a list or tuple")
         for factor in t:
             if not isinstance(factor, (tuple, list)):
                 raise ValueError("each factor in t should be a list or tuple")

src/sage/combinat/finite_state_machine.py

@@ -104,7 +104,7 @@
     :meth:`~FiniteStateMachine.has_state` | Checks for a state
     :meth:`~FiniteStateMachine.has_initial_state` | Checks for an initial state
     :meth:`~FiniteStateMachine.has_initial_states` | Checks for initial states
-    :meth:`~FiniteStateMachine.has_final_state` | Checks for an final state
+    :meth:`~FiniteStateMachine.has_final_state` | Checks for a final state
     :meth:`~FiniteStateMachine.has_final_states` | Checks for final states
     :meth:`~FiniteStateMachine.has_transition` | Checks for a transition
     :meth:`~FiniteStateMachine.is_deterministic` | Checks for a deterministic machine
@@ -3663,7 +3663,7 @@ def __call__(self, *args, **kwargs):
             sage: H.states()
             [('A', 1), ('B', 1), ('B', 2)]
 
-        An automaton or transducer can also act on an input (an list
+        An automaton or transducer can also act on an input (a list
         or other iterable of letters)::
 
             sage: binary_inverter = Transducer({'A': [('A', 0, 1), ('A', 1, 0)]},
@@ -12119,7 +12119,7 @@ class Transducer(FiniteStateMachine):
     This creates a transducer, which is a finite state machine, whose
     transitions have input and output labels.
 
-    An transducer has additional features like creating a simplified
+    A transducer has additional features like creating a simplified
     transducer.
 
     See class :class:`FiniteStateMachine` for more information.

src/sage/combinat/integer_lists/invlex.pyx

@@ -99,7 +99,7 @@ class IntegerListsLex(IntegerLists, metaclass=ClasscallMetaclass):
       value is `\infty`.
 
     - ``min_slope`` -- an integer or `-\infty` (default: `-\infty`):
-      an lower bound on the slope between consecutive parts:
+      a lower bound on the slope between consecutive parts:
       ``min_slope <= l[i+1]-l[i]`` for ``0 <= i < len(l)-1``
 
     - ``max_slope`` -- an integer or `+\infty` (defaults: `+\infty`)
@@ -796,7 +796,7 @@ class IntegerListsLex(IntegerLists, metaclass=ClasscallMetaclass):
 
 cdef class IntegerListsBackend_invlex(IntegerListsBackend):
     """
-    Cython back-end of an set of lists of integers with specified
+    Cython back-end of a set of lists of integers with specified
     constraints enumerated in inverse lexicographic order.
     """
     def __init__(self, *args, check=True, **kwds):

src/sage/combinat/k_tableau.py

@@ -4225,7 +4225,7 @@ def add_marking( cls, unmarkedT, marking, k, weight ):
         r"""
         Add markings to a partially marked strong tableau.
 
-        Given an partially marked standard tableau and a list of cells where the marks
+        Given a partially marked standard tableau and a list of cells where the marks
         should be placed along with a ``weight``, return the semi-standard marked strong
         tableau.  The marking should complete the marking so that the result is a
         strong standard marked tableau.