Vector Field Modules - Manifolds

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

# Vector Field Modules

The set of vector fields along a differentiable manifold \(U\) with values on a differentiable manifold \(M\) via a differentiable map \(\Phi: U \to M\) (possibly \(U = M\) and \(\Phi=\mathrm{Id}_M\)) is a module over the algebra \(C^k(U)\) of differentiable scalar fields on \(U\). If \(\Phi\) is the identity map, this module is considered a Lie algebroid under the Lie bracket \([\ ,\ ]\) (cf. Wikipedia article Lie_algebroid). It is a free module if and only if \(M\) is parallelizable. Accordingly, there are two classes for vector field modules:

- `VectorFieldModule` for vector fields with values on a generic (in practice, not parallelizable) differentiable manifold \(M\).

- `VectorFieldFreeModule` for vector fields with values on a parallelizable manifold \(M\).

AUTHORS:

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

- Travis Scrimshaw (2016): structure of Lie algebroid (Issue #20771)

REFERENCES:

- [KN1963]

- [Lee2013]

- [ONe1983]

class sage.manifolds.differentiable.vectorfield_module.VectorFieldFreeModule(domain, dest_map=None)

  Bases: `FiniteRankFreeModule`

  Free module of vector fields along a differentiable manifold \(U\) with values on a parallelizable manifold \(M\), via a differentiable map \(U \rightarrow M\).

  Given a differentiable map

  \[\Phi:\ U \longrightarrow M\]

  the vector field module \(\mathfrak{X}(U,\Phi)\) is the set of all vector fields of the type

  \[v:\ U \longrightarrow TM\]

  (where \(TM\) is the tangent bundle of \(M\)) such that

  \[\forall p \in U,\ v(p) \in T_{\Phi(p)} M,\]

  where \(T_{\Phi(p)} M\) is the tangent space to \(M\) at the point \(\Phi(p)\).

  Since \(M\) is parallelizable, the set \(\mathfrak{X}(U,\Phi)\) is a free module over \(C^k(U)\), the ring (algebra) of differentiable scalar fields on \(U\) (see `DiffScalarFieldAlgebra`). In fact, it carries the structure of a finite-dimensional Lie algebroid (cf. Wikipedia article Lie_algebroid).

  The standard case of vector fields on a differentiable manifold corresponds to \(U=M\) and \(\Phi = \mathrm{Id}_M\); we then denote \(\mathfrak{X}(M,\mathrm{Id}_M)\) by merely \(\mathfrak{X}(M)\). Other common cases are \(\Phi\) being an immersion and \(\Phi\) being a curve in \(M\) (\(U\) is then an open interval of \(\RR\)).

  Note

  If \(M\) is not parallelizable, the class `VectorFieldModule` should be used instead, for \(\mathfrak{X}(U,\Phi)\) is no longer a free module.

  INPUT:

  - `domain` – differentiable manifold \(U\) along which the vector fields are defined

  - `dest_map` – (default: `None`) destination map \(\Phi:\ U \rightarrow M\) (type: `DiffMap`); if `None`, it is assumed that \(U=M\) and \(\Phi\) is the identity map of \(M\) (case of vector fields on \(M\))

  EXAMPLES:

  Module of vector fields on \(\RR^2\):

  Sage

      sage: M = Manifold(2, 'R^2')
      sage: cart.<x,y> = M.chart()  # Cartesian coordinates on R^2
      sage: XM = M.vector_field_module() ; XM
      Free module X(R^2) of vector fields on the 2-dimensional differentiable
       manifold R^2
      sage: XM.category()
      Category of finite dimensional modules
       over Algebra of differentiable scalar fields
       on the 2-dimensional differentiable manifold R^2
      sage: XM.base_ring() is M.scalar_field_algebra()
      True

  Python

      >>> from sage.all import *
      >>> M = Manifold(Integer(2), 'R^2')
      >>> cart = M.chart(names=('x', 'y',)); (x, y,) = cart._first_ngens(2)# Cartesian coordinates on R^2
      >>> XM = M.vector_field_module() ; XM
      Free module X(R^2) of vector fields on the 2-dimensional differentiable
       manifold R^2
      >>> XM.category()
      Category of finite dimensional modules
       over Algebra of differentiable scalar fields
       on the 2-dimensional differentiable manifold R^2
      >>> XM.base_ring() is M.scalar_field_algebra()
      True

  Since \(\RR^2\) is obviously parallelizable, `XM` is a free module:

  Sage

      sage: isinstance(XM, FiniteRankFreeModule)
      True

  [Python]

      >>> from sage.all import *
      >>> isinstance(XM, FiniteRankFreeModule)
      True

  Some elements:

  Sage

      sage: XM.an_element().display()
      2 ∂/∂x + 2 ∂/∂y
      sage: XM.zero().display()
      zero = 0
      sage: v = XM([-y,x]) ; v
      Vector field on the 2-dimensional differentiable manifold R^2
      sage: v.display()
      -y ∂/∂x + x ∂/∂y

  Python

      >>> from sage.all import *
      >>> XM.an_element().display()
      2 ∂/∂x + 2 ∂/∂y
      >>> XM.zero().display()
      zero = 0
      >>> v = XM([-y,x]) ; v
      Vector field on the 2-dimensional differentiable manifold R^2
      >>> v.display()
      -y ∂/∂x + x ∂/∂y

  An example of module of vector fields with a destination map \(\Phi\) different from the identity map, namely a mapping \(\Phi: I \rightarrow \RR^2\), where \(I\) is an open interval of \(\RR\):

  Sage

      sage: I = Manifold(1, 'I')
      sage: canon.<t> = I.chart('t:(0,2*pi)')
      sage: Phi = I.diff_map(M, coord_functions=[cos(t), sin(t)], name='Phi',
      ....:                      latex_name=r'\Phi') ; Phi
      Differentiable map Phi from the 1-dimensional differentiable manifold
       I to the 2-dimensional differentiable manifold R^2
      sage: Phi.display()
      Phi: I → R^2
         t ↦ (x, y) = (cos(t), sin(t))
      sage: XIM = I.vector_field_module(dest_map=Phi) ; XIM
      Free module X(I,Phi) of vector fields along the 1-dimensional
       differentiable manifold I mapped into the 2-dimensional differentiable
       manifold R^2
      sage: XIM.category()
      Category of finite dimensional modules
       over Algebra of differentiable scalar fields
       on the 1-dimensional differentiable manifold I

  [Python]

      >>> from sage.all import *
      >>> I = Manifold(Integer(1), 'I')
      >>> canon = I.chart('t:(0,2*pi)', names=('t',)); (t,) = canon._first_ngens(1)
      >>> Phi = I.diff_map(M, coord_functions=[cos(t), sin(t)], name='Phi',
      ...                      latex_name=r'\Phi') ; Phi
      Differentiable map Phi from the 1-dimensional differentiable manifold
       I to the 2-dimensional differentiable manifold R^2
      >>> Phi.display()
      Phi: I → R^2
         t ↦ (x, y) = (cos(t), sin(t))
      >>> XIM = I.vector_field_module(dest_map=Phi) ; XIM
      Free module X(I,Phi) of vector fields along the 1-dimensional
       differentiable manifold I mapped into the 2-dimensional differentiable
       manifold R^2
      >>> XIM.category()
      Category of finite dimensional modules
       over Algebra of differentiable scalar fields
       on the 1-dimensional differentiable manifold I

  The rank of the free module \(\mathfrak{X}(I,\Phi)\) is the dimension of the manifold \(\RR^2\), namely two:

  Sage

      sage: XIM.rank()
      2

  Python

      >>> from sage.all import *
      >>> XIM.rank()
      2

  A basis of it is induced by the coordinate vector frame of \(\RR^2\):

  Sage

      sage: XIM.bases()
      [Vector frame (I, (∂/∂x,∂/∂y)) with values on the 2-dimensional
       differentiable manifold R^2]

  [Python]

      >>> from sage.all import *
      >>> XIM.bases()
      [Vector frame (I, (∂/∂x,∂/∂y)) with values on the 2-dimensional
       differentiable manifold R^2]

  Some elements of this module:

  Sage

      sage: XIM.an_element().display()
      2 ∂/∂x + 2 ∂/∂y
      sage: v = XIM([t, t^2]) ; v
      Vector field along the 1-dimensional differentiable manifold I with
       values on the 2-dimensional differentiable manifold R^2
      sage: v.display()
      t ∂/∂x + t^2 ∂/∂y

  Python

      >>> from sage.all import *
      >>> XIM.an_element().display()
      2 ∂/∂x + 2 ∂/∂y
      >>> v = XIM([t, t**Integer(2)]) ; v
      Vector field along the 1-dimensional differentiable manifold I with
       values on the 2-dimensional differentiable manifold R^2
      >>> v.display()
      t ∂/∂x + t^2 ∂/∂y

  The test suite is passed:

  Sage

      sage: TestSuite(XIM).run()

  [Python]

      >>> from sage.all import *
      >>> TestSuite(XIM).run()

  Let us introduce an open subset of \(J\subset I\) and the vector field module corresponding to the restriction of \(\Phi\) to it:

  Sage

      sage: J = I.open_subset('J', coord_def={canon: t<pi})
      sage: XJM = J.vector_field_module(dest_map=Phi.restrict(J)); XJM
      Free module X(J,Phi) of vector fields along the Open subset J of the
       1-dimensional differentiable manifold I mapped into the 2-dimensional
       differentiable manifold R^2

  Python

      >>> from sage.all import *
      >>> J = I.open_subset('J', coord_def={canon: t<pi})
      >>> XJM = J.vector_field_module(dest_map=Phi.restrict(J)); XJM
      Free module X(J,Phi) of vector fields along the Open subset J of the
       1-dimensional differentiable manifold I mapped into the 2-dimensional
       differentiable manifold R^2

  We have then:

  Sage

      sage: XJM.default_basis()
      Vector frame (J, (∂/∂x,∂/∂y)) with values on the 2-dimensional
       differentiable manifold R^2
      sage: XJM.default_basis() is XIM.default_basis().restrict(J)
      True
      sage: v.restrict(J)
      Vector field along the Open subset J of the 1-dimensional
       differentiable manifold I with values on the 2-dimensional
       differentiable manifold R^2
      sage: v.restrict(J).display()
      t ∂/∂x + t^2 ∂/∂y

  [Python]

      >>> from sage.all import *
      >>> XJM.default_basis()
      Vector frame (J, (∂/∂x,∂/∂y)) with values on the 2-dimensional
       differentiable manifold R^2
      >>> XJM.default_basis() is XIM.default_basis().restrict(J)
      True
      >>> v.restrict(J)
      Vector field along the Open subset J of the 1-dimensional
       differentiable manifold I with values on the 2-dimensional
       differentiable manifold R^2
      >>> v.restrict(J).display()
      t ∂/∂x + t^2 ∂/∂y

  Let us now consider the module of vector fields on the circle \(S^1\); we start by constructing the \(S^1\) manifold:

  Sage

      sage: M = Manifold(1, 'S^1')
      sage: U = M.open_subset('U')  # the complement of one point
      sage: c_t.<t> =  U.chart('t:(0,2*pi)') # the standard angle coordinate
      sage: V = M.open_subset('V') # the complement of the point t=pi
      sage: M.declare_union(U,V)   # S^1 is the union of U and V
      sage: c_u.<u> = V.chart('u:(0,2*pi)') # the angle t-pi
      sage: t_to_u = c_t.transition_map(c_u, (t-pi,), intersection_name='W',
      ....:                     restrictions1 = t!=pi, restrictions2 = u!=pi)
      sage: u_to_t = t_to_u.inverse()
      sage: W = U.intersection(V)

  Python

      >>> from sage.all import *
      >>> M = Manifold(Integer(1), 'S^1')
      >>> U = M.open_subset('U')  # the complement of one point
      >>> c_t = U.chart('t:(0,2*pi)', names=('t',)); (t,) = c_t._first_ngens(1)# the standard angle coordinate
      >>> V = M.open_subset('V') # the complement of the point t=pi
      >>> M.declare_union(U,V)   # S^1 is the union of U and V
      >>> c_u = V.chart('u:(0,2*pi)', names=('u',)); (u,) = c_u._first_ngens(1)# the angle t-pi
      >>> t_to_u = c_t.transition_map(c_u, (t-pi,), intersection_name='W',
      ...                     restrictions1 = t!=pi, restrictions2 = u!=pi)
      >>> u_to_t = t_to_u.inverse()
      >>> W = U.intersection(V)

  \(S^1\) cannot be covered by a single chart, so it cannot be covered by a coordinate frame. It is however parallelizable and we introduce a global vector frame as follows. We notice that on their common subdomain, \(W\), the coordinate vectors \(\partial/\partial t\) and \(\partial/\partial u\) coincide, as we can check explicitly:

  Sage

      sage: c_t.frame()[0].display(c_u.frame().restrict(W))
      ∂/∂t = ∂/∂u

  [Python]

      >>> from sage.all import *
      >>> c_t.frame()[Integer(0)].display(c_u.frame().restrict(W))
      ∂/∂t = ∂/∂u

  Therefore, we can extend \(\partial/\partial t\) to all \(V\) and hence to all \(S^1\), to form a vector field on \(S^1\) whose components w.r.t. both \(\partial/\partial t\) and \(\partial/\partial u\) are 1:

  Sage

      sage: e = M.vector_frame('e')
      sage: U.set_change_of_frame(e.restrict(U), c_t.frame(),
      ....:                       U.tangent_identity_field())
      sage: V.set_change_of_frame(e.restrict(V), c_u.frame(),
      ....:                       V.tangent_identity_field())
      sage: e[0].display(c_t.frame())
      e_0 = ∂/∂t
      sage: e[0].display(c_u.frame())
      e_0 = ∂/∂u

  Python

      >>> from sage.all import *
      >>> e = M.vector_frame('e')
      >>> U.set_change_of_frame(e.restrict(U), c_t.frame(),
      ...                       U.tangent_identity_field())
      >>> V.set_change_of_frame(e.restrict(V), c_u.frame(),
      ...                       V.tangent_identity_field())
      >>> e[Integer(0)].display(c_t.frame())
      e_0 = ∂/∂t
      >>> e[Integer(0)].display(c_u.frame())
      e_0 = ∂/∂u

  Equipped with the frame \(e\), the manifold \(S^1\) is manifestly parallelizable:

  Sage

      sage: M.is_manifestly_parallelizable()
      True

  [Python]

      >>> from sage.all import *
      >>> M.is_manifestly_parallelizable()
      True

  Consequently, the module of vector fields on \(S^1\) is a free module:

  Sage

      sage: XM = M.vector_field_module() ; XM
      Free module X(S^1) of vector fields on the 1-dimensional differentiable
       manifold S^1
      sage: isinstance(XM, FiniteRankFreeModule)
      True
      sage: XM.category()
      Category of finite dimensional modules
       over Algebra of differentiable scalar fields
       on the 1-dimensional differentiable manifold S^1
      sage: XM.base_ring() is M.scalar_field_algebra()
      True

  Python

      >>> from sage.all import *
      >>> XM = M.vector_field_module() ; XM
      Free module X(S^1) of vector fields on the 1-dimensional differentiable
       manifold S^1
      >>> isinstance(XM, FiniteRankFreeModule)
      True
      >>> XM.category()
      Category of finite dimensional modules
       over Algebra of differentiable scalar fields
       on the 1-dimensional differentiable manifold S^1
      >>> XM.base_ring() is M.scalar_field_algebra()
      True

  The zero element:

  Sage

      sage: z = XM.zero() ; z
      Vector field zero on the 1-dimensional differentiable manifold S^1
      sage: z.display()
      zero = 0
      sage: z.display(c_t.frame())
      zero = 0

  [Python]

      >>> from sage.all import *
      >>> z = XM.zero() ; z
      Vector field zero on the 1-dimensional differentiable manifold S^1
      >>> z.display()
      zero = 0
      >>> z.display(c_t.frame())
      zero = 0

  The module \(\mathfrak{X}(S^1)\) coerces to any module of vector fields defined on a subdomain of \(S^1\), for instance \(\mathfrak{X}(U)\):

  Sage

      sage: XU = U.vector_field_module() ; XU
      Free module X(U) of vector fields on the Open subset U of the
       1-dimensional differentiable manifold S^1
      sage: XU.has_coerce_map_from(XM)
      True
      sage: XU.coerce_map_from(XM)
      Coercion map:
        From: Free module X(S^1) of vector fields on the 1-dimensional
         differentiable manifold S^1
        To:   Free module X(U) of vector fields on the Open subset U of the
         1-dimensional differentiable manifold S^1

  Python

      >>> from sage.all import *
      >>> XU = U.vector_field_module() ; XU
      Free module X(U) of vector fields on the Open subset U of the
       1-dimensional differentiable manifold S^1
      >>> XU.has_coerce_map_from(XM)
      True
      >>> XU.coerce_map_from(XM)
      Coercion map:
        From: Free module X(S^1) of vector fields on the 1-dimensional
         differentiable manifold S^1
        To:   Free module X(U) of vector fields on the Open subset U of the
         1-dimensional differentiable manifold S^1

  The conversion map is actually the restriction of vector fields defined on \(S^1\) to \(U\).

  The Sage test suite for modules is passed:

  Sage

      sage: TestSuite(XM).run()

  [Python]

      >>> from sage.all import *
      >>> TestSuite(XM).run()

  Element

    alias of `VectorFieldParal`

  ambient_domain()

    Return the manifold in which the vector fields of `self` take their values.

    If the module is \(\mathfrak{X}(U, \Phi)\), returns the codomain \(M\) of \(\Phi\).

    OUTPUT:

    - a `DifferentiableManifold` representing the manifold in which the vector fields of `self` take their values

    EXAMPLES:

    Sage

        sage: M = Manifold(3, 'M')
        sage: X.<x,y,z> = M.chart()  # makes M parallelizable
        sage: XM = M.vector_field_module()
        sage: XM.ambient_domain()
        3-dimensional differentiable manifold M
        sage: U = Manifold(2, 'U')
        sage: Y.<u,v> = U.chart()
        sage: Phi = U.diff_map(M, {(Y,X): [u+v, u-v, u*v]}, name='Phi')
        sage: XU = U.vector_field_module(dest_map=Phi)
        sage: XU.ambient_domain()
        3-dimensional differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M')
        >>> X = M.chart(names=('x', 'y', 'z',)); (x, y, z,) = X._first_ngens(3)# makes M parallelizable
        >>> XM = M.vector_field_module()
        >>> XM.ambient_domain()
        3-dimensional differentiable manifold M
        >>> U = Manifold(Integer(2), 'U')
        >>> Y = U.chart(names=('u', 'v',)); (u, v,) = Y._first_ngens(2)
        >>> Phi = U.diff_map(M, {(Y,X): [u+v, u-v, u*v]}, name='Phi')
        >>> XU = U.vector_field_module(dest_map=Phi)
        >>> XU.ambient_domain()
        3-dimensional differentiable manifold M

  basis(symbol=None, latex_symbol=None, from_frame=None, indices=None, latex_indices=None, symbol_dual=None, latex_symbol_dual=None)

    Define a basis of `self`.

    A basis of the vector field module is actually a vector frame along the differentiable manifold \(U\) over which the vector field module is defined.

    If the basis specified by the given symbol already exists, it is simply returned. If no argument is provided the module’s default basis is returned.

    INPUT:

    - `symbol` – (default: `None`) either a string, to be used as a common base for the symbols of the elements of the basis, or a tuple of strings, representing the individual symbols of the elements of the basis

    - `latex_symbol` – (default: `None`) either a string, to be used as a common base for the LaTeX symbols of the elements of the basis, or a tuple of strings, representing the individual LaTeX symbols of the elements of the basis; if `None`, `symbol` is used in place of `latex_symbol`

    - `from_frame` – (default: `None`) vector frame \(\tilde{e}\) on the codomain \(M\) of the destination map \(\Phi\) of `self`; the returned basis \(e\) is then such that for all \(p \in U\), we have \(e(p) = \tilde{e}(\Phi(p))\)

    - `indices` – (default: `None`; used only if `symbol` is a single string) tuple of strings representing the indices labelling the elements of the basis; 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 elements of the basis; if `None`, `indices` is used instead

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

    - `latex_symbol_dual` – (default: `None`) same as `latex_symbol` but for the dual basis

    OUTPUT:

    - a `VectorFrame` representing a basis on `self`

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: X.<x,y> = M.chart()  # makes M parallelizable
        sage: XM = M.vector_field_module()
        sage: e = XM.basis('e'); e
        Vector frame (M, (e_0,e_1))

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> X = M.chart(names=('x', 'y',)); (x, y,) = X._first_ngens(2)# makes M parallelizable
        >>> XM = M.vector_field_module()
        >>> e = XM.basis('e'); e
        Vector frame (M, (e_0,e_1))

    See `VectorFrame` for more examples and documentation.

  destination_map()

    Return the differential map associated to `self`.

    The differential map associated to this module is the map

    \[\Phi:\ U \longrightarrow M\]

    such that this module is the set \(\mathfrak{X}(U,\Phi)\) of all vector fields of the type

    \[v:\ U \longrightarrow TM\]

    (where \(TM\) is the tangent bundle of \(M\)) such that

    \[\forall p \in U,\ v(p) \in T_{\Phi(p)} M,\]

    where \(T_{\Phi(p)} M\) is the tangent space to \(M\) at the point \(\Phi(p)\).

    OUTPUT:

    - a `DiffMap` representing the differential map \(\Phi\)

    EXAMPLES:

    Sage

        sage: M = Manifold(3, 'M')
        sage: X.<x,y,z> = M.chart()  # makes M parallelizable
        sage: XM = M.vector_field_module()
        sage: XM.destination_map()
        Identity map Id_M of the 3-dimensional differentiable manifold M
        sage: U = Manifold(2, 'U')
        sage: Y.<u,v> = U.chart()
        sage: Phi = U.diff_map(M, {(Y,X): [u+v, u-v, u*v]}, name='Phi')
        sage: XU = U.vector_field_module(dest_map=Phi)
        sage: XU.destination_map()
        Differentiable map Phi from the 2-dimensional differentiable
         manifold U to the 3-dimensional differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(3), 'M')
        >>> X = M.chart(names=('x', 'y', 'z',)); (x, y, z,) = X._first_ngens(3)# makes M parallelizable
        >>> XM = M.vector_field_module()
        >>> XM.destination_map()
        Identity map Id_M of the 3-dimensional differentiable manifold M
        >>> U = Manifold(Integer(2), 'U')
        >>> Y = U.chart(names=('u', 'v',)); (u, v,) = Y._first_ngens(2)
        >>> Phi = U.diff_map(M, {(Y,X): [u+v, u-v, u*v]}, name='Phi')
        >>> XU = U.vector_field_module(dest_map=Phi)
        >>> XU.destination_map()
        Differentiable map Phi from the 2-dimensional differentiable
         manifold U to the 3-dimensional differentiable manifold M

  domain()

    Return the domain of the vector fields in `self`.

    If the module is \(\mathfrak{X}(U, \Phi)\), returns the domain \(U\) of \(\Phi\).

    OUTPUT:

    - a `DifferentiableManifold` representing the domain of the vector fields that belong to this module

    EXAMPLES:

    Sage

        sage: M = Manifold(3, 'M')
        sage: X.<x,y,z> = M.chart()  # makes M parallelizable
        sage: XM = M.vector_field_module()
        sage: XM.domain()
        3-dimensional differentiable manifold M
        sage: U = Manifold(2, 'U')
        sage: Y.<u,v> = U.chart()
        sage: Phi = U.diff_map(M, {(Y,X): [u+v, u-v, u*v]}, name='Phi')
        sage: XU = U.vector_field_module(dest_map=Phi)
        sage: XU.domain()
        2-dimensional differentiable manifold 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)# makes M parallelizable
        >>> XM = M.vector_field_module()
        >>> XM.domain()
        3-dimensional differentiable manifold M
        >>> U = Manifold(Integer(2), 'U')
        >>> Y = U.chart(names=('u', 'v',)); (u, v,) = Y._first_ngens(2)
        >>> Phi = U.diff_map(M, {(Y,X): [u+v, u-v, u*v]}, name='Phi')
        >>> XU = U.vector_field_module(dest_map=Phi)
        >>> XU.domain()
        2-dimensional differentiable manifold U

  dual_exterior_power(p)

    Return the \(p\)-th exterior power of the dual of `self`.

    If the vector field module `self` is \(\mathfrak{X}(U,\Phi)\), the \(p\)-th exterior power of its dual is the set \(\Omega^p(U, \Phi)\) of \(p\)-forms along \(U\) with values on \(\Phi(U)\). It is a free module over \(C^k(U)\), the ring (algebra) of differentiable scalar fields on \(U\).

    INPUT:

    - `p` – nonnegative integer

    OUTPUT:

    - for \(p=0\), the base ring, i.e. \(C^k(U)\)

    - for \(p \geq 1\), a `DiffFormFreeModule` representing the module \(\Omega^p(U,\Phi)\)

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: X.<x,y> = M.chart()  # makes M parallelizable
        sage: XM = M.vector_field_module()
        sage: XM.dual_exterior_power(2)
        Free module Omega^2(M) of 2-forms on the 2-dimensional
         differentiable manifold M
        sage: XM.dual_exterior_power(1)
        Free module Omega^1(M) of 1-forms on the 2-dimensional differentiable manifold M
        sage: XM.dual_exterior_power(1) is XM.dual()
        True
        sage: XM.dual_exterior_power(0)
        Algebra of differentiable scalar fields on the 2-dimensional
         differentiable manifold M
        sage: XM.dual_exterior_power(0) is M.scalar_field_algebra()
        True

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> X = M.chart(names=('x', 'y',)); (x, y,) = X._first_ngens(2)# makes M parallelizable
        >>> XM = M.vector_field_module()
        >>> XM.dual_exterior_power(Integer(2))
        Free module Omega^2(M) of 2-forms on the 2-dimensional
         differentiable manifold M
        >>> XM.dual_exterior_power(Integer(1))
        Free module Omega^1(M) of 1-forms on the 2-dimensional differentiable manifold M
        >>> XM.dual_exterior_power(Integer(1)) is XM.dual()
        True
        >>> XM.dual_exterior_power(Integer(0))
        Algebra of differentiable scalar fields on the 2-dimensional
         differentiable manifold M
        >>> XM.dual_exterior_power(Integer(0)) is M.scalar_field_algebra()
        True

    See also

    `DiffFormFreeModule` for more examples and documentation.

  exterior_power(p)

    Return the \(p\)-th exterior power of `self`.

    If the vector field module `self` is \(\mathfrak{X}(U,\Phi)\), its \(p\)-th exterior power is the set \(A^p(U, \Phi)\) of \(p\)-vector fields along \(U\) with values on \(\Phi(U)\). It is a free module over \(C^k(U)\), the ring (algebra) of differentiable scalar fields on \(U\).

    INPUT:

    - `p` – nonnegative integer

    OUTPUT:

    - for \(p=0\), the base ring, i.e. \(C^k(U)\)

    - for \(p=1\), the vector field free module `self`, since \(A^1(U, \Phi) = \mathfrak{X}(U,\Phi)\)

    - for \(p \geq 2\), instance of `MultivectorFreeModule` representing the module \(A^p(U,\Phi)\)

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: X.<x,y> = M.chart()  # makes M parallelizable
        sage: XM = M.vector_field_module()
        sage: XM.exterior_power(2)
        Free module A^2(M) of 2-vector fields on the 2-dimensional
         differentiable manifold M
        sage: XM.exterior_power(1)
        Free module X(M) of vector fields on the 2-dimensional
         differentiable manifold M
        sage: XM.exterior_power(1) is XM
        True
        sage: XM.exterior_power(0)
        Algebra of differentiable scalar fields on the 2-dimensional
         differentiable manifold M
        sage: XM.exterior_power(0) is M.scalar_field_algebra()
        True

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> X = M.chart(names=('x', 'y',)); (x, y,) = X._first_ngens(2)# makes M parallelizable
        >>> XM = M.vector_field_module()
        >>> XM.exterior_power(Integer(2))
        Free module A^2(M) of 2-vector fields on the 2-dimensional
         differentiable manifold M
        >>> XM.exterior_power(Integer(1))
        Free module X(M) of vector fields on the 2-dimensional
         differentiable manifold M
        >>> XM.exterior_power(Integer(1)) is XM
        True
        >>> XM.exterior_power(Integer(0))
        Algebra of differentiable scalar fields on the 2-dimensional
         differentiable manifold M
        >>> XM.exterior_power(Integer(0)) is M.scalar_field_algebra()
        True

    See also

    `MultivectorFreeModule` for more examples and documentation.

  general_linear_group()

    Return the general linear group of `self`.

    If the vector field module is \(\mathfrak{X}(U,\Phi)\), the general linear group is the group \(\mathrm{GL}(\mathfrak{X}(U,\Phi))\) of automorphisms of \(\mathfrak{X}(U,\Phi)\). Note that an automorphism of \(\mathfrak{X}(U,\Phi)\) can also be viewed as a field along \(U\) of automorphisms of the tangent spaces of \(V=\Phi(U)\).

    OUTPUT:

    - a `AutomorphismFieldParalGroup` representing \(\mathrm{GL}(\mathfrak{X}(U,\Phi))\)

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: X.<x,y> = M.chart()  # makes M parallelizable
        sage: XM = M.vector_field_module()
        sage: XM.general_linear_group()
        General linear group of the Free module X(M) of vector fields on
         the 2-dimensional differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> X = M.chart(names=('x', 'y',)); (x, y,) = X._first_ngens(2)# makes M parallelizable
        >>> XM = M.vector_field_module()
        >>> XM.general_linear_group()
        General linear group of the Free module X(M) of vector fields on
         the 2-dimensional differentiable manifold M

    See also

    `AutomorphismFieldParalGroup` for more examples and documentation.

  metric(name, signature=None, latex_name=None)

    Construct a pseudo-Riemannian metric (nondegenerate symmetric bilinear form) on the current vector field module.

    A pseudo-Riemannian metric of the vector field module is actually a field of tangent-space non-degenerate symmetric bilinear forms along the manifold \(U\) on which the vector field module is defined.

    INPUT:

    - `name` – string; name given to the metric

    - `signature` – integer (default: `None`); signature \(S\) of the metric: \(S = n_+ - n_-\), where \(n_+\) (resp. \(n_-\)) is the number of positive terms (resp. number of negative terms) in any diagonal writing of the metric components; if `signature` is not provided, \(S\) is set to the manifold’s dimension (Riemannian signature)

    - `latex_name` – (string; default: `None`) LaTeX symbol to denote the metric; if `None`, it is formed from `name`

    OUTPUT:

    - instance of `PseudoRiemannianMetricParal` representing the defined pseudo-Riemannian metric.

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: X.<x,y> = M.chart()  # makes M parallelizable
        sage: XM = M.vector_field_module()
        sage: XM.metric('g')
        Riemannian metric g on the 2-dimensional differentiable manifold M
        sage: XM.metric('g', signature=0)
        Lorentzian metric g on the 2-dimensional differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> X = M.chart(names=('x', 'y',)); (x, y,) = X._first_ngens(2)# makes M parallelizable
        >>> XM = M.vector_field_module()
        >>> XM.metric('g')
        Riemannian metric g on the 2-dimensional differentiable manifold M
        >>> XM.metric('g', signature=Integer(0))
        Lorentzian metric g on the 2-dimensional differentiable manifold M

    See also

    `PseudoRiemannianMetricParal` for more documentation.

  poisson_tensor(name=None, latex_name=None)

    Construct a Poisson tensor on the current vector field module.

    OUTPUT:

    - instance of `PoissonTensorFieldParal`

    EXAMPLES:

    Standard Poisson tensor on \(\RR^2\):

    Sage

        sage: M.<q, p> = EuclideanSpace(2)
        sage: poisson = M.vector_field_module().poisson_tensor('varpi')
        sage: poisson.set_comp()[1,2] = -1
        sage: poisson.display()
        varpi = -e_q∧e_p

    Python

        >>> from sage.all import *
        >>> M = EuclideanSpace(Integer(2), names=('q', 'p',)); (q, p,) = M._first_ngens(2)
        >>> poisson = M.vector_field_module().poisson_tensor('varpi')
        >>> poisson.set_comp()[Integer(1),Integer(2)] = -Integer(1)
        >>> poisson.display()
        varpi = -e_q∧e_p

  sym_bilinear_form(name=None, latex_name=None)

    Construct a symmetric bilinear form on `self`.

    A symmetric bilinear form on the vector field module is actually a field of tangent-space symmetric bilinear forms along the differentiable manifold \(U\) over which the vector field module is defined.

    INPUT:

    - `name` – string (default: `None`); name given to the symmetric bilinear form

    - `latex_name` – string (default: `None`); LaTeX symbol to denote the symmetric bilinear form; if `None`, the LaTeX symbol is set to `name`

    OUTPUT:

    - a `TensorFieldParal` of tensor type \((0,2)\) and symmetric

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: X.<x,y> = M.chart()  # makes M parallelizable
        sage: XM = M.vector_field_module()
        sage: XM.sym_bilinear_form(name='a')
        Field of symmetric bilinear forms a on the 2-dimensional
         differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> X = M.chart(names=('x', 'y',)); (x, y,) = X._first_ngens(2)# makes M parallelizable
        >>> XM = M.vector_field_module()
        >>> XM.sym_bilinear_form(name='a')
        Field of symmetric bilinear forms a on the 2-dimensional
         differentiable manifold M

    See also

    `TensorFieldParal` for more examples and documentation.

  symplectic_form(name=None, latex_name=None)

    Construct a symplectic form on the current vector field module.

    OUTPUT:

    - instance of `SymplecticFormParal`

    EXAMPLES:

    Standard symplectic form on \(\RR^2\):

    Sage

        sage: M.<q, p> = EuclideanSpace(2)
        sage: omega = M.vector_field_module().symplectic_form('omega', r'\omega')
        sage: omega.set_comp()[1,2] = -1
        sage: omega.display()
        omega = -dq∧dp

    Python

        >>> from sage.all import *
        >>> M = EuclideanSpace(Integer(2), names=('q', 'p',)); (q, p,) = M._first_ngens(2)
        >>> omega = M.vector_field_module().symplectic_form('omega', r'\omega')
        >>> omega.set_comp()[Integer(1),Integer(2)] = -Integer(1)
        >>> omega.display()
        omega = -dq∧dp

  tensor_from_comp(tensor_type, comp, name=None, latex_name=None)

    Construct a tensor on `self` from a set of components.

    The tensor is actually a tensor field along the differentiable manifold \(U\) over which the vector field module is defined. The tensor symmetries are deduced from those of the components.

    INPUT:

    - `tensor_type` – pair \((k,l)\) with \(k\) being the contravariant rank and \(l\) the covariant rank

    - `comp` – `Components`; the tensor components in a given basis

    - `name` – string (default: `None`); name given to the tensor

    - `latex_name` – string (default: `None`); LaTeX symbol to denote the tensor; if `None`, the LaTeX symbol is set to `name`

    OUTPUT:

    - a `TensorFieldParal` representing the tensor defined on the vector field module with the provided characteristics

    EXAMPLES:

    A 2-dimensional set of components transformed into a type-\((1,1)\) tensor field:

    Sage

        sage: M = Manifold(2, 'M')
        sage: X.<x,y> = M.chart()
        sage: XM = M.vector_field_module()
        sage: from sage.tensor.modules.comp import Components
        sage: comp = Components(M.scalar_field_algebra(), X.frame(), 2,
        ....:                   output_formatter=XM._output_formatter)
        sage: comp[:] = [[1+x, -y], [x*y, 2-y^2]]
        sage: t = XM.tensor_from_comp((1,1), comp, name='t'); t
        Tensor field t of type (1,1) on the 2-dimensional differentiable
         manifold M
        sage: t.display()
        t = (x + 1) ∂/∂x⊗dx - y ∂/∂x⊗dy + x*y ∂/∂y⊗dx + (-y^2 + 2) ∂/∂y⊗dy

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> X = M.chart(names=('x', 'y',)); (x, y,) = X._first_ngens(2)
        >>> XM = M.vector_field_module()
        >>> from sage.tensor.modules.comp import Components
        >>> comp = Components(M.scalar_field_algebra(), X.frame(), Integer(2),
        ...                   output_formatter=XM._output_formatter)
        >>> comp[:] = [[Integer(1)+x, -y], [x*y, Integer(2)-y**Integer(2)]]
        >>> t = XM.tensor_from_comp((Integer(1),Integer(1)), comp, name='t'); t
        Tensor field t of type (1,1) on the 2-dimensional differentiable
         manifold M
        >>> t.display()
        t = (x + 1) ∂/∂x⊗dx - y ∂/∂x⊗dy + x*y ∂/∂y⊗dx + (-y^2 + 2) ∂/∂y⊗dy

    The same set of components transformed into a type-\((0,2)\) tensor field:

    Sage

        sage: t = XM.tensor_from_comp((0,2), comp, name='t'); t
        Tensor field t of type (0,2) on the 2-dimensional differentiable
         manifold M
        sage: t.display()
        t = (x + 1) dx⊗dx - y dx⊗dy + x*y dy⊗dx + (-y^2 + 2) dy⊗dy

    [Python]

        >>> from sage.all import *
        >>> t = XM.tensor_from_comp((Integer(0),Integer(2)), comp, name='t'); t
        Tensor field t of type (0,2) on the 2-dimensional differentiable
         manifold M
        >>> t.display()
        t = (x + 1) dx⊗dx - y dx⊗dy + x*y dy⊗dx + (-y^2 + 2) dy⊗dy

  tensor_module(k, l, sym, antisym)

    Return the free module of all tensors of type \((k, l)\) defined on `self`.

    INPUT:

    - `k` – nonnegative integer; the contravariant rank, the tensor type being \((k, l)\)

    - `l` – nonnegative integer; the covariant rank, the tensor type being \((k, l)\)

    OUTPUT:

    - a `TensorFieldFreeModule` representing the free module of type-\((k,l)\) tensors on the vector field module

    EXAMPLES:

    A tensor field module on a 2-dimensional differentiable manifold:

    Sage

        sage: M = Manifold(2, 'M')
        sage: X.<x,y> = M.chart()  # makes M parallelizable
        sage: XM = M.vector_field_module()
        sage: XM.tensor_module(1,2)
        Free module T^(1,2)(M) of type-(1,2) tensors fields on the
         2-dimensional differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> X = M.chart(names=('x', 'y',)); (x, y,) = X._first_ngens(2)# makes M parallelizable
        >>> XM = M.vector_field_module()
        >>> XM.tensor_module(Integer(1),Integer(2))
        Free module T^(1,2)(M) of type-(1,2) tensors fields on the
         2-dimensional differentiable manifold M

    The special case of tensor fields of type (1,0):

    Sage

        sage: XM.tensor_module(1,0)
        Free module X(M) of vector fields on the 2-dimensional
         differentiable manifold M

    [Python]

        >>> from sage.all import *
        >>> XM.tensor_module(Integer(1),Integer(0))
        Free module X(M) of vector fields on the 2-dimensional
         differentiable manifold M

    The result is cached:

    Sage

        sage: XM.tensor_module(1,2) is XM.tensor_module(1,2)
        True
        sage: XM.tensor_module(1,0) is XM
        True

    Python

        >>> from sage.all import *
        >>> XM.tensor_module(Integer(1),Integer(2)) is XM.tensor_module(Integer(1),Integer(2))
        True
        >>> XM.tensor_module(Integer(1),Integer(0)) is XM
        True

    See also

    `TensorFieldFreeModule` for more examples and documentation.

