lean/OAI/Geometry/SmoothYau/Smoothness/ContDiffSmoothFiniteWave.lean

import Mathlib
import OAI.Geometry.SmoothYau.Estimates.CanonicalCutoffWave
import OAI.Geometry.SmoothYau.Geometry.WaveDerivCompLinear
import OAI.Geometry.SmoothYau.Limits.FrameDualNorm
import OAI.Geometry.SmoothYau.Smoothness.FlowInitialFderiv

namespace OAI

noncomputable section
namespace YauCounterexamples
section
open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open MvPolynomial
open Set Filter
open scoped ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open scoped Topology
open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Matrix
open scoped Topology Matrix.Norms.Elementwise
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set
open scoped Topology ContDiff NNReal
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E]
local instance normalFamilyVecNorm : NormedAddCommGroup (E →L[ℝ] E) := inferInstance
local instance normalFamilyVecSpace : NormedSpace ℝ (E →L[ℝ] E) := inferInstance
local instance normalFamilyBiVecNorm : NormedAddCommGroup (E →L[ℝ] E →L[ℝ] E) := inferInstance
local instance normalFamilyBiVecSpace : NormedSpace ℝ (E →L[ℝ] E →L[ℝ] E) := inferInstance
local instance normalFamilyDualNorm : NormedAddCommGroup (E →L[ℝ] ℝ) := inferInstance
local instance normalFamilyDualSpace : NormedSpace ℝ (E →L[ℝ] ℝ) := inferInstance
local instance normalFamilyFormNorm : NormedAddCommGroup (E →L[ℝ] E →L[ℝ] ℝ) := inferInstance
local instance normalFamilyFormSpace : NormedSpace ℝ (E →L[ℝ] E →L[ℝ] ℝ) := inferInstance

lemma contDiff_frameChristoffel (g : SmoothMetric E E) :
    ContDiff ℝ ∞ (fun q : E × (E →L[ℝ] E) =>
      (metricChristoffel g q.1).bilinearComp q.2 q.2) := by
  have h1 : ContDiff ℝ ∞ (fun q : E × (E →L[ℝ] E) => (metricChristoffel g q.1).comp q.2) :=
    ((contDiff_metricChristoffel g).comp contDiff_fst).clm_comp contDiff_snd
  have h2 := (ContinuousLinearMap.flipₗᵢ ℝ E E E).toContinuousLinearMap.contDiff.comp h1
  have h3 := h2.clm_comp contDiff_snd
  exact (ContinuousLinearMap.flipₗᵢ ℝ E E E).toContinuousLinearMap.contDiff.comp h3

lemma contDiff_normalJetFamily (g : SmoothMetric E E) :
    ContDiff ℝ ∞ (fun q : (E × (E →L[ℝ] E)) × E =>
      normalJetMap q.1.1 q.1.2 ((metricChristoffel g q.1.1).bilinearComp q.1.2 q.1.2) q.2) := by
  have hC : ContDiff ℝ ∞ (fun q : (E × (E →L[ℝ] E)) × E => (metricChristoffel g q.1.1).bilinearComp q.1.2 q.1.2) :=
    (contDiff_frameChristoffel g).comp contDiff_fst
  exact (contDiff_fst.fst.add (contDiff_fst.snd.clm_apply contDiff_snd)).sub
    ((hC.clm_apply contDiff_snd |>.clm_apply contDiff_snd).const_smul (1/2 : ℝ))

lemma contDiff_normalMetricFamily_apply (g : SmoothMetric E E) (v w : E) :
    ContDiff ℝ ∞ (fun q : (E × (E →L[ℝ] E)) × E =>
      normalMetricTensor g q.1.1 q.1.2 q.2 v w) := by
  have hC : ContDiff ℝ ∞ (fun q : (E × (E →L[ℝ] E)) × E =>
      ((metricChristoffel g q.1.1).bilinearComp q.1.2 q.1.2) q.2) :=
    ((contDiff_frameChristoffel g).comp contDiff_fst).clm_apply contDiff_snd
  have hD := (show ContDiff ℝ ∞ (fun q : (E × (E →L[ℝ] E)) × E => q.1.2) from contDiff_fst.snd).sub hC
  exact (((contDiff_selfMetricFlat g).comp (contDiff_normalJetFamily g)).clm_apply
    (hD.clm_apply contDiff_const)).clm_apply (hD.clm_apply contDiff_const)

