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((1,3), (0,2))
(0, 3)
sage: RealSet(-oo, oo)
(-oo, +oo)
>>> from sage.all import *
>>> RealSet(Integer(0),Integer(1))
(0, 1)
>>> RealSet((Integer(0),Integer(1)), [Integer(2),Integer(3)])
(0, 1) ∪ [2, 3]
>>> RealSet((Integer(1),Integer(3)), (Integer(0),Integer(2)))
(0, 3)
>>> 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: ...
>>> from sage.all import *
>>> RealSet([Integer(0),Integer(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)
>>> from sage.all import *
>>> RealSet.open_closed(Integer(0),Integer(1))
(0, 1]
>>> RealSet.closed_open(Integer(0),Integer(1))
[0, 1)
>>> RealSet.point(Integer(1)/Integer(2))
{1/2}
>>> RealSet.unbounded_below_open(Integer(0))
(-oo, 0)
>>> RealSet.unbounded_below_closed(Integer(0))
(-oo, 0]
>>> RealSet.unbounded_above_open(Integer(1))
(1, +oo)
>>> RealSet.unbounded_above_closed(Integer(1))
[1, +oo)
The lower and upper endpoints will be sorted if necessary:
sage: RealSet.interval(1, 0, lower_closed=True, upper_closed=False)
[0, 1)
>>> from sage.all import *
>>> RealSet.interval(Integer(1), Integer(0), lower_closed=True, upper_closed=False)
[0, 1)
Relations containing symbols and numeric values or constants:
sage: # needs sage.symbolic
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)
>>> from sage.all import *
>>> # needs sage.symbolic
>>> RealSet(x != Integer(0))
(-oo, 0) ∪ (0, +oo)
>>> RealSet(x == pi)
{pi}
>>> RealSet(x < Integer(1)/Integer(2))
(-oo, 1/2)
>>> RealSet(Integer(1)/Integer(2) < x)
(1/2, +oo)
>>> RealSet(RealNumber('1.5') <= x)
[1.50000000000000, +oo)
Note that multiple arguments are combined as union:
sage: RealSet(x >= 0, x < 1)                                                        # needs sage.symbolic
(-oo, +oo)
sage: RealSet(x >= 0, x > 1)                                                        # needs sage.symbolic
[0, +oo)
sage: RealSet(x >= 0, x > -1)                                                       # needs sage.symbolic
(-1, +oo)
>>> from sage.all import *
>>> RealSet(x >= Integer(0), x < Integer(1))                                                        # needs sage.symbolic
(-oo, +oo)
>>> RealSet(x >= Integer(0), x > Integer(1))                                                        # needs sage.symbolic
[0, +oo)
>>> RealSet(x >= Integer(0), x > -Integer(1))                                                       # needs sage.symbolic
(-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 
- Yueqi Li, Yuan Zhou (2022-07-31): Rewrite RealSet. Adapt faster operations by scan-line (merging) techniques from the code by Matthias Köppe et al., at https://github.com/mkoeppe/cutgeneratingfunctionology/blob/master/cutgeneratingfunctionology/igp/intervals.py 
- class sage.sets.real_set.InternalRealInterval(lower, lower_closed, upper, upper_closed, check=True)[source]¶
- Bases: - UniqueRepresentation,- Parent- A real interval. - You are not supposed to create - InternalRealIntervalobjects yourself. Always use- RealSetinstead.- 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
 - boundary_points()[source]¶
- Generate the boundary points of - self.- EXAMPLES: - sage: list(RealSet.open_closed(-oo, 1)[0].boundary_points()) [1] sage: list(RealSet.open(1, 2)[0].boundary_points()) [1, 2] - >>> from sage.all import * >>> list(RealSet.open_closed(-oo, Integer(1))[Integer(0)].boundary_points()) [1] >>> list(RealSet.open(Integer(1), Integer(2))[Integer(0)].boundary_points()) [1, 2] 
 - closure()[source]¶
- Return the closure. - OUTPUT: the closure as a new - InternalRealInterval- 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) - >>> from sage.all import * >>> RealSet.open(Integer(0),Integer(1))[Integer(0)].closure() [0, 1] >>> RealSet.open(-oo,Integer(1))[Integer(0)].closure() (-oo, 1] >>> RealSet.open(Integer(0), oo)[Integer(0)].closure() [0, +oo) 
 - contains(x)[source]¶
- 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 - >>> from sage.all import * >>> i = RealSet.open_closed(Integer(0),Integer(2))[Integer(0)]; i (0, 2] >>> i.contains(Integer(0)) False >>> i.contains(Integer(1)) True >>> i.contains(Integer(2)) True 
 - convex_hull(other)[source]¶
- Return the convex hull of the two intervals. - OUTPUT: the convex hull as a new - InternalRealInterval- 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] - >>> from sage.all import * >>> I1 = RealSet.open(Integer(0), Integer(1))[Integer(0)]; I1 (0, 1) >>> I2 = RealSet.closed(Integer(1), Integer(2))[Integer(0)]; I2 [1, 2] >>> I1.convex_hull(I2) (0, 2] >>> I2.convex_hull(I1) (0, 2] >>> I1.convex_hull(I2.interior()) (0, 2) >>> I1.closure().convex_hull(I2.interior()) [0, 2) >>> I1.closure().convex_hull(I2) [0, 2] >>> I3 = RealSet.closed(Integer(1)/Integer(2), Integer(3)/Integer(2))[Integer(0)]; I3 [1/2, 3/2] >>> I1.convex_hull(I3) (0, 3/2] 
 - element_class[source]¶
- alias of - LazyFieldElement
 - interior()[source]¶
- Return the interior. - OUTPUT: the interior as a new - InternalRealInterval- 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) - >>> from sage.all import * >>> RealSet.closed(Integer(0), Integer(1))[Integer(0)].interior() (0, 1) >>> RealSet.open_closed(-oo, Integer(1))[Integer(0)].interior() (-oo, 1) >>> RealSet.closed_open(Integer(0), oo)[Integer(0)].interior() (0, +oo) 
 - intersection(other)[source]¶
