many single-backticks should be double-backticks

src/sage/categories/bialgebras_with_basis.py

@@ -402,7 +402,7 @@ def convolution_product(self, *maps):
 
             for mor in T[:-1]:
                 # ALGORITHM:
-                # `split_convolve` moves terms of the form x # y to x*Ti(y1) # y2 in Sweedler notation.
+                # ``split_convolve`` moves terms of the form x # y to x*Ti(y1) # y2 in Sweedler notation.
                 def split_convolve(x_y):
                     x, y = x_y
                     return (((xy1, y2), c * d)

src/sage/categories/category_types.py

@@ -458,7 +458,7 @@ def _subcategory_hook_(self, C):
             ....:            VectorSpaces(GF(3)).parent_class)
             True
 
-        Check that :issue:`16618` is fixed: this `_subcategory_hook_`
+        Check that :issue:`16618` is fixed: this ``_subcategory_hook_``
         method is only valid for :class:`Category_over_base_ring`, not
         :class:`Category_over_base`::
 

src/sage/categories/rings.py

@@ -621,8 +621,8 @@ def _mul_(self, x, switch_sides=False):
 
             INPUT:
 
-            - `x`, an object to multiply with.
-            - `switch_sides` (optional bool): If ``False``,
+            - ``x``, an object to multiply with.
+            - ``switch_sides`` (optional bool): If ``False``,
               the product is ``self*x``; if ``True``, the
               product is ``x*self``.
 

src/sage/coding/abstract_code.py

@@ -324,9 +324,9 @@ def __iter__(self):
         r"""
         Return an error message requiring to override ``__iter__`` in ``self``.
 
-        As one has to implement specific category related methods (`__iter__` and
-        `__contains__`) when writing a new code class which inherits from
-        :class:`AbstractCode`, the generic call to `__iter__` has to fail.
+        As one has to implement specific category related methods (``__iter__`` and
+        ``__contains__``) when writing a new code class which inherits from
+        :class:`AbstractCode`, the generic call to ``__iter__`` has to fail.
 
         EXAMPLES:
 
@@ -352,9 +352,9 @@ def __contains__(self, c):
         r"""
         Return an error message requiring to override ``__contains__`` in ``self``.
 
-        As one has to implement specific category related methods (`__iter__` and
-        `__contains__`) when writing a new code class which inherits from
-        :class:`AbstractCode`, the generic call to `__contains__` has to fail.
+        As one has to implement specific category related methods (``__iter__`` and
+        ``__contains__``) when writing a new code class which inherits from
+        :class:`AbstractCode`, the generic call to ``__contains__`` has to fail.
 
         EXAMPLES:
 
@@ -448,9 +448,9 @@ def _repr_(self):
         r"""
         Return an error message requiring to override ``_repr_`` in ``self``.
 
-        As one has to implement specific representation methods (`_repr_` and
-        `_latex_`) when writing a new code class which inherits from
-        :class:`AbstractCode`, the generic call to `_repr_` has to fail.
+        As one has to implement specific representation methods (``_repr_`` and
+        ``_latex_``) when writing a new code class which inherits from
+        :class:`AbstractCode`, the generic call to ``_repr_`` has to fail.
 
         EXAMPLES:
 
@@ -476,9 +476,9 @@ def _latex_(self):
         r"""
         Return an error message requiring to override ``_latex_`` in ``self``.
 
-        As one has to implement specific representation methods (`_repr_` and
-        `_latex_`) when writing a new code class which inherits from
-        :class:`AbstractCode`, the generic call to `_latex_` has to fail.
+        As one has to implement specific representation methods (``_repr_`` and
+        ``_latex_``) when writing a new code class which inherits from
+        :class:`AbstractCode`, the generic call to ``_latex_`` has to fail.
 
         EXAMPLES:
 

src/sage/coding/guruswami_sudan/gs_decoder.py

@@ -389,7 +389,7 @@ def get_tau(s, l):
         # Either s or l is set, but not both. First a shared local function
         def find_integral_max(real_max, f):
             """Given a real (local) maximum of a function `f`, return that of
-            the integers around `real_max` which gives the (local) integral
+            the integers around ``real_max`` which gives the (local) integral
             maximum, and the value of at that point."""
             if real_max in ZZ:
                 int_max = ZZ(real_max)

