Subsets of the Real Line

This module contains subsets of the real line that can be constructed as the union of a finite set of open and closed intervals.

EXAMPLES:

sage: RealSet(0,1)
(0, 1)
sage: RealSet((0,1), [2,3])
(0, 1) + [2, 3]
sage: RealSet(-oo, oo)
(-oo, +oo)

Brackets must be balanced in Python, so the naive notation for half-open intervals does not work:

sage: RealSet([0,1))
Traceback (most recent call last):
...
SyntaxError: ...

Instead, you can use the following construction functions:

sage: RealSet.open_closed(0,1)
(0, 1]
sage: RealSet.closed_open(0,1)
[0, 1)
sage: RealSet.point(1/2)
{1/2}
sage: RealSet.unbounded_below_open(0)
(-oo, 0)
sage: RealSet.unbounded_below_closed(0)
(-oo, 0]
sage: RealSet.unbounded_above_open(1)
(1, +oo)
sage: RealSet.unbounded_above_closed(1)
[1, +oo)

Relations containing symbols and numeric values or constants:

sage: RealSet(x != 0)
(-oo, 0) + (0, +oo)
sage: RealSet(x == pi)
{pi}
sage: RealSet(x < 1/2)
(-oo, 1/2)
sage: RealSet(1/2 < x)
(1/2, +oo)
sage: RealSet(1.5 <= x)
[1.50000000000000, +oo)

Note that multiple arguments are combined as union:

sage: RealSet(x >= 0, x < 1)
(-oo, +oo)
sage: RealSet(x >= 0, x > 1)
[0, +oo)
sage: RealSet(x >= 0, x > -1)
(-1, +oo)

AUTHORS:

• Laurent Claessens (2010-12-10): Interval and ContinuousSet, posted to sage-devel at http://www.mail-archive.com/sage-support@googlegroups.com/msg21326.html.

• Ares Ribo (2011-10-24): Extended the previous work defining the class RealSet.

• Jordi Saludes (2011-12-10): Documentation and file reorganization.

• Volker Braun (2013-06-22): Rewrite

class sage.sets.real_set.InternalRealInterval(lower, lower_closed, upper, upper_closed, check=True)

Bases: sage.structure.unique_representation.UniqueRepresentation, sage.structure.parent.Parent

A real interval.

You are not supposed to create RealInterval objects yourself. Always use RealSet instead.

INPUT:

• lower – real or minus infinity; the lower bound of the interval.

• lower_closed – boolean; whether the interval is closed at the lower bound

• upper – real or (plus) infinity; the upper bound of the interval

• upper_closed – boolean; whether the interval is closed at the upper bound

• check – boolean; whether to check the other arguments for validity

closure()

Return the closure

OUTPUT:

The closure as a new RealInterval

EXAMPLES:

sage: RealSet.open(0,1)[0].closure()
[0, 1]
sage: RealSet.open(-oo,1)[0].closure()
(-oo, 1]
sage: RealSet.open(0, oo)[0].closure()
[0, +oo)

contains(x)

Return whether \(x\) is contained in the interval

INPUT:

• x – a real number.

OUTPUT:

Boolean.

EXAMPLES:

sage: i = RealSet.open_closed(0,2)[0]; i
(0, 2]
sage: i.contains(0)
False
sage: i.contains(1)
True
sage: i.contains(2)
True

convex_hull(other)

Return the convex hull of the two intervals

OUTPUT:

The convex hull as a new RealInterval.

EXAMPLES:

sage: I1 = RealSet.open(0, 1)[0];  I1
(0, 1)
sage: I2 = RealSet.closed(1, 2)[0];  I2
[1, 2]
sage: I1.convex_hull(I2)
(0, 2]
sage: I2.convex_hull(I1)
(0, 2]
sage: I1.convex_hull(I2.interior())
(0, 2)
sage: I1.closure().convex_hull(I2.interior())
[0, 2)
sage: I1.closure().convex_hull(I2)
[0, 2]
sage: I3 = RealSet.closed(1/2, 3/2)[0]; I3
[1/2, 3/2]
sage: I1.convex_hull(I3)
(0, 3/2]

