import OAI.MeasureTheory.Falconer.Recursion.ReachedBranchWeights
import OAI.MeasureTheory.Falconer.Recursion.ProfileExcess

namespace OAI

/-! # Branch weights for the ambient-dimensional profile

The excess profile is d-Lipschitz. These estimates retain that factor in
both the terminal potential payment and the accumulated error exponent.
-/

namespace Falconer
open PlanarFalconer

def DimensionalProfileLipschitz (d : ℕ) (A : ℕ → ℝ) (N : ℕ) : Prop :=
  ∀ i ≤ N, ∀ j ≤ N, |A i-A j| ≤ (d:ℝ)*|(i:ℝ)-j|/(N:ℝ)

theorem profileExcess_dimensional_lipschitz {d N : ℕ} {Q : DyadicCube d}
    {ρ : MeasureTheory.Measure (Space d)} {profile : ℝ → ℝ} {s lam : ℝ}
    (hreg : Regularization.RegularizedProfileData Q ρ N s lam profile) (hN : 0 < N) :
    DimensionalProfileLipschitz d (profileExcess (d := d) profile N) N := by
  intro i hi j hj
  exact profileExcess_lipschitz Q ρ hreg hN i j hi hj

theorem dimensional_potential_le_final_start {A : ℕ → ℝ} {d N a t f Q : ℕ}
    (hN : 0 < N) (hA : DimensionalProfileLipschitz d A N)
    (hQ : 0 < Q) (hw : a+Q ≤ t) (ht : t ≤ N) (haf : a ≤ f) (hft : f ≤ t) :
    potential A a t Q ≤ 2*A f+2*d*(Q:ℝ)/N := by
  have hNR : (0:ℝ) < N := Nat.cast_pos.mpr hN
  have hb := potential_near_final A hQ hw haf hft (e := (d:ℝ)*(Q:ℝ)/N) ?_
  · simpa only [mul_div_assoc,mul_assoc] using hb
  intro j _ hjt hjf hfj
  have hd : |(j:ℝ)-f| ≤ (Q:ℝ) := by
    have hjR : (j:ℝ) ≤ (f:ℝ)+Q := by exact_mod_cast hjf
    have hfR : (f:ℝ) ≤ (j:ℝ)+Q := by exact_mod_cast hfj
    exact abs_le.mpr ⟨by linarith,by linarith⟩
  have hh := (hA j (hjt.trans ht) f (hft.trans ht)).trans (div_le_div_of_nonneg_right
    (mul_le_mul_of_nonneg_left hd (Nat.cast_nonneg d)) hNR.le)
  have hh' := (le_abs_self (A j-A f)).trans hh
  linarith

theorem _root_.OAI.PlanarFalconer.PolicyBranch.dimensional_costs_le_final_start {d N q n : ℕ} {A : ℕ → ℝ} {sig : ℝ}
    (b : PolicyBranch A N q sig n) (hN : 0 < N) (hq : 0 < q)
    (hslack : sig*(N:ℝ) ≤ q) (hA : DimensionalProfileLipschitz d A N)
    (hinit : (b.state 0).start+10*q ≤ (b.state 0).finish) :
    ∑ j ∈ Finset.range n, branchCost A (b.state j) (b.label j) (b.state (j+1)) ≤
      2*A (b.state n).start+20*d*(q:ℝ)/N-potential A (b.state 0).start (b.state 0).finish (10*q) := by
  have hQ : 0 < 10*q := by omega
  have hfinal := BranchState.valid_depths (b.valid n le_rfl)
  by_cases hw : (b.state n).start+10*q ≤ (b.state n).finish
  · have hc := b.costs_le_potential hq hslack hw
    have hf := dimensional_potential_le_final_start hN hA hQ hw hfinal.2 (le_refl _) hfinal.1
    norm_num only [Nat.cast_mul,Nat.cast_ofNat] at hf
    linear_combination hc+hf
  · cases n with
    | zero => exact (hw hinit).elim
    | succ n =>
      have hs := b.step n (by omega)
      have hn := hs.nested hq (b.valid n (by omega))
      have hp := hs.nonterminal
      have hpwide : (b.state n).start+10*q ≤ (b.state n).finish := by omega
      have hd := BranchState.valid_depths (b.valid n (by omega))
      have hc := (b.initialSegment n (by omega)).costs_le_potential hq hslack hpwide
      dsimp only [PlanarFalconer.PolicyBranch.initialSegment] at hc
      have hz := hs.short_cost_zero hq (b.valid n (by omega)) hslack (by omega)
      have hf := dimensional_potential_le_final_start hN hA hQ hpwide hd.2 hn.1 (hfinal.1.trans hn.2)
      norm_num only [Nat.cast_mul,Nat.cast_ofNat] at hf
      rw [Finset.sum_range_succ,hz,add_zero]
      linear_combination hc+hf

