Blame for lean/OAI/Geometry/Immersion/ClosedSurface/ForcedSolve.lean

import OAI.Geometry.Immersion.ClosedSurface.JetBounds
import OAI.Geometry.Immersion.ClosedSurface.TensorBounds
import OAI.Geometry.Immersion.ClosedSurface.ExtendedCancellation
import OAI.Geometry.Immersion.ClosedSurface.QuadraticSupport

namespace OAI

noncomputable section
open Set Complex Bundle Manifold
open scoped ContDiff Matrix Topology Manifold BigOperators

namespace ClosedSurfaceR4.RealModes
open ClosedSurfaceR4.SmallModes ClosedSurfaceR4.PhaseMean ClosedSurfaceR4.WeightedEstimates
open ClosedSurfaceR4.QuadraticMean (displacement)
open Set Filter

lemma contDiffOn_displacement {n : ℕ} {U : Set Base} {φ : Base → ℝ} {Z : Field n}
    (hφ : ContDiffOn ℝ ∞ φ U) (hZ : ContDiffOn ℝ ∞ Z U) (τ : ℝ) :
    ContDiffOn ℝ ∞ (displacement τ φ Z) U := by
  have he : ContDiffOn ℝ ∞ (fun p => QuadraticMean.phase (φ p / τ)) U := by
    exact ((Complex.ofRealCLM.contDiff.comp_contDiffOn
      (hφ.div_const τ)).mul contDiffOn_const).cexp
  exact (QuadraticMean.realPartCLM n).contDiff.comp_contDiffOn (he.smul hZ)



structure SupportedSolveChart {n : ℕ} (F : RField n) (φ : Base → ℝ) (S : Set Base) where
  U : Set Base
  V : Set Base
  χ : Base → Base
  e : Base → Base
  openU : IsOpen U
  closedS : IsClosed S
  supportU : S ⊆ U
  smoothFe : ContDiff ℝ ∞ (F ∘ e)
  domain : ModeDomain (fun p => complexify (F (e p))) V
  smoothχ : ContDiffOn ℝ ∞ χ U
  smoothe : ContDiffOn ℝ ∞ e V
  maps : MapsTo χ U V
  inverse : EqOn (e ∘ χ) id U
  phase : ∀ p ∈ U, (χ p).1 = φ p

def SupportedSolveChart.solve {n : ℕ} {F : RField n} {φ : Base → ℝ} {S : Set Base}
    (c : SupportedSolveChart F φ S) (τ : ℝ) (A : Base → ComplexTensor) (q : ℕ) : RField n :=
  c.U.indicator (phaseCanceller τ F c.χ c.e A q)



structure SolveBudget {n : ℕ} {F : RField n} {φ : Base → ℝ} {S : Set Base}
    (c : SupportedSolveChart F φ S) (A : Base → ComplexTensor) (τ s : ℝ) (q m : ℕ) where
  K : ℝ
  C : ℝ
  J : ℝ
  D : ℝ
  nonnegK : 0 ≤ K
  nonnegC : 0 ≤ C
  oneLEJ : 1 ≤ J
  nonnegD : 0 ≤ D
  smoothA : ContDiffOn ℝ ∞ (coordinateTarget c.e A) c.V
  coefficients : ReconstructionCoefficientBound (fun p => complexify (F (c.e p)))
    c.V s (m + q + 1) K
  forcing : WeightedBound c.V s (m + q + 1) C (coordinateTarget c.e A)
  coordinate : ∀ j, 1 ≤ j → j ≤ m → ∀ p ∈ c.U,
    ‖iteratedFDerivWithin ℝ j c.χ c.U p‖ ≤ J
  coordinateDerivative : ∀ v, ‖v‖ ≤ 1 → WeightedBound c.U τ m D (coordDeriv v c.χ)

def SolveBudget.size {n : ℕ} {F : RField n} {φ : Base → ℝ} {S : Set Base}
    {c : SupportedSolveChart F φ S} {A : Base → ComplexTensor} {τ s : ℝ} {q m : ℕ}
    (b : SolveBudget c A τ s q m) : ℝ :=
  (m.factorial : ℝ) * (2 ^ m * (forcedModeConstant n m b.K q * b.C)) * b.J ^ m

