Docstring edits

Initial work in `modular`.

src/sage/algebras/cluster_algebra.py

@@ -1163,7 +1163,7 @@ def _mutated_F(self, k, old_g_vector):
 
         INPUT:
 
-        - ``k`` --  an integer in ``range(self.parent().rank())``;
+        - ``k`` -- an integer in ``range(self.parent().rank())``;
           the direction in which we are mutating
 
         - ``old_g_vector`` -- tuple; the `k`-th g-vector of ``self``

src/sage/algebras/hecke_algebras/cubic_hecke_algebra.py

@@ -320,10 +320,10 @@ def matrix(self, subdivide=False, representation_type=None, original=False):
           this can be obtained by the attribute :attr:`CubicHeckeAlgebra.repr_type`
           of ``self``; the following values are possible:
 
-          - ``RegularLeft`` --  (regular left repr. from the above URL)
-          - ``RegularRight`` --  (regular right repr. from the above URL)
+          - ``RegularLeft`` -- (regular left repr. from the above URL)
+          - ``RegularRight`` -- (regular right repr. from the above URL)
           - ``SplitIrredChevie`` -- (split irred. repr. via CHEVIE)
-          - ``SplitIrredMarin`` --  (split irred. repr. from the above URL)
+          - ``SplitIrredMarin`` -- (split irred. repr. from the above URL)
           - default:  ``SplitIrredChevie`` taken if GAP3 and CHEVIE are installed
             on the system, otherwise the default will be ``SplitIrredMarin``
 
@@ -660,13 +660,13 @@ class CubicHeckeAlgebra(CombinatorialFreeModule):
 
     - ``names`` -- string containing the names of the generators as images of
       the braid group generators
-    - ``cubic_equation_parameters`` --  tuple ``(u, v, w)`` of three elements
+    - ``cubic_equation_parameters`` -- tuple ``(u, v, w)`` of three elements
       in an integral domain used as coefficients in the cubic equation. If this
       argument is given the base ring will be set to the common parent of
       ``u, v, w``. In addition a conversion map from the generic base ring is
       supplied. This keyword can also be used to change the variable names of
       the generic base ring (see example 3 below)
-    - ``cubic_equation_roots`` --  tuple ``(a, b, c)`` of three elements in an
+    - ``cubic_equation_roots`` -- tuple ``(a, b, c)`` of three elements in an
       integral domain which stand for the roots of the cubic equation. If this
       argument is given the extension ring will be set to the common parent of
       ``a, b, c``. In addition a conversion map from the generic extension ring
@@ -1942,7 +1942,7 @@ def _braid_image_to_filecache(self, braid_tietze, braid_image_vect):
 
         INPUT:
 
-        - ``braid_tietze`` --  braid in Tietze form
+        - ``braid_tietze`` -- braid in Tietze form
         - ``braid_image_vect`` -- image of the given braid in ``self`` in vector
           representation
 

src/sage/algebras/lie_conformal_algebras/fermionic_ghosts_lie_conformal_algebra.py

@@ -37,7 +37,7 @@ class FermionicGhostsLieConformalAlgebra(GradedLieConformalAlgebra):
 
     INPUT:
 
-    - ``R`` --  a commutative ring; the base ring of this Lie
+    - ``R`` -- a commutative ring; the base ring of this Lie
       conformal algebra
     - ``ngens`` -- an even positive Integer (default: ``2``); the
       number of non-central generators of this Lie conformal

src/sage/algebras/lie_conformal_algebras/graded_lie_conformal_algebra.py

@@ -81,12 +81,12 @@ class GradedLieConformalAlgebra(LieConformalAlgebraWithStructureCoefficients):
       ``index_set`` or ``names``. Central elements are assumed
       to have weight ``0``.
 
-    - ``category`` The category that this Lie conformal algebra
-      belongs to.
+    - ``category`` -- the category that this Lie conformal algebra
+      belongs to
 
     - ``parity`` -- tuple of ``0`` or ``1`` (default: tuple of
       ``0``); a tuple specifying the parity of each non-central
-      generator.
+      generator
 
     EXAMPLES::
 

src/sage/algebras/lie_conformal_algebras/lie_conformal_algebra.py

@@ -242,8 +242,8 @@ class LieConformalAlgebra(UniqueRepresentation, Parent):
       ``LieConformalAlgebras(R).Super()``, even if all generators
       are even.
 
-    - ``category`` The category that this Lie conformal algebra
-      belongs to.
+    - ``category`` -- the category that this Lie conformal algebra
+      belongs to
 
     In addition we accept the following keywords:
 

src/sage/algebras/steenrod/steenrod_algebra_bases.py

