import Mathlib
import OAI.MeasureTheory.Falconer.Model
import OAI.MeasureTheory.Falconer.Recursion.Ledger
import OAI.MeasureTheory.Falconer.Recursion.PolicyDescriptors
import OAI.MeasureTheory.FalconerCompletion.Estimates.TreeCenter2
import OAI.MeasureTheory.FalconerCompletion.Graphs.GraphPerp2

namespace OAI

/-! Recursive policies and quantitative depth estimates. -/

open _root_.OAI.PlanarFalconer

section
section
open Set MeasureTheory
open scoped ComplexConjugate RealInnerProductSpace
namespace GraphLiteralSupport
namespace CurrentFalconer.TreeND
open Set Metric MeasureTheory PlanarFalconer
open scoped ENNReal RealInnerProductSpace
variable {d : ℕ}

noncomputable def classConditional (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    (P : CellPath d) : Measure (EuclideanSpace ℝ (Fin d)) :=
  (ρ (treeCell P)).toNNReal⁻¹ • ρ.restrict (treeCell P)

instance classConditional_finite (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    [IsFiniteMeasure ρ] (P : CellPath d) : IsFiniteMeasure (classConditional ρ P) := by
  unfold classConditional
  infer_instance

lemma classConditional_probability (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    [IsFiniteMeasure ρ] (P : CellPath d) (hP : 0 < ρ (treeCell P)) :
    IsProbabilityMeasure (classConditional ρ P) := by
  constructor
  simp only [classConditional, Measure.smul_apply, ENNReal.smul_def,
    smul_eq_mul, Measure.restrict_apply_univ]
  rw [ENNReal.coe_inv (ENNReal.toNNReal_ne_zero.mpr ⟨ne_of_gt hP,measure_ne_top ρ _⟩),
    ENNReal.coe_toNNReal (measure_ne_top ρ _),
    ENNReal.inv_mul_cancel (ne_of_gt hP) (measure_ne_top ρ _)]

noncomputable def adjustedProfile (m : ℝ → ℝ) (N : ℕ) (n : ℕ) : ℝ :=
  m n-(d:ℝ)/2*(n:ℝ)/N

noncomputable def testWidth (N J i n : ℕ) (sig : ℝ) : ℝ :=
  (2-(i:ℝ)/J)*(2:ℝ)^(-(n:ℝ))*((2:ℝ)^N)^(500*sig)

noncomputable def fullParallelCount (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    (g p : ℕ) (P : CellPath d) (W : ℝ) (w : EuclideanSpace ℝ (Fin d)) : ℕ :=
  ((dyadicPaths p).filter fun Q => 0 < ρ (treeCell Q) ∧
    dist (treeCenter Q) (treeCenter P) < 10*(d+1)/(2:ℝ)^g ∧
    ‖graphPerpND w (treeCenter Q-treeCenter P)‖ ≤ W).card

lemma fullParallelCount_actual_line (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    (g p : ℕ) (P : CellPath d) (W : ℝ) (w : EuclideanSpace ℝ (Fin d)) (hw : ‖w‖=1) :
    fullParallelCount ρ g p P W w =
      ((dyadicPaths p).filter fun Q => 0 < ρ (treeCell Q) ∧
        dist (treeCenter Q) (treeCenter P) < 10*(d+1)/(2:ℝ)^g ∧
        infDist (treeCenter Q) (graphAffineLineND w (treeCenter P)) ≤ W).card := by
  simp only [fullParallelCount,infDist_graphAffineLineND w _ _ hw]

lemma measurable_fullParallelCount (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    (g p : ℕ) (P : CellPath d) (W : ℝ) : Measurable (fullParallelCount ρ g p P W) := by
  classical
  have he : fullParallelCount ρ g p P W = fun w =>
      ∑ Q ∈ dyadicPaths p, if 0 < ρ (treeCell Q) ∧
        dist (treeCenter Q) (treeCenter P) < 10*(d+1)/(2:ℝ)^g ∧
        ‖graphPerpND w (treeCenter Q-treeCenter P)‖ ≤ W then (1:ℕ) else 0 := by
    funext w
    simp only [fullParallelCount,Finset.card_filter]
  rw [he]
  apply Finset.measurable_sum
  intro Q hQ
  apply Measurable.ite _ measurable_const measurable_const
  unfold graphPerpND
  by_cases h₁ : 0 < ρ (treeCell Q)
  · by_cases h₂ : dist (treeCenter Q) (treeCenter P) < 10*(d+1)/(2:ℝ)^g
    · simp only [h₁,h₂,true_and]
      exact measurableSet_le (by fun_prop) measurable_const
    · simp [h₂]
  · simp [h₁]

noncomputable def fullProjectionCollision (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    (P : CellPath d) (W : ℝ) (w : EuclideanSpace ℝ (Fin d)) : ℝ≥0∞ :=
  ((classConditional ρ P).prod (classConditional ρ P))
    {xy | |inner ℝ (xy.1-xy.2) w| ≤ W}

lemma measurable_fullProjectionCollision (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    [IsFiniteMeasure ρ] (P : CellPath d) (W : ℝ) :
    Measurable (fullProjectionCollision ρ P W) := by
  exact measurable_measure_prodMk_left (show MeasurableSet
    {z : EuclideanSpace ℝ (Fin d) × (EuclideanSpace ℝ (Fin d) × EuclideanSpace ℝ (Fin d)) |
      |inner ℝ (z.2.1-z.2.2) z.1| ≤ W} from by measurability)

noncomputable def descriptorGood (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    (m : ℝ → ℝ) (N : ℕ) (sig C : ℝ) (J i : ℕ) (P : CellPath d) :
    PolicyDescriptor → Set (EuclideanSpace ℝ (Fin d))
  | .parallel g p => {w | ‖w‖=1 ∧
      (fullParallelCount ρ g p P (testWidth N J i p sig) w:ℝ) ≤
        ((2:ℝ)^N)^(height (adjustedProfile (d := d) m N) g p+C*sig)}
  | .projection p t => {w | ‖w‖=1 ∧
      fullProjectionCollision ρ P (testWidth N J i t sig) w ≤
        ENNReal.ofReal ((2:ℝ)^(-((t:ℝ)-p))*
          ((2:ℝ)^N)^((adjustedProfile (d := d) m N) p-
            intervalMin (adjustedProfile (d := d) m N) p t+C*sig))}

lemma measurable_descriptorGood (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    [IsFiniteMeasure ρ] (m : ℝ → ℝ) (N : ℕ) (sig C : ℝ) (J i : ℕ)
    (P : CellPath d) (b : PolicyDescriptor) :
    MeasurableSet (descriptorGood ρ m N sig C J i P b) := by
  cases b with
  | parallel g p =>
    exact (measurableSet_eq_fun (by fun_prop) measurable_const).inter
      (measurableSet_le ((measurable_of_countable (fun a : ℕ => (a:ℝ))).comp
        (measurable_fullParallelCount ρ g p P _)) measurable_const)
  | projection p t =>
    exact (measurableSet_eq_fun (by fun_prop) measurable_const).inter
      (measurableSet_le (measurable_fullProjectionCollision ρ P _) measurable_const)

noncomputable def radialVector (x y : EuclideanSpace ℝ (Fin d)) := ‖x-y‖⁻¹ • (x-y)

lemma norm_radialVector {x y : EuclideanSpace ℝ (Fin d)} (hxy : x ≠ y) :
    ‖radialVector x y‖=1 := by
  rw [radialVector,norm_smul,Real.norm_eq_abs,abs_inv,abs_norm,
    inv_mul_cancel₀ (norm_ne_zero_iff.mpr (sub_ne_zero.mpr hxy))]

@[fun_prop] lemma measurable_radialVector : Measurable
    (fun z : EuclideanSpace ℝ (Fin d) × EuclideanSpace ℝ (Fin d) => radialVector z.1 z.2) := by
  unfold radialVector
  fun_prop

noncomputable def endpointGood (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    (m : ℝ → ℝ) (N : ℕ) (sig C : ℝ) (J i : ℕ) (b : PolicyDescriptor) :
    Set (EuclideanSpace ℝ (Fin d) × EuclideanSpace ℝ (Fin d)) :=
  {z | ∀ P ∈ dyadicPaths (descriptorAnchor b), z.1 ∈ treeCell P →
    z.2 ∈ descriptorGood ρ m N sig C J i P b}

lemma measurable_endpointGood (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    [IsFiniteMeasure ρ] (m : ℝ → ℝ) (N : ℕ) (sig C : ℝ) (J i : ℕ) (b : PolicyDescriptor) :
    MeasurableSet (endpointGood ρ m N sig C J i b) := by
  simp only [endpointGood,ofPred_forall]
  apply MeasurableSet.iInter
  intro P
  apply MeasurableSet.iInter
  intro hP
  exact ((measurableSet_treeCell P).preimage measurable_fst).himp
    ((measurable_descriptorGood ρ m N sig C J i P b).preimage measurable_snd)

noncomputable def distanceGood (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    (m : ℝ → ℝ) (N q a t : ℕ) (sig C : ℝ) (J i : ℕ) :
    Set (EuclideanSpace ℝ (Fin d) × EuclideanSpace ℝ (Fin d)) :=
  {z | ∀ b ∈ policyDescriptorList (adjustedProfile (d := d) m N) N q a t,
    (z.1,radialVector z.1 z.2) ∈ endpointGood ρ m N sig C J i b ∧
    (z.2,radialVector z.1 z.2) ∈ endpointGood ρ m N sig C J i b}

lemma measurable_distanceGood (ρ : Measure (EuclideanSpace ℝ (Fin d)))
    [IsFiniteMeasure ρ] (m : ℝ → ℝ) (N q a t : ℕ) (sig C : ℝ) (J i : ℕ) :
    MeasurableSet (distanceGood ρ m N q a t sig C J i) := by
  simp only [distanceGood,ofPred_forall]
  apply Finset.measurableSet_biInter
  intro b hb
  exact ((measurable_endpointGood ρ m N sig C J i b).preimage
      (measurable_fst.prodMk measurable_radialVector)).inter
    ((measurable_endpointGood ρ m N sig C J i b).preimage
      (measurable_snd.prodMk measurable_radialVector))

structure PositiveDistanceState (d : ℕ) where
  ρ : Measure (EuclideanSpace ℝ (Fin d))
  mass : ℝ → ℝ
  (N q a t J i : ℕ)
  (sig C : ℝ)
  (X Y : CellPath d)

namespace PositiveDistanceState
variable (e : PositiveDistanceState d)

noncomputable def good := distanceGood e.ρ e.mass e.N e.q e.a e.t e.sig e.C e.J e.i
noncomputable def cellPair := (e.ρ.restrict (treeCell e.X)).prod (e.ρ.restrict (treeCell e.Y))
noncomputable def pair := e.cellPair.restrict e.good
noncomputable def distance : Measure ℝ := Measure.map (fun z => dist z.1 z.2) e.pair
noncomputable def levelMass : ℝ := ((2:ℝ)^e.N)^(-e.mass e.a)
noncomputable def normalization : ℝ≥0∞ := ENNReal.ofReal ((2:ℝ)^((e.t:ℝ)-e.a)/e.levelMass^4)
noncomputable def width : ℝ := (2:ℝ)^(-(e.t:ℝ))
noncomputable def coincidence : ℝ≥0∞ := e.normalization*(e.pair.prod e.pair)
  {z | |dist z.1.1 z.1.2-dist z.2.1 z.2.2| ≤ 100*(d+1)*e.width}

instance cellPair_finite [IsFiniteMeasure e.ρ] : IsFiniteMeasure e.cellPair := by
  unfold cellPair; infer_instance
instance pair_finite [IsFiniteMeasure e.ρ] : IsFiniteMeasure e.pair := by
  unfold pair; infer_instance
instance distance_finite [IsFiniteMeasure e.ρ] : IsFiniteMeasure e.distance := by
  unfold distance; infer_instance

lemma measurable_good [IsFiniteMeasure e.ρ] : MeasurableSet e.good :=
  measurable_distanceGood _ _ _ _ _ _ _ _ _ _

lemma distance_apply [IsFiniteMeasure e.ρ] {S : Set ℝ} (hS : MeasurableSet S) :
    e.distance S = e.cellPair {z | dist z.1 z.2 ∈ S ∧ z ∈ e.good} := by
  rw [distance,Measure.map_apply (continuous_fst.dist continuous_snd).measurable hS,
    pair,Measure.restrict_apply ((continuous_fst.dist continuous_snd).measurable hS)]
  rfl

lemma distance_collision [IsFiniteMeasure e.ρ] (w : ℝ) :
    (e.distance.prod e.distance) {z : ℝ × ℝ | |z.1-z.2| ≤ w} =
      (e.pair.prod e.pair) {z | |dist z.1.1 z.1.2-dist z.2.1 z.2.2| ≤ w} := by
  rw [distance,Measure.map_prod_map _ _ (continuous_fst.dist continuous_snd).measurable
    (continuous_fst.dist continuous_snd).measurable,
    Measure.map_apply (by fun_prop) (by measurability)]
  rfl

lemma coincidence_four_point [IsFiniteMeasure e.ρ] :
    e.coincidence = e.normalization*(e.cellPair.prod e.cellPair)
      {z | |dist z.1.1 z.1.2-dist z.2.1 z.2.2| ≤ 100*(d+1)*e.width ∧
        z.1 ∈ e.good ∧ z.2 ∈ e.good} := by
  rw [coincidence,pair,Measure.prod_restrict,Measure.restrict_apply (by measurability)]
  rfl

lemma coincidence_ne_top [IsFiniteMeasure e.ρ] : e.coincidence ≠ ⊤ :=
  ENNReal.mul_ne_top ENNReal.ofReal_ne_top (measure_ne_top _ _)

end PositiveDistanceState

end CurrentFalconer.TreeND
end GraphLiteralSupport
end
end

section
section
open Set MeasureTheory
open scoped ComplexConjugate RealInnerProductSpace
namespace GraphLiteralSupport
namespace CurrentFalconer.TreeND
open Set MeasureTheory
open scoped ENNReal
variable {d : ℕ}

lemma RegularizedProfileData.normalized_cell_mass_le
    {ρ : Measure (EuclideanSpace ℝ (Fin d))} {N B : ℕ} {s lam : ℝ} {m : ℝ → ℝ}
    (hd : RegularizedProfileData ρ N B s lam m) {a : ℕ} (ha : a ≤ N)
    {P : CellPath d} (hP : P.length = a) :
    (ρ (treeCell P)).toReal/((2:ℝ)^N)^(-m a) ≤ ((2:ℝ)^N)^((d+1:ℝ)*lam) := by
  apply (div_le_iff₀ (Real.rpow_pos_of_pos (by positivity) _)).mpr
  by_cases hp : 0 < ρ (treeCell P)
  · exact (hd.cells a ha P hP hp).2
  · have hz : ρ (treeCell P) = 0 := le_antisymm (le_of_not_gt hp) bot_le
    rw [hz,ENNReal.toReal_zero]
    positivity

namespace PositiveDistanceState
variable (e : PositiveDistanceState d)

lemma normalized_cellPair_mass [IsFiniteMeasure e.ρ] :
    e.levelMass^(-2:ℤ)*e.cellPair.real univ =
      ((e.ρ (treeCell e.X)).toReal/e.levelMass)*
      ((e.ρ (treeCell e.Y)).toReal/e.levelMass) := by
  have hp : e.cellPair univ = e.ρ (treeCell e.X)*e.ρ (treeCell e.Y) := by
    unfold cellPair
    rw [← univ_prod_univ,Measure.prod_prod,Measure.restrict_apply_univ,
      Measure.restrict_apply_univ]
  rw [measureReal_def,hp,ENNReal.toReal_mul]
  simp only [zpow_neg,zpow_ofNat,div_eq_mul_inv]
  ring

lemma normalized_cellPair_profile_mass {B : ℕ} {s lam : ℝ}
    (hd : RegularizedProfileData e.ρ e.N B s lam e.mass)
    (ha : e.a ≤ e.N) (hX : e.X.length=e.a) (hY : e.Y.length=e.a) :
    e.levelMass^(-2:ℤ)*e.cellPair.real univ ≤ ((2:ℝ)^e.N)^(2*(d+1:ℝ)*lam) := by
  let := hd.probability
  rw [e.normalized_cellPair_mass]
  have h := mul_le_mul (hd.normalized_cell_mass_le ha hX)
    (hd.normalized_cell_mass_le ha hY) (by positivity) (by positivity)
  rw [← Real.rpow_add (by positivity : 0 < (2:ℝ)^e.N)] at h
  convert h using 1 <;> congr 1
  ring

lemma coincidence_trivial_profile_bound {B : ℕ} {s lam : ℝ}
    (hd : RegularizedProfileData e.ρ e.N B s lam e.mass)
    (ha : e.a ≤ e.N) (hX : e.X.length=e.a) (hY : e.Y.length=e.a) :
    e.coincidence.toReal ≤ (2:ℝ)^((e.t:ℝ)-e.a)*((2:ℝ)^e.N)^(4*(d+1:ℝ)*lam) := by
  let := hd.probability
  have hmass := e.normalized_cellPair_profile_mass hd ha hX hY
  have hquad : (e.cellPair.prod e.cellPair) univ = e.cellPair univ*e.cellPair univ := by
    rw [← univ_prod_univ,Measure.prod_prod]
  have hc : e.coincidence.toReal ≤ e.normalization.toReal*(e.cellPair.real univ)^2 := by
    rw [e.coincidence_four_point,ENNReal.toReal_mul]
    apply mul_le_mul_of_nonneg_left _ ENNReal.toReal_nonneg
    calc
      _ ≤ ((e.cellPair.prod e.cellPair) univ).toReal :=
        ENNReal.toReal_mono (measure_ne_top _ _) (measure_mono (subset_univ _))
      _ = _ := by rw [hquad,ENNReal.toReal_mul]; simp only [pow_two,measureReal_def]
  have he : e.normalization.toReal*(e.cellPair.real univ)^2 =
      (2:ℝ)^((e.t:ℝ)-e.a)*(e.levelMass^(-2:ℤ)*e.cellPair.real univ)^2 := by
    rw [normalization,ENNReal.toReal_ofReal (by positivity)]
    simp only [zpow_neg,zpow_ofNat]
    field_simp
  have hp := pow_le_pow_left₀ (show 0 ≤ e.levelMass^(-2:ℤ)*e.cellPair.real univ by positivity) hmass 2
  have hr : (((2:ℝ)^e.N)^(2*(d+1:ℝ)*lam))^2 = ((2:ℝ)^e.N)^(4*(d+1:ℝ)*lam) := by
    rw [← Real.rpow_mul_natCast (by positivity : 0 ≤ (2:ℝ)^e.N)]
    congr 1
    norm_num
    ring
  rw [hr] at hp
  exact hc.trans (he.trans_le (mul_le_mul_of_nonneg_left hp (by positivity)))

lemma actual_distance_terminal {B : ℕ} {s lam : ℝ}
    (hd : RegularizedProfileData e.ρ e.N B s lam e.mass)
    (ha : e.a ≤ e.N) (hX : e.X.length=e.a) (hY : e.Y.length=e.a)
    (ht : e.t ≤ e.a+100*e.q) :
    e.coincidence.toReal ≤ (2:ℝ)^(100*(e.q:ℝ))*((2:ℝ)^e.N)^(4*(d+1:ℝ)*lam) := by
  have htR : (e.t:ℝ) ≤ (e.a:ℝ)+100*e.q := by exact_mod_cast ht
  have he : (2:ℝ)^((e.t:ℝ)-e.a) ≤ (2:ℝ)^(100*(e.q:ℝ)) :=
    Real.rpow_le_rpow_of_exponent_le (by norm_num) (by linarith)
  exact (e.coincidence_trivial_profile_bound hd ha hX hY).trans
    (mul_le_mul_of_nonneg_right he (by positivity))

lemma actual_distance_terminal_rpow {B : ℕ} {s lam : ℝ}
    (hd : RegularizedProfileData e.ρ e.N B s lam e.mass)
    (hN : 0 < e.N) (ha : e.a ≤ e.N) (hX : e.X.length=e.a) (hY : e.Y.length=e.a)
    (ht : e.t ≤ e.a+100*e.q) :
    e.coincidence.toReal ≤ ((2:ℝ)^e.N)^(100*(e.q:ℝ)/e.N+4*(d+1:ℝ)*lam) := by
  apply (e.actual_distance_terminal hd ha hX hY ht).trans_eq
  rw [Real.rpow_add (by positivity)]
  congr 1
  rw [← Real.rpow_natCast,← Real.rpow_mul (by norm_num : (0:ℝ) ≤ 2)]
  congr 1
  have hn : (e.N:ℝ) ≠ 0 := by exact_mod_cast (Nat.ne_of_gt hN)
  field_simp

end PositiveDistanceState

end CurrentFalconer.TreeND
end GraphLiteralSupport
end
end

end OAI