lean/OAI/Geometry/BallPacking/DiskMaps/FlatIsotopy.lean

import Mathlib
import OAI.Geometry.BallPacking.DiskMaps.SmoothInverse

namespace OAI

noncomputable section

namespace PackingSufficiencySupport.Hamiltonian
open scoped ContDiff Topology
open Set Function
open MeasureTheory
open scoped ComplexConjugate
section

variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
  [FiniteDimensional ℝ E]

omit [CompleteSpace E] [FiniteDimensional ℝ E] in
 theorem flat_isotopy_stationary {f : ℝ × E → E} (hf : ContDiff ℝ ∞ f)
    (t : ℝ) (ht : t ∉ Ioo (0:ℝ) 1) (x : E) :
    fderiv ℝ (fun p : ℝ × E => f (Real.smoothTransition p.1,p.2)) (t,x) (1,0) = 0 := by
  have hst : deriv Real.smoothTransition t = 0 :=
    smoothTransition_deriv_eq_zero (by simpa only [mem_Ioo,not_and_or,not_lt] using ht)
  have hsm : ContDiff ℝ ∞ Real.smoothTransition := Real.smoothTransition.contDiff
  have hs := (hsm.differentiable (by simp) t).hasDerivAt
  have hi := (hs.hasFDerivAt.comp (t,x)
    (hasFDerivAt_fst (𝕜 := ℝ) (p := (t,x)))).prodMk
    (hasFDerivAt_snd (𝕜 := ℝ) (p := (t,x)))
  have hd := ((hf.differentiable (by simp) _).hasFDerivAt.comp (t,x) hi).fderiv
  simp only [Function.comp_def] at hd
  rw [hd]
  simp [hst]
  exact map_zero _

theorem exists_flat_embedding_extension
    (f : ℝ × E → E) (hf : ContDiff ℝ ∞ f)
    (U W : Set E) (hU : IsOpen U) (hW : IsOpen W)
    (hinj : ∀ t ∈ Icc (0:ℝ) 1, InjOn (fun x => f (t,x)) U)
    (hi : ∀ t ∈ Icc (0:ℝ) 1, ∀ x ∈ U,
      (fderiv ℝ (fun x => f (t,x)) x).IsInvertible)
    (K : Set E) (hK : IsCompact K) (hKU : K ⊆ U)
    (htrack : ∀ t ∈ Icc (0:ℝ) 1, ∀ x ∈ K, f (t,x) ∈ W) :
    ∃ (S : Set E) (Φ : ℝ → E ≃ₜ E), IsCompact S ∧ S ⊆ W ∧
      ContDiff ℝ ∞ (fun p : ℝ × E => Φ p.1 p.2) ∧
      ContDiff ℝ ∞ (fun p : ℝ × E => (Φ p.1).symm p.2) ∧
      Φ 0 = Homeomorph.refl E ∧
      (∀ t x, x ∉ S → Φ t x = x) ∧
      (∀ x ∈ K, Φ 1 (f (0,x)) = f (1,x)) := by
  let F : ℝ × E → E := fun p => f (Real.smoothTransition p.1,p.2)
  have hF : ContDiff ℝ ∞ F :=
    hf.comp ((Real.smoothTransition.contDiff.comp contDiff_fst).prodMk contDiff_snd)
  let D : Set (ℝ × E) := Prod.snd ⁻¹' U ∩ F ⁻¹' W
  have hD : IsOpen D := (hU.preimage continuous_snd).inter (hW.preimage hF.continuous)
  have hstep (t : ℝ) : Real.smoothTransition t ∈ Icc (0:ℝ) 1 :=
    ⟨Real.smoothTransition.nonneg t,Real.smoothTransition.le_one t⟩
  obtain ⟨S,Φ,hS,hSW,hΦ,hΦi,hΦ0,hΦs,hΦf⟩ :=
    exists_embedding_isotopy_extension F hF D hD
      (fun t => (hinj _ (hstep t)).mono (fun _ hx => hx.1))
      (fun p hp => hi _ (hstep p.1) _ hp.1) K hK W (fun _ hp => hp.2)
      (fun p hp => ⟨hKU hp.2,htrack _ (hstep p.1) _ hp.2⟩)
      (flat_isotopy_stationary hf)
  refine ⟨S,Φ,hS,hSW,hΦ,hΦi,hΦ0,hΦs,?_⟩
  intro x hx
  simpa only [F,Real.smoothTransition.zero_of_nonpos (le_refl 0),    Real.smoothTransition.one_of_one_le (le_refl 1)] using hΦf 1 x hx

