Docstring edits

Work in `numerical`.

src/sage/algebras/fusion_rings/fusion_double.py

@@ -691,7 +691,8 @@ def product_on_basis(self, a, b):
 
         INPUT:
 
-        - ``a`, ``b`` -- keys for the dictionary ``self._names`` representing simple objects
+        - ``a``, ``b`` -- keys for the dictionary ``self._names`` representing
+          simple objects
 
         EXAMPLES::
 

src/sage/algebras/fusion_rings/fusion_ring.py

@@ -773,7 +773,7 @@ def N_ijk(self, elt_i, elt_j, elt_k):
 
         This is the same as `N_{ij}^{k\ast}`, where `N_{ij}^k` are
         the structure coefficients of the ring (see :meth:`Nk_ij`),
-        and `k\ast`` denotes the dual element. The coefficient `N_{ijk}`
+        and `k\ast` denotes the dual element. The coefficient `N_{ijk}`
         is unchanged under permutations of the three basis vectors.
 
         EXAMPLES::

src/sage/algebras/fusion_rings/shm_managers.pyx

@@ -177,7 +177,7 @@ cdef class KSHandler:
 
     cpdef update(self, list eqns):
         r"""
-        Update ```self``'s ``shared_memory``-backed dictionary of known
+        Update ``self``'s ``shared_memory``-backed dictionary of known
         squares. Keys are variable indices and corresponding values
         are the squares.
 

src/sage/algebras/iwahori_hecke_algebra.py

@@ -717,7 +717,7 @@ def __getitem__(self, i):
 
                 .. WARNING::
 
-                    If `i`` is not a reduced expression then the basis element
+                    If ``i`` is not a reduced expression then the basis element
                     indexed by the corresponding element of the algebra is
                     returned rather than the corresponding product of the
                     generators::

src/sage/categories/coxeter_groups.py

@@ -2366,10 +2366,10 @@ def binary_factorizations(self, predicate=ConstantFunction(True)):
             Iterating through this set is Constant Amortized Time
             (counting arithmetic operations in the Coxeter group as
             constant time) complexity, and memory linear in the length
-            of `self`.
+            of ``self``.
 
             One can pass as optional argument a predicate p such that
-            `p(u)` implies `p(u')` for any `u` left factor of `self`
+            `p(u)` implies `p(u')` for any `u` left factor of ``self``
             and `u'` left factor of `u`. Then this returns only the
             factorizations `self = uv` such `p(u)` holds.
 

src/sage/categories/drinfeld_modules.py

@@ -205,7 +205,7 @@ class DrinfeldModules(Category_over_base_ring):
 
     def __init__(self, base_field, name='t'):
         r"""
-        Initialize `self`.
+        Initialize ``self``.
 
         INPUT:
 

src/sage/categories/enumerated_sets.py

@@ -751,7 +751,7 @@ def _rank_from_iterator(self, x):
             ``self.rank(x)`` returns the rank of `x`, that is its
             position in the enumeration of ``self``. This is an
             integer between ``0`` and ``n-1`` where ``n`` is the
-            cardinality of ``self``, or None if `x` is not in `self`.
+            cardinality of ``self``, or None if `x` is not in ``self``.
 
             This is the default (brute force) implementation from the
             category ``EnumeratedSets()`` which can be used when the

src/sage/categories/facade_sets.py

@@ -53,7 +53,7 @@ def _element_constructor_(self, element):
             - ``element`` -- any object
 
             This default implementation returns ``element`` if
-            ``self`` is a facade for ``parent(element)`. Otherwise it
+            ``self`` is a facade for ``parent(element)``. Otherwise it
             attempts in turn to coerce ``element`` into each parent
             ``self`` is a facade for.
 

src/sage/categories/magmas.py

@@ -380,7 +380,7 @@ def is_field(self, proof=True):
                 Return ``True`` if ``self`` is a field.
 
                 For a magma algebra `RS` this is always false unless
-                `S` is trivial and the base ring `R`` is a field.
+                `S` is trivial and the base ring `R` is a field.
 
                 EXAMPLES::
 

src/sage/categories/poor_man_map.py

