Symplectic structures - Manifolds

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

# Symplectic structures

The class `SymplecticForm` implements symplectic structures on differentiable manifolds over \(\RR\). The derived class `SymplecticFormParal` is devoted to symplectic forms on a parallelizable manifold.

AUTHORS:

- Tobias Diez (2021) : initial version

REFERENCES:

- [AM1990]

- [RS2012]

class sage.manifolds.differentiable.symplectic_form.SymplecticForm(manifold: DifferentiableManifold | VectorFieldModule, name: str | None = None, latex_name: str | None = None)

  Bases: `DiffForm`

  A symplectic form on a differentiable manifold.

  An instance of this class is a closed nondegenerate differential \(2\)-form \(\omega\) on a differentiable manifold \(M\) over \(\RR\).

  In particular, at each point \(m \in M\), \(\omega_m\) is a bilinear map of the type:

  \[\omega_m:\ T_m M \times T_m M \to \RR,\]

  where \(T_m M\) stands for the tangent space to the manifold \(M\) at the point \(m\), such that \(\omega_m\) is skew-symmetric: \(\forall u,v \in T_m M, \ \omega_m(v,u) = - \omega_m(u,v)\) and nondegenerate: \((\forall v \in T_m M,\ \ \omega_m(u,v) = 0) \Longrightarrow u=0\).

  Note

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

  INPUT:

  - `manifold` – module \(\mathfrak{X}(M)\) of vector fields on the manifold \(M\), or the manifold \(M\) itself

  - `name` – (default: `omega`) name given to the symplectic form

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

  EXAMPLES:

  A symplectic form on the 2-sphere:

  Sage

      sage: M.<x,y> = manifolds.Sphere(2, coordinates='stereographic')
      sage: stereoN = M.stereographic_coordinates(pole='north')
      sage: stereoS = M.stereographic_coordinates(pole='south')
      sage: omega = M.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', names=('x', 'y',)); (x, y,) = M._first_ngens(2)
      >>> stereoN = M.stereographic_coordinates(pole='north')
      >>> stereoS = M.stereographic_coordinates(pole='south')
      >>> omega = M.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

  `omega` is initialized by providing its single nonvanishing component w.r.t. the vector frame associated to `stereoN`, which is the default frame on `M`:

  Sage

      sage: omega[1, 2] = 1/(1 + x^2 + y^2)^2

  [Python]

      >>> from sage.all import *
      >>> omega[Integer(1), Integer(2)] = Integer(1)/(Integer(1) + x**Integer(2) + y**Integer(2))**Integer(2)

  The components w.r.t. the vector frame associated to `stereoS` are obtained thanks to the method `add_comp_by_continuation()`:

  Sage

      sage: omega.add_comp_by_continuation(stereoS.frame(),
      ....:                  stereoS.domain().intersection(stereoN.domain()))
      sage: omega.display()
      omega = (x^2 + y^2 + 1)^(-2) dx∧dy
      sage: omega.display(stereoS)
      omega = -1/(xp^4 + yp^4 + 2*(xp^2 + 1)*yp^2 + 2*xp^2 + 1) dxp∧dyp

  Python

      >>> from sage.all import *
      >>> omega.add_comp_by_continuation(stereoS.frame(),
      ...                  stereoS.domain().intersection(stereoN.domain()))
      >>> omega.display()
      omega = (x^2 + y^2 + 1)^(-2) dx∧dy
      >>> omega.display(stereoS)
      omega = -1/(xp^4 + yp^4 + 2*(xp^2 + 1)*yp^2 + 2*xp^2 + 1) dxp∧dyp

  `omega` is an exact 2-form (this is trivial here, since `M` is 2-dimensional):

  Sage

      sage: diff(omega).display()
      domega = 0

  [Python]

      >>> from sage.all import *
      >>> diff(omega).display()
      domega = 0

  flat(vector_field)

    Return the image of the given differential form under the map \(\omega^\flat: T M \to T^*M\) defined by

    \[<\omega^\flat(X), Y> = \omega_m (X, Y)\]

    for all \(X, Y \in T_m M\).

    In indices, \(X_i = \omega_{ji} X^j\).

    INPUT:

    - `vector_field` – the vector field to calculate its flat of

    EXAMPLES:

    Sage

        sage: M = manifolds.StandardSymplecticSpace(2)
        sage: omega = M.symplectic_form()
        sage: X = M.vector_field_module().an_element()
        sage: X.set_name('X')
        sage: X.display()
        X = 2 e_q + 2 e_p
        sage: omega.flat(X).display()
        X_flat = 2 dq - 2 dp

    Python

        >>> from sage.all import *
        >>> M = manifolds.StandardSymplecticSpace(Integer(2))
        >>> omega = M.symplectic_form()
        >>> X = M.vector_field_module().an_element()
        >>> X.set_name('X')
        >>> X.display()
        X = 2 e_q + 2 e_p
        >>> omega.flat(X).display()
        X_flat = 2 dq - 2 dp

  hamiltonian_vector_field(function)

    The Hamiltonian vector field \(X_f\) generated by a function \(f: M \to \RR\).

    The Hamiltonian vector field is defined by

    \[X_f \lrcorner \omega + df = 0.\]

    INPUT:

    - `function` – the function generating the Hamiltonian vector field

    EXAMPLES:

    Sage

        sage: M = manifolds.StandardSymplecticSpace(2)
        sage: omega = M.symplectic_form()
        sage: f = M.scalar_field({ chart: function('f')(*chart[:]) for chart in M.atlas() }, name='f')
        sage: f.display()
        f: R2 → ℝ
           (q, p) ↦ f(q, p)
        sage: Xf = omega.hamiltonian_vector_field(f)
        sage: Xf.display()
        Xf = d(f)/dp e_q - d(f)/dq e_p

    Python

        >>> from sage.all import *
        >>> M = manifolds.StandardSymplecticSpace(Integer(2))
        >>> omega = M.symplectic_form()
        >>> f = M.scalar_field({ chart: function('f')(*chart[:]) for chart in M.atlas() }, name='f')
        >>> f.display()
        f: R2 → ℝ
           (q, p) ↦ f(q, p)
        >>> Xf = omega.hamiltonian_vector_field(f)
        >>> Xf.display()
        Xf = d(f)/dp e_q - d(f)/dq e_p

  hodge_star(pform)

    Compute the Hodge dual of a differential form with respect to the symplectic form.

    See `hodge_dual()` for the definition and more details.

    INPUT:

    - `pform` – a \(p\)-form \(A\); must be an instance of `DiffScalarField` for \(p=0\) and of `DiffForm` or `DiffFormParal` for \(p\geq 1\).

    OUTPUT:

    - the \((n-p)\)-form \(*A\)

    EXAMPLES:

    Hodge dual of any form on the symplectic vector space \(R^2\):

    Sage

        sage: M = manifolds.StandardSymplecticSpace(2)
        sage: omega = M.symplectic_form()
        sage: a = M.one_form(1, 0, name='a')
        sage: omega.hodge_star(a).display()
        *a = dq
        sage: b = M.one_form(0, 1, name='b')
        sage: omega.hodge_star(b).display()
        *b = dp
        sage: f = M.scalar_field(1, name='f')
        sage: omega.hodge_star(f).display()
        *f = -dq∧dp
        sage: omega.hodge_star(omega).display()
        *omega: R2 → ℝ
           (q, p) ↦ 1

    Python

        >>> from sage.all import *
        >>> M = manifolds.StandardSymplecticSpace(Integer(2))
        >>> omega = M.symplectic_form()
        >>> a = M.one_form(Integer(1), Integer(0), name='a')
        >>> omega.hodge_star(a).display()
        *a = dq
        >>> b = M.one_form(Integer(0), Integer(1), name='b')
        >>> omega.hodge_star(b).display()
        *b = dp
        >>> f = M.scalar_field(Integer(1), name='f')
        >>> omega.hodge_star(f).display()
        *f = -dq∧dp
        >>> omega.hodge_star(omega).display()
        *omega: R2 → ℝ
           (q, p) ↦ 1

  on_forms(first, second)

    Return the contraction of the two forms with respect to the symplectic form.

    The symplectic form \(\omega\) gives rise to a bilinear form, also denoted by \(\omega\) on the space of \(1\)-forms by

    \[\omega(\alpha, \beta) = \omega(\alpha^\sharp, \beta^\sharp),\]

    where \(\alpha^\sharp\) is the dual of \(\alpha\) with respect to \(\omega\), see `up()`. This bilinear form induces a bilinear form on the space of all forms determined by its value on decomposable elements as:

    \[\omega(\alpha_1 \wedge \ldots \wedge\alpha_p, \beta_1 \wedge \ldots \wedge\beta_p) = det(\omega(\alpha_i, \beta_j)).\]

    INPUT:

    - `first` – a \(p\)-form \(\alpha\)

    - `second` – a \(p\)-form \(\beta\)

    OUTPUT:

    - the scalar field \(\omega(\alpha, \beta)\)

    EXAMPLES:

    > sage: M = manifolds.StandardSymplecticSpace(2) sage: omega = M.symplectic_form() sage: a = M.one_form(1, 0, name=’a’) sage: b = M.one_form(0, 1, name=’b’) sage: omega.on_forms(a, b).display() R2 → ℝ (q, p) ↦ -1

  poisson(expansion_symbol=None, order=1)

    Return the Poisson tensor associated with the symplectic form.

    INPUT:

    - `expansion_symbol` – (default: `None`) symbolic variable; if specified, the inverse will be expanded in power series with respect to this variable (around its zero value)

    - `order` – integer (default: 1); the order of the expansion if `expansion_symbol` is not `None`; the order is defined as the degree of the polynomial representing the truncated power series in `expansion_symbol`; currently only first order inverse is supported

    If `expansion_symbol` is set, then the zeroth order symplectic form must be invertible. Moreover, subsequent calls to this method will return a cached value, even when called with the default value (to enable computation of derived quantities). To reset, use `_del_derived()`.

    OUTPUT:

    - the Poisson tensor, as an instance of `PoissonTensorField()`

    EXAMPLES:

    Poisson tensor of \(2\)-dimensional symplectic vector space:

    Sage

        sage: M = manifolds.StandardSymplecticSpace(2)
        sage: omega = M.symplectic_form()
        sage: poisson = omega.poisson(); poisson
        2-vector field poisson_omega on the Standard symplectic space R2
        sage: poisson.display()
        poisson_omega = -e_q∧e_p

    Python

        >>> from sage.all import *
        >>> M = manifolds.StandardSymplecticSpace(Integer(2))
        >>> omega = M.symplectic_form()
        >>> poisson = omega.poisson(); poisson
        2-vector field poisson_omega on the Standard symplectic space R2
        >>> poisson.display()
        poisson_omega = -e_q∧e_p

  poisson_bracket(f, g)

    Return the Poisson bracket

    \[\{f, g\} = \omega(X_f, X_g)\]

    of the given functions.

    INPUT:

    - `f` – function inserted in the first slot

    - `g` – function inserted in the second slot

    EXAMPLES:

    Sage

        sage: M.<q, p> = EuclideanSpace(2)
        sage: poisson = M.poisson_tensor('varpi')
        sage: poisson.set_comp()[1,2] = -1
        sage: f = M.scalar_field({ chart: function('f')(*chart[:]) for chart in M.atlas() }, name='f')
        sage: g = M.scalar_field({ chart: function('g')(*chart[:]) for chart in M.atlas() }, name='g')
        sage: poisson.poisson_bracket(f, g).display()
        poisson(f, g): E^2 → ℝ
           (q, p) ↦ d(f)/dp*d(g)/dq - d(f)/dq*d(g)/dp

    Python

        >>> from sage.all import *
        >>> M = EuclideanSpace(Integer(2), names=('q', 'p',)); (q, p,) = M._first_ngens(2)
        >>> poisson = M.poisson_tensor('varpi')
        >>> poisson.set_comp()[Integer(1),Integer(2)] = -Integer(1)
        >>> f = M.scalar_field({ chart: function('f')(*chart[:]) for chart in M.atlas() }, name='f')
        >>> g = M.scalar_field({ chart: function('g')(*chart[:]) for chart in M.atlas() }, name='g')
        >>> poisson.poisson_bracket(f, g).display()
        poisson(f, g): E^2 → ℝ
           (q, p) ↦ d(f)/dp*d(g)/dq - d(f)/dq*d(g)/dp

  restrict(subdomain, dest_map=None)

    Return the restriction of the symplectic form to some subdomain.

    If the restriction has not been defined yet, it is constructed here.

    INPUT:

    - `subdomain` – open subset \(U\) of the symplectic form’s domain

    - `dest_map` – (default: `None`) smooth destination map \(\Phi:\ U \to V\), where \(V\) is a subdomain of the symplectic form’s domain If `None`, the restriction of the initial vector field module is used.

    OUTPUT: the restricted symplectic form

    EXAMPLES:

    Sage

        sage: M = Manifold(6, 'M')
        sage: omega = M.symplectic_form()
        sage: U = M.open_subset('U')
        sage: omega.restrict(U)
        2-form omega on the Open subset U of the 6-dimensional differentiable manifold M

    Python

        >>> from sage.all import *
        >>> M = Manifold(Integer(6), 'M')
        >>> omega = M.symplectic_form()
        >>> U = M.open_subset('U')
        >>> omega.restrict(U)
        2-form omega on the Open subset U of the 6-dimensional differentiable manifold M

  sharp(form)

    Return the image of the given differential form under the map \(\omega^\sharp: T^* M \to TM\) defined by

    \[\omega (\omega^\sharp(\alpha), X) = \alpha(X)\]

    for all \(X \in T_m M\) and \(\alpha \in T^*_m M\). The sharp map is inverse to the flat map.

    In indices, \(\alpha^i = \varpi^{ij} \alpha_j\), where \(\varpi\) is the Poisson tensor associated with the symplectic form.

    INPUT:

    - `form` – the differential form to calculate its sharp of

    EXAMPLES:

    Sage

        sage: M = manifolds.StandardSymplecticSpace(2)
        sage: omega = M.symplectic_form()
        sage: X = M.vector_field_module().an_element()
        sage: alpha = omega.flat(X)
        sage: alpha.set_name('alpha')
        sage: alpha.display()
        alpha = 2 dq - 2 dp
        sage: omega.sharp(alpha).display()
        alpha_sharp = 2 e_q + 2 e_p

    Python

        >>> from sage.all import *
        >>> M = manifolds.StandardSymplecticSpace(Integer(2))
        >>> omega = M.symplectic_form()
        >>> X = M.vector_field_module().an_element()
        >>> alpha = omega.flat(X)
        >>> alpha.set_name('alpha')
        >>> alpha.display()
        alpha = 2 dq - 2 dp
        >>> omega.sharp(alpha).display()
        alpha_sharp = 2 e_q + 2 e_p

  volume_form(contra=0)

    Liouville volume form \(\frac{1}{n!}\omega^n\) associated with the symplectic form \(\omega\), where \(2n\) is the dimension of the manifold.

    INPUT:

    - `contra` – (default: 0) number of contravariant indices of the returned tensor

    OUTPUT:

    - if `contra = 0`: volume form associated with the symplectic form

    - if `contra = k`, with \(1\leq k \leq n\), the tensor field of type (k,n-k) formed from \(\epsilon\) by raising the first k indices with the symplectic form (see method `up()`)

    EXAMPLES:

    Volume form on \(\RR^4\):

    Sage

        sage: M = manifolds.StandardSymplecticSpace(4)
        sage: omega = M.symplectic_form()
        sage: vol = omega.volume_form() ; vol
        4-form mu_omega on the Standard symplectic space R4
        sage: vol.display()
        mu_omega = dq1∧dp1∧dq2∧dp2

    Python

        >>> from sage.all import *
        >>> M = manifolds.StandardSymplecticSpace(Integer(4))
        >>> omega = M.symplectic_form()
        >>> vol = omega.volume_form() ; vol
        4-form mu_omega on the Standard symplectic space R4
        >>> vol.display()
        mu_omega = dq1∧dp1∧dq2∧dp2

  static wrap(form, name=None, latex_name=None)

    Define the symplectic form from a differential form.

    INPUT:

    - `form` – differential \(2\)-form

    EXAMPLES:

    Volume form on the sphere as a symplectic form:

    Sage

        sage: from sage.manifolds.differentiable.symplectic_form import SymplecticForm
        sage: M = manifolds.Sphere(2, coordinates='stereographic')
        sage: vol_form = M.induced_metric().volume_form()                   # long time
        sage: omega = SymplecticForm.wrap(vol_form, 'omega', r'\omega')     # long time
        sage: omega.display()                                               # long time
        omega = -4/(y1^4 + y2^4 + 2*(y1^2 + 1)*y2^2 + 2*y1^2 + 1) dy1∧dy2

    Python

        >>> from sage.all import *
        >>> from sage.manifolds.differentiable.symplectic_form import SymplecticForm
        >>> M = manifolds.Sphere(Integer(2), coordinates='stereographic')
        >>> vol_form = M.induced_metric().volume_form()                   # long time
        >>> omega = SymplecticForm.wrap(vol_form, 'omega', r'\omega')     # long time
        >>> omega.display()                                               # long time
        omega = -4/(y1^4 + y2^4 + 2*(y1^2 + 1)*y2^2 + 2*y1^2 + 1) dy1∧dy2