@@ -266,9 +266,9 @@ def steenrod_algebra_basis(n, basis='milnor', p=2, **kwds):
     - ``n`` -- nonnegative integer
     - ``basis`` -- string, which basis to use (default: ``'milnor'``)
     - ``p`` -- positive prime number (default: 2)
-    - ``profile`` -- profile function (default: ``None``).  This
+    - ``profile`` -- profile function (default: ``None``); this
       is just passed on to the functions :func:`milnor_basis` and
-      :func:`pst_basis`.
+      :func:`pst_basis`
     - ``truncation_type`` -- truncation type, either 0 or Infinity
       (default: Infinity if no profile function is specified,
       0 otherwise).  This is just passed on to the function

src/sage/arith/misc.py

@@ -2399,7 +2399,7 @@ def mqrr_rational_reconstruction(u, m, T):
 
     INPUT:
 
-    - ``u``, ``m``, ``T`` --  integers such that `m > u \ge 0`, `T > 0`
+    - ``u``, ``m``, ``T`` -- integers such that `m > u \ge 0`, `T > 0`
 
     OUTPUT:
 

src/sage/calculus/transforms/dft.py

@@ -474,7 +474,7 @@ def convolution(self, other):
 
         INPUT:
 
-        - ``other`` --  a collection of elements of a ring with
+        - ``other`` -- a collection of elements of a ring with
           index set a finite abelian group (under `+`)
 
         OUTPUT: the Dirichlet convolution of ``self`` and ``other``
@@ -531,7 +531,7 @@ def convolution_periodic(self, other):
 
         INPUT:
 
-        - ``other`` --  a sequence of elements of `\CC`, `\RR` or `\GF{q}`
+        - ``other`` -- a sequence of elements of `\CC`, `\RR` or `\GF{q}`
 
         OUTPUT: the Dirichlet convolution of ``self`` and ``other``
 

src/sage/calculus/transforms/dwt.pyx

@@ -28,7 +28,7 @@ def WaveletTransform(n, wavelet_type, wavelet_k):
 
     INPUT:
 
-    - ``n`` --  a power of 2
+    - ``n`` -- a power of 2
     - ``T`` -- the data in the GSLDoubleArray must be real
     - ``wavelet_type`` -- the name of the type of wavelet, valid choices are:
 

src/sage/categories/covariant_functorial_construction.py

@@ -131,8 +131,8 @@ def category_from_parents(self, parents):
 
         INPUT:
 
-         - self: a functor F
-         - parents: a list (or iterable) of parents.
+         - ``self`` -- a functor `F`
+         - ``parents`` -- a list (or iterable) of parents
 
         EXAMPLES::
 

src/sage/categories/coxeter_groups.py