@@ -183,7 +183,7 @@ def __mul__(self, other):
         - ``self`` -- a map `f`
         - ``other`` -- a map `g`
 
-        Returns the composition map `f\circ g` of `f`` and `g`
+        Returns the composition map `f\circ g` of `f` and `g`
 
         EXAMPLES::
 

src/sage/categories/primer.py

@@ -1368,7 +1368,7 @@ class naming and introspection. Sage currently works around the
     How far should this be pushed? :class:`Fields` should definitely
     stay, but should :class:`FiniteGroups` or :class:`DivisionRings`
     be removed from the global namespace? Do we want to further
-    completely deprecate the notation ``FiniteGroups()` in favor of
+    completely deprecate the notation ``FiniteGroups()`` in favor of
     ``Groups().Finite()``?
 
 .. _category-primer-axioms-explosion:

src/sage/categories/sets_cat.py

@@ -2686,7 +2686,7 @@ def construction(self):
 
             def _repr_(self):
                 r"""
-                Return the string representation of `self`.
+                Return the string representation of ``self``.
 
                 EXAMPLES::
 

src/sage/coding/information_set_decoder.py

@@ -521,7 +521,7 @@ def calibrate(self):
         OUTPUT: does not output anything but sets private fields used by
         :meth:`sage.coding.information_set_decoder.InformationSetAlgorithm.parameters()`
         and
-        :meth:`sage.coding.information_set_decoder.InformationSetAlgorithm.time_estimate()``.
+        :meth:`sage.coding.information_set_decoder.InformationSetAlgorithm.time_estimate()`.
 
         EXAMPLES::
 

src/sage/combinat/binary_recurrence_sequences.py

@@ -626,7 +626,7 @@ def pthpowers(self, p, Bound):
         #power if and only if it is a ``p`` th power modulo every prime `\\ell`.  This condition
         #gives nontrivial information if ``p`` divides the order of the multiplicative group of
         #`\\Bold(F)_{\\ell}`, i.e. if `\\ell` is ` 1 \mod{p}`, as then only `1/p` terms are ``p`` th
-        #powers modulo `\\ell``.
+        #powers modulo `\\ell`.
 
         #Thus, given such an `\\ell`, we get a set of necessary congruences for the index modulo the
         #the period of the sequence mod `\\ell`.  Then we intersect these congruences for many primes

src/sage/combinat/cluster_algebra_quiver/cluster_seed.py

@@ -3623,7 +3623,7 @@ def mutation_class(self, depth=infinity, show_depth=False, return_paths=False,
 
         INPUT:
 
-        - ``depth`` -- (default: ``infinity`) integer, only seeds with
+        - ``depth`` -- (default: ``infinity``) integer, only seeds with
           distance at most depth from ``self`` are returned
         - ``show_depth`` -- boolean (default: ``False``); if ``True``, the
           actual depth of the mutation is shown
@@ -5089,7 +5089,7 @@ def _multi_concatenate(l1, l2):
 
     INPUT:
 
-    - ``l1``` -- a 2-dimensional array
+    - ``l1`` -- a 2-dimensional array
     - ``l2`` -- a single array
 
     OUTPUT: a 2-dimensional array

src/sage/combinat/cluster_algebra_quiver/quiver.py

@@ -1771,7 +1771,7 @@ def mutation_class(self, depth=infinity, show_depth=False, return_paths=False,
 
         INPUT:
 
-        - ``depth`` -- (default: ``infinity`) integer, only seeds with
+        - ``depth`` -- (default: ``infinity``) integer, only seeds with
           distance at most depth from ``self`` are returned
         - ``show_depth`` -- boolean (default: ``False``); if ``True``, the
           actual depth of the mutation is shown

src/sage/combinat/crystals/fast_crystals.py

@@ -45,7 +45,7 @@ class FastCrystal(UniqueRepresentation, Parent):
     - ``shape`` -- a shape is of the form ``[l1,l2]`` where ``l1`` and ``l2``
       are either integers or (in type `B_2`) half integers such that
       ``l1 - l2`` is integral. It is assumed that ``l1 >= l2 >= 0``. If
-      ``l1`` and ``l2` are integers, this will produce a crystal
+      ``l1`` and ``l2`` are integers, this will produce a crystal
       isomorphic to the one obtained by
       ``crystals.Tableaux(type, shape=[l1,l2])``. Furthermore
       ``crystals.FastRankTwo(['B', 2], l1+1/2, l2+1/2)`` produces a crystal

src/sage/combinat/crystals/pbw_datum.pyx

@@ -422,10 +422,10 @@ cpdef list enhance_braid_move_chain(braid_move_chain, cartan_type):
     ``(interval_of_change, cartan_sub_matrix)`` where
 
     - ``interval_of_change`` is the (half-open) interval of indices where
-      the braid move occurs; this is `None` for the first tuple
+      the braid move occurs; this is ``None`` for the first tuple
     - ``cartan_sub_matrix`` is the off-diagonal entries of the `2 \times 2`
       submatrix of the Cartan matrix corresponding to the braid move;
-      this is `None` for the first tuple
+      this is ``None`` for the first tuple
 
     For a matrix::
 

src/sage/combinat/designs/difference_family.py

@@ -1141,7 +1141,7 @@ def hadamard_difference_set_product_parameters(N):
     Check whether a product construction is available for Hadamard difference
     set with parameter ``N``.
 
-    This function looks for two integers `N_1` and `N_2`` greater than `1`
+    This function looks for two integers `N_1` and `N_2` greater than `1`
     and so that `N = 2 N_1 N_2` and there exists Hadamard difference set with
     parameters `(4 N_i^2, 2N_i^2 - N_i, N_i^2 - N_i)`. If such pair exists,
     the output is the pair ``(N_1, N_2)`` otherwise it is ``None``.
@@ -3474,7 +3474,7 @@ def difference_family(v, k, l=1, existence=False, explain_construction=False, ch
     OUTPUT:
 
     A pair ``(G,D)`` made of a group `G` and a difference family `D` on that
-    group. Or, if ``existence=True``` a troolean or if
+    group. Or, if ``existence=True`` a troolean or if
     ``explain_construction=True`` a string.
 
     EXAMPLES::

src/sage/combinat/designs/latin_squares.py

@@ -21,7 +21,7 @@
     :meth:`mutually_orthogonal_latin_squares` | Return `k` Mutually Orthogonal `n\times n` Latin Squares.
     :meth:`are_mutually_orthogonal_latin_squares` | Check that the list ``l`` of matrices in are MOLS.
     :meth:`latin_square_product` | Return the product of two (or more) latin squares.
-    :meth:`MOLS_table` | Prints the MOLS table.
+    :meth:`MOLS_table` | Print the MOLS table.
 
 **Table of MOLS**
 

src/sage/combinat/designs/orthogonal_arrays_build_recursive.py

@@ -23,10 +23,10 @@
     :func:`~sage.combinat.designs.orthogonal_arrays_build_recursive.construction_3_6` | Return a `OA(k,nm+i)`.
     :func:`~sage.combinat.designs.orthogonal_arrays_build_recursive.construction_q_x` | Return an `OA(k,(q-1)*(q-x)+x+2)` using the `q-x` construction.
     :func:`OA_and_oval` | Return a `OA(q+1,q)` whose blocks contains `\leq 2` zeroes in the last `q` columns.
-    :func:`thwart_lemma_3_5` | Returns an `OA(k,nm+a+b+c+d)`.
-    :func:`thwart_lemma_4_1` | Returns an `OA(k,nm+4(n-2))`.
-    :func:`three_factor_product` | Returns an `OA(k+1,n_1n_2n_3)`.
-    :func:`brouwer_separable_design` | Returns a `OA(k,t(q^2+q+1)+x)` using Brouwer's result on separable designs.
+    :func:`thwart_lemma_3_5` | Return an `OA(k,nm+a+b+c+d)`.
+    :func:`thwart_lemma_4_1` | Return an `OA(k,nm+4(n-2))`.
+    :func:`three_factor_product` | Return an `OA(k+1,n_1n_2n_3)`.
+    :func:`brouwer_separable_design` | Return a `OA(k,t(q^2+q+1)+x)` using Brouwer's result on separable designs.
 
 Functions
 ---------
@@ -1037,7 +1037,7 @@ def product_with_parallel_classes(OA1,k,g1,g2,g1_parall,parall,check=True):
 
         Two lists of classes ``g1_parall`` and ``parallel`` which are respectively
         `g_1`-parallel and parallel classes such that ``g1_parall+parallel`` is an
-        `OA(k,g1*g2)``.
+        ``OA(k,g1*g2)``.
         """
         if check:
             for classs in g1_parall:

src/sage/combinat/designs/twographs.py

@@ -36,9 +36,9 @@
     :widths: 30, 70
     :delim: |
 
-    :meth:`~TwoGraph.is_regular_twograph` | tests if ``self`` is a regular two-graph, i.e. a 2-design
-    :meth:`~TwoGraph.complement` | returns the complement of ``self``
-    :meth:`~TwoGraph.descendant` | returns the descendant graph at `w`
+    :meth:`~TwoGraph.is_regular_twograph` | Test if ``self`` is a regular two-graph, i.e. a 2-design
+    :meth:`~TwoGraph.complement` | Return the complement of ``self``
+    :meth:`~TwoGraph.descendant` | Return the descendant graph at `w`
 
 This module's functions are the following:
 
@@ -47,9 +47,9 @@
     :widths: 30, 70
     :delim: |
 
-    :func:`~taylor_twograph` | constructs Taylor's two-graph for `U_3(q)`
-    :func:`~is_twograph`         | checks that the incidence system is a two-graph
-    :func:`~twograph_descendant`  | returns the descendant graph w.r.t. a given vertex of the two-graph of a given graph
+    :func:`~taylor_twograph` | Construct Taylor's two-graph for `U_3(q)`
+    :func:`~is_twograph`         | Check that the incidence system is a two-graph
+    :func:`~twograph_descendant`  | Return the descendant graph w.r.t. a given vertex of the two-graph of a given graph
 
 Methods
 ---------

