Subsets of Topological Manifolds

The class ManifoldSubset implements generic subsets of a topological manifold. Open subsets are implemented by the class TopologicalManifold (since an open subset of a manifold is a manifold by itself), which inherits from ManifoldSubset. Besides, subsets that are images of a manifold subset under a continuous map are implemented by the subclass ImageManifoldSubset.

AUTHORS:

  • Eric Gourgoulhon, Michal Bejger (2013-2015): initial version

  • Travis Scrimshaw (2015): review tweaks; removal of facade parents

  • Matthias Koeppe (2021): Families and posets of subsets

REFERENCES:

EXAMPLES:

Two subsets on a manifold:

sage: M = Manifold(2, 'M', structure='topological')
sage: a = M.subset('A'); a
Subset A of the 2-dimensional topological manifold M
sage: b = M.subset('B'); b
Subset B of the 2-dimensional topological manifold M
sage: M.subset_family()
Set {A, B, M} of subsets of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> a = M.subset('A'); a
Subset A of the 2-dimensional topological manifold M
>>> b = M.subset('B'); b
Subset B of the 2-dimensional topological manifold M
>>> M.subset_family()
Set {A, B, M} of subsets of the 2-dimensional topological manifold M

M = Manifold(2, 'M', structure='topological')
a = M.subset('A'); a
b = M.subset('B'); b
M.subset_family()

The intersection of the two subsets:

sage: c = a.intersection(b); c
Subset A_inter_B of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> c = a.intersection(b); c
Subset A_inter_B of the 2-dimensional topological manifold M

c = a.intersection(b); c

Their union:

sage: d = a.union(b); d
Subset A_union_B of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> d = a.union(b); d
Subset A_union_B of the 2-dimensional topological manifold M

d = a.union(b); d

Families of subsets after the above operations:

sage: M.subset_family()
Set {A, A_inter_B, A_union_B, B, M} of subsets of the 2-dimensional topological manifold M
sage: a.subset_family()
Set {A, A_inter_B} of subsets of the 2-dimensional topological manifold M
sage: c.subset_family()
Set {A_inter_B} of subsets of the 2-dimensional topological manifold M
sage: d.subset_family()
Set {A, A_inter_B, A_union_B, B} of subsets of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> M.subset_family()
Set {A, A_inter_B, A_union_B, B, M} of subsets of the 2-dimensional topological manifold M
>>> a.subset_family()
Set {A, A_inter_B} of subsets of the 2-dimensional topological manifold M
>>> c.subset_family()
Set {A_inter_B} of subsets of the 2-dimensional topological manifold M
>>> d.subset_family()
Set {A, A_inter_B, A_union_B, B} of subsets of the 2-dimensional topological manifold M

M.subset_family()
a.subset_family()
c.subset_family()
d.subset_family()
class sage.manifolds.subset.ManifoldSubset(manifold, name: str, latex_name=None, category=None)[source]

Bases: UniqueRepresentation, Parent

Subset of a topological manifold.

The class ManifoldSubset inherits from the generic class Parent. The corresponding element class is ManifoldPoint.

Note that open subsets are not implemented directly by this class, but by the derived class TopologicalManifold (an open subset of a topological manifold being itself a topological manifold).

INPUT:

  • manifold – topological manifold on which the subset is defined

  • name – string; name (symbol) given to the subset

  • latex_name – string (default: None); LaTeX symbol to denote the subset; if none are provided, it is set to name

  • category – (default: None) to specify the category; if None, the category for generic subsets is used

EXAMPLES:

A subset of a manifold:

sage: M = Manifold(2, 'M', structure='topological')
sage: from sage.manifolds.subset import ManifoldSubset
sage: A = ManifoldSubset(M, 'A', latex_name=r'\mathcal{A}')
sage: A
Subset A of the 2-dimensional topological manifold M
sage: latex(A)
\mathcal{A}
sage: A.is_subset(M)
True

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> from sage.manifolds.subset import ManifoldSubset
>>> A = ManifoldSubset(M, 'A', latex_name=r'\mathcal{A}')
>>> A
Subset A of the 2-dimensional topological manifold M
>>> latex(A)
\mathcal{A}
>>> A.is_subset(M)
True

M = Manifold(2, 'M', structure='topological')
from sage.manifolds.subset import ManifoldSubset
A = ManifoldSubset(M, 'A', latex_name=r'\mathcal{A}')
A
latex(A)
A.is_subset(M)

Instead of importing ManifoldSubset in the global namespace, it is recommended to use the method subset() to create a new subset:

sage: B = M.subset('B', latex_name=r'\mathcal{B}'); B
Subset B of the 2-dimensional topological manifold M
sage: M.subset_family()
Set {A, B, M} of subsets of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> B = M.subset('B', latex_name=r'\mathcal{B}'); B
Subset B of the 2-dimensional topological manifold M
>>> M.subset_family()
Set {A, B, M} of subsets of the 2-dimensional topological manifold M

B = M.subset('B', latex_name=r'\mathcal{B}'); B
M.subset_family()

The manifold is itself a subset:

sage: isinstance(M, ManifoldSubset)
True
sage: M in M.subsets()
True

>>> from sage.all import *
>>> isinstance(M, ManifoldSubset)
True
>>> M in M.subsets()
True

isinstance(M, ManifoldSubset)
M in M.subsets()

Instances of ManifoldSubset are parents:

sage: isinstance(A, Parent)
True
sage: A.category()
Category of subobjects of sets
sage: p = A.an_element(); p
Point on the 2-dimensional topological manifold M
sage: p.parent()
Subset A of the 2-dimensional topological manifold M
sage: p in A
True
sage: p in M
True

>>> from sage.all import *
>>> isinstance(A, Parent)
True
>>> A.category()
Category of subobjects of sets
>>> p = A.an_element(); p
Point on the 2-dimensional topological manifold M
>>> p.parent()
Subset A of the 2-dimensional topological manifold M
>>> p in A
True
>>> p in M
True

isinstance(A, Parent)
A.category()
p = A.an_element(); p
p.parent()
p in A
p in M
Element[source]

alias of ManifoldPoint

ambient()[source]

Return the ambient manifold of self.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: A = M.subset('A')
sage: A.manifold()
2-dimensional topological manifold M
sage: A.manifold() is M
True
sage: B = A.subset('B')
sage: B.manifold() is M
True

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> A = M.subset('A')
>>> A.manifold()
2-dimensional topological manifold M
>>> A.manifold() is M
True
>>> B = A.subset('B')
>>> B.manifold() is M
True

M = Manifold(2, 'M', structure='topological')
A = M.subset('A')
A.manifold()
A.manifold() is M
B = A.subset('B')
B.manifold() is M

An alias is ambient:

sage: A.ambient() is A.manifold()
True

>>> from sage.all import *
>>> A.ambient() is A.manifold()
True

A.ambient() is A.manifold()
closure(name=None, latex_name=None)[source]

Return the topological closure of self as a subset of the manifold.

INPUT:

  • name – (default: None) name given to the difference in the case the latter has to be created; the default prepends cl_ to self._name

  • latex_name – (default: None) LaTeX symbol to denote the difference in the case the latter has to be created; the default is built upon the operator \(\mathrm{cl}\)

OUTPUT:

EXAMPLES:

sage: M = Manifold(2, 'R^2', structure='topological')
sage: c_cart.<x,y> = M.chart() # Cartesian coordinates on R^2
sage: M.closure() is M
True
sage: D2 = M.open_subset('D2', coord_def={c_cart: x^2+y^2<2}); D2
Open subset D2 of the 2-dimensional topological manifold R^2
sage: cl_D2 = D2.closure(); cl_D2
Topological closure cl_D2 of the
 Open subset D2 of the 2-dimensional topological manifold R^2
sage: cl_D2.is_closed()
True
sage: cl_D2 is cl_D2.closure()
True

sage: D1 = D2.open_subset('D1'); D1
Open subset D1 of the 2-dimensional topological manifold R^2
sage: D1.closure().is_subset(D2.closure())
True

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'R^2', structure='topological')
>>> c_cart = M.chart(names=('x', 'y',)); (x, y,) = c_cart._first_ngens(2)# Cartesian coordinates on R^2
>>> M.closure() is M
True
>>> D2 = M.open_subset('D2', coord_def={c_cart: x**Integer(2)+y**Integer(2)<Integer(2)}); D2
Open subset D2 of the 2-dimensional topological manifold R^2
>>> cl_D2 = D2.closure(); cl_D2
Topological closure cl_D2 of the
 Open subset D2 of the 2-dimensional topological manifold R^2
>>> cl_D2.is_closed()
True
>>> cl_D2 is cl_D2.closure()
True

>>> D1 = D2.open_subset('D1'); D1
Open subset D1 of the 2-dimensional topological manifold R^2
>>> D1.closure().is_subset(D2.closure())
True

M = Manifold(2, 'R^2', structure='topological')
c_cart.<x,y> = M.chart() # Cartesian coordinates on R^2
M.closure() is M
D2 = M.open_subset('D2', coord_def={c_cart: x^2+y^2<2}); D2
cl_D2 = D2.closure(); cl_D2
cl_D2.is_closed()
cl_D2 is cl_D2.closure()
D1 = D2.open_subset('D1'); D1
D1.closure().is_subset(D2.closure())
complement(superset=None, name=None, latex_name=None, is_open=False)[source]

Return the complement of self in the manifold or in superset.

INPUT:

  • superset – (default: self.manifold()) a superset of self

  • name – (default: None) name given to the complement in the case the latter has to be created; the default is superset._name minus self._name

  • latex_name – (default: None) LaTeX symbol to denote the complement in the case the latter has to be created; the default is built upon the symbol \(\setminus\)

  • is_open – boolean (default: False); if True, the created subset is assumed to be open with respect to the manifold’s topology

OUTPUT:

  • instance of ManifoldSubset representing the subset that is superset minus self

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: A = M.subset('A')
sage: B1 = A.subset('B1')
sage: B2 = A.subset('B2')
sage: B1.complement()
Subset M_minus_B1 of the 2-dimensional topological manifold M
sage: B1.complement(A)
Subset A_minus_B1 of the 2-dimensional topological manifold M
sage: B1.complement(B2)
Traceback (most recent call last):
...
TypeError: superset must be a superset of self

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> A = M.subset('A')
>>> B1 = A.subset('B1')
>>> B2 = A.subset('B2')
>>> B1.complement()
Subset M_minus_B1 of the 2-dimensional topological manifold M
>>> B1.complement(A)
Subset A_minus_B1 of the 2-dimensional topological manifold M
>>> B1.complement(B2)
Traceback (most recent call last):
...
TypeError: superset must be a superset of self

M = Manifold(2, 'M', structure='topological')
A = M.subset('A')
B1 = A.subset('B1')
B2 = A.subset('B2')
B1.complement()
B1.complement(A)
B1.complement(B2)

Demanding that the complement is open makes self a closed subset:

sage: A.is_closed()  # False a priori
False
sage: A.complement(is_open=True)
Open subset M_minus_A of the 2-dimensional topological manifold M
sage: A.is_closed()
True

