Ticket #1275: 7427-for-review.patch

a/sage/calculus/calculus.py

@@ -2830 +2830 @@
-    def _recursive_sub_over_ring(self, kwds, ring):
-        return ring(self)
-    
+    def _algebraic_(self, field):
+        """
+        EXAMPLES:
+            sage: a = SR(5/6)
+            sage: AA(a)
+            5/6
+            sage: type(AA(a))
+            <class 'sage.rings.algebraic_real.AlgebraicReal'>
+            sage: QQbar(a)
+            5/6
+            sage: type(QQbar(a))
+            <class 'sage.rings.algebraic_real.AlgebraicNumber'>
+            sage: from sage.calculus.calculus import SymbolicConstant
+            sage: i = SymbolicConstant(I)
+            sage: AA(i)
+            Traceback (most recent call last):
+            ...    
+            TypeError: Cannot coerce algebraic number with non-zero imaginary part to algebraic real
+            sage: QQbar(i)
+            1*I
+            sage: phi = SymbolicConstant(golden_ratio)
+            sage: AA(phi)
+            [1.6180339887498946 .. 1.6180339887498950]
+            sage: QQbar(phi)
+            [1.6180339887498946 .. 1.6180339887498950]
+        """
+
+        # Out of the many kinds of things that can be in a SymbolicConstant,
+        # we accept only rational numbers (or things that can be coerced
+        # to rational) and a few instances of Constant.
+
+        if isinstance(self._obj, sage.functions.constants.Constant) \
+               and hasattr(self._obj, '_algebraic_'):
+            return self._obj._algebraic_(field)
+        return field(Rational(self._obj))
-
-
-class SymbolicPolynomial(Symbolic_object):
@@ -3073 +3108 @@
-        rops = [op._real_rqdf_(field) for op in self._operands]
-        return self._operator(*rops)
-
+    def _algebraic_(self, field):
+        """
+        Convert a symbolic expression to an algebraic number.
+
+        EXAMPLES:
+            sage: QQbar(sqrt(2) + sqrt(8))
+            [4.2426406871192847 .. 4.2426406871192857]
+            sage: AA(sqrt(2) ^ 4) == 4
+            True
+            sage: AA(-golden_ratio)
+            [-1.6180339887498950 .. -1.6180339887498946]
+            sage: QQbar((2*I)^(1/2))
+            [1.0000000000000000 .. 1.0000000000000000] + [1.0000000000000000 .. 1.0000000000000000]*I
+        """
+
+        # We try to avoid simplifying, because maxima's simplify command
+        # can change the value of a radical expression (by changing which
+        # root is selected).
+        try:
+            if self._operator is operator.pow:
+                base = field(self._operands[0])
+                expt = Rational(self._operands[1])
+                return field(field(base) ** expt)
+            else:
+                rops = [field(op) for op in self._operands]
+                return self._operator(*rops)
+        except TypeError:
+            if self.is_simplified():
+                raise
+            else:
+                return self.simplify()._algebraic_(field)
+
-    def _is_atomic(self):
-        try:
-            return self._atomic
@@ -4011 +4078 @@
-        else:
-            return z
-
+    def _algebraic_(self, field):
+        """
+        Coerce to an algebraic number.
+
+        EXAMPLES:
+            sage: QQbar(sqrt(2))
+            [1.4142135623730949 .. 1.4142135623730952]
+            sage: AA(abs(1+I))
+            [1.4142135623730949 .. 1.4142135623730952]
+        """
+        # We try to avoid simplifying, because maxima's simplify command
+        # can change the value of a radical expression (by changing which
+        # root is selected).
+        f = self._operands[0]
+        g = self._operands[1]
+        try:
+            return field(f(g._algebraic_(field)))
+        except TypeError:
+            if self.is_simplified():
+                raise
+            else:
+                return self.simplify()._algebraic_(field)
+        
+
-class PrimitiveFunction(SymbolicExpression):
-    def __init__(self, needs_braces=False):
-        SymbolicExpression.__init__(self)

a/sage/functions/constants.py

