lean/OAI/Geometry/SmoothYau/Smoothness/ContinuousCompactSmoothJets.lean

import Mathlib
import OAI.Geometry.SmoothYau.Smoothness.ChartTensorCoordLocal1

namespace OAI

noncomputable section
namespace YauCounterexamples
section
open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set Filter Metric
open scoped Topology InnerProductSpace
open Set Filter Function Metric
open scoped Topology
open Set Filter Function Metric
open scoped Topology
open Set Filter Manifold
open scoped Topology ContDiff Matrix.Norms.Elementwise
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E]
local instance mcfDualNorm : NormedAddCommGroup (E →L[ℝ] ℝ) := inferInstance
local instance mcfDualSpace : NormedSpace ℝ (E →L[ℝ] ℝ) := inferInstance
local instance mcfFormNorm : NormedAddCommGroup (CoordinateForm E) := inferInstance
local instance mcfFormSpace : NormedSpace ℝ (CoordinateForm E) := inferInstance
private local instance mcfMatrixMapNorm {ι κ : Type*} [Fintype ι] [Fintype κ] :
    NormedAddCommGroup (Matrix ι κ ℝ →L[ℝ] CoordinateForm (E)) :=
  inferInstanceAs (NormedAddCommGroup ((ι → κ → ℝ) →L[ℝ] CoordinateForm (E)))
private local instance mcfMapMatrixNorm {ι κ : Type*} [Fintype ι] [Fintype κ] :
    NormedAddCommGroup (E →L[ℝ] Matrix ι κ ℝ) :=
  inferInstanceAs (NormedAddCommGroup (E →L[ℝ] (ι → κ → ℝ)))

def metricMatrixFormCLM : Matrix (CoordIndex E) (CoordIndex E) ℝ →L[ℝ] CoordinateForm E :=
  ({ toFun := metricMatrixForm
     map_add' := by
       intro A B
       simp only [metricMatrixForm, Matrix.add_apply, add_smul, Finset.sum_add_distrib]
     map_smul' := by
       intro c A
       simp only [metricMatrixForm, Matrix.smul_apply, smul_eq_mul, mul_smul,
         Finset.smul_sum, RingHom.id_apply] } :
    Matrix (CoordIndex E) (CoordIndex E) ℝ →ₗ[ℝ] CoordinateForm E).toContinuousLinearMap

lemma metricMatrixFormCLM_apply (A : Matrix (CoordIndex E) (CoordIndex E) ℝ) :
    metricMatrixFormCLM A = (metricMatrixForm A : CoordinateForm E) := rfl

omit [FiniteDimensional ℝ E] in
lemma matrix_fderiv_norm_le {ι κ : Type*} [Fintype ι] [Fintype κ]
    {A : E → Matrix ι κ ℝ} {x : E} (hA : DifferentiableAt ℝ A x) {ε : ℝ} (hε : 0 ≤ ε)
    (hb : ∀ i j, ‖fderiv ℝ (fun y => A y i j) x‖ ≤ ε) :
    ‖fderiv ℝ A x‖ ≤ ε := by
  apply ContinuousLinearMap.opNorm_le_bound _ hε
  intro v
  apply (pi_norm_le_iff_of_nonneg (mul_nonneg hε (norm_nonneg v))).mpr
  intro i
  apply (pi_norm_le_iff_of_nonneg (mul_nonneg hε (norm_nonneg v))).mpr
  intro j
  have he : fderiv ℝ (fun y => A y i j) x v = (fderiv ℝ A x v) i j := by
    rw [fderiv_apply (differentiableAt_pi.mp hA i) j, fderiv_apply hA i]
    rfl
  erw [← he]
  exact (ContinuousLinearMap.le_opNorm _ _).trans (mul_le_mul_of_nonneg_right (hb i j) (norm_nonneg v))

theorem metricMatrixForm_first_jet_bound
    {A B : E → Matrix (CoordIndex E) (CoordIndex E) ℝ} {x : E}
    (hA : DifferentiableAt ℝ A x) (hB : DifferentiableAt ℝ B x)
    {ε : ℝ} (hε : 0 ≤ ε)
    (h₀ : ∀ i j, |A x i j-B x i j| ≤ ε)
    (h₁ : ∀ i j, ‖fderiv ℝ (fun y => A y i j-B y i j) x‖ ≤ ε) :
    ‖metricMatrixForm (A x)-metricMatrixForm (B x)‖ ≤ ‖metricMatrixFormCLM (E := E)‖*ε ∧
    ‖fderiv ℝ (fun y => metricMatrixForm (A y)) x-
      fderiv ℝ (fun y => metricMatrixForm (B y)) x‖ ≤ ‖metricMatrixFormCLM (E := E)‖*ε := by
  let L := metricMatrixFormCLM (E := E)
  have hF : DifferentiableAt ℝ (fun y => A y-B y) x := hA.sub hB
  have hn : ‖A x-B x‖ ≤ ε := by
    apply (pi_norm_le_iff_of_nonneg hε).mpr
    intro i
    apply (pi_norm_le_iff_of_nonneg hε).mpr
    intro j
    exact h₀ i j
  have hDn : ‖fderiv ℝ (fun y => A y-B y) x‖ ≤ ε := matrix_fderiv_norm_le hF hε h₁
  constructor
  · change ‖L (A x)-L (B x)‖ ≤ ‖L‖*ε
    rw [← map_sub]
    exact (L.le_opNorm _).trans (mul_le_mul_of_nonneg_left hn (norm_nonneg L))
  · have hLA : DifferentiableAt ℝ (fun y => metricMatrixForm (A y)) x := L.differentiableAt.comp x hA
    have hLB : DifferentiableAt ℝ (fun y => metricMatrixForm (B y)) x := L.differentiableAt.comp x hB
    rw [← fderiv_fun_sub hLA hLB]
    have he : (fun y => metricMatrixForm (A y)-metricMatrixForm (B y)) = fun y => L (A y-B y) := by
      funext y
      exact (map_sub L _ _).symm
    rw [he]
    have hd : fderiv ℝ (fun y => L (A y-B y)) x = L.comp (fderiv ℝ (fun y => A y-B y) x) :=
      (L.hasFDerivAt.comp x hF.hasFDerivAt).fderiv
    rw [hd]
    exact (L.opNorm_comp_le _).trans (mul_le_mul_of_nonneg_left hDn (norm_nonneg L))