- Return the intersection of the two intervals. - INPUT: - other– a- InternalRealInterval
 - OUTPUT: the intersection as a new - InternalRealInterval- 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) - >>> from sage.all import * >>> I1 = RealSet.open(Integer(0), Integer(2))[Integer(0)]; I1 (0, 2) >>> I2 = RealSet.closed(Integer(1), Integer(3))[Integer(0)]; I2 [1, 3] >>> I1.intersection(I2) [1, 2) >>> I2.intersection(I1) [1, 2) >>> I1.closure().intersection(I2.interior()) (1, 2] >>> I2.interior().intersection(I1.closure()) (1, 2] >>> I3 = RealSet.closed(Integer(10), Integer(11))[Integer(0)]; I3 [10, 11] >>> I1.intersection(I3) (0, 0) >>> I3.intersection(I1) (0, 0) 
 - is_connected(other)[source]¶
- 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 - >>> from sage.all import * >>> I1 = RealSet.open(Integer(0), Integer(1))[Integer(0)]; I1 (0, 1) >>> I2 = RealSet.closed(Integer(1), Integer(2))[Integer(0)]; I2 [1, 2] >>> I1.is_connected(I2) True >>> I1.is_connected(I2.interior()) False >>> I1.closure().is_connected(I2.interior()) True >>> I2.is_connected(I1) True >>> I2.interior().is_connected(I1) False >>> I2.closure().is_connected(I1.interior()) True >>> I3 = RealSet.closed(Integer(1)/Integer(2), Integer(3)/Integer(2))[Integer(0)]; I3 [1/2, 3/2] >>> I1.is_connected(I3) True >>> I3.is_connected(I1) True 
 - is_empty()[source]¶
- Return whether the interval is empty. - The normalized form of - RealSethas all intervals non-empty, so this method usually returns- False.- OUTPUT: boolean - EXAMPLES: - sage: I = RealSet(0, 1)[0] sage: I.is_empty() False - >>> from sage.all import * >>> I = RealSet(Integer(0), Integer(1))[Integer(0)] >>> I.is_empty() False 
 - is_point()[source]¶
- Return whether the interval consists of a single point. - OUTPUT: boolean - EXAMPLES: - sage: I = RealSet(0, 1)[0] sage: I.is_point() False - >>> from sage.all import * >>> I = RealSet(Integer(0), Integer(1))[Integer(0)] >>> I.is_point() False 
 - lower()[source]¶
- 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 - >>> from sage.all import * >>> I = RealSet(Integer(0), Integer(1))[Integer(0)] >>> I.lower() 0 >>> I.upper() 1 
 - lower_closed()[source]¶
- 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 - >>> from sage.all import * >>> I = RealSet.open_closed(Integer(0), Integer(1))[Integer(0)]; I (0, 1] >>> I.lower_closed() False >>> I.lower_open() True >>> I.upper_closed() True >>> I.upper_open() False 
 - lower_open()[source]¶
- 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 - >>> from sage.all import * >>> I = RealSet.open_closed(Integer(0), Integer(1))[Integer(0)]; I (0, 1] >>> I.lower_closed() False >>> I.lower_open() True >>> I.upper_closed() True >>> I.upper_open() False 
 - upper()[source]¶
- 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 - >>> from sage.all import * >>> I = RealSet(Integer(0), Integer(1))[Integer(0)] >>> I.lower() 0 >>> I.upper() 1 
 - upper_closed()[source]¶
- 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 - >>> from sage.all import * >>> I = RealSet.open_closed(Integer(0), Integer(1))[Integer(0)]; I (0, 1] >>> I.lower_closed() False >>> I.lower_open() True >>> I.upper_closed() True >>> I.upper_open() False 
 - upper_open()[source]¶
- 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 - >>> from sage.all import * >>> I = RealSet.open_closed(Integer(0), Integer(1))[Integer(0)]; I (0, 1] >>> I.lower_closed() False >>> I.lower_open() True >>> I.upper_closed() True >>> I.upper_open() False 
 