>>> from sage.all import *
>>> A.is_closed()  # False a priori
False
>>> A.complement(is_open=True)
Open subset M_minus_A of the 2-dimensional topological manifold M
>>> A.is_closed()
True

A.is_closed()  # False a priori
A.complement(is_open=True)
A.is_closed()
declare_closed()[source]

Declare self to be a closed subset of the manifold.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: A = M.subset('A')
sage: B1 = A.subset('B1')
sage: B1.is_closed()
False
sage: B1.declare_closed()
sage: B1.is_closed()
True

sage: B2 = A.subset('B2')
sage: cl_B2 = B2.closure()
sage: A.declare_closed()
sage: cl_B2.is_subset(A)
True

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> A = M.subset('A')
>>> B1 = A.subset('B1')
>>> B1.is_closed()
False
>>> B1.declare_closed()
>>> B1.is_closed()
True

>>> B2 = A.subset('B2')
>>> cl_B2 = B2.closure()
>>> A.declare_closed()
>>> cl_B2.is_subset(A)
True

M = Manifold(2, 'M', structure='topological')
A = M.subset('A')
B1 = A.subset('B1')
B1.is_closed()
B1.declare_closed()
B1.is_closed()
B2 = A.subset('B2')
cl_B2 = B2.closure()
A.declare_closed()
cl_B2.is_subset(A)
declare_empty()[source]

Declare that self is the empty set.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: A = M.subset('A', is_open=True)
sage: AA = A.subset('AA')
sage: A
Open subset A of the 2-dimensional topological manifold M
sage: A.declare_empty()
sage: A.is_empty()
True

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> A = M.subset('A', is_open=True)
>>> AA = A.subset('AA')
>>> A
Open subset A of the 2-dimensional topological manifold M
>>> A.declare_empty()
>>> A.is_empty()
True

M = Manifold(2, 'M', structure='topological')
A = M.subset('A', is_open=True)
AA = A.subset('AA')
A
A.declare_empty()
A.is_empty()

Empty sets do not allow to define points on them:

sage: A.point()
Traceback (most recent call last):
...
TypeError: cannot define a point on the
  Open subset A of the 2-dimensional topological manifold M
  because it has been declared empty

>>> from sage.all import *
>>> A.point()
Traceback (most recent call last):
...
TypeError: cannot define a point on the
  Open subset A of the 2-dimensional topological manifold M
  because it has been declared empty

A.point()

Emptiness transfers to subsets:

sage: AA.is_empty()
True
sage: AA.point()
Traceback (most recent call last):
...
TypeError: cannot define a point on the
  Subset AA of the 2-dimensional topological manifold M
  because it has been declared empty
sage: AD = A.subset('AD')
sage: AD.is_empty()
True

>>> from sage.all import *
>>> AA.is_empty()
True
>>> AA.point()
Traceback (most recent call last):
...
TypeError: cannot define a point on the
  Subset AA of the 2-dimensional topological manifold M
  because it has been declared empty
>>> AD = A.subset('AD')
>>> AD.is_empty()
True

AA.is_empty()
AA.point()
AD = A.subset('AD')
AD.is_empty()

If points have already been defined on self (or its subsets), it is an error to declare it to be empty:

sage: B = M.subset('B')
sage: b = B.point(name='b'); b
Point b on the 2-dimensional topological manifold M
sage: B.declare_empty()
Traceback (most recent call last):
...
TypeError: cannot be empty because it has defined points

>>> from sage.all import *
>>> B = M.subset('B')
>>> b = B.point(name='b'); b
Point b on the 2-dimensional topological manifold M
>>> B.declare_empty()
Traceback (most recent call last):
...
TypeError: cannot be empty because it has defined points

B = M.subset('B')
b = B.point(name='b'); b
B.declare_empty()

Emptiness is recorded as empty open covers:

sage: P = M.subset_poset(open_covers=True, points=[b])                      # needs sage.graphs
sage: def label(element):
....:     if isinstance(element, str):
....:         return element
....:     try:
....:         return element._name
....:     except AttributeError:
....:         return '[' + ', '.join(sorted(x._name for x in element)) + ']'
sage: P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 10 graphics primitives

>>> from sage.all import *
>>> P = M.subset_poset(open_covers=True, points=[b])                      # needs sage.graphs
>>> def label(element):
...     if isinstance(element, str):
...         return element
...     try:
...         return element._name
...     except AttributeError:
...         return '[' + ', '.join(sorted(x._name for x in element)) + ']'
>>> P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 10 graphics primitives

P = M.subset_poset(open_covers=True, points=[b])                      # needs sage.graphs
def label(element):
    if isinstance(element, str):
        return element
    try:
        return element._name
    except AttributeError:
        return '[' + ', '.join(sorted(x._name for x in element)) + ']'
P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
../../_images/subset-1.svg
declare_equal(*others)[source]

Declare that self and others are the same sets.

INPUT:

  • others – finitely many subsets or iterables of subsets of the same manifold as self

EXAMPLES:

sage: M = Manifold(2, 'M')
sage: U = M.open_subset('U')
sage: V = M.open_subset('V')
sage: Vs = [M.open_subset(f'V{i}') for i in range(2)]
sage: UV = U.intersection(V)
sage: W = UV.open_subset('W')
sage: P = M.subset_poset()                                                  # needs sage.graphs
sage: def label(element):
....:     return element._name
sage: P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 15 graphics primitives
sage: V.declare_equal(Vs)
sage: P = M.subset_poset()                                                  # needs sage.graphs
sage: P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 11 graphics primitives
sage: W.declare_equal(U)
sage: P = M.subset_poset()                                                  # needs sage.graphs
sage: P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 6 graphics primitives

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M')
>>> U = M.open_subset('U')
>>> V = M.open_subset('V')
>>> Vs = [M.open_subset(f'V{i}') for i in range(Integer(2))]
>>> UV = U.intersection(V)
>>> W = UV.open_subset('W')
>>> P = M.subset_poset()                                                  # needs sage.graphs
>>> def label(element):
...     return element._name
>>> P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 15 graphics primitives
>>> V.declare_equal(Vs)
>>> P = M.subset_poset()                                                  # needs sage.graphs
>>> P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 11 graphics primitives
>>> W.declare_equal(U)
>>> P = M.subset_poset()                                                  # needs sage.graphs
>>> P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 6 graphics primitives

M = Manifold(2, 'M')
U = M.open_subset('U')
V = M.open_subset('V')
Vs = [M.open_subset(f'V{i}') for i in range(2)]
UV = U.intersection(V)
W = UV.open_subset('W')
P = M.subset_poset()                                                  # needs sage.graphs
def label(element):
    return element._name
P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
V.declare_equal(Vs)
P = M.subset_poset()                                                  # needs sage.graphs
P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
W.declare_equal(U)
P = M.subset_poset()                                                  # needs sage.graphs
P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
../../_images/subset-2.svg
declare_nonempty()[source]

Declare that self is nonempty.

Once declared nonempty, self (or any of its supersets) cannot be declared empty.

This is equivalent to defining a point on self using point() but is cheaper than actually creating a ManifoldPoint instance.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: A = M.subset('A', is_open=True)
sage: AA = A.subset('AA')
sage: AA.declare_nonempty()
sage: A.has_defined_points()
True
sage: A.declare_empty()
Traceback (most recent call last):
...
TypeError: cannot be empty because it has defined points

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> A = M.subset('A', is_open=True)
>>> AA = A.subset('AA')
>>> AA.declare_nonempty()
>>> A.has_defined_points()
True
>>> A.declare_empty()
Traceback (most recent call last):
...
TypeError: cannot be empty because it has defined points

M = Manifold(2, 'M', structure='topological')
A = M.subset('A', is_open=True)
AA = A.subset('AA')
AA.declare_nonempty()
A.has_defined_points()
A.declare_empty()
declare_subset(*supersets)[source]

Declare self to be a subset of each of the given supersets.

INPUT:

  • supersets – other subsets of the same manifold

EXAMPLES:

sage: M = Manifold(2, 'M')
sage: U1 = M.open_subset('U1')
sage: U2 = M.open_subset('U2')
sage: V = M.open_subset('V')
sage: V.superset_family()
Set {M, V} of open subsets of the 2-dimensional differentiable manifold M
sage: U1.subset_family()
Set {U1} of open subsets of the 2-dimensional differentiable manifold M
sage: P = M.subset_poset()                                                  # needs sage.graphs
sage: def label(element):
....:     return element._name
sage: P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 8 graphics primitives
sage: V.declare_subset(U1, U2)
sage: V.superset_family()
Set {M, U1, U2, V} of open subsets of the 2-dimensional differentiable manifold M
sage: P = M.subset_poset()                                                  # needs sage.graphs
sage: P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 9 graphics primitives

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M')
>>> U1 = M.open_subset('U1')
>>> U2 = M.open_subset('U2')
>>> V = M.open_subset('V')
>>> V.superset_family()
Set {M, V} of open subsets of the 2-dimensional differentiable manifold M
>>> U1.subset_family()
Set {U1} of open subsets of the 2-dimensional differentiable manifold M
>>> P = M.subset_poset()                                                  # needs sage.graphs
>>> def label(element):
...     return element._name
>>> P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 8 graphics primitives
>>> V.declare_subset(U1, U2)
>>> V.superset_family()
Set {M, U1, U2, V} of open subsets of the 2-dimensional differentiable manifold M
>>> P = M.subset_poset()                                                  # needs sage.graphs
>>> P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 9 graphics primitives

M = Manifold(2, 'M')
U1 = M.open_subset('U1')
U2 = M.open_subset('U2')
V = M.open_subset('V')
V.superset_family()
U1.subset_family()
P = M.subset_poset()                                                  # needs sage.graphs
def label(element):
    return element._name
P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
V.declare_subset(U1, U2)
V.superset_family()
P = M.subset_poset()                                                  # needs sage.graphs
P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot

Subsets in a directed cycle of inclusions are equal:

sage: M.declare_subset(V)
sage: M.superset_family()
Set {M, U1, U2, V} of open subsets of the 2-dimensional differentiable manifold M
sage: M.equal_subset_family()
Set {M, U1, U2, V} of open subsets of the 2-dimensional differentiable manifold M
sage: P = M.subset_poset()                                                  # needs sage.graphs
sage: P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 2 graphics primitives

>>> from sage.all import *
>>> M.declare_subset(V)
>>> M.superset_family()
Set {M, U1, U2, V} of open subsets of the 2-dimensional differentiable manifold M
>>> M.equal_subset_family()
Set {M, U1, U2, V} of open subsets of the 2-dimensional differentiable manifold M
>>> P = M.subset_poset()                                                  # needs sage.graphs
>>> P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 2 graphics primitives

M.declare_subset(V)
M.superset_family()
M.equal_subset_family()
P = M.subset_poset()                                                  # needs sage.graphs
P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
../../_images/subset-3.svg
declare_superset(*subsets)[source]

Declare self to be a superset of each of the given subsets.

INPUT:

  • subsets – other subsets of the same manifold

EXAMPLES:

sage: M = Manifold(2, 'M')
sage: U = M.open_subset('U')
sage: V1 = M.open_subset('V1')
sage: V2 = M.open_subset('V2')
sage: W = V1.intersection(V2)
sage: U.subset_family()
Set {U} of open subsets of the 2-dimensional differentiable manifold M
sage: P = M.subset_poset()                                                  # needs sage.graphs
sage: def label(element):
....:     return element._name
sage: P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 11 graphics primitives
sage: U.declare_superset(V1, V2)
sage: U.subset_family()
Set {U, V1, V1_inter_V2, V2} of open subsets of the 2-dimensional differentiable manifold M
sage: P = M.subset_poset()                                                  # needs sage.graphs
sage: P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 11 graphics primitives

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M')
>>> U = M.open_subset('U')
>>> V1 = M.open_subset('V1')
>>> V2 = M.open_subset('V2')
>>> W = V1.intersection(V2)
>>> U.subset_family()
Set {U} of open subsets of the 2-dimensional differentiable manifold M
>>> P = M.subset_poset()                                                  # needs sage.graphs
>>> def label(element):
...     return element._name
>>> P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 11 graphics primitives
>>> U.declare_superset(V1, V2)
>>> U.subset_family()
Set {U, V1, V1_inter_V2, V2} of open subsets of the 2-dimensional differentiable manifold M
>>> P = M.subset_poset()                                                  # needs sage.graphs
>>> P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 11 graphics primitives

M = Manifold(2, 'M')
U = M.open_subset('U')
V1 = M.open_subset('V1')
V2 = M.open_subset('V2')
W = V1.intersection(V2)
U.subset_family()
P = M.subset_poset()                                                  # needs sage.graphs
def label(element):
    return element._name
P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
U.declare_superset(V1, V2)
U.subset_family()
P = M.subset_poset()                                                  # needs sage.graphs
P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot

Subsets in a directed cycle of inclusions are equal:

sage: W.declare_superset(U)
sage: W.subset_family()
Set {U, V1, V1_inter_V2, V2} of open subsets of the 2-dimensional differentiable manifold M
sage: W.equal_subset_family()
Set {U, V1, V1_inter_V2, V2} of open subsets of the 2-dimensional differentiable manifold M
sage: P = M.subset_poset()                                                  # needs sage.graphs
sage: P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 4 graphics primitives

>>> from sage.all import *
>>> W.declare_superset(U)
>>> W.subset_family()
Set {U, V1, V1_inter_V2, V2} of open subsets of the 2-dimensional differentiable manifold M
>>> W.equal_subset_family()
Set {U, V1, V1_inter_V2, V2} of open subsets of the 2-dimensional differentiable manifold M
>>> P = M.subset_poset()                                                  # needs sage.graphs
>>> P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 4 graphics primitives

W.declare_superset(U)
W.subset_family()
W.equal_subset_family()
P = M.subset_poset()                                                  # needs sage.graphs
P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
../../_images/subset-4.svg
declare_union(disjoint, *subsets_or_families)[source]

Declare that the current subset is the union of two subsets.

Suppose \(U\) is the current subset, then this method declares that \(U = \bigcup_{S\in F} S\).

INPUT:

  • subsets_or_families – finitely many subsets or iterables of subsets

  • disjoint – boolean (default: False); whether to declare the subsets pairwise disjoint

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: AB = M.subset('AB')
sage: A = AB.subset('A')
sage: B = AB.subset('B')
sage: def label(element):
....:     try:
....:         return element._name
....:     except AttributeError:
....:         return '[' + ', '.join(sorted(x._name for x in element)) + ']'
sage: P = M.subset_poset(open_covers=True); P                               # needs sage.graphs
Finite poset containing 4 elements
sage: P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 8 graphics primitives

sage: AB.declare_union(A, B)
sage: A.union(B)
Subset AB of the 2-dimensional topological manifold M
sage: P = M.subset_poset(open_covers=True); P                               # needs sage.graphs
Finite poset containing 4 elements
sage: P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 8 graphics primitives

sage: B1 = B.subset('B1', is_open=True)
sage: B2 = B.subset('B2', is_open=True)
sage: B.declare_union(B1, B2, disjoint=True)
sage: P = M.subset_poset(open_covers=True); P                               # needs sage.graphs
Finite poset containing 9 elements
sage: P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 19 graphics primitives

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> AB = M.subset('AB')
>>> A = AB.subset('A')
>>> B = AB.subset('B')
>>> def label(element):
...     try:
...         return element._name
...     except AttributeError:
...         return '[' + ', '.join(sorted(x._name for x in element)) + ']'
>>> P = M.subset_poset(open_covers=True); P                               # needs sage.graphs
Finite poset containing 4 elements
>>> P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 8 graphics primitives

>>> AB.declare_union(A, B)
>>> A.union(B)
Subset AB of the 2-dimensional topological manifold M
>>> P = M.subset_poset(open_covers=True); P                               # needs sage.graphs
Finite poset containing 4 elements
>>> P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 8 graphics primitives

>>> B1 = B.subset('B1', is_open=True)
>>> B2 = B.subset('B2', is_open=True)
>>> B.declare_union(B1, B2, disjoint=True)
>>> P = M.subset_poset(open_covers=True); P                               # needs sage.graphs
Finite poset containing 9 elements
>>> P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
Graphics object consisting of 19 graphics primitives

M = Manifold(2, 'M', structure='topological')
AB = M.subset('AB')
A = AB.subset('A')
B = AB.subset('B')
def label(element):
    try:
        return element._name
    except AttributeError:
        return '[' + ', '.join(sorted(x._name for x in element)) + ']'
P = M.subset_poset(open_covers=True); P                               # needs sage.graphs
P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
AB.declare_union(A, B)
A.union(B)
P = M.subset_poset(open_covers=True); P                               # needs sage.graphs
P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
B1 = B.subset('B1', is_open=True)
B2 = B.subset('B2', is_open=True)
B.declare_union(B1, B2, disjoint=True)
P = M.subset_poset(open_covers=True); P                               # needs sage.graphs
P.plot(element_labels={element: label(element) for element in P})     # needs sage.graphs sage.plot
../../_images/subset-5.svg
difference(other, name=None, latex_name=None, is_open=False)[source]

Return the set difference of self minus other.

INPUT:

  • other – another subset of the same manifold

  • name – (default: None) name given to the difference in the case the latter has to be created; the default is self._name minus other._name

  • latex_name – (default: None) LaTeX symbol to denote the difference in the case the latter has to be created; the default is built upon the symbol \(\setminus\)

  • is_open – boolean (default: False); if True, the created subset is assumed to be open with respect to the manifold’s topology

OUTPUT:

  • instance of ManifoldSubset representing the subset that is self minus other

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: A = M.subset('A')
sage: CA = M.difference(A); CA
Subset M_minus_A of the 2-dimensional topological manifold M
sage: latex(CA)
M\setminus A
sage: A.intersection(CA).is_empty()
True
sage: A.union(CA)
2-dimensional topological manifold M

sage: O = M.open_subset('O')
sage: CO = M.difference(O); CO
Subset M_minus_O of the 2-dimensional topological manifold M
sage: M.difference(O) is CO
True

sage: CO2 = M.difference(O, is_open=True, name='CO2'); CO2
Open subset CO2 of the 2-dimensional topological manifold M
sage: CO is CO2
False
sage: CO.is_subset(CO2) and CO2.is_subset(CO)
True
sage: M.difference(O, is_open=True)
Open subset CO2 of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> A = M.subset('A')
>>> CA = M.difference(A); CA
Subset M_minus_A of the 2-dimensional topological manifold M
>>> latex(CA)
M\setminus A
>>> A.intersection(CA).is_empty()
True
>>> A.union(CA)
2-dimensional topological manifold M

>>> O = M.open_subset('O')
>>> CO = M.difference(O); CO
Subset M_minus_O of the 2-dimensional topological manifold M
>>> M.difference(O) is CO
True

>>> CO2 = M.difference(O, is_open=True, name='CO2'); CO2
Open subset CO2 of the 2-dimensional topological manifold M
>>> CO is CO2
False
>>> CO.is_subset(CO2) and CO2.is_subset(CO)
True
>>> M.difference(O, is_open=True)
Open subset CO2 of the 2-dimensional topological manifold M

M = Manifold(2, 'M', structure='topological')
A = M.subset('A')
CA = M.difference(A); CA
latex(CA)
A.intersection(CA).is_empty()
A.union(CA)
O = M.open_subset('O')
CO = M.difference(O); CO
M.difference(O) is CO
CO2 = M.difference(O, is_open=True, name='CO2'); CO2
CO is CO2
CO.is_subset(CO2) and CO2.is_subset(CO)
M.difference(O, is_open=True)

Since \(O\) is open and we have asked \(M\setminus O\) to be open, \(O\) is a clopen set (if \(O\neq M\) and \(O\neq\emptyset\), this implies that \(M\) is not connected):

sage: O.is_closed() and O.is_open()
True

>>> from sage.all import *
>>> O.is_closed() and O.is_open()
True

O.is_closed() and O.is_open()
equal_subset_family()[source]

Generate the declared manifold subsets that are equal to self.

Note

If you only need to iterate over the equal sets in arbitrary order, you can use the generator method equal_subsets() instead.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: U = M.open_subset('U')
sage: V = U.subset('V')
sage: V.declare_equal(M)
sage: V.equal_subset_family()
Set {M, U, V} of subsets of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> U = M.open_subset('U')
>>> V = U.subset('V')
>>> V.declare_equal(M)
>>> V.equal_subset_family()
Set {M, U, V} of subsets of the 2-dimensional topological manifold M

M = Manifold(2, 'M', structure='topological')
U = M.open_subset('U')
V = U.subset('V')
V.declare_equal(M)
V.equal_subset_family()
equal_subsets()[source]

Generate the declared manifold subsets that are equal to self.

Note

To get the equal subsets as a family, sorted by name, use the method equal_subset_family() instead.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: U = M.open_subset('U')
sage: V = U.subset('V')
sage: V.declare_equal(M)
sage: sorted(V.equal_subsets(), key=lambda v: v._name)
[2-dimensional topological manifold M,
 Open subset U of the 2-dimensional topological manifold M,
 Subset V of the 2-dimensional topological manifold M]

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> U = M.open_subset('U')
>>> V = U.subset('V')
>>> V.declare_equal(M)
>>> sorted(V.equal_subsets(), key=lambda v: v._name)
[2-dimensional topological manifold M,
 Open subset U of the 2-dimensional topological manifold M,
 Subset V of the 2-dimensional topological manifold M]

M = Manifold(2, 'M', structure='topological')
U = M.open_subset('U')
V = U.subset('V')
V.declare_equal(M)
sorted(V.equal_subsets(), key=lambda v: v._name)
get_subset(name)[source]

Get a subset by its name.

The subset must have been previously created by the method subset() (or open_subset())

INPUT:

  • name – string; name of the subset

OUTPUT:

EXAMPLES:

sage: M = Manifold(4, 'M', structure='topological')
sage: A = M.subset('A')
sage: B = A.subset('B')
sage: U = M.open_subset('U')
sage: M.subset_family()
Set {A, B, M, U} of subsets of the 4-dimensional topological manifold M
sage: M.get_subset('A')
Subset A of the 4-dimensional topological manifold M
sage: M.get_subset('A') is A
True
sage: M.get_subset('B') is B
True
sage: A.get_subset('B') is B
True
sage: M.get_subset('U')
Open subset U of the 4-dimensional topological manifold M
sage: M.get_subset('U') is U
True