theorem DimensionalProfileLipschitz.increment_le {d N i j : ℕ} {A : ℕ → ℝ}
    (hA : DimensionalProfileLipschitz d A N) (hN : 0 < N) (hi : i ≤ N) (hj : j ≤ N) :
    |A i-A j| ≤ d := by
  apply (hA i hi j hj).trans
  apply (div_le_iff₀ (Nat.cast_pos.mpr hN)).mpr
  apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg d)
  apply abs_le.mpr
  have hi' : (i:ℝ) ≤ N := Nat.cast_le.mpr hi
  have hj' : (j:ℝ) ≤ N := Nat.cast_le.mpr hj
  constructor <;> linarith [Nat.cast_nonneg (α := ℝ) i,Nat.cast_nonneg (α := ℝ) j]

theorem DimensionalProfileLipschitz.abs_le {d N i : ℕ} {A : ℕ → ℝ}
    (hA : DimensionalProfileLipschitz d A N) (hN : 0 < N) (hzero : A 0 = 0) (hi : i ≤ N) :
    |A i| ≤ d := by
  simpa only [hzero,sub_zero] using hA.increment_le hN hi (Nat.zero_le N)

theorem DimensionalProfileLipschitz.minimum_cost_le {d N a t i : ℕ} {A : ℕ → ℝ}
    (hA : DimensionalProfileLipschitz d A N) (hN : 0 < N)
    (hat : a ≤ t) (ht : t ≤ N) (hi : i ≤ N) : A i-intervalMin A a t ≤ d := by
  obtain ⟨j,_,hjt,hmin⟩ := intervalMin_attained A hat
  rw [hmin]
  exact (le_abs_self _).trans (hA.increment_le hN hi (hjt.trans ht))

theorem _root_.OAI.PlanarFalconer.BranchStep.dimensional_cost_le {A : ℕ → ℝ} {d N q : ℕ} {sig : ℝ}
    (hA : DimensionalProfileLipschitz d A N) (hN : 0 < N) (hq : 0 < q)
    {s u : BranchState} {l : BranchLabel} (h : BranchStep A N q sig s l u)
    (hs : s.Valid N sig) (hu : u.Valid N sig) : branchCost A s l u ≤ d := by
  have hn := h.nested hq hs
  have hsd := BranchState.valid_depths hs
  have hud := BranchState.valid_depths hu
  cases h <;> simp only [branchCost]
  · exact hA.minimum_cost_le hN hn.2 hsd.2 (hud.2.trans (le_refl _))
  · norm_num
  · exact hA.minimum_cost_le hN hn.1 (hud.1.trans hud.2) (hud.1.trans hud.2)
  · norm_num
  · norm_num
  · exact hA.minimum_cost_le hN hn.1 (hud.1.trans hud.2) (hud.1.trans hud.2)

theorem _root_.OAI.PlanarFalconer.BranchStep.dimensional_exponent_le {A : ℕ → ℝ} {d N q : ℕ} {lam sig eps : ℝ}
    (hA : DimensionalProfileLipschitz d A N) (hN : 0 < N) (hq : 0 < q)
    (hloss : 4000*(lam+sig) ≤ 1)
    {s u : BranchState} {l : BranchLabel} (h : BranchStep A N q sig s l u)
    (hs : s.Valid N sig) (hu : u.Valid N sig) :
    branchExponent A lam sig eps s l u ≤ 3*(d:ℝ)+1+eps := by
  have hc := h.dimensional_cost_le hA hN hq hs hu
  have hsd := BranchState.valid_depths hs
  have hud := BranchState.valid_depths hu
  have hi := abs_le.mp (hA.increment_le hN (hud.1.trans hud.2) (hsd.1.trans hsd.2))
  unfold branchExponent
  split_ifs <;> linarith