end

section
open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set Filter Metric
open scoped Topology InnerProductSpace
open Set Filter Function Metric
open scoped Topology
open Set Filter Function Metric
open scoped Topology
open Set Filter Metric
open scoped Topology InnerProductSpace
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E]

local instance hmsDualNorm : NormedAddCommGroup (E →L[ℝ] ℝ) := inferInstance
local instance hmsDualSpace : NormedSpace ℝ (E →L[ℝ] ℝ) := inferInstance
local instance hmsFormNorm : NormedAddCommGroup (CoordinateForm E) := inferInstance
local instance hmsFormSpace : NormedSpace ℝ (CoordinateForm E) := inferInstance
local instance hmsDerivNorm : NormedAddCommGroup (E →L[ℝ] CoordinateForm E) := inferInstance
local instance hmsDerivSpace : NormedSpace ℝ (E →L[ℝ] CoordinateForm E) := inferInstance

abbrev HessianJetData (E : Type*) [NormedAddCommGroup E] [NormedSpace ℝ E] :=
  (CoordinateForm E × (E →L[ℝ] CoordinateForm E)) × ((E →L[ℝ] ℝ) × CoordinateForm E)

local instance hmsJetNorm : NormedAddCommGroup (HessianJetData E) := inferInstance
local instance hmsJetSpace : NormedSpace ℝ (HessianJetData E) := inferInstance

def christoffelFromJet (B : CoordinateForm E) (D : E →L[ℝ] CoordinateForm E) :
    E →L[ℝ] E →L[ℝ] E :=
  ((ContinuousLinearMap.compL ℝ E (E →L[ℝ] ℝ) E) B.inverse).comp (coordinateKoszul D)

def metricHessianFromFullJet (z : HessianJetData E) : CoordinateForm E :=
  z.2.2 - (ContinuousLinearMap.compL ℝ E E ℝ z.2.1).comp (christoffelFromJet z.1.1 z.1.2)

lemma continuous_coordinateKoszul : Continuous
    (coordinateKoszul : (E →L[ℝ] CoordinateForm E) → E →L[ℝ] CoordinateForm E) := by
  have hDf : Continuous (fun D : E →L[ℝ] CoordinateForm E => D.flip) :=
    (ContinuousLinearMap.flipₗᵢ ℝ E E (E →L[ℝ] ℝ)).toContinuousLinearMap.continuous
  exact ((continuous_id.add hDf).sub (continuous_const.clm_comp hDf)).const_smul (1/2 : ℝ)

lemma continuousAt_metricHessianFromFullJet {z : HessianJetData E} (hB : z.1.1.IsInvertible) :
    ContinuousAt (metricHessianFromFullJet : HessianJetData E → CoordinateForm E) z := by
  have hp : ContinuousAt (fun w : HessianJetData E => w.1.1) z :=
    continuous_fst.fst.continuousAt
  have hi : ContinuousAt (fun w : HessianJetData E => w.1.1.inverse) z :=
    (hB.contDiffAt_map_inverse (n := ∞)).continuousAt.comp (f := fun w : HessianJetData E => w.1.1) (x := z) hp
  have hK : Continuous (fun z : HessianJetData E => coordinateKoszul z.1.2) :=
    continuous_coordinateKoszul.comp continuous_fst.snd
  have hΓ : ContinuousAt (fun z : HessianJetData E => christoffelFromJet z.1.1 z.1.2) z :=
    (continuousAt_const.clm_apply hi).clm_comp hK.continuousAt
  exact continuous_snd.snd.continuousAt.sub
    ((continuousAt_const.clm_apply continuous_snd.fst.continuousAt).clm_comp hΓ)

def metricScalarJet (g : SmoothMetric E E) (f : E → ℝ) (x : E) : HessianJetData E :=
  ((selfMetricFlat g x,fderiv ℝ (selfMetricFlat g) x),
    (fderiv ℝ f x,fderiv ℝ (fderiv ℝ f) x))