element_class

alias of sage.rings.real_lazy.LazyFieldElement

interior()

Return the interior

OUTPUT:

The interior as a new RealInterval

EXAMPLES:

sage: RealSet.closed(0, 1)[0].interior()
(0, 1)
sage: RealSet.open_closed(-oo, 1)[0].interior()
(-oo, 1)
sage: RealSet.closed_open(0, oo)[0].interior()
(0, +oo)

intersection(other)

Return the intersection of the two intervals

INPUT:

• other – a RealInterval

OUTPUT:

The intersection as a new RealInterval

EXAMPLES:

sage: I1 = RealSet.open(0, 2)[0];  I1
(0, 2)
sage: I2 = RealSet.closed(1, 3)[0];  I2
[1, 3]
sage: I1.intersection(I2)
[1, 2)
sage: I2.intersection(I1)
[1, 2)
sage: I1.closure().intersection(I2.interior())
(1, 2]
sage: I2.interior().intersection(I1.closure())
(1, 2]

sage: I3 = RealSet.closed(10, 11)[0];  I3
[10, 11]
sage: I1.intersection(I3)
(0, 0)
sage: I3.intersection(I1)
(0, 0)

is_connected(other)

Test whether two intervals are connected

OUTPUT:

Boolean. Whether the set-theoretic union of the two intervals has a single connected component.

EXAMPLES:

sage: I1 = RealSet.open(0, 1)[0];  I1
(0, 1)
sage: I2 = RealSet.closed(1, 2)[0];  I2
[1, 2]
sage: I1.is_connected(I2)
True
sage: I1.is_connected(I2.interior())
False
sage: I1.closure().is_connected(I2.interior())
True
sage: I2.is_connected(I1)
True
sage: I2.interior().is_connected(I1)
False
sage: I2.closure().is_connected(I1.interior())
True
sage: I3 = RealSet.closed(1/2, 3/2)[0]; I3
[1/2, 3/2]
sage: I1.is_connected(I3)
True
sage: I3.is_connected(I1)
True

is_empty()

Return whether the interval is empty

The normalized form of RealSet has all intervals non-empty, so this method usually returns False.

OUTPUT:

Boolean.

EXAMPLES:

sage: I = RealSet(0, 1)[0]
sage: I.is_empty()
False

is_point()

Return whether the interval consists of a single point

OUTPUT:

Boolean.

EXAMPLES:

sage: I = RealSet(0, 1)[0]
sage: I.is_point()
False

lower()

Return the lower bound

OUTPUT:

The lower bound as it was originally specified.

EXAMPLES:

sage: I = RealSet(0, 1)[0]
sage: I.lower()
0
sage: I.upper()
1

lower_closed()

Return whether the interval is open at the lower bound

OUTPUT:

Boolean.

EXAMPLES:

sage: I = RealSet.open_closed(0, 1)[0];  I
(0, 1]
sage: I.lower_closed()
False
sage: I.lower_open()
True
sage: I.upper_closed()
True
sage: I.upper_open()
False

lower_open()

Return whether the interval is closed at the upper bound

OUTPUT:

Boolean.

EXAMPLES:

sage: I = RealSet.open_closed(0, 1)[0];  I
(0, 1]
sage: I.lower_closed()
False
sage: I.lower_open()
True
sage: I.upper_closed()
True
sage: I.upper_open()
False

upper()

Return the upper bound

OUTPUT:

The upper bound as it was originally specified.

EXAMPLES:

sage: I = RealSet(0, 1)[0]
sage: I.lower()
0
sage: I.upper()
1

upper_closed()

Return whether the interval is closed at the lower bound

OUTPUT:

Boolean.

EXAMPLES:

sage: I = RealSet.open_closed(0, 1)[0];  I
(0, 1]
sage: I.lower_closed()
False
sage: I.lower_open()
True
sage: I.upper_closed()
True
sage: I.upper_open()
False