- class sage.sets.real_set.RealSet(*intervals, normalized=True)[source]¶
- Bases: - UniqueRepresentation,- Parent,- Set_base,- Set_boolean_operators,- Set_add_sub_operators- A subset of the real line, a finite union of intervals. - INPUT: - *args– arguments defining a real set. Possibilities are either:- two extended real numbers - a, b, to construct the open interval \((a, b)\), or
- a list/tuple/iterable of (not necessarily disjoint) intervals or real sets, whose union is taken. The individual intervals can be specified by either - a tuple - (a, b)of two extended real numbers (constructing an open interval),
- a list - [a, b]of two real numbers (constructing a closed interval),
- an - OpenInterval.
 
 
- structure– (default:- None) if- None, construct the real set as an instance of- RealSet; if- 'differentiable', construct it as a subset of an instance of- RealLine, representing the differentiable manifold \(\RR\).
- ambient– (default:- None) an instance of- RealLine; construct a subset of it. Using this keyword implies- structure='differentiable'.
- namesor- coordinate– coordinate symbol for the canonical chart; see- RealLine. Using these keywords implies- structure='differentiable'.
- name,- latex_name,- start_index– see- RealLine
- normalized– (default:- None) if- True, the input is already normalized, i.e.,- *argsare the connected components (type- InternalRealInterval) of the real set in ascending order; no other keyword is provided.
 - There are also specialized constructors for various types of intervals: - Constructor - Interval - \((a, b)\) - \([a, b]\) - \(\{a\}\) - \((a, b]\) - \([a, b)\) - \((-\infty, b]\) - \((-\infty, b)\) - \([a, +\infty)\) - \((a, +\infty)\) - \((-\infty, +\infty)\) - any - EXAMPLES: - sage: RealSet(0, 1) # open set from two numbers (0, 1) sage: RealSet(1, 0) # the two numbers will be sorted (0, 1) sage: s1 = RealSet((1,2)); s1 # tuple of two numbers = open set (1, 2) sage: s2 = RealSet([3,4]); s2 # list of two numbers = closed set [3, 4] sage: i1, i2 = s1[0], s2[0] sage: RealSet(i2, i1) # union of intervals (1, 2) ∪ [3, 4] sage: RealSet((-oo, 0), x > 6, i1, RealSet.point(5), # needs sage.symbolic ....: RealSet.closed_open(4, 3)) (-oo, 0) ∪ (1, 2) ∪ [3, 4) ∪ {5} ∪ (6, +oo) - >>> from sage.all import * >>> RealSet(Integer(0), Integer(1)) # open set from two numbers (0, 1) >>> RealSet(Integer(1), Integer(0)) # the two numbers will be sorted (0, 1) >>> s1 = RealSet((Integer(1),Integer(2))); s1 # tuple of two numbers = open set (1, 2) >>> s2 = RealSet([Integer(3),Integer(4)]); s2 # list of two numbers = closed set [3, 4] >>> i1, i2 = s1[Integer(0)], s2[Integer(0)] >>> RealSet(i2, i1) # union of intervals (1, 2) ∪ [3, 4] >>> RealSet((-oo, Integer(0)), x > Integer(6), i1, RealSet.point(Integer(5)), # needs sage.symbolic ... RealSet.closed_open(Integer(4), Integer(3))) (-oo, 0) ∪ (1, 2) ∪ [3, 4) ∪ {5} ∪ (6, +oo) - Initialization from manifold objects: - sage: # needs sage.symbolic sage: R = manifolds.RealLine(); R Real number line ℝ sage: RealSet(R) (-oo, +oo) sage: I02 = manifolds.OpenInterval(0, 2); I I sage: RealSet(I02) (0, 2) sage: I01_of_R = manifolds.OpenInterval(0, 1, ambient_interval=R); I01_of_R Real interval (0, 1) sage: RealSet(I01_of_R) (0, 1) sage: RealSet(I01_of_R.closure()) [0, 1] sage: I01_of_I02 = manifolds.OpenInterval(0, 1, ....: ambient_interval=I02); I01_of_I02 Real interval (0, 1) sage: RealSet(I01_of_I02) (0, 1) sage: RealSet(I01_of_I02.closure()) (0, 1] - >>> from sage.all import * >>> # needs sage.symbolic >>> R = manifolds.RealLine(); R Real number line ℝ >>> RealSet(R) (-oo, +oo) >>> I02 = manifolds.OpenInterval(Integer(0), Integer(2)); I I >>> RealSet(I02) (0, 2) >>> I01_of_R = manifolds.OpenInterval(Integer(0), Integer(1), ambient_interval=R); I01_of_R Real interval (0, 1) >>> RealSet(I01_of_R) (0, 1) >>> RealSet(I01_of_R.closure()) [0, 1] >>> I01_of_I02 = manifolds.OpenInterval(Integer(0), Integer(1), ... ambient_interval=I02); I01_of_I02 Real interval (0, 1) >>> RealSet(I01_of_I02) (0, 1) >>> RealSet(I01_of_I02.closure()) (0, 1] - Real sets belong to a subcategory of topological spaces: - sage: RealSet().category() Join of Category of finite sets and Category of subobjects of sets and Category of connected topological spaces sage: RealSet.point(1).category() Join of Category of finite sets and Category of subobjects of sets and Category of connected topological spaces sage: RealSet([1, 2]).category() Join of Category of infinite sets and Category of compact topological spaces and Category of subobjects of sets and Category of connected topological spaces sage: RealSet((1, 2), (3, 4)).category() Join of Category of infinite sets and Category of subobjects of sets and Category of topological spaces - >>> from sage.all import * >>> RealSet().category() Join of Category of finite sets and Category of subobjects of sets and Category of connected topological spaces >>> RealSet.point(Integer(1)).category() Join of Category of finite sets and Category of subobjects of sets and Category of connected topological spaces >>> RealSet([Integer(1), Integer(2)]).category() Join of Category of infinite sets and Category of compact topological spaces and Category of subobjects of sets and Category of connected topological spaces >>> RealSet((Integer(1), Integer(2)), (Integer(3), Integer(4))).category() Join of Category of infinite sets and Category of subobjects of sets and Category of topological spaces - Constructing real sets as manifolds or manifold subsets by passing - structure='differentiable':- sage: # needs sage.symbolic sage: RealSet(-oo, oo, structure='differentiable') Real number line ℝ sage: RealSet([0, 1], structure='differentiable') Subset [0, 1] of the Real number line ℝ sage: _.category() Category of subobjects of sets sage: RealSet.open_closed(0, 5, structure='differentiable') Subset (0, 5] of the Real number line ℝ - >>> from sage.all import * >>> # needs sage.symbolic >>> RealSet(-oo, oo, structure='differentiable') Real number line ℝ >>> RealSet([Integer(0), Integer(1)], structure='differentiable') Subset [0, 1] of the Real number line ℝ >>> _.category() Category of subobjects of sets >>> RealSet.open_closed(Integer(0), Integer(5), structure='differentiable') Subset (0, 5] of the Real number line ℝ - This is implied when a coordinate name is given using the keywords - coordinateor- names:- sage: RealSet(0, 1, coordinate='λ') # needs sage.symbolic Open subset (0, 1) of the Real number line ℝ sage: _.category() # needs sage.symbolic Join of Category of smooth manifolds over Real Field with 53 bits of precision and Category of connected manifolds over Real Field with 53 bits of precision and Category of subobjects of sets - >>> from sage.all import * >>> RealSet(Integer(0), Integer(1), coordinate='λ') # needs sage.symbolic Open subset (0, 1) of the Real number line ℝ >>> _.category() # needs sage.symbolic Join of Category of smooth manifolds over Real Field with 53 bits of precision and Category of connected manifolds over Real Field with 53 bits of precision and Category of subobjects of sets - It is also implied by assigning a coordinate name using generator notation: - sage: R_xi.<ξ> = RealSet.real_line(); R_xi # needs sage.symbolic Real number line ℝ sage: R_xi.canonical_chart() # needs sage.symbolic Chart (ℝ, (ξ,)) - >>> from sage.all import * >>> R_xi = RealSet.real_line(names=('ξ',)); (ξ,) = R_xi._first_ngens(1); R_xi # needs sage.symbolic Real number line ℝ >>> R_xi.canonical_chart() # needs sage.symbolic Chart (ℝ, (ξ,)) - With the keyword - ambient, we can construct a subset of a previously constructed manifold:- sage: # needs sage.symbolic sage: P_xi = RealSet(0, oo, ambient=R_xi); P_xi Open subset (0, +oo) of the Real number line ℝ sage: P_xi.default_chart() Chart ((0, +oo), (ξ,)) sage: B_xi = RealSet(0, 1, ambient=P_xi); B_xi Open subset (0, 1) of the Real number line ℝ sage: B_xi.default_chart() Chart ((0, 1), (ξ,)) sage: R_xi.subset_family() Set {(0, +oo), (0, 1), ℝ} of open subsets of the Real number line ℝ sage: F = RealSet.point(0).union(RealSet.point(1)).union(RealSet.point(2)); F {0} ∪ {1} ∪ {2} sage: F_tau = RealSet(F, names='τ'); F_tau Subset {0} ∪ {1} ∪ {2} of the Real number line ℝ sage: F_tau.manifold().canonical_chart() Chart (ℝ, (τ,)) - >>> from sage.all import * >>> # needs sage.symbolic >>> P_xi = RealSet(Integer(0), oo, ambient=R_xi); P_xi Open subset (0, +oo) of the Real number line ℝ >>> P_xi.default_chart() Chart ((0, +oo), (ξ,)) >>> B_xi = RealSet(Integer(0), Integer(1), ambient=P_xi); B_xi Open subset (0, 1) of the Real number line ℝ >>> B_xi.default_chart() Chart ((0, 1), (ξ,)) >>> R_xi.subset_family() Set {(0, +oo), (0, 1), ℝ} of open subsets of the Real number line ℝ >>> F = RealSet.point(Integer(0)).union(RealSet.point(Integer(1))).union(RealSet.point(Integer(2))); F {0} ∪ {1} ∪ {2} >>> F_tau = RealSet(F, names='τ'); F_tau Subset {0} ∪ {1} ∪ {2} of the Real number line ℝ >>> F_tau.manifold().canonical_chart() Chart (ℝ, (τ,)) - ambient()[source]¶