theorem _root_.OAI.PlanarFalconer.PolicyBranch.dimensional_ancestor_exponent_bound {A : ℕ → ℝ} {d N q n : ℕ} {lam sig eps : ℝ}
    (b : PolicyBranch A N q sig n) (hA : DimensionalProfileLipschitz d A N)
    (hN : 0 < N) (hq : 0 < q) (hloss : 4000*(lam+sig) ≤ 1) :
    (∑ j ∈ Finset.range n, branchExponent A lam sig eps (b.state j) (b.label j) (b.state (j+1))) ≤
      (n:ℝ)*(3*(d:ℝ)+1+eps) := by
  calc
    _ ≤ ∑ _j ∈ Finset.range n, (3*(d:ℝ)+1+eps) := by
      apply Finset.sum_le_sum
      intro j hj
      have hj := Finset.mem_range.mp hj
      exact (b.step j hj).dimensional_exponent_le hA hN hq hloss (b.valid j hj.le)
        (b.valid (j+1) (by omega))
    _ = _ := by simp only [Finset.sum_const,Finset.card_range,nsmul_eq_mul]

theorem dimensional_source_branch_exponent {A : ℕ → ℝ} {d N n : ℕ} {lam sig kap eta : ℝ}
    (hN : 0 < N) (hlam : 0 ≤ lam) (hsig : 0 < sig) (hkap : 0 < kap) (hkap1 : kap ≤ 1)
    (heta : 0 < eta) (hceil : ⌈10*sig*(N:ℝ)⌉₊ < sourcePolicyBlock N kap)
    (hslack : sig*(N:ℝ) ≤ sourcePolicyBlock N kap)
    (hqratio : (sourcePolicyBlock N kap:ℝ)/(N:ℝ) ≤ 2*kap)
    (hA : DimensionalProfileLipschitz d A N)
    (b : PolicyBranch A N (sourcePolicyBlock N kap) sig n)
    (hinit : (b.state 0).start+10*sourcePolicyBlock N kap ≤ (b.state 0).finish) :
    let eps := eta/(2*(1+20/kap+1/sig))
    (∑ j ∈ Finset.range n, branchExponent A lam sig eps (b.state j) (b.label j) (b.state (j+1))) +
      (200*d*(sourcePolicyBlock N kap:ℝ)/N+12*lam+eta/2) ≤
      2*A (b.state 0).start-potential A (b.state 0).start (b.state 0).finish
        (10*sourcePolicyBlock N kap)+500*d*kap+10^6*(lam+sig)/kap+eta := by
  dsimp only
  have hq := sourcePolicyBlock_pos hN hkap
  have hc := b.dimensional_costs_le_final_start hN hq hslack hA hinit
  have hb := source_branch_count_bounds hN hsig hkap hkap1 hceil b
  let D : ℝ := 1+20/kap+1/sig
  have hD : 0 < D := by dsimp [D]; positivity
  have heps : 0 ≤ eta/(2*D) := by positivity
  have htime : (n:ℝ)*(eta/(2*D)) ≤ eta/2 := by
    have hn : (n:ℝ) ≤ D := by dsimp [D]; linarith [hb.2.2]
    calc
      _ ≤ D*(eta/(2*D)) := mul_le_mul_of_nonneg_right hn heps
      _ = eta/2 := by field_simp
  have hloss : (branchNonlowCount b.label n:ℝ)*(4000*(lam+sig)) ≤ 80000*(lam+sig)/kap := by
    calc
      _ ≤ (20/kap)*(4000*(lam+sig)) := mul_le_mul_of_nonneg_right hb.1 (by positivity)
      _ = _ := by ring
  have hlamK : lam ≤ (lam+sig)/kap := by
    apply (le_div_iff₀ hkap).mpr
    have hh := mul_le_mul_of_nonneg_left hkap1 hlam
    linarith
  have hbudget : 0 ≤ (lam+sig)/kap := by positivity
  have hqrd := mul_le_mul_of_nonneg_left hqratio (Nat.cast_nonneg (α := ℝ) d)
  rw [branch_exponent_sum]
  dsimp only [D] at htime
  simp only [mul_div_assoc] at hc hloss ⊢
  nlinarith

