Topological Vector Bundle - Manifolds

Skip to content
Back to top
View this page
Edit this page

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

- [Lee2013]

- [Mil1974]

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

  Bases: `CategoryObject`, `UniqueRepresentation`

  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

      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

  Python

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

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

  Sage

      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

  [Python]

      >>> from sage.all import *
      >>> M = Manifold(Integer(2), 'M', structure='top')
      >>> U = M.open_subset('U') ; V = M.open_subset('V')
      >>> M.declare_union(U,V)   # M is the union of U and V
      >>> c_xy = U.chart(names=('x', 'y',)); (x, y,) = c_xy._first_ngens(2); c_uv = V.chart(names=('u', 'v',)); (u, v,) = c_uv._first_ngens(2)
      >>> xy_to_uv = c_xy.transition_map(c_uv, (x+y, x-y),
      ...                    intersection_name='W', restrictions1= x>Integer(0),
      ...                    restrictions2= u+v>Integer(0))
      >>> uv_to_xy = xy_to_uv.inverse()
      >>> W = U.intersection(V)
      >>> E = M.vector_bundle(Integer(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

      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}

  Python

      >>> from sage.all import *
      >>> phi_U = E.trivialization('phi_U', domain=U); phi_U
      Trivialization (phi_U, E|_U)
      >>> phi_V = E.trivialization('phi_V', domain=V); phi_V
      Trivialization (phi_V, E|_V)
      >>> transf = phi_U.transition_map(phi_V, [[Integer(0),x],[x,Integer(0)]]) # transition map between trivializations
      >>> fU = phi_U.frame(); fU
      Trivialization frame (E|_U, ((phi_U^*e_1),(phi_U^*e_2)))
      >>> fV = phi_V.frame(); fV
      Trivialization frame (E|_V, ((phi_V^*e_1),(phi_V^*e_2)))
      >>> 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

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

  [Python]

      >>> from sage.all import *
      >>> 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

      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

  Python

      >>> from sage.all import *
      >>> eU = E.local_frame('eU', domain=U); eU
      Local frame (E|_U, (eU_0,eU_1))
      >>> eUW = eU.restrict(W) # to trivialize E|_W
      >>> eV = E.local_frame('eV', domain=V); eV
      Local frame (E|_V, (eV_0,eV_1))
      >>> eVW = eV.restrict(W)
      >>> 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
      >>> a[eUW,:] = [[Integer(0),x],[x,Integer(0)]]
      >>> E.set_change_of_frame(eUW, eVW, a)
      >>> 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

      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))]

  [Python]

      >>> from sage.all import *
      >>> 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

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

  Python

      >>> from sage.all import *
      >>> 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

      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

  [Python]

      >>> from sage.all import *
      >>> 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
      >>> s in E.section_module()
      True

  atlas()

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

    EXAMPLES:

    Sage

        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)]

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M')
        >>> U = M.open_subset('U')
        >>> V = M.open_subset('V')
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> phi_U = E.trivialization('phi_U', domain=U)
        >>> phi_V = E.trivialization('phi_V', domain=V)
        >>> phi_M = E.trivialization('phi_M')
        >>> 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

        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

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M', structure='topological')
        >>> E = M.vector_bundle(Integer(2), 'E', field=CC)
        >>> 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

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

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M', structure='top')
        >>> E = M.vector_bundle(Integer(2), 'E', field=CC)
        >>> E.base_field_type()
        'complex'

  base_space()

    Return the base space of the vector bundle.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M', structure='top')
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> 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

        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

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M', structure='top')
        >>> X = M.chart(names=('x', 'y', 'z',)); (x, y, z,) = X._first_ngens(3)
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> e = E.local_frame('e')
        >>> a = E.section_module().automorphism() # Now, the section module is free
        >>> a[:] = [[sqrt(Integer(3))/Integer(2), -Integer(1)/Integer(2)], [Integer(1)/Integer(2), sqrt(Integer(3))/Integer(2)]]
        >>> f = e.new_frame(a, 'f')
        >>> 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
        >>> a == E.change_of_frame(e, f)
        True
        >>> 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

        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}

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M', structure='top')
        >>> c_xyz = M.chart(names=('x', 'y', 'z',)); (x, y, z,) = c_xyz._first_ngens(3)
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> e = E.local_frame('e'); e
        Local frame (E|_M, (e_0,e_1))
        >>> auto_group = E.section_module().general_linear_group()
        >>> e_to_f = auto_group([[Integer(0),Integer(1)],[Integer(1),Integer(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
        >>> f_in_e = auto_group([[Integer(0),Integer(1)],[Integer(1),Integer(0)]])
        >>> f = e.new_frame(f_in_e, 'f'); f
        Local frame (E|_M, (f_0,f_1))
        >>> 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

        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))]

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M', structure='top')
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> U = M.open_subset('U'); V = M.open_subset('V')
        >>> phi_U = E.trivialization('phi_U', domain=U)
        >>> e = E.local_frame('e', domain=V)
        >>> 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:

    - a local frame as an instance of `LocalFrame`

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M', structure='top')
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> e = E.local_frame('e')
        >>> E.default_frame()
        Local frame (E|_M, (e_0,e_1))

  fiber(point)

    Return the vector bundle fiber over a point.

    INPUT:

    - `point` – `ManifoldPoint`; point \(p\) of the base space of `self`

    OUTPUT:

    - instance of `VectorBundleFiber` representing the fiber over \(p\)

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M', structure='top')
        >>> X = M.chart(names=('x', 'y', 'z',)); (x, y, z,) = X._first_ngens(3)
        >>> p = M((Integer(0),Integer(2),Integer(1)), name='p'); p
        Point p on the 3-dimensional topological manifold M
        >>> E = M.vector_bundle(Integer(2), 'E'); E
        Topological real vector bundle E -> M of rank 2 over the base space
         3-dimensional topological manifold M
        >>> 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

        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))]

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M', structure='top')
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> U = M.open_subset('U'); V = M.open_subset('V')
        >>> phi_U = E.trivialization('phi_U', domain=U)
        >>> e = E.local_frame('e', domain=V)
        >>> 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.

    See also

    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

        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

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M', structure='top')
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> e = E.local_frame('e')
        >>> E.has_orientation()  # trivial case
        True

    Non-trivial case:

    Sage

        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

    [Python]

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M', structure='top')
        >>> U = M.open_subset('U'); V = M.open_subset('V')
        >>> M.declare_union(U, V)
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> e = E.local_frame('e', domain=U)
        >>> f = E.local_frame('f', domain=V)
        >>> E.has_orientation()
        False
        >>> E.set_orientation([e, f])
        >>> 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

        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]

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(5), 'M', structure='topological')
        >>> E = M.vector_bundle(Integer(4), 'E')
        >>> list(E.irange())
        [0, 1, 2, 3]
        >>> list(E.irange(Integer(2)))
        [2, 3]

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

    Sage

        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]

    [Python]

        >>> from sage.all import *
        >>> M = Manifold(Integer(5), 'M', structure='topological', start_index=Integer(1))
        >>> E = M.vector_bundle(Integer(4), 'E')
        >>> list(E.irange())
        [1, 2, 3, 4]
        >>> list(E.irange(Integer(2)))
        [2, 3, 4]

    In general, one has always:

    Sage

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

    Python

        >>> from sage.all import *
        >>> 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

        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

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M', structure='top')
        >>> E = M.vector_bundle(Integer(1), 'E')
        >>> U = M.open_subset('U')
        >>> V = M.open_subset('V')
        >>> M.declare_union(U, V)
        >>> phi_U = E.trivialization('phi_U', domain=U); phi_U
        Trivialization (phi_U, E|_U)
        >>> phi_V = E.trivialization('phi_V', domain=V); phi_V
        Trivialization (phi_V, E|_V)
        >>> E.is_manifestly_trivial()
        False
        >>> E.trivialization('phi_M', M)
        Trivialization (phi_M, E|_M)
        >>> 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\).

    See also

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

    - a `LocalFrame` representing the defined local frame

    EXAMPLES:

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

    Sage

        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[0], e[1]) == (s0, s1)
        True

    Python

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

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

    Sage

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

    [Python]

        >>> from sage.all import *
        >>> 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

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

    Python

        >>> from sage.all import *
        >>> 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

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

    [Python]

        >>> from sage.all import *
        >>> g = E.local_frame('g'); g
        Local frame (E|_M, (g_0,g_1))

    See also

    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

        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))]

    Python

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

    The orientation can also be set by the user:

    Sage

        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))]

    [Python]

        >>> from sage.all import *
        >>> f = E.local_frame('f'); f
        Local frame (E|_M, (f_0,f_1))
        >>> E.set_orientation(f)
        >>> 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

        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))]

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M', structure='top')
        >>> U = M.open_subset('U'); V = M.open_subset('V')
        >>> M.declare_union(U, V)
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> e = E.local_frame('e', domain=U); e
        Local frame (E|_U, (e_0,e_1))
        >>> f = E.local_frame('f', domain=V); f
        Local frame (E|_V, (f_0,f_1))
        >>> E.orientation()
        []
        >>> E.set_orientation([e, f])
        >>> 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

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

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M', structure='top')
        >>> E = M.vector_bundle(Integer(3), 'E')
        >>> 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` – (default``None``) latex representation of the local section

    OUTPUT:

    - an instance of `Section` representing a continuous section of \(M\) with values on \(E\)

    EXAMPLES:

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

    Sage

        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

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M', structure='top')
        >>> U = M.open_subset('U') ; V = M.open_subset('V')
        >>> M.declare_union(U,V)   # M is the union of U and V
        >>> c_xy = U.chart(names=('x', 'y',)); (x, y,) = c_xy._first_ngens(2); c_uv = V.chart(names=('u', 'v',)); (u, v,) = c_uv._first_ngens(2)
        >>> xy_to_uv = c_xy.transition_map(c_uv, (x+y, x-y),
        ...                    intersection_name='W', restrictions1= x>Integer(0),
        ...                    restrictions2= u+v>Integer(0))
        >>> uv_to_xy = xy_to_uv.inverse()
        >>> W = U.intersection(V)
        >>> E = M.vector_bundle(Integer(2), 'E') # define the vector bundle
        >>> phi_U = E.trivialization('phi_U', domain=U) # define trivializations
        >>> phi_V = E.trivialization('phi_V', domain=V)
        >>> transf = phi_U.transition_map(phi_V, [[Integer(0),x],[x,Integer(0)]]) # transition map between trivializations
        >>> fU = phi_U.frame(); fV = phi_V.frame() # define induced frames
        >>> 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` – boolean (default: `False`); if set to `True`, force the construction of a free module (this implies that \(E\) is trivial)

    OUTPUT:

    - a `SectionModule` (or if \(E\) is trivial, a `SectionFreeModule`) representing the module of continuous sections on \(U\) taking values in \(E\)

    EXAMPLES:

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

    Sage

        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

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(1), 'RP^1', structure='top', start_index=Integer(1))
        >>> U = M.open_subset('U')  # the complement of one point
        >>> c_u = U.chart(names=('u',)); (u,) = c_u._first_ngens(1)# [1:u] in homogeneous coord.
        >>> V = M.open_subset('V') # the complement of the point u=0
        >>> M.declare_union(U,V)   # [v:1] in homogeneous coord.
        >>> c_v = V.chart(names=('v',)); (v,) = c_v._first_ngens(1)
        >>> u_to_v = c_u.transition_map(c_v, (Integer(1)/u),
        ...                             intersection_name='W',
        ...                             restrictions1 = u!=Integer(0),
        ...                             restrictions2 = v!=Integer(0))
        >>> v_to_u = u_to_v.inverse()
        >>> W = U.intersection(V)
        >>> E = M.vector_bundle(Integer(1), 'E')
        >>> phi_U = E.trivialization('phi_U', latex_name=r'\varphi_U',
        ...                          domain=U)
        >>> phi_V = E.trivialization('phi_V', latex_name=r'\varphi_V',
        ...                          domain=V)
        >>> transf = phi_U.transition_map(phi_V, [[u]])
        >>> 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

        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

    [Python]

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

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

    Sage

        sage: isinstance(C0, FiniteRankFreeModule)
        False

    Python

        >>> from sage.all import *
        >>> isinstance(C0, FiniteRankFreeModule)
        False

    since the Möbius bundle is not trivial:

    Sage

        sage: E.is_manifestly_trivial()
        False

    [Python]

        >>> from sage.all import *
        >>> 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

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

    Python

        >>> from sage.all import *
        >>> C0_U = E.section_module(domain=U)
        >>> isinstance(C0_U, FiniteRankFreeModule)
        True

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

    Sage

        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)

    [Python]

        >>> from sage.all import *
        >>> 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
        >>> 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` – boolean (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

        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[0].display(e)
        f_0 = e_0
        sage: f[1].display(e)
        f_1 = 2 e_0 + 3 e_1
        sage: e[0].display(f)
        e_0 = f_0
        sage: e[1].display(f)
        e_1 = -2/3 f_0 + 1/3 f_1
        sage: E.change_of_frame(e,f)[e,:]
        [1 2]
        [0 3]

    Python

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

  set_default_frame(frame)

    Set the default frame of `self`.

    INPUT:

    - `frame` – a local frame defined on `self` as an instance of `LocalFrame`

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M', structure='top')
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> e = E.local_frame('e')
        >>> E.default_frame()
        Local frame (E|_M, (e_0,e_1))
        >>> f = E.local_frame('f')
        >>> E.set_default_frame(f)
        >>> 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

        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))]

    Python

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

    Set an orientation in the non-trivial case:

    Sage

        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))]

    [Python]

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M', structure='top')
        >>> U = M.open_subset('U'); V = M.open_subset('V')
        >>> M.declare_union(U, V)
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> e = E.local_frame('e', domain=U); e
        Local frame (E|_U, (e_0,e_1))
        >>> f = E.local_frame('f', domain=V); f
        Local frame (E|_V, (f_0,f_1))
        >>> E.orientation()
        []
        >>> E.set_orientation([e, f])
        >>> 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:

    - the total space of `self` as an instance of `TopologicalManifold`

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M', structure='top')
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> E.total_space()
        5-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:

    - instance of `TransitionMap` representing the transition map from trivialization 1 to trivialization 2

    EXAMPLES:

    Sage

        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)

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M')
        >>> X = M.chart(names=('x', 'y', 'z',)); (x, y, z,) = X._first_ngens(3)
        >>> U = M.open_subset('U')
        >>> V = M.open_subset('V')
        >>> X_UV = X.restrict(U.intersection(V))
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> phi_U = E.trivialization('phi_U', domain=U)
        >>> phi_V = E.trivialization('phi_V', domain=V)
        >>> phi_U_to_phi_V = phi_U.transition_map(phi_V, Integer(1))
        >>> 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

        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)}

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M')
        >>> X = M.chart(names=('x', 'y', 'z',)); (x, y, z,) = X._first_ngens(3)
        >>> U = M.open_subset('U')
        >>> V = M.open_subset('V')
        >>> X_UV = X.restrict(U.intersection(V))
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> phi_U = E.trivialization('phi_U', domain=U)
        >>> phi_V = E.trivialization('phi_U', domain=V)
        >>> phi_U_to_phi_V = phi_U.transition_map(phi_V, Integer(1))
        >>> 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:

    - a `Trivialization` representing a trivialization of \(E\)

    EXAMPLES:

    Sage

        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)

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M')
        >>> U = M.open_subset('U')
        >>> E = M.vector_bundle(Integer(2), 'E')
        >>> phi = E.trivialization('phi', domain=U); phi
        Trivialization (phi, E|_U)