- Return the ambient space (the real line). - EXAMPLES: - sage: s = RealSet(RealSet.open_closed(0,1), RealSet.closed_open(2,3)) sage: s.ambient() (-oo, +oo) - >>> from sage.all import * >>> s = RealSet(RealSet.open_closed(Integer(0),Integer(1)), RealSet.closed_open(Integer(2),Integer(3))) >>> s.ambient() (-oo, +oo) 
 - static are_pairwise_disjoint(*real_set_collection)[source]¶
- Test whether the real sets are pairwise disjoint. - INPUT: - *real_set_collection– list/tuple/iterable of- RealSetor data that defines one
 - OUTPUT: boolean - See also - 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 - >>> from sage.all import * >>> s1 = RealSet((Integer(0), Integer(1)), (Integer(2), Integer(3))) >>> s2 = RealSet((Integer(1), Integer(2))) >>> s3 = RealSet.point(Integer(3)) >>> RealSet.are_pairwise_disjoint(s1, s2, s3) True >>> RealSet.are_pairwise_disjoint(s1, s2, s3, [Integer(10),Integer(10)]) True >>> RealSet.are_pairwise_disjoint(s1, s2, s3, [-Integer(1), Integer(1)/Integer(2)]) False 
 - boundary()[source]¶
- Return the topological boundary of - selfas a new- RealSet.- EXAMPLES: - sage: RealSet(-oo, oo).boundary() {} sage: RealSet().boundary() {} sage: RealSet.point(2).boundary() {2} sage: RealSet([1, 2], (3, 4)).boundary() {1} ∪ {2} ∪ {3} ∪ {4} sage: RealSet((1, 2), (2, 3)).boundary() {1} ∪ {2} ∪ {3} - >>> from sage.all import * >>> RealSet(-oo, oo).boundary() {} >>> RealSet().boundary() {} >>> RealSet.point(Integer(2)).boundary() {2} >>> RealSet([Integer(1), Integer(2)], (Integer(3), Integer(4))).boundary() {1} ∪ {2} ∪ {3} ∪ {4} >>> RealSet((Integer(1), Integer(2)), (Integer(2), Integer(3))).boundary() {1} ∪ {2} ∪ {3} 
 - cardinality()[source]¶
- 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 - >>> from sage.all import * >>> RealSet([Integer(0), Integer(0)], [Integer(1), Integer(1)], [Integer(3), Integer(3)]).cardinality() 3 >>> RealSet(Integer(0),Integer(3)).cardinality() +Infinity 
 - static closed(lower, upper, **kwds)[source]¶
- Construct a closed interval. - INPUT: - lower,- upper– two real numbers or infinity; they will be sorted if necessary
- **kwds– see- RealSet
 - OUTPUT: a new - RealSet- EXAMPLES: - sage: RealSet.closed(1, 0) [0, 1] - >>> from sage.all import * >>> RealSet.closed(Integer(1), Integer(0)) [0, 1] 
 - static closed_open(lower, upper, **kwds)[source]¶