lemma metricHessianFromFullJet_metricScalarJet (g : SmoothMetric E E) (f : E → ℝ) (x : E) :
    metricHessianFromFullJet (metricScalarJet g f x) = actualCoordinateHessian g f x := rfl

omit [FiniteDimensional ℝ E] in
lemma continuous_metricScalarJet (g : SmoothMetric E E) {f : E → ℝ} (hf : ContDiff ℝ ∞ f) :
    Continuous (metricScalarJet g f) := by
  exact ((contDiff_selfMetricFlat g).continuous.prodMk
      ((contDiff_selfMetricFlat g).continuous_fderiv (by simp))).prodMk
    ((hf.continuous_fderiv (by simp)).prodMk
      ((hf.fderiv_right (m := ∞) (by simp)).continuous_fderiv (by simp)))

def hessianJetMarginSet : Set (HessianJetData E) :=
    {z | hessianMargins z.1.1 (metricHessianFromFullJet z)}

lemma metricScalarJet_margin_interior (g : SmoothMetric E E) (f : E → ℝ) (x : E)
    (h : hessianMargins (selfMetricFlat g x) (actualCoordinateHessian g f x)) :
    metricScalarJet g f x ∈ interior (hessianJetMarginSet (E := E)) := by
  apply mem_interior_iff_mem_nhds.mpr
  have hc : ContinuousAt (fun z : HessianJetData E => (z.1.1,metricHessianFromFullJet z))
      (metricScalarJet g f x) :=
    continuous_fst.fst.continuousAt.prodMk
      (continuousAt_metricHessianFromFullJet (selfMetricFlat_invertible g x))
  exact hc ((isOpen_hessianMargins (E := E)).mem_nhds h)

omit [FiniteDimensional ℝ E] in
lemma dist_metricScalarJet_lt (g g₀ : SmoothMetric E E) (f : E → ℝ) (x : E)
    {δ : ℝ} (hδ : 0 < δ)
    (h₀ : ‖selfMetricFlat g x-selfMetricFlat g₀ x‖ < δ)
    (h₁ : ‖fderiv ℝ (selfMetricFlat g) x-fderiv ℝ (selfMetricFlat g₀) x‖ < δ) :
    dist (metricScalarJet g f x) (metricScalarJet g₀ f x) < δ := by
  change max (max (dist (selfMetricFlat g x) (selfMetricFlat g₀ x))
    (dist (fderiv ℝ (selfMetricFlat g) x) (fderiv ℝ (selfMetricFlat g₀) x)))
    (dist (fderiv ℝ f x,fderiv ℝ (fderiv ℝ f) x)
      (fderiv ℝ f x,fderiv ℝ (fderiv ℝ f) x)) < δ
  rw [dist_self, dist_eq_norm, dist_eq_norm]
  exact max_lt (max_lt h₀ h₁) hδ

lemma compact_map_uniform_interior {X Y : Type*} [TopologicalSpace X] [MetricSpace Y]
    {K : Set X} (hK : IsCompact K) {F : X → Y} (hF : Continuous F) {U : Set Y}
    (hU : ∀ x ∈ K, F x ∈ interior U) :
    ∃ δ > 0, ∀ x ∈ K, ∀ y, dist y (F x) < δ → y ∈ U := by
  have hi : F '' K ⊆ interior U := by
    rintro _ ⟨x,hx,rfl⟩
    exact hU x hx
  obtain ⟨δ,hδ,hδU⟩ := (hK.image hF).exists_thickening_subset_open isOpen_interior hi
  refine ⟨δ,hδ,?_⟩
  intro x hx y hy
  exact interior_subset (hδU (mem_thickening_iff.mpr ⟨F x,⟨x,hx,rfl⟩,hy⟩))

theorem compact_hessianMargins_stability (g₀ : SmoothMetric E E)
    {f : E → ℝ} (hf : ContDiff ℝ ∞ f) {K : Set E} (hK : IsCompact K)
    (hmargin : ∀ x ∈ K, hessianMargins (selfMetricFlat g₀ x) (actualCoordinateHessian g₀ f x)) :
    ∃ δ > 0, ∀ g : SmoothMetric E E,
      (∀ x ∈ K, ‖selfMetricFlat g x-selfMetricFlat g₀ x‖ < δ ∧
        ‖fderiv ℝ (selfMetricFlat g) x-fderiv ℝ (selfMetricFlat g₀) x‖ < δ) →
      ∀ x ∈ K, hessianMargins (selfMetricFlat g x) (actualCoordinateHessian g f x) := by
  obtain ⟨δ,hδ,hstable⟩ := compact_map_uniform_interior hK
    (continuous_metricScalarJet g₀ hf)
    (fun x hx => metricScalarJet_margin_interior g₀ f x (hmargin x hx))
  refine ⟨δ,hδ,?_⟩
  intro g hg x hx
  exact hstable x hx (metricScalarJet g f x)
    (dist_metricScalarJet_lt g g₀ f x hδ (hg x hx).1 (hg x hx).2)


end