class sage.manifolds.differentiable.vectorfield_module.VectorFieldModule(domain: DifferentiableManifold, dest_map: DiffMap | None = None)

  Bases: `UniqueRepresentation`, `ReflexiveModule_base`

  Module of vector fields along a differentiable manifold \(U\) with values on a differentiable manifold \(M\), via a differentiable map \(U \rightarrow M\).

  Given a differentiable map

  \[\Phi:\ U \longrightarrow M,\]

  the vector field module \(\mathfrak{X}(U,\Phi)\) is the set of all vector fields of the type

  \[v:\ U \longrightarrow TM\]

  (where \(TM\) is the tangent bundle of \(M\)) such that

  \[\forall p \in U,\ v(p) \in T_{\Phi(p)}M,\]

  where \(T_{\Phi(p)}M\) is the tangent space to \(M\) at the point \(\Phi(p)\).

  The set \(\mathfrak{X}(U,\Phi)\) is a module over \(C^k(U)\), the ring (algebra) of differentiable scalar fields on \(U\) (see `DiffScalarFieldAlgebra`). Furthermore, it is a Lie algebroid under the Lie bracket (cf. Wikipedia article Lie_algebroid)

  \[[X, Y] = X \circ Y - Y \circ X\]

  over the scalarfields if \(\Phi\) is the identity map. That is to say the Lie bracket is antisymmetric, bilinear over the base field, satisfies the Jacobi identity, and \([X, fY] = X(f) Y + f[X, Y]\).

  The standard case of vector fields on a differentiable manifold corresponds to \(U = M\) and \(\Phi = \mathrm{Id}_M\); we then denote \(\mathfrak{X}(M,\mathrm{Id}_M)\) by merely \(\mathfrak{X}(M)\). Other common cases are \(\Phi\) being an immersion and \(\Phi\) being a curve in \(M\) (\(U\) is then an open interval of \(\RR\)).

  Note

  If \(M\) is parallelizable, the class `VectorFieldFreeModule` should be used instead.

  INPUT:

  - `domain` – differentiable manifold \(U\) along which the vector fields are defined

  - `dest_map` – (default: `None`) destination map \(\Phi:\ U \rightarrow M\) (type: `DiffMap`); if `None`, it is assumed that \(U = M\) and \(\Phi\) is the identity map of \(M\) (case of vector fields on \(M\))

  EXAMPLES:

  Module of vector fields on the 2-sphere:

  Sage

      sage: M = Manifold(2, 'M') # the 2-dimensional sphere S^2
      sage: U = M.open_subset('U') # complement of the North pole
      sage: c_xy.<x,y> = U.chart() # stereographic coordinates from the North pole
      sage: V = M.open_subset('V') # complement of the South pole
      sage: c_uv.<u,v> = V.chart() # stereographic coordinates from the South pole
      sage: M.declare_union(U,V)   # S^2 is the union of U and V
      sage: xy_to_uv = c_xy.transition_map(c_uv, (x/(x^2+y^2), y/(x^2+y^2)),
      ....:                 intersection_name='W', restrictions1= x^2+y^2!=0,
      ....:                 restrictions2= u^2+v^2!=0)
      sage: uv_to_xy = xy_to_uv.inverse()
      sage: XM = M.vector_field_module() ; XM
      Module X(M) of vector fields on the 2-dimensional differentiable
       manifold M

  Python

      >>> from sage.all import *
      >>> M = Manifold(Integer(2), 'M') # the 2-dimensional sphere S^2
      >>> U = M.open_subset('U') # complement of the North pole
      >>> c_xy = U.chart(names=('x', 'y',)); (x, y,) = c_xy._first_ngens(2)# stereographic coordinates from the North pole
      >>> V = M.open_subset('V') # complement of the South pole
      >>> c_uv = V.chart(names=('u', 'v',)); (u, v,) = c_uv._first_ngens(2)# stereographic coordinates from the South pole
      >>> M.declare_union(U,V)   # S^2 is the union of U and V
      >>> xy_to_uv = c_xy.transition_map(c_uv, (x/(x**Integer(2)+y**Integer(2)), y/(x**Integer(2)+y**Integer(2))),
      ...                 intersection_name='W', restrictions1= x**Integer(2)+y**Integer(2)!=Integer(0),
      ...                 restrictions2= u**Integer(2)+v**Integer(2)!=Integer(0))
      >>> uv_to_xy = xy_to_uv.inverse()
      >>> XM = M.vector_field_module() ; XM
      Module X(M) of vector fields on the 2-dimensional differentiable
       manifold M

  \(\mathfrak{X}(M)\) is a module over the algebra \(C^k(M)\):

  Sage

      sage: XM.category()
      Category of modules over Algebra of differentiable scalar fields on the
       2-dimensional differentiable manifold M
      sage: XM.base_ring() is M.scalar_field_algebra()
      True

  [Python]

      >>> from sage.all import *
      >>> XM.category()
      Category of modules over Algebra of differentiable scalar fields on the
       2-dimensional differentiable manifold M
      >>> XM.base_ring() is M.scalar_field_algebra()
      True

  \(\mathfrak{X}(M)\) is not a free module:

  Sage

      sage: isinstance(XM, FiniteRankFreeModule)
      False

  Python

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

  because \(M = S^2\) is not parallelizable:

  Sage

      sage: M.is_manifestly_parallelizable()
      False

  [Python]

      >>> from sage.all import *
      >>> M.is_manifestly_parallelizable()
      False

  On the contrary, the module of vector fields on \(U\) is a free module, since \(U\) is parallelizable (being a coordinate domain):

  Sage

      sage: XU = U.vector_field_module()
      sage: isinstance(XU, FiniteRankFreeModule)
      True
      sage: U.is_manifestly_parallelizable()
      True

  Python

      >>> from sage.all import *
      >>> XU = U.vector_field_module()
      >>> isinstance(XU, FiniteRankFreeModule)
      True
      >>> U.is_manifestly_parallelizable()
      True

  The zero element of the module:

  Sage

      sage: z = XM.zero() ; z
      Vector field zero on the 2-dimensional differentiable manifold M
      sage: z.display(c_xy.frame())
      zero = 0
      sage: z.display(c_uv.frame())
      zero = 0

  [Python]

      >>> from sage.all import *
      >>> z = XM.zero() ; z
      Vector field zero on the 2-dimensional differentiable manifold M
      >>> z.display(c_xy.frame())
      zero = 0
      >>> z.display(c_uv.frame())
      zero = 0

  The module \(\mathfrak{X}(M)\) coerces to any module of vector fields defined on a subdomain of \(M\), for instance \(\mathfrak{X}(U)\):

  Sage

      sage: XU.has_coerce_map_from(XM)
      True
      sage: XU.coerce_map_from(XM)
      Coercion map:
        From: Module X(M) of vector fields on the 2-dimensional
         differentiable manifold M
        To:   Free module X(U) of vector fields on the Open subset U of the
         2-dimensional differentiable manifold M

  Python

      >>> from sage.all import *
      >>> XU.has_coerce_map_from(XM)
      True
      >>> XU.coerce_map_from(XM)
      Coercion map:
        From: Module X(M) of vector fields on the 2-dimensional
         differentiable manifold M
        To:   Free module X(U) of vector fields on the Open subset U of the
         2-dimensional differentiable manifold M

  The conversion map is actually the restriction of vector fields defined on \(M\) to \(U\).

  Element

    alias of `VectorField`

  alternating_contravariant_tensor(degree, name=None, latex_name=None)

    Construct an alternating contravariant tensor on the vector field module `self`.

    An alternating contravariant tensor on `self` is actually a multivector field along the differentiable manifold \(U\) over which `self` is defined.

    INPUT:

    - `degree` – degree of the alternating contravariant tensor (i.e. its tensor rank)

    - `name` – (default: `None`) string; name given to the alternating contravariant tensor

    - `latex_name` – (default: `None`) string; LaTeX symbol to denote the alternating contravariant tensor; if none is provided, the LaTeX symbol is set to `name`

    OUTPUT:

    - instance of `MultivectorField`

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: XM = M.vector_field_module()
        sage: XM.alternating_contravariant_tensor(2, name='a')
        2-vector field a on the 2-dimensional differentiable
         manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> XM = M.vector_field_module()
        >>> XM.alternating_contravariant_tensor(Integer(2), name='a')
        2-vector field a on the 2-dimensional differentiable
         manifold M

    An alternating contravariant tensor of degree 1 is simply a vector field:

    Sage

        sage: XM.alternating_contravariant_tensor(1, name='a')
        Vector field a on the 2-dimensional differentiable
         manifold M

    [Python]

        >>> from sage.all import *
        >>> XM.alternating_contravariant_tensor(Integer(1), name='a')
        Vector field a on the 2-dimensional differentiable
         manifold M

    See also

    `MultivectorField` for more examples and documentation.

  alternating_form(degree, name=None, latex_name=None)

    Construct an alternating form on the vector field module `self`.

    An alternating form on `self` is actually a differential form along the differentiable manifold \(U\) over which `self` is defined.

    INPUT:

    - `degree` – the degree of the alternating form (i.e. its tensor rank)

    - `name` – (string; optional) name given to the alternating form

    - `latex_name` – (string; optional) LaTeX symbol to denote the alternating form; if none is provided, the LaTeX symbol is set to `name`

    OUTPUT:

    - instance of `DiffForm`

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: XM = M.vector_field_module()
        sage: XM.alternating_form(2, name='a')
        2-form a on the 2-dimensional differentiable manifold M
        sage: XM.alternating_form(1, name='a')
        1-form a on the 2-dimensional differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> XM = M.vector_field_module()
        >>> XM.alternating_form(Integer(2), name='a')
        2-form a on the 2-dimensional differentiable manifold M
        >>> XM.alternating_form(Integer(1), name='a')
        1-form a on the 2-dimensional differentiable manifold M

    See also

    `DiffForm` for more examples and documentation.

  ambient_domain()

    Return the manifold in which the vector fields of this module take their values.

    If the module is \(\mathfrak{X}(U,\Phi)\), returns the codomain \(M\) of \(\Phi\).

    OUTPUT:

    - instance of `DifferentiableManifold` representing the manifold in which the vector fields of this module take their values

    EXAMPLES:

    Sage

        sage: M = Manifold(5, 'M')
        sage: XM = M.vector_field_module()
        sage: XM.ambient_domain()
        5-dimensional differentiable manifold M
        sage: U = Manifold(2, 'U')
        sage: Phi = U.diff_map(M, name='Phi')
        sage: XU = U.vector_field_module(dest_map=Phi)
        sage: XU.ambient_domain()
        5-dimensional differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(5), 'M')
        >>> XM = M.vector_field_module()
        >>> XM.ambient_domain()
        5-dimensional differentiable manifold M
        >>> U = Manifold(Integer(2), 'U')
        >>> Phi = U.diff_map(M, name='Phi')
        >>> XU = U.vector_field_module(dest_map=Phi)
        >>> XU.ambient_domain()
        5-dimensional differentiable manifold M

  automorphism(name=None, latex_name=None)

    Construct an automorphism of the vector field module.

    An automorphism of the vector field module is actually a field of tangent-space automorphisms along the differentiable manifold \(U\) over which the vector field module is defined.

    INPUT:

    - `name` – (string; optional) name given to the automorphism

    - `latex_name` – (string; optional) LaTeX symbol to denote the automorphism; if none is provided, the LaTeX symbol is set to `name`

    OUTPUT:

    - instance of `AutomorphismField`

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: XM = M.vector_field_module()
        sage: XM.automorphism()
        Field of tangent-space automorphisms on the 2-dimensional
         differentiable manifold M
        sage: XM.automorphism(name='a')
        Field of tangent-space automorphisms a on the 2-dimensional
         differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> XM = M.vector_field_module()
        >>> XM.automorphism()
        Field of tangent-space automorphisms on the 2-dimensional
         differentiable manifold M
        >>> XM.automorphism(name='a')
        Field of tangent-space automorphisms a on the 2-dimensional
         differentiable manifold M

    See also

    `AutomorphismField` for more examples and documentation.

  destination_map()

    Return the differential map associated to this module.

    The differential map associated to this module is the map

    \[\Phi:\ U \longrightarrow M\]

    such that this module is the set \(\mathfrak{X}(U,\Phi)\) of all vector fields of the type

    \[v:\ U \longrightarrow TM\]

    (where \(TM\) is the tangent bundle of \(M\)) such that

    \[\forall p \in U,\ v(p) \in T_{\Phi(p)}M,\]

    where \(T_{\Phi(p)}M\) is the tangent space to \(M\) at the point \(\Phi(p)\).

    OUTPUT:

    - instance of `DiffMap` representing the differential map \(\Phi\)

    EXAMPLES:

    Sage

        sage: M = Manifold(5, 'M')
        sage: XM = M.vector_field_module()
        sage: XM.destination_map()
        Identity map Id_M of the 5-dimensional differentiable manifold M
        sage: U = Manifold(2, 'U')
        sage: Phi = U.diff_map(M, name='Phi')
        sage: XU = U.vector_field_module(dest_map=Phi)
        sage: XU.destination_map()
        Differentiable map Phi from the 2-dimensional differentiable
         manifold U to the 5-dimensional differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(5), 'M')
        >>> XM = M.vector_field_module()
        >>> XM.destination_map()
        Identity map Id_M of the 5-dimensional differentiable manifold M
        >>> U = Manifold(Integer(2), 'U')
        >>> Phi = U.diff_map(M, name='Phi')
        >>> XU = U.vector_field_module(dest_map=Phi)
        >>> XU.destination_map()
        Differentiable map Phi from the 2-dimensional differentiable
         manifold U to the 5-dimensional differentiable manifold M

  domain()

    Return the domain of the vector fields in this module.

    If the module is \(\mathfrak{X}(U,\Phi)\), returns the domain \(U\) of \(\Phi\).

    OUTPUT:

    - instance of `DifferentiableManifold` representing the domain of the vector fields that belong to this module

    EXAMPLES:

    Sage

        sage: M = Manifold(5, 'M')
        sage: XM = M.vector_field_module()
        sage: XM.domain()
        5-dimensional differentiable manifold M
        sage: U = Manifold(2, 'U')
        sage: Phi = U.diff_map(M, name='Phi')
        sage: XU = U.vector_field_module(dest_map=Phi)
        sage: XU.domain()
        2-dimensional differentiable manifold U

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(5), 'M')
        >>> XM = M.vector_field_module()
        >>> XM.domain()
        5-dimensional differentiable manifold M
        >>> U = Manifold(Integer(2), 'U')
        >>> Phi = U.diff_map(M, name='Phi')
        >>> XU = U.vector_field_module(dest_map=Phi)
        >>> XU.domain()
        2-dimensional differentiable manifold U

  dual()

    Return the dual module.

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: XM = M.vector_field_module()
        sage: XM.dual()
        Module Omega^1(M) of 1-forms on the 2-dimensional differentiable
         manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> XM = M.vector_field_module()
        >>> XM.dual()
        Module Omega^1(M) of 1-forms on the 2-dimensional differentiable
         manifold M

  dual_exterior_power(p)

    Return the \(p\)-th exterior power of the dual of the vector field module.

    If the vector field module is \(\mathfrak{X}(U,\Phi)\), the \(p\)-th exterior power of its dual is the set \(\Omega^p(U, \Phi)\) of \(p\)-forms along \(U\) with values on \(\Phi(U)\). It is a module over \(C^k(U)\), the ring (algebra) of differentiable scalar fields on \(U\).

    INPUT:

    - `p` – nonnegative integer

    OUTPUT:

    - for \(p=0\), the base ring, i.e. \(C^k(U)\)

    - for \(p \geq 1\), instance of `DiffFormModule` representing the module \(\Omega^p(U,\Phi)\)

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: XM = M.vector_field_module()
        sage: XM.dual_exterior_power(2)
        Module Omega^2(M) of 2-forms on the 2-dimensional differentiable
         manifold M
        sage: XM.dual_exterior_power(1)
        Module Omega^1(M) of 1-forms on the 2-dimensional differentiable
         manifold M
        sage: XM.dual_exterior_power(1) is XM.dual()
        True
        sage: XM.dual_exterior_power(0)
        Algebra of differentiable scalar fields on the 2-dimensional
         differentiable manifold M
        sage: XM.dual_exterior_power(0) is M.scalar_field_algebra()
        True

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> XM = M.vector_field_module()
        >>> XM.dual_exterior_power(Integer(2))
        Module Omega^2(M) of 2-forms on the 2-dimensional differentiable
         manifold M
        >>> XM.dual_exterior_power(Integer(1))
        Module Omega^1(M) of 1-forms on the 2-dimensional differentiable
         manifold M
        >>> XM.dual_exterior_power(Integer(1)) is XM.dual()
        True
        >>> XM.dual_exterior_power(Integer(0))
        Algebra of differentiable scalar fields on the 2-dimensional
         differentiable manifold M
        >>> XM.dual_exterior_power(Integer(0)) is M.scalar_field_algebra()
        True

    See also

    `DiffFormModule` for more examples and documentation.

  exterior_power(p)

    Return the \(p\)-th exterior power of `self`.

    If the vector field module `self` is \(\mathfrak{X}(U,\Phi)\), its \(p\)-th exterior power is the set \(A^p(U, \Phi)\) of \(p\)-vector fields along \(U\) with values on \(\Phi(U)\). It is a module over \(C^k(U)\), the ring (algebra) of differentiable scalar fields on \(U\).

    INPUT:

    - `p` – nonnegative integer

    OUTPUT:

    - for \(p=0\), the base ring, i.e. \(C^k(U)\)

    - for \(p=1\), the vector field module `self`, since \(A^1(U, \Phi) = \mathfrak{X}(U,\Phi)\)

    - for \(p \geq 2\), instance of `MultivectorModule` representing the module \(A^p(U,\Phi)\)

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: XM = M.vector_field_module()
        sage: XM.exterior_power(2)
        Module A^2(M) of 2-vector fields on the 2-dimensional
         differentiable manifold M
        sage: XM.exterior_power(1)
        Module X(M) of vector fields on the 2-dimensional
         differentiable manifold M
        sage: XM.exterior_power(1) is XM
        True
        sage: XM.exterior_power(0)
        Algebra of differentiable scalar fields on the 2-dimensional
         differentiable manifold M
        sage: XM.exterior_power(0) is M.scalar_field_algebra()
        True

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> XM = M.vector_field_module()
        >>> XM.exterior_power(Integer(2))
        Module A^2(M) of 2-vector fields on the 2-dimensional
         differentiable manifold M
        >>> XM.exterior_power(Integer(1))
        Module X(M) of vector fields on the 2-dimensional
         differentiable manifold M
        >>> XM.exterior_power(Integer(1)) is XM
        True
        >>> XM.exterior_power(Integer(0))
        Algebra of differentiable scalar fields on the 2-dimensional
         differentiable manifold M
        >>> XM.exterior_power(Integer(0)) is M.scalar_field_algebra()
        True

    See also

    `MultivectorModule` for more examples and documentation.

  general_linear_group()

    Return the general linear group of `self`.

    If the vector field module is \(\mathfrak{X}(U,\Phi)\), the general linear group is the group \(\mathrm{GL}(\mathfrak{X}(U,\Phi))\) of automorphisms of \(\mathfrak{X}(U, \Phi)\). Note that an automorphism of \(\mathfrak{X}(U,\Phi)\) can also be viewed as a field along \(U\) of automorphisms of the tangent spaces of \(M \supset \Phi(U)\).

    OUTPUT:

    - instance of class `AutomorphismFieldGroup` representing \(\mathrm{GL}(\mathfrak{X}(U,\Phi))\)

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: XM = M.vector_field_module()
        sage: XM.general_linear_group()
        General linear group of the Module X(M) of vector fields on the
         2-dimensional differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> XM = M.vector_field_module()
        >>> XM.general_linear_group()
        General linear group of the Module X(M) of vector fields on the
         2-dimensional differentiable manifold M

    See also

    `AutomorphismFieldGroup` for more examples and documentation.

  identity_map()

    Construct the identity map on the vector field module.

    The identity map on the vector field module is actually a field of tangent-space identity maps along the differentiable manifold \(U\) over which the vector field module is defined.

    OUTPUT:

    - instance of `AutomorphismField`

    EXAMPLES:

    Get the identity map on a vector field module:

    Sage

        sage: M = Manifold(2, 'M')
        sage: XM = M.vector_field_module()
        sage: Id = XM.identity_map(); Id
        Field of tangent-space identity maps on the 2-dimensional
         differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> XM = M.vector_field_module()
        >>> Id = XM.identity_map(); Id
        Field of tangent-space identity maps on the 2-dimensional
         differentiable manifold M

    If the identity should be renamed, one has to create a copy:

    Sage

        sage: Id.set_name('1')
        Traceback (most recent call last):
        ...
        ValueError: the name of an immutable element cannot be changed
        sage: one = Id.copy('1'); one
        Field of tangent-space automorphisms 1 on the 2-dimensional
         differentiable manifold M

    [Python]

        >>> from sage.all import *
        >>> Id.set_name('1')
        Traceback (most recent call last):
        ...
        ValueError: the name of an immutable element cannot be changed
        >>> one = Id.copy('1'); one
        Field of tangent-space automorphisms 1 on the 2-dimensional
         differentiable manifold M

  linear_form(name=None, latex_name=None)

    Construct a linear form on the vector field module.

    A linear form on the vector field module is actually a field of linear forms (i.e. a 1-form) along the differentiable manifold \(U\) over which the vector field module is defined.

    INPUT:

    - `name` – (string; optional) name given to the linear form

    - `latex_name` – (string; optional) LaTeX symbol to denote the linear form; if none is provided, the LaTeX symbol is set to `name`

    OUTPUT:

    - instance of `DiffForm`

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: XM = M.vector_field_module()
        sage: XM.linear_form()
        1-form on the 2-dimensional differentiable manifold M
        sage: XM.linear_form(name='a')
        1-form a on the 2-dimensional differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> XM = M.vector_field_module()
        >>> XM.linear_form()
        1-form on the 2-dimensional differentiable manifold M
        >>> XM.linear_form(name='a')
        1-form a on the 2-dimensional differentiable manifold M

    See also

    `DiffForm` for more examples and documentation.

  metric(name, signature=None, latex_name=None)

    Construct a metric (symmetric bilinear form) on the current vector field module.

    A metric of the vector field module is actually a field of tangent-space non-degenerate symmetric bilinear forms along the manifold \(U\) on which the vector field module is defined.

    INPUT:

    - `name` – string; name given to the metric

    - `signature` – integer (default: `None`); signature \(S\) of the metric: \(S = n_+ - n_-\), where \(n_+\) (resp. \(n_-\)) is the number of positive terms (resp. number of negative terms) in any diagonal writing of the metric components; if `signature` is not provided, \(S\) is set to the manifold’s dimension (Riemannian signature)

    - `latex_name` – (string; default: `None`) LaTeX symbol to denote the metric; if `None`, it is formed from `name`

    OUTPUT:

    - instance of `PseudoRiemannianMetric` representing the defined pseudo-Riemannian metric.

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: XM = M.vector_field_module()
        sage: XM.metric('g')
        Riemannian metric g on the 2-dimensional differentiable manifold M
        sage: XM.metric('g', signature=0)
        Lorentzian metric g on the 2-dimensional differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> XM = M.vector_field_module()
        >>> XM.metric('g')
        Riemannian metric g on the 2-dimensional differentiable manifold M
        >>> XM.metric('g', signature=Integer(0))
        Lorentzian metric g on the 2-dimensional differentiable manifold M

    See also

    `PseudoRiemannianMetric` for more documentation.

  poisson_tensor(name=None, latex_name=None)

    Construct a Poisson tensor on the current vector field module.

    OUTPUT:

    - instance of `PoissonTensorField`

    EXAMPLES:

    Poisson tensor on the 2-sphere:

    Sage

        sage: M = manifolds.Sphere(2, coordinates='stereographic')
        sage: XM = M.vector_field_module()
        sage: varpi = XM.poisson_tensor(name='varpi', latex_name=r'\varpi')
        sage: varpi
        2-vector field varpi on the 2-sphere S^2 of radius 1 smoothly embedded in the Euclidean space E^3

    Python

        >>> from sage.all import *
        >>> M = manifolds.Sphere(Integer(2), coordinates='stereographic')
        >>> XM = M.vector_field_module()
        >>> varpi = XM.poisson_tensor(name='varpi', latex_name=r'\varpi')
        >>> varpi
        2-vector field varpi on the 2-sphere S^2 of radius 1 smoothly embedded in the Euclidean space E^3

  symplectic_form(name=None, latex_name=None)

    Construct a symplectic form on the current vector field module.

    OUTPUT:

    - instance of `SymplecticForm`

    EXAMPLES:

    Symplectic form on the 2-sphere:

    Sage

        sage: M = manifolds.Sphere(2, coordinates='stereographic')
        sage: XM = M.vector_field_module()
        sage: omega = XM.symplectic_form(name='omega', latex_name=r'\omega')
        sage: omega
        Symplectic form omega on the 2-sphere S^2 of radius 1 smoothly
         embedded in the Euclidean space E^3

    Python

        >>> from sage.all import *
        >>> M = manifolds.Sphere(Integer(2), coordinates='stereographic')
        >>> XM = M.vector_field_module()
        >>> omega = XM.symplectic_form(name='omega', latex_name=r'\omega')
        >>> omega
        Symplectic form omega on the 2-sphere S^2 of radius 1 smoothly
         embedded in the Euclidean space E^3

  tensor(*args, **kwds)

    Construct a tensor field on the domain of `self` or a tensor product of `self` with other modules.

    If `args` consist of other parents, just delegate to `tensor_product()`.

    Otherwise, construct a tensor (i.e., a tensor field on the domain of the vector field module) from the following input.

    INPUT:

    - `tensor_type` – pair (k,l) with k being the contravariant rank and l the covariant rank

    - `name` – (string; default: `None`) name given to the tensor

    - `latex_name` – (string; default: `None`) LaTeX symbol to denote the tensor; if none is provided, the LaTeX symbol is set to `name`

    - `sym` – (default: `None`) a symmetry or a list of symmetries among the tensor arguments: each symmetry is described by a tuple containing the positions of the involved arguments, with the convention position=0 for the first argument; for instance:

      - `sym=(0,1)` for a symmetry between the 1st and 2nd arguments

      - `sym=[(0,2),(1,3,4)]` for a symmetry between the 1st and 3rd arguments and a symmetry between the 2nd, 4th and 5th arguments

    - `antisym` – (default: `None`) antisymmetry or list of antisymmetries among the arguments, with the same convention as for `sym`

    - `specific_type` – (default: `None`) specific subclass of `TensorField` for the output

    OUTPUT:

    - instance of `TensorField` representing the tensor defined on the vector field module with the provided characteristics

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: XM = M.vector_field_module()
        sage: XM.tensor((1,2), name='t')
        Tensor field t of type (1,2) on the 2-dimensional differentiable
         manifold M
        sage: XM.tensor((1,0), name='a')
        Vector field a on the 2-dimensional differentiable manifold M
        sage: XM.tensor((0,2), name='a', antisym=(0,1))
        2-form a on the 2-dimensional differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> XM = M.vector_field_module()
        >>> XM.tensor((Integer(1),Integer(2)), name='t')
        Tensor field t of type (1,2) on the 2-dimensional differentiable
         manifold M
        >>> XM.tensor((Integer(1),Integer(0)), name='a')
        Vector field a on the 2-dimensional differentiable manifold M
        >>> XM.tensor((Integer(0),Integer(2)), name='a', antisym=(Integer(0),Integer(1)))
        2-form a on the 2-dimensional differentiable manifold M

    Delegation to `tensor_product()`:

    Sage

        sage: M = Manifold(2, 'M')
        sage: XM = M.vector_field_module()
        sage: XM.tensor(XM)
        Module T^(2,0)(M) of type-(2,0) tensors fields on the 2-dimensional differentiable manifold M
        sage: XM.tensor(XM, XM.dual(), XM)
        Module T^(3,1)(M) of type-(3,1) tensors fields on the 2-dimensional differentiable manifold M
        sage: XM.tensor(XM).tensor(XM.dual().tensor(XM.dual()))
        Traceback (most recent call last):
        ...
        AttributeError: 'TensorFieldModule_with_category' object has no attribute '_basis_sym'...

    [Python]

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> XM = M.vector_field_module()
        >>> XM.tensor(XM)
        Module T^(2,0)(M) of type-(2,0) tensors fields on the 2-dimensional differentiable manifold M
        >>> XM.tensor(XM, XM.dual(), XM)
        Module T^(3,1)(M) of type-(3,1) tensors fields on the 2-dimensional differentiable manifold M
        >>> XM.tensor(XM).tensor(XM.dual().tensor(XM.dual()))
        Traceback (most recent call last):
        ...
        AttributeError: 'TensorFieldModule_with_category' object has no attribute '_basis_sym'...

    See also

    `TensorField` for more examples and documentation.

  tensor_module(k, l, sym, antisym)

    Return the module of type-\((k,l)\) tensors on `self`.

    INPUT:

    - `k` – nonnegative integer; the contravariant rank, the tensor type being \((k,l)\)

    - `l` – nonnegative integer; the covariant rank, the tensor type being \((k,l)\)

    OUTPUT:

    - instance of `TensorFieldModule` representing the module \(T^{(k,l)}(U,\Phi)\) of type-\((k,l)\) tensors on the vector field module

    EXAMPLES:

    A tensor field module on a 2-dimensional differentiable manifold:

    Sage

        sage: M = Manifold(2, 'M')
        sage: XM = M.vector_field_module()
        sage: XM.tensor_module(1,2)
        Module T^(1,2)(M) of type-(1,2) tensors fields on the 2-dimensional
         differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> XM = M.vector_field_module()
        >>> XM.tensor_module(Integer(1),Integer(2))
        Module T^(1,2)(M) of type-(1,2) tensors fields on the 2-dimensional
         differentiable manifold M

    The special case of tensor fields of type (1,0):

    Sage

        sage: XM.tensor_module(1,0)
        Module X(M) of vector fields on the 2-dimensional differentiable
         manifold M

    [Python]

        >>> from sage.all import *
        >>> XM.tensor_module(Integer(1),Integer(0))
        Module X(M) of vector fields on the 2-dimensional differentiable
         manifold M

    The result is cached:

    Sage

        sage: XM.tensor_module(1,2) is XM.tensor_module(1,2)
        True
        sage: XM.tensor_module(1,0) is XM
        True

    Python

        >>> from sage.all import *
        >>> XM.tensor_module(Integer(1),Integer(2)) is XM.tensor_module(Integer(1),Integer(2))
        True
        >>> XM.tensor_module(Integer(1),Integer(0)) is XM
        True

    See `TensorFieldModule` for more examples and documentation.

  zero()

    Return the zero of `self`.

    EXAMPLES:

    Sage

        sage: M = Manifold(2, 'M')
        sage: X.<x,y> = M.chart()  # makes M parallelizable
        sage: XM = M.vector_field_module()
        sage: XM.zero()
        Vector field zero on the 2-dimensional differentiable
         manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(2), 'M')
        >>> X = M.chart(names=('x', 'y',)); (x, y,) = X._first_ngens(2)# makes M parallelizable
        >>> XM = M.vector_field_module()
        >>> XM.zero()
        Vector field zero on the 2-dimensional differentiable
         manifold M