theorem compact_normal_coordinate_radius [Nontrivial E] (g : SmoothMetric E E)
    {K : Set E} (hK : IsCompact K) :
    ∃ r : ℝ≥0, 0 < r ∧ ∀ q ∈ metricFrameSet g K,
      ∃ e : OpenPartialHomeomorph E E,
        (e : E → E) = normalJetMap q.1 q.2
          ((metricChristoffel g q.1).bilinearComp q.2 q.2) ∧
        e.source = Metric.ball 0 r ∧ ContDiffOn ℝ ∞ e.symm e.target := by
  obtain ⟨R,hR,hRb⟩ := metricFrameSet_inverse_bound g hK
  obtain ⟨B,hBb⟩ := (metricFrameSet_isCompact g hK).exists_bound_of_continuousOn
    (f := fun q : E × (E →L[ℝ] E) =>
      (metricChristoffel g q.1).bilinearComp q.2 q.2)
    (contDiff_frameChristoffel g).continuous.continuousOn
  let r : ℝ≥0 := ⟨(2*(R+1)*(max B 0+1))⁻¹, by positivity⟩
  have hr : 0 < r := by change 0 < (2*(R+1)*(max B 0+1))⁻¹; positivity
  refine ⟨r,hr,?_⟩
  intro q hq
  obtain ⟨A,hA⟩ := metricFrameSet_equiv g hq
  let C := (metricChristoffel g q.1).bilinearComp q.2 q.2
  have hAi : (A.symm : E →L[ℝ] E) = q.2.inverse := by
    rw [←hA, ContinuousLinearMap.inverse_equiv]
  have hAiPos : 0 < ‖(A.symm : E →L[ℝ] E)‖₊ := by
    rw [nnnorm_pos]
    intro hz
    obtain ⟨v,hv⟩ := exists_ne (0 : E)
    have hh := congrArg (fun T : E →L[ℝ] E => T (A v)) hz
    simp only [ContinuousLinearEquiv.coe_coe, A.symm_apply_apply, _root_.zero_apply] at hh
    exact hv hh
  have hb : ‖(A.symm : E →L[ℝ] E)‖ * (‖C‖ * (r : ℝ)) < 1 := by
    have hi : ‖(A.symm : E →L[ℝ] E)‖ ≤ R := by rw [hAi]; exact hRb q hq
    have hc : ‖C‖ ≤ max B 0 := (hBb q hq).trans (le_max_left _ _)
    have hm : ‖(A.symm : E →L[ℝ] E)‖ * (‖C‖ * (r : ℝ)) ≤
        R * (max B 0 * (2*(R+1)*(max B 0+1))⁻¹) := by
      change ‖(A.symm : E →L[ℝ] E)‖ * (‖C‖ * (2*(R+1)*(max B 0+1))⁻¹) ≤ _
      gcongr
    apply lt_of_le_of_lt hm
    rw [←mul_assoc, ←div_eq_mul_inv, div_lt_one (by positivity)]
    nlinarith [le_max_right B 0]
  have hsmall : ‖C‖₊ * r < ‖(A.symm : E →L[ℝ] E)‖₊⁻¹ := by
    have hnn : ‖(A.symm : E →L[ℝ] E)‖₊ * (‖C‖₊ * r) < 1 := by exact_mod_cast hb
    simpa only [mul_one] using (lt_inv_mul_iff₀ hAiPos).mpr hnn
  obtain ⟨e,he,hs,hi⟩ := normalJetMap_uniform_inverse q.1 A C
    (fun v w => metricChristoffel_symm g q.1 (q.2 v) (q.2 w)) r hsmall
  exact ⟨e, by simpa only [hA] using he, hs, hi⟩

end

section
open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open MvPolynomial
open Set Filter
open scoped ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open scoped Topology
open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Matrix
open scoped Topology Matrix.Norms.Elementwise
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
variable {P E F G : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P]
  [NormedAddCommGroup E] [NormedSpace ℝ E] [NormedAddCommGroup F] [NormedSpace ℝ F]
  [NormedAddCommGroup G] [NormedSpace ℝ G]
lemma normal_iteratedFDeriv_comp_clm_at (L : F →L[ℝ] E) {f : E → G} {x : F} (n : ℕ)
    (hf : ContDiffAt ℝ n f (L x)) :
    iteratedFDeriv ℝ n (f ∘ L) x =
      (iteratedFDeriv ℝ n f (L x)).compContinuousLinearMap (fun _ => L) := by
  obtain ⟨U,hU,hu⟩ := hf.contDiffOn le_rfl (by simp)
  obtain ⟨V,hVU,hVo,hx⟩ := mem_nhds_iff.mp hU
  have he := L.iteratedFDerivWithin_comp_right (hu.mono hVU) hVo.uniqueDiffOn
    (hVo.preimage L.continuous).uniqueDiffOn hx (le_refl (n : WithTop ℕ∞))
  rw [iteratedFDerivWithin_of_isOpen n hVo hx,
    iteratedFDerivWithin_of_isOpen n (hVo.preimage L.continuous) hx] at he
  exact he

lemma parameter_iteratedFDeriv (f : P × E → F) (t : P) (x : E) (n : ℕ)
    (hf : ContDiffAt ℝ n f (t,x)) :
    iteratedFDeriv ℝ n (fun y => f (t,y)) x =
      (iteratedFDeriv ℝ n f (t,x)).compContinuousLinearMap
        (fun _ => ContinuousLinearMap.inr ℝ P E) := by
  let L := ContinuousLinearMap.inr ℝ P E
  let q : P × E → F := fun z => f ((t,0)+z)
  have hq : ContDiffAt ℝ n q (L x) := by
    have hg : ContDiffAt ℝ n (fun z : P × E => (t,0)+z) (L x) := by fun_prop
    exact (show ContDiffAt ℝ n f ((t,0)+L x) by simpa [L] using hf).comp (L x) hg
  have hj := normal_iteratedFDeriv_comp_clm_at L n hq
  simpa [q,L,Function.comp_def,iteratedFDeriv_comp_add_left] using hj