section
open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set Filter Metric
open scoped Topology InnerProductSpace
open Set Filter Function Metric
open scoped Topology
open Set Filter Function Metric
open scoped Topology
open Set Filter Manifold
open scoped Topology ContDiff Matrix.Norms.Elementwise
variable {n : ℕ}
local instance spnENorm : NormedAddCommGroup (Euclidean n) := inferInstance
local instance spnESpace : NormedSpace ℝ (Euclidean n) := inferInstance
local instance spnDualNorm : NormedAddCommGroup (Euclidean n →L[ℝ] ℝ) := inferInstance
local instance spnDualSpace : NormedSpace ℝ (Euclidean n →L[ℝ] ℝ) := inferInstance
local instance spnFormNorm : NormedAddCommGroup (CoordinateForm (Euclidean n)) := inferInstance
local instance spnFormSpace : NormedSpace ℝ (CoordinateForm (Euclidean n)) := inferInstance
local instance spnDerivNorm : NormedAddCommGroup (Euclidean n →L[ℝ] CoordinateForm (Euclidean n)) := inferInstance
local instance spnDerivSpace : NormedSpace ℝ (Euclidean n →L[ℝ] CoordinateForm (Euclidean n)) := inferInstance
private local instance spnMatrixMapNorm {ι κ : Type*} [Fintype ι] [Fintype κ] :
    NormedAddCommGroup (Matrix ι κ ℝ →L[ℝ] CoordinateForm (Euclidean n)) :=
  inferInstanceAs (NormedAddCommGroup ((ι → κ → ℝ) →L[ℝ] CoordinateForm (Euclidean n)))

lemma sphere_metricCoefficients_smooth (g : SmoothMetric (Euclidean n) (Sphere n))
    (p : Sphere n) : ContDiff ℝ ∞ (metricCoefficients g p) := by
  apply contDiff_pi.mpr
  intro i
  apply contDiff_pi.mpr
  intro j
  exact contDiffOn_univ.mp (by
    simpa only [sphere_chart_target] using contDiffOn_metricCoefficient g p i j)

theorem sphere_metric_first_jet_neighborhood (g₀ : SmoothMetric (Euclidean n) (Sphere n))
    (p : Sphere n) {K : Set (Euclidean n)} (hK : IsCompact K) {δ : ℝ} (hδ : 0 < δ) :
    IsSmoothNeighborhood g₀ {g | ∀ x ∈ K,
      ‖selfMetricFlat (sphereChartMetric g p) x-selfMetricFlat (sphereChartMetric g₀ p) x‖ < δ ∧
      ‖fderiv ℝ (selfMetricFlat (sphereChartMetric g p)) x-
        fderiv ℝ (selfMetricFlat (sphereChartMetric g₀ p)) x‖ < δ} := by
  let L := metricMatrixFormCLM (E := Euclidean n)
  let ε := δ/(‖L‖+1)
  have hden : 0 < ‖L‖+1 := by positivity
  have hε : 0 < ε := div_pos hδ hden
  have hmul : ‖L‖*ε < δ := by
    calc
      ‖L‖*ε < (‖L‖+1)*ε := mul_lt_mul_of_pos_right (by linarith) hε
      _ = δ := by dsimp [ε]; field_simp
  let test : Fin 2 × CoordIndex (Euclidean n) × CoordIndex (Euclidean n) →
      CoordinateTest (Euclidean n) (Sphere n) := fun q =>
    { center := p, compactSet := K, isCompact := hK,
      inTarget := by rw [sphere_chart_target]; exact subset_univ K,
      order := q.1.val, row := q.2.1, column := q.2.2 }
  let tests := (Finset.univ : Finset (Fin 2 × CoordIndex (Euclidean n) × CoordIndex (Euclidean n))).toList.map test
  refine ⟨tests,ε,hε,?_⟩
  intro g hg x hx
  have htest (k : Fin 2) (i j : CoordIndex (Euclidean n)) : test (k,i,j) ∈ tests := by
    exact List.mem_map.mpr ⟨(k,i,j),by simp,rfl⟩
  have h₀ (i j : CoordIndex (Euclidean n)) :
      |metricCoefficients g p x i j-metricCoefficients g₀ p x i j| ≤ ε := by
    have hh := hg (test (0,i,j)) (htest 0 i j) x hx
    simpa only [test,Fin.val_zero,norm_iteratedFDeriv_zero,Real.norm_eq_abs] using hh.le
  have h₁ (i j : CoordIndex (Euclidean n)) :
      ‖fderiv ℝ (fun y => metricCoefficients g p y i j-metricCoefficients g₀ p y i j) x‖ ≤ ε := by
    have hh := hg (test (1,i,j)) (htest 1 i j) x hx
    simpa only [test,Fin.val_one,norm_iteratedFDeriv_one] using hh.le
  have hb := metricMatrixForm_first_jet_bound
    ((sphere_metricCoefficients_smooth g p).differentiable (by simp) x)
    ((sphere_metricCoefficients_smooth g₀ p).differentiable (by simp) x) hε.le h₀ h₁
  have he (g : SmoothMetric (Euclidean n) (Sphere n)) :
      selfMetricFlat (sphereChartMetric g p) = fun y => metricMatrixForm (metricCoefficients g p y) :=
    funext (sphereChartMetric_selfFlat g p)
  rw [he g,he g₀]
  exact ⟨hb.1.trans_lt hmul,hb.2.trans_lt hmul⟩