>>> from sage.all import *
>>> M = Manifold(Integer(4), 'M', structure='topological')
>>> A = M.subset('A')
>>> B = A.subset('B')
>>> U = M.open_subset('U')
>>> M.subset_family()
Set {A, B, M, U} of subsets of the 4-dimensional topological manifold M
>>> M.get_subset('A')
Subset A of the 4-dimensional topological manifold M
>>> M.get_subset('A') is A
True
>>> M.get_subset('B') is B
True
>>> A.get_subset('B') is B
True
>>> M.get_subset('U')
Open subset U of the 4-dimensional topological manifold M
>>> M.get_subset('U') is U
True

M = Manifold(4, 'M', structure='topological')
A = M.subset('A')
B = A.subset('B')
U = M.open_subset('U')
M.subset_family()
M.get_subset('A')
M.get_subset('A') is A
M.get_subset('B') is B
A.get_subset('B') is B
M.get_subset('U')
M.get_subset('U') is U
has_defined_points(subsets=True)[source]

Return whether any points have been defined on self or any of its subsets.

INPUT:

  • subsets – boolean (default: True); if False, only consider points that have been defined directly on self. If True, also consider points on all subsets.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: A = M.subset('A', is_open=True)
sage: AA = A.subset('AA')
sage: AA.point()
Point on the 2-dimensional topological manifold M
sage: AA.has_defined_points()
True
sage: A.has_defined_points(subsets=False)
False
sage: A.has_defined_points()
True

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> A = M.subset('A', is_open=True)
>>> AA = A.subset('AA')
>>> AA.point()
Point on the 2-dimensional topological manifold M
>>> AA.has_defined_points()
True
>>> A.has_defined_points(subsets=False)
False
>>> A.has_defined_points()
True

M = Manifold(2, 'M', structure='topological')
A = M.subset('A', is_open=True)
AA = A.subset('AA')
AA.point()
AA.has_defined_points()
A.has_defined_points(subsets=False)
A.has_defined_points()
intersection(name, latex_name, *others)[source]

Return the intersection of the current subset with other subsets.

This method may return a previously constructed intersection instead of creating a new subset. In this case, name and latex_name are not used.

INPUT:

  • others – other subsets of the same manifold

  • name – (default: None) name given to the intersection in the case the latter has to be created; the default is self._name inter other._name

  • latex_name – (default: None) LaTeX symbol to denote the intersection in the case the latter has to be created; the default is built upon the symbol \(\cap\)

OUTPUT:

  • instance of ManifoldSubset representing the subset that is the intersection of the current subset with others

EXAMPLES:

Intersection of two subsets:

sage: M = Manifold(2, 'M', structure='topological')
sage: a = M.subset('A')
sage: b = M.subset('B')
sage: c = a.intersection(b); c
Subset A_inter_B of the 2-dimensional topological manifold M
sage: a.subset_family()
Set {A, A_inter_B} of subsets of the 2-dimensional topological manifold M
sage: b.subset_family()
Set {A_inter_B, B} of subsets of the 2-dimensional topological manifold M
sage: c.superset_family()
Set {A, A_inter_B, B, M} of subsets of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> a = M.subset('A')
>>> b = M.subset('B')
>>> c = a.intersection(b); c
Subset A_inter_B of the 2-dimensional topological manifold M
>>> a.subset_family()
Set {A, A_inter_B} of subsets of the 2-dimensional topological manifold M
>>> b.subset_family()
Set {A_inter_B, B} of subsets of the 2-dimensional topological manifold M
>>> c.superset_family()
Set {A, A_inter_B, B, M} of subsets of the 2-dimensional topological manifold M

M = Manifold(2, 'M', structure='topological')
a = M.subset('A')
b = M.subset('B')
c = a.intersection(b); c
a.subset_family()
b.subset_family()
c.superset_family()

Intersection of six subsets:

sage: T = Manifold(2, 'T', structure='topological')
sage: S = [T.subset(f'S{i}') for i in range(6)]
sage: [S[i].intersection(S[i+3]) for i in range(3)]
[Subset S0_inter_S3 of the 2-dimensional topological manifold T,
 Subset S1_inter_S4 of the 2-dimensional topological manifold T,
 Subset S2_inter_S5 of the 2-dimensional topological manifold T]
sage: inter_S_i = T.intersection(*S, name='inter_S_i'); inter_S_i
Subset inter_S_i of the 2-dimensional topological manifold T
sage: inter_S_i.superset_family()
Set {S0, S0_inter_S3, S0_inter_S3_inter_S1_inter_S4, S1, S1_inter_S4,
     S2, S2_inter_S5, S3, S4, S5, T, inter_S_i} of
 subsets of the 2-dimensional topological manifold T

>>> from sage.all import *
>>> T = Manifold(Integer(2), 'T', structure='topological')
>>> S = [T.subset(f'S{i}') for i in range(Integer(6))]
>>> [S[i].intersection(S[i+Integer(3)]) for i in range(Integer(3))]
[Subset S0_inter_S3 of the 2-dimensional topological manifold T,
 Subset S1_inter_S4 of the 2-dimensional topological manifold T,
 Subset S2_inter_S5 of the 2-dimensional topological manifold T]
>>> inter_S_i = T.intersection(*S, name='inter_S_i'); inter_S_i
Subset inter_S_i of the 2-dimensional topological manifold T
>>> inter_S_i.superset_family()
Set {S0, S0_inter_S3, S0_inter_S3_inter_S1_inter_S4, S1, S1_inter_S4,
     S2, S2_inter_S5, S3, S4, S5, T, inter_S_i} of
 subsets of the 2-dimensional topological manifold T

T = Manifold(2, 'T', structure='topological')
S = [T.subset(f'S{i}') for i in range(6)]
[S[i].intersection(S[i+3]) for i in range(3)]
inter_S_i = T.intersection(*S, name='inter_S_i'); inter_S_i
inter_S_i.superset_family()
../../_images/subset-6.svg
is_closed()[source]

Return if self is a closed set.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: M.is_closed()
True
sage: also_M = M.subset('also_M')
sage: M.declare_subset(also_M)
sage: also_M.is_closed()
True

sage: A = M.subset('A')
sage: A.is_closed()
False
sage: A.declare_empty()
sage: A.is_closed()
True

sage: N = M.open_subset('N')
sage: N.is_closed()
False
sage: complement_N = M.subset('complement_N')
sage: M.declare_union(N, complement_N, disjoint=True)
sage: complement_N.is_closed()
True

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> M.is_closed()
True
>>> also_M = M.subset('also_M')
>>> M.declare_subset(also_M)
>>> also_M.is_closed()
True

>>> A = M.subset('A')
>>> A.is_closed()
False
>>> A.declare_empty()
>>> A.is_closed()
True

>>> N = M.open_subset('N')
>>> N.is_closed()
False
>>> complement_N = M.subset('complement_N')
>>> M.declare_union(N, complement_N, disjoint=True)
>>> complement_N.is_closed()
True

M = Manifold(2, 'M', structure='topological')
M.is_closed()
also_M = M.subset('also_M')
M.declare_subset(also_M)
also_M.is_closed()
A = M.subset('A')
A.is_closed()
A.declare_empty()
A.is_closed()
N = M.open_subset('N')
N.is_closed()
complement_N = M.subset('complement_N')
M.declare_union(N, complement_N, disjoint=True)
complement_N.is_closed()
is_empty()[source]

Return whether the current subset is empty.

By default, manifold subsets are considered nonempty: The method point() can be used to define points on it, either with or without coordinates some chart.

However, using declare_empty(), a subset can be declared empty, and emptiness transfers to all of its subsets.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: A = M.subset('A', is_open=True)
sage: AA = A.subset('AA')
sage: A.is_empty()
False
sage: A.declare_empty()
sage: A.is_empty()
True
sage: AA.is_empty()
True

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> A = M.subset('A', is_open=True)
>>> AA = A.subset('AA')
>>> A.is_empty()
False
>>> A.declare_empty()
>>> A.is_empty()
True
>>> AA.is_empty()
True

M = Manifold(2, 'M', structure='topological')
A = M.subset('A', is_open=True)
AA = A.subset('AA')
A.is_empty()
A.declare_empty()
A.is_empty()
AA.is_empty()
is_open()[source]

Return if self is an open set.

This method always returns False, since open subsets must be constructed as instances of the subclass TopologicalManifold (which redefines is_open)

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: A = M.subset('A')
sage: A.is_open()
False

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> A = M.subset('A')
>>> A.is_open()
False

M = Manifold(2, 'M', structure='topological')
A = M.subset('A')
A.is_open()
is_subset(other)[source]

Return True if and only if self is included in other.

EXAMPLES:

Subsets on a 2-dimensional manifold:

sage: M = Manifold(2, 'M', structure='topological')
sage: a = M.subset('A')
sage: b = a.subset('B')
sage: c = M.subset('C')
sage: a.is_subset(M)
True
sage: b.is_subset(a)
True
sage: b.is_subset(M)
True
sage: a.is_subset(b)
False
sage: c.is_subset(a)
False

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> a = M.subset('A')
>>> b = a.subset('B')
>>> c = M.subset('C')
>>> a.is_subset(M)
True
>>> b.is_subset(a)
True
>>> b.is_subset(M)
True
>>> a.is_subset(b)
False
>>> c.is_subset(a)
False

M = Manifold(2, 'M', structure='topological')
a = M.subset('A')
b = a.subset('B')
c = M.subset('C')
a.is_subset(M)
b.is_subset(a)
b.is_subset(M)
a.is_subset(b)
c.is_subset(a)
lift(p)[source]

Return the lift of p to the ambient manifold of self.

INPUT:

  • p – point of the subset

OUTPUT: the same point, considered as a point of the ambient manifold

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: A = M.open_subset('A', coord_def={X: x>0})
sage: p = A((1, -2)); p
Point on the 2-dimensional topological manifold M
sage: p.parent()
Open subset A of the 2-dimensional topological manifold M
sage: q = A.lift(p); q
Point on the 2-dimensional topological manifold M
sage: q.parent()
2-dimensional topological manifold M
sage: q.coord()
(1, -2)
sage: (p == q) and (q == p)
True

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> X = M.chart(names=('x', 'y',)); (x, y,) = X._first_ngens(2)
>>> A = M.open_subset('A', coord_def={X: x>Integer(0)})
>>> p = A((Integer(1), -Integer(2))); p
Point on the 2-dimensional topological manifold M
>>> p.parent()
Open subset A of the 2-dimensional topological manifold M
>>> q = A.lift(p); q
Point on the 2-dimensional topological manifold M
>>> q.parent()
2-dimensional topological manifold M
>>> q.coord()
(1, -2)
>>> (p == q) and (q == p)
True

M = Manifold(2, 'M', structure='topological')
X.<x,y> = M.chart()
A = M.open_subset('A', coord_def={X: x>0})
p = A((1, -2)); p
p.parent()
q = A.lift(p); q
q.parent()
q.coord()
(p == q) and (q == p)
list_of_subsets()[source]

