Docstring edits

Work in `modules`, `monoids`, `parallel`, `probability`, `quivers`, `sandpiles`, `sat`, `stats`, and `typeset`.

src/sage/algebras/finite_dimensional_algebras/finite_dimensional_algebra.py

@@ -439,7 +439,7 @@ def ideal(self, gens=None, given_by_matrix=False, side=None):
 
         - ``A`` -- a :class:`FiniteDimensionalAlgebra`
 
-        - ``gens`` -- (default: ``None``); either an element of `A` or a
+        - ``gens`` -- (default: ``None``) either an element of `A` or a
           list of elements of `A`, given as vectors, matrices, or
           FiniteDimensionalAlgebraElements.  If ``given_by_matrix`` is
           ``True``, then ``gens`` should instead be a matrix whose rows

src/sage/arith/misc.py

@@ -1683,17 +1683,17 @@ def plot(self, xmin=1, xmax=50, k=1, pointsize=30, rgbcolor=(0,0,1), join=True,
 
         INPUT:
 
-        - ``xmin`` -- default: 1
+        - ``xmin`` -- (default: 1)
 
-        - ``xmax`` -- default: 50
+        - ``xmax`` -- (default: 50)
 
-        - ``k`` -- default: 1
+        - ``k`` -- (default: 1)
 
-        - ``pointsize`` -- default: 30
+        - ``pointsize`` -- (default: 30)
 
-        - ``rgbcolor`` -- default: (0,0,1)
+        - ``rgbcolor`` -- (default: (0,0,1))
 
-        - ``join`` -- default: ``True``; whether to join the points
+        - ``join`` -- (default: ``True``) whether to join the points
 
         - ``**kwds`` -- passed on
 
@@ -3108,13 +3108,13 @@ def plot(self, xmin=1, xmax=50, pointsize=30, rgbcolor=(0, 0, 1),
 
         INPUT:
 
-        - ``xmin`` -- default: 1
+        - ``xmin`` -- (default: 1)
 
-        - ``xmax`` -- default: 50
+        - ``xmax`` -- (default: 50)
 
-        - ``pointsize`` -- default: 30
+        - ``pointsize`` -- (default: 30)
 
-        - ``rgbcolor`` -- default: (0,0,1)
+        - ``rgbcolor`` -- (default: (0,0,1))
 
         - ``join`` -- boolean (default: ``True``); whether to join the points
 
@@ -4557,15 +4557,15 @@ def plot(self, xmin=0, xmax=50, pointsize=30, rgbcolor=(0,0,1), join=True,
 
         INPUT:
 
-        - ``xmin`` -- default: 0
+        - ``xmin`` -- (default: 0)
 
-        - ``xmax`` -- default: 50
+        - ``xmax`` -- (default: 50)
 
-        - ``pointsize`` -- default: 30
+        - ``pointsize`` -- (default: 30)
 
-        - ``rgbcolor`` -- default: (0,0,1)
+        - ``rgbcolor`` -- (default: (0,0,1))
 
-        - ``join`` -- default: ``True``; whether to join the points
+        - ``join`` -- (default: ``True``) whether to join the points
            (very helpful in seeing their order)
 
         - ``**kwds`` -- passed on

src/sage/calculus/calculus.py

@@ -1167,12 +1167,12 @@ def limit(ex, dir=None, taylor=False, algorithm='maxima', **argv):
 
     INPUT:
 
-    - ``dir`` -- (default: ``None``); may have the value
+    - ``dir`` -- (default: ``None``) may have the value
       ``'plus'`` (or ``'+'`` or ``'right'`` or ``'above'``) for a limit from above,
       ``'minus'`` (or ``'-'`` or ``'left'`` or ``'below'``) for a limit from below, or may be omitted
       (implying a two-sided limit is to be computed).
 
-    - ``taylor`` -- (default: ``False``); if ``True``, use Taylor
+    - ``taylor`` -- (default: ``False``) if ``True``, use Taylor
       series, which allows more limits to be computed (but may also
       crash in some obscure cases due to bugs in Maxima).
 

src/sage/calculus/functional.py

@@ -335,12 +335,12 @@ def limit(f, dir=None, taylor=False, **argv):
 
     INPUT:
 
-    - ``dir`` -- (default: ``None``); dir may have the value ``'plus'`` (or
+    - ``dir`` -- (default: ``None``) dir may have the value ``'plus'`` (or
       ``'above'``) for a limit from above, ``'minus'`` (or ``'below'``) for a
       limit from below, or may be omitted (implying a two-sided limit is to be
       computed).
 
-    - ``taylor`` -- (default: ``False``); if ``True``, use Taylor
+    - ``taylor`` -- (default: ``False``) if ``True``, use Taylor
       series, which allows more limits to be computed (but may also
       crash in some obscure cases due to bugs in Maxima).
 

src/sage/categories/groups.py

@@ -225,7 +225,7 @@ def cayley_table(self, names='letters', elements=None):
               * a list - a list of strings, where the length
                 of the list equals the number of elements.
 
-            - ``elements`` -- (default: ``None``);  A list of
+            - ``elements`` -- (default: ``None``) a list of
               elements of the group, in forms that can be
               coerced into the structure, eg. their string
               representations. This may be used to impose an

src/sage/coding/cyclic_code.py

@@ -150,7 +150,7 @@ def bch_bound(n, D, arithmetic=False):
 
     - ``D`` -- list of integers
 
-    - ``arithmetic`` -- (default: ``False``); if it is set to ``True``, then it
+    - ``arithmetic`` -- (default: ``False``) if it is set to ``True``, then it
       computes the BCH bound using the longest arithmetic sequence definition
 
     OUTPUT:
@@ -763,7 +763,7 @@ def bch_bound(self, arithmetic=False):
 
         INPUT:
 
-        - ``arithmetic`` -- (default: ``False``); if it is set to ``True``,
+        - ``arithmetic`` -- (default: ``False``) if it is set to ``True``,
           then it computes the BCH bound using the longest arithmetic sequence
           definition
 

src/sage/combinat/cluster_algebra_quiver/cluster_seed.py

@@ -3756,10 +3756,10 @@ def cluster_class(self, depth=infinity, show_depth=False, up_to_equivalence=True
 
         - ``depth`` -- (default: infinity) integer, only seeds with distance
           at most ``depth`` from ``self`` are returned
-        - ``return_depth`` -- (default: ``False``); if ``True``, ignored if
+        - ``return_depth`` -- (default: ``False``) if ``True``, ignored if
           ``depth`` is set; returns the depth of the mutation class, i.e.,
           the maximal distance from ``self`` of an element in the mutation class
-        - ``up_to_equivalence`` -- (default: ``True``); if ``True``, only
+        - ``up_to_equivalence`` -- (default: ``True``) if ``True``, only
           clusters up to equivalence are considered
 
         EXAMPLES:

src/sage/combinat/cluster_algebra_quiver/quiver.py

@@ -1925,9 +1925,9 @@ def is_mutation_finite( self, nr_of_checks=None, return_path=False ):
 
         - ``nr_of_checks`` -- (default: ``None``) number of mutations applied;
           Standard is 500*(number of vertices of ``self``)
-        - ``return_path`` -- (default: ``False``); if ``True``, in case of
+        - ``return_path`` -- (default: ``False``) if ``True``, in case of
           ``self`` not being mutation finite, a path from ``self`` to a quiver
-          with an edge label `(a,-b)` and `a*b > 4` is returned.
+          with an edge label `(a,-b)` and `a*b > 4` is returned
 
         ALGORITHM:
 

src/sage/combinat/designs/twographs.py

@@ -271,7 +271,7 @@ def twograph_descendant(G, v, name=None):
 
     - ``v`` -- a vertex of ``G``
 
-    - ``name`` -- (default: ``None``); no name, otherwise derive from the construction
+    - ``name`` -- (default: ``None``) no name, otherwise derive from the construction
 
     EXAMPLES:
 

src/sage/combinat/diagram_algebras.py

@@ -1145,7 +1145,7 @@ class AbstractPartitionDiagrams(Parent, UniqueRepresentation):
     INPUT:
 
     - ``order`` -- integer or integer `+ 1/2`; the order of the diagrams
-    - ``category`` -- (default: ``FiniteEnumeratedSets()``); the category
+    - ``category`` -- (default: ``FiniteEnumeratedSets()``) the category
 
     All concrete classes should implement attributes
 

src/sage/combinat/ncsf_qsym/ncsf.py

@@ -1920,7 +1920,7 @@ def expand(self, n, alphabet='x'):
 
                 - ``n`` -- nonnegative integer; the number of variables
                   in the expansion
-                - ``alphabet`` -- (default: ``'x'``); the alphabet in
+                - ``alphabet`` -- (default: ``'x'``) the alphabet in
                   which ``self`` is to be expanded
 
                 OUTPUT: an expansion of ``self`` into the `n` variables

src/sage/combinat/ncsf_qsym/qsym.py

@@ -1568,7 +1568,7 @@ def expand(self, n, alphabet='x'):
 
                 - ``n`` -- nonnegative integer; the number of variables
                   in the expansion
-                - ``alphabet`` -- (default: ``'x'``); the alphabet in
+                - ``alphabet`` -- (default: ``'x'``) the alphabet in
                   which ``self`` is to be expanded
 
                 OUTPUT: an expansion of ``self`` into the ``n`` variables

src/sage/combinat/output.py

@@ -353,7 +353,7 @@ def tex_from_skew_array(array, with_lines=False, align='b'):
     - ``with_lines`` -- (default: ``False``) if ``True`` lines are drawn, if
       ``False`` they are not
 
-    - ``align`` -- (default: ``'b'``); determine the alignment on the latex
+    - ``align`` -- (default: ``'b'``) determine the alignment on the latex
       array environments
 
     EXAMPLES::

src/sage/combinat/posets/posets.py

@@ -363,7 +363,7 @@ def Poset(data=None, element_labels=None, cover_relations=False, linear_extensio
 
       6. A previously constructed poset (the poset itself is returned).
 
-    - ``element_labels`` -- (default: ``None``); an optional list or
+    - ``element_labels`` -- (default: ``None``) an optional list or
       dictionary of objects that label the poset elements
 
     - ``cover_relations`` -- boolean (default: ``False``); whether the
@@ -4366,7 +4366,7 @@ def coxeter_smith_form(self, algorithm='singular'):
 
         INPUT:
 
-        - ``algorithm`` -- (default: ``'singular'``); possible
+        - ``algorithm`` -- (default: ``'singular'``) possible
           values are ``'singular'``, ``'sage'``, ``'gap'``,
           ``'pari'``, ``'maple'``, ``'magma'``, ``'fricas'``
 

src/sage/combinat/root_system/reflection_group_element.pyx

@@ -186,7 +186,7 @@ cdef class ComplexReflectionGroupElement(PermutationGroupElement):
         Return ``self`` as a matrix acting on the underlying vector
         space.
 
-        - ``on_space`` -- (default: ``'primal'``); whether
+        - ``on_space`` -- (default: ``'primal'``) whether
           to act as the reflection representation on the given
           basis, or to act on the dual reflection representation
           on the dual basis
@@ -356,7 +356,7 @@ cdef class ComplexReflectionGroupElement(PermutationGroupElement):
 
         - ``vec`` -- vector in the basis given by the simple root
 
-        - ``on_space`` -- (default: ``'primal'``); whether
+        - ``on_space`` -- (default: ``'primal'``) whether
           to act as the reflection representation on the given
           basis, or to act on the dual reflection representation
           on the dual basis
@@ -875,10 +875,10 @@ cdef class RealReflectionGroupElement(ComplexReflectionGroupElement):
         Return ``self`` as a matrix acting on the underlying vector
         space.
 
-        - ``side`` -- (default: ``'right'``); whether the
+        - ``side`` -- (default: ``'right'``) whether the
           action of ``self`` is on the ``'left'`` or on the ``'right'``
 
-        - ``on_space`` -- (default: ``'primal'``); whether
+        - ``on_space`` -- (default: ``'primal'``) whether
           to act as the reflection representation on the given
           basis, or to act on the dual reflection representation
           on the dual basis
@@ -967,10 +967,10 @@ cdef class RealReflectionGroupElement(ComplexReflectionGroupElement):
 
         - ``vec`` -- vector in the basis given by the simple root
 
-        - ``side`` -- (default: ``'right'``); whether the
+        - ``side`` -- (default: ``'right'``) whether the
           action of ``self`` is on the ``'left'`` or on the ``'right'``
 
-        - ``on_space`` -- (default: ``'primal'``); whether
+        - ``on_space`` -- (default: ``'primal'``) whether
           to act as the reflection representation on the given
           basis, or to act on the dual reflection representation
           on the dual basis
@@ -1062,7 +1062,7 @@ cdef class RealReflectionGroupElement(ComplexReflectionGroupElement):
 
         - ``i`` -- index of the root to act on
 
-        - ``side`` -- (default: ``'right'``); whether the
+        - ``side`` -- (default: ``'right'``) whether the
           action is on the left or on the right
 
         EXAMPLES::
@@ -1098,7 +1098,7 @@ cdef class RealReflectionGroupElement(ComplexReflectionGroupElement):
 
         - ``root`` -- the root to act on
 
-        - ``side`` -- (default: ``'right'``); whether the
+        - ``side`` -- (default: ``'right'``) whether the
           action is on the left or on the right
 
         EXAMPLES::

src/sage/combinat/root_system/reflection_group_real.py

@@ -301,7 +301,7 @@ def iteration(self, algorithm='breadth', tracking_words=True):
 
         INPUT:
 
-        - ``algorithm`` -- (default: ``'breadth'``); must be one of
+        - ``algorithm`` -- (default: ``'breadth'``) must be one of
           the following:
 
           * ``'breadth'`` -- iterate over in a linear extension of the

src/sage/combinat/sf/elementary.py

@@ -452,7 +452,7 @@ def exponential_specialization(self, t=None, q=1):
 
             INPUT:
 
-            - ``t`` -- (default: ``None``); the value to use for `t`.
+            - ``t`` -- (default: ``None``) the value to use for `t`.
               The default is to create a ring of polynomials in `t`.
 
             - ``q`` -- (default: `1`) the value to use for `q`.  If

src/sage/combinat/sf/schur.py

@@ -620,7 +620,7 @@ def principal_specialization(self, n=infinity, q=None):
               specialization of order ``n`` or the stable principal
               specialization.
 
-            - ``q`` -- (default: ``None``); the value to use for `q`; the
+            - ``q`` -- (default: ``None``) the value to use for `q`; the
               default is to create a ring of polynomials in ``q``
               (or a field of rational functions in ``q``) over the
               given coefficient ring.

src/sage/combinat/sf/sfa.py

@@ -6047,7 +6047,7 @@ def principal_specialization(self, n=infinity, q=None):
           specialization of order ``n`` or the stable principal
           specialization.
 
-        - ``q`` -- (default: ``None``); the value to use for `q`; the
+        - ``q`` -- (default: ``None``) the value to use for `q`; the
           default is to create a ring of polynomials in ``q``
           (or a field of rational functions in ``q``) over the
           given coefficient ring.
@@ -6295,7 +6295,7 @@ def exponential_specialization(self, t=None, q=1):
 
         INPUT:
 
-        - ``t`` -- (default: ``None``); the value to use for `t`;
+        - ``t`` -- (default: ``None``) the value to use for `t`;
           the default is to create a ring of polynomials in ``t``
 
         - ``q`` -- (default: `1`) the value to use for `q`.  If

src/sage/crypto/block_cipher/des.py

@@ -349,11 +349,11 @@ def __init__(self, rounds=None, keySchedule='DES_KS', keySize=64, doFinalRound=T
         - ``rounds`` -- integer (default: ``None``); the number of rounds. If
           ``None`` the number of rounds of the key schedule is used.
 
-        - ``keySchedule`` -- (default: ``'DES_KS'``); the key schedule that
+        - ``keySchedule`` -- (default: ``'DES_KS'``) the key schedule that
           will be used for encryption and decryption. If ``'DES_KS'`` the
           default DES key schedule is used.
 
-        - ``keySize`` -- (default: ``64``); the key length in bits. Must be
+        - ``keySize`` -- (default: ``64``) the key length in bits. Must be
           ``56`` of ``64``. In the latter case the key contains 8 parity bits.
 
         - ``doFinalRound`` -- boolean (default: ``True``); if ``False`` a swap

src/sage/crypto/block_cipher/present.py

@@ -179,7 +179,7 @@ def __init__(self, keySchedule=80, rounds=None, doFinalRound=False):
 
         INPUT:
 
-        - ``keySchedule`` -- (default: ``80``); the key schedule that will be
+        - ``keySchedule`` -- (default: ``80``) the key schedule that will be
           used for encryption and decryption. Use ``80`` or ``128`` as a
           shortcut for the original key schedules from [BKLPPRSV2007]_.
 

src/sage/geometry/hyperplane_arrangement/ordered_arrangement.py

@@ -142,7 +142,7 @@ def hyperplane_section(self, proj=True):
 
         INPUT:
 
-        - ``proj`` -- (default: ``True``); if the
+        - ``proj`` -- (default: ``True``) if the
           ambient space is affine or projective
 
         OUTPUT:

src/sage/geometry/polyhedron/combinatorial_polyhedron/conversions.pyx

@@ -410,7 +410,7 @@ def _bit_rep_to_Vrep_list_wrapper(ListOfFaces faces, index=0):
     INPUT:
 
     - ``faces`` -- a :class:`~sage.geometry.polyhedron.combinatorial_polyhedron.list_of_faces.ListOfFaces`
-    - ``index`` -- (default: ``0``); the face to obtain
+    - ``index`` -- (default: ``0``) the face to obtain
 
     OUTPUT: the face as tuple of integers
 

src/sage/geometry/toric_lattice.py

@@ -1730,7 +1730,7 @@ def coordinate_vector(self, x, reduce=False):
 
         - ``x`` -- element of ``self`` or convertible to ``self``
 
-        - ``reduce`` -- (default: ``False``); if ``True``, reduce coefficients
+        - ``reduce`` -- (default: ``False``) if ``True``, reduce coefficients
           modulo invariants
 
         OUTPUT: the coordinates as a vector

src/sage/graphs/base/static_dense_graph.pyx

@@ -64,7 +64,7 @@ cdef dict dense_graph_init(binary_matrix_t m, g, translation=None, force_undirec
 
     - ``g`` -- a graph or digraph
 
-    - ``translation`` -- (default: `None``); several options for this parameter
+    - ``translation`` -- (default: `None``) several options for this parameter
       used to specify the mapping from vertices to integers:
 
       - ``True``, ``False``, ``None`` -- the `i`-th vertex in the binary matrix