@@ -537 +537 @@
-    def _real_double_(self, R):
-        raise TypeError        
-
+    def _algebraic_(self, field):
+        import sage.rings.algebraic_real
+        return field(sage.rings.algebraic_real.QQbar_I)
+
-    def __abs__(self):
-        return Integer(1)
-
@@ -691 +695 @@
-    
-    def _mpfr_(self,R):  #is this OK for _mpfr_ ?
-        return (R(1)+R(5).sqrt())*R(0.5)
+
+    def _algebraic_(self, field):
+        import sage.rings.algebraic_real
+        return field(sage.rings.algebraic_real.get_AA_golden_ratio())
-
-golden_ratio = GoldenRatio()
-    

a/sage/rings/algebraic_real.py

@@ -1 +1 @@
-"""
-Real
+Number
-
-AUTHOR:
-    -- Carl Witty (2007-01-27): initial version
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-Algebraic numbers exist in one of the following forms:
-
-* a rational number
+* the product of a rational number and an n'th root of unity
-* the sum, difference, product, or quotient of algebraic numbers
+* the negation, inverse, absolute value, norm, real part, 
+imaginary part, or complex conjugate of an algebraic number
-* a particular root of a polynomial, given as a polynomial with
-algebraic coefficients, an isolating interval (given as a 
-RealIntervalFieldElement) which encloses exactly one root, and
@@ -22 +36 @@
-number given as the root of an irreducible polynomial with integral
-coefficients and the polynomial is given as a NumberFieldElement
-
-
-
+
+
+
+
+
+
+
+
+
-
-Everything is done with intervals except for comparisons.  By default,
-comparisons compute the two algebraic numbers with 128-bit precision
@@ -44 +65 @@
-EXAMPLES:
-    sage: sqrt(AA(2)) > 0
-    True
-
+
+
+
-    True
-
-For a monic cubic polynomial x^3 + b*x^2 + c*x + d with roots
@@ -82 +105 @@
-    sage: disc1(b, c, d) == disc2(s1, s2, s3)
-    True
-
+We can coerce from symbolic expressions:
+
+    sage: QQbar(sqrt(-5))
+    [2.2360679774997893 .. 2.2360679774997899]*I
+    sage: AA(sqrt(2) + sqrt(3))
+    [3.1462643699419721 .. 3.1462643699419726]
+    sage: AA(sqrt(2)) + sqrt(3)
+    [3.1462643699419721 .. 3.1462643699419726]
+    sage: sqrt(2) + QQbar(sqrt(3))
+    [3.1462643699419721 .. 3.1462643699419726]
+    sage: QQbar(I)
+    1*I
+    sage: AA(I)
+    Traceback (most recent call last):
+    ...
+    TypeError: Cannot coerce algebraic number with non-zero imaginary part to algebraic real
+    sage: QQbar(I * golden_ratio)
+    [1.6180339887498946 .. 1.6180339887498950]*I
+    sage: AA(golden_ratio)^2 - AA(golden_ratio)
+    1
+    sage: QQbar((-8)^(1/3))
+    [0.99999999999999988 .. 1.0000000000000003] + [1.7320508075688771 .. 1.7320508075688775]*I
+    sage: AA((-8)^(1/3))
+    -2
+    sage: QQbar((-4)^(1/4))
+    [1.0000000000000000 .. 1.0000000000000000] + [1.0000000000000000 .. 1.0000000000000000]*I
+    sage: AA((-4)^(1/4))
+    Traceback (most recent call last):
+    ...
+    TypeError: Cannot coerce algebraic number with non-zero imaginary part to algebraic real
+
+We can explicitly coerce from QQ[I].  (Technically, this is not quite
+kosher, since QQ[I] doesn't come with an embedding; we don't know
+whether the field generator is supposed to map to +I or -I.  We assume
+that for any quadratic field with polynomial x^2+1, the generator maps
+to +I.)
+
+    sage: K.<im> = QQ[I]
+    sage: pythag = QQbar(3/5 + 4*im/5); pythag
+    4/5*I + 3/5
+    sage: pythag.abs() == 1
+    True
+
+However, implicit coercion from QQ[I] is not allowed.
+
+    sage: QQbar(1) + im
+    Traceback (most recent call last):
+    ...
+    TypeError: unsupported operand parent(s) for '+': 'Algebraic Field' and 'Number Field in I with defining polynomial x^2 + 1'
+
+We can implicitly coerce from algebraic reals to algebraic numbers:
+
+    sage: a = QQbar(1); print a, a.parent()
+    1 Algebraic Field
+    sage: b = AA(1); print b, b.parent()
+    1 Algebraic Real Field
+    sage: c = a + b; print c, c.parent()
+    2 Algebraic Field
+
-Some computation with radicals:
-
-    sage: phi = (1 + sqrt(AA(5))) / 2
@@ -101 +183 @@
-    sage: rt23 * rt35 == rt25
-    True
-
-reals which are known to be rational print as rationals; otherwise
-
+numbers which are known to be rational print as rationals;
+otherwise 
-
-    sage: AA(2)/3
-    2/3
-AA
+QQbar
-    5/7
-
+
+
+
-    [1.9999999999999997 .. 2.0000000000000005]
-    sage: two == 2; two
-    True
@@ -116 +200 @@
-    sage: phi
-    [1.6180339887498946 .. 1.6180339887498950]
-
+We can find the real and imaginary parts of an algebraic number (exactly).
+
+    sage: r = QQbar.polynomial_root(x^5 - x - 1, CIF(RIF(0.1, 0.2), RIF(1.0, 1.1))); r
+    [0.18123244446987538 .. 0.18123244446987541] + [1.0839541013177105 .. 1.0839541013177108]*I
+    sage: r.real()
+    [0.18123244446987538 .. 0.18123244446987541]
+    sage: r.imag()
+    [1.0839541013177105 .. 1.0839541013177108]
+    sage: r.minpoly()
+    x^5 - x - 1
+    sage: r.real().minpoly()
+    x^10 + 3/16*x^6 + 11/32*x^5 - 1/64*x^2 + 1/128*x - 1/1024
+    sage: r.imag().minpoly() # this takes a long time (143s on my laptop)
+    x^20 - 5/8*x^16 - 95/256*x^12 - 625/1024*x^10 - 5/512*x^8 - 1875/8192*x^6 + 25/4096*x^4 - 625/32768*x^2 + 2869/1048576
+
+We can find the absolute value and norm of an algebraic number exactly.
+(Note that we define the norm as the product of a number and its
+complex conjugate; this is the algebraic definition of norm, if we
+view QQbar as AA[I].)
+
+    sage: r = QQbar((-8)^(1/3)); r
+    [0.99999999999999988 .. 1.0000000000000003] + [1.7320508075688771 .. 1.7320508075688775]*I
+    sage: r.abs() == 2
+    True
+    sage: r.norm() == 4
+    True    
+    sage: (r+I).norm().minpoly()
+    x^2 - 10*x + 13
+    sage: r = AA.polynomial_root(x^2 - x - 1, RIF(-1, 0)); r
+    [-0.61803398874989491 .. -0.61803398874989479]
+    sage: r.abs().minpoly()
+    x^2 + x - 1
+
+We can compute the multiplicative order of an algebraic number.
+
+    sage: QQbar(-1/2 + I*sqrt(3)/2).multiplicative_order()
+    3
+    sage: QQbar(-sqrt(3)/2 + I/2).multiplicative_order()
+    12
+    sage: QQbar.zeta(12345).multiplicative_order()
+    12345
+
+Cyclotomic fields are very fast as long as we only multiply and divide:
+
+    sage: z3_3 = QQbar.zeta(3) * 3
+    sage: z4_4 = QQbar.zeta(4) * 4
+    sage: z5_5 = QQbar.zeta(5) * 5
+    sage: z6_6 = QQbar.zeta(6) * 6
+    sage: z20_20 = QQbar.zeta(20) * 20
+    sage: z3_3 * z4_4 * z5_5 * z6_6 * z20_20
+    7200
+
+And they're still pretty fast even if you add and subtract, and trigger
+exact computation:
+
+    sage: (z3_3 + z4_4 + z5_5 + z6_6 + z20_20)._exact_value()
+    4*zeta60^15 + 5*zeta60^12 + 9*zeta60^10 + 20*zeta60^3 - 3 where a^16 + a^14 - a^10 - a^8 - a^6 + a^2 + 1 = 0 and a in [0.99452189536827328 .. 0.99452189536827341] + [0.10452846326765345 .. 0.10452846326765352]*I
+
-The paper _ARPREC: An Arbitrary Precision Computation Package_ discusses
-this result.  Evidently it is difficult to find, but we can easily
-verify it.
-
-AA
+QQbar
-    sage: lhs = alpha^630 - 1
-    sage: rhs_num = (alpha^315 - 1) * (alpha^210 - 1) * (alpha^126 - 1)^2 * (alpha^90 - 1) * (alpha^3 - 1)^3 * (alpha^2 - 1)^5 * (alpha - 1)^3
-    sage: rhs_den = (alpha^35 - 1) * (alpha^15 - 1)^2 * (alpha^14 - 1)^2 * (alpha^5 - 1)^6 * alpha^68
@@ -128 +270 @@
-    sage: lhs
-    [2.6420403358193507e44 .. 2.6420403358193520e44]
-    sage: rhs
-7
+3
-    sage: lhs - rhs
-63347712947806569000000000000. .. 65804250213263496
+79344219392947342000000000000. .. 81800756658404269
-    sage: lhs == rhs
-    True
-    sage: lhs - rhs
-[0.00000000000000000 .. 0.00000000000000000]
+0
-    sage: lhs._exact_value()
-    -242494609856316402264822833062350847769474540*a^9 + 862295472068289472491654837785947906234680703*a^8 - 829559238431038252116584538075753012193290520*a^7 - 125882239615006638366472766103700441555126185*a^6 + 1399067970863104691667276008776398309383579345*a^5 - 1561176687069361567616835847286958553574223422*a^4 + 761706318888840943058230840550737823821027895*a^3 + 580740464974951394762758666210754821723780266*a^2 - 954587496403409756503464154898858512440951323*a + 546081123623099782018260884934770383777092602 where a^10 - 4*a^9 + 5*a^8 - a^7 - 6*a^6 + 9*a^5 - 6*a^4 - a^3 + 5*a^2 - 4*a + 1 = 0 and a in [0.44406334400909258 .. 0.44406334400909265]
-"""
@@ -143 +285 @@
-from sage.structure.sage_object import SageObject
-from sage.structure.parent_gens import ParentWithGens
-from sage.rings.real_mpfr import RR
-
-
+
+
+
+
+
-from sage.rings.integer_ring import ZZ
-from sage.rings.rational_field import QQ
-
+, NumberField_quadratic, QuadraticField, CyclotomicField
-from sage.rings.number_field.number_field_element import is_NumberFieldElement
+from sage.rings.number_field.number_field_element_quadratic import NumberFieldElement_quadratic
-from sage.rings.arith import factor
-from sage.libs.pari.gen import pari
-from sage.structure.element import generic_power
+import infinity
+from sage.misc.functional import cyclotomic_polynomial
+
+CC = ComplexField()
+CIF = ComplexIntervalField()
-
-# Singleton object implementation copied from integer_ring.py
-_obj = None
@@ -162 +313 @@
-            _obj = sage.rings.ring.Field.__new__(cls)
-        return _obj
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    r"""
-    The field of algebraic reals.
-
-    """
-
-    def __init__(self):
-        ParentWithGens.__init__(self, self, ('x',), normalize=False)
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    # Is there a standard representation for this?
-    def _latex_(self):
-        return "\\mathbf{A}"
-
-    def __call__(self, x):
-        """
-        Coerce x into the field of algebraic numbers.
-
-        """
-
-        if isinstance(x, AlgebraicRealNumber):
-            return x
-        return AlgebraicRealNumber(x)
-
-    def _coerce_impl(self, x):
-        if isinstance(x, (int, long, sage.rings.integer.Integer,
-                          sage.rings.rational.Rational)):
-            return self(x)
+        elif hasattr(x, '_algebraic_'):
+            return x._algebraic_(AA)
-        raise TypeError, 'no implicit coercion of element to the algebraic numbers'
+
+    def has_coerce_map_from_impl(self, from_par):
+        if from_par == ZZ or from_par == QQ or from_par == int or from_par == long:
+            return True
+        late_import()
+        if is_SymbolicExpressionRing(from_par):
+            return True
+        return False
-
-    def _is_valid_homomorphism_(self, codomain, im_gens):
-        try:
@@ -201 +436 @@
-        except TypeError:
-            return False
-
-    def default_interval_field(self):
-        return self._default_interval_field
-
-    def gens(self):
-        return (self(1), )
-
@@ -216 +448 @@
-    def ngens(self):
-        return 1
-
-    def is_finite(self):
-        return False
-
-    def is_atomic_repr(self):
-        return True
-
-    def characteristic(self):
-        return sage.rings.integer.Integer(0)
-
-    def order(self):
-        return infinity.infinity
-
-    def zeta(self, n=2):
-        if n == 1:
@@ -235 +458 @@
-            return self(-1)
-        else:
-            raise ValueError, "no n-th root of unity in algebraic reals"
-
-    def common_polynomial(self, poly):
-        """
-        Given a polynomial with algebraic coefficients, returns a
-        wrapper that caches high-precision calculations and
-        factorizations.  This wrapper can be passed to polynomial_root
-        in place of the polynomial.
-
-        Using common_polynomial makes no semantic difference, but will
-        improve efficiency if you are dealing with multiple roots
-        of a single polynomial.
-
-        EXAMPLES:
-            sage: x = polygen(AA)
-            sage: p = AA.common_polynomial(x^2 - x - 1)
-            sage: phi = AA.polynomial_root(p, RIF(0, 2))
-            sage: tau = AA.polynomial_root(p, RIF(-2, 0))
-            sage: phi + tau == 1
-            True
-            sage: phi * tau == -1
-            True
-        """
-        return AlgebraicPolynomialTracker(poly)
-
-    def polynomial_root(self, poly, interval, multiplicity=1):
-        """
@@ -279 +479 @@
-        or wrong answers may result.
-
-        Note that if you are constructing multiple roots of a single
-
-
+
+
+
-
-        EXAMPLES:
-            sage: x = polygen(AA)
-0
+1
-            [1.6180339887498946 .. 1.6180339887498950]
-            sage: p = (x-1)^7 * (x-2)
-            sage: r = AA.polynomial_root(p, RIF(9/10, 11/10), multiplicity=7)
@@ -296 +497 @@
-            sage: r; r == sqrt(AA(2))
-            [1.4142135623730949 .. 1.4142135623730952]
-            True
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-def is_AlgebraicRealField(F):
-    return isinstance(F, AlgebraicRealField)
-
-AA = AlgebraicRealField()
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    # XXX Should do some testing to see where the efficiency breaks are
-
+
+
-    bits = 64
-    while True:
-RealIntervalField(bits)
+bits
-        bits = bits * 2
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-def clear_denominators(poly):
-    """
@@ -327 +696 @@
-
-    (Inspired by Pari's primitive_pol_to_monic().)
-
+    We assume that coefficient denominators are "small"; the algorithm
+    factors the denominators, to give the smallest possible scale factor.
+
-    EXAMPLES:
-        sage: from sage.rings.algebraic_real import clear_denominators
-
@@ -337 +709 @@
-        (2, x^2 + x + 1)
-
-    """
+
+    # This algorithm factors the polynomial denominators.
+    # We should check the size of the denominators and switch to
+    # an alternate, less precise algorithm if we decide factoring
+    # would be too slow.
-
-    d = poly.denominator()
-    if d == 1:
@@ -401 +778 @@
-
-    assert(best is not None)
-    parent = poly.parent()
-
+
+
-
-def isolating_interval(intv_fn, pol):
-    """
-RealIntervalField
-containing some particular root of pol.  (It must return
-better approximations as the RealIntervalField
+precision
+of that precision containing some particular root of pol.
+(It must return better approximations as the
-    pol is an irreducible polynomial with rational coefficients.
-
-    Returns an interval containing at most one root of pol.
@@ -416 +794 @@
-        sage: from sage.rings.algebraic_real import isolating_interval
-
-        sage: _.<x> = QQ['x']
-rif: sqrt(rif
+prec: sqrt(RealIntervalField(prec)
-        [1.41421356237309504876 .. 1.41421356237309504888]
-
-    And an example that requires more precision:
-        sage: delta = 10^(-70)
-        sage: p = (x - 1) * (x - 1 - delta) * (x - 1 + delta)
-rif: rif
+prec: RealIntervalField(prec)
-        [1.00000000000000000000000000000000000000000000000000000000000000000000009999999999999999999999999999999999999999999999999999999999999999999999999999999999998 .. 1.00000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000014]
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-
-        # We need to verify that pol has exactly one root in the
-        # interval intv.  We know (because it is a precondition of
@@ -434 +820 @@
-        # interval, so we only need to verify that it has at most one
-        # root (that the interval is sufficiently narrow).
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-            return intv
-
-def find_zero_result(fn, l):
-    """
-
-fn is a function which maps an element of l and a RealIntervalField
-into an interval, such that for a sufficiently precise RealIntervalField,
-xactly one element of l results in an interval containing 0.
-Returns that 
+  fn is a function which maps an element
+of l and a precision into an interval (either real or complex) of
+that precision, such that for sufficient precision, exactly one
+lement of l results in an interval containing 0.  Returns that
+
-
-    EXAMPLES:
-        sage: from sage.rings.algebraic_real import find_zero_result
@@ -502 +842 @@
-        sage: p1 = x - 1
-        sage: p2 = x - 1 - delta
-        sage: p3 = x - 1 + delta
-rif: p(rif
-
-
-rif in rif
+prec: p(RealIntervalField(prec)
+
+
+prec in prec
-        result = None
-        ambig = False
-        for v in l:
-rif
-0 in intv
+prec
+intv.contains_zero()
-                if result is not None:
-                    ambig = True
-                    break
@@ -520 +860 @@
-        if result is None:
-            raise ValueError, 'find_zero_result could not find any zeroes'
-        return result
+
+def conjugate_expand(v):
+    """
+    If the interval v (which may be real or complex) includes some
+    purely real numbers, return v' containing v such that
+    v' == v'.conjugate().  Otherwise return v unchanged.  (Note that if
+    v' == v'.conjugate(), and v' includes one non-real root of a real
+    polynomial, then v' also includes the conjugate of that root.
+    Also note that the diameter of the return value is at most twice
+    the diameter of the input.)
+
+    EXAMPLES:
+        sage: from sage.rings.algebraic_real import conjugate_expand
+        sage: conjugate_expand(CIF(RIF(0, 1), RIF(1, 2)))
+        [0.00000000000000000 .. 1.0000000000000000] + [1.0000000000000000 .. 2.0000000000000000]*I
+        sage: conjugate_expand(CIF(RIF(0, 1), RIF(0, 1)))
+        [0.00000000000000000 .. 1.0000000000000000] + [-1.0000000000000000 .. 1.0000000000000000]*I
+        sage: conjugate_expand(CIF(RIF(0, 1), RIF(-2, 1)))
+        [0.00000000000000000 .. 1.0000000000000000] + [-2.0000000000000000 .. 2.0000000000000000]*I
+        sage: conjugate_expand(RIF(1, 2))
+        [1.0000000000000000 .. 2.0000000000000000]
+    """
+    if is_RealIntervalFieldElement(v):
+        return v
+    im = v.imag()
+    if not im.contains_zero():
+        return v
+    re = v.real()
+    fld = ComplexIntervalField(v.prec())
+    return fld(re, im.union(-im))
+
+def conjugate_shrink(v):
+    """
+    If the interval v includes some purely real numbers, return
+    a real interval containing only those real numbers.  Otherwise
+    return v unchanged.
+
+    If v includes exactly one root of a real polynomial, and v was
+    returned by conjugate_expand(), then conjugate_shrink(v) still
+    includes that root, and is a RealIntervalFieldElement iff the root
+    in question is real.
+
+    EXAMPLES:
+        sage: from sage.rings.