class sage.manifolds.differentiable.symplectic_form.SymplecticFormParal(manifold: VectorFieldModule | DifferentiableManifold, name: str | None, latex_name: str | None = None)

  Bases: `SymplecticForm`, `DiffFormParal`

  A symplectic form on a parallelizable manifold.

  Note

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

  INPUT:

  - `manifold` – module \(\mathfrak{X}(M)\) of vector fields on the manifold \(M\), or the manifold \(M\) itself

  - `name` – (default: `omega`) name given to the symplectic form

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

  EXAMPLES:

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

  Sage

      sage: M.<q, p> = EuclideanSpace(name='R2', latex_name=r"\mathbb{R}^2")
      sage: omega = M.symplectic_form(name='omega', latex_name=r'\omega')
      sage: omega
      Symplectic form omega on the Euclidean plane R2
      sage: omega.set_comp()[1,2] = -1
      sage: omega.display()
      omega = -dq∧dp

  Python

      >>> from sage.all import *
      >>> M = EuclideanSpace(name='R2', latex_name=r"\mathbb{R}^2", names=('q', 'p',)); (q, p,) = M._first_ngens(2)
      >>> omega = M.symplectic_form(name='omega', latex_name=r'\omega')
      >>> omega
      Symplectic form omega on the Euclidean plane R2
      >>> omega.set_comp()[Integer(1),Integer(2)] = -Integer(1)
      >>> omega.display()
      omega = -dq∧dp

  poisson(expansion_symbol=None, order=1)

    Return the Poisson tensor associated with the symplectic form.

    INPUT:

    - `expansion_symbol` – (default: `None`) symbolic variable; if specified, the inverse will be expanded in power series with respect to this variable (around its zero value)

    - `order` – integer (default: 1); the order of the expansion if `expansion_symbol` is not `None`; the order is defined as the degree of the polynomial representing the truncated power series in `expansion_symbol`; currently only first order inverse is supported

    If `expansion_symbol` is set, then the zeroth order symplectic form must be invertible. Moreover, subsequent calls to this method will return a cached value, even when called with the default value (to enable computation of derived quantities). To reset, use `_del_derived()`.

    OUTPUT:

    - the Poisson tensor, , as an instance of `PoissonTensorFieldParal()`

    EXAMPLES:

    Poisson tensor of \(2\)-dimensional symplectic vector space:

    Sage

        sage: from sage.manifolds.differentiable.symplectic_form import SymplecticFormParal
        sage: M.<q, p> = EuclideanSpace(2, "R2", r"\mathbb{R}^2", symbols=r"q:q p:p")
        sage: omega = SymplecticFormParal(M, 'omega', r'\omega')
        sage: omega[1,2] = -1
        sage: poisson = omega.poisson(); poisson
        2-vector field poisson_omega on the Euclidean plane R2
        sage: poisson.display()
        poisson_omega = -e_q∧e_p

    Python

        >>> from sage.all import *
        >>> from sage.manifolds.differentiable.symplectic_form import SymplecticFormParal
        >>> M = EuclideanSpace(Integer(2), "R2", r"\mathbb{R}^2", symbols=r"q:q p:p", names=('q', 'p',)); (q, p,) = M._first_ngens(2)
        >>> omega = SymplecticFormParal(M, 'omega', r'\omega')
        >>> omega[Integer(1),Integer(2)] = -Integer(1)
        >>> poisson = omega.poisson(); poisson
        2-vector field poisson_omega on the Euclidean plane R2
        >>> poisson.display()
        poisson_omega = -e_q∧e_p

  restrict(subdomain, dest_map=None)

    Return the restriction of the symplectic form to some subdomain.

    If the restriction has not been defined yet, it is constructed here.

    INPUT:

    - `subdomain` – open subset \(U\) of the symplectic form’s domain

    - `dest_map` – (default: `None`) smooth destination map \(\Phi:\ U \rightarrow V\), where \(V\) is a subdomain of the symplectic form’s domain. If `None`, the restriction of the initial vector field module is used.

    OUTPUT: the restricted symplectic form

    EXAMPLES:

    Restriction of the standard symplectic form on \(\RR^2\) to the upper half plane:

    Sage

        sage: from sage.manifolds.differentiable.symplectic_form import SymplecticFormParal
        sage: M = EuclideanSpace(2, "R2", r"\mathbb{R}^2", symbols=r"q:q p:p")
        sage: X.<q, p> = M.chart()
        sage: omega = SymplecticFormParal(M, 'omega', r'\omega')
        sage: omega[1,2] = -1
        sage: U = M.open_subset('U', coord_def={X: q>0})
        sage: omegaU = omega.restrict(U); omegaU
        Symplectic form omega on the Open subset U of the Euclidean plane R2
        sage: omegaU.display()
        omega = -dq∧dp

    Python

        >>> from sage.all import *
        >>> from sage.manifolds.differentiable.symplectic_form import SymplecticFormParal
        >>> M = EuclideanSpace(Integer(2), "R2", r"\mathbb{R}^2", symbols=r"q:q p:p")
        >>> X = M.chart(names=('q', 'p',)); (q, p,) = X._first_ngens(2)
        >>> omega = SymplecticFormParal(M, 'omega', r'\omega')
        >>> omega[Integer(1),Integer(2)] = -Integer(1)
        >>> U = M.open_subset('U', coord_def={X: q>Integer(0)})
        >>> omegaU = omega.restrict(U); omegaU
        Symplectic form omega on the Open subset U of the Euclidean plane R2
        >>> omegaU.display()
        omega = -dq∧dp