Return the list of subsets that have been defined on the current subset.

The list is sorted by the alphabetical names of the subsets.

OUTPUT:

  • a list containing all the subsets that have been defined on the current subset

Note

This method is deprecated.

To get the subsets as a ManifoldSubsetFiniteFamily instance (which sorts its elements alphabetically by name), use subset_family() instead.

To loop over the subsets in an arbitrary order, use the generator method subsets() instead.

EXAMPLES:

List of subsets of a 2-dimensional manifold (deprecated):

sage: M = Manifold(2, 'M', structure='topological')
sage: U = M.open_subset('U')
sage: V = M.subset('V')
sage: M.list_of_subsets()
doctest:...: DeprecationWarning: the method list_of_subsets of ManifoldSubset
 is deprecated; use subset_family or subsets instead...
[2-dimensional topological manifold M,
 Open subset U of the 2-dimensional topological manifold M,
 Subset V of the 2-dimensional topological manifold M]

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> U = M.open_subset('U')
>>> V = M.subset('V')
>>> M.list_of_subsets()
doctest:...: DeprecationWarning: the method list_of_subsets of ManifoldSubset
 is deprecated; use subset_family or subsets instead...
[2-dimensional topological manifold M,
 Open subset U of the 2-dimensional topological manifold M,
 Subset V of the 2-dimensional topological manifold M]

M = Manifold(2, 'M', structure='topological')
U = M.open_subset('U')
V = M.subset('V')
M.list_of_subsets()

Using subset_family() instead (recommended when order matters):

sage: M.subset_family()
Set {M, U, V} of subsets of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> M.subset_family()
Set {M, U, V} of subsets of the 2-dimensional topological manifold M

M.subset_family()

The method subsets() generates the subsets in an unspecified order. To create a set:

sage: frozenset(M.subsets())  # random (set output)
{Subset V of the 2-dimensional topological manifold M,
 2-dimensional topological manifold M,
 Open subset U of the 2-dimensional topological manifold M}

>>> from sage.all import *
>>> frozenset(M.subsets())  # random (set output)
{Subset V of the 2-dimensional topological manifold M,
 2-dimensional topological manifold M,
 Open subset U of the 2-dimensional topological manifold M}

frozenset(M.subsets())  # random (set output)
manifold()[source]

Return the ambient manifold of self.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: A = M.subset('A')
sage: A.manifold()
2-dimensional topological manifold M
sage: A.manifold() is M
True
sage: B = A.subset('B')
sage: B.manifold() is M
True

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> A = M.subset('A')
>>> A.manifold()
2-dimensional topological manifold M
>>> A.manifold() is M
True
>>> B = A.subset('B')
>>> B.manifold() is M
True

M = Manifold(2, 'M', structure='topological')
A = M.subset('A')
A.manifold()
A.manifold() is M
B = A.subset('B')
B.manifold() is M

An alias is ambient:

sage: A.ambient() is A.manifold()
True

>>> from sage.all import *
>>> A.ambient() is A.manifold()
True

A.ambient() is A.manifold()
open_cover_family(trivial=True, supersets=False)[source]

Return the family of open covers of the current subset.

If the current subset, \(A\) say, is a subset of the manifold \(M\), an open cover of \(A\) is a ManifoldSubsetFiniteFamily \(F\) of open subsets \(U \in F\) of \(M\) such that

\[A \subset \bigcup_{U \in F} U.\]

If \(A\) is open, we ask that the above inclusion is actually an identity:

\[A = \bigcup_{U \in F} U.\]

The family is sorted lexicographically by the names of the subsets forming the open covers.

Note

If you only need to iterate over the open covers in arbitrary order, you can use the generator method open_covers() instead.

INPUT:

  • trivial – boolean (default: True); if self is open, include the trivial open cover of self by itself

  • supersets – boolean (default: False); if True, include open covers of all the supersets. It can also be an iterable of supersets to include

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: M.open_cover_family()
Set {{M}} of objects of the 2-dimensional topological manifold M
sage: U = M.open_subset('U')
sage: U.open_cover_family()
Set {{U}} of objects of the 2-dimensional topological manifold M
sage: A = U.open_subset('A')
sage: B = U.open_subset('B')
sage: U.declare_union(A,B)
sage: U.open_cover_family()
Set {{A, B}, {U}} of objects of the 2-dimensional topological manifold M
sage: U.open_cover_family(trivial=False)
Set {{A, B}} of objects of the 2-dimensional topological manifold M
sage: V = M.open_subset('V')
sage: M.declare_union(U,V)
sage: M.open_cover_family()
Set {{A, B, V}, {M}, {U, V}} of objects of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> M.open_cover_family()
Set {{M}} of objects of the 2-dimensional topological manifold M
>>> U = M.open_subset('U')
>>> U.open_cover_family()
Set {{U}} of objects of the 2-dimensional topological manifold M
>>> A = U.open_subset('A')
>>> B = U.open_subset('B')
>>> U.declare_union(A,B)
>>> U.open_cover_family()
Set {{A, B}, {U}} of objects of the 2-dimensional topological manifold M
>>> U.open_cover_family(trivial=False)
Set {{A, B}} of objects of the 2-dimensional topological manifold M
>>> V = M.open_subset('V')
>>> M.declare_union(U,V)
>>> M.open_cover_family()
Set {{A, B, V}, {M}, {U, V}} of objects of the 2-dimensional topological manifold M

M = Manifold(2, 'M', structure='topological')
M.open_cover_family()
U = M.open_subset('U')
U.open_cover_family()
A = U.open_subset('A')
B = U.open_subset('B')
U.declare_union(A,B)
U.open_cover_family()
U.open_cover_family(trivial=False)
V = M.open_subset('V')
M.declare_union(U,V)
M.open_cover_family()
open_covers(trivial=True, supersets=False)[source]

Generate the open covers of the current subset.

If the current subset, \(A\) say, is a subset of the manifold \(M\), an open cover of \(A\) is a ManifoldSubsetFiniteFamily \(F\) of open subsets \(U \in F\) of \(M\) such that

\[A \subset \bigcup_{U \in F} U.\]

If \(A\) is open, we ask that the above inclusion is actually an identity:

\[A = \bigcup_{U \in F} U.\]

Note

To get the open covers as a family, sorted lexicographically by the names of the subsets forming the open covers, use the method open_cover_family() instead.

INPUT:

  • trivial – boolean (default: True); if self is open, include the trivial open cover of self by itself

  • supersets – boolean (default: False); if True, include open covers of all the supersets. It can also be an iterable of supersets to include.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: M.open_covers()
<generator ...>
sage: list(M.open_covers())
[Set {M} of open subsets of the 2-dimensional topological manifold M]
sage: U = M.open_subset('U')
sage: list(U.open_covers())
[Set {U} of open subsets of the 2-dimensional topological manifold M]
sage: A = U.open_subset('A')
sage: B = U.open_subset('B')
sage: U.declare_union(A,B)
sage: list(U.open_covers())
[Set {U} of open subsets of the 2-dimensional topological manifold M,
 Set {A, B} of open subsets of the 2-dimensional topological manifold M]
sage: list(U.open_covers(trivial=False))
[Set {A, B} of open subsets of the 2-dimensional topological manifold M]
sage: V = M.open_subset('V')
sage: M.declare_union(U,V)
sage: list(M.open_covers())
[Set {M} of open subsets of the 2-dimensional topological manifold M,
 Set {U, V} of open subsets of the 2-dimensional topological manifold M,
 Set {A, B, V} of open subsets of the 2-dimensional topological manifold M]

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> M.open_covers()
<generator ...>
>>> list(M.open_covers())
[Set {M} of open subsets of the 2-dimensional topological manifold M]
>>> U = M.open_subset('U')
>>> list(U.open_covers())
[Set {U} of open subsets of the 2-dimensional topological manifold M]
>>> A = U.open_subset('A')
>>> B = U.open_subset('B')
>>> U.declare_union(A,B)
>>> list(U.open_covers())
[Set {U} of open subsets of the 2-dimensional topological manifold M,
 Set {A, B} of open subsets of the 2-dimensional topological manifold M]
>>> list(U.open_covers(trivial=False))
[Set {A, B} of open subsets of the 2-dimensional topological manifold M]
>>> V = M.open_subset('V')
>>> M.declare_union(U,V)
>>> list(M.open_covers())
[Set {M} of open subsets of the 2-dimensional topological manifold M,
 Set {U, V} of open subsets of the 2-dimensional topological manifold M,
 Set {A, B, V} of open subsets of the 2-dimensional topological manifold M]

M = Manifold(2, 'M', structure='topological')
M.open_covers()
list(M.open_covers())
U = M.open_subset('U')
list(U.open_covers())
A = U.open_subset('A')
B = U.open_subset('B')
U.declare_union(A,B)
list(U.open_covers())
list(U.open_covers(trivial=False))
V = M.open_subset('V')
M.declare_union(U,V)
list(M.open_covers())
open_subset(name, latex_name=None, coord_def={}, supersets=None)[source]

Create an open subset of the manifold that is a subset of self.

An open subset is a set that is (i) included in the manifold and (ii) open with respect to the manifold’s topology. It is a topological manifold by itself. Hence the returned object is an instance of TopologicalManifold.

INPUT:

  • name – name given to the open subset

  • latex_name – (default: None) LaTeX symbol to denote the subset; if none are provided, it is set to name

  • coord_def – (default: {}) definition of the subset in terms of coordinates; coord_def must a be dictionary with keys charts on the manifold and values the symbolic expressions formed by the coordinates to define the subset

  • supersets – (default: only self) list of sets that the new open subset is a subset of

OUTPUT:

EXAMPLES:

sage: M = Manifold(2, 'R^2', structure='topological')
sage: c_cart.<x,y> = M.chart() # Cartesian coordinates on R^2
sage: cl_D = M.subset('cl_D'); cl_D
Subset cl_D of the 2-dimensional topological manifold R^2
sage: D = cl_D.open_subset('D', coord_def={c_cart: x^2+y^2<1}); D
Open subset D of the 2-dimensional topological manifold R^2
sage: D.is_subset(cl_D)
True
sage: D.is_subset(M)
True

sage: M = Manifold(2, 'R^2', structure='differentiable')
sage: c_cart.<x,y> = M.chart() # Cartesian coordinates on R^2
sage: cl_D = M.subset('cl_D'); cl_D
Subset cl_D of the 2-dimensional differentiable manifold R^2
sage: D = cl_D.open_subset('D', coord_def={c_cart: x^2+y^2<1}); D
Open subset D of the 2-dimensional differentiable manifold R^2
sage: D.is_subset(cl_D)
True
sage: D.is_subset(M)
True