src/sage/combinat/abstract_tree.py

@@ -1857,7 +1857,7 @@ def __setitem__(self, idx, value):
             The tree ``self`` must be in a mutable state. See
             :mod:`sage.structure.list_clone` for more details about
             mutability.  The default implementation here assume that the
-            container of the node implement a method `_setitem` with signature
+            container of the node implement a method ``_setitem`` with signature
             `self._setitem(idx, value)`. It is usually provided by inheriting
             from :class:`~sage.structure.list_clone.ClonableArray`.
 

src/sage/combinat/crystals/pbw_datum.pyx

@@ -167,7 +167,7 @@ class PBWDatum():
     def star(self):
         """
         Return the starred version of ``self``, i.e.,
-        with reversed `long_word` and `lusztig_datum`
+        with reversed ``long_word`` and ``lusztig_datum``
 
         EXAMPLES::
 

src/sage/combinat/crystals/spins.pyx

@@ -65,7 +65,7 @@ def CrystalOfSpins(ct):
     Return the spin crystal of the given type `B`.
 
     This is a combinatorial model for the crystal with highest weight
-    `Lambda_n` (the `n`-th fundamental weight). It has
+    `\Lambda_n` (the `n`-th fundamental weight). It has
     `2^n` elements, here called Spins. See also
     :func:`~sage.combinat.crystals.letters.CrystalOfLetters`,
     :func:`~sage.combinat.crystals.spins.CrystalOfSpinsPlus`,
@@ -108,7 +108,7 @@ def CrystalOfSpinsPlus(ct):
     r"""
     Return the plus spin crystal of the given type D.
 
