lean/OAI/MeasureTheory/FalconerCompletion/Angular/AngularWordOperatorBound.lean

import Mathlib
import OAI.MeasureTheory.Falconer.Model
import OAI.MeasureTheory.Falconer.Recursion.PolicyDescriptors
import OAI.MeasureTheory.FalconerCompletion.Angular.EndpointMask
import OAI.MeasureTheory.FalconerCompletion.Graphs.NormalizedAngularWord
import OAI.MeasureTheory.FalconerCompletion.Sphere.AngularDerivativeBound

namespace OAI

/-! Angular cutoffs and derivative estimates. -/

open _root_.OAI.PlanarFalconer

section
section
open Set MeasureTheory
open scoped ComplexConjugate RealInnerProductSpace
namespace GraphLiteralSupport
namespace CurrentFalconer
open Set
open scoped ContDiff
variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [FiniteDimensional ℝ V]

lemma angularWordOperatorND_bound (L : List (V →L[ℝ] V)) (m : ℕ) (C : ℝ) (hC : 0 ≤ C) :
    ∃ D : ℝ, 0 ≤ D ∧ ∀ (b : SmoothFunctionND V) (A : ℝ) (s : ℕ), 1 ≤ A →
      (∀ j ≤ m+L.length, ∀ w, ‖w‖=1 → ‖iteratedFDeriv ℝ j b.1 w‖ ≤ C*A^(j+s)) →
      ∀ j ≤ m, ∀ w, ‖w‖=1 →
        ‖iteratedFDeriv ℝ j (angularWordOperatorND L b).1 w‖ ≤ D*A^(j+(s+L.length)) := by
  induction L generalizing m C with
  | nil =>
    refine ⟨C,hC,?_⟩
    intro b A s hA hb j hj w hw
    simpa [angularWordOperatorND] using hb j (by simpa using hj) w hw
  | cons T L ih =>
    obtain ⟨D,hD,hDb⟩ := ih (m+1) C hC
    obtain ⟨F,hF,hFb⟩ := angularDerivativeND_bound T m D hD
    refine ⟨F,hF,?_⟩
    intro b A s hA hb j hj w hw
    have hb' : ∀ k ≤ m+1+L.length, ∀ u, ‖u‖=1 →
        ‖iteratedFDeriv ℝ k b.1 u‖ ≤ C*A^(k+s) := fun k hk u hu => hb k (by simpa only [List.length_cons] using (show k ≤ m+(L.length+1) by omega)) u hu
    have hh := hFb (angularWordOperatorND L b).1 A (s+L.length)
      (smoothFunctionND_contDiff _) hA (hDb b A s hA hb') j hj w hw
    change ‖iteratedFDeriv ℝ j (angularDerivativeND T (angularWordOperatorND L b).1) w‖ ≤ _
    simpa only [List.length_cons,Nat.add_assoc] using hh

lemma normalizedAngularWordND_bound (L : List (V →L[ℝ] V)) (m : ℕ) (C : ℝ) (hC : 0 ≤ C) :
    ∃ D : ℝ, 0 ≤ D ∧ ∀ (b : SmoothFunctionND V) (A : ℝ), 1 ≤ A →
      (∀ j ≤ m+L.length, ∀ w, ‖w‖=1 → ‖iteratedFDeriv ℝ j b.1 w‖ ≤ C*A^j) →
      ∀ j ≤ m, ∀ w, ‖w‖=1 →
        ‖iteratedFDeriv ℝ j (normalizedAngularWordND A L b).1 w‖ ≤ D*A^j := by
  obtain ⟨D,hD,hDb⟩ := angularWordOperatorND_bound L m C hC
  refine ⟨D,hD,?_⟩
  intro b A hA hb j hj w hw
  have hAp : 0 < A := zero_lt_one.trans_le hA
  have hh := sphere_derivative_const_mul_bound ((A:ℂ)^L.length)⁻¹
    (smoothFunctionND_contDiff (angularWordOperatorND L b))
    (hDb b A 0 hA (by simpa only [Nat.add_zero] using hb)) j hj w hw
  change ‖iteratedFDeriv ℝ j (normalizedAngularWordND A L b).1 w‖ ≤ _ at hh
  apply hh.trans
  rw [norm_inv,norm_pow,Complex.norm_real,Real.norm_eq_abs,abs_of_pos hAp]
  simp only [Nat.zero_add]
  rw [pow_add]
  have hn : A^L.length ≠ 0 := pow_ne_zero _ hAp.ne'
  field_simp
  exact le_rfl

lemma normalizedAngularWordND_finite_bound (W : Finset (List (V →L[ℝ] V)))
    (m b : ℕ) (hb : ∀ L ∈ W, L.length ≤ b) (C : ℝ) (hC : 0 ≤ C) :
    ∃ D : ℝ, 0 ≤ D ∧ ∀ L ∈ W, ∀ (f : SmoothFunctionND V) (A : ℝ), 1 ≤ A →
      (∀ j ≤ m+b, ∀ w, ‖w‖=1 → ‖iteratedFDeriv ℝ j f.1 w‖ ≤ C*A^j) →
      ∀ j ≤ m, ∀ w, ‖w‖=1 →
        ‖iteratedFDeriv ℝ j (normalizedAngularWordND A L f).1 w‖ ≤ D*A^j := by
  choose D hD hDb using fun L => normalizedAngularWordND_bound (V := V) L m C hC
  refine ⟨∑ L ∈ W,D L,Finset.sum_nonneg (fun L _ => hD L),?_⟩
  intro L hL f A hA hf j hj w hw
  have hh := hDb L f A hA (fun k hk z hz => hf k (by have := hb L hL; omega) z hz) j hj w hw
  apply hh.trans
  exact mul_le_mul_of_nonneg_right (Finset.single_le_sum (fun L _ => hD L) hL) (pow_nonneg (by linarith) _)

end CurrentFalconer
end GraphLiteralSupport
end
end

section
section
open Set MeasureTheory
open scoped ComplexConjugate RealInnerProductSpace
namespace GraphLiteralSupport
namespace CurrentFalconer.TreeND
open Set Metric MeasureTheory PlanarFalconer
open scoped ENNReal RealInnerProductSpace ContDiff Topology
variable {d : ℕ}
noncomputable def actualEndpointSmooth (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    (m : ℝ → ℝ) (N : ℕ) (sig C : ℝ) (J i : ℕ) (b : PolicyDescriptor)
    (x : EuclideanSpace ℝ (Fin d)) : SmoothFunctionND (EuclideanSpace ℝ (Fin d)) :=
  ⟨fun w => (actualEndpointMask ρ m N sig C J i b x w : ℂ),
    Complex.ofRealCLM.contDiff.comp (actualEndpointMask_smooth ρ m N sig C J i b x)⟩

lemma actualEndpointSmooth_support (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    (m : ℝ → ℝ) (N : ℕ) (sig C : ℝ) (J i : ℕ) (b : PolicyDescriptor)
    (x : EuclideanSpace ℝ (Fin d)) :
    tsupport (actualEndpointSmooth ρ m N sig C J i b x).1=
      tsupport (actualEndpointMask ρ m N sig C J i b x) := by
  apply congrArg closure
  ext w
  change (Complex.ofReal (actualEndpointMask ρ m N sig C J i b x w) ≠ 0) ↔ _
  exact not_congr Complex.ofReal_eq_zero

lemma actualEndpointSmooth_derivative_norm (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    (m : ℝ → ℝ) (N : ℕ) (sig C : ℝ) (J i : ℕ) (b : PolicyDescriptor)
    (x w : EuclideanSpace ℝ (Fin d)) (k : ℕ) :
    ‖iteratedFDeriv ℝ k (actualEndpointSmooth ρ m N sig C J i b x).1 w‖=
      ‖iteratedFDeriv ℝ k (actualEndpointMask ρ m N sig C J i b x) w‖ := by
  exact Complex.ofRealLI.norm_iteratedFDeriv_comp_left
    (actualEndpointMask_smooth ρ m N sig C J i b x).contDiffAt
    (by exact_mod_cast (le_top : (k:ℕ∞) ≤ ⊤))

noncomputable def actualEndpointAngular
    (L : List (EuclideanSpace ℝ (Fin d) →L[ℝ] EuclideanSpace ℝ (Fin d)))
    (ρ : Measure (EuclideanSpace ℝ (Fin d))) (m : ℝ → ℝ) (N : ℕ)
    (sig C : ℝ) (J i : ℕ) (b : PolicyDescriptor) (x : EuclideanSpace ℝ (Fin d)) :
    SmoothFunctionND (EuclideanSpace ℝ (Fin d)) :=
  normalizedAngularWordND (sourceMaskScaleND (descriptorLength b) ((2:ℝ)^N) sig) L
    (actualEndpointSmooth ρ m N sig C J i b x)

lemma actualEndpointAngular_derivatives
    (W : Finset (List (EuclideanSpace ℝ (Fin d) →L[ℝ] EuclideanSpace ℝ (Fin d))))
    (M B : ℕ) (hW : ∀ L ∈ W, L.length ≤ B) :
    ∃ D : ℝ, 0 ≤ D ∧ ∀ L ∈ W,
      ∀ (ρ : Measure (EuclideanSpace ℝ (Fin d))) (m : ℝ → ℝ) (N : ℕ)
        (sig C : ℝ) (J i : ℕ) (b : PolicyDescriptor) (x : EuclideanSpace ℝ (Fin d)),
      ∀ j ≤ M, ∀ w, ‖w‖=1 →
      ‖iteratedFDeriv ℝ j (actualEndpointAngular L ρ m N sig C J i b x).1 w‖ ≤
        D*(sourceMaskScaleND (descriptorLength b) ((2:ℝ)^N) sig)^j := by
  obtain ⟨C₀,hC,hCb⟩ := actualEndpointMask_derivatives d (M+B)
  obtain ⟨D,hD,hDb⟩ := normalizedAngularWordND_finite_bound W M B hW C₀ hC
  refine ⟨D,hD,?_⟩
  intro L hL ρ m N sig C J i b x j hj w hw
  apply hDb L hL (actualEndpointSmooth ρ m N sig C J i b x)
    (sourceMaskScaleND (descriptorLength b) ((2:ℝ)^N) sig)
    (sourceMaskScaleND_one_le _ _ _) _ j hj w hw
  intro k hk z _hz
  rw [actualEndpointSmooth_derivative_norm]
  exact hCb ρ m N sig C J i b k hk x z

lemma uniform_actualEndpointAngular_support {sig : ℝ} (hsig : 0<sig) {J : ℕ} (hJ : 0<J) :
    ∃ N₀ : ℕ, ∀ N ≥ N₀, ∀ (ρ : Measure (EuclideanSpace ℝ (Fin d))), IsFiniteMeasure ρ →
      ∀ (m : ℝ → ℝ) (C : ℝ) (i : ℕ) (b : PolicyDescriptor), ValidDescriptor N b →
      ∀ (L : List (EuclideanSpace ℝ (Fin d) →L[ℝ] EuclideanSpace ℝ (Fin d)))
        (k : ℕ) (x w : EuclideanSpace ℝ (Fin d)), ‖w‖=1 →
      w ∈ tsupport (iteratedFDeriv ℝ k (actualEndpointAngular L ρ m N sig C J i b x).1) →
      (x,w) ∈ endpointGood ρ m N sig C J (i+1) b := by
  obtain ⟨N₀,h₀⟩ := uniform_actualEndpointMask_support (d:=d) hsig hJ
  refine ⟨N₀,?_⟩
  intro N hN ρ hf m C i b hb L k x w hw hs
  have hs' := tsupport_iteratedFDeriv_subset k hs
  have hs'' := normalizedAngularWordND_support
    (sourceMaskScaleND (descriptorLength b) ((2:ℝ)^N) sig) L
    (actualEndpointSmooth ρ m N sig C J i b x) hs'
  rw [actualEndpointSmooth_support] at hs''
  apply h₀ N hN ρ hf m C i b hb 0 x w hw
  have he : tsupport (iteratedFDeriv ℝ 0 (actualEndpointMask ρ m N sig C J i b x))=
      tsupport (actualEndpointMask ρ m N sig C J i b x) := by
    apply congrArg closure
    ext u
    simp only [Function.mem_support]
    rw [← norm_ne_zero_iff,norm_iteratedFDeriv_zero,norm_ne_zero_iff]
  rw [he]
  exact hs''

end CurrentFalconer.TreeND
end GraphLiteralSupport
end
end

section
section
open Set MeasureTheory
open scoped ComplexConjugate RealInnerProductSpace
namespace GraphLiteralSupport
namespace CurrentFalconer
open scoped ContDiff
variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V]

lemma angularDerivativeND_star (A : V →L[ℝ] V) (f : V → ℂ) :
    angularDerivativeND A (fun x => star (f x)) = fun x => star (angularDerivativeND A f x) := by
  funext x
  simp only [angularDerivativeND,fderiv_star,ContinuousLinearMap.comp_apply]
  rfl

lemma angularDerivativeND_even (A : V →L[ℝ] V) {f : V → ℂ}
    (hf : ContDiff ℝ ∞ f) (he : Function.Even f) : Function.Even (angularDerivativeND A f) := by
  have heq : f ∘ (fun x : V => -x) = f := funext he
  intro x
  have hd := fderiv_comp (𝕜 := ℝ) x (hf.differentiable (by simp) (-x))
    (differentiableAt_id.neg : DifferentiableAt ℝ (fun y : V => -y) x)
  have hneg : fderiv ℝ (fun y : V => -y) x = -ContinuousLinearMap.id ℝ V :=
    ContinuousLinearMap.fderiv (-ContinuousLinearMap.id ℝ V)
  rw [heq,hneg] at hd
  have hh := congrArg (fun T : V →L[ℝ] ℂ => T (A x)) hd
  simpa only [angularDerivativeND,Function.comp_apply,map_neg,ContinuousLinearMap.comp_apply,
    fderiv_fun_neg,fderiv_fun_id,neg_apply,ContinuousLinearMap.id_apply] using hh.symm

noncomputable def smoothStarND (f : SmoothFunctionND V) : SmoothFunctionND V :=
  ⟨fun x => star (f.1 x), by
    change ContDiff ℝ ∞ (fun x => star (f.1 x))
    simpa only [Complex.star_def,Function.comp_def,Complex.conjCLE_apply] using
      Complex.conjCLE.contDiff.comp (smoothFunctionND_contDiff f)⟩

lemma angularWordOperatorND_star (L : List (V →L[ℝ] V)) (f : SmoothFunctionND V) :
    angularWordOperatorND L (smoothStarND f)=smoothStarND (angularWordOperatorND L f) := by
  induction L with
  | nil => rfl
  | cons A L ih =>
    change angularOperatorND A (angularWordOperatorND L (smoothStarND f)) = _
    rw [ih]
    apply Subtype.ext
    exact angularDerivativeND_star A _

lemma angularWordOperatorND_even (L : List (V →L[ℝ] V)) (f : SmoothFunctionND V)
    (he : Function.Even f.1) : Function.Even (angularWordOperatorND L f).1 := by
  induction L with
  | nil => exact he
  | cons A L ih =>
    exact angularDerivativeND_even A (smoothFunctionND_contDiff _) ih

lemma normalizedAngularWordND_even (A : ℝ) (L : List (V →L[ℝ] V)) (f : SmoothFunctionND V)
    (he : Function.Even f.1) : Function.Even (normalizedAngularWordND A L f).1 := by
  intro x
  change ((A:ℂ)^L.length)⁻¹ * (angularWordOperatorND L f).1 (-x) =
    ((A:ℂ)^L.length)⁻¹ * (angularWordOperatorND L f).1 x
  rw [angularWordOperatorND_even L f he x]

lemma normalizedAngularWordND_star (A : ℝ) (L : List (V →L[ℝ] V)) (f : SmoothFunctionND V) :
    normalizedAngularWordND A L (smoothStarND f) = smoothStarND (normalizedAngularWordND A L f) := by
  apply Subtype.ext
  funext x
  simp only [normalizedAngularWordND,angularWordOperatorND_star]
  change ((A:ℂ)^L.length)⁻¹ * star ((angularWordOperatorND L f).1 x) =
    star (((A:ℂ)^L.length)⁻¹ * (angularWordOperatorND L f).1 x)
  simp only [map_mul,map_inv₀,map_pow,Complex.star_def,Complex.conj_ofReal]

end CurrentFalconer
end GraphLiteralSupport
end
end

end OAI