def SolveBudget.residual {n : ℕ} {F : RField n} {φ : Base → ℝ} {S : Set Base}
    {c : SupportedSolveChart F φ S} {A : Base → ComplexTensor} {τ s : ℝ} {q m : ℕ}
    (b : SolveBudget c A τ s q m) : ℝ :=
  4 * (2 ^ m * (2 ^ m * ((m.factorial : ℝ) *
    (2 ^ m * (fullErrorConstant n (m + q) b.K ^ (q + 1) * (τ / s) ^ (q + 1) * b.C)) *
    b.J ^ m) * b.D) * b.D)

theorem SupportedSolveChart.solve_spec {n : ℕ} {F : RField n} {φ : Base → ℝ}
    {S : Set Base} (c : SupportedSolveChart F φ S) (hF : ContDiff ℝ ∞ F)
    {A : Base → ComplexTensor} (hAsp : tsupport A ⊆ S)
    {τ s : ℝ} (hτ : 0 < τ) (hs : 0 < s) (hτs : τ ≤ s) (hs1 : s ≤ 1)
    {q m : ℕ} (b : SolveBudget c A τ s q m) :
    ContDiff ℝ ∞ (c.solve τ A q) ∧ tsupport (c.solve τ A q) ⊆ S ∧
    WeightedBound univ τ m b.size (c.solve τ A q) ∧
    WeightedBound univ τ m b.residual
      (fun p => realLinearizedTensor F (c.solve τ A q) p + displacement τ φ A p) := by
  have hh := weighted_extended_phaseCanceller c.smoothFe c.openU c.domain c.closedS c.supportU
    c.smoothχ c.smoothe c.maps c.inverse hF.contDiffOn hAsp hτ hs hτs hs1
    b.nonnegK b.nonnegC b.oneLEJ b.nonnegD b.smoothA q m b.coefficients b.forcing
    b.coordinate b.coordinateDerivative
  dsimp only at hh
  refine ⟨hh.1, hh.2.1, hh.2.2.1, ?_⟩
  have he : displacement τ (fun p => (c.χ p).1) A = displacement τ φ A := by
    funext p
    by_cases hp : p ∈ c.U
    · simp only [displacement, c.phase p hp]
    · have hz : A p = 0 := image_eq_zero_of_notMem_tsupport
        (fun hh => hp (c.supportU (hAsp hh)))
      rw [displacement_zero_value τ _ hz, displacement_zero_value τ _ hz]
  simpa only [he, SupportedSolveChart.solve, SolveBudget.residual] using hh.2.2.2



theorem finite_forced_solve {n : ℕ} {ι : Type*} [Fintype ι]
    {F : RField n} (hF : ContDiff ℝ ∞ F) {φ : ι → Base → ℝ}
    (hφ : ∀ i, ContDiff ℝ ∞ (φ i)) {A : ι → Base → ComplexTensor}
    (hA : ∀ i, ContDiff ℝ ∞ (A i)) {S : ι → Set Base}
    (hAsp : ∀ i, tsupport (A i) ⊆ S i) (c : ∀ i, SupportedSolveChart F (φ i) (S i))
    {τ s : ℝ} (hτ : 0 < τ) (hs : 0 < s) (hτs : τ ≤ s) (hs1 : s ≤ 1)
    (q m : ℕ) (b : ∀ i, SolveBudget (c i) (A i) τ s q m) :
    let X := fun p => ∑ i, (c i).solve τ (A i) q p
    ContDiff ℝ ∞ X ∧ tsupport X ⊆ ⋃ i, S i ∧
    WeightedBound univ τ m (∑ i, (b i).size) X ∧
    WeightedBound univ τ m (∑ i, (b i).residual)
      (fun p => realLinearizedTensor F X p + ∑ i, displacement τ (φ i) (A i) p) := by
  classical
  dsimp only
  have hh (i) := (c i).solve_spec hF (hAsp i) hτ hs hτs hs1 (b i)
  have hsm := fun i => (hh i).1
  refine ⟨ContDiff.sum fun i _ => hsm i, ?_, ?_, ?_⟩
  · apply closure_minimal _ (isClosed_iUnion_of_finite fun i => (c i).closedS)
    intro p hp
    by_contra hn
    apply hp
    apply Finset.sum_eq_zero
    intro i _
    exact image_eq_zero_of_notMem_tsupport
      (fun hh' => hn (mem_iUnion.mpr ⟨i, (hh i).2.1 hh'⟩))
  · exact WeightedBound.finset_sum isOpen_univ.uniqueDiffOn hτ.le Finset.univ _ _
      (fun i _ => (hsm i).contDiffOn) (fun i _ => (hh i).2.2.1)
  · have he (p) : realLinearizedTensor F (fun x => ∑ i, (c i).solve τ (A i) q x) p +
        ∑ i, displacement τ (φ i) (A i) p =
        ∑ i, (realLinearizedTensor F ((c i).solve τ (A i) q) p +
          displacement τ (φ i) (A i) p) := by
      rw [realLinearized_sum_right F (fun i => (hsm i).differentiable (by simp) p)]
      exact (Finset.sum_add_distrib).symm
    simp_rw [he]
    exact WeightedBound.finset_sum isOpen_univ.uniqueDiffOn hτ.le Finset.univ _ _
      (fun i _ => (contDiffOn_realLinearizedTensor isOpen_univ hF.contDiffOn
        (hsm i).contDiffOn).add (contDiffOn_displacement (hφ i).contDiffOn (hA i).contDiffOn τ))
      (fun i _ => (hh i).2.2.2)

