Docstring edits

Work in `schemes` (1/2).

src/sage/arith/misc.py

@@ -1038,7 +1038,7 @@ def primes(start=2, stop=None, proof=None):
     - ``stop`` -- integer (or infinity); upper (open) bound for the
       primes
 
-    - ``proof`` -- bool or ``None`` (default: ``None``); if ``True``, the
+    - ``proof`` -- boolean or ``None`` (default: ``None``); if ``True``, the
       function yields only proven primes.  If ``False``, the function uses a
       pseudo-primality test, which is much faster for really big numbers but
       does not provide a proof of primality. If ``None``, uses the global
@@ -1385,7 +1385,7 @@ def random_prime(n, proof=None, lbound=2):
 
     - ``n`` -- integer `\geq 2`
 
-    - ``proof`` -- bool or ``None`` (default: ``None``); if ``False``, the function uses a
+    - ``proof`` -- boolean or ``None`` (default: ``None``); if ``False``, the function uses a
       pseudo-primality test, which is much faster for really big numbers but
       does not provide a proof of primality. If ``None``, uses the global default
       (see :mod:`sage.structure.proof.proof`)

src/sage/calculus/var.pyx

@@ -143,7 +143,7 @@ def function(s, **kwds):
       other systems, this is used by the interfaces internally during conversion
     - ``eval_func`` -- method used for automatic evaluation
     - ``evalf_func`` -- method used for numeric evaluation
-    - ``evalf_params_first`` -- bool to indicate if parameters should be
+    - ``evalf_params_first`` -- boolean to indicate if parameters should be
       evaluated numerically before calling the custom evalf function
     - ``conjugate_func`` -- method used for complex conjugation
     - ``real_part_func`` -- method used when taking real parts

src/sage/combinat/designs/resolvable_bibd.py

@@ -150,7 +150,7 @@ def kirkman_triple_system(v,existence=False):
 
     INPUT:
 
-    - `n` -- integer
+    - ``n`` -- integer
 
     - ``existence`` -- boolean (default: ``False``); whether to build the
       `KTS(n)` or only answer whether it exists
@@ -374,7 +374,7 @@ def v_4_1_rbibd(v,existence=False):
 
     INPUT:
 
-    - `n` -- integer
+    - ``n`` -- integer
 
     - ``existence`` -- boolean (default: ``False``); whether to build the
       design or only answer whether it exists

src/sage/combinat/nu_dyck_word.py

@@ -706,7 +706,7 @@ def pretty_print(self, style=None, labelling=None):
         - ``labelling`` -- (if style is "N-E") a list of labels assigned to
           the up steps in ``self``
 
-        - ``underpath`` -- (if style is "N-E", default: ``True``) If ``True``,
+        - ``underpath`` -- (if style is "N-E", default: ``True``) if ``True``,
           an ``x`` to show the boxes between `\nu` and the `\nu`-Dyck Path
 
         EXAMPLES::

src/sage/combinat/path_tableaux/dyck_path.py

@@ -45,10 +45,10 @@ class DyckPath(PathTableau):
 
     INPUT:
 
-    * a sequence of nonnegative integers
-    * a two row standard skew tableau
-    * a Dyck word
-    * a noncrossing perfect matching
+    - a sequence of nonnegative integers
+    - a two row standard skew tableau
+    - a Dyck word
+    - a noncrossing perfect matching
 
     EXAMPLES::
 

src/sage/combinat/q_bernoulli.pyx

@@ -19,7 +19,7 @@ def q_bernoulli(m, p=None):
 
     - ``m`` -- nonnegative integer
 
-    - `p` -- (default: ``None``) an optional value for `q`
+    - ``p`` -- (default: ``None``) an optional value for `q`
 
     OUTPUT:
 

src/sage/combinat/ranker.py

@@ -181,7 +181,7 @@ def unrank(L, i):
     INPUT:
 
     - ``L`` -- list, tuple, finite enumerated set, etc.
