# Topological Vector Bundle¶

Let $$K$$ be a topological field. A vector bundle of rank $$n$$ over the field $$K$$ and over a topological manifold $$B$$ (base space) is a topological manifold $$E$$ (total space) together with a continuous and surjective map $$\pi: E \to B$$ such that for every point $$p \in B$$, we have:

• the set $$E_p=\pi^{-1}(p)$$ has the vector space structure of $$K^n$$,

• there is a neighborhood $$U \subset B$$ of $$p$$ and a homeomorphism (trivialization) $$\varphi: \pi^{-1}(p) \to U \times K^n$$ such that $$\varphi$$ is compatible with the fibers, namely $$\pi \circ \varphi^{-1} = \mathrm{pr}_1$$, and $$v \mapsto \varphi^{-1}(q,v)$$ is a linear isomorphism between $$K^n$$ and $$E_q$$ for any $$q \in U$$.

AUTHORS:

• Michael Jung (2019) : initial version

REFERENCES:

class sage.manifolds.vector_bundle.TopologicalVectorBundle(rank, name, base_space, field='real', latex_name=None, category=None, unique_tag=None)

An instance of this class is a topological vector bundle $$E \to B$$ over a topological field $$K$$.

INPUT:

• rank – positive integer; rank of the vector bundle

• name – string representation given to the total space

• base_space – the base space (topological manifold) over which the vector bundle is defined

• field – field $$K$$ which gives the fibers the structure of a vector space over $$K$$; allowed values are

• 'real' or an object of type RealField (e.g., RR) for a vector bundle over $$\RR$$

• 'complex' or an object of type ComplexField (e.g., CC) for a vector bundle over $$\CC$$

• an object in the category of topological fields (see Fields and TopologicalSpaces) for other types of topological fields

• latex_name – (default: None) LaTeX representation given to the total space

• category – (default: None) to specify the category; if None, VectorBundles(base_space, c_field) is assumed (see the category VectorBundles)

• unique_tag – (default: None) tag used to force the construction of a new object when all the other arguments have been used previously (without unique_tag, the UniqueRepresentation behavior would return the previously constructed object corresponding to these arguments)

EXAMPLES:

A real line bundle over some 4-dimensional topological manifold:

sage: M = Manifold(4, 'M', structure='top')
sage: E = M.vector_bundle(1, 'E'); E
Topological real vector bundle E -> M of rank 1 over the base space
4-dimensional topological manifold M
sage: E.base_space()
4-dimensional topological manifold M
sage: E.base_ring()
Real Field with 53 bits of precision
sage: E.rank()
1


For a more sophisticated example, let us define a non-trivial 2-manifold to work with:

sage: M = Manifold(2, 'M', structure='top')
sage: U = M.open_subset('U') ; V = M.open_subset('V')
sage: M.declare_union(U,V)   # M is the union of U and V
sage: c_xy.<x,y> = U.chart() ; c_uv.<u,v> = V.chart()
sage: xy_to_uv = c_xy.transition_map(c_uv, (x+y, x-y),
....:                    intersection_name='W', restrictions1= x>0,
....:                    restrictions2= u+v>0)
sage: uv_to_xy = xy_to_uv.inverse()
sage: W = U.intersection(V)
sage: E = M.vector_bundle(2, 'E'); E
Topological real vector bundle E -> M of rank 2 over the base space
2-dimensional topological manifold M


Now, there a two ways to go. Most effortlessly, we define trivializations similar to charts (see Trivialization):