- Construct a half-open interval. - INPUT: - lower,- upper– two real numbers or infinity; they will be sorted if necessary
- **kwds– see- RealSet
 - OUTPUT: - A new - RealSetthat is closed at the lower bound and open at the upper bound.- EXAMPLES: - sage: RealSet.closed_open(1, 0) [0, 1) - >>> from sage.all import * >>> RealSet.closed_open(Integer(1), Integer(0)) [0, 1) 
 - closure()[source]¶
- Return the topological closure of - selfas a new- RealSet.- EXAMPLES: - sage: RealSet(-oo, oo).closure() (-oo, +oo) sage: RealSet((1, 2), (2, 3)).closure() [1, 3] sage: RealSet().closure() {} - >>> from sage.all import * >>> RealSet(-oo, oo).closure() (-oo, +oo) >>> RealSet((Integer(1), Integer(2)), (Integer(2), Integer(3))).closure() [1, 3] >>> RealSet().closure() {} 
 - complement()[source]¶
- 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) - >>> from sage.all import * >>> RealSet(Integer(0),Integer(1)).complement() (-oo, 0] ∪ [1, +oo) >>> s1 = RealSet(Integer(0),Integer(2)) + RealSet.unbounded_above_closed(Integer(10)); s1 (0, 2) ∪ [10, +oo) >>> s1.complement() (-oo, 0] ∪ [2, 10) >>> s2 = RealSet(Integer(1),Integer(3)) + RealSet.unbounded_below_closed(-Integer(10)); s2 (-oo, -10] ∪ (1, 3) >>> s2.complement() (-10, 1] ∪ [3, +oo) 
 - contains(x)[source]¶
- 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: s.contains(10.0) True sage: 10 in s # syntactic sugar True sage: s.contains(+oo) False sage: RealSet().contains(1) False - >>> from sage.all import * >>> s = RealSet(Integer(0),Integer(2)) + RealSet.unbounded_above_closed(Integer(10)); s (0, 2) ∪ [10, +oo) >>> s.contains(Integer(1)) True >>> s.contains(Integer(0)) False >>> s.contains(RealNumber('10.0')) True >>> Integer(10) in s # syntactic sugar True >>> s.contains(+oo) False >>> RealSet().contains(Integer(1)) False 
 - static convex_hull(*real_set_collection)[source]¶
- Return the convex hull of real sets. - INPUT: - *real_set_collection– list/tuple/iterable of- RealSetor data that defines one
 - OUTPUT: the convex hull as a new - RealSet- EXAMPLES: - sage: s1 = RealSet(0,2) + RealSet.unbounded_above_closed(10); s1 # unbounded set (0, 2) ∪ [10, +oo) sage: s2 = RealSet(1,3) + RealSet.unbounded_below_closed(-10); s2 (-oo, -10] ∪ (1, 3) sage: s3 = RealSet((0,2), RealSet.point(8)); s3 (0, 2) ∪ {8} sage: s4 = RealSet(); s4 # empty set {} sage: RealSet.convex_hull(s1) (0, +oo) sage: RealSet.convex_hull(s2) (-oo, 3) sage: RealSet.convex_hull(s3) (0, 8] sage: RealSet.convex_hull(s4) {} sage: RealSet.convex_hull(s1, s2) (-oo, +oo) sage: RealSet.convex_hull(s2, s3) (-oo, 8] sage: RealSet.convex_hull(s2, s3, s4) (-oo, 8] - >>> from sage.all import * >>> s1 = RealSet(Integer(0),Integer(2)) + RealSet.unbounded_above_closed(Integer(10)); s1 # unbounded set (0, 2) ∪ [10, +oo) >>> s2 = RealSet(Integer(1),Integer(3)) + RealSet.unbounded_below_closed(-Integer(10)); s2 (-oo, -10] ∪ (1, 3) >>> s3 = RealSet((Integer(0),Integer(2)), RealSet.point(Integer(8))); s3 (0, 2) ∪ {8} >>> s4 = RealSet(); s4 # empty set {} >>> RealSet.convex_hull(s1) (0, +oo) >>> RealSet.convex_hull(s2) (-oo, 3) >>> RealSet.convex_hull(s3) (0, 8] >>> RealSet.convex_hull(s4) {} >>> RealSet.convex_hull(s1, s2) (-oo, +oo) >>> RealSet.convex_hull(s2, s3) (-oo, 8] >>> RealSet.convex_hull(s2, s3, s4) (-oo, 8] 
 - difference(*other)[source]¶
- Return - selfwith- othersubtracted.- INPUT: - other– a- RealSetor data that defines one
 - OUTPUT: - The set-theoretic difference of - selfwith- otherremoved 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) - >>> from sage.all import * >>> s1 = RealSet(Integer(0),Integer(2)) + RealSet.unbounded_above_closed(Integer(10)); s1 (0, 2) ∪ [10, +oo) >>> s2 = RealSet(Integer(1),Integer(3)) + RealSet.unbounded_below_closed(-Integer(10)); s2 (-oo, -10] ∪ (1, 3) >>> s1.difference(s2) (0, 1] ∪ [10, +oo) >>> s1 - s2 # syntactic sugar (0, 1] ∪ [10, +oo) >>> s2.difference(s1) (-oo, -10] ∪ [2, 3) >>> s2 - s1 # syntactic sugar (-oo, -10] ∪ [2, 3) >>> s1.difference(Integer(1),Integer(11)) (0, 1] ∪ [11, +oo) 
 - get_interval(i)[source]¶
- Return the - i-th connected component.- Note that the intervals representing the real set are always normalized, i.e., they are sorted, disjoint and not connected. - INPUT: - i– integer
 - OUTPUT: the \(i\)-th connected component as a - InternalRealInterval- 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 - >>> from sage.all import * >>> s = RealSet(RealSet.open_closed(Integer(0),Integer(1)), RealSet.closed_open(Integer(2),Integer(3))) >>> s.get_interval(Integer(0)) (0, 1] >>> s[Integer(0)] # shorthand (0, 1] >>> s.get_interval(Integer(1)) [2, 3) >>> s[Integer(0)] == s.get_interval(Integer(0)) True 
 - inf()[source]¶