src/sage/combinat/finite_state_machine.py

@@ -61,10 +61,10 @@
     :widths: 30, 70
     :delim: |
 
-    :meth:`~FiniteStateMachine.empty_copy` | Returns an empty deep copy
-    :meth:`~FiniteStateMachine.deepcopy` | Returns a deep copy
-    :meth:`~FiniteStateMachine.relabeled` | Returns a relabeled deep copy
-    :meth:`Automaton.with_output` | Extends an automaton to a transducer
+    :meth:`~FiniteStateMachine.empty_copy` | Return an empty deep copy
+    :meth:`~FiniteStateMachine.deepcopy` | Return a deep copy
+    :meth:`~FiniteStateMachine.relabeled` | Return a relabeled deep copy
+    :meth:`Automaton.with_output` | Extend an automaton to a transducer
 
 
 Manipulation
@@ -101,18 +101,18 @@
     :widths: 30, 70
     :delim: |
 
-    :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 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
-    :meth:`~FiniteStateMachine.is_complete` | Checks for a complete machine
-    :meth:`~FiniteStateMachine.is_connected` | Checks for a connected machine
-    :meth:`Automaton.is_equivalent` | Checks for equivalent automata
-    :meth:`~FiniteStateMachine.is_Markov_chain` | Checks for a Markov chain
-    :meth:`~FiniteStateMachine.is_monochromatic` | Checks whether the colors of all states are equal
+    :meth:`~FiniteStateMachine.has_state` | Check for a state
+    :meth:`~FiniteStateMachine.has_initial_state` | Check for an initial state
+    :meth:`~FiniteStateMachine.has_initial_states` | Check for initial states
+    :meth:`~FiniteStateMachine.has_final_state` | Check for a final state
+    :meth:`~FiniteStateMachine.has_final_states` | Check for final states
+    :meth:`~FiniteStateMachine.has_transition` | Check for a transition
+    :meth:`~FiniteStateMachine.is_deterministic` | Check for a deterministic machine
+    :meth:`~FiniteStateMachine.is_complete` | Check for a complete machine
+    :meth:`~FiniteStateMachine.is_connected` | Check for a connected machine
+    :meth:`Automaton.is_equivalent` | Check for equivalent automata
+    :meth:`~FiniteStateMachine.is_Markov_chain` | Check for a Markov chain
+    :meth:`~FiniteStateMachine.is_monochromatic` | Check whether the colors of all states are equal
     :meth:`~FiniteStateMachine.number_of_words` | Determine the number of successful paths
     :meth:`~FiniteStateMachine.asymptotic_moments` | Main terms of expectation and variance of sums of labels
     :meth:`~FiniteStateMachine.moments_waiting_time` | Moments of the waiting time for first true output