sage: phi_U = E.trivialization('phi_U', domain=U); phi_U
Trivialization (phi_U, E|_U)
sage: phi_V = E.trivialization('phi_V', domain=V); phi_V
Trivialization (phi_V, E|_V)
sage: transf = phi_U.transition_map(phi_V, [[0,x],[x,0]]) # transition map between trivializations
sage: fU = phi_U.frame(); fU
Trivialization frame (E|_U, ((phi_U^*e_1),(phi_U^*e_2)))
sage: fV = phi_V.frame(); fV
Trivialization frame (E|_V, ((phi_V^*e_1),(phi_V^*e_2)))
sage: E.changes_of_frame() # random
{(Local frame (E|_W, ((phi_U^*e_1),(phi_U^*e_2))),
Local frame (E|_W, ((phi_V^*e_1),(phi_V^*e_2)))): Automorphism
phi_U^(-1)*phi_V^(-1) of the Free module C^0(W;E) of sections on
the Open subset W of the 2-dimensional topological manifold M with
values in the real vector bundle E of rank 2,
(Local frame (E|_W, ((phi_V^*e_1),(phi_V^*e_2))),
Local frame (E|_W, ((phi_U^*e_1),(phi_U^*e_2)))): Automorphism
phi_U^(-1)*phi_V of the Free module C^0(W;E) of sections on the
Open subset W of the 2-dimensional topological manifold M with
values in the real vector bundle E of rank 2}


Then, the atlas of $$E$$ consists of all known trivializations defined on E:

sage: E.atlas() # a shallow copy of the atlas
[Trivialization (phi_U, E|_U), Trivialization (phi_V, E|_V)]


Or we just define frames, an automorphism on the free section module over the intersection domain $$W$$ and declare the change of frame manually (for more details consult LocalFrame):

sage: eU = E.local_frame('eU', domain=U); eU
Local frame (E|_U, (eU_0,eU_1))
sage: eUW = eU.restrict(W) # to trivialize E|_W
sage: eV = E.local_frame('eV', domain=V); eV
Local frame (E|_V, (eV_0,eV_1))
sage: eVW = eV.restrict(W)
sage: a = E.section_module(domain=W).automorphism(); a
Automorphism of the Free module C^0(W;E) of sections on the Open
subset W of the 2-dimensional topological manifold M with values in
the real vector bundle E of rank 2
sage: a[eUW,:] = [[0,x],[x,0]]
sage: E.set_change_of_frame(eUW, eVW, a)
sage: E.change_of_frame(eUW, eVW)
Automorphism of the Free module C^0(W;E) of sections on the Open
subset W of the 2-dimensional topological manifold M with values in
the real vector bundle E of rank 2


Now, the list of all known frames defined on $$E$$ can be displayed via frames():

sage: E.frames() # a shallow copy of all known frames on E
[Trivialization frame (E|_U, ((phi_U^*e_1),(phi_U^*e_2))),
Trivialization frame (E|_V, ((phi_V^*e_1),(phi_V^*e_2))),
Local frame (E|_W, ((phi_U^*e_1),(phi_U^*e_2))),
Local frame (E|_W, ((phi_V^*e_1),(phi_V^*e_2))),
Local frame (E|_U, (eU_0,eU_1)),
Local frame (E|_W, (eU_0,eU_1)),
Local frame (E|_V, (eV_0,eV_1)),
Local frame (E|_W, (eV_0,eV_1))]


By definition $$E$$ is a manifold, in this case of dimension 4 (notice that the induced charts are not implemented, yet):

sage: E.total_space()
4-dimensional topological manifold E


The method section() returns a section while the method section_module() returns the section module on the corresponding domain:

sage: s = E.section(name='s'); s
Section s on the 2-dimensional topological manifold M with values in
the real vector bundle E of rank 2
sage: s in E.section_module()
True

atlas()

Return the list of trivializations that have been defined for self.

EXAMPLES:

sage: M = Manifold(3, 'M')
sage: U = M.open_subset('U')
sage: V = M.open_subset('V')
sage: E = M.vector_bundle(2, 'E')
sage: phi_U = E.trivialization('phi_U', domain=U)
sage: phi_V = E.trivialization('phi_V', domain=V)
sage: phi_M = E.trivialization('phi_M')
sage: E.atlas()
[Trivialization (phi_U, E|_U),
Trivialization (phi_V, E|_V),
Trivialization (phi_M, E|_M)]