sage: M = Manifold(2, 'R^2', structure='Riemannian')
sage: c_cart.<x,y> = M.chart() # Cartesian coordinates on R^2
sage: cl_D = M.subset('cl_D'); cl_D
Subset cl_D of the 2-dimensional Riemannian manifold R^2
sage: D = cl_D.open_subset('D', coord_def={c_cart: x^2+y^2<1}); D
Open subset D of the 2-dimensional Riemannian manifold R^2
sage: D.is_subset(cl_D)
True
sage: D.is_subset(M)
True

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'R^2', structure='topological')
>>> c_cart = M.chart(names=('x', 'y',)); (x, y,) = c_cart._first_ngens(2)# Cartesian coordinates on R^2
>>> cl_D = M.subset('cl_D'); cl_D
Subset cl_D of the 2-dimensional topological manifold R^2
>>> D = cl_D.open_subset('D', coord_def={c_cart: x**Integer(2)+y**Integer(2)<Integer(1)}); D
Open subset D of the 2-dimensional topological manifold R^2
>>> D.is_subset(cl_D)
True
>>> D.is_subset(M)
True

>>> M = Manifold(Integer(2), 'R^2', structure='differentiable')
>>> c_cart = M.chart(names=('x', 'y',)); (x, y,) = c_cart._first_ngens(2)# Cartesian coordinates on R^2
>>> cl_D = M.subset('cl_D'); cl_D
Subset cl_D of the 2-dimensional differentiable manifold R^2
>>> D = cl_D.open_subset('D', coord_def={c_cart: x**Integer(2)+y**Integer(2)<Integer(1)}); D
Open subset D of the 2-dimensional differentiable manifold R^2
>>> D.is_subset(cl_D)
True
>>> D.is_subset(M)
True

>>> M = Manifold(Integer(2), 'R^2', structure='Riemannian')
>>> c_cart = M.chart(names=('x', 'y',)); (x, y,) = c_cart._first_ngens(2)# Cartesian coordinates on R^2
>>> cl_D = M.subset('cl_D'); cl_D
Subset cl_D of the 2-dimensional Riemannian manifold R^2
>>> D = cl_D.open_subset('D', coord_def={c_cart: x**Integer(2)+y**Integer(2)<Integer(1)}); D
Open subset D of the 2-dimensional Riemannian manifold R^2
>>> D.is_subset(cl_D)
True
>>> D.is_subset(M)
True

M = Manifold(2, 'R^2', structure='topological')
c_cart.<x,y> = M.chart() # Cartesian coordinates on R^2
cl_D = M.subset('cl_D'); cl_D
D = cl_D.open_subset('D', coord_def={c_cart: x^2+y^2<1}); D
D.is_subset(cl_D)
D.is_subset(M)
M = Manifold(2, 'R^2', structure='differentiable')
c_cart.<x,y> = M.chart() # Cartesian coordinates on R^2
cl_D = M.subset('cl_D'); cl_D
D = cl_D.open_subset('D', coord_def={c_cart: x^2+y^2<1}); D
D.is_subset(cl_D)
D.is_subset(M)
M = Manifold(2, 'R^2', structure='Riemannian')
c_cart.<x,y> = M.chart() # Cartesian coordinates on R^2
cl_D = M.subset('cl_D'); cl_D
D = cl_D.open_subset('D', coord_def={c_cart: x^2+y^2<1}); D
D.is_subset(cl_D)
D.is_subset(M)
open_superset_family()[source]

Return the family of open supersets of self.

The family is sorted by the alphabetical names of the subsets.

OUTPUT:

Note

If you only need to iterate over the open supersets in arbitrary order, you can use the generator method open_supersets() instead.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: U = M.open_subset('U')
sage: V = U.subset('V')
sage: W = V.subset('W')
sage: W.open_superset_family()
Set {M, U} of open subsets of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> U = M.open_subset('U')
>>> V = U.subset('V')
>>> W = V.subset('W')
>>> W.open_superset_family()
Set {M, U} of open subsets of the 2-dimensional topological manifold M

M = Manifold(2, 'M', structure='topological')
U = M.open_subset('U')
V = U.subset('V')
W = V.subset('W')
W.open_superset_family()
open_supersets()[source]

Generate the open supersets of self.

Note

To get the open supersets as a family, sorted by name, use the method open_superset_family() instead.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: U = M.open_subset('U')
sage: V = U.subset('V')
sage: W = V.subset('W')
sage: sorted(W.open_supersets(), key=lambda S: S._name)
[2-dimensional topological manifold M,
 Open subset U of the 2-dimensional topological manifold M]

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> U = M.open_subset('U')
>>> V = U.subset('V')
>>> W = V.subset('W')
>>> sorted(W.open_supersets(), key=lambda S: S._name)
[2-dimensional topological manifold M,
 Open subset U of the 2-dimensional topological manifold M]

M = Manifold(2, 'M', structure='topological')
U = M.open_subset('U')
V = U.subset('V')
W = V.subset('W')
sorted(W.open_supersets(), key=lambda S: S._name)
point(coords=None, chart=None, name=None, latex_name=None)[source]

Define a point in self.

See ManifoldPoint for a complete documentation.

INPUT:

  • coords – the point coordinates (as a tuple or a list) in the chart specified by chart

  • chart – (default: None) chart in which the point coordinates are given; if None, the coordinates are assumed to refer to the default chart of the current subset

  • name – (default: None) name given to the point

  • latex_name – (default: None) LaTeX symbol to denote the point; if None, the LaTeX symbol is set to name

OUTPUT:

EXAMPLES:

Points on a 2-dimensional manifold:

sage: M = Manifold(2, 'M', structure='topological')
sage: c_xy.<x,y> = M.chart()
sage: p = M.point((1,2), name='p'); p
Point p on the 2-dimensional topological manifold M
sage: p in M
True
sage: a = M.open_subset('A')
sage: c_uv.<u,v> = a.chart()
sage: q = a.point((-1,0), name='q'); q
Point q on the 2-dimensional topological manifold M
sage: q in a
True
sage: p._coordinates
{Chart (M, (x, y)): (1, 2)}
sage: q._coordinates
{Chart (A, (u, v)): (-1, 0)}

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> c_xy = M.chart(names=('x', 'y',)); (x, y,) = c_xy._first_ngens(2)
>>> p = M.point((Integer(1),Integer(2)), name='p'); p
Point p on the 2-dimensional topological manifold M
>>> p in M
True
>>> a = M.open_subset('A')
>>> c_uv = a.chart(names=('u', 'v',)); (u, v,) = c_uv._first_ngens(2)
>>> q = a.point((-Integer(1),Integer(0)), name='q'); q
Point q on the 2-dimensional topological manifold M
>>> q in a
True
>>> p._coordinates
{Chart (M, (x, y)): (1, 2)}
>>> q._coordinates
{Chart (A, (u, v)): (-1, 0)}

M = Manifold(2, 'M', structure='topological')
c_xy.<x,y> = M.chart()
p = M.point((1,2), name='p'); p
p in M
a = M.open_subset('A')
c_uv.<u,v> = a.chart()
q = a.point((-1,0), name='q'); q
q in a
p._coordinates
q._coordinates
retract(p)[source]

Return the retract of p to self.

INPUT:

  • p – point of the ambient manifold

OUTPUT: the same point, considered as a point of the subset

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: A = M.open_subset('A', coord_def={X: x>0})
sage: p = M((1, -2)); p
Point on the 2-dimensional topological manifold M
sage: p.parent()
2-dimensional topological manifold M
sage: q = A.retract(p); q
Point on the 2-dimensional topological manifold M
sage: q.parent()
Open subset A of the 2-dimensional topological manifold M
sage: q.coord()
(1, -2)
sage: (q == p) and (p == q)
True

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> X = M.chart(names=('x', 'y',)); (x, y,) = X._first_ngens(2)
>>> A = M.open_subset('A', coord_def={X: x>Integer(0)})
>>> p = M((Integer(1), -Integer(2))); p
Point on the 2-dimensional topological manifold M
>>> p.parent()
2-dimensional topological manifold M
>>> q = A.retract(p); q
Point on the 2-dimensional topological manifold M
>>> q.parent()
Open subset A of the 2-dimensional topological manifold M
>>> q.coord()
(1, -2)
>>> (q == p) and (p == q)
True

M = Manifold(2, 'M', structure='topological')
X.<x,y> = M.chart()
A = M.open_subset('A', coord_def={X: x>0})
p = M((1, -2)); p
p.parent()
q = A.retract(p); q
q.parent()
q.coord()
(q == p) and (p == q)

Of course, if the point does not belong to A, the retract method fails:

sage: p = M((-1, 3))  #  x < 0, so that p is not in A
sage: q = A.retract(p)
Traceback (most recent call last):
...
ValueError: the Point on the 2-dimensional topological manifold M
 is not in Open subset A of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> p = M((-Integer(1), Integer(3)))  #  x < 0, so that p is not in A
>>> q = A.retract(p)
Traceback (most recent call last):
...
ValueError: the Point on the 2-dimensional topological manifold M
 is not in Open subset A of the 2-dimensional topological manifold M

p = M((-1, 3))  #  x < 0, so that p is not in A
q = A.retract(p)
subset(name, latex_name=None, is_open=False)[source]

Create a subset of the current subset.

INPUT:

  • name – name given to the subset

  • latex_name – (default: None) LaTeX symbol to denote the subset; if none are provided, it is set to name

  • is_open – boolean (default: False); if True, the created subset is assumed to be open with respect to the manifold’s topology

OUTPUT:

EXAMPLES:

Creating a subset of a manifold:

sage: M = Manifold(2, 'M', structure='topological')
sage: a = M.subset('A'); a
Subset A of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> a = M.subset('A'); a
Subset A of the 2-dimensional topological manifold M

M = Manifold(2, 'M', structure='topological')
a = M.subset('A'); a

Creating a subset of A:

sage: b = a.subset('B', latex_name=r'\mathcal{B}'); b
Subset B of the 2-dimensional topological manifold M
sage: latex(b)
\mathcal{B}

>>> from sage.all import *
>>> b = a.subset('B', latex_name=r'\mathcal{B}'); b
Subset B of the 2-dimensional topological manifold M
>>> latex(b)
\mathcal{B}

b = a.subset('B', latex_name=r'\mathcal{B}'); b
latex(b)

We have then:

sage: b.is_subset(a)
True
sage: b in a.subsets()
True

>>> from sage.all import *
>>> b.is_subset(a)
True
>>> b in a.subsets()
True

b.is_subset(a)
b in a.subsets()
subset_digraph(loops=False, quotient=False, open_covers=False, points=False, lower_bound=None)[source]

Return the digraph whose arcs represent subset relations among the subsets of self.

INPUT:

  • loops – boolean (default: False); whether to include the trivial containment of each subset in itself as loops of the digraph

  • quotient – boolean (default: False); whether to contract directed cycles in the graph, replacing equivalence classes of equal subsets by a single vertex. In this case, each vertex of the digraph is a set of ManifoldSubset instances.

  • open_covers – boolean (default: False); whether to include vertices for open covers

  • points – boolean (default: False); whether to include vertices for declared points; this can also be an iterable for the points to include

  • lower_bound – (default: None) only include supersets of this

OUTPUT: a digraph; each vertex of the digraph is either:

EXAMPLES:

sage: # needs sage.graphs
sage: M = Manifold(3, 'M')
sage: U = M.open_subset('U'); V = M.open_subset('V'); W = M.open_subset('W')
sage: D = M.subset_digraph(); D
Digraph on 4 vertices
sage: D.edges(sort=True, key=lambda e: (e[0]._name, e[1]._name))            # needs sage.graphs
[(Set {U} of open subsets of the 3-dimensional differentiable manifold M,
  Set {M} of open subsets of the 3-dimensional differentiable manifold M,
  None),
 (Set {V} of open subsets of the 3-dimensional differentiable manifold M,
  Set {M} of open subsets of the 3-dimensional differentiable manifold M,
  None),
 (Set {W} of open subsets of the 3-dimensional differentiable manifold M,
  Set {M} of open subsets of the 3-dimensional differentiable manifold M,
  None)]
sage: D.plot(layout='acyclic')                                              # needs sage.plot
Graphics object consisting of 8 graphics primitives
sage: def label(element):
....:     try:
....:         return element._name
....:     except AttributeError:
....:         return '[' + ', '.join(sorted(x._name for x in element)) + ']'
sage: D.relabel(label, inplace=False).plot(layout='acyclic')                # needs sage.plot
Graphics object consisting of 8 graphics primitives
sage: VW = V.union(W)
sage: D = M.subset_digraph(); D
Digraph on 5 vertices
sage: D.relabel(label, inplace=False).plot(layout='acyclic')                # needs sage.plot
Graphics object consisting of 12 graphics primitives

>>> from sage.all import *
>>> # needs sage.graphs
>>> M = Manifold(Integer(3), 'M')
>>> U = M.open_subset('U'); V = M.open_subset('V'); W = M.open_subset('W')
>>> D = M.subset_digraph(); D
Digraph on 4 vertices
>>> D.edges(sort=True, key=lambda e: (e[Integer(0)]._name, e[Integer(1)]._name))            # needs sage.graphs
[(Set {U} of open subsets of the 3-dimensional differentiable manifold M,
  Set {M} of open subsets of the 3-dimensional differentiable manifold M,
  None),
 (Set {V} of open subsets of the 3-dimensional differentiable manifold M,
  Set {M} of open subsets of the 3-dimensional differentiable manifold M,
  None),
 (Set {W} of open subsets of the 3-dimensional differentiable manifold M,
  Set {M} of open subsets of the 3-dimensional differentiable manifold M,
  None)]
>>> D.plot(layout='acyclic')                                              # needs sage.plot
Graphics object consisting of 8 graphics primitives
>>> def label(element):
...     try:
...         return element._name
...     except AttributeError:
...         return '[' + ', '.join(sorted(x._name for x in element)) + ']'
>>> D.relabel(label, inplace=False).plot(layout='acyclic')                # needs sage.plot
Graphics object consisting of 8 graphics primitives
>>> VW = V.union(W)
>>> D = M.subset_digraph(); D
Digraph on 5 vertices
>>> D.relabel(label, inplace=False).plot(layout='acyclic')                # needs sage.plot
Graphics object consisting of 12 graphics primitives

# needs sage.graphs
M = Manifold(3, 'M')
U = M.open_subset('U'); V = M.open_subset('V'); W = M.open_subset('W')
D = M.subset_digraph(); D
D.edges(sort=True, key=lambda e: (e[0]._name, e[1]._name))            # needs sage.graphs
D.plot(layout='acyclic')                                              # needs sage.plot
def label(element):
    try:
        return element._name
    except AttributeError:
        return '[' + ', '.join(sorted(x._name for x in element)) + ']'
D.relabel(label, inplace=False).plot(layout='acyclic')                # needs sage.plot
VW = V.union(W)
D = M.subset_digraph(); D
D.relabel(label, inplace=False).plot(layout='acyclic')                # needs sage.plot

If open_covers is True, the digraph includes a special vertex for each nontrivial open cover of a subset:

sage: D = M.subset_digraph(open_covers=True)                                # needs sage.graphs
sage: D.relabel(label, inplace=False).plot(layout='acyclic')                # needs sage.graphs sage.plot
Graphics object consisting of 14 graphics primitives

>>> from sage.all import *
>>> D = M.subset_digraph(open_covers=True)                                # needs sage.graphs
>>> D.relabel(label, inplace=False).plot(layout='acyclic')                # needs sage.graphs sage.plot
Graphics object consisting of 14 graphics primitives

D = M.subset_digraph(open_covers=True)                                # needs sage.graphs
D.relabel(label, inplace=False).plot(layout='acyclic')                # needs sage.graphs sage.plot
../../_images/subset-7.svg
subset_family()[source]

Return the family of subsets that have been defined on the current subset.

The family is sorted by the alphabetical names of the subsets.

OUTPUT:

Note

If you only need to iterate over the subsets in arbitrary order, you can use the generator method subsets() instead.

EXAMPLES:

Subsets of a 2-dimensional manifold:

sage: M = Manifold(2, 'M', structure='topological')
sage: U = M.open_subset('U')
sage: V = M.subset('V')
sage: M.subset_family()
Set {M, U, V} of subsets of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> U = M.open_subset('U')
>>> V = M.subset('V')
>>> M.subset_family()
Set {M, U, V} of subsets of the 2-dimensional topological manifold M

M = Manifold(2, 'M', structure='topological')
U = M.open_subset('U')
V = M.subset('V')
M.subset_family()
subset_poset(open_covers=False, points=False, lower_bound=None)[source]

Return the poset of equivalence classes of the subsets of self.

Each element of the poset is a set of ManifoldSubset instances, which are known to be equal.

INPUT:

  • open_covers – boolean (default: False); whether to include vertices for open covers

  • points – boolean (default: False); whether to include vertices for declared points; this can also be an iterable for the points to include

  • lower_bound – (default: None) only include supersets of this

EXAMPLES:

sage: # needs sage.graphs
sage: M = Manifold(3, 'M')
sage: U = M.open_subset('U'); V = M.open_subset('V'); W = M.open_subset('W')
sage: P = M.subset_poset(); P
Finite poset containing 4 elements
sage: P.plot(element_labels={element: element._name for element in P})      # needs sage.plot
Graphics object consisting of 8 graphics primitives
sage: VW = V.union(W)
sage: P = M.subset_poset(); P
Finite poset containing 5 elements
sage: P.maximal_elements()
[Set {M} of open subsets of the 3-dimensional differentiable manifold M]
sage: sorted(P.minimal_elements(), key=lambda v: v._name)
 [Set {U} of open subsets of the 3-dimensional differentiable manifold M,
  Set {V} of open subsets of the 3-dimensional differentiable manifold M,
  Set {W} of open subsets of the 3-dimensional differentiable manifold M]
sage: from sage.manifolds.subset import ManifoldSubsetFiniteFamily
sage: sorted(P.lower_covers(ManifoldSubsetFiniteFamily([M])), key=str)
 [Set {U} of open subsets of the 3-dimensional differentiable manifold M,
  Set {V_union_W} of open subsets of the 3-dimensional differentiable manifold M]
sage: P.plot(element_labels={element: element._name for element in P})      # needs sage.plot
Graphics object consisting of 10 graphics primitives

>>> from sage.all import *
>>> # needs sage.graphs
>>> M = Manifold(Integer(3), 'M')
>>> U = M.open_subset('U'); V = M.open_subset('V'); W = M.open_subset('W')
>>> P = M.subset_poset(); P
Finite poset containing 4 elements
>>> P.plot(element_labels={element: element._name for element in P})      # needs sage.plot
Graphics object consisting of 8 graphics primitives
>>> VW = V.union(W)
>>> P = M.subset_poset(); P
Finite poset containing 5 elements
>>> P.maximal_elements()
[Set {M} of open subsets of the 3-dimensional differentiable manifold M]
>>> sorted(P.minimal_elements(), key=lambda v: v._name)
 [Set {U} of open subsets of the 3-dimensional differentiable manifold M,
  Set {V} of open subsets of the 3-dimensional differentiable manifold M,
  Set {W} of open subsets of the 3-dimensional differentiable manifold M]
>>> from sage.manifolds.subset import ManifoldSubsetFiniteFamily
>>> sorted(P.lower_covers(ManifoldSubsetFiniteFamily([M])), key=str)
 [Set {U} of open subsets of the 3-dimensional differentiable manifold M,
  Set {V_union_W} of open subsets of the 3-dimensional differentiable manifold M]
>>> P.plot(element_labels={element: element._name for element in P})      # needs sage.plot
Graphics object consisting of 10 graphics primitives

# needs sage.graphs
M = Manifold(3, 'M')
U = M.open_subset('U'); V = M.open_subset('V'); W = M.open_subset('W')
P = M.subset_poset(); P
P.plot(element_labels={element: element._name for element in P})      # needs sage.plot
VW = V.union(W)
P = M.subset_poset(); P
P.maximal_elements()
sorted(P.minimal_elements(), key=lambda v: v._name)
from sage.manifolds.subset import ManifoldSubsetFiniteFamily
sorted(P.lower_covers(ManifoldSubsetFiniteFamily([M])), key=str)
P.plot(element_labels={element: element._name for element in P})      # needs sage.plot

If open_covers is True, the poset includes a special vertex for each nontrivial open cover of a subset:

sage: # needs sage.graphs
sage: P = M.subset_poset(open_covers=True); P
Finite poset containing 6 elements
sage: from sage.manifolds.subset import ManifoldSubsetFiniteFamily
sage: sorted(P.upper_covers(ManifoldSubsetFiniteFamily([VW])), key=str)
[(Set {V} of open subsets of the 3-dimensional differentiable manifold M,
  Set {W} of open subsets of the 3-dimensional differentiable manifold M),
 Set {M} of open subsets of the 3-dimensional differentiable manifold M]
sage: def label(element):
....:     try:
....:         return element._name
....:     except AttributeError:
....:         return '[' + ', '.join(sorted(x._name for x in element)) + ']'
sage: P.plot(element_labels={element: label(element) for element in P})     # needs sage.plot
Graphics object consisting of 12 graphics primitives

>>> from sage.all import *
>>> # needs sage.graphs
>>> P = M.subset_poset(open_covers=True); P
Finite poset containing 6 elements
>>> from sage.manifolds.subset import ManifoldSubsetFiniteFamily
>>> sorted(P.upper_covers(ManifoldSubsetFiniteFamily([VW])), key=str)
[(Set {V} of open subsets of the 3-dimensional differentiable manifold M,
  Set {W} of open subsets of the 3-dimensional differentiable manifold M),
 Set {M} of open subsets of the 3-dimensional differentiable manifold M]
>>> def label(element):
...     try:
...         return element._name
...     except AttributeError:
...         return '[' + ', '.join(sorted(x._name for x in element)) + ']'
>>> P.plot(element_labels={element: label(element) for element in P})     # needs sage.plot
Graphics object consisting of 12 graphics primitives

# needs sage.graphs
P = M.subset_poset(open_covers=True); P
from sage.manifolds.subset import ManifoldSubsetFiniteFamily
sorted(P.upper_covers(ManifoldSubsetFiniteFamily([VW])), key=str)
def label(element):
    try:
        return element._name
    except AttributeError:
        return '[' + ', '.join(sorted(x._name for x in element)) + ']'
P.plot(element_labels={element: label(element) for element in P})     # needs sage.plot
../../_images/subset-8.svg
subsets()[source]

Generate the subsets that have been defined on the current subset.

Note

To get the subsets as a family, sorted by name, use the method subset_family() instead.