lemma continuousAt_parameter_iteratedFDeriv (f : P × E → F) {z : P × E} (n : ℕ)
    (hf : ContDiffAt ℝ ∞ f z) :
    ContinuousAt (fun w : P × E => iteratedFDeriv ℝ n (fun y => f (w.1,y)) w.2) z := by
  have hc := (ContinuousMultilinearMap.continuous_precomp
    (fun _ : Fin n => ContinuousLinearMap.inr ℝ P E)).continuousAt.comp
      (hf.continuousAt_iteratedFDeriv (k := n) (ENat.natCast_le_of_coe_top_le_withTop le_rfl n))
  apply hc.congr_of_eventuallyEq
  filter_upwards [(hf.of_le (show (n : WithTop ℕ∞) ≤ (∞ : WithTop ℕ∞) from ENat.natCast_le_of_coe_top_le_withTop le_rfl n)).eventually (by simp)] with w hw
  exact parameter_iteratedFDeriv f w.1 w.2 n hw


end

section
open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open MvPolynomial
open Set Filter
open scoped ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open scoped Topology
open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Matrix
open scoped Topology Matrix.Norms.Elementwise
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
section ParameterDerivative
variable {P E F : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P]
  [NormedAddCommGroup E] [NormedSpace ℝ E] [NormedAddCommGroup F] [NormedSpace ℝ F]
lemma parameter_fderiv_apply (f : P × E → F) (hf : Differentiable ℝ f)
    (p : P) (x v : E) :
    fderiv ℝ (fun y => f (p,y)) x v = fderiv ℝ f (p,x) (0,v) := by
  have h := (hf (p,x)).hasFDerivAt.comp x
    ((hasFDerivAt_const p x).prodMk (hasFDerivAt_id x))
  exact congrArg (fun T => T v) h.fderiv

lemma contDiff_parameter_fderiv_apply (f : P × E → F) (hf : ContDiff ℝ ∞ f) (v : E) :
    ContDiff ℝ ∞ (fun q : P × E => fderiv ℝ (fun x => f (q.1,x)) q.2 v) := by
  simp only [parameter_fderiv_apply f (hf.differentiable (by simp))]
  exact (hf.fderiv_right (by simp)).clm_apply contDiff_const

lemma continuous_parameter_iteratedFDeriv (f : P × E → F) (hf : ContDiff ℝ ∞ f) (k : ℕ) :
    Continuous (fun q : P × E => iteratedFDeriv ℝ k (fun x => f (q.1,x)) q.2) :=
  continuous_iff_continuousAt.mpr (fun _ => continuousAt_parameter_iteratedFDeriv f k hf.contDiffAt)
end ParameterDerivative

variable {P ι : Type*} [NormedAddCommGroup P] [NormedSpace ℝ P]
  [Fintype ι] [DecidableEq ι]
