Documentation

TauCeti.Geometry.Symplectic.SymplecticTransport

Transporting symplectic forms along linear equivalences #

A real-linear isomorphism e : V ≃ₗ[ℝ] W carries a symplectic form ω on V to one on W by pushing the arguments back along e.symm: (ω.transport e)(v, w) = ω(e.symm v, e.symm w). This is the symplectic companion of TauCeti.AlmostComplexStructure.transport (in TauCeti.Geometry.Symplectic.Transport): together they make e simultaneously a symplectomorphism and a complex-linear isomorphism, so every compatibility relation between ω and an almost complex structure J is preserved when both are transported along e.

This is the pointwise linear algebra that the smooth layer of the analytic Heegaard Floer roadmap needs before stating bundle-level naturality: a symplectic form on a vector bundle is given fiberwise, and a change of trivialization acts on each fiber by exactly this transport. Stating the compatibility transport now keeps the invariance statements naturality-ready, as the roadmap asks. The underlying form transport reuses Mathlib's LinearMap.BilinForm.congr and LinearMap.BilinForm.Nondegenerate.congr.

Main declarations #

The conventions follow McDuff--Salamon, J-holomorphic Curves and Symplectic Topology, Section 2.1, where a symplectomorphism carries a compatible triple to a compatible triple.

noncomputable def TauCeti.SymplecticForm.transport {V : Type u_1} {W : Type u_2} [AddCommGroup V] [Module V] [AddCommGroup W] [Module W] (ω : SymplecticForm V) (e : V ≃ₗ[] W) :

Transport a symplectic form along a real-linear equivalence e : V ≃ₗ[ℝ] W by pushing the arguments back along e.symm.

The underlying bilinear form is LinearMap.BilinForm.congr e applied to ω, equivalently (v, w) ↦ ω(e.symm v, e.symm w); it stays alternating and nondegenerate because e.symm is a linear bijection.

Equations
Instances For
    @[simp]
    theorem TauCeti.SymplecticForm.transport_apply {V : Type u_1} {W : Type u_2} [AddCommGroup V] [Module V] [AddCommGroup W] [Module W] (ω : SymplecticForm V) (e : V ≃ₗ[] W) (v w : W) :
    (fun (v w : W) => ((ω.transport e).toBilinForm v) w) v w = (fun (v w : V) => (ω.toBilinForm v) w) (e.symm v) (e.symm w)
    @[simp]

    Transporting along the identity equivalence does nothing.

    @[simp]
    theorem TauCeti.SymplecticForm.transport_trans {V : Type u_1} {W : Type u_2} {X : Type u_3} [AddCommGroup V] [Module V] [AddCommGroup W] [Module W] [AddCommGroup X] [Module X] (ω : SymplecticForm V) (e₁ : V ≃ₗ[] W) (e₂ : W ≃ₗ[] X) :
    (ω.transport e₁).transport e₂ = ω.transport (e₁ ≪≫ₗ e₂)

    Transport is functorial: transporting along e₁ then e₂ is transporting along their composite.

    Transporting forward along e and back along e.symm returns the original form.

    Transporting back along e.symm and forward along e returns the original form.

    theorem TauCeti.SymplecticForm.transport_apply_apply {V : Type u_1} {W : Type u_2} [AddCommGroup V] [Module V] [AddCommGroup W] [Module W] (ω : SymplecticForm V) (e : V ≃ₗ[] W) (v w : V) :
    (fun (v w : W) => ((ω.transport e).toBilinForm v) w) (e v) (e w) = (fun (v w : V) => (ω.toBilinForm v) w) v w

    e is a symplectomorphism onto the transported form: evaluating ω.transport e on images under e recovers ω.

    A real-linear equivalence e : V ≃ₗ[ℝ] W is a symplectomorphism from (V, ω₁) to (W, ω₂) when it intertwines the two symplectic forms, ω₂(e v, e w) = ω₁(v, w).

    The body is @[no_expose]: downstream code uses this predicate through isSymplectomorphism_iff, IsSymplectomorphism.apply, and isSymplectomorphism_iff_transport_eq rather than by unfolding.

    Equations
    Instances For
      theorem TauCeti.SymplecticForm.isSymplectomorphism_iff {V : Type u_1} {W : Type u_2} [AddCommGroup V] [Module V] [AddCommGroup W] [Module W] {ω₁ : SymplecticForm V} {ω₂ : SymplecticForm W} {e : V ≃ₗ[] W} :
      ω₁.IsSymplectomorphism ω₂ e ∀ (v w : V), (fun (v w : W) => (ω₂.toBilinForm v) w) (e v) (e w) = (fun (v w : V) => (ω₁.toBilinForm v) w) v w

      A linear equivalence is a symplectomorphism exactly when it preserves the symplectic forms pointwise.

      theorem TauCeti.SymplecticForm.IsSymplectomorphism.apply {V : Type u_1} {W : Type u_2} [AddCommGroup V] [Module V] [AddCommGroup W] [Module W] {ω₁ : SymplecticForm V} {ω₂ : SymplecticForm W} {e : V ≃ₗ[] W} (h : ω₁.IsSymplectomorphism ω₂ e) (v w : V) :
      (fun (v w : W) => (ω₂.toBilinForm v) w) (e v) (e w) = (fun (v w : V) => (ω₁.toBilinForm v) w) v w

      Apply a symplectomorphism hypothesis to two vectors.

      theorem TauCeti.SymplecticForm.isSymplectomorphism_iff_transport_eq {V : Type u_1} {W : Type u_2} [AddCommGroup V] [Module V] [AddCommGroup W] [Module W] {ω₁ : SymplecticForm V} {ω₂ : SymplecticForm W} {e : V ≃ₗ[] W} :
      ω₁.IsSymplectomorphism ω₂ e ω₁.transport e = ω₂

      A linear equivalence is a symplectomorphism exactly when ω₂ is the transport of ω₁ along that equivalence.

      @[simp]

      The identity equivalence is a symplectomorphism.

      theorem TauCeti.SymplecticForm.IsSymplectomorphism.symm {V : Type u_1} {W : Type u_2} [AddCommGroup V] [Module V] [AddCommGroup W] [Module W] {ω₁ : SymplecticForm V} {ω₂ : SymplecticForm W} {e : V ≃ₗ[] W} (h : ω₁.IsSymplectomorphism ω₂ e) :

      The inverse of a symplectomorphism is a symplectomorphism.

      theorem TauCeti.SymplecticForm.IsSymplectomorphism.trans {V : Type u_1} {W : Type u_2} {X : Type u_3} [AddCommGroup V] [Module V] [AddCommGroup W] [Module W] [AddCommGroup X] [Module X] {ω₁ : SymplecticForm V} {ω₂ : SymplecticForm W} {ω₃ : SymplecticForm X} {e : V ≃ₗ[] W} {f : W ≃ₗ[] X} (h₁ : ω₁.IsSymplectomorphism ω₂ e) (h₂ : ω₂.IsSymplectomorphism ω₃ f) :
      ω₁.IsSymplectomorphism ω₃ (e ≪≫ₗ f)

      Symplectomorphisms compose.

      @[simp]

      Transport by a linear equivalence preserves and reflects J-invariance.

      J-invariance transports along a linear equivalence: if ω is J-invariant, then ω.transport e is invariant under the transported almost complex structure J.transport e.

      @[simp]

      Transport by a linear equivalence preserves and reflects tameness.

      theorem TauCeti.SymplecticForm.Tames.transport {V : Type u_1} {W : Type u_2} [AddCommGroup V] [Module V] [AddCommGroup W] [Module W] {ω : SymplecticForm V} {J : AlmostComplexStructure V} (htames : ω.Tames J) (e : V ≃ₗ[] W) :

      Taming transports along a linear equivalence: if ω tames J, then ω.transport e tames the transported almost complex structure J.transport e.

      @[simp]

      Transport by a linear equivalence preserves and reflects compatibility.

      Compatibility transports along a linear equivalence: if ω is compatible with J, then ω.transport e is compatible with the transported almost complex structure J.transport e. This expresses that e carries the compatible pair (ω, J) to the compatible pair (ω.transport e, J.transport e).