-    - ``i`` -- an int or :class:`Integer`
+    - ``i`` -- integer or :class:`Integer`
 
     The purpose of this utility is to give a uniform idiom to recover
     the `i`-th element of an object ``L``, whether ``L`` is a list,

src/sage/combinat/tamari_lattices.py

@@ -61,9 +61,9 @@ def paths_in_triangle(i, j, a, b) -> list[tuple[int, ...]]:
 
     INPUT:
 
-    - `a` and `b` -- integers with `a \geq b`
+    - ``a``, ``b`` -- integers with `a \geq b`
 
-    - `i` and `j` -- nonnegative integers with `1 \geq \frac{j}{b} \geq
+    - ``i``, ``j`` -- nonnegative integers with `1 \geq \frac{j}{b} \geq
       \frac{i}{a} \geq 0`
 
     OUTPUT: list of paths
@@ -165,7 +165,7 @@ def GeneralizedTamariLattice(a, b, m=1):
 
     INPUT:
 
-    - `a` and `b` -- integers with `a \geq b`
+    - ``a``, ``b`` -- integers with `a \geq b`
 
     - ``m`` -- a nonnegative rational number such that `a \geq b m`
 

src/sage/combinat/words/abstract_word.py

@@ -1096,8 +1096,8 @@ def prefixes_iterator(self, max_length=None):
 
         INPUT:
 
-        - ``max_length`` -- nonnegative integer or None (optional,
-          default: None) the maximum length of the prefixes
+        - ``max_length`` -- nonnegative integer or ``None`` (default); the
+          maximum length of the prefixes
 
         OUTPUT: iterator
 
@@ -1148,8 +1148,8 @@ def palindrome_prefixes_iterator(self, max_length=None):
 
         INPUT:
 
-        - ``max_length`` -- nonnegative integer or None (optional,
-          default: None) the maximum length of the prefixes
+        - ``max_length`` -- nonnegative integer or ``None`` (default); the
+          maximum length of the prefixes
 
         OUTPUT: iterator
 

src/sage/databases/cremona.py

@@ -1383,7 +1383,7 @@ def _init_allcurves(self, ftpdata, largest_conductor=0):
 
         INPUT:
 
-        - `ftpdata` (string) -- the name of the directory in which the data is
+        - ``ftpdata`` -- string; the name of the directory in which the data is
 
         - ``largest_conductor`` -- integer (default: 0); if 0,
           then only include data up to that conductor

src/sage/databases/oeis.py

@@ -1209,9 +1209,9 @@ def first_terms(self, number=None):
 
         INPUT:
 
-        - ``number`` -- (integer or ``None``, default: ``None``) the number of
+        - ``number`` -- integer or ``None`` (default); the number of
           terms returned (if less than the number of available terms). When set
-          to None, returns all the known terms.
+          to ``None``, returns all the known terms.
 
         OUTPUT: tuple of integers
 

src/sage/geometry/cone.py

@@ -6346,29 +6346,29 @@ def random_cone(lattice=None, min_ambient_dim=0, max_ambient_dim=None,
 
     INPUT:
 
-    * ``lattice`` -- (default: random) a ``ToricLattice`` object in
+    - ``lattice`` -- (default: random) a ``ToricLattice`` object in
       which the returned cone will live. By default a new lattice will
       be constructed with a randomly-chosen rank (subject to
       ``min_ambient_dim`` and ``max_ambient_dim``).
 
-    * ``min_ambient_dim`` -- (default: zero) a nonnegative integer
+    - ``min_ambient_dim`` -- (default: zero) a nonnegative integer
       representing the minimum dimension of the ambient lattice
 
-    * ``max_ambient_dim`` -- (default: random) a nonnegative integer
+    - ``max_ambient_dim`` -- (default: random) a nonnegative integer
       representing the maximum dimension of the ambient lattice
 
-    * ``min_rays`` -- (default: zero) a nonnegative integer representing
+    - ``min_rays`` -- (default: zero) a nonnegative integer representing
       the minimum number of generating rays of the cone
 
-    * ``max_rays`` -- (default: random) a nonnegative integer representing
+    - ``max_rays`` -- (default: random) a nonnegative integer representing
       the maximum number of generating rays of the cone
 
-    * ``strictly_convex`` -- (default: random) whether or not to make the
+    - ``strictly_convex`` -- (default: random) whether or not to make the
       returned cone strictly convex. Specify ``True`` for a strictly convex
       cone, ``False`` for a non-strictly-convex cone, or ``None`` if you
       don't care.
 
-    * ``solid`` -- (default: random) whether or not to make the returned
+    - ``solid`` -- (default: random) whether or not to make the returned
       cone solid. Specify ``True`` for a solid cone, ``False`` for a
       non-solid cone, or ``None`` if you don't care.
 

src/sage/graphs/bipartite_graph.py

@@ -758,10 +758,10 @@ def add_vertices(self, vertices, left=False, right=False):
         - ``vertices`` -- sequence of vertices to add
 
         - ``left`` -- (default: ``False``) either ``True`` or sequence of same
-          length as ``vertices`` with ``True``/``False`` elements
+          length as ``vertices`` with boolean elements
 
         - ``right`` -- (default: ``False``) either ``True`` or sequence of the
-          same length as ``vertices`` with ``True``/``False`` elements
+          same length as ``vertices`` with boolean elements
 
         Only one of ``left`` and ``right`` keywords should be provided.  See
         the examples below.

src/sage/graphs/convexity_properties.pyx

@@ -295,7 +295,7 @@ cdef class ConvexityProperties:
 
         INPUT:
 
-        * ``vertices`` -- list of vertices
+        - ``vertices`` -- list of vertices
 
         EXAMPLES::
 
@@ -351,11 +351,11 @@ cdef class ConvexityProperties:
 
         INPUT:
 
-        * ``value_only`` -- boolean (default: ``True``); whether to return only
+        - ``value_only`` -- boolean (default: ``True``); whether to return only
           the hull number (default) or a minimum set whose convex hull is the
           whole graph
 
-        * ``verbose`` -- boolean (default: ``False``); whether to display
+        - ``verbose`` -- boolean (default: ``False``); whether to display
           information on the LP
 
         **COMPLEXITY:**

src/sage/graphs/graph_coloring.pyx

@@ -149,22 +149,22 @@ def all_graph_colorings(G, n, count_only=False, hex_colors=False,
 
     INPUT:
 
-    * ``G`` -- a graph
+    - ``G`` -- a graph
 
-    * ``n`` -- positive integer; the number of colors
+    - ``n`` -- positive integer; the number of colors
 
-    * ``count_only`` -- boolean (default: ``False``); when set to ``True``, it
+    - ``count_only`` -- boolean (default: ``False``); when set to ``True``, it
       returns 1 for each coloring and ignores other parameters
 
-    * ``hex_colors`` -- boolean (default: ``False``); when set to ``False``,
+    - ``hex_colors`` -- boolean (default: ``False``); when set to ``False``,
       colors are labeled [0, 1, ..., `n - 1`], otherwise the RGB Hex labeling
       is used
 
-    * ``vertex_color_dict`` -- boolean (default: ``False``); when set to
+    - ``vertex_color_dict`` -- boolean (default: ``False``); when set to
       ``True``, it returns a dictionary ``{vertex: color}``, otherwise it
       returns a dictionary ``{color: [list of vertices]}``
 
-    * ``color_classes`` -- boolean (default: ``False``); when set to ``True``,
+    - ``color_classes`` -- boolean (default: ``False``); when set to ``True``,
       the method returns only a list of the color classes and ignores parameters
       ``hex_colors`` and ``vertex_color_dict``
 

src/sage/interfaces/gnuplot.py

@@ -149,7 +149,7 @@ def plot3d_parametric(self, f='cos(u)*(3 + v*cos(u/2)), sin(u)*(3 + v*cos(u/2)),
         - ``range2`` -- string; range of values for another
           variable, e.g., ``'[v=-0.2:0.2]'``
 
-        - ``samples`` -- (int) number of sample points to use
+        - ``samples`` -- integer; number of sample points to use
 
         - ``title`` -- string; title of the graph
 

src/sage/libs/eclib/interface.py

@@ -1014,9 +1014,7 @@ def rank(self):
         """
         Return the rank of this subgroup of the Mordell-Weil group.
 
-        OUTPUT:
-
-        (int) The rank of this subgroup of the Mordell-Weil group.
+        OUTPUT: integer
 
         EXAMPLES::
 

src/sage/libs/eclib/mwrank.pyx

@@ -85,9 +85,7 @@ def get_precision():
     Return the working floating point bit precision of mwrank, which is
     equal to the global NTL real number precision.
 
-    OUTPUT:
-
-    (int) The current precision in bits.
+    OUTPUT: integer; the current precision in bits
 
     See also :meth:`set_precision`.
 
@@ -1149,9 +1147,7 @@ cdef class _two_descent:
         """
         Return the success flag (after doing a 2-descent).
 
-        OUTPUT:
-
-        (bool) Flag indicating whether or not 2-descent was successful.
+        OUTPUT: boolean flag indicating whether or not 2-descent was successful
 
         EXAMPLES::
 
@@ -1178,9 +1174,7 @@ cdef class _two_descent:
         """
         Return the certainty flag (after doing a 2-descent).
 
-        OUTPUT:
-
-        (bool) ``True`` if the rank upper and lower bounds are equal.
+        OUTPUT: boolean; ``True`` if the rank upper and lower bounds are equal
 
         EXAMPLES::
 

src/sage/libs/pari/convert_sage.pyx

@@ -86,7 +86,7 @@ cpdef gen_to_sage(Gen z, locals=None):
 
     - a matrix if ``z`` is a matrix (type ``t_MAT``)
 
-    - a padic element (type ``t_PADIC``)
+    - a `p`-adic element (type ``t_PADIC``)
 
     - a :class:`~sage.rings.infinity.Infinity` if ``z`` is an infinity
       (type ``t_INF``)

src/sage/matrix/matrix2.pyx

@@ -5841,9 +5841,9 @@ cdef class Matrix(Matrix1):
 
         INPUT:
 
-            - `M` -- a subspace of the free module ``self`` acts on
+            - ``M`` -- a subspace of the free module ``self`` acts on
             - ``check_restrict`` -- boolean (default: ``True``); call restrict
-              with or without check.
+              with or without check
             - ``kwds`` -- keywords that will be forwarded to :meth:`~.decomposition`
 
         EXAMPLES::

src/sage/misc/misc.py

@@ -1030,7 +1030,7 @@ def increase_recursion_limit(increment):
 
     INPUT:
 
-    - `increment` -- increment to add to the current limit
+    - ``increment`` -- increment to add to the current limit
 
     EXAMPLES::
 

src/sage/modular/modsym/ambient.py

@@ -1015,7 +1015,7 @@ def __heilbronn_operator(self, M, H, t=1):
 
         - ``M`` -- ModularSymbols; codomain (a space of modular symbols)
 
-        - ``H`` -- list; list of matrices in `M_2(\ZZ)`
+        - ``H`` -- list of matrices in `M_2(\ZZ)`
 
         - ``t`` -- integer (default: 1)
 
@@ -1499,9 +1499,7 @@ def rank(self):
         """
         Return the rank of this modular symbols ambient space.
 
-        OUTPUT:
-
-        (int) The rank of this space of modular symbols.
+        OUTPUT: integer; the rank of this space of modular symbols
 
         EXAMPLES::