theorem uniform_dimensional_source_branch_exponent {d : ℕ} {lam sig kap eta : ℝ}
    (hlam : 0 ≤ lam) (hsig : 0 < sig) (hkap : 0 < kap) (hkap1 : kap ≤ 1)
    (hgap : sig < kap/1000) (heta : 0 < eta) :
    ∃ N₀ : ℕ, 0 < N₀ ∧ ∀ N ≥ N₀, ∀ A : ℕ → ℝ,
      DimensionalProfileLipschitz d A N → ∀ n : ℕ,
      ∀ b : PolicyBranch A N (sourcePolicyBlock N kap) sig n,
      (b.state 0).start+10*sourcePolicyBlock N kap ≤ (b.state 0).finish →
      (∑ j ∈ Finset.range n, branchExponent A lam sig (eta/(2*(1+20/kap+1/sig)))
        (b.state j) (b.label j) (b.state (j+1))) +
        (200*d*(sourcePolicyBlock N kap:ℝ)/N+12*lam+eta/2) ≤
      2*A (b.state 0).start-potential A (b.state 0).start (b.state 0).finish
        (10*sourcePolicyBlock N kap)+500*d*kap+10^6*(lam+sig)/kap+eta := by
  obtain ⟨N₁,hN₁,h₁⟩ := uniform_source_ceiling_slack hsig hgap
  obtain ⟨N₂,hN₂⟩ := exists_nat_gt (1/kap)
  refine ⟨max N₁ N₂,by omega,?_⟩
  intro N hN A hA n b hi
  have hNp : 0 < N := by omega
  have hNR : (0:ℝ) < N := Nat.cast_pos.mpr hNp
  have hkn : 1 < kap*(N:ℝ) := by
    have hh := (div_lt_iff₀ hkap).mp (hN₂.trans_le (Nat.cast_le.mpr (show N₂ ≤ N by omega)))
    linarith
  have hq : (sourcePolicyBlock N kap:ℝ) < kap*N+1 :=
    Nat.ceil_lt_add_one (mul_nonneg hkap.le hNR.le)
  have hqr : (sourcePolicyBlock N kap:ℝ)/(N:ℝ) ≤ 2*kap :=
    (div_le_iff₀ hNR).mpr (by linarith)
  exact dimensional_source_branch_exponent hNp hlam hsig hkap hkap1 heta
    (h₁ N (by omega)).1 (h₁ N (by omega)).2.2 hqr hA b hi

theorem dimensional_source_error_exponent {d : ℕ} {sig kap T eps n : ℝ}
    (hn : 0 ≤ n)
    (hdepth : n ≤ 20/kap+1/sig) (heps : eps ≤ 1)
    (hT : (20/kap+1/sig)*(3*(d:ℝ)+2)+10 < T) :
    -T+n*(3*(d:ℝ)+1+eps) < -10 := by
  have hstep : n*(3*(d:ℝ)+1+eps) ≤ n*(3*(d:ℝ)+2) := by nlinarith
  have hbound := mul_le_mul_of_nonneg_right hdepth
    (show 0 ≤ 3*(d:ℝ)+2 by positivity)
  linarith

theorem dimensional_uniform_source_error_branch {d : ℕ} {lam sig kap T eps : ℝ}
    (hsig : 0 < sig) (hkap : 0 < kap) (hkap1 : kap ≤ 1) (hgap : sig < kap/1000)
    (hloss : 4000*(lam+sig) ≤ 1) (heps : eps ≤ 1)
    (hT : (20/kap+1/sig)*(3*(d:ℝ)+2)+10 < T) :
    ∃ N₀ : ℕ, 0 < N₀ ∧ ∀ N ≥ N₀, ∀ A : ℕ → ℝ,
      DimensionalProfileLipschitz d A N → ∀ n : ℕ,
      ∀ b : PolicyBranch A N (sourcePolicyBlock N kap) sig n,
      (b.state 0).index = 0 →
      ((2:ℝ)^N)^(-T+(∑ j ∈ Finset.range n,
        branchExponent A lam sig eps (b.state j) (b.label j) (b.state (j+1)))) ≤
      ((2:ℝ)^N)^(-10:ℝ) := by
  obtain ⟨N₀,hN₀,h₀⟩ := uniform_source_branch_depth hsig hkap hkap1 hgap
  refine ⟨N₀,hN₀,?_⟩
  intro N hN A hA n b hi
  have hNp : 0 < N := hN₀.trans_le hN
  have hc := b.dimensional_ancestor_exponent_bound (eps := eps) hA hNp (sourcePolicyBlock_pos hNp hkap) hloss
  have hd := (h₀ N hN A n b hi).2.2.1
  have he := dimensional_source_error_exponent (Nat.cast_nonneg n) hd heps hT
  apply Real.rpow_le_rpow_of_exponent_le (one_le_pow₀ (by norm_num))
  linarith

