adding some links for Errors in the doc

Author: fchapoton

src/sage/combinat/binary_recurrence_sequences.py

@@ -539,7 +539,7 @@ def pthpowers(self, p, Bound):
             [1]
 
         If the sequence is degenerate, and there are no ``p`` th powers, returns `[]`.  Otherwise, if
-        there are many ``p`` th powers, raises ``ValueError``.
+        there are many ``p`` th powers, raises :class:`ValueError`.
 
         ::
 

src/sage/combinat/cartesian_product.py

@@ -190,7 +190,7 @@ def __len__(self):
 
         An ``int``, the number of elements in the Cartesian product. If the
         number of elements is infinite or does not fit into a python ``int``, a
-        ``TypeError`` is raised.
+        :class:`TypeError` is raised.
 
         .. SEEALSO::
 

src/sage/combinat/dyck_word.py

@@ -124,7 +124,7 @@ def replace_parens(x):
     - If ``x`` is a closing parenthesis, replace ``x`` with the
       constant ``close_symbol``.
 
-    - Raise a ``ValueError`` if ``x`` is neither an opening nor a
+    - Raise a :class:`ValueError` if ``x`` is neither an opening nor a
       closing parenthesis.
 
     .. SEEALSO:: :func:`replace_symbols`
@@ -168,7 +168,7 @@ def replace_symbols(x):
     - If ``x`` is ``close_symbol``, replace ``x`` with ``')'``.
 
     - If ``x`` is neither ``open_symbol`` nor ``close_symbol``, a
-      ``ValueError`` is raised.
+      :class:`ValueError` is raised.
 
     .. SEEALSO:: :func:`replace_parens`
 

src/sage/combinat/free_module.py

@@ -699,7 +699,8 @@ def _element_constructor_(self, x):
 
         The following originally used to yield ``p[[2]] # p[[2]]``, and if
         there was no natural coercion between ``s`` and ``p``, this would
-        raise a ``NotImplementedError``. Since :trac:`15305`, this takes the
+        raise a :class:`NotImplementedError`.
+        Since :trac:`15305`, this takes the
         coercion between ``s`` and ``p`` and lifts it to the tensor product. ::
 
             sage: pp(a)                                                                 # optional - sage.combinat

src/sage/combinat/fully_commutative_elements.py

@@ -800,7 +800,7 @@ class FullyCommutativeElements(UniqueRepresentation, Parent):
         True
 
     Attempting to create an element from an input that is not the reduced word
-    of a fully commutative element throws a ``ValueError``::
+    of a fully commutative element throws a :class:`ValueError`::
 
         sage: FC([1,2,1])
         Traceback (most recent call last):

src/sage/combinat/integer_lists/invlex.pyx

@@ -862,7 +862,7 @@ If you know what you are doing, you can set check=False to skip this warning."""
 
         ``None`` if this method finds a proof that there
         exists an upper bound on the length. Otherwise a
-        ``ValueError`` is raised.
+        :class:`ValueError` is raised.
 
         EXAMPLES::
 

src/sage/combinat/nu_dyck_word.py

@@ -94,7 +94,7 @@ def replace_dyck_char(x):
     - If ``x`` is a closing character, replace ``x`` with the
       constant ``ndw_close_symbol``.
 
-    - Raise a ``ValueError`` if ``x`` is neither an opening nor a
+    - Raise a :class:`ValueError` if ``x`` is neither an opening nor a
       closing character.
 
     .. SEEALSO:: :func:`replace_dyck_symbol`
@@ -142,7 +142,7 @@ def replace_dyck_symbol(x, open_char='N', close_char='E') -> str:
     - If ``x`` is ``ndw_close_symbol``, replace ``x`` with ``close_char``.
 
     - If ``x`` is neither ``ndw_open_symbol`` nor ``ndw_close_symbol``, a
-      ``ValueError`` is raised.
+      :class:`ValueError` is raised.
 
     .. SEEALSO:: :func:`replace_dyck_char`
 

src/sage/combinat/perfect_matching.py

@@ -130,7 +130,7 @@ def __classcall_private__(cls, parts):
         The function checks that the given list or permutation is
         a valid perfect matching (i.e. a list of pairs with pairwise
         disjoint elements or a fix point free involution) and raises
-        a ``ValueError`` otherwise::
+        a :class:`ValueError` otherwise::
 
             sage: PerfectMatching([(1, 2, 3), (4, 5)])
             Traceback (most recent call last):

src/sage/combinat/ranker.py

@@ -72,7 +72,7 @@ def rank_from_list(l):
         sage: r('c')
         2
 
-    For non elements a ``ValueError`` is raised, as with the usual
+    For non elements a :class:`ValueError` is raised, as with the usual
     ``index`` method of lists::
 
         sage: r('blah')

src/sage/combinat/root_system/associahedron.py

@@ -337,7 +337,7 @@ class Associahedra_base():
 
     Importantly, the parent knows the dimension of the ambient
     space. If you try to construct an associahedron of a different
-    dimension, a ``ValueError`` is raised::
+    dimension, a :class:`ValueError` is raised::
 
         sage: parent(['A',3])
         Traceback (most recent call last):