@@ -211,12 +211,12 @@
     :delim: |
 
     :attr:`~FSMState.final_word_out` | Final output of a state
-    :attr:`~FSMState.is_final` | Describes whether a state is final or not
-    :attr:`~FSMState.is_initial` | Describes whether a state is initial or not
+    :attr:`~FSMState.is_final` | Describe whether a state is final or not
+    :attr:`~FSMState.is_initial` | Describe whether a state is initial or not
     :attr:`~FSMState.initial_probability` | Probability of starting in this state as part of a Markov chain
     :meth:`~FSMState.label` | Label of a state
-    :meth:`~FSMState.relabeled` | Returns a relabeled deep copy of a state
-    :meth:`~FSMState.fully_equal` | Checks whether two states are fully equal (including all attributes)
+    :meth:`~FSMState.relabeled` | Return a relabeled deep copy of a state
+    :meth:`~FSMState.fully_equal` | Check whether two states are fully equal (including all attributes)
 
 
 :class:`FSMTransition`
@@ -231,7 +231,7 @@
     :attr:`~FSMTransition.to_state` | State in which transition ends
     :attr:`~FSMTransition.word_in` | Input word of the transition
     :attr:`~FSMTransition.word_out` | Output word of the transition
-    :meth:`~FSMTransition.deepcopy` | Returns a deep copy of the transition
+    :meth:`~FSMTransition.deepcopy` | Return a deep copy of the transition
 
 
 :class:`FSMProcessIterator`
@@ -242,9 +242,9 @@
     :widths: 30, 70
     :delim: |
 
-    :meth:`~FSMProcessIterator.next` | Makes one step in processing the input tape
-    :meth:`~FSMProcessIterator.preview_word` | Reads a word from the input tape
-    :meth:`~FSMProcessIterator.result` | Returns the finished branches during process
+    :meth:`~FSMProcessIterator.next` | Make one step in processing the input tape
+    :meth:`~FSMProcessIterator.preview_word` | Read a word from the input tape
+    :meth:`~FSMProcessIterator.result` | Return the finished branches during process
 
 
 Helper Functions
@@ -255,14 +255,14 @@
     :widths: 30, 70
     :delim: |
 
-    :func:`equal` | Checks whether all elements of ``iterator`` are equal
+    :func:`equal` | Check whether all elements of ``iterator`` are equal
     :func:`full_group_by` | Group iterable by values of some key
     :func:`startswith` | Determine whether list starts with the given prefix
-    :func:`FSMLetterSymbol` | Returns a string associated to the input letter
-    :func:`FSMWordSymbol` | Returns a string associated to a word
-    :func:`is_FSMState` | Tests whether an object inherits from :class:`FSMState`
-    :func:`is_FSMTransition` | Tests whether an object inherits from :class:`FSMTransition`
-    :func:`is_FiniteStateMachine` | Tests whether an object inherits from :class:`FiniteStateMachine`
+    :func:`FSMLetterSymbol` | Return a string associated to the input letter
+    :func:`FSMWordSymbol` | Return a string associated to a word
+    :func:`is_FSMState` | Test whether an object inherits from :class:`FSMState`
+    :func:`is_FSMTransition` | Test whether an object inherits from :class:`FSMTransition`
+    :func:`is_FiniteStateMachine` | Test whether an object inherits from :class:`FiniteStateMachine`
     :func:`duplicate_transition_ignore` |  Default function for handling duplicate transitions
     :func:`duplicate_transition_raise_error` | Raise error when inserting a duplicate transition
     :func:`duplicate_transition_add_input` | Add input when inserting a duplicate transition