upper_open()

Return whether the interval is closed at the upper bound

OUTPUT:

Boolean.

EXAMPLES:

sage: I = RealSet.open_closed(0, 1)[0];  I
(0, 1]
sage: I.lower_closed()
False
sage: I.lower_open()
True
sage: I.upper_closed()
True
sage: I.upper_open()
False

class sage.sets.real_set.RealSet(*intervals)

Bases: sage.structure.unique_representation.UniqueRepresentation, sage.structure.parent.Parent

A subset of the real line

INPUT:

Arguments defining a real set. Possibilities are either two real numbers to construct an open set or a list/tuple/iterable of intervals. The individual intervals can be specified by either a RealInterval, a tuple of two real numbers (constructing an open interval), or a list of two number (constructing a closed interval).

EXAMPLES:

sage: RealSet(0,1)    # open set from two numbers
(0, 1)
sage: i = RealSet(0,1)[0]
sage: RealSet(i)      # interval
(0, 1)
sage: RealSet(i, (3,4))    # tuple of two numbers = open set
(0, 1) + (3, 4)
sage: RealSet(i, [3,4])    # list of two numbers = closed set
(0, 1) + [3, 4]

an_element()

Return a point of the set

OUTPUT:

A real number. ValueError if the set is empty.

EXAMPLES:

sage: RealSet.open_closed(0, 1).an_element()
1
sage: RealSet(0, 1).an_element()
1/2
sage: RealSet(-oo,+oo).an_element()
0
sage: RealSet(-oo,7).an_element()
6
sage: RealSet(7,+oo).an_element()
8

static are_pairwise_disjoint(*real_set_collection)

Test whether sets are pairwise disjoint

INPUT:

• *real_set_collection – a list/tuple/iterable of RealSet.

OUTPUT:

Boolean.

EXAMPLES:

sage: s1 = RealSet((0, 1), (2, 3))
sage: s2 = RealSet((1, 2))
sage: s3 = RealSet.point(3)
sage: RealSet.are_pairwise_disjoint(s1, s2, s3)
True
sage: RealSet.are_pairwise_disjoint(s1, s2, s3, [10,10])
True
sage: RealSet.are_pairwise_disjoint(s1, s2, s3, [-1, 1/2])
False

cardinality()

Return the cardinality of the subset of the real line.

OUTPUT:

Integer or infinity. The size of a discrete set is the number of points; the size of a real interval is Infinity.

EXAMPLES:

sage: RealSet([0, 0], [1, 1], [3, 3]).cardinality()
3
sage: RealSet(0,3).cardinality()
+Infinity

static closed(lower, upper)

Construct a closed interval

INPUT:

• lower, upper – two real numbers or infinity. They will be sorted if necessary.

OUTPUT:

A new RealSet.

EXAMPLES:

sage: RealSet.closed(1, 0)
[0, 1]

static closed_open(lower, upper)

Construct an half-open interval

INPUT:

• lower, upper – two real numbers or infinity. They will be sorted if necessary.

OUTPUT:

A new RealSet that is closed at the lower bound and open an the upper bound.

EXAMPLES:

sage: RealSet.closed_open(1, 0)
[0, 1)

complement()

Return the complement

OUTPUT:

The set-theoretic complement as a new RealSet.

EXAMPLES:

sage: RealSet(0,1).complement()
(-oo, 0] + [1, +oo)

sage: s1 = RealSet(0,2) + RealSet.unbounded_above_closed(10);  s1
(0, 2) + [10, +oo)
sage: s1.complement()
(-oo, 0] + [2, 10)

sage: s2 = RealSet(1,3) + RealSet.unbounded_below_closed(-10);  s2
(-oo, -10] + (1, 3)
sage: s2.complement()
(-10, 1] + [3, +oo)

contains(x)

Return whether \(x\) is contained in the set

INPUT:

• x – a real number.

OUTPUT:

Boolean.

EXAMPLES:

sage: s = RealSet(0,2) + RealSet.unbounded_above_closed(10);  s
(0, 2) + [10, +oo)
sage: s.contains(1)
True
sage: s.contains(0)
False
sage: 10 in s    # syntactic sugar
True

difference(*other)

Return self with other subtracted

INPUT:

• other – a RealSet or data that defines one.

OUTPUT:

The set-theoretic difference of self with other removed as a new RealSet.

EXAMPLES:

sage: s1 = RealSet(0,2) + RealSet.unbounded_above_closed(10);  s1
(0, 2) + [10, +oo)
sage: s2 = RealSet(1,3) + RealSet.unbounded_below_closed(-10);  s2
(-oo, -10] + (1, 3)
sage: s1.difference(s2)
(0, 1] + [10, +oo)
sage: s1 - s2    # syntactic sugar
(0, 1] + [10, +oo)
sage: s2.difference(s1)
(-oo, -10] + [2, 3)
sage: s2 - s1    # syntactic sugar
(-oo, -10] + [2, 3)
sage: s1.difference(1,11)
(0, 1] + [11, +oo)

get_interval(i)

Return the i-th connected component.

Note that the intervals representing the real set are always normalized, see normalize().

INPUT:

• i – integer.

OUTPUT:

The \(i\)-th connected component as a RealInterval.

EXAMPLES:

sage: s = RealSet(RealSet.open_closed(0,1), RealSet.closed_open(2,3))
sage: s.get_interval(0)
(0, 1]
sage: s[0]    # shorthand
(0, 1]
sage: s.get_interval(1)
[2, 3)
sage: s[0] == s.get_interval(0)
True

inf()

Return the infimum

OUTPUT:

A real number or infinity.

EXAMPLES:

sage: s1 = RealSet(0,2) + RealSet.unbounded_above_closed(10);  s1
(0, 2) + [10, +oo)
sage: s1.inf()
0

sage: s2 = RealSet(1,3) + RealSet.unbounded_below_closed(-10);  s2
(-oo, -10] + (1, 3)
sage: s2.inf()
-Infinity

intersection(*other)

Return the intersection of the two sets

INPUT:

• other – a RealSet or data that defines one.

OUTPUT:

The set-theoretic intersection as a new RealSet.

EXAMPLES:

sage: s1 = RealSet(0,2) + RealSet.unbounded_above_closed(10);  s1
(0, 2) + [10, +oo)
sage: s2 = RealSet(1,3) + RealSet.unbounded_below_closed(-10);  s2
(-oo, -10] + (1, 3)
sage: s1.intersection(s2)
(1, 2)
sage: s1 & s2    # syntactic sugar
(1, 2)

sage: s1 = RealSet((0, 1), (2, 3));  s1
(0, 1) + (2, 3)
sage: s2 = RealSet([0, 1], [2, 3]);  s2
[0, 1] + [2, 3]
sage: s3 = RealSet([1, 2]);  s3
[1, 2]
sage: s1.intersection(s2)
(0, 1) + (2, 3)
sage: s1.intersection(s3)
{}
sage: s2.intersection(s3)
{1} + {2}

is_disjoint_from(*other)

Test whether the two sets are disjoint

INPUT:

• other – a RealSet or data defining one.

OUTPUT:

Boolean.

EXAMPLES:

sage: s1 = RealSet((0, 1), (2, 3));  s1
(0, 1) + (2, 3)
sage: s2 = RealSet([1, 2]);  s2
[1, 2]
sage: s1.is_disjoint_from(s2)
True
sage: s1.is_disjoint_from([1, 2])
True

is_empty()

Return whether the set is empty

EXAMPLES:

sage: RealSet(0, 1).is_empty()
False
sage: RealSet(0, 0).is_empty()
True

is_included_in(*other)

Tests interval inclusion

INPUT:

• *args – a RealSet or something that defines one.

OUTPUT:

Boolean.

EXAMPLES:

sage: I = RealSet((1,2))
sage: J = RealSet((1,3))
sage: K = RealSet((2,3))
sage: I.is_included_in(J)
True
sage: J.is_included_in(K)
False