base_field()

Return the field on which the fibers are defined.

OUTPUT:

• a topological field

EXAMPLES:

sage: M = Manifold(3, 'M', structure='topological')
sage: E = M.vector_bundle(2, 'E', field=CC)
sage: E.base_field()
Complex Field with 53 bits of precision

base_field_type()

Return the type of topological field on which the fibers are defined.

OUTPUT:

• a string describing the field, with three possible values:

• 'real' for the real field $$\RR$$

• 'complex' for the complex field $$\CC$$

• 'neither_real_nor_complex' for a field different from $$\RR$$ and $$\CC$$

EXAMPLES:

sage: M = Manifold(2, 'M', structure='top')
sage: E = M.vector_bundle(2, 'E', field=CC)
sage: E.base_field_type()
'complex'

base_space()

Return the base space of the vector bundle.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='top')
sage: E = M.vector_bundle(2, 'E')
sage: E.base_space()
2-dimensional topological manifold M

change_of_frame(frame1, frame2)

Return a change of local frames defined on self.

INPUT:

• frame1 – local frame 1

• frame2 – local frame 2

OUTPUT:

• a FreeModuleAutomorphism representing, at each point, the vector space automorphism $$P$$ that relates frame 1, $$(e_i)$$ say, to frame 2, $$(f_i)$$ say, according to $$f_i = P(e_i)$$

EXAMPLES:

sage: M = Manifold(3, 'M', structure='top')
sage: X.<x,y,z> = M.chart()
sage: E = M.vector_bundle(2, 'E')
sage: e = E.local_frame('e')
sage: a = E.section_module().automorphism() # Now, the section module is free
sage: a[:] = [[sqrt(3)/2, -1/2], [1/2, sqrt(3)/2]]
sage: f = e.new_frame(a, 'f')
sage: E.change_of_frame(e, f)
Automorphism of the Free module C^0(M;E) of sections on the
3-dimensional topological manifold M with values in the real vector
bundle E of rank 2
sage: a == E.change_of_frame(e, f)
True
sage: a.inverse() == E.change_of_frame(f, e)
True

changes_of_frame()

Return all the changes of local frames defined on self.

OUTPUT:

• dictionary of vector bundle automorphisms representing the changes of frames, the keys being the pair of frames

EXAMPLES:

sage: M = Manifold(3, 'M', structure='top')
sage: c_xyz.<x,y,z> = M.chart()
sage: E = M.vector_bundle(2, 'E')
sage: e = E.local_frame('e'); e
Local frame (E|_M, (e_0,e_1))
sage: auto_group = E.section_module().general_linear_group()
sage: e_to_f = auto_group([[0,1],[1,0]]); e_to_f
Automorphism of the Free module C^0(M;E) of sections on the
3-dimensional topological manifold M with values in the real vector
bundle E of rank 2
sage: f_in_e = auto_group([[0,1],[1,0]])
sage: f = e.new_frame(f_in_e, 'f'); f
Local frame (E|_M, (f_0,f_1))
sage: E.changes_of_frame() # random
{(Local frame (E|_M, (f_0,f_1)),
Local frame (E|_M, (e_0,e_1))): Automorphism of the Free module
C^0(M;E) of sections on the 3-dimensional topological manifold M
with values in the real vector bundle E of rank 2,
(Local frame (E|_M, (e_0,e_1)),
Local frame (E|_M, (f_0,f_1))): Automorphism of the Free module
C^0(M;E) of sections on the 3-dimensional topological manifold M
with values in the real vector bundle E of rank 2}

coframes()

Return the list of coframes defined on self.

OUTPUT:

• list of coframes defined on self

EXAMPLES:

sage: M = Manifold(3, 'M', structure='top')
sage: E = M.vector_bundle(2, 'E')
sage: U = M.open_subset('U'); V = M.open_subset('V')
sage: phi_U = E.trivialization('phi_U', domain=U)
sage: e = E.local_frame('e', domain=V)
sage: E.coframes()
[Trivialization coframe (E|_U, ((phi_U^*e^1),(phi_U^*e^2))),
Local coframe (E|_V, (e^0,e^1))]

default_frame()

Return the default frame of on self.

OUTPUT:

EXAMPLES:

sage: M = Manifold(3, 'M', structure='top')
sage: E = M.vector_bundle(2, 'E')
sage: e = E.local_frame('e')
sage: E.default_frame()
Local frame (E|_M, (e_0,e_1))

fiber(point)

Return the vector bundle fiber over a point.

INPUT:

OUTPUT:

EXAMPLES:

sage: M = Manifold(3, 'M', structure='top')
sage: X.<x,y,z> = M.chart()
sage: p = M((0,2,1), name='p'); p
Point p on the 3-dimensional topological manifold M
sage: E = M.vector_bundle(2, 'E'); E
Topological real vector bundle E -> M of rank 2 over the base space
3-dimensional topological manifold M
sage: E.fiber(p)
Fiber of E at Point p on the 3-dimensional topological manifold M

frames()

Return the list of local frames defined on self.

OUTPUT:

• list of local frames defined on self

EXAMPLES:

sage: M = Manifold(3, 'M', structure='top')
sage: E = M.vector_bundle(2, 'E')
sage: U = M.open_subset('U'); V = M.open_subset('V')
sage: phi_U = E.trivialization('phi_U', domain=U)
sage: e = E.local_frame('e', domain=V)
sage: E.frames()
[Trivialization frame (E|_U, ((phi_U^*e_1),(phi_U^*e_2))),
Local frame (E|_V, (e_0,e_1))]

has_orientation()

Check whether self admits an obvious or by user set orientation.

Consult orientation() for details about orientations.

Note

Notice that if has_orientation() returns False this does not necessarily mean that the vector bundle admits no orientation. It just means that the user has to set an orientation manually in that case, see set_orientation().

EXAMPLES:

The trivial case:

sage: M = Manifold(3, 'M', structure='top')
sage: E = M.vector_bundle(2, 'E')
sage: e = E.local_frame('e')
sage: E.has_orientation()  # trivial case
True


Non-trivial case:

sage: M = Manifold(3, 'M', structure='top')
sage: U = M.open_subset('U'); V = M.open_subset('V')
sage: M.declare_union(U, V)
sage: E = M.vector_bundle(2, 'E')
sage: e = E.local_frame('e', domain=U)
sage: f = E.local_frame('f', domain=V)
sage: E.has_orientation()
False
sage: E.set_orientation([e, f])
sage: E.has_orientation()
True

irange(start=None)

Single index generator.

INPUT:

• start – (default: None) initial value $$i_0$$ of the index; if none are provided, the value returned by sage.manifolds.manifold.Manifold.start_index() is assumed

OUTPUT:

• an iterable index, starting from $$i_0$$ and ending at $$i_0 + n - 1$$, where $$n$$ is the vector bundle’s dimension

EXAMPLES:

Index range on a 4-dimensional vector bundle over a 5-dimensional manifold:

sage: M = Manifold(5, 'M', structure='topological')
sage: E = M.vector_bundle(4, 'E')
sage: list(E.irange())
[0, 1, 2, 3]
sage: list(E.irange(2))
[2, 3]


Index range on a 4-dimensional vector bundle over a 5-dimensional manifold with starting index=1:

sage: M = Manifold(5, 'M', structure='topological', start_index=1)
sage: E = M.vector_bundle(4, 'E')
sage: list(E.irange())
[1, 2, 3, 4]
sage: list(E.irange(2))
[2, 3, 4]


In general, one has always:

sage: next(E.irange()) == M.start_index()
True

is_manifestly_trivial()