end
section

variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]

structure SupportedSmoothIsotopy (W : Set E) where
  map : ℝ → E ≃ₜ E
  smooth : ContDiff ℝ ∞ (fun p : ℝ × E => map p.1 p.2)
  inverse_smooth : ContDiff ℝ ∞ (fun p : ℝ × E => (map p.1).symm p.2)
  zero : map 0 = Homeomorph.refl E
  support : Set E
  compact_support : IsCompact support
  support_subset : support ⊆ W
  fixed : ∀ t x, x ∉ support → map t x = x

namespace SupportedSmoothIsotopy

 def refl (W : Set E) : SupportedSmoothIsotopy W where
  map := fun _ => Homeomorph.refl E
  smooth := contDiff_snd
  inverse_smooth := contDiff_snd
  zero := rfl
  support := ∅
  compact_support := isCompact_empty
  support_subset := empty_subset _
  fixed := fun _ _ _ => rfl

 def trans {W : Set E} (Φ Ψ : SupportedSmoothIsotopy W) : SupportedSmoothIsotopy W where
  map := fun t => (Φ.map t).trans (Ψ.map t)
  smooth := Ψ.smooth.comp (contDiff_fst.prodMk Φ.smooth)
  inverse_smooth := Φ.inverse_smooth.comp (contDiff_fst.prodMk Ψ.inverse_smooth)
  zero := by rw [Φ.zero,Ψ.zero]; rfl
  support := Φ.support ∪ Ψ.support
  compact_support := Φ.compact_support.union Ψ.compact_support
  support_subset := union_subset Φ.support_subset Ψ.support_subset
  fixed := by
    intro t x hx
    have hx' : x ∉ Φ.support ∧ x ∉ Ψ.support := by simpa only [mem_union,not_or] using hx
    change Ψ.map t (Φ.map t x) = x
    rw [Φ.fixed t x hx'.1,Ψ.fixed t x hx'.2]

 def symm {W : Set E} (Φ : SupportedSmoothIsotopy W) : SupportedSmoothIsotopy W where
  map := fun t => (Φ.map t).symm
  smooth := Φ.inverse_smooth
  inverse_smooth := Φ.smooth
  zero := by rw [Φ.zero]; rfl
  support := Φ.support
  compact_support := Φ.compact_support
  support_subset := Φ.support_subset
  fixed := by
    intro t x hx
    apply (Φ.map t).injective
    rw [(Φ.map t).apply_symm_apply,Φ.fixed t x hx]

 theorem mapsTo {W : Set E} (Φ : SupportedSmoothIsotopy W) (t : ℝ) :
    MapsTo (Φ.map t) W W := by
  intro x hx
  by_contra hn
  have hn' : Φ.map t x ∉ Φ.support := fun h => hn (Φ.support_subset h)
  have he := Φ.fixed t (Φ.map t x) hn'
  exact hn (((Φ.map t).injective he).symm ▸ hx)

 theorem mapsTo_compl {W : Set E} (Φ : SupportedSmoothIsotopy W) (t : ℝ) :
    MapsTo (Φ.map t) Wᶜ Wᶜ := by
  intro x hx
  rwa [Φ.fixed t x (fun h => hx (Φ.support_subset h))]

end SupportedSmoothIsotopy

def SmoothlyAmbientRelated (W K : Set E) (f g : E → E) : Prop :=
  ∃ Φ : SupportedSmoothIsotopy W, ∀ x ∈ K, Φ.map 1 (f x) = g x

namespace SmoothlyAmbientRelated
 theorem refl (W K : Set E) (f : E → E) : SmoothlyAmbientRelated W K f f :=
  ⟨SupportedSmoothIsotopy.refl W,fun _ _ => rfl⟩

 theorem trans {W K : Set E} {f g h : E → E}
    (hfg : SmoothlyAmbientRelated W K f g) (hgh : SmoothlyAmbientRelated W K g h) :
    SmoothlyAmbientRelated W K f h := by
  obtain ⟨Φ,hΦ⟩ := hfg
  obtain ⟨Ψ,hΨ⟩ := hgh
  refine ⟨Φ.trans Ψ,?_⟩
  intro x hx
  change Ψ.map 1 (Φ.map 1 (f x)) = h x
  rw [hΦ x hx,hΨ x hx]

 theorem symm {W K : Set E} {f g : E → E} (hfg : SmoothlyAmbientRelated W K f g) :
    SmoothlyAmbientRelated W K g f := by
  obtain ⟨Φ,hΦ⟩ := hfg
  refine ⟨Φ.symm,?_⟩
  intro x hx
  change (Φ.map 1).symm (g x) = f x
  rw [← hΦ x hx,(Φ.map 1).symm_apply_apply]

 theorem mono {W K J : Set E} {f g : E → E} (hfg : SmoothlyAmbientRelated W K f g)
    (hJK : J ⊆ K) : SmoothlyAmbientRelated W J f g := by
  obtain ⟨Φ,hΦ⟩ := hfg
  exact ⟨Φ,fun x hx => hΦ x (hJK hx)⟩

end SmoothlyAmbientRelated

variable [CompleteSpace E] [FiniteDimensional ℝ E]

 theorem smoothlyAmbientRelated_of_path
    (f : ℝ × E → E) (hf : ContDiff ℝ ∞ f)
    (U W : Set E) (hU : IsOpen U) (hW : IsOpen W)
    (hinj : ∀ t ∈ Icc (0:ℝ) 1, InjOn (fun x => f (t,x)) U)
    (hi : ∀ t ∈ Icc (0:ℝ) 1, ∀ x ∈ U,
      (fderiv ℝ (fun x => f (t,x)) x).IsInvertible)
    (K : Set E) (hK : IsCompact K) (hKU : K ⊆ U)
    (htrack : ∀ t ∈ Icc (0:ℝ) 1, ∀ x ∈ K, f (t,x) ∈ W) :
    SmoothlyAmbientRelated W K (fun x => f (0,x)) (fun x => f (1,x)) := by
  obtain ⟨S,Φ,hS,hSW,hΦ,hΦi,hΦ0,hΦs,hΦf⟩ :=
    exists_flat_embedding_extension f hf U W hU hW hinj hi K hK hKU htrack
  exact ⟨⟨Φ,hΦ,hΦi,hΦ0,S,hS,hSW,hΦs⟩,hΦf⟩

end
section

variable {P E : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P]
  [NormedAddCommGroup E] [NormedSpace ℝ E]

 theorem parametric_flat_isotopy_stationary {f : (P × ℝ) × E → E} (hf : ContDiff ℝ ∞ f)
    (y : P) (t : ℝ) (ht : t ∉ Ioo (0:ℝ) 1) (x : E) :
    fderiv ℝ (fun p : (P × ℝ) × E => f ((p.1.1,Real.smoothTransition p.1.2),p.2))
      ((y,t),x) ((0,1),0) = 0 := by
  have hst : deriv Real.smoothTransition t = 0 :=
    smoothTransition_deriv_eq_zero (by simpa only [mem_Ioo,not_and_or,not_lt] using ht)
  have hsm : ContDiff ℝ ∞ Real.smoothTransition := Real.smoothTransition.contDiff
  have hs := (hsm.differentiable (by simp) t).hasDerivAt
  have hp := hasFDerivAt_fst (𝕜 := ℝ) (p := ((y,t),x))
  have hy := (hasFDerivAt_fst (𝕜 := ℝ) (p := (y,t))).comp ((y,t),x) hp
  have ht' := (hasFDerivAt_snd (𝕜 := ℝ) (p := (y,t))).comp ((y,t),x) hp
  have hi := (hy.prodMk (hs.hasFDerivAt.comp ((y,t),x) ht')).prodMk
    (hasFDerivAt_snd (𝕜 := ℝ) (p := ((y,t),x)))
  have hd := ((hf.differentiable (by simp) _).hasFDerivAt.comp ((y,t),x) hi).fderiv
  simp only [Function.comp_def] at hd
  rw [hd]
  simp [hst]
  exact map_zero _

variable [CompleteSpace P] [FiniteDimensional ℝ P]
  [CompleteSpace E] [FiniteDimensional ℝ E]

theorem exists_parametric_flat_embedding_extension
    (f : (P × ℝ) × E → E) (hf : ContDiff ℝ ∞ f)
    (O : Set P) (hO : IsOpen O) (U W : Set E) (hU : IsOpen U) (hW : IsOpen W)
    (hinj : ∀ y ∈ O, ∀ t ∈ Icc (0:ℝ) 1, InjOn (fun x => f ((y,t),x)) U)
    (hi : ∀ y ∈ O, ∀ t ∈ Icc (0:ℝ) 1, ∀ x ∈ U,
      (fderiv ℝ (fun x => f ((y,t),x)) x).IsInvertible)
    (Y : Set P) (hY : IsCompact Y) (hYO : Y ⊆ O)
    (K : Set E) (hK : IsCompact K) (hKU : K ⊆ U)
    (htrack : ∀ y ∈ Y, ∀ t ∈ Icc (0:ℝ) 1, ∀ x ∈ K, f ((y,t),x) ∈ W) :
    ∃ (S : Set E) (Φ : P → ℝ → E ≃ₜ E), IsCompact S ∧ S ⊆ W ∧
      ContDiff ℝ ∞ (fun p : (P × ℝ) × E => Φ p.1.1 p.1.2 p.2) ∧
      ContDiff ℝ ∞ (fun p : (P × ℝ) × E => (Φ p.1.1 p.1.2).symm p.2) ∧
      (∀ y, Φ y 0 = Homeomorph.refl E) ∧
      (∀ y t x, x ∉ S → Φ y t x = x) ∧
      (∀ y ∈ Y, ∀ x ∈ K, Φ y 1 (f ((y,0),x)) = f ((y,1),x)) := by
  let F : (P × ℝ) × E → E := fun p => f ((p.1.1,Real.smoothTransition p.1.2),p.2)
  have hF : ContDiff ℝ ∞ F := hf.comp
    ((contDiff_fst.fst.prodMk (Real.smoothTransition.contDiff.comp contDiff_fst.snd)).prodMk contDiff_snd)
  let D : Set ((P × ℝ) × E) := (fun p => p.1.1) ⁻¹' O ∩ (Prod.snd ⁻¹' U ∩ F ⁻¹' W)
  have hD : IsOpen D := (hO.preimage continuous_fst.fst).inter
    ((hU.preimage continuous_snd).inter (hW.preimage hF.continuous))
  have hstep (t : ℝ) : Real.smoothTransition t ∈ Icc (0:ℝ) 1 :=
    ⟨Real.smoothTransition.nonneg t,Real.smoothTransition.le_one t⟩
  obtain ⟨S,Φ,hS,hSW,hΦ,hΦi,hΦ0,hΦs,hΦf⟩ :=
    exists_parametric_embedding_isotopy_extension F hF D hD
      (fun q => by
        intro x hx z hz he
        exact hinj q.1 hx.1 _ (hstep q.2) hx.2.1 hz.2.1 he)
      (fun p hp => hi _ hp.1 _ (hstep p.1.2) _ hp.2.1) Y hY K hK W (fun _ hp => hp.2.2)
      (fun p hp => ⟨hYO hp.1.1,hKU hp.2,htrack _ hp.1.1 _ (hstep p.1.2) _ hp.2⟩)
      (parametric_flat_isotopy_stationary hf)
  refine ⟨S,Φ,hS,hSW,hΦ,hΦi,hΦ0,hΦs,?_⟩
  intro y hy x hx
  simpa only [F,Real.smoothTransition.zero_of_nonpos (le_refl 0),    Real.smoothTransition.one_of_one_le (le_refl 1)] using hΦf y hy 1 x hx

end
section

universe u
variable {P E F : Type u} [NormedAddCommGroup P] [NormedSpace ℝ P]
  [FiniteDimensional ℝ P] [NormedAddCommGroup E] [NormedSpace ℝ E]
  [FiniteDimensional ℝ E] [NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F]

theorem contDiff_fixed_integral {f : ℝ × P → F} (hf : ContDiff ℝ ∞ f) :
    ContDiff ℝ ∞ (fun p => ∫ t in (0:ℝ)..1, f (t,p)) := by
  let τ : C(Time,ℝ × P) := ⟨fun t => ((t:ℝ),0),continuous_subtype_val.prodMk continuous_const⟩
  let v : P → C(Time,ℝ × P) := fun p => τ + constantPath (0,p)
  have hv : ContDiff ℝ ∞ v := contDiff_const.add
    ((constantPath (E := ℝ × P)).contDiff.comp (contDiff_const.prodMk contDiff_id))
  let I : C(Time,F) →L[ℝ] F := (ContinuousMap.evalCLM ℝ (⟨1,by simp⟩ : Time)).comp pathIntegral
  have he : (fun p => ∫ t in (0:ℝ)..1, f (t,p)) =
      fun p => I ((⟨f,hf.continuous⟩ : C(ℝ × P,F)).comp (v p)) := by
    funext p
    change _ = ∫ t in (0:ℝ)..1, extendPath ((⟨f,hf.continuous⟩ : C(ℝ × P,F)).comp (v p)) t
    apply intervalIntegral.integral_congr
    intro t ht
    rw [uIcc_of_le zero_le_one] at ht
    rw [show extendPath ((⟨f,hf.continuous⟩ : C(ℝ × P,F)).comp (v p)) t =      ((⟨f,hf.continuous⟩ : C(ℝ × P,F)).comp (v p)) ⟨t,ht⟩ from extendPath_coe _ ⟨t,ht⟩]
    change f (t,p) = f ((t,0)+(0,p))
    simp
  rw [he]
  exact I.contDiff.comp ((postcomp_contDiff hf).comp hv)

def smoothBlowup (f : E → F) (p : ℝ × E) : F :=
  ∫ s in (0:ℝ)..1, fderiv ℝ f ((s*p.1) • p.2) p.2

 theorem smoothBlowup_contDiff {f : E → F} (hf : ContDiff ℝ ∞ f) :
    ContDiff ℝ ∞ (smoothBlowup f) := by
  unfold smoothBlowup
  apply contDiff_fixed_integral (f := fun q : ℝ × (ℝ × E) =>
    fderiv ℝ f ((q.1*q.2.1) • q.2.2) q.2.2)
  exact ((hf.fderiv_right (by simp)).comp
    ((contDiff_fst.mul contDiff_snd.fst).smul contDiff_snd.snd)).clm_apply contDiff_snd.snd

omit [FiniteDimensional ℝ E] in
 theorem smoothBlowup_zero (f : E → F) (x : E) :
    smoothBlowup f (0,x) = fderiv ℝ f 0 x := by
  simp [smoothBlowup]

omit [FiniteDimensional ℝ E] in
 theorem smul_smoothBlowup {f : E → F} (hf : ContDiff ℝ ∞ f) (t : ℝ) (x : E) :
    t • smoothBlowup f (t,x) = f (t • x)-f 0 := by
  have hd (s : ℝ) : HasDerivAt (fun r : ℝ => f ((r*t) • x))
      (t • fderiv ℝ f ((s*t) • x) x) s := by
    simpa only [Function.comp_def,id_eq,one_mul,map_smul] using
      (hf.differentiable (by simp) _).hasFDerivAt.comp_hasDerivAt s
        (((hasDerivAt_id s).mul_const t).smul_const x)
  have hc : Continuous (fun s : ℝ => t • fderiv ℝ f ((s*t) • x) x) :=
    continuous_const.smul (((hf.fderiv_right (m := ∞) (by simp)).continuous.comp
      ((continuous_id.mul continuous_const).smul continuous_const)).clm_apply continuous_const)
  have hi := intervalIntegral.integral_eq_sub_of_hasDerivAt (fun s _ => hd s)
    (hc.intervalIntegrable 0 1)
  simpa only [intervalIntegral.integral_smul,one_mul,zero_mul,zero_smul,smoothBlowup] using hi

omit [FiniteDimensional ℝ E] in
 theorem smoothBlowup_eq {f : E → F} (hf : ContDiff ℝ ∞ f) {t : ℝ} (ht : t ≠ 0) (x : E) :
    smoothBlowup f (t,x) = t⁻¹ • (f (t • x)-f 0) := by
  rw [← smul_smoothBlowup hf t x,smul_smul,inv_mul_cancel₀ ht,one_smul]

omit [FiniteDimensional ℝ E] in
 theorem smoothBlowup_injOn {f : E → F} (hf : ContDiff ℝ ∞ f)
    {U : Set E} (hinj : InjOn f U) (hi0 : Injective (fderiv ℝ f 0)) (t : ℝ) :
    InjOn (fun x => smoothBlowup f (t,x)) {x | t • x ∈ U} := by
  intro x hx y hy he
  by_cases ht : t = 0
  · subst t
    simp only [smoothBlowup_zero] at he
    exact hi0 he
  · have h := congrArg (fun z : F => t • z) he
    rw [smul_smoothBlowup hf,smul_smoothBlowup hf,sub_left_inj] at h
    exact (smul_right_injective E ht) (hinj hx hy h)

omit [FiniteDimensional ℝ E] in
 theorem smoothBlowup_hasFDerivAt {f : E → F} (hf : ContDiff ℝ ∞ f) (t : ℝ) (x : E) :
    HasFDerivAt (fun x => smoothBlowup f (t,x)) (fderiv ℝ f (t • x)) x := by
  by_cases ht : t = 0
  · subst t
    simpa only [smoothBlowup_zero,zero_smul] using (fderiv ℝ f 0).hasFDerivAt
  · have he : (fun x => smoothBlowup f (t,x)) = fun x => t⁻¹ • (f (t • x)-f 0) :=
      funext (smoothBlowup_eq hf ht)
    rw [he]
    have hd := (((hf.differentiable (by simp) (t • x)).hasFDerivAt.comp x
      ((hasFDerivAt_id x).const_smul t)).sub_const (f 0)).const_smul t⁻¹
    have hde : t⁻¹ • (fderiv ℝ f (t • x)).comp (t • ContinuousLinearMap.id ℝ E) =
        fderiv ℝ f (t • x) := by
      ext v
      change t⁻¹ • fderiv ℝ f (t • x) (t • v) = fderiv ℝ f (t • x) v
      rw [map_smul,smul_smul,inv_mul_cancel₀ ht,one_smul]
    convert hd using 1
    · rfl
    · exact hde.symm

end

def complexPair (a b : ℂ) : ℂ →L[ℝ] ℂ :=
  a • ContinuousLinearMap.id ℝ ℂ + b • Complex.conjCLE.toContinuousLinearMap

@[simp] theorem complexPair_apply (a b z : ℂ) : complexPair a b z = a*z+b*conj z := rfl

 theorem realLinear_complex_decomposition (A : ℂ →L[ℝ] ℂ) :
    A = complexPair ((A 1-Complex.I*A Complex.I)/2) ((A 1+Complex.I*A Complex.I)/2) := by
  ext z
  have hz : z = z.re • (1:ℂ) + z.im • Complex.I := by
    simpa only [Complex.real_smul,Complex.ofReal_mul,Complex.ofReal_one,mul_one] using
      (Complex.re_add_im z).symm
  conv_lhs => rw [hz,map_add,map_smul,map_smul]
  simp only [complexPair_apply,Complex.real_smul]
  apply Complex.ext <;> simp [Complex.add_re,Complex.add_im,Complex.mul_re,Complex.mul_im] <;> ring

 theorem complex_decomposition_orientation (A : ℂ →L[ℝ] ℂ) :
    Complex.normSq ((A 1-Complex.I*A Complex.I)/2) -
      Complex.normSq ((A 1+Complex.I*A Complex.I)/2) =
      (A 1).re * (A Complex.I).im - (A 1).im * (A Complex.I).re := by
  simp [Complex.normSq_apply,Complex.mul_re,Complex.mul_im]
  ring

 theorem complexPair_invertible {a b : ℂ} (h : ‖b‖ < ‖a‖) :
    (complexPair a b).IsInvertible := by
  have hi : Injective (complexPair a b) := by
    apply (injective_iff_map_eq_zero (complexPair a b)).mpr
    intro z hz
    change a*z+b*conj z = 0 at hz
    have hn := congrArg norm (eq_neg_of_add_eq_zero_left hz)
    rw [norm_mul,norm_neg,norm_mul,Complex.norm_conj] at hn
    have hz0 : ‖z‖ = 0 := by nlinarith [norm_nonneg z]
    exact norm_eq_zero.mp hz0
  have hs := (LinearMap.injective_iff_surjective (f := (complexPair a b).toLinearMap)).mp hi
  exact ⟨ContinuousLinearEquiv.ofBijective (complexPair a b)
    (LinearMap.ker_eq_bot.mpr hi) (LinearMap.range_eq_top.mpr hs),rfl⟩

theorem exists_positive_complex_linear_path (A : ℂ →L[ℝ] ℂ)
    (hA : 0 < (A 1).re * (A Complex.I).im - (A 1).im * (A Complex.I).re) :
    ∃ L : ℝ → ℂ →L[ℝ] ℂ, ContDiff ℝ ∞ L ∧
      (∀ t, (L t).IsInvertible) ∧ L 0 = ContinuousLinearMap.id ℝ ℂ ∧ L 1 = A ∧
      (∀ t ≤ 0, L t = ContinuousLinearMap.id ℝ ℂ) ∧ (∀ t, 1 ≤ t → L t = A) := by
  let a := (A 1-Complex.I*A Complex.I)/2
  let b := (A 1+Complex.I*A Complex.I)/2
  have hab : ‖b‖ < ‖a‖ := by
    have he := complex_decomposition_orientation A
    change Complex.normSq a-Complex.normSq b = _ at he
    rw [Complex.normSq_eq_norm_sq,Complex.normSq_eq_norm_sq] at he
    nlinarith [norm_nonneg a,norm_nonneg b]
  have ha : a ≠ 0 := norm_pos_iff.mp ((norm_nonneg b).trans_lt hab)
  let s : ℝ → ℝ := fun t => Real.smoothTransition (2*t)
  let r : ℝ → ℝ := fun t => Real.smoothTransition (2*t-1)
  let α : ℝ → ℂ := fun t => Complex.exp (s t • Complex.log a)
  let β : ℝ → ℂ := fun t => r t • b
  let L : ℝ → ℂ →L[ℝ] ℂ := fun t => complexPair (α t) (β t)
  have hs : ContDiff ℝ ∞ s := Real.smoothTransition.contDiff.comp (contDiff_const.mul contDiff_id)
  have hr : ContDiff ℝ ∞ r := Real.smoothTransition.contDiff.comp
    ((contDiff_const.mul contDiff_id).sub contDiff_const)
  have hα : ContDiff ℝ ∞ α := (hs.smul contDiff_const).cexp
  have hβ : ContDiff ℝ ∞ β := hr.smul contDiff_const
  have hL : ContDiff ℝ ∞ L := (hα.smul contDiff_const).add (hβ.smul contDiff_const)
  have hαa (t : ℝ) (ht : 1 ≤ 2*t) : α t = a := by
    dsimp [α,s]
    simp only [Real.smoothTransition.one_of_one_le ht,Complex.ofReal_one,one_mul,Complex.exp_log ha]
  have hL0 (t : ℝ) (ht : t ≤ 0) : L t = ContinuousLinearMap.id ℝ ℂ := by
    have ht0 : 2*t ≤ 0 := by linarith
    have ht1 : 2*t-1 ≤ 0 := by linarith
    ext z
    simp [L,α,β,s,r,Real.smoothTransition.zero_of_nonpos ht0,      Real.smoothTransition.zero_of_nonpos ht1]
  have hL1 (t : ℝ) (ht : 1 ≤ t) : L t = A := by
    have ht1 : 1 ≤ 2*t-1 := by linarith
    have ht0 : 1 ≤ 2*t := by linarith
    change complexPair (α t) (r t • b) = A
    rw [hαa t ht0,show r t = 1 from Real.smoothTransition.one_of_one_le ht1,one_smul]
    exact (realLinear_complex_decomposition A).symm
  refine ⟨L,hL,?_,hL0 0 le_rfl,hL1 1 le_rfl,hL0,hL1⟩
  intro t
  apply complexPair_invertible
  by_cases ht : 2*t-1 ≤ 0
  · have hr0 : r t = 0 := Real.smoothTransition.zero_of_nonpos ht
    change ‖r t • b‖ < ‖Complex.exp (s t • Complex.log a)‖
    rw [hr0,zero_smul,norm_zero]
    exact norm_pos_iff.mpr (Complex.exp_ne_zero _)
  · have ht0 : 1 ≤ 2*t := by linarith
    change ‖r t • b‖ < ‖α t‖
    rw [hαa t ht0,norm_smul,Real.norm_of_nonneg (Real.smoothTransition.nonneg _)]
    exact (mul_le_of_le_one_left (norm_nonneg b) (Real.smoothTransition.le_one _)).trans_lt hab

variable {P E : Type*} [TopologicalSpace P] [TopologicalSpace E]

theorem exists_small_positive_perturbation {K : Set P} (hK : IsCompact K)
    {F : ℝ × P → E} (hF : Continuous F) {W : Set E} (hW : IsOpen W)
    (h0 : ∀ p ∈ K, F (0,p) ∈ W) :
    ∃ δ > 0, ∀ ε : ℝ, |ε| < δ → ∀ p ∈ K, F (ε,p) ∈ W := by
  have hsub : ({0} : Set ℝ) ×ˢ K ⊆ F ⁻¹' W := by
    rintro ⟨ε,p⟩ ⟨hε,hp⟩
    have he : ε = 0 := hε
    subst ε
    exact h0 p hp
  obtain ⟨U,V,hU,_,h0U,hKV,hUV⟩ :=
    generalized_tube_lemma isCompact_singleton hK (hW.preimage hF) hsub
  obtain ⟨δ,hδ,hδU⟩ := Metric.mem_nhds_iff.mp (hU.mem_nhds (h0U (mem_singleton 0)))
  refine ⟨δ,hδ,?_⟩
  intro ε hε p hp
  exact hUV ⟨hδU (by simpa only [Metric.mem_ball,Real.dist_eq,sub_zero] using hε),hKV hp⟩

end PackingSufficiencySupport.Hamiltonian
end

end OAI