end ClosedSurfaceR4.RealModes

namespace ClosedSurfaceR4.RealModes
open ClosedSurfaceR4.SmallModes ClosedSurfaceR4.PhaseMean ClosedSurfaceR4.WeightedEstimates
open ClosedSurfaceR4.QuadraticMean (displacement)
open Set Filter

lemma quadraticPhase_smooth {ι : Type*} {φ : ι → Base → ℝ}
    (hφ : ∀ i, ContDiff ℝ ∞ (φ i)) :
    ∀ l : QuadraticLabel ι, ContDiff ℝ ∞ (quadraticPhase φ l) := by
  intro l
  rcases l with i | ⟨i, j, b⟩
  · exact contDiff_const.mul (hφ i)
  · cases b
    · exact (hφ i).add (hφ j)
    · exact (hφ i).sub (hφ j)




theorem finite_quadratic_cancellation {n : ℕ} {ι : Type*} [Fintype ι] [DecidableEq ι]
    {F : RField n} (hF : ContDiff ℝ ∞ F) {φ : ι → Base → ℝ}
    (hφ : ∀ i, ContDiff ℝ ∞ (φ i)) {Z : ι → Field n}
    (hZ : ∀ i, ContDiff ℝ ∞ (Z i)) {S : ι → Set Base}
    (hZsp : ∀ i, tsupport (Z i) ⊆ S i)
    (c : ∀ l : QuadraticLabel ι, SupportedSolveChart F (quadraticPhase φ l) (quadraticSupport S l))
    {τ s : ℝ} (hτ : 0 < τ) (hs : 0 < s) (hτs : τ ≤ s) (hs1 : s ≤ 1)
    (q m : ℕ) (b : ∀ l, SolveBudget (c l) (quadraticAmplitude τ φ Z l) τ s q m) :
    let V := fun p => ∑ l, (c l).solve τ (quadraticAmplitude τ φ Z l) q p
    ContDiff ℝ ∞ V ∧ tsupport V ⊆ ⋃ i, S i ∧
    WeightedBound univ τ m (∑ l, (b l).size) V ∧
    WeightedBound univ τ m (∑ l, (b l).residual)
      (fun p => realLinearizedTensor F V p + nonzeroPhaseSum τ φ Z p) := by
  classical
  dsimp only
  obtain ⟨hsm, hsp, hb, hr⟩ := finite_forced_solve hF (quadraticPhase_smooth hφ)
    (quadraticAmplitude_smooth hφ hZ τ) (quadraticAmplitude_tsupport τ φ Z hZsp)
    c hτ hs hτs hs1 q m b
  refine ⟨hsm, hsp.trans ?_, hb, ?_⟩
  · intro p hp
    obtain ⟨l, hl⟩ := mem_iUnion.mp hp
    rcases l with i | ⟨i, j, b⟩
    · exact mem_iUnion.mpr ⟨i, hl⟩
    · exact mem_iUnion.mpr ⟨i, hl.1⟩
  · simpa only [nonzeroPhaseSum_eq_quadraticFamily] using hr

end ClosedSurfaceR4.RealModes

end

end OAI