- 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 - >>> from sage.all import * >>> s1 = RealSet(Integer(0),Integer(2)) + RealSet.unbounded_above_closed(Integer(10)); s1 (0, 2) ∪ [10, +oo) >>> s1.inf() 0 >>> s2 = RealSet(Integer(1),Integer(3)) + RealSet.unbounded_below_closed(-Integer(10)); s2 (-oo, -10] ∪ (1, 3) >>> s2.inf() -Infinity 
 - interior()[source]¶
- Return the topological interior of - selfas a new- RealSet.- EXAMPLES: - sage: RealSet(-oo, oo).interior() (-oo, +oo) sage: RealSet().interior() {} sage: RealSet.point(2).interior() {} sage: RealSet([1, 2], (3, 4)).interior() (1, 2) ∪ (3, 4) - >>> from sage.all import * >>> RealSet(-oo, oo).interior() (-oo, +oo) >>> RealSet().interior() {} >>> RealSet.point(Integer(2)).interior() {} >>> RealSet([Integer(1), Integer(2)], (Integer(3), Integer(4))).interior() (1, 2) ∪ (3, 4) 
 - intersection(*real_set_collection)[source]¶
- Return the intersection of real sets. - INPUT: - *real_set_collection– list/tuple/iterable of- RealSetor 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: s3 = RealSet((0, 1), (2, 3)); s3 (0, 1) ∪ (2, 3) sage: s4 = RealSet([0, 1], [2, 3]); s4 [0, 1] ∪ [2, 3] sage: s3.intersection(s4) (0, 1) ∪ (2, 3) sage: s3.intersection([1, 2]) {} sage: s4.intersection([1, 2]) {1} ∪ {2} sage: s4.intersection(1, 2) {} sage: s5 = RealSet.closed_open(1, 10); s5 [1, 10) sage: s5.intersection(-oo, +oo) [1, 10) sage: s5.intersection(x != 2, (-oo, 3), RealSet.real_line()[0]) # needs sage.symbolic [1, 2) ∪ (2, 3) - >>> from sage.all import * >>> s1 = RealSet(Integer(0),Integer(2)) + RealSet.unbounded_above_closed(Integer(10)); s1 (0, 2) ∪ [10, +oo) >>> s2 = RealSet(Integer(1),Integer(3)) + RealSet.unbounded_below_closed(-Integer(10)); s2 (-oo, -10] ∪ (1, 3) >>> s1.intersection(s2) (1, 2) >>> s1 & s2 # syntactic sugar (1, 2) >>> s3 = RealSet((Integer(0), Integer(1)), (Integer(2), Integer(3))); s3 (0, 1) ∪ (2, 3) >>> s4 = RealSet([Integer(0), Integer(1)], [Integer(2), Integer(3)]); s4 [0, 1] ∪ [2, 3] >>> s3.intersection(s4) (0, 1) ∪ (2, 3) >>> s3.intersection([Integer(1), Integer(2)]) {} >>> s4.intersection([Integer(1), Integer(2)]) {1} ∪ {2} >>> s4.intersection(Integer(1), Integer(2)) {} >>> s5 = RealSet.closed_open(Integer(1), Integer(10)); s5 [1, 10) >>> s5.intersection(-oo, +oo) [1, 10) >>> s5.intersection(x != Integer(2), (-oo, Integer(3)), RealSet.real_line()[Integer(0)]) # needs sage.symbolic [1, 2) ∪ (2, 3) 
 - static interval(lower, upper, lower_closed, upper_closed, **kwds)[source]¶
- Construct an interval. - INPUT: - lower,- upper– two real numbers or infinity; they will be sorted if necessary
- lower_closed,- upper_closed– boolean; whether the interval is closed at the lower and upper bound of the interval, respectively
- **kwds– see- RealSet
 - OUTPUT: a new - RealSet- EXAMPLES: - sage: RealSet.interval(1, 0, lower_closed=True, upper_closed=False) [0, 1) - >>> from sage.all import * >>> RealSet.interval(Integer(1), Integer(0), lower_closed=True, upper_closed=False) [0, 1) 
 - is_closed()[source]¶
- Return whether - selfis a closed set.- EXAMPLES: - sage: RealSet().is_closed() True sage: RealSet.point(1).is_closed() True sage: RealSet([1, 2]).is_closed() True sage: RealSet([1, 2], (3, 4)).is_closed() False sage: RealSet(-oo, +oo).is_closed() True - >>> from sage.all import * >>> RealSet().is_closed() True >>> RealSet.point(Integer(1)).is_closed() True >>> RealSet([Integer(1), Integer(2)]).is_closed() True >>> RealSet([Integer(1), Integer(2)], (Integer(3), Integer(4))).is_closed() False >>> RealSet(-oo, +oo).is_closed() True 
 - is_connected()[source]¶
- Return whether - selfis a connected set.- OUTPUT: boolean - EXAMPLES: - sage: s1 = RealSet((1, 2), (2, 4)); s1 (1, 2) ∪ (2, 4) sage: s1.is_connected() False sage: s2 = RealSet((1, 2), (2, 4), RealSet.point(2)); s2 (1, 4) sage: s2.is_connected() True sage: s3 = RealSet(1,3) + RealSet.unbounded_below_closed(-10); s3 (-oo, -10] ∪ (1, 3) sage: s3.is_connected() False sage: RealSet(x != 0).is_connected() # needs sage.symbolic False sage: RealSet(-oo, oo).is_connected() True sage: RealSet().is_connected() False - >>> from sage.all import * >>> s1 = RealSet((Integer(1), Integer(2)), (Integer(2), Integer(4))); s1 (1, 2) ∪ (2, 4) >>> s1.is_connected() False >>> s2 = RealSet((Integer(1), Integer(2)), (Integer(2), Integer(4)), RealSet.point(Integer(2))); s2 (1, 4) >>> s2.is_connected() True >>> s3 = RealSet(Integer(1),Integer(3)) + RealSet.unbounded_below_closed(-Integer(10)); s3 (-oo, -10] ∪ (1, 3) >>> s3.is_connected() False >>> RealSet(x != Integer(0)).is_connected() # needs sage.symbolic False >>> RealSet(-oo, oo).is_connected() True >>> RealSet().is_connected() False 
 - is_disjoint(*other)[source]¶