EXAMPLES:

Subsets of a 2-dimensional manifold:

sage: M = Manifold(2, 'M', structure='topological')
sage: U = M.open_subset('U')
sage: V = M.subset('V')
sage: frozenset(M.subsets())  # random (set output)
{Subset V of the 2-dimensional topological manifold M,
 2-dimensional topological manifold M,
 Open subset U of the 2-dimensional topological manifold M}
sage: U in M.subsets()
True

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> U = M.open_subset('U')
>>> V = M.subset('V')
>>> frozenset(M.subsets())  # random (set output)
{Subset V of the 2-dimensional topological manifold M,
 2-dimensional topological manifold M,
 Open subset U of the 2-dimensional topological manifold M}
>>> U in M.subsets()
True

M = Manifold(2, 'M', structure='topological')
U = M.open_subset('U')
V = M.subset('V')
frozenset(M.subsets())  # random (set output)
U in M.subsets()

The method subset_family() returns a family (sorted alphabetically by the subset names):

sage: M.subset_family()
Set {M, U, V} of subsets of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> M.subset_family()
Set {M, U, V} of subsets of the 2-dimensional topological manifold M

M.subset_family()
superset(name, latex_name=None, is_open=False)[source]

Create a superset of the current subset.

A superset is a manifold subset in which the current subset is included.

INPUT:

  • name – name given to the superset

  • latex_name – (default: None) LaTeX symbol to denote the superset; if none are provided, it is set to name

  • is_open – boolean (default: False); if True, the created subset is assumed to be open with respect to the manifold’s topology

OUTPUT:

EXAMPLES:

Creating some superset of a given subset:

sage: M = Manifold(2, 'M', structure='topological')
sage: a = M.subset('A')
sage: b = a.superset('B'); b
Subset B of the 2-dimensional topological manifold M
sage: b.subset_family()
Set {A, B} of subsets of the 2-dimensional topological manifold M
sage: a.superset_family()
Set {A, B, M} of subsets of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> a = M.subset('A')
>>> b = a.superset('B'); b
Subset B of the 2-dimensional topological manifold M
>>> b.subset_family()
Set {A, B} of subsets of the 2-dimensional topological manifold M
>>> a.superset_family()
Set {A, B, M} of subsets of the 2-dimensional topological manifold M

M = Manifold(2, 'M', structure='topological')
a = M.subset('A')
b = a.superset('B'); b
b.subset_family()
a.superset_family()

The superset of the whole manifold is itself:

sage: M.superset('SM') is M
True

>>> from sage.all import *
>>> M.superset('SM') is M
True

M.superset('SM') is M

Two supersets of a given subset are a priori different:

sage: c = a.superset('C')
sage: c == b
False

>>> from sage.all import *
>>> c = a.superset('C')
>>> c == b
False

c = a.superset('C')
c == b
superset_digraph(loops=False, quotient=False, open_covers=False, points=False, upper_bound=None)[source]

Return the digraph whose arcs represent subset relations among the supersets of self.

INPUT:

  • loops – boolean (default: False); whether to include the trivial containment of each subset in itself as loops of the digraph

  • quotient – boolean (default: False); whether to contract directed cycles in the graph, replacing equivalence classes of equal subsets by a single vertex. In this case, each vertex of the digraph is a set of ManifoldSubset instances.

  • open_covers – boolean (default: False); whether to include vertices for open covers

  • points – boolean (default: False); whether to include vertices for declared points; this can also be an iterable for the points to include

  • upper_bound – (default: None) only include subsets of this

EXAMPLES:

sage: M = Manifold(3, 'M')
sage: U = M.open_subset('U'); V = M.open_subset('V'); W = M.open_subset('W')
sage: VW = V.union(W)
sage: P = V.superset_digraph(loops=False, upper_bound=VW); P                # needs sage.graphs
Digraph on 2 vertices

>>> from sage.all import *
>>> M = Manifold(Integer(3), 'M')
>>> U = M.open_subset('U'); V = M.open_subset('V'); W = M.open_subset('W')
>>> VW = V.union(W)
>>> P = V.superset_digraph(loops=False, upper_bound=VW); P                # needs sage.graphs
Digraph on 2 vertices

M = Manifold(3, 'M')
U = M.open_subset('U'); V = M.open_subset('V'); W = M.open_subset('W')
VW = V.union(W)
P = V.superset_digraph(loops=False, upper_bound=VW); P                # needs sage.graphs
superset_family()[source]

Return the family of declared supersets of the current subset.

The family is sorted by the alphabetical names of the supersets.

OUTPUT:

Note

If you only need to iterate over the supersets in arbitrary order, you can use the generator method supersets() instead.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: U = M.open_subset('U')
sage: V = M.subset('V')
sage: V.superset_family()
Set {M, V} of subsets of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> U = M.open_subset('U')
>>> V = M.subset('V')
>>> V.superset_family()
Set {M, V} of subsets of the 2-dimensional topological manifold M

M = Manifold(2, 'M', structure='topological')
U = M.open_subset('U')
V = M.subset('V')
V.superset_family()
superset_poset(open_covers=False, points=False, upper_bound=None)[source]

Return the poset of the supersets of self.

INPUT:

  • open_covers – boolean (default: False); whether to include vertices for open covers

  • points – boolean (default: False); whether to include vertices for declared points; this can also be an iterable for the points to include

  • upper_bound – (default: None) only include subsets of this

EXAMPLES:

sage: M = Manifold(3, 'M')
sage: U = M.open_subset('U'); V = M.open_subset('V'); W = M.open_subset('W')
sage: VW = V.union(W)
sage: P = V.superset_poset(); P                                             # needs sage.graphs
Finite poset containing 3 elements
sage: P.plot(element_labels={element: element._name for element in P})      # needs sage.graphs sage.plot
Graphics object consisting of 6 graphics primitives

>>> from sage.all import *
>>> M = Manifold(Integer(3), 'M')
>>> U = M.open_subset('U'); V = M.open_subset('V'); W = M.open_subset('W')
>>> VW = V.union(W)
>>> P = V.superset_poset(); P                                             # needs sage.graphs
Finite poset containing 3 elements
>>> P.plot(element_labels={element: element._name for element in P})      # needs sage.graphs sage.plot
Graphics object consisting of 6 graphics primitives

M = Manifold(3, 'M')
U = M.open_subset('U'); V = M.open_subset('V'); W = M.open_subset('W')
VW = V.union(W)
P = V.superset_poset(); P                                             # needs sage.graphs
P.plot(element_labels={element: element._name for element in P})      # needs sage.graphs sage.plot
supersets()[source]

Generate the declared supersets of the current subset.

Note

To get the supersets as a family, sorted by name, use the method superset_family() instead.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: U = M.open_subset('U')
sage: V = M.subset('V')
sage: sorted(V.supersets(), key=lambda v: v._name)
[2-dimensional topological manifold M,
 Subset V of the 2-dimensional topological manifold M]

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> U = M.open_subset('U')
>>> V = M.subset('V')
>>> sorted(V.supersets(), key=lambda v: v._name)
[2-dimensional topological manifold M,
 Subset V of the 2-dimensional topological manifold M]

M = Manifold(2, 'M', structure='topological')
U = M.open_subset('U')
V = M.subset('V')
sorted(V.supersets(), key=lambda v: v._name)
union(name, latex_name, *others)[source]

Return the union of the current subset with other subsets.

This method may return a previously constructed union instead of creating a new subset. In this case, name and latex_name are not used.

INPUT:

  • others – other subsets of the same manifold

  • name – (default: None) name given to the union in the case the latter has to be created; the default is self._name union other._name

  • latex_name – (default: None) LaTeX symbol to denote the union in the case the latter has to be created; the default is built upon the symbol \(\cup\)

OUTPUT:

  • instance of ManifoldSubset representing the subset that is the union of the current subset with others

EXAMPLES:

Union of two subsets:

sage: M = Manifold(2, 'M', structure='topological')
sage: a = M.subset('A')
sage: b = M.subset('B')
sage: c = a.union(b); c
Subset A_union_B of the 2-dimensional topological manifold M
sage: a.superset_family()
Set {A, A_union_B, M} of subsets of the 2-dimensional topological manifold M
sage: b.superset_family()
Set {A_union_B, B, M} of subsets of the 2-dimensional topological manifold M
sage: c.superset_family()
Set {A_union_B, M} of subsets of the 2-dimensional topological manifold M

>>> from sage.all import *
>>> M = Manifold(Integer(2), 'M', structure='topological')
>>> a = M.subset('A')
>>> b = M.subset('B')
>>> c = a.union(b); c
Subset A_union_B of the 2-dimensional topological manifold M
>>> a.superset_family()
Set {A, A_union_B, M} of subsets of the 2-dimensional topological manifold M
>>> b.superset_family()
Set {A_union_B, B, M} of subsets of the 2-dimensional topological manifold M
>>> c.superset_family()
Set {A_union_B, M} of subsets of the 2-dimensional topological manifold M

M = Manifold(2, 'M', structure='topological')
a = M.subset('A')
b = M.subset('B')
c = a.union(b); c
a.superset_family()
b.superset_family()
c.superset_family()

Union of six subsets:

sage: T = Manifold(2, 'T', structure='topological')
sage: S = [T.subset(f'S{i}') for i in range(6)]
sage: [S[i].union(S[i+3]) for i in range(3)]
[Subset S0_union_S3 of the 2-dimensional topological manifold T,
 Subset S1_union_S4 of the 2-dimensional topological manifold T,
 Subset S2_union_S5 of the 2-dimensional topological manifold T]
sage: union_S_i = S[0].union(S[1:], name='union_S_i'); union_S_i
Subset union_S_i of the 2-dimensional topological manifold T
sage: T.subset_family()
Set {S0, S0_union_S3, S0_union_S3_union_S1_union_S4, S1,
     S1_union_S4, S2, S2_union_S5, S3, S4, S5, T, union_S_i}
 of subsets of the 2-dimensional topological manifold T

>>> from sage.all import *
>>> T = Manifold(Integer(2), 'T', structure='topological')
>>> S = [T.subset(f'S{i}') for i in range(Integer(6))]
>>> [S[i].union(S[i+Integer(3)]) for i in range(Integer(3))]
[Subset S0_union_S3 of the 2-dimensional topological manifold T,
 Subset S1_union_S4 of the 2-dimensional topological manifold T,
 Subset S2_union_S5 of the 2-dimensional topological manifold T]
>>> union_S_i = S[Integer(0)].union(S[Integer(1):], name='union_S_i'); union_S_i
Subset union_S_i of the 2-dimensional topological manifold T
>>> T.subset_family()
Set {S0, S0_union_S3, S0_union_S3_union_S1_union_S4, S1,
     S1_union_S4, S2, S2_union_S5, S3, S4, S5, T, union_S_i}
 of subsets of the 2-dimensional topological manifold T

T = Manifold(2, 'T', structure='topological')
S = [T.subset(f'S{i}') for i in range(6)]
[S[i].union(S[i+3]) for i in range(3)]
union_S_i = S[0].union(S[1:], name='union_S_i'); union_S_i
T.subset_family()
../../_images/subset-9.svg