n_components()

Return the number of connected components

See also get_interval()

EXAMPLES:

sage: s = RealSet(RealSet.open_closed(0,1), RealSet.closed_open(2,3))
sage: s.n_components()
2

static normalize(intervals)

Bring a collection of intervals into canonical form

INPUT:

• intervals – a list/tuple/iterable of intervals.

OUTPUT:

A tuple of intervals such that

• they are sorted in ascending order (by lower bound)

• there is a gap between each interval

• all intervals are non-empty

EXAMPLES:

sage: i1 = RealSet((0, 1))[0]
sage: i2 = RealSet([1, 2])[0]
sage: i3 = RealSet((2, 3))[0]
sage: RealSet.normalize([i1, i2, i3])
((0, 3),)

sage: RealSet((0, 1), [1, 2], (2, 3))
(0, 3)
sage: RealSet((0, 1), (1, 2), (2, 3))
(0, 1) + (1, 2) + (2, 3)
sage: RealSet([0, 1], [2, 3])
[0, 1] + [2, 3]
sage: RealSet((0, 2), (1, 3))
(0, 3)
sage: RealSet(0,0)
{}

static open(lower, upper)

Construct an open interval

INPUT:

• lower, upper – two real numbers or infinity. They will be sorted if necessary.

OUTPUT:

A new RealSet.

EXAMPLES:

sage: RealSet.open(1, 0)
(0, 1)

static open_closed(lower, upper)

Construct a half-open interval

INPUT:

• lower, upper – two real numbers or infinity. They will be sorted if necessary.

OUTPUT:

A new RealSet that is open at the lower bound and closed at the upper bound.

EXAMPLES:

sage: RealSet.open_closed(1, 0)
(0, 1]

static point(p)

Construct an interval containing a single point

INPUT:

• p – a real number.

OUTPUT:

A new RealSet.

EXAMPLES:

sage: RealSet.open(1, 0)
(0, 1)

sup()

Return the supremum

OUTPUT:

A real number or infinity.

EXAMPLES:

sage: s1 = RealSet(0,2) + RealSet.unbounded_above_closed(10);  s1
(0, 2) + [10, +oo)
sage: s1.sup()
+Infinity

sage: s2 = RealSet(1,3) + RealSet.unbounded_below_closed(-10);  s2
(-oo, -10] + (1, 3)
sage: s2.sup()
3

static unbounded_above_closed(bound)

Construct a semi-infinite interval

INPUT:

• bound – a real number.

OUTPUT:

A new RealSet from the bound (including) to plus infinity.

EXAMPLES:

sage: RealSet.unbounded_above_closed(1)
[1, +oo)

static unbounded_above_open(bound)

Construct a semi-infinite interval

INPUT:

• bound – a real number.

OUTPUT:

A new RealSet from the bound (excluding) to plus infinity.

EXAMPLES:

sage: RealSet.unbounded_above_open(1)
(1, +oo)

static unbounded_below_closed(bound)

Construct a semi-infinite interval

INPUT:

• bound – a real number.

OUTPUT:

A new RealSet from minus infinity to the bound (including).

EXAMPLES:

sage: RealSet.unbounded_below_closed(1)
(-oo, 1]

static unbounded_below_open(bound)

Construct a semi-infinite interval

INPUT:

• bound – a real number.

OUTPUT:

A new RealSet from minus infinity to the bound (excluding).

EXAMPLES:

sage: RealSet.unbounded_below_open(1)
(-oo, 1)

union(*other)

Return the union of the two sets

INPUT:

• other – a RealSet or data that defines one.

OUTPUT:

The set-theoretic union as a new RealSet.

EXAMPLES:

sage: s1 = RealSet(0,2)
sage: s2 = RealSet(1,3)
sage: s1.union(s2)
(0, 3)
sage: s1.union(1,3)
(0, 3)
sage: s1 | s2    # syntactic sugar
(0, 3)
sage: s1 + s2    # syntactic sugar
(0, 3)