- Test whether the two sets are disjoint. - INPUT: - other– a- RealSetor data defining one
 - OUTPUT: boolean - See also - EXAMPLES: - sage: s = RealSet((0, 1), (2, 3)); s (0, 1) ∪ (2, 3) sage: s.is_disjoint(RealSet([1, 2])) True sage: s.is_disjoint([3/2, 5/2]) False sage: s.is_disjoint(RealSet()) True sage: s.is_disjoint(RealSet().real_line()) False - >>> from sage.all import * >>> s = RealSet((Integer(0), Integer(1)), (Integer(2), Integer(3))); s (0, 1) ∪ (2, 3) >>> s.is_disjoint(RealSet([Integer(1), Integer(2)])) True >>> s.is_disjoint([Integer(3)/Integer(2), Integer(5)/Integer(2)]) False >>> s.is_disjoint(RealSet()) True >>> s.is_disjoint(RealSet().real_line()) False 
 - is_disjoint_from(*args, **kwds)[source]¶
- Deprecated: Use - is_disjoint()instead. See Issue #31927 for details.
 - is_empty()[source]¶
- Return whether the set is empty. - EXAMPLES: - sage: RealSet(0, 1).is_empty() False sage: RealSet(0, 0).is_empty() True sage: RealSet.interval(1, 1, lower_closed=False, upper_closed=True).is_empty() True sage: RealSet.interval(1, -1, lower_closed=False, upper_closed=True).is_empty() False - >>> from sage.all import * >>> RealSet(Integer(0), Integer(1)).is_empty() False >>> RealSet(Integer(0), Integer(0)).is_empty() True >>> RealSet.interval(Integer(1), Integer(1), lower_closed=False, upper_closed=True).is_empty() True >>> RealSet.interval(Integer(1), -Integer(1), lower_closed=False, upper_closed=True).is_empty() False 
 - is_included_in(*args, **kwds)[source]¶
- Deprecated: Use - is_subset()instead. See Issue #31927 for details.
 - is_open()[source]¶
- Return whether - selfis an open set.- EXAMPLES: - sage: RealSet().is_open() True sage: RealSet.point(1).is_open() False sage: RealSet((1, 2)).is_open() True sage: RealSet([1, 2], (3, 4)).is_open() False sage: RealSet(-oo, +oo).is_open() True - >>> from sage.all import * >>> RealSet().is_open() True >>> RealSet.point(Integer(1)).is_open() False >>> RealSet((Integer(1), Integer(2))).is_open() True >>> RealSet([Integer(1), Integer(2)], (Integer(3), Integer(4))).is_open() False >>> RealSet(-oo, +oo).is_open() True 
 - is_subset(*other)[source]¶
- Return whether - selfis a subset of- other.- INPUT: - *other– a- RealSetor 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_subset(J) True sage: J.is_subset(K) False - >>> from sage.all import * >>> I = RealSet((Integer(1),Integer(2))) >>> J = RealSet((Integer(1),Integer(3))) >>> K = RealSet((Integer(2),Integer(3))) >>> I.is_subset(J) True >>> J.is_subset(K) False 
 - is_universe()[source]¶
- Return whether the set is the ambient space (the real line). - EXAMPLES: - sage: RealSet().ambient().is_universe() True - >>> from sage.all import * >>> RealSet().ambient().is_universe() True 
 - lift(x)[source]¶
- Lift - xto the ambient space for- self.- This version of the method just returns - x.- EXAMPLES: - sage: s = RealSet(0, 2); s (0, 2) sage: s.lift(1) 1 - >>> from sage.all import * >>> s = RealSet(Integer(0), Integer(2)); s (0, 2) >>> s.lift(Integer(1)) 1 
 - n_components()[source]¶
- 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 - >>> from sage.all import * >>> s = RealSet(RealSet.open_closed(Integer(0),Integer(1)), RealSet.closed_open(Integer(2),Integer(3))) >>> s.n_components() 2 
 - normalize(intervals)[source]¶
- Bring a collection of intervals into canonical form. - INPUT: - intervals– 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),) - >>> from sage.all import * >>> i1 = RealSet((Integer(0), Integer(1)))[Integer(0)] >>> i2 = RealSet([Integer(1), Integer(2)])[Integer(0)] >>> i3 = RealSet((Integer(2), Integer(3)))[Integer(0)] >>> RealSet.normalize([i1, i2, i3]) ((0, 3),) 
 - static open(lower, upper, **kwds)[source]¶
- Construct an open interval. - INPUT: - lower,- upper– two real numbers or infinity; they will be sorted if necessary
- **kwds– see- RealSet
 - OUTPUT: a new - RealSet- EXAMPLES: - sage: RealSet.open(1, 0) (0, 1) - >>> from sage.all import * >>> RealSet.open(Integer(1), Integer(0)) (0, 1) 
 - static open_closed(lower, upper, **kwds)[source]¶
- Construct a half-open interval. - INPUT: - lower,- upper– two real numbers or infinity; they will be sorted if necessary
- **kwds– see- RealSet
 - OUTPUT: - A new - RealSetthat is open at the lower bound and closed at the upper bound.- EXAMPLES: - sage: RealSet.open_closed(1, 0) (0, 1] - >>> from sage.all import * >>> RealSet.open_closed(Integer(1), Integer(0)) (0, 1] 
 - static point(p, **kwds)[source]¶