theorem sphericalBaseProfile_neighborhood (g₀ : SmoothMetric (Euclidean 3) (Sphere 3))
    (hg₀ : IsRound g₀) (p : Sphere 3) (a b : Euclidean 4)
    (ha : inner ℝ a a = 1) (hb : inner ℝ b b = 1) (hab : inner ℝ a b = 0)
    (t : ℝ) {K : Set (Euclidean 3)} (hK : IsCompact K)
    (hr : ∀ y ∈ K, (inner ℝ (roundChart (p : Euclidean 4) (sphereFrame p) y) a)^2 +
      (inner ℝ (roundChart (p : Euclidean 4) (sphereFrame p) y) b)^2 ≤ 1/8) :
    IsSmoothNeighborhood g₀ {g | ∀ y ∈ K,
      hessianMargins (selfMetricFlat (sphereChartMetric g p) y)
        (actualCoordinateHessian (sphereChartMetric g p)
          (sphericalBaseProfile a b t ∘ (chartAt (Euclidean 3) p).symm) y)} := by
  have hm (y : Euclidean 3) (hy : y ∈ K) :
      hessianMargins (selfMetricFlat (sphereChartMetric g₀ p) y)
        (actualCoordinateHessian (sphereChartMetric g₀ p)
          (sphericalBaseProfile a b t ∘ (chartAt (Euclidean 3) p).symm) y) := by
    have hh := sphericalBaseProfile_chart_margins g₀ hg₀ p a b ha hb hab t y (hr y hy)
    exact hessianMargins_of_strong _ _ (fun v hv => by
      rw [selfMetricFlat_apply]; exact (sphereChartMetric g₀ p).pos _ _ hv) hh.1 hh.2
  obtain ⟨δ,hδ,hstable⟩ := compact_hessianMargins_stability (sphereChartMetric g₀ p)
    (sphericalBaseProfile_chart_smooth p a b t) hK hm
  obtain ⟨tests,ε,hε,htests⟩ := sphere_metric_first_jet_neighborhood g₀ p hK hδ
  refine ⟨tests,ε,hε,?_⟩
  intro g hg
  exact hstable (sphereChartMetric g p) (htests g hg)


end

section
open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set Filter Metric
open scoped Topology InnerProductSpace
open Set Filter Function Metric
open scoped Topology
open Set Filter Function Metric
open scoped Topology
open Set Filter Manifold Bundle MeasureTheory
open scoped Topology ContDiff ENNReal
open Set Filter Manifold Bundle
open scoped Topology ContDiff
open Set Filter Metric
open scoped Topology InnerProductSpace
open Set Filter Function Metric
open scoped Topology
open Set Filter Function Metric
open scoped Topology
open Set Filter Manifold Metric
open scoped Topology ContDiff

