Signed and Unsigned Infinities¶
The unsigned infinity “ring” is the set of two elements
 infinity
 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 welldefined are defined.
The infinity “ring” is the set of five elements
 plus infinity
 a positive finite element
 zero
 a negative finite element
 negative infinity
The infinity ring coerces to the unsigned infinity ring, sending the infinite elements to infinity and the noninfinite 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 welldefined:
sage: unsigned_oo/0
Traceback (most recent call last):
...
ValueError: quotient of number < oo by number < oo not defined
What happened above is that 0 is canonically coerced to “A number less than infinity” in the unsigned infinity ring. Next, Sage tries to divide by multiplying with its inverse. Finally, this inverse is not welldefined.
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)
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
We check that trac ticket #17990 is fixed:
sage: m = Matrix([Infinity])
sage: m.rows()
[(+Infinity)]

class
sage.rings.infinity.
AnInfinity
¶ Bases:
object

lcm
(x)¶ Return the least common multiple of
oo
andx
, which is by definition oo unlessx
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
.
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


sage.rings.infinity.
InfinityRing
= The Infinity Ring¶

class
sage.rings.infinity.
InfinityRing_class
¶ Bases:
sage.misc.fast_methods.Singleton
,sage.rings.ring.Ring
Initialize
self
.
fraction_field
()¶ This isn’t really a ring, let alone an integral domain.

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]

is_commutative
()¶ The Infinity Ring is commutative
EXAMPLES:
sage: InfinityRing.is_commutative() True

is_zero
()¶ The Infinity Ring is not zero
EXAMPLES:
sage: InfinityRing.is_zero() False

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.InfinityElement
Initialize
self
.
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.InfinityElement
Initialize
self
.
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
.

sage.rings.infinity.
UnsignedInfinityRing
= The Unsigned Infinity Ring¶

class
sage.rings.infinity.
UnsignedInfinityRing_class
¶ Bases:
sage.misc.fast_methods.Singleton
,sage.rings.ring.Ring
Initialize
self
.
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 subring 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^23) 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)