@@ -2991,11 +2991,15 @@ def apply_demazure_product(self, element, side='right',
 
         def min_demazure_product_greater(self, element):
             r"""
-            Find the unique Bruhat-minimum element ``u`` such that ``v`` `\le` ``w`` * ``u`` where ``v`` is ``self``, ``w`` is ``element`` and ``*`` is the Demazure product.
+            Find the unique Bruhat-minimum element ``u`` such that ``v`` `\le`
+            ``w`` * ``u`` where ``v`` is ``self``, ``w`` is ``element`` and
+            ``*`` is the Demazure product.
 
             INPUT:
 
-            - ``element`` is either an element of the same Coxeter group as ``self`` or a list (such as a reduced word) of elements from the index set of the Coxeter group.
+            - ``element`` -- is either an element of the same Coxeter group as
+              ``self`` or a list (such as a reduced word) of elements from the
+              index set of the Coxeter group
 
             EXAMPLES::
 

src/sage/categories/finite_monoids.py

@@ -170,7 +170,7 @@ def rhodes_radical_congruence(self, base_ring=None):
 
             INPUT:
 
-            - ``base_ring`` (default: `\QQ`) a field
+            - ``base_ring`` -- (default: `\QQ`) a field
 
             OUTPUT:
 

src/sage/categories/semigroups.py

@@ -178,11 +178,10 @@ def cayley_graph(self, side='right', simple=False, elements=None,
 
             INPUT:
 
-            - ``side`` -- "left", "right", or "twosided":
-              the side on which the generators act (default: "right")
-            - ``simple`` -- boolean (default: ``False``):
-              if ``True``, returns a simple graph (no loops, no labels,
-              no multiple edges)
+            - ``side`` -- ``'left'``, ``'right'``, or ``'twosided'``:
+              the side on which the generators act (default: ``'right'``)
+            - ``simple`` -- boolean (default: ``False``); if ``True``, returns
+              a simple graph (no loops, no labels, no multiple edges)
             - ``generators`` -- list; tuple, or family of elements
               of ``self`` (default: ``self.semigroup_generators()``)
             - ``connecting_set`` -- alias for ``generators``; deprecated

src/sage/combinat/binary_recurrence_sequences.py

@@ -805,7 +805,7 @@ def _goodness(n, R, p):
 
     INPUT:
 
-    - ``n`` --  an integer
+    - ``n`` -- an integer
 
     - ``R`` -- an object in the class ``BinaryRecurrenceSequence``
 
@@ -847,7 +847,7 @@ def _next_good_prime(p, R, qq, patience, qqold):
 
     - ``patience`` -- a real number
 
-    - ``qqold`` --  a perfect power less than or equal to ``qq``
+    - ``qqold`` -- a perfect power less than or equal to ``qq``
 
     OUTPUT: a prime `\ell` such that `\ell` is 1 mod `p`, `b^2+4 c` is a
     square mod `\ell` and the period of `\ell` has ``goodness`` by ``qq`` but
@@ -1041,7 +1041,7 @@ def _estimated_time(M2, M1, length, p):
 
     - ``length`` -- list (the current length of the list of congruences mod ``M1``)
 
-    - ``p`` --  a prime
+    - ``p`` -- a prime
 
     OUTPUT: the estimated run time of the "CRT" step to combine consistent congruences
 

src/sage/combinat/fully_commutative_elements.py

@@ -387,7 +387,7 @@ def has_descent(self, s, side='left'):
         - ``side`` -- string (default: ``'left'``); if set to 'right', determine
           if ``self`` has ``s`` as a right descent
 
-        OUTPUT: a boolean value
+        OUTPUT: boolean
 
         EXAMPLES::
 

src/sage/combinat/k_tableau.py

@@ -3326,7 +3326,7 @@ def shape( self ):
         INPUT:
 
         - ``form`` -- optional argument to indicate 'inner', 'outer' or 'skew'
-          (default: : 'outer')
+          (default: 'outer')
 
         OUTPUT: a `k+1`-core or a pair of `k+1`-cores if form is not 'inner' or 'outer'
 

src/sage/combinat/matrices/hadamard_matrix.py

@@ -2270,7 +2270,7 @@ def williamson_goethals_seidel_skew_hadamard_matrix(a, b, c, d, check=True):
     - ``b`` -- 1,-1 list; the 1st row of `B`
     - ``d`` -- 1,-1 list; the 1st row of `C`
     - ``c`` -- 1,-1 list; the 1st row of `D`
-    - ``check`` --  boolean (default: ``True``); if ``True``, check that the
+    - ``check`` -- boolean (default: ``True``); if ``True``, check that the
       resulting matrix is skew Hadamard before returning it
 
     EXAMPLES::
@@ -2313,7 +2313,7 @@ def skew_hadamard_matrix_spence_construction(n, check=True):
     INPUT:
 
     - ``n`` -- positive integer
-    - ``check`` --  boolean (default: ``True``); if ``True``, check that the
+    - ``check`` -- boolean (default: ``True``); if ``True``, check that the
       resulting matrix is Hadamard before returning it
 
     OUTPUT:

src/sage/combinat/ncsf_qsym/generic_basis_code.py

@@ -1002,7 +1002,7 @@ def __init__(self, domain, on_generators, position=0, codomain=None, category=No
         - ``codomain`` -- the codomain
         - ``position`` -- integer (default: 0)
         - ``category`` -- a category (default: ``None``)
-        - ``anti`` -- boolean (default: False)
+        - ``anti`` -- boolean (default: ``False``)
 
         OUTPUT: module morphism
 

src/sage/combinat/posets/lattices.py

@@ -3351,7 +3351,7 @@ def isomorphic_sublattices_iterator(self, other):
 
         INPUT:
 
-        - ``other`` --  a finite lattice
+        - ``other`` -- a finite lattice
 
         EXAMPLES:
 

src/sage/combinat/posets/poset_examples.py

@@ -1315,7 +1315,7 @@ def SymmetricGroupAbsoluteOrderPoset(n, labels='permutations'):
 
         INPUT:
 
-        - ``n`` --  a positive integer
+        - ``n`` -- a positive integer
 
         - ``label`` -- (default: ``'permutations'``) a label for the elements
           of the poset returned by the function; the options are

src/sage/combinat/posets/posets.py

@@ -1911,8 +1911,8 @@ def plot(self, label_elements=True, element_labels=None,
             ``element_colors``
           * ``element_shape`` -- the shape of elements, like ``'s'`` for
             square; see https://matplotlib.org/api/markers_api.html for the list
-          * ``element_size`` (default: 200) - the size of elements
-          * ``label_elements`` boolean (default: ``True``); whether to display
+          * ``element_size`` -- (default: 200) the size of elements
+          * ``label_elements`` -- boolean (default: ``True``); whether to display
             element labels
           * ``element_labels`` (default: ``None``); a dictionary where keys
             are elements and values are labels to show

src/sage/combinat/sf/kfpoly.py

@@ -300,7 +300,7 @@ def dom(mup, snu):
     - ``mup`` -- a partition conjugate to ``mu``
     - ``snu`` -- a sequence of positive integers
 
-    OUTPUT: a boolean value
+    OUTPUT: boolean
 
     EXAMPLES::
 

src/sage/combinat/shuffle.py

@@ -205,7 +205,7 @@ def __init__(self, l1, l2, element_constructor=None):
 
         - ``l1``, ``l2`` -- iterable: the sets to shuffle
 
-        - ``element_constructor`` --  constructor for the returned elements
+        - ``element_constructor`` -- constructor for the returned elements
 
         TESTS::
 

src/sage/combinat/words/morphism.py

@@ -2488,9 +2488,9 @@ def rauzy_fractal_projection(self, eig=None, prec=53):
           but for substitutions with more than 3 letters
           other interesting choices are sometimes possible.
 
-        - ``prec`` -- integer (default: `53`).
-          The number of bits used in the floating point representations
-          of the coordinates.
+        - ``prec`` -- integer (default: `53`);
+          the number of bits used in the floating point representations
+          of the coordinates
 
         OUTPUT:
 
@@ -2748,9 +2748,9 @@ def rauzy_fractal_plot(self, n=None, exchange=False, eig=None,
           is not plotted with the ``translate`` option;
           the vector ``(0,0,...,0)`` has to be added manually.
 
-        - ``prec`` -- integer (default: `53`).
-          The number of bits used in the floating point representations
-          of the points of the fractal.
+        - ``prec`` -- integer (default: `53`);
+          the number of bits used in the floating point representations
+          of the points of the fractal
 
         - ``colormap`` -- color map or dictionary (default: ``'hsv'``).
           It can be one of the following:
@@ -3531,7 +3531,7 @@ def infinite_repetitions_primitive_roots(self, w=None, allow_growing=None):
         - ``w`` -- finite iterable (default: ``self.domain().alphabet()``);
           represents a word used to start the language
 
-        - ``allow_growing`` -- boolean or ``None`` (default: ``None``). If
+        - ``allow_growing`` -- boolean or ``None`` (default: ``None``); if
           ``False``, return only the primitive roots that contain no growing
           letters. If ``True``, return only the primitive roots that contain at
           least one growing letter. If ``None``, return both.

src/sage/data_structures/bitset.pyx

@@ -62,7 +62,7 @@ cdef class FrozenBitset:
 
     INPUT:
 
-    - ``iter`` -- initialization parameter (default: ``None``). Valid input
+    - ``iter`` -- initialization parameter (default: ``None``); valid inputs
       are:
 
       - :class:`Bitset` and :class:`FrozenBitset` -- If this is a

src/sage/databases/sql_db.py

@@ -2143,7 +2143,7 @@ def add_rows(self, table_name, rows, entry_order=None):
 
         - ``rows`` -- list of tuples that represent one row of data to add
           (types should match col types in order)
-        - ``entry_order`` --  an ordered list or tuple overrides normal order
+        - ``entry_order`` -- an ordered list or tuple overrides normal order
           with user defined order
 
         EXAMPLES::

src/sage/dynamics/arithmetic_dynamics/projective_ds.py

@@ -1522,7 +1522,7 @@ def orbit(self, P, N, **kwds):
 
         kwds:
 
-        - ``check`` --  boolean (default: ``True``)
+        - ``check`` -- boolean (default: ``True``)
 
         - ``normalize`` -- boolean (default: ``False``)
 

src/sage/geometry/polyhedron/base2.py

@@ -738,7 +738,7 @@ def generating_function_of_integral_points(self, **kwds):
           both at the same time.
 
         - ``Factorization_sort`` (default: ``False``) and
-          ``Factorization_simplify`` boolean (default: ``True``); booleans
+          ``Factorization_simplify`` (default: ``True``) -- booleans
 
           These are passed on to
           :class:`sage.structure.factorization.Factorization` when creating

src/sage/geometry/polyhedron/generating_function.py

@@ -98,7 +98,7 @@ def generating_function_of_integral_points(polyhedron, split=False,
       both at the same time.
 
     - ``Factorization_sort`` (default: ``False``) and
-      ``Factorization_simplify`` (default: ``True``); booleans
+      ``Factorization_simplify`` (default: ``True``) -- booleans
 
       These are passed on to
       :class:`sage.structure.factorization.Factorization` when creating

src/sage/graphs/base/static_sparse_graph.pyx

@@ -35,7 +35,7 @@ five fields
 
 - ``n`` -- ``int``; the number of vertices in the graph
 
-- ``m`` --  --`int``; the number of edges in the graph
+- ``m`` -- ``int``; the number of edges in the graph
 
 - ``edges`` -- ``uint32_t *``; array whose length is the number of edges of the
   graph