lemma IsSmoothNeighborhood.mono {E M : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [FiniteDimensional ℝ E] [TopologicalSpace M] [ChartedSpace E M]
    [IsManifold 𝓘(ℝ,E) ∞ M] (g₀ : SmoothMetric E M) {N O : Set (SmoothMetric E M)}
    (hN : IsSmoothNeighborhood g₀ N) (hNO : N ⊆ O) : IsSmoothNeighborhood g₀ O := by
  obtain ⟨tests,ε,hε,h⟩ := hN
  exact ⟨tests,ε,hε,fun g hg => hNO (h g hg)⟩

lemma IsSmoothNeighborhood.inter {E M : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [FiniteDimensional ℝ E] [TopologicalSpace M] [ChartedSpace E M]
    [IsManifold 𝓘(ℝ,E) ∞ M] (g₀ : SmoothMetric E M) {N O : Set (SmoothMetric E M)}
    (hN : IsSmoothNeighborhood g₀ N) (hO : IsSmoothNeighborhood g₀ O) :
    IsSmoothNeighborhood g₀ (N ∩ O) := by
  obtain ⟨t,ε,hε,h⟩ := hN
  obtain ⟨s,δ,hδ,k⟩ := hO
  refine ⟨t++s,min ε δ,lt_min hε hδ,fun g hg => ⟨h g ?_,k g ?_⟩⟩
  · intro a ha y hy
    exact (hg a (List.mem_append_left _ ha) y hy).trans_le (min_le_left _ _)
  · intro a ha y hy
    exact (hg a (List.mem_append_right _ ha) y hy).trans_le (min_le_right _ _)

lemma chartMetricForm_domination_transfer {E M : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] [FiniteDimensional ℝ E] [TopologicalSpace M] [ChartedSpace E M]
    [IsManifold 𝓘(ℝ,E) ∞ M] (g₀ g : SmoothMetric E M) (p : M) {x : M}
    (hx : x ∈ (chartAt E p).source) (a : ℝ)
    (h : ∀ v : E, chartMetricForm g₀ p (chartAt E p x) v v ≤
      a*chartMetricForm g p (chartAt E p x) v v) :
    ∀ v : TangentSpace 𝓘(ℝ,E) x, g₀.inner x v v ≤ a*g.inner x v v := by
  let c := chartAt E p
  have hc : c.MDifferentiable 𝓘(ℝ,E) 𝓘(ℝ,E) :=
    ⟨mdifferentiableOn_atlas (chart_mem_atlas E p),mdifferentiableOn_atlas_symm (chart_mem_atlas E p)⟩
  have hh : ∀ v : TangentSpace 𝓘(ℝ,E) (c.symm (c x)),
      g₀.inner (c.symm (c x)) v v ≤ a*g.inner (c.symm (c x)) v v := by
    intro v
    obtain ⟨w,rfl⟩ := hc.symm.mfderiv_surjective (c.map_source hx) v
    have hw := h w
    erw [chartMetricForm_pairing, chartMetricForm_pairing] at hw
    exact hw
  have he : c.symm (c x) = x := c.left_inv hx
  exact he ▸ hh

lemma small_bilinear_difference_domination {E : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] (B G : E →L[ℝ] E →L[ℝ] ℝ) {m : ℝ} (hm : 0 < m)
    (hB : ∀ v, m*‖v‖^2 ≤ B v v) (hG : ‖G-B‖ < m/2) :
    ∀ v, B v v ≤ 4*G v v := by
  intro v
  have he : |G v v-B v v| ≤ (m/2)*‖v‖^2 := by
    calc
      _ = ‖(G-B) v v‖ := by simp
      _ ≤ ‖G-B‖*‖v‖*‖v‖ := (ContinuousLinearMap.le_opNorm _ _).trans
        (mul_le_mul_of_nonneg_right (ContinuousLinearMap.le_opNorm _ _) (norm_nonneg _))
      _ ≤ _ := by nlinarith [mul_le_mul_of_nonneg_right hG.le (sq_nonneg ‖v‖)]
  have hl := hB v
  have hmnorm : 0 ≤ B v v := (mul_nonneg hm.le (sq_nonneg _)).trans hl
  have ha := (abs_le.mp he).1
  nlinarith

def sphericalHalf (p : Sphere 3) : Set (Sphere 3) :=
  {q | 0 ≤ inner ℝ (p : Euclidean 4) (q : Euclidean 4)}

lemma sphericalHalf_compact (p : Sphere 3) : IsCompact (sphericalHalf p) :=
  (isClosed_le continuous_const (continuous_const.inner continuous_subtype_val)).isCompact

lemma sphericalHalf_in_source (p : Sphere 3) : sphericalHalf p ⊆ (chartAt (Euclidean 3) p).source := by
  intro q hq
  rw [sphere_chart_source]
  change q ≠ -p
  intro he
  rw [he] at hq
  have hp : ‖(p : Euclidean 4)‖ = 1 := by simpa only [mem_sphere,dist_zero_right] using p.property
  change 0 ≤ inner ℝ (p : Euclidean 4) (-(p : Euclidean 4)) at hq
  rw [inner_neg_right,real_inner_self_eq_norm_sq,hp] at hq
  norm_num at hq

lemma sphericalHalves_cover (p q : Sphere 3) : q ∈ sphericalHalf p ∨ q ∈ sphericalHalf (-p) := by
  change 0 ≤ inner ℝ (p : Euclidean 4) (q : Euclidean 4) ∨
    0 ≤ inner ℝ (-(p : Euclidean 4)) (q : Euclidean 4)
  rw [inner_neg_left]
  exact le_total 0 _ |>.imp id (fun h => neg_nonneg.mpr h)

lemma sphericalHalf_domination_neighborhood (g₀ : SmoothMetric (Euclidean 3) (Sphere 3))
    (p : Sphere 3) : IsSmoothNeighborhood g₀ {g | ∀ x ∈ sphericalHalf p,
      ∀ v : TangentSpace 𝓘(ℝ,Euclidean 3) x, g₀.inner x v v ≤ 4*g.inner x v v} := by
  let c := chartAt (Euclidean 3) p
  let K := c '' sphericalHalf p
  have hK : IsCompact K := (sphericalHalf_compact p).image_of_continuousOn
    (c.continuousOn.mono (sphericalHalf_in_source p))
  obtain ⟨m,hm,hml⟩ := compact_selfMetricFlat_lower (sphereChartMetric g₀ p) hK
  apply IsSmoothNeighborhood.mono g₀ (sphere_metric_first_jet_neighborhood g₀ p hK (half_pos hm))
  intro g hg x hx
  apply chartMetricForm_domination_transfer g₀ g p (sphericalHalf_in_source p hx) 4
  have hxx : c x ∈ K := ⟨x,hx,rfl⟩
  have hdom := small_bilinear_difference_domination _ _ hm (hml _ hxx) (hg _ hxx).1
  simpa only [sphereChartMetric_selfFlat] using hdom

theorem spherical_domination_neighborhood (g₀ : SmoothMetric (Euclidean 3) (Sphere 3)) :
    IsSmoothNeighborhood g₀ {g | ∀ x (v : TangentSpace 𝓘(ℝ,Euclidean 3) x),
      g₀.inner x v v ≤ 4*g.inner x v v} := by
  apply IsSmoothNeighborhood.mono g₀ (IsSmoothNeighborhood.inter g₀
    (sphericalHalf_domination_neighborhood g₀ sourcePole)
    (sphericalHalf_domination_neighborhood g₀ (-sourcePole)))
  intro g hg x v
  rcases sphericalHalves_cover sourcePole x with h | h
  · exact hg.1 x h v
  · exact hg.2 x h v


end

section
open Set Filter Manifold
open scoped Topology ContDiff Matrix.Norms.Elementwise
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
lemma matrix_iteratedFDeriv_norm_le {ι κ : Type*} [Fintype ι] [Fintype κ]
    [DecidableEq ι] [DecidableEq κ]
    {A : E → Matrix ι κ ℝ} {x : E} (hA : ContDiffAt ℝ ∞ A x)
    (m : ℕ) {ε : ℝ} (hε : 0 ≤ ε)
    (hb : ∀ i j, ‖iteratedFDeriv ℝ m (fun y => A y i j) x‖ ≤ ε) :
    ‖iteratedFDeriv ℝ m A x‖ ≤ ε := by
  apply ContinuousMultilinearMap.opNorm_le_bound hε
  intro v
  have hp := Finset.prod_nonneg (fun k (_ : k ∈ Finset.univ) => norm_nonneg (v k))
  apply (pi_norm_le_iff_of_nonneg (mul_nonneg hε hp)).mpr
  intro i
  apply (pi_norm_le_iff_of_nonneg (mul_nonneg hε hp)).mpr
  intro j
  let L : Matrix ι κ ℝ →L[ℝ] ℝ := (ContinuousLinearMap.proj j : (κ → ℝ) →L[ℝ] ℝ).comp
    (ContinuousLinearMap.proj i : Matrix ι κ ℝ →L[ℝ] (κ → ℝ))
  have he : iteratedFDeriv ℝ m (fun y => A y i j) x v = (iteratedFDeriv ℝ m A x v) i j :=
    congrArg (fun T => T v) (L.iteratedFDeriv_comp_left hA (ENat.natCast_le_of_coe_top_le_withTop le_rfl m))
  rw [← he]
  exact (ContinuousMultilinearMap.le_opNorm _ _).trans (mul_le_mul_of_nonneg_right (hb i j) hp)

variable [FiniteDimensional ℝ E]
local instance matrixJetInst1 : NormedAddCommGroup (E →L[ℝ] ℝ) := inferInstance
local instance matrixJetInst2 : NormedSpace ℝ (E →L[ℝ] ℝ) := inferInstance
local instance matrixJetInst3 : NormedAddCommGroup (CoordinateForm E) := inferInstance
local instance matrixJetInst4 : NormedSpace ℝ (CoordinateForm E) := inferInstance
private local instance matrixJetMatrixMapNorm {ι κ : Type*} [Fintype ι] [Fintype κ] :
    NormedAddCommGroup (Matrix ι κ ℝ →L[ℝ] CoordinateForm (E)) :=
  inferInstanceAs (NormedAddCommGroup ((ι → κ → ℝ) →L[ℝ] CoordinateForm (E)))
lemma metricMatrixForm_iterated_jet_bound
    {A : E → Matrix (CoordIndex E) (CoordIndex E) ℝ} {x : E}
    (hA : ContDiffAt ℝ ∞ A x) (m : ℕ) {ε : ℝ} (hε : 0 ≤ ε)
    (hb : ∀ i j, ‖iteratedFDeriv ℝ m (fun y => A y i j) x‖ ≤ ε) :
    ‖iteratedFDeriv ℝ m (fun y => metricMatrixForm (A y)) x‖ ≤ ‖metricMatrixFormCLM (E:=E)‖*ε := by
  classical
  let L := metricMatrixFormCLM (E:=E)
  change ‖iteratedFDeriv ℝ m (L ∘ A) x‖ ≤ ‖L‖*ε
  erw [L.iteratedFDeriv_comp_left hA (ENat.natCast_le_of_coe_top_le_withTop le_rfl m)]
  exact (L.norm_compContinuousMultilinearMap_le _).trans
    (mul_le_mul_of_nonneg_left (matrix_iteratedFDeriv_norm_le hA m hε hb) (norm_nonneg L))
end


open Set Filter Function Manifold Bundle TopologicalSpace
open scoped Topology ContDiff Distributions BoundedContinuousFunction Matrix.Norms.Elementwise
section CompactSmoothContinuity
variable {P E F : Type*} [TopologicalSpace P]
  [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]
lemma continuous_compactSmooth_of_jets (K : Compacts E) (f : P → 𝓓_{K}(E,F))
    (hf : ∀ n, Continuous (fun z : P × E => iteratedFDeriv ℝ n (f z.1) z.2)) : Continuous f := by
  rw [continuous_iff_continuousAt]
  intro a₀
  rw [ContinuousAt,(ContDiffMapSupportedIn.withSeminorms ℝ E F ⊤ K).tendsto_nhds]
  intro n ε hε
  have hj : Continuous (fun z : P × E => iteratedFDeriv ℝ n (f z.1-f a₀) z.2) := by
    have he : (fun z : P × E => iteratedFDeriv ℝ n (f z.1-f a₀) z.2) =
        (fun z : P × E => iteratedFDeriv ℝ n (f z.1) z.2-iteratedFDeriv ℝ n (f a₀) z.2) := by
      funext z
      exact iteratedFDeriv_sub_apply
        ((f z.1).contDiff.of_le (ENat.natCast_le_of_coe_top_le_withTop le_rfl n)).contDiffAt
        ((f a₀).contDiff.of_le (ENat.natCast_le_of_coe_top_le_withTop le_rfl n)).contDiffAt
    rw [he]
    exact (hf n).sub (((f a₀).contDiff.continuous_iteratedFDeriv
      (ENat.natCast_le_of_coe_top_le_withTop le_rfl n)).comp continuous_snd)
  have he : ∀ᶠ a in 𝓝 a₀, ∀ y ∈ (K : Set E),
      ‖iteratedFDeriv ℝ n (f a-f a₀) y‖ < ε/2 := by
    apply K.isCompact.eventually_forall_of_forall_eventually
    intro y hy
    exact hj.norm.continuousAt.eventually (gt_mem_nhds (by simpa using half_pos hε))
  filter_upwards [he] with a ha
  apply lt_of_le_of_lt ?_ (half_lt_self hε)
  apply (ContDiffMapSupportedIn.seminorm_top_le_iff ℝ (half_pos hε).le _ _).mpr
  intro y hy
  exact (ha y hy).le
end CompactSmoothContinuity
namespace ContinuousSmoothFamilyOn
variable {P E F ι : Type*} [TopologicalSpace P]
  [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F] [Fintype ι]
lemma pi {f : P → E → ι → F} {U : Set E}
    (hf : ∀ i, ContinuousSmoothFamilyOn (fun p x => f p x i) U) :
    ContinuousSmoothFamilyOn f U := by
  classical
  have hh := sum Finset.univ (fun i p x => Pi.single i (f p x i)) (fun i _ =>
    (hf i).postcomp (ContinuousLinearMap.single ℝ (fun _ : ι => F) i)
      (fun _ _ _ => (ContinuousLinearMap.single ℝ (fun _ : ι => F) i).contDiff.contDiffAt))
  have he : (fun p x => ∑ i, Pi.single i (f p x i)) = f := by
    funext p x i
    simp
  rwa [he] at hh
end ContinuousSmoothFamilyOn
variable {P E M : Type*} [TopologicalSpace P]
  [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E] [TopologicalSpace M] [ChartedSpace E M]
  [IsManifold 𝓘(ℝ,E) ∞ M] [T2Space M]
local instance compactSmoothContinuityInst1 : NormedAddCommGroup (E →L[ℝ] ℝ) := inferInstance
local instance compactSmoothContinuityInst2 : NormedSpace ℝ (E →L[ℝ] ℝ) := inferInstance
local instance compactSmoothContinuityInst3 : NormedAddCommGroup (MetricForm E) := inferInstanceAs (NormedAddCommGroup (E →L[ℝ] E →L[ℝ] ℝ))
local instance compactSmoothContinuityInst4 : NormedSpace ℝ (MetricForm E) := inferInstanceAs (NormedSpace ℝ (E →L[ℝ] E →L[ℝ] ℝ))
omit [T2Space M] in
lemma continuous_chartTensorOfMetric (g₀ : SmoothMetric E M) (p : M) (K : Compacts E)
    (ht : (chartAt E p).target = univ) (q : P → SmoothMetric E M)
    (he : ∀ a x, x ∉ (chartAt E p).symm '' (K : Set E) → (q a).inner x=g₀.inner x)
    (hq : ∀ i j, ContinuousSmoothFamilyOn (fun a y => metricCoefficients (q a) p y i j) univ) :
    Continuous (fun a => chartTensorOfMetric g₀ p K ht (q a) (he a)) := by
  apply continuous_compactSmooth_of_jets
  have hf : ContinuousSmoothFamilyOn (fun a y => metricCoefficients (q a) p y) univ :=
    ContinuousSmoothFamilyOn.pi (fun i => ContinuousSmoothFamilyOn.pi (hq i))
  have hfm := hf.postcomp (metricMatrixFormCLM (E:=E)) (fun _ _ _ => (metricMatrixFormCLM (E:=E)).contDiff.contDiffAt)
  have hfb : ContinuousSmoothFamilyOn (fun (_ : P) y => chartMetricForm g₀ p y) univ :=
    ContinuousSmoothFamilyOn.const (P:=P) (chartMetricForm g₀ p) (fun y _ =>
    (chartMetricForm_contDiffOn g₀ p).contDiffAt (ht ▸ univ_mem))
  intro n
  change Continuous (fun z : P × E => iteratedFDeriv ℝ n
    (fun y => chartMetricForm (q z.1) p y-chartMetricForm g₀ p y) z.2)
  simpa only [univ_prod_univ,continuousOn_univ,chartMetricForm,metricMatrixFormCLM_apply] using (hfm.sub hfb).jets n

end YauCounterexamples
end

end OAI