### Navigation

- index
- modules |
- next |
- previous |
- General Rings, Ideals, and Morphisms »

# Infinity Rings

The unsigned infinity “ring” is the set of two elements

1. infinity
2. A number less than infinity

The rules for arithmetic are that the unsigned infinity ring does not canonically coerce to any other ring, and all other rings canonically coerce to the unsigned infinity ring, sending all elements to the single element “a number less than infinity” of the unsigned infinity ring. Arithmetic and comparisons then take place in the unsigned infinity ring, where all arithmetic operations that are well-defined are defined.

The infinity “ring” is the set of five elements

1. plus infinity
2. a positive finite element
3. zero
4. a negative finite element
5. negative infinity

The infinity ring coerces to the unsigned infinity ring, sending the infinite elements to infinity and the non-infinite elements to “a number less than infinity.” Any ordered ring coerces to the infinity ring in the obvious way.

Note

The shorthand `oo` is predefined in Sage to be the same as `+Infinity` in the infinity ring. It is considered equal to, but not the same as `Infinity` in the `UnsignedInfinityRing`.

EXAMPLES:

We fetch the unsigned infinity ring and create some elements:

    sage: P = UnsignedInfinityRing; P
    The Unsigned Infinity Ring
    sage: P(5)
    A number less than infinity
    sage: P.ngens()
    1
    sage: unsigned_oo = P.0; unsigned_oo
    Infinity

We compare finite numbers with infinity:

    sage: 5 < unsigned_oo
    True
    sage: 5 > unsigned_oo
    False
    sage: unsigned_oo < 5
    False
    sage: unsigned_oo > 5
    True

Demonstrating the shorthand `oo` versus `Infinity`:

    sage: oo
    +Infinity
    sage: oo is InfinityRing.0
    True
    sage: oo is UnsignedInfinityRing.0
    False
    sage: oo == UnsignedInfinityRing.0
    True

We do arithmetic:

    sage: unsigned_oo + 5
    Infinity

We make `1 / unsigned_oo` return the integer 0 so that arithmetic of the following type works:

    sage: (1/unsigned_oo) + 2
    2
    sage: 32/5 - (2.439/unsigned_oo)
    32/5

Note that many operations are not defined, since the result is not well-defined:

    sage: unsigned_oo/0
    Traceback (most recent call last):
    ...
    ValueError: unsigned oo times smaller number not defined

What happened above is that 0 is canonically coerced to “a number less than infinity” in the unsigned infinity ring, and the quotient is then not well-defined.

    sage: 0/unsigned_oo
    0
    sage: unsigned_oo * 0
    Traceback (most recent call last):
    ...
    ValueError: unsigned oo times smaller number not defined
    sage: unsigned_oo/unsigned_oo
    Traceback (most recent call last):
    ...
    ValueError: unsigned oo times smaller number not defined

In the infinity ring, we can negate infinity, multiply positive numbers by infinity, etc.

    sage: P = InfinityRing; P
    The Infinity Ring
    sage: P(5)
    A positive finite number

The symbol `oo` is predefined as a shorthand for `+Infinity`:

    sage: oo
    +Infinity

We compare finite and infinite elements:

    sage: 5 < oo
    True
    sage: P(-5) < P(5)
    True
    sage: P(2) < P(3)
    False
    sage: -oo < oo
    True

We can do more arithmetic than in the unsigned infinity ring:

    sage: 2 * oo
    +Infinity
    sage: -2 * oo
    -Infinity
    sage: 1 - oo
    -Infinity
    sage: 1 / oo
    0
    sage: -1 / oo
    0

We make `1 / oo` and `1 / -oo` return the integer 0 instead of the infinity ring Zero so that arithmetic of the following type works:

    sage: (1/oo) + 2
    2
    sage: 32/5 - (2.439/-oo)
    32/5

If we try to subtract infinities or multiply infinity by zero we still get an error:

    sage: oo - oo
    Traceback (most recent call last):
    ...
    SignError: cannot add infinity to minus infinity
    sage: 0 * oo
    Traceback (most recent call last):
    ...
    SignError: cannot multiply infinity by zero
    sage: P(2) + P(-3)
    Traceback (most recent call last):
    ...
    SignError: cannot add positive finite value to negative finite value

Signed infinity can also be represented by RR / RDF elements. But unsigned infinity cannot:

    sage: oo in RR, oo in RDF
    (True, True)
    sage: unsigned_infinity in RR, unsigned_infinity in RDF
    (False, False)

TESTS:

    sage: P = InfinityRing
    sage: P == loads(dumps(P))
    True

    sage: P(2) == loads(dumps(P(2)))
    True