-    This is the crystal with highest weight `Lambda_n` (the
+    This is the crystal with highest weight `\Lambda_n` (the
     `n`-th fundamental weight).
 
     INPUT:
@@ -141,7 +141,7 @@ def CrystalOfSpinsMinus(ct):
     r"""
     Return the minus spin crystal of the given type D.
 
-    This is the crystal with highest weight `Lambda_{n-1}`
+    This is the crystal with highest weight `\Lambda_{n-1}`
     (the `(n-1)`-st fundamental weight).
 
     INPUT:

src/sage/combinat/designs/evenly_distributed_sets.pyx

@@ -408,7 +408,7 @@ cdef class EvenlyDistributedSetsBacktracker:
         whether the set `f_{ij}(B)` is smaller than `B`.
 
         This is an internal function and should only be call by the backtracker
-        implemented in the method `__iter__`.
+        implemented in the method ``__iter__``.
 
         OUTPUT: ``False`` if ``self.B`` is not minimal
 

src/sage/combinat/matrices/dancing_links.pyx

@@ -154,7 +154,7 @@ cdef class dancing_linksWrapper:
         Initialization of the search algorithm.
 
         This adds the rows to the instance of dancing_links. This method is
-        used by `__init__` and `reinitialize` methods and should not be
+        used by ``__init__`` and ``reinitialize`` methods and should not be
         used directly.
 
         EXAMPLES::

src/sage/combinat/multiset_partition_into_sets_ordered.py

@@ -1885,7 +1885,7 @@ def __iter__(self):
             # iterate over blocks of letters over an alphabet
             if "alphabet" in self.constraints:
                 A = self.constraints["alphabet"]
-                # establish a cutoff order `max_ell`
+                # establish a cutoff order ``max_ell``
                 max = self.constraints.get("max_length", infinity)
                 max = self.constraints.get("length", max)
                 max = max * len(A)

src/sage/combinat/permutation_cython.pyx

@@ -74,7 +74,7 @@ cdef int next_swap(int n, int *c, int *o) noexcept:
     Note, Knuth's descriptions of algorithms tend to encourage
     one to think of finite state machines.  For convenience,
     we have added comments to show what state the machine is
-    in at any given point in the algorithm. `plain_swap_reset`
+    in at any given point in the algorithm. ``plain_swap_reset``
     sets the state to 1, and this function begins and ends in
     state 2.
 

src/sage/combinat/posets/posets.py

@@ -794,7 +794,7 @@ class FinitePoset(UniqueRepresentation, Parent):
       corresponding to vertex ``i``. If ``elements`` is ``None``, then it is
       set to be the vertex set of the digraph. Note that if this option is set,
       then ``elements`` is considered as a specified linear extension of the poset
-      and the `linear_extension` attribute is set.
+      and the ``linear_extension`` attribute is set.
 
     - ``category`` -- :class:`FinitePosets`, or a subcategory thereof
 

src/sage/combinat/root_system/type_reducible.py

@@ -90,7 +90,7 @@ def __init__(self, types):
              ((1, 0), 5), ((1, 1), 6), ((1, 2), 7), ((1, 3), 8), ((1, 4), 9), ((1, 5), 10),
              ((2, 1), 11), ((2, 2), 12), ((2, 3), 13)]
 
-        Similarly, the attribute `_shifts` specifies by how much the
+        Similarly, the attribute ``_shifts`` specifies by how much the
         indices of the bases of the ambient spaces of the components
         are shifted in the ambient space of this Cartan type::
 

src/sage/combinat/tableau.py

@@ -5841,7 +5841,7 @@ class SemistandardTableaux(Tableaux):
     OUTPUT:
 
     - The appropriate class, after checking basic consistency tests. (For
-      example, specifying ``eval`` implies a value for `max_entry`).
+      example, specifying ``eval`` implies a value for ``max_entry``).
 
     A semistandard tableau is a tableau whose entries are positive integers,
     which are weakly increasing in rows and strictly increasing down columns.

src/sage/crypto/key_exchange/diffie_hellman.py

@@ -254,7 +254,7 @@ def subgroup_size(self) -> Integer:
     def __len__(self) -> int:
         """
         Calculates the size of the subgroup of `\\GF{p}` generated by
-        ``self.generator()``. This is a wrapper around `subgroup_size`.
+        ``self.generator()``. This is a wrapper around ``subgroup_size``.
 
         TESTS::
 

src/sage/databases/cubic_hecke_db.py

@@ -729,7 +729,7 @@ def __init__(self, num_strands):
 
     def _warn_incompatibility(self, fname):
         """
-        Warn the user that he has an incomaptible file cache under `Sage_DOT`
+        Warn the user that he has an incomaptible file cache under ``Sage_DOT``
         and move it away to another file (marked with timestamp).
 
         EXAMPLES::

src/sage/dynamics/arithmetic_dynamics/projective_ds.py

@@ -6837,10 +6837,10 @@
 
         INPUT:
 
-        `return_conjugation`` -- (default: ``False``) if ``True``, then
+        ``return_conjugation`` -- (default: ``False``) if ``True``, then
         return the conjugation that moves self to a map that comes from a
         Short Weierstrass Model Elliptic curve
-        `check_lattes``.-.(default:.``False``) if ``True``, then  will ValueError if not Lattes
+        ``check_lattes``.-.(default:.``False``) if ``True``, then  will ValueError if not Lattes
 
         OUTPUT: a Short Weierstrass Model Elliptic curve which is isogenous to
         the Elliptic curve of 'self',
@@ -6964,7 +6964,7 @@
             sage: P.<x,y>=ProjectiveSpace(QQbar, 1)
             sage: E=EllipticCurve([1, 2])
             sage: f=P.Lattes_map(E, 2)
             sage: f.Lattes_to_curve(check_lattes=true)
             Elliptic Curve defined by y^2 = x^3 + x + 2 over Rational Field
 
         """

src/sage/features/databases.py

@@ -25,7 +25,7 @@
 
 def sage_data_path(data_name):
     r"""
-    Search path for database `data_name`.
+    Search path for database ``data_name``.
 
     EXAMPLES::
 

src/sage/game_theory/normal_form_game.py

@@ -1989,7 +1989,7 @@ def _solve_enumeration(self, maximization=True):
             sage: c._solve_enumeration()
             [[(0, 1), (1, 0)]]
 
-        Testing against an error in `_is_NE`.  Note that 1 equilibrium is
+        Testing against an error in ``_is_NE``.  Note that 1 equilibrium is
         missing: ``[(2/3, 1/3), (0, 1)]``, however this equilibrium has
         supports of different sizes. This only occurs in degenerate games
         and is not supported in the `enumeration` algorithm::

src/sage/geometry/polyhedron/base_number_field.py

@@ -28,7 +28,7 @@
 
 def _number_field_elements_from_algebraics_list_of_lists_of_lists(listss, **kwds):
     r"""
-    Like `number_field_elements_from_algebraics`, but for a list of lists of lists.
+    Like ``number_field_elements_from_algebraics``, but for a list of lists of lists.
 
     EXAMPLES::
 

src/sage/graphs/base/c_graph.pyx

@@ -2824,7 +2824,7 @@ cdef class CGraphBackend(GenericGraphBackend):
 
             # WARNING
             # If you modify this, you must keep in mind the documentation in the
-            # corresponding method in `generic_graph.py` in the method `edge_iterator`.
+            # corresponding method in ``generic_graph.py`` in the method ``edge_iterator``.
             # E.g. code assumes that you can use an iterator to relabel or delete arcs.
 
             u_int = cg._next_neighbor_unsafe(v_int, -1, out, &l_int)

src/sage/graphs/base/sparse_graph.pyx

@@ -1569,7 +1569,7 @@ cdef class SparseGraphBackend(CGraphBackend):
 
             # WARNING
             # If you modify this, you must keep in mind the documentation in the
-            # corresponding method in `generic_graph.py` in the method `edge_iterator`.
+            # corresponding method in ``generic_graph.py`` in the method ``edge_iterator``.
             # E.g. code assumes that you can use an iterator to relabel or delete arcs.
 
             r = self._cg._neighbors_BTNode_unsafe(v_int, out, neighbors, maxdegree)

src/sage/graphs/centrality.pyx

@@ -131,7 +131,7 @@ cdef dict centrality_betweenness_C(G, numerical_type _, bint normalize=True):
     - ``G`` -- a graph
 
     - ``_`` -- this variable is ignored, only its type matters. If it is of type
-      `mpq_t` then computations are made on `Q`, if it is ``double`` the
+      ``mpq_t`` then computations are made on `Q`, if it is ``double`` the
       computations are made on ``double``.
 
     - ``normalize`` -- boolean (default: ``True``); whether to renormalize the

src/sage/graphs/graph_decompositions/tree_decomposition.pyx

@@ -75,7 +75,7 @@ The treewidth of a clique is `n-1` and its treelength is 1::
 
     :meth:`treewidth` | Compute the treewidth of `G` (and provide a decomposition).
     :meth:`treelength` | Compute the treelength of `G` (and provide a decomposition).
-    :meth:`make_nice_tree_decomposition` | Return a *nice* tree decomposition (TD) of the TD `tree_decomp`.
+    :meth:`make_nice_tree_decomposition` | Return a *nice* tree decomposition (TD) of the TD ``tree_decomp``.
     :meth:`label_nice_tree_decomposition` | Return a nice tree decomposition with nodes labelled accordingly.
     :meth:`is_valid_tree_decomposition` | Check whether `T` is a valid tree-decomposition for `G`.
     :meth:`reduced_tree_decomposition` | Return a reduced tree-decomposition of `T`.
@@ -830,7 +830,7 @@ def make_nice_tree_decomposition(graph, tree_decomp):
 
     .. WARNING::
 
-        This method assumes that the vertices of the input tree `tree_decomp`
+        This method assumes that the vertices of the input tree ``tree_decomp``
         are hashable and have attribute ``issuperset``, e.g., ``frozenset`` or
         :class:`~sage.sets.set.Set_object_enumerated_with_category`.
 

src/sage/groups/cubic_braid.py

@@ -371,7 +371,7 @@ def burau_matrix(self, root_bur=None, domain=None, characteristic=None,
         - ``root_bur`` -- six (resp. twelfth) root of unity in some field
           (default: root of unity over `\QQ`)
         - ``domain`` -- (default: cyclotomic field of order 3 and degree 2, resp.
-          the domain of `root_bur` if given) base ring for the Burau matrix
+          the domain of ``root_bur`` if given) base ring for the Burau matrix
         - ``characteristic`` -- integer giving the characteristic of the
           domain (default: 0 or the characteristic of ``domain`` if given)
         - ``var`` -- string used for the indeterminate name in case ``root_bur``

src/sage/interfaces/interface.py

@@ -880,7 +880,7 @@ def _reduce(self):
 
         Special care has to be taken with strings. Since for example `r("abc")` will be
         interpreted as the R-command abc (not a string in R), we have to reduce to
-        `"'abc'"` instead. That is dependant on the Elements `is_string` function to
+        `"'abc'"` instead. That is dependant on the Elements ``is_string`` function to
         be implemented correctly. This has gone wrong in the past and remained uncaught
         by the doctests because the original identifier was reused. This test makes sure
         that does not happen again::

src/sage/interfaces/mathematica.py

@@ -454,7 +454,7 @@ def clean_output(s):
 
 def _un_camel(name):
     """
-    Convert `CamelCase` to `camel_case`.
+    Convert ``CamelCase`` to ``camel_case``.
 
     EXAMPLES::
 

src/sage/interfaces/mathics.py

@@ -402,7 +402,7 @@ def _mathics_sympysage_symbol(self):
 
     This function replaces ``_sympysage_symbol`` to
     take care of the special names used in Mathics.
-    It is set to the method `_sage_` of the Sympy class
+    It is set to the method ``_sage_`` of the Sympy class
     :class:`sympy.core.symbol.Sympol`.
 
     EXAMPLES::

src/sage/interfaces/maxima_lib.py

@@ -35,7 +35,7 @@
 classical Maxima Pexpect interface in case no new implementation has been made.
 
 This interface is the one used for calculus by Sage
-and is accessible as `maxima_calculus`::
+and is accessible as ``maxima_calculus``::
 
     sage: maxima_calculus
     Maxima_lib
@@ -80,8 +80,8 @@
 TESTS:
 
 Check our workaround for a race in ecl works, see :issue:`26968`.
-We use a temporary `MAXIMA_USERDIR` so it's empty; we place it
-in `DOT_SAGE` since we expect it to have more latency than `/tmp`.
+We use a temporary ``MAXIMA_USERDIR`` so it's empty; we place it
+in ``DOT_SAGE`` since we expect it to have more latency than ``/tmp``.
 
     sage: import tempfile, subprocess
     sage: tmpdir = tempfile.TemporaryDirectory(dir=DOT_SAGE)

src/sage/matrix/matrix2.pyx

@@ -3056,7 +3056,7 @@ cdef class Matrix(Matrix1):
 
         ALGORITHM:
 
-        If the base ring has a method `_matrix_charpoly`, we use it.
+        If the base ring has a method ``_matrix_charpoly``, we use it.
 
         In the generic case of matrices over a ring (commutative and with
         unity), there is a division-free algorithm, which can be accessed

src/sage/matrix/matrix_double_dense.pyx

@@ -2396,8 +2396,8 @@ cdef class Matrix_double_dense(Matrix_numpy_dense):
         r"""
         Return ``True`` if the matrix is (skew-)Hermitian.
 
-        For internal purposes. This function is used in `is_hermitian`
-        and `is_skew_hermitian` functions.
+        For internal purposes. This function is used in ``is_hermitian``
+        and ``is_skew_hermitian`` functions.
 
         INPUT:
 

src/sage/misc/cachefunc.pyx

@@ -1462,7 +1462,7 @@ class CachedMethodPickle():
         we replace the actual cached method by a place holder,
         that kills itself as soon as any attribute is requested.
         Then, the original cached attribute is reinstated. But the
-        cached values are in fact saved (if `do_pickle` is set.)
+        cached values are in fact saved (if ``do_pickle`` is set.)
 
     EXAMPLES::
 

src/sage/misc/persist.pyx

@@ -57,7 +57,7 @@ from sage.misc.sage_unittest import TestSuite
 # Apart from this, you are free to use these variables as you like.
 #
 # However, the standard utilisation is the following.
-# The pickling method (namely `__reduce__`) checks if the id of the
+# The pickling method (namely ``__reduce__``) checks if the id of the
 # current element appears in the dictionary `already_pickled`. If it
 # does not, the methods records that this element is about to be
 # pickled by adding the entry { id: True } to `already_pickled`.