theorem dimensional_source_profile_exponent_lower {A : ℕ → ℝ} {d N a t Q : ℕ}
    (hA : DimensionalProfileLipschitz d A N) (hN : 0 < N) (hzero : A 0 = 0)
    (hQ : 0 < Q) (hw : a+Q ≤ t) (ht : t ≤ N) :
    -4*(d:ℝ) ≤ 2*A a-potential A a t Q := by
  have ha := abs_le.mp (hA.abs_le hN hzero (show a ≤ N by omega))
  have hb := abs_le.mp (hA.abs_le hN hzero (show a+Q ≤ N by omega))
  have hp := potential_le A (Q := Q) (le_refl a) (by omega : a < a+Q) hw (le_refl _)
  linarith

theorem dimensional_uniform_source_weighted_terminal {d : ℕ} {lam sig kap eta : ℝ}
    (hlam : 0 ≤ lam) (hsig : 0 < sig) (hkap : 0 < kap) (hkap1 : kap ≤ 1)
    (hgap : sig < kap/1000) (heta : 0 < eta) :
    ∃ N₀ : ℕ, 0 < N₀ ∧ ∀ N ≥ N₀, ∀ A : ℕ → ℝ,
      DimensionalProfileLipschitz d A N → ∀ n : ℕ,
      ∀ b : PolicyBranch A N (sourcePolicyBlock N kap) sig n,
      (b.state 0).start+10*sourcePolicyBlock N kap ≤ (b.state 0).finish →
      b.weight lam (eta/(2*(1+20/kap+1/sig))) *
        ((2:ℝ)^N)^(200*d*(sourcePolicyBlock N kap:ℝ)/N+12*lam+eta/2) ≤
      ((2:ℝ)^N)^(2*A (b.state 0).start-potential A (b.state 0).start (b.state 0).finish
        (10*sourcePolicyBlock N kap)+500*d*kap+10^6*(lam+sig)/kap+eta) := by
  obtain ⟨N₀,hN₀,h₀⟩ := uniform_dimensional_source_branch_exponent hlam hsig hkap hkap1 hgap heta
  refine ⟨N₀,hN₀,?_⟩
  intro N hN A hA n b hi
  rw [PolicyBranch.weight,← Real.rpow_add (by positivity : 0 < (2:ℝ)^N)]
  exact Real.rpow_le_rpow_of_exponent_le (one_le_pow₀ (by norm_num)) (h₀ N hN A hA n b hi)

theorem dimensional_uniform_source_weighted_error {d : ℕ} {lam sig kap T eps : ℝ}
    (hsig : 0 < sig) (hkap : 0 < kap) (hkap1 : kap ≤ 1) (hgap : sig < kap/1000)
    (hloss : 4000*(lam+sig) ≤ 1) (heps : eps ≤ 1)
    (hT : (20/kap+1/sig)*(3*(d:ℝ)+2)+10 < T) :
    ∃ N₀ : ℕ, 0 < N₀ ∧ ∀ N ≥ N₀, ∀ A : ℕ → ℝ,
      DimensionalProfileLipschitz d A N → ∀ n : ℕ,
      ∀ b : PolicyBranch A N (sourcePolicyBlock N kap) sig n,
      (b.state 0).index = 0 →
      b.weight lam eps*((2:ℝ)^N)^(-T) ≤ ((2:ℝ)^N)^(-10:ℝ) := by
  obtain ⟨N₀,hN₀,h₀⟩ := dimensional_uniform_source_error_branch hsig hkap hkap1 hgap hloss heps hT
  refine ⟨N₀,hN₀,?_⟩
  intro N hN A hA n b hi
  rw [PolicyBranch.weight,← Real.rpow_add (by positivity : 0 < (2:ℝ)^N),add_comm]
  exact h₀ N hN A hA n b hi

end Falconer

end OAI