### Navigation

- index
- modules |
- next |
- previous |
- Basic Structures »

# 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: invalid syntax

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)

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.``RealInterval`(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 keyword argument. Whether to check the other arguments for validity.

  EXAMPLES:

      sage: RealSet([0, oo])
      Traceback (most recent call last):
      ...
      ValueError: interval cannot be closed at +oo

  `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 `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

  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)

### Navigation

- index
- modules |
- next |
- previous |
- Basic Structures »