Return True if self is manifestly a trivial bundle, i.e. there exists a frame or a trivialization defined on the whole base space.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='top')
sage: E = M.vector_bundle(1, 'E')
sage: U = M.open_subset('U')
sage: V = M.open_subset('V')
sage: M.declare_union(U, V)
sage: phi_U = E.trivialization('phi_U', domain=U); phi_U
Trivialization (phi_U, E|_U)
sage: phi_V = E.trivialization('phi_V', domain=V); phi_V
Trivialization (phi_V, E|_V)
sage: E.is_manifestly_trivial()
False
sage: E.trivialization('phi_M', M)
Trivialization (phi_M, E|_M)
sage: E.is_manifestly_trivial()
True

local_frame(*args, **kwargs)

Define a local frame on self.

A local frame is a section on a subset $$U \subset M$$ in $$E$$ that provides, at each point $$p$$ of the base space, a vector basis of the fiber $$E_p$$ at $$p$$.

LocalFrame for complete documentation.

INPUT:

• symbol – either a string, to be used as a common base for the symbols of the sections constituting the local frame, or a list/tuple of strings, representing the individual symbols of the sections

• sections – tuple or list of $$n$$ linearly independent sections on self ($$n$$ being the rank of self) defining the local frame; can be omitted if the local frame is created from scratch

• latex_symbol – (default: None) either a string, to be used as a common base for the LaTeX symbols of the sections constituting the local frame, or a list/tuple of strings, representing the individual LaTeX symbols of the sections; if None, symbol is used in place of latex_symbol

• indices – (default: None; used only if symbol is a single string) tuple of strings representing the indices labelling the sections of the frame; if None, the indices will be generated as integers within the range declared on self

• latex_indices – (default: None) tuple of strings representing the indices for the LaTeX symbols of the sections; if None, indices is used instead

• symbol_dual – (default: None) same as symbol but for the dual coframe; if None, symbol must be a string and is used for the common base of the symbols of the elements of the dual coframe

• latex_symbol_dual – (default: None) same as latex_symbol but for the dual coframe

• domain – (default: None) domain on which the local frame is defined; if None, the whole base space is assumed

OUTPUT:

EXAMPLES:

Defining a local frame from two linearly independent sections on a real rank-2 vector bundle:

sage: M = Manifold(3, 'M', structure='top')
sage: U = M.open_subset('U')
sage: X.<x,y,z> = U.chart()
sage: E = M.vector_bundle(2, 'E')
sage: phi = E.trivialization('phi', domain=U)
sage: s0 = E.section(name='s_0', domain=U)
sage: s0[:] = 1+z^2, -2
sage: s1 = E.section(name='s_1', domain=U)
sage: s1[:] = 1, 1+x^2
sage: e = E.local_frame('e', (s0, s1), domain=U); e
Local frame (E|_U, (e_0,e_1))
sage: (e, e) == (s0, s1)
True


If the sections are not linearly independent, an error is raised:

sage: e = E.local_frame('z', (s0, -s0), domain=U)
Traceback (most recent call last):
...
ValueError: the provided sections are not linearly independent


It is also possible to create a local frame from scratch, without connecting it to previously defined local frames or sections (this can still be performed later via the method set_change_of_frame()):

sage: f = E.local_frame('f', domain=U); f
Local frame (E|_U, (f_0,f_1))


For a global frame, the argument domain is omitted:

sage: g = E.local_frame('g'); g
Local frame (E|_M, (g_0,g_1))


For more options, in particular for the choice of symbols and indices, see LocalFrame.

orientation()

Get the orientation of self if available.

An orientation on a vector bundle is a choice of local frames whose

1. union of domains cover the base space,

2. changes of frames are pairwise orientation preserving, i.e. have positive determinant.

A vector bundle endowed with an orientation is called orientable.

The trivial case corresponds to self being trivial, i.e. self can be covered by one frame. In that case, if no preferred orientation has been set before, one of those frames (usually the default frame) is set automatically to the preferred orientation and returned here.

EXAMPLES:

The trivial case is covered automatically:

sage: M = Manifold(3, 'M', structure='top')
sage: E = M.vector_bundle(2, 'E')
sage: e = E.local_frame('e'); e
Local frame (E|_M, (e_0,e_1))
sage: E.orientation()  # trivial case
[Local frame (E|_M, (e_0,e_1))]


The orientation can also be set by the user:

sage: f = E.local_frame('f'); f
Local frame (E|_M, (f_0,f_1))
sage: E.set_orientation(f)
sage: E.orientation()
[Local frame (E|_M, (f_0,f_1))]


In case of the non-trivial case, the orientation must be set manually, otherwise no orientation is returned:

sage: M = Manifold(3, 'M', structure='top')
sage: U = M.open_subset('U'); V = M.open_subset('V')
sage: M.declare_union(U, V)
sage: E = M.vector_bundle(2, 'E')
sage: e = E.local_frame('e', domain=U); e
Local frame (E|_U, (e_0,e_1))
sage: f = E.local_frame('f', domain=V); f
Local frame (E|_V, (f_0,f_1))
sage: E.orientation()
[]
sage: E.set_orientation([e, f])
sage: E.orientation()
[Local frame (E|_U, (e_0,e_1)),
Local frame (E|_V, (f_0,f_1))]

rank()

Return the rank of the vector bundle.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='top')
sage: E = M.vector_bundle(3, 'E')
sage: E.rank()
3

section(*comp, **kwargs)

Return a continuous section of self.

INPUT:

• domain – (default: None) domain on which the section shall be defined; if None, the base space is assumed

• name – (default: None) name of the local section

• latex_name – (defaultNone) latex representation of the local section

OUTPUT:

EXAMPLES:

A section on a non-trivial rank 2 vector bundle over a non-trivial 2-manifold:

sage: M = Manifold(2, 'M', structure='top')
sage: U = M.open_subset('U') ; V = M.open_subset('V')
sage: M.declare_union(U,V)   # M is the union of U and V
sage: c_xy.<x,y> = U.chart() ; c_uv.<u,v> = V.chart()
sage: xy_to_uv = c_xy.transition_map(c_uv, (x+y, x-y),
....:                    intersection_name='W', restrictions1= x>0,
....:                    restrictions2= u+v>0)
sage: uv_to_xy = xy_to_uv.inverse()
sage: W = U.intersection(V)
sage: E = M.vector_bundle(2, 'E') # define the vector bundle
sage: phi_U = E.trivialization('phi_U', domain=U) # define trivializations
sage: phi_V = E.trivialization('phi_V', domain=V)
sage: transf = phi_U.transition_map(phi_V, [[0,x],[x,0]]) # transition map between trivializations
sage: fU = phi_U.frame(); fV = phi_V.frame() # define induced frames
sage: s = E.section(name='s'); s
Section s on the 2-dimensional topological manifold M with values in the
real vector bundle E of rank 2

section_module(domain=None, force_free=False)

Return the section module of continuous sections on self.

See SectionModule for a complete documentation.

INPUT:

• domain – (default: None) the domain on which the module is defined; if None the base space is assumed

• force_free – (default: False) if set to True, force the construction of a free module (this implies that $$E$$ is trivial)

OUTPUT:

EXAMPLES:

Module of sections on the Möbius bundle over the real-projective space $$M=\RR P^1$$:

sage: M = Manifold(1, 'RP^1', structure='top', start_index=1)
sage: U = M.open_subset('U')  # the complement of one point
sage: c_u.<u> =  U.chart() # [1:u] in homogeneous coord.
sage: V = M.open_subset('V') # the complement of the point u=0
sage: M.declare_union(U,V)   # [v:1] in homogeneous coord.
sage: c_v.<v> = V.chart()
sage: u_to_v = c_u.transition_map(c_v, (1/u),
....:                             intersection_name='W',
....:                             restrictions1 = u!=0,
....:                             restrictions2 = v!=0)
sage: v_to_u = u_to_v.inverse()
sage: W = U.intersection(V)
sage: E = M.vector_bundle(1, 'E')
sage: phi_U = E.trivialization('phi_U', latex_name=r'\varphi_U',
....:                          domain=U)
sage: phi_V = E.trivialization('phi_V', latex_name=r'\varphi_V',
....:                          domain=V)
sage: transf = phi_U.transition_map(phi_V, [[u]])
sage: C0 = E.section_module(); C0
Module C^0(RP^1;E) of sections on the 1-dimensional topological
manifold RP^1 with values in the real vector bundle E of rank 1


$$C^0(\RR P^1;E)$$ is a module over the algebra $$C^0(\RR P^1)$$:

sage: C0.category()
Category of modules over Algebra of scalar fields on the
1-dimensional topological manifold RP^1
sage: C0.base_ring() is M.scalar_field_algebra()
True


However, $$C^0(\RR P^1;E)$$ is not a free module:

sage: isinstance(C0, FiniteRankFreeModule)
False


since the Möbius bundle is not trivial:

sage: E.is_manifestly_trivial()
False


The section module over $$U$$, on the other hand, is a free module since $$E|_U$$ admits a trivialization and therefore has a local frame:

sage: C0_U = E.section_module(domain=U)
sage: isinstance(C0_U, FiniteRankFreeModule)
True


The elements of $$C^0(U)$$ are sections on $$U$$:

sage: C0_U.an_element()
Section on the Open subset U of the 1-dimensional topological
manifold RP^1 with values in the real vector bundle E of rank 1
sage: C0_U.an_element().display(phi_U.frame())
2 (phi_U^*e_1)

set_change_of_frame(frame1, frame2, change_of_frame, compute_inverse=True)

Relate two vector frames by an automorphism.

This updates the internal dictionary self._frame_changes.

INPUT:

• frame1 – frame 1, denoted $$(e_i)$$ below

• frame2 – frame 2, denoted $$(f_i)$$ below

• change_of_frame – instance of class FreeModuleAutomorphism describing the automorphism $$P$$ that relates the basis $$(e_i)$$ to the basis $$(f_i)$$ according to $$f_i = P(e_i)$$

• compute_inverse (default: True) – if set to True, the inverse automorphism is computed and the change from basis $$(f_i)$$ to $$(e_i)$$ is set to it in the internal dictionary self._frame_changes

EXAMPLES:

sage: M = Manifold(3, 'M')
sage: c_xyz.<x,y,z> = M.chart()
sage: E = M.vector_bundle(2, 'E')
sage: e = E.local_frame('e')
sage: f = E.local_frame('f')
sage: a = E.section_module().automorphism()
sage: a[e,:] = [[1,2],[0,3]]
sage: E.set_change_of_frame(e, f, a)
sage: f.display(e)
f_0 = e_0
sage: f.display(e)
f_1 = 2 e_0 + 3 e_1
sage: e.display(f)
e_0 = f_0
sage: e.display(f)
e_1 = -2/3 f_0 + 1/3 f_1
sage: E.change_of_frame(e,f)[e,:]
[1 2]
[0 3]

set_default_frame(frame)

Set the default frame of self.

INPUT:

EXAMPLES:

sage: M = Manifold(3, 'M', structure='top')
sage: E = M.vector_bundle(2, 'E')
sage: e = E.local_frame('e')
sage: E.default_frame()
Local frame (E|_M, (e_0,e_1))
sage: f = E.local_frame('f')
sage: E.set_default_frame(f)
sage: E.default_frame()
Local frame (E|_M, (f_0,f_1))

set_orientation(orientation)

Set the preferred orientation of self.

INPUT:

• orientation – a local frame or a list of local frames whose domains cover the base space

Warning

It is the user’s responsibility that the orientation set here is indeed an orientation. There is no check going on in the background. See orientation() for the definition of an orientation.

EXAMPLES:

Set an orientation on a vector bundle:

sage: M = Manifold(3, 'M', structure='top')
sage: E = M.vector_bundle(2, 'E')
sage: e = E.local_frame('e'); e
Local frame (E|_M, (e_0,e_1))
sage: f = E.local_frame('f'); f
Local frame (E|_M, (f_0,f_1))
sage: E.set_orientation(f)
sage: E.orientation()
[Local frame (E|_M, (f_0,f_1))]


Set an orientation in the non-trivial case:

sage: M = Manifold(3, 'M', structure='top')
sage: U = M.open_subset('U'); V = M.open_subset('V')
sage: M.declare_union(U, V)
sage: E = M.vector_bundle(2, 'E')
sage: e = E.local_frame('e', domain=U); e
Local frame (E|_U, (e_0,e_1))
sage: f = E.local_frame('f', domain=V); f
Local frame (E|_V, (f_0,f_1))
sage: E.orientation()
[]
sage: E.set_orientation([e, f])
sage: E.orientation()
[Local frame (E|_U, (e_0,e_1)),
Local frame (E|_V, (f_0,f_1))]

total_space()

Return the total space of self.

Note

At this stage, the total space does not come with induced charts.

OUTPUT:

EXAMPLES:

sage: M = Manifold(3, 'M', structure='top')
sage: E = M.vector_bundle(2, 'E')
sage: E.total_space()
6-dimensional topological manifold E

transition(triv1, triv2)

Return the transition map between two trivializations defined over the manifold.

The transition map must have been defined previously, for instance by the method transition_map().

INPUT:

• triv1 – trivialization 1

• triv2 – trivialization 2

OUTPUT:

EXAMPLES:

sage: M = Manifold(3, 'M')
sage: X.<x,y,z> = M.chart()
sage: U = M.open_subset('U')
sage: V = M.open_subset('V')
sage: X_UV = X.restrict(U.intersection(V))
sage: E = M.vector_bundle(2, 'E')
sage: phi_U = E.trivialization('phi_U', domain=U)
sage: phi_V = E.trivialization('phi_V', domain=V)
sage: phi_U_to_phi_V = phi_U.transition_map(phi_V, 1)
sage: E.transition(phi_V, phi_U)
Transition map from Trivialization (phi_V, E|_V) to Trivialization
(phi_U, E|_U)

transitions()

Return the transition maps defined over subsets of the base space.

OUTPUT:

• dictionary of transition maps, with pairs of trivializations as keys

EXAMPLES:

sage: M = Manifold(3, 'M')
sage: X.<x,y,z> = M.chart()
sage: U = M.open_subset('U')
sage: V = M.open_subset('V')
sage: X_UV = X.restrict(U.intersection(V))
sage: E = M.vector_bundle(2, 'E')
sage: phi_U = E.trivialization('phi_U', domain=U)
sage: phi_V = E.trivialization('phi_U', domain=V)
sage: phi_U_to_phi_V = phi_U.transition_map(phi_V, 1)
sage: E.transitions() # random
{(Trivialization (phi_U, E|_U),
Trivialization (phi_U, E|_V)): Transition map from Trivialization
(phi_U, E|_U) to Trivialization (phi_U, E|_V),
(Trivialization (phi_U, E|_V),
Trivialization (phi_U, E|_U)): Transition map from Trivialization
(phi_U, E|_V) to Trivialization (phi_U, E|_U)}

trivialization(name, domain=None, latex_name=None)

Return a trivialization of self over the domain domain.

INPUT:

• domain – (default: None) domain on which the trivialization is defined; if None the base space is assumed

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

• latex_name – (default: None) LaTeX name given to the trivialization

OUTPUT:

EXAMPLES:

sage: M = Manifold(3, 'M')
sage: U = M.open_subset('U')
sage: E = M.vector_bundle(2, 'E')
sage: phi = E.trivialization('phi', domain=U); phi
Trivialization (phi, E|_U)