lean/OAI/Probability/MemoryPrecision/KernelCaps.lean

import Mathlib
import OAI.Probability.GaussianRegression.Main
import OAI.Probability.MemoryPrecision.CubeExperiment
import OAI.Probability.MemoryPrecision.KernelEvaluation
import OAI.Probability.MemoryPrecision.SphereCaps

namespace OAI

open MeasureTheory ProbabilityTheory Set Filter EuclideanGeometry
open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise

noncomputable section
universe u v


open MeasureTheory ProbabilityTheory Set Filter
open scoped ENNReal NNReal RealInnerProductSpace Topology Pointwise
namespace MemoryPrecision.Kernel
open MemoryPrecision NoiselessRegression
instance {d : ℕ} [NeZero d] : IsProbabilityMeasure (UniformSphere d) :=
  (show IsProbabilityMeasure (NoiselessRegression.sphereLaw (E := Vector d)) from inferInstance)
instance (d T : ℕ) : IsProbabilityMeasure (RowLaw d T) := by unfold RowLaw; infer_instance

namespace Policy
variable {d M T : ℕ} (K : Policy d M T)

lemma chordTest_eq_cap (ε : ℝ) (s v : MemoryPrecision.Kernel.Sphere d) :
    chordTest ε (s,v) = capWeight v.val ε s.val := by
  classical
  change (if dist v.val s.val ≤ ε then 1 else 0) =
    (if dist s.val v.val ≤ ε then 1 else 0)
  rw [dist_comm]

lemma output_chord_sphere_local (hd : 1 ≤ d) {ε α : ℝ} (hε : 0 < ε)
    (hα : 0 ≤ α) (hαn : α ≤ (d:ℝ)-1) (t : ℕ) (j : MemoryPrecision.Kernel.State M) :
    SphereBallBound (K.outputTest (chordTest ε) t j)
      ((3*4^d:ℝ)*ε^((d:ℝ)-1-α)) α := by
  have : NeZero d := ⟨by omega⟩
  intro z r hr
  change (∫⁻ s in {s : MemoryPrecision.Kernel.Sphere d | dist s.val z ≤ r},
    ∫⁻ v, chordTest ε (s,v) ∂K.output t j ∂UniformSphere d) ≤ _
  have hm : Measurable (Function.uncurry (fun s v : MemoryPrecision.Kernel.Sphere d => chordTest ε (s,v))) :=
    measurable_chordTest ε
  rw [lintegral_lintegral_swap hm.aemeasurable]
  have hb (v : MemoryPrecision.Kernel.Sphere d) := sphere_cap_real_mass hd v.val hε hα hαn z r hr
  simp_rw [chordTest_eq_cap]
  exact (lintegral_mono hb).trans_eq (by simp)

lemma output_chord_cube_local (hd : 2 ≤ d) {ε : ℝ} (hε : 0 < ε)
    (t : ℕ) (j : MemoryPrecision.Kernel.State M) :
    CubeLocal (fun u => K.outputTest (chordTest ε) t j (CubeSphere hd u))
      ((12:ℝ)^(d/2)*ε^((d/2:ℕ)/4:ℝ)) := by
  intro z r hr
  change (∫⁻ u in CubeBall d z r, ∫⁻ v, chordTest ε (CubeSphere hd u,v)
    ∂K.output t j ∂CubeLaw d) ≤ _
  have hf : Measurable (Function.uncurry (fun (u : Cube d) (v : MemoryPrecision.Kernel.Sphere d) =>
      chordTest ε (CubeSphere hd u,v))) :=
    (measurable_chordTest ε).comp ((cubeSphere_measurable hd).comp measurable_fst |>.prodMk measurable_snd)
  rw [lintegral_lintegral_swap hf.aemeasurable]
  simp_rw [chordTest_eq_cap]
  change (∫⁻ v : MemoryPrecision.Kernel.Sphere d, ∫⁻ u in CubeBall d z r,
      capWeight v.val ε (CubeEmbedding d u) ∂CubeLaw d ∂K.output t j) ≤ _
  have hb (v : MemoryPrecision.Kernel.Sphere d) := cube_cap_local hd v.val hε z r hr
  exact (lintegral_mono hb).trans_eq (by simp)

lemma output_chord_sphere_total (hd : 1 ≤ d) {ε : ℝ} (hε : 0 < ε)
    (t : ℕ) (j : MemoryPrecision.Kernel.State M) :
    (∫⁻ s, K.outputTest (chordTest ε) t j s ∂UniformSphere d) ≤
      ENNReal.ofReal ((3*4^d:ℝ)*ε^(d-1)) := by
  have h := sphere_mass_bound (K.output_chord_sphere_local hd hε (α := 0) le_rfl (by
    have hd' : (1:ℝ) ≤ d := by exact_mod_cast hd
    linarith) t j)
  have hn : ((d-1:ℕ):ℝ) = (d:ℝ)-1 := by rw [Nat.cast_sub hd, Nat.cast_one]
  simpa only [UniformSphere, SpherePrior,sub_zero, ← hn, Real.rpow_natCast] using h

lemma angleTest_le_chordTest (ε : ℝ) (x : MemoryPrecision.Kernel.Sphere d × MemoryPrecision.Kernel.Sphere d) :
    angleTest ε x ≤ chordTest ε x := by
  classical
  by_cases ha : Real.arccos ⟪x.2.val,x.1.val⟫ ≤ ε
  · have hc : dist x.2.val x.1.val ≤ ε := (chord_le_arccos x.2 x.1).trans ha
    simp [angleTest, chordTest, ha, hc]
  · simp [angleTest, ha]

lemma eval_mono {X : Type*} {w v : ℕ → MemoryPrecision.Kernel.State M → X → ℝ≥0∞}
    (h : ∀ n j s, w n j s ≤ v n j s) (n k : ℕ) (j : MemoryPrecision.Kernel.State M)
    (s : X) (obs : Observations d k) : K.eval w n k j s obs ≤ K.eval v n k j s obs := by
  induction k generalizing n j with
  | zero => exact h n j s
  | succ k ih =>
    apply Finset.sum_le_sum
    intro a _
    apply mul_le_mul' le_rfl
    split
    · exact h _ _ _
    · exact ih _ _ _

lemma pathValue_mono {X : Type*} {w v : ℕ → MemoryPrecision.Kernel.State M → X → ℝ≥0∞}
    (h : ∀ n j s, w n j s ≤ v n j s) (s : X) (obs : Observations d T) :
    K.pathValue w s obs ≤ K.pathValue v s obs := by
  apply Finset.sum_le_sum
  intro a _
  apply mul_le_mul' le_rfl
  split
  · exact h _ _ _
  · exact K.eval_mono h _ _ _ _ _

lemma success_le_chord {Ω : Type*} [MeasurableSpace Ω] (L : Ω → Policy d M T)
    (ρ : Measure Ω) (π : Measure (MemoryPrecision.Kernel.Sphere d)) (ε : ℝ) :
    Success L ρ π ε ≤ ChordSuccess L ρ π ε := by
  apply lintegral_mono
  intro z
  exact (L z.2.1).pathValue_mono (fun n j s => lintegral_mono (fun v => angleTest_le_chordTest ε (s,v))) _ _
end Policy
end MemoryPrecision.Kernel


end

end OAI