The following is assumed in a lot of code (i.e., “is” is used for testing whether something is infinity), so make sure it is satisfied:

    sage: loads(dumps(infinity)) is infinity
    True

class `sage.rings.infinity.``AnInfinity`

  Bases: `object`

  x.__init__(...) initializes x; see help(type(x)) for signature

  `lcm`(x)

    Return the least common multiple of `oo` and `x`, which is by definition oo unless `x` is 0.

    EXAMPLES:

        sage: oo.lcm(0)
        0
        sage: oo.lcm(oo)
        +Infinity
        sage: oo.lcm(-oo)
        +Infinity
        sage: oo.lcm(10)
        +Infinity
        sage: (-oo).lcm(10)
        +Infinity

class `sage.rings.infinity.``FiniteNumber`(parent, x)

  Bases: `sage.structure.element.RingElement`

  Initialize `self`.

  TESTS:

      sage: sage.rings.infinity.FiniteNumber(InfinityRing, 1)
      A positive finite number
      sage: sage.rings.infinity.FiniteNumber(InfinityRing, -1)
      A negative finite number
      sage: sage.rings.infinity.FiniteNumber(InfinityRing, 0)
      Zero

  `sqrt`()

    EXAMPLES:

        sage: InfinityRing(7).sqrt()
        A positive finite number
        sage: InfinityRing(0).sqrt()
        Zero
        sage: InfinityRing(-.001).sqrt()
        Traceback (most recent call last):
        ...
        SignError: cannot take square root of a negative number

class `sage.rings.infinity.``InfinityRing_class`

  Bases: `sage.rings.infinity._uniq`, `sage.rings.ring.Ring`

  Initialize `self`.

  TEST:

      sage: sage.rings.infinity.InfinityRing_class() is sage.rings.infinity.InfinityRing_class() is InfinityRing
      True

  `fraction_field`()

    This isn’t really a ring, let alone an integral domain.

    TEST:

        sage: InfinityRing.fraction_field()
        Traceback (most recent call last):
        ...
        TypeError: infinity 'ring' has no fraction field

  `gen`(n=0)

    The two generators are plus and minus infinity.

    EXAMPLES:

        sage: InfinityRing.gen(0)
        +Infinity
        sage: InfinityRing.gen(1)
        -Infinity
        sage: InfinityRing.gen(2)
        Traceback (most recent call last):
        ...
        IndexError: n must be 0 or 1

  `gens`()

    The two generators are plus and minus infinity.

    EXAMPLES:

        sage: InfinityRing.gens()
        [+Infinity, -Infinity]

  `ngens`()

    The two generators are plus and minus infinity.

    EXAMPLES:

        sage: InfinityRing.ngens()
        2
        sage: len(InfinityRing.gens())
        2

class `sage.rings.infinity.``LessThanInfinity`(parent=The Unsigned Infinity Ring)

  Bases: `sage.rings.infinity._uniq`, `sage.structure.element.RingElement`

  Initialize `self`.

  EXAMPLES:

      sage: sage.rings.infinity.LessThanInfinity() is UnsignedInfinityRing(5)
      True

class `sage.rings.infinity.``MinusInfinity`

  Bases: `sage.rings.infinity._uniq`, `sage.rings.infinity.AnInfinity`, `sage.structure.element.MinusInfinityElement`

  Initialize `self`.

  TESTS:

      sage: sage.rings.infinity.MinusInfinity() is sage.rings.infinity.MinusInfinity() is -oo
      True

  `sqrt`()

    EXAMPLES:

        sage: (-oo).sqrt()
        Traceback (most recent call last):
        ...
        SignError: cannot take square root of negative infinity

class `sage.rings.infinity.``PlusInfinity`

  Bases: `sage.rings.infinity._uniq`, `sage.rings.infinity.AnInfinity`, `sage.structure.element.PlusInfinityElement`

  Initialize `self`.

  TESTS:

      sage: sage.rings.infinity.PlusInfinity() is sage.rings.infinity.PlusInfinity() is oo
      True

  `sqrt`()

    The square root of `self`.

    The square root of infinity is infinity.

    EXAMPLES:

        sage: oo.sqrt()
        +Infinity

exception `sage.rings.infinity.``SignError`

  Bases: `exceptions.ArithmeticError`

  Sign error exception.

class `sage.rings.infinity.``UnsignedInfinity`

  Bases: `sage.rings.infinity._uniq`, `sage.rings.infinity.AnInfinity`, `sage.structure.element.InfinityElement`

  Initialize `self`.

  TESTS:

      sage: sage.rings.infinity.UnsignedInfinity() is sage.rings.infinity.UnsignedInfinity() is unsigned_infinity
      True

class `sage.rings.infinity.``UnsignedInfinityRing_class`

  Bases: `sage.rings.infinity._uniq`, `sage.rings.ring.Ring`

  Initialize `self`.

  TESTS:

      sage: sage.rings.infinity.UnsignedInfinityRing_class() is sage.rings.infinity.UnsignedInfinityRing_class() is UnsignedInfinityRing
      True

  `fraction_field`()

    The unsigned infinity ring isn’t an integral domain.

    EXAMPLES:

        sage: UnsignedInfinityRing.fraction_field()
        Traceback (most recent call last):
        ...
        TypeError: infinity 'ring' has no fraction field

  `gen`(n=0)

    The “generator” of `self` is the infinity object.

    EXAMPLES:

        sage: UnsignedInfinityRing.gen()
        Infinity
        sage: UnsignedInfinityRing.gen(1)
        Traceback (most recent call last):
        ...
        IndexError: UnsignedInfinityRing only has one generator

  `gens`()

    The “generator” of `self` is the infinity object.

    EXAMPLES:

        sage: UnsignedInfinityRing.gens()
        [Infinity]

  `less_than_infinity`()

    This is the element that represents a finite value.

    EXAMPLES:

        sage: UnsignedInfinityRing.less_than_infinity()
        A number less than infinity
        sage: UnsignedInfinityRing(5) is UnsignedInfinityRing.less_than_infinity()
        True

  `ngens`()

    The unsigned infinity ring has one “generator.”

    EXAMPLES:

        sage: UnsignedInfinityRing.ngens()
        1
        sage: len(UnsignedInfinityRing.gens())
        1

`sage.rings.infinity.``is_Infinite`(x)

  This is a type check for infinity elements.

  EXAMPLES:

      sage: sage.rings.infinity.is_Infinite(oo)
      True
      sage: sage.rings.infinity.is_Infinite(-oo)
      True
      sage: sage.rings.infinity.is_Infinite(unsigned_infinity)
      True
      sage: sage.rings.infinity.is_Infinite(3)
      False
      sage: sage.rings.infinity.is_Infinite(RR(infinity))
      False
      sage: sage.rings.infinity.is_Infinite(ZZ)
      False

`sage.rings.infinity.``test_comparison`(ring)

  Check comparison with infinity

  INPUT:

  - `ring` – a sub-ring of the real numbers

  OUTPUT:

  Various attempts are made to generate elements of `ring`. An assertion is triggered if one of these elements does not compare correctly with plus/minus infinity.

  EXAMPLES:

      sage: from sage.rings.infinity import test_comparison
      sage: rings = [ZZ, QQ, RR, RealField(200), RDF, RLF, AA, RIF]
      sage: for R in rings:
      ....:     print('testing {}'.format(R))
      ....:     test_comparison(R)
      testing Integer Ring
      testing Rational Field
      testing Real Field with 53 bits of precision
      testing Real Field with 200 bits of precision
      testing Real Double Field
      testing Real Lazy Field
      testing Algebraic Real Field
      testing Real Interval Field with 53 bits of precision

  Comparison with number fields does not work:

      sage: K.<sqrt3> = NumberField(x^2-3)
      sage: (-oo < 1+sqrt3) and (1+sqrt3 < oo)     # known bug
      False

  The symbolic ring handles its own infinities, but answers `False` (meaning: cannot decide) already for some very elementary comparisons:

      sage: test_comparison(SR)      # known bug
      Traceback (most recent call last):
      ...
      AssertionError: testing -1000.0 in Symbolic Ring: id = ...

`sage.rings.infinity.``test_signed_infinity`(pos_inf)

  Test consistency of infinity representations.

  There are different possible representations of infinity in Sage. These are all consistent with the infinity ring, that is, compare with infinity in the expected way. See also trac ticket #14045

  INPUT:

  - `pos_inf` – a representation of positive infinity.

  OUTPUT:

  An assertion error is raised if the representation is not consistent with the infinity ring.

  Check that trac ticket #14045 is fixed:

      sage: InfinityRing(float('+inf'))
      +Infinity
      sage: InfinityRing(float('-inf'))
      -Infinity
      sage: oo > float('+inf')
      False
      sage: oo == float('+inf')
      True

  EXAMPLES:

      sage: from sage.rings.infinity import test_signed_infinity
      sage: for pos_inf in [oo, float('+inf'), RLF(oo), RIF(oo), SR(oo)]:
      ....:     test_signed_infinity(pos_inf)

### Navigation

- index
- modules |
- next |
- previous |
- General Rings, Ideals, and Morphisms »