- Construct an interval containing a single point. - INPUT: - p– a real number
- **kwds– see- RealSet
 - OUTPUT: a new - RealSet- EXAMPLES: - sage: RealSet.open(1, 0) (0, 1) - >>> from sage.all import * >>> RealSet.open(Integer(1), Integer(0)) (0, 1) 
 - static real_line(**kwds)[source]¶
- Construct the real line. - INPUT: - **kwds– see- RealSet
 - EXAMPLES: - sage: RealSet.real_line() (-oo, +oo) - >>> from sage.all import * >>> RealSet.real_line() (-oo, +oo) 
 - retract(x)[source]¶
- Retract - xto- self.- It raises an error if - xdoes not lie in the set- self.- EXAMPLES: - sage: s = RealSet(0, 2); s (0, 2) sage: s.retract(1) 1 sage: s.retract(2) Traceback (most recent call last): ... ValueError: 2 is not an element of (0, 2) - >>> from sage.all import * >>> s = RealSet(Integer(0), Integer(2)); s (0, 2) >>> s.retract(Integer(1)) 1 >>> s.retract(Integer(2)) Traceback (most recent call last): ... ValueError: 2 is not an element of (0, 2) 
 - sup()[source]¶
- 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 - >>> from sage.all import * >>> s1 = RealSet(Integer(0),Integer(2)) + RealSet.unbounded_above_closed(Integer(10)); s1 (0, 2) ∪ [10, +oo) >>> s1.sup() +Infinity >>> s2 = RealSet(Integer(1),Integer(3)) + RealSet.unbounded_below_closed(-Integer(10)); s2 (-oo, -10] ∪ (1, 3) >>> s2.sup() 3 
 - symmetric_difference(*other)[source]¶
- Return the symmetric difference of - selfand- other.- INPUT: - other– a- RealSetor data that defines one
 - OUTPUT: - The set-theoretic symmetric difference of - selfand- otheras a new- RealSet.- EXAMPLES: - sage: s1 = RealSet(0,2); s1 (0, 2) sage: s2 = RealSet.unbounded_above_open(1); s2 (1, +oo) sage: s1.symmetric_difference(s2) (0, 1] ∪ [2, +oo) - >>> from sage.all import * >>> s1 = RealSet(Integer(0),Integer(2)); s1 (0, 2) >>> s2 = RealSet.unbounded_above_open(Integer(1)); s2 (1, +oo) >>> s1.symmetric_difference(s2) (0, 1] ∪ [2, +oo) 
 - static unbounded_above_closed(bound, **kwds)[source]¶
- Construct a semi-infinite interval. - INPUT: - bound– a real number
- **kwds– see- RealSet
 - OUTPUT: - A new - RealSetfrom the bound (including) to plus infinity.- EXAMPLES: - sage: RealSet.unbounded_above_closed(1) [1, +oo) - >>> from sage.all import * >>> RealSet.unbounded_above_closed(Integer(1)) [1, +oo) 
 - static unbounded_above_open(bound, **kwds)[source]¶
- Construct a semi-infinite interval. - INPUT: - bound– a real number
- **kwds– see- RealSet
 - OUTPUT: - A new - RealSetfrom the bound (excluding) to plus infinity.- EXAMPLES: - sage: RealSet.unbounded_above_open(1) (1, +oo) - >>> from sage.all import * >>> RealSet.unbounded_above_open(Integer(1)) (1, +oo) 
 - static unbounded_below_closed(bound, **kwds)[source]¶
- Construct a semi-infinite interval. - INPUT: - bound– a real number
 - OUTPUT: - A new - RealSetfrom minus infinity to the bound (including).- **kwds– see- RealSet
 - EXAMPLES: - sage: RealSet.unbounded_below_closed(1) (-oo, 1] - >>> from sage.all import * >>> RealSet.unbounded_below_closed(Integer(1)) (-oo, 1] 
 - static unbounded_below_open(bound, **kwds)[source]¶
- Construct a semi-infinite interval. - INPUT: - bound– a real number
 - OUTPUT: - A new - RealSetfrom minus infinity to the bound (excluding).- **kwds– see- RealSet
 - EXAMPLES: - sage: RealSet.unbounded_below_open(1) (-oo, 1) - >>> from sage.all import * >>> RealSet.unbounded_below_open(Integer(1)) (-oo, 1) 
 - union(*real_set_collection)[source]¶
- Return the union of real sets. - INPUT: - *real_set_collection– list/tuple/iterable of- RealSetor 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) sage: RealSet().union(RealSet.real_line()) (-oo, +oo) sage: s = RealSet().union([1, 2], (2, 3)); s [1, 3) sage: RealSet().union((-oo, 0), x > 6, s[0], # needs sage.symbolic ....: RealSet.point(5.0), RealSet.closed_open(2, 4)) (-oo, 0) ∪ [1, 4) ∪ {5} ∪ (6, +oo) - >>> from sage.all import * >>> s1 = RealSet(Integer(0),Integer(2)) >>> s2 = RealSet(Integer(1),Integer(3)) >>> s1.union(s2) (0, 3) >>> s1.union(Integer(1),Integer(3)) (0, 3) >>> s1 | s2 # syntactic sugar (0, 3) >>> s1 + s2 # syntactic sugar (0, 3) >>> RealSet().union(RealSet.real_line()) (-oo, +oo) >>> s = RealSet().union([Integer(1), Integer(2)], (Integer(2), Integer(3))); s [1, 3) >>> RealSet().union((-oo, Integer(0)), x > Integer(6), s[Integer(0)], # needs sage.symbolic ... RealSet.point(RealNumber('5.0')), RealSet.closed_open(Integer(2), Integer(4))) (-oo, 0) ∪ [1, 4) ∪ {5} ∪ (6, +oo)