lemma contDiff_matrix_det (A : P → Matrix ι ι ℝ)
    (hA : ∀ i j, ContDiff ℝ ∞ (fun p => A p i j)) :
    ContDiff ℝ ∞ (fun p => (A p).det) := by
  simp only [Matrix.det_apply']
  apply ContDiff.sum
  intro σ _
  apply contDiff_const.mul
  apply contDiff_prod
  intro i _
  exact hA _ _

lemma contDiff_matrix_adjugate (A : P → Matrix ι ι ℝ)
    (hA : ∀ i j, ContDiff ℝ ∞ (fun p => A p i j)) (i j : ι) :
    ContDiff ℝ ∞ (fun p => (A p).adjugate i j) := by
  simp only [Matrix.adjugate_apply, Matrix.det_apply']
  apply ContDiff.sum
  intro σ _
  apply contDiff_const.mul
  apply contDiff_prod
  intro k _
  simp only [Matrix.updateRow_apply]
  split_ifs
  · exact contDiff_const
  · exact hA _ _

lemma contDiffOn_matrix_inv (A : P → Matrix ι ι ℝ)
    (hA : ∀ i j, ContDiff ℝ ∞ (fun p => A p i j)) (i j : ι) :
    ContDiffOn ℝ ∞ (fun p => (A p)⁻¹ i j) {p | (A p).det ≠ 0} := by
  simp only [Matrix.inv_def, Ring.inverse_eq_inv, Matrix.smul_apply, smul_eq_mul]
  exact ((contDiff_matrix_det A hA).contDiffOn.inv (fun _ hp => hp)).mul
    (contDiff_matrix_adjugate A hA i j).contDiffOn

end

section
open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open MvPolynomial
open Set Filter
open scoped ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open scoped Topology
open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Matrix
open scoped Topology Matrix.Norms.Elementwise
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set Filter Matrix
open scoped Topology ContDiff Matrix Matrix.Norms.Elementwise
abbrev NormalWaveSpace := EuclideanSpace ℝ (Fin 3)
abbrev NormalWaveParameter := NormalWaveSpace × (NormalWaveSpace →L[ℝ] NormalWaveSpace)

def normalWaveMetric (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    (q : NormalWaveParameter) (x : NormalWaveSpace) : Matrix (Fin 3) (Fin 3) ℝ :=
  fun i j => normalMetricTensor g q.1 q.2 x
    (EuclideanSpace.basisFun (Fin 3) ℝ i) (EuclideanSpace.basisFun (Fin 3) ℝ j)

lemma contDiff_normalWaveMetric (g : SmoothMetric NormalWaveSpace NormalWaveSpace) (i j : Fin 3) :
    ContDiff ℝ ∞ (fun q : NormalWaveParameter × NormalWaveSpace => normalWaveMetric g q.1 q.2 i j) :=
  contDiff_normalMetricFamily_apply g _ _

lemma normalWaveMetric_zero (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    {K : Set NormalWaveSpace} {q : NormalWaveParameter} (hq : q ∈ metricFrameSet g K) :
    normalWaveMetric g q 0 = 1 := by
  ext i j
  change normalMetricTensor g q.1 q.2 0 _ _ = _
  rw [normalMetricTensor_at_zero]
  change selfMetricFlat g q.1 (q.2 _) (q.2 _) = _
  rw [hq.2]
  exact (EuclideanSpace.basisFun (Fin 3) ℝ).inner_eq_ite i j

lemma normalWaveMetric_first_jet (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    (q : NormalWaveParameter) : HasFDerivAt (𝕜 := ℝ) (normalWaveMetric g q) 0 0 := by
  have hc (i j : Fin 3) : HasFDerivAt (𝕜 := ℝ) (fun x => normalWaveMetric g q x i j) 0 0 := by
    have h := (contDiff_normalMetricTensor_apply g q.1 q.2
      (EuclideanSpace.basisFun (Fin 3) ℝ i) (EuclideanSpace.basisFun (Fin 3) ℝ j)).differentiable (by simp) 0
    simpa only [normalWaveMetric, normalMetricTensor_normal_jet] using h.hasFDerivAt
  convert (hasFDerivAt_pi.mpr (fun i => hasFDerivAt_pi.mpr (fun j => hc i j))) using 1 <;> rfl

lemma hasFDerivAt_matrix_inv_zero {ι : Type*} [Fintype ι] [DecidableEq ι]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (A : E → Matrix ι ι ℝ) {x : E} (hA : HasFDerivAt (𝕜 := ℝ) A 0 x) (hdet : (A x).det ≠ 0) :
    HasFDerivAt (𝕜 := ℝ) (fun y => (A y)⁻¹) 0 x := by
  have hc (i j : ι) : ContDiffAt ℝ ∞ (fun M : Matrix ι ι ℝ => M⁻¹ i j) (A x) := by
    have hO : IsOpen {M : Matrix ι ι ℝ | M.det ≠ 0} :=
      isOpen_ne_fun (contDiff_matrix_det id (fun _ _ => by fun_prop)).continuous continuous_const
    exact (contDiffOn_matrix_inv id (fun _ _ => by fun_prop) i j _ hdet).contDiffAt
      (hO.mem_nhds hdet)
  have hi : DifferentiableAt ℝ (fun M : Matrix ι ι ℝ => M⁻¹) (A x) := by
    apply differentiableAt_pi.mpr
    intro i
    apply differentiableAt_pi.mpr
    intro j
    exact (hc i j).differentiableAt (by simp)
  have h := hi.hasFDerivAt.comp x hA
  erw [ContinuousLinearMap.comp_zero] at h
  exact h

lemma normalWaveInverse_first_jet (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    {K : Set NormalWaveSpace} {q : NormalWaveParameter} (hq : q ∈ metricFrameSet g K) :
    HasFDerivAt (𝕜 := ℝ) (fun x => (normalWaveMetric g q x)⁻¹) 0 0 :=
  hasFDerivAt_matrix_inv_zero _ (normalWaveMetric_first_jet g q) (by rw [normalWaveMetric_zero g hq]; simp)

theorem exists_normal_inverse_extension (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    {K : Set NormalWaveSpace} (hK : IsCompact K) :
    ∃ A : NormalWaveParameter × NormalWaveSpace → Matrix (Fin 3) (Fin 3) ℝ,
      ∃ d : NormalWaveParameter × NormalWaveSpace → ℝ,
      ContDiff ℝ ∞ A ∧ ContDiff ℝ ∞ d ∧
      ∃ O : Set (NormalWaveParameter × NormalWaveSpace), IsOpen O ∧
        metricFrameSet g K ×ˢ {(0 : NormalWaveSpace)} ⊆ O ∧
        ∀ q ∈ O, A q = (normalWaveMetric g q.1 q.2)⁻¹ ∧
          d q = (normalWaveMetric g q.1 q.2).det⁻¹ := by
  let G := fun q : NormalWaveParameter × NormalWaveSpace => normalWaveMetric g q.1 q.2
  let V := {q | (G q).det ≠ 0}
  have hG (i j : Fin 3) : ContDiff ℝ ∞ (fun q => G q i j) := contDiff_normalWaveMetric g i j
  have hV : IsOpen V := isOpen_ne_fun (contDiff_matrix_det G hG).continuous continuous_const
  have hc : IsCompact (metricFrameSet g K ×ˢ {(0 : NormalWaveSpace)}) :=
    (metricFrameSet_isCompact g hK).prod isCompact_singleton
  have hsub : metricFrameSet g K ×ˢ {(0 : NormalWaveSpace)} ⊆ V := by
    rintro ⟨q,x⟩ ⟨hq,hx⟩
    have hx0 : x = 0 := mem_singleton_iff.mp hx
    subst x
    change (normalWaveMetric g q 0).det ≠ 0
    rw [normalWaveMetric_zero g hq]
    simp
  have hF : ContDiffOn ℝ ∞ (fun q => ((G q)⁻¹,(G q).det⁻¹)) V := by
    apply ContDiffOn.prodMk
    · apply contDiffOn_pi.mpr
      intro i
      apply contDiffOn_pi.mpr
      intro j
      exact contDiffOn_matrix_inv G hG i j
    · exact (contDiff_matrix_det G hG).contDiffOn.inv (fun _ h => h)
  obtain ⟨ψ,hψ,he⟩ := smooth_extension_near_compact hc hV hsub hF
  obtain ⟨O,hO,hKO,hEq⟩ := mem_nhdsSet_iff_exists.mp he
  refine ⟨fun q => (ψ q).1,fun q => (ψ q).2,hψ.fst,hψ.snd,O,hO,hKO,?_⟩
  intro q hq
  have hh := hEq hq
  exact ⟨(congrArg Prod.fst hh).symm,(congrArg Prod.snd hh).symm⟩

def normalWaveFirstCoefficient (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    (q : NormalWaveParameter) (x : NormalWaveSpace) (j : Fin 3) : ℝ :=
  ∑ i, (fderiv ℝ (fun y => (normalWaveMetric g q y)⁻¹ i j) x
      (EuclideanSpace.basisFun (Fin 3) ℝ i) +
    (1/2 : ℝ) * (normalWaveMetric g q x)⁻¹ i j * (normalWaveMetric g q x).det⁻¹ *
      fderiv ℝ (fun y => (normalWaveMetric g q y).det) x
        (EuclideanSpace.basisFun (Fin 3) ℝ i))

lemma normalWaveMetric_det_first_jet (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    (q : NormalWaveParameter) : HasFDerivAt (𝕜 := ℝ)
      (fun x => (normalWaveMetric g q x).det) 0 0 := by
  have hd := (contDiff_matrix_det (id : Matrix (Fin 3) (Fin 3) ℝ → _) (fun _ _ => by fun_prop)).differentiable (by simp)
  have h := (hd (normalWaveMetric g q 0)).hasFDerivAt.comp 0
    (normalWaveMetric_first_jet g q)
  erw [ContinuousLinearMap.comp_zero] at h
  exact h

lemma normalWaveFirstCoefficient_zero (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    {K : Set NormalWaveSpace} {q : NormalWaveParameter} (hq : q ∈ metricFrameSet g K) :
    normalWaveFirstCoefficient g q 0 = 0 := by
  let : ContinuousSMul ℝ NormalWaveSpace := IsBoundedSMul.continuousSMul
  funext j
  have hi := normalWaveInverse_first_jet g hq
  have hc (i j : Fin 3) : fderiv ℝ (fun y => (normalWaveMetric g q y)⁻¹ i j) 0 = 0 := by
    have h1 := (ContinuousLinearMap.proj i : Matrix (Fin 3) (Fin 3) ℝ →L[ℝ] (Fin 3 → ℝ)).hasFDerivAt.comp 0 hi
    have h2 := (ContinuousLinearMap.proj j : (Fin 3 → ℝ) →L[ℝ] ℝ).hasFDerivAt.comp 0 h1
    have h := h2.fderiv
    erw [ContinuousLinearMap.comp_zero] at h
    exact h
  simp [normalWaveFirstCoefficient,hc,(normalWaveMetric_det_first_jet g q).fderiv]

theorem exists_normal_wave_coefficients (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    {K : Set NormalWaveSpace} (hK : IsCompact K) :
    ∃ A : NormalWaveParameter × NormalWaveSpace → Matrix (Fin 3) (Fin 3) ℝ,
      ∃ b : NormalWaveParameter × NormalWaveSpace → Fin 3 → ℝ,
      ContDiff ℝ ∞ A ∧ ContDiff ℝ ∞ b ∧
      ∃ r > 0, ∀ q ∈ metricFrameSet g K,
        A (q,0) = 1 ∧ HasFDerivAt (𝕜 := ℝ) (fun x => A (q,x)) 0 0 ∧ b (q,0) = 0 ∧
        ∀ x ∈ Metric.ball (0 : NormalWaveSpace) r,
          A (q,x) = (normalWaveMetric g q x)⁻¹ ∧ b (q,x) = normalWaveFirstCoefficient g q x := by
  obtain ⟨A,d,hA,hd,O,hO,hsub,he⟩ := exists_normal_inverse_extension g hK
  let b := fun q : NormalWaveParameter × NormalWaveSpace => fun j : Fin 3 =>
    ∑ i, (fderiv ℝ (fun x => A (q.1,x) i j) q.2 (EuclideanSpace.basisFun (Fin 3) ℝ i) +
      (1/2 : ℝ) * A q i j * d q * fderiv ℝ (fun x => (normalWaveMetric g q.1 x).det) q.2
        (EuclideanSpace.basisFun (Fin 3) ℝ i))
  have hb : ContDiff ℝ ∞ b := by
    apply contDiff_pi.mpr
    intro j
    dsimp only [b]
    apply ContDiff.sum
    intro i _
    apply ContDiff.add
    · exact contDiff_parameter_fderiv_apply (fun q => A q i j) (contDiff_pi.mp (contDiff_pi.mp hA i) j) _
    · exact ((contDiff_const.mul (contDiff_pi.mp (contDiff_pi.mp hA i) j)).mul hd).mul
        (contDiff_parameter_fderiv_apply _
          (contDiff_matrix_det _ (contDiff_normalWaveMetric g)) _)
  have hgerm (q : NormalWaveParameter) (x : NormalWaveSpace) (hx : (q,x) ∈ O) :
      (fun y => A (q,y)) =ᶠ[𝓝 x] (fun y => (normalWaveMetric g q y)⁻¹) := by
    have ht : Tendsto (fun y : NormalWaveSpace => (q,y)) (𝓝 x) (𝓝 (q,x)) :=
      (continuous_const.prodMk continuous_id).continuousAt
    filter_upwards [ht (hO.mem_nhds hx)] with y hy
    exact (he (q,y) hy).1
  have hbe (q : NormalWaveParameter) (x : NormalWaveSpace) (hx : (q,x) ∈ O) :
      b (q,x) = normalWaveFirstCoefficient g q x := by
    funext j
    dsimp only [b,normalWaveFirstCoefficient]
    apply Finset.sum_congr rfl
    intro i _
    have hg : (fun y => A (q,y) i j) =ᶠ[𝓝 x] (fun y => (normalWaveMetric g q y)⁻¹ i j) :=
      (hgerm q x hx).fun_comp (fun M => M i j)
    rw [hg.fderiv_eq,(he (q,x) hx).1,(he (q,x) hx).2]
  obtain ⟨U,V,hU,hV,hKU,h0V,hUV⟩ := generalized_tube_lemma (metricFrameSet_isCompact g hK)
    isCompact_singleton hO hsub
  obtain ⟨r,hr,hrV⟩ := Metric.isOpen_iff.mp hV 0 (h0V (mem_singleton 0))
  refine ⟨A,b,hA,hb,r,hr,?_⟩
  intro q hq
  have hq0 : (q,0) ∈ O := hsub ⟨hq,mem_singleton 0⟩
  refine ⟨?_,?_,?_,?_⟩
  · rw [(he (q,0) hq0).1,normalWaveMetric_zero g hq]; simp
  · exact (normalWaveInverse_first_jet g hq).congr_of_eventuallyEq (hgerm q 0 hq0)
  · rw [hbe q 0 hq0,normalWaveFirstCoefficient_zero g hq]
  · intro x hx
    have hqx : (q,x) ∈ O := hUV ⟨hKU hq,hrV hx⟩
    exact ⟨(he (q,x) hqx).1,hbe q x hqx⟩


end

section
open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open MvPolynomial
open Set Filter
open scoped ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open scoped Topology
open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Matrix
open scoped Topology Matrix.Norms.Elementwise
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set Filter Matrix
open scoped Topology ContDiff Matrix.Norms.Elementwise
section Density
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]

lemma density_first_derivative {d a : E → ℝ} {x : E}
    (hd : DifferentiableAt ℝ d x) (ha : DifferentiableAt ℝ a x)
    (hx : 0 < d x) (v : E) :
    (Real.sqrt (d x))⁻¹ * fderiv ℝ (fun y => Real.sqrt (d y) * a y) x v =
      fderiv ℝ a x v + (1/2 : ℝ) * a x * (d x)⁻¹ * fderiv ℝ d x v := by
  erw [fderiv_fun_mul (hd.sqrt hx.ne') ha, _root_.add_apply]
  simp only [_root_.smul_apply, smul_eq_mul, fderiv_sqrt hd hx.ne']
  have hs : Real.sqrt (d x) ≠ 0 := (Real.sqrt_pos.mpr hx).ne'
  have hs2 : Real.sqrt (d x) ^ 2 = d x := Real.sq_sqrt hx.le
  field_simp
  rw [hs2]
  ring
end Density

lemma normalWaveDensity_firstCoefficient (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    (q : NormalWaveParameter) {x : NormalWaveSpace}
    (hx : 0 < (normalWaveMetric g q x).det) (j : Fin 3) :
    (Real.sqrt (normalWaveMetric g q x).det)⁻¹ *
      ∑ i, fderiv ℝ (fun y => Real.sqrt (normalWaveMetric g q y).det *
        (normalWaveMetric g q y)⁻¹ i j) x (EuclideanSpace.basisFun (Fin 3) ℝ i) =
      normalWaveFirstCoefficient g q x j := by
  rw [Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro i hi
  have hG (i j : Fin 3) : ContDiff ℝ ∞ (fun y => normalWaveMetric g q y i j) :=
    (contDiff_normalMetricTensor_apply g q.1 q.2
      (EuclideanSpace.basisFun (Fin 3) ℝ i) (EuclideanSpace.basisFun (Fin 3) ℝ j))
  have hd := (contDiff_matrix_det _ hG).differentiable (by simp) x
  have hO : IsOpen {y : NormalWaveSpace | (normalWaveMetric g q y).det ≠ 0} :=
    isOpen_ne_fun (contDiff_matrix_det _ hG).continuous continuous_const
  have ha := (contDiffOn_matrix_inv (normalWaveMetric g q) hG i j x hx.ne').contDiffAt
    (hO.mem_nhds hx.ne')
  exact density_first_derivative hd (ha.differentiableAt (by simp)) hx _

lemma compact_family_positive_radius {P E : Type*} [TopologicalSpace P]
    [NormedAddCommGroup E] {K : Set P} (hK : IsCompact K)
    (f : P × E → ℝ) (hf : Continuous f) (hpos : ∀ p ∈ K, 0 < f (p,0)) :
    ∃ r > 0, ∀ p ∈ K, ∀ x ∈ Metric.ball (0 : E) r, 0 < f (p,x) := by
  let O : Set (P × E) := {q | 0 < f q}
  have hO : IsOpen O := isOpen_lt continuous_const hf
  have hsub : K ×ˢ {(0 : E)} ⊆ O := by
    rintro ⟨p,x⟩ ⟨hp,hx⟩
    change 0 < f (p,x)
    have hx0 : x = 0 := hx
    rw [hx0]
    exact hpos p hp
  obtain ⟨U,V,hU,hV,hKU,h0V,hUV⟩ := generalized_tube_lemma hK
    isCompact_singleton hO hsub
  obtain ⟨r,hr,hrV⟩ := Metric.isOpen_iff.mp hV 0 (h0V (mem_singleton 0))
  exact ⟨r,hr,fun p hp x hx => hUV ⟨hKU hp,hrV hx⟩⟩

lemma compact_normal_density_radius (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    {K : Set NormalWaveSpace} (hK : IsCompact K) :
    ∃ r > 0, ∀ q ∈ metricFrameSet g K, ∀ x ∈ Metric.ball (0 : NormalWaveSpace) r,
      0 < (normalWaveMetric g q x).det := by
  apply compact_family_positive_radius (metricFrameSet_isCompact g hK)
    (fun q : NormalWaveParameter × NormalWaveSpace => (normalWaveMetric g q.1 q.2).det)
    (contDiff_matrix_det _ (contDiff_normalWaveMetric g)).continuous
  intro q hq
  rw [normalWaveMetric_zero g hq]
  simp

end

section
open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open MvPolynomial
open Set Filter
open scoped ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open scoped Topology
open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Matrix
open scoped Topology Matrix.Norms.Elementwise
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set Filter Matrix
open scoped Topology ContDiff Matrix.Norms.Elementwise

abbrev normalWaveEquiv : (Fin 3 → ℝ) ≃L[ℝ] NormalWaveSpace :=
  (PiLp.continuousLinearEquiv 2 ℝ (fun _ : Fin 3 => ℝ)).symm

lemma normalWaveEquiv_single (i : Fin 3) :
    normalWaveEquiv (Pi.single i 1) = EuclideanSpace.basisFun (Fin 3) ℝ i := by
  rw [EuclideanSpace.basisFun_apply]
  rfl

theorem exists_normal_wave_pi_coefficients (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    {K : Set NormalWaveSpace} (hK : IsCompact K) :
    ∃ A : NormalWaveParameter × (Fin 3 → ℝ) → Matrix (Fin 3) (Fin 3) ℂ,
      ∃ b : NormalWaveParameter × (Fin 3 → ℝ) → Fin 3 → ℂ,
      ContDiff ℝ ∞ A ∧ ContDiff ℝ ∞ b ∧
      ∃ r > 0, ∀ q ∈ metricFrameSet g K,
        (∀ i j, A (q,0) i j = if i = j then 1 else 0) ∧
        (∀ i j, fderiv ℝ (fun x => A (q,x) i j) 0 = 0) ∧
        b (q,0) = 0 ∧
        ∀ x, ‖normalWaveEquiv x‖ < r →
          (∀ i j, A (q,x) i j = ((normalWaveMetric g q (normalWaveEquiv x))⁻¹ i j : ℂ)) ∧
          (∀ j, b (q,x) j = (normalWaveFirstCoefficient g q (normalWaveEquiv x) j : ℂ)) := by
  obtain ⟨A,b,hA,hb,r,hr,he⟩ := exists_normal_wave_coefficients g hK
  let Ap := fun q : NormalWaveParameter × (Fin 3 → ℝ) =>
    fun i j : Fin 3 => (A (q.1,normalWaveEquiv q.2) i j : ℂ)
  let bp := fun q : NormalWaveParameter × (Fin 3 → ℝ) =>
    fun j : Fin 3 => (b (q.1,normalWaveEquiv q.2) j : ℂ)
  have hT : ContDiff ℝ ∞ (fun q : NormalWaveParameter × (Fin 3 → ℝ) => (q.1,normalWaveEquiv q.2)) :=
    contDiff_fst.prodMk (normalWaveEquiv.contDiff.comp contDiff_snd)
  have hAp : ContDiff ℝ ∞ Ap := by
    apply contDiff_pi.mpr
    intro i
    apply contDiff_pi.mpr
    intro j
    exact Complex.ofRealCLM.contDiff.comp ((contDiff_pi.mp (contDiff_pi.mp hA i) j).comp hT)
  have hbp : ContDiff ℝ ∞ bp := by
    apply contDiff_pi.mpr
    intro j
    exact Complex.ofRealCLM.contDiff.comp ((contDiff_pi.mp hb j).comp hT)
  refine ⟨Ap,bp,hAp,hbp,r,hr,?_⟩
  intro q hq
  obtain ⟨h0,hd,hb0,heq⟩ := he q hq
  refine ⟨?_,?_,?_,?_⟩
  · intro i j
    simp only [Ap,map_zero,h0,Matrix.one_apply]
    split_ifs <;> simp
  · intro i j
    let L : Matrix (Fin 3) (Fin 3) ℝ →L[ℝ] ℂ :=
      Complex.ofRealCLM.comp ((ContinuousLinearMap.proj j : (Fin 3 → ℝ) →L[ℝ] ℝ).comp
        (ContinuousLinearMap.proj i : Matrix (Fin 3) (Fin 3) ℝ →L[ℝ] (Fin 3 → ℝ)))
    have hf := (L.hasFDerivAt.comp 0 hd).comp 0 normalWaveEquiv.hasFDerivAt
    have hf' : HasFDerivAt (fun x => Ap (q,x) i j)
        ((L.comp 0).comp normalWaveEquiv.toContinuousLinearMap) 0 := hf
    simpa only [ContinuousLinearMap.comp_zero,ContinuousLinearMap.zero_comp] using hf'.fderiv
  · ext j
    simp [bp,hb0]
  · intro x hx
    have h := heq (normalWaveEquiv x) (by simpa only [Metric.mem_ball,dist_zero_right] using hx)
    exact ⟨fun i j => by dsimp [Ap]; rw [h.1],fun j => by dsimp [bp]; rw [h.2]⟩

lemma normal_profile_family_smooth (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    (φ : NormalWaveSpace → ℝ) (hφ : ContDiff ℝ ∞ φ) :
    ContDiff ℝ ∞ (fun q : NormalWaveParameter × NormalWaveSpace =>
      φ (normalJetMap q.1.1 q.1.2 ((metricChristoffel g q.1.1).bilinearComp q.1.2 q.1.2) q.2)) :=
  hφ.comp (contDiff_normalJetFamily g)


end

open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open MvPolynomial
open Set Filter
open scoped ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter Function MvPolynomial
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open Set Filter Function
open scoped Topology ContDiff
open scoped Topology
open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Matrix
open scoped Topology Matrix.Norms.Elementwise
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set Filter
open scoped Topology ContDiff

lemma contDiff_smoothFiniteWave {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    {S : E → ℂ} {V : ℕ → E → ℂ} (hS : ContDiff ℝ ∞ S)
    (hV : ∀ j, ContDiff ℝ ∞ (V j)) (J : ℕ) (n : ℝ) :
    ContDiff ℝ ∞ (smoothFiniteWave S V J n) := by
  unfold smoothFiniteWave
  exact (contDiff_const.mul hS).cexp.mul
    (ContDiff.sum (fun j _ => contDiff_const.mul (hV j)))

lemma contDiff_canonicalCutoffWave
    (A : Fin 3 → Fin 3 → (Fin 3 → ℝ) → ℂ) (b : Fin 3 → (Fin 3 → ℝ) → ℂ)
    (s : ℂ) (z : Fin 3 → ℂ) (Q : ComplexPhaseMatrix)
    (ζ : (Fin 3 → ℝ) → ℂ) (hζ : ContDiff ℝ ∞ ζ) (m D : ℕ) (n : ℝ) :
    ContDiff ℝ ∞ (canonicalCutoffWave A b s z Q ζ m D n) :=
  contDiff_smoothFiniteWave (contDiff_realPolyEval _)
    (fun _ => hζ.mul (contDiff_realPolyEval _)) _ _

def normalWavePiOperator (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    (q : NormalWaveParameter) (f : (Fin 3 → ℝ) → ℂ) (x : Fin 3 → ℝ) : ℂ :=
  waveCoordinateOperator (EuclideanSpace.basisFun (Fin 3) ℝ)
    (fun i j y => ((normalWaveMetric g q y)⁻¹ i j : ℂ))
    (fun j y => (normalWaveFirstCoefficient g q y j : ℂ))
    (f ∘ normalWaveEquiv.symm) (normalWaveEquiv x)

lemma normalWavePiOperator_eq (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    (q : NormalWaveParameter) {f : (Fin 3 → ℝ) → ℂ} (hf : ContDiff ℝ ∞ f)
    (x : Fin 3 → ℝ) :
    normalWavePiOperator g q f x =
      waveCoordinateOperator (fun i => Pi.single i 1)
        (fun i j y => ((normalWaveMetric g q (normalWaveEquiv y))⁻¹ i j : ℂ))
        (fun j y => (normalWaveFirstCoefficient g q (normalWaveEquiv y) j : ℂ)) f x := by
  have h := waveCoordinateOperator_comp_linear normalWaveEquiv.toContinuousLinearMap
    (fun i => Pi.single i 1)
    (fun i j y => ((normalWaveMetric g q y)⁻¹ i j : ℂ))
    (fun j y => (normalWaveFirstCoefficient g q y j : ℂ))
    (hf.comp normalWaveEquiv.symm.contDiff) x
  simpa only [normalWavePiOperator,Function.comp_def,ContinuousLinearEquiv.coe_coe,
    normalWaveEquiv_single,ContinuousLinearEquiv.symm_apply_apply] using h.symm

lemma normalWavePiOperator_eq_extension (g : SmoothMetric NormalWaveSpace NormalWaveSpace)
    (q : NormalWaveParameter) {f : (Fin 3 → ℝ) → ℂ} (hf : ContDiff ℝ ∞ f)
    (A : Fin 3 → Fin 3 → (Fin 3 → ℝ) → ℂ) (b : Fin 3 → (Fin 3 → ℝ) → ℂ)
    (x : Fin 3 → ℝ)
    (hA : ∀ i j, A i j x = ((normalWaveMetric g q (normalWaveEquiv x))⁻¹ i j : ℂ))
    (hb : ∀ j, b j x = (normalWaveFirstCoefficient g q (normalWaveEquiv x) j : ℂ)) :
    normalWavePiOperator g q f x = waveCoordinateOperator (fun i => Pi.single i 1) A b f x := by
  rw [normalWavePiOperator_eq g q hf]
  simp only [waveCoordinateOperator,hA,hb]



end YauCounterexamples
end

end OAI