some cross-references btw doc of RR, RBF, ...

(mainly intended to make RBF and CBF, which are the most powerful
implementations for most purposes, more discoverable)

src/sage/rings/complex_arb.pyx

@@ -336,6 +336,13 @@ class ComplexBallField(UniqueRepresentation, sage.rings.abc.ComplexBallField):
 
         sage: loads(dumps(ComplexBallField(60))) is ComplexBallField(60)
         True
+
+    .. SEEALSO::
+
+    - :mod:`sage.rings.complex_arb`
+    - :mod:`sage.rings.complex_mpfr`
+    - :mod:`sage.rings.complex_mpfi`
+    - :mod:`sage.rings.real_arb`
     """
     Element = ComplexBall
 

src/sage/rings/complex_interval_field.py

@@ -171,6 +171,12 @@ class ComplexIntervalField_class(sage.rings.abc.ComplexIntervalField):
 
         sage: CIF.is_finite()
         False
+
+    .. SEEALSO::
+
+    - :mod:`sage.rings.real_mpfi`
+    - :class:`sage.rings.complex_arb.ComplexBallField` (alternative implementation of
+      complex intervals, with more features)
     """
     Element = complex_interval.ComplexIntervalFieldElement
 

src/sage/rings/complex_mpfr.pyx

@@ -176,6 +176,12 @@ def ComplexField(prec=53, names=None):
         sage: i = ComplexField(200).gen()
         sage: i^2
         -1.0000000000000000000000000000000000000000000000000000000000
+
+    .. SEEALSO::
+
+    - :class:`~sage.rings.complex_mpfr.ComplexField_class`
+    - :class:`~sage.rings.real_arb.ComplexBallField` (complex numbers with
+      rigorous error bounds)
     """
     global cache
     if prec in cache:
@@ -261,6 +267,13 @@ class ComplexField_class(sage.rings.abc.ComplexField):
         False
         sage: CC == 1.1
         False
+
+    .. SEEALSO::
+
+    - :func:`~sage.rings.complex_mpfr.ComplexField` (constructor)
+    - :class:`~sage.rings.real_arb.ComplexBallField` (complex numbers with
+      rigorous error bounds)
+    - :mod:`~sage.rings.real_mpfr`
     """
     def __init__(self, prec=53):
         """

src/sage/rings/real_arb.pyx

@@ -368,6 +368,14 @@ class RealBallField(UniqueRepresentation, sage.rings.abc.RealBallField):
 
         sage: loads(dumps(RealBallField(60))) is RealBallField(60)
         True
+
+    .. SEEALSO::
+
+    - :mod:`sage.rings.real_arb`
+    - :mod:`sage.rings.real_mpfr`
+    - :mod:`sage.rings.real_mpfi` (real intervals represented by their
+      endpoints)
+    - :mod:`sage.rings.complex_arb`
     """
     Element = RealBall
 

src/sage/rings/real_mpfi.pyx

@@ -511,6 +511,13 @@ cdef class RealIntervalField_class(sage.rings.abc.RealIntervalField):
 
         sage: RealIntervalField(10).is_finite()
         False
+
+    .. SEEALSO::
+
+    - :mod:`sage.rings.real_mpfi`
+    - :mod:`sage.rings.complex_interval_field`
+    - :class:`sage.rings.real_arb.RealBallField` (alternative implementation of
+      real intervals, with more features)
     """
     Element = RealIntervalFieldElement
 

src/sage/rings/real_mpfr.pyx

@@ -427,6 +427,12 @@ cpdef RealField(mpfr_prec_t prec=53, int sci_not=0, rnd=MPFR_RNDN) noexcept:
        computations with double-precision machine floating-point
        numbers (double type in C), except the default exponent range
        is much wider and subnormal numbers are not implemented.'
+
+    .. SEEALSO::
+
+    - :mod:`sage.rings.real_mpfr`
+    - :class:`sage.rings.real_arb.RealBallField` (real numbers with rigorous
+      error bounds)
     """
     # We allow specifying the rounding mode as string or integer.
     # But we pass an integer to __init__
@@ -457,8 +463,12 @@ cdef class RealField_class(sage.rings.abc.RealField):
     numbers. This is due to the rounding errors inherent to finite
     precision calculations.
 
-    See the documentation for the module :mod:`sage.rings.real_mpfr` for more
-    details.
+    .. SEEALSO::
+
+    - :mod:`sage.rings.real_mpfr`
+    - :class:`sage.rings.real_arb.RealBallField` (real numbers with rigorous
+      error bounds)
+    - :mod:`sage.rings.complex_mpfr`
     """
     def __init__(self, mpfr_prec_t prec=53, int sci_not=0, long rnd=MPFR_RNDN):
         """