import Mathlib
import OAI.MeasureTheory.Falconer.Estimates.ActualDirectBuffer
import OAI.MeasureTheory.Falconer.Estimates.ActualOuterMasks
import OAI.MeasureTheory.Falconer.Model
import OAI.MeasureTheory.Falconer.Recursion.BranchCounts
import OAI.MeasureTheory.Falconer.Recursion.BranchPotential
import OAI.MeasureTheory.Falconer.Recursion.BranchTransitions
import OAI.MeasureTheory.Falconer.Recursion.Ledger
import OAI.MeasureTheory.Falconer.Recursion.Potential
import OAI.MeasureTheory.Falconer.Recursion.SourceBranchDepth
import OAI.MeasureTheory.FalconerCompletion.Recursion.ProfileLipschitz

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.DimensionalPolicy
open PlanarFalconer

namespace PolicyBranch
variable {A : ℕ → ℝ} {N q n offset : ℕ} {sig : ℝ}

def extend (b : PolicyBranch A N q offset sig n) {u : BranchState} {l : BranchLabel}
    (hu : u.Valid N sig) (hstep : BranchStep A N q offset sig (b.state n) l u) :
    PolicyBranch A N q offset sig (n+1) where
  state j := if j ≤ n then b.state j else u
  label j := if j < n then b.label j else l
  valid j hj := by
    split_ifs with h
    · exact b.valid j h
    · exact hu
  step j hj := by
    by_cases h : j < n
    · simpa only [ite_eq_left h, ite_eq_left (show j ≤ n by omega),
        ite_eq_left (show j+1 ≤ n by omega)] using b.step j h
    · have he : j = n := by omega
      subst j
      simpa using hstep

@[simp] theorem extend_state_le (b : PolicyBranch A N q offset sig n)
    {u : BranchState} {l : BranchLabel} (hu : u.Valid N sig)
    (hstep : BranchStep A N q offset sig (b.state n) l u) {j : ℕ} (hj : j ≤ n) :
    (b.extend hu hstep).state j = b.state j := ite_eq_left hj

@[simp] theorem extend_label_lt (b : PolicyBranch A N q offset sig n)
    {u : BranchState} {l : BranchLabel} (hu : u.Valid N sig)
    (hstep : BranchStep A N q offset sig (b.state n) l u) {j : ℕ} (hj : j < n) :
    (b.extend hu hstep).label j = b.label j := ite_eq_left hj

@[simp] theorem extend_last_state (b : PolicyBranch A N q offset sig n)
    {u : BranchState} {l : BranchLabel} (hu : u.Valid N sig)
    (hstep : BranchStep A N q offset sig (b.state n) l u) :
    (b.extend hu hstep).state (n+1) = u := ite_eq_right (by omega)

@[simp] theorem extend_last_label (b : PolicyBranch A N q offset sig n)
    {u : BranchState} {l : BranchLabel} (hu : u.Valid N sig)
    (hstep : BranchStep A N q offset sig (b.state n) l u) :
    (b.extend hu hstep).label n = l := ite_eq_right (Nat.lt_irrefl n)

end PolicyBranch

namespace PolicyBranch
variable {A : ℕ → ℝ} {N q n offset : ℕ} {sig : ℝ}

noncomputable def exponentSum (b : PolicyBranch A N q offset sig n) (C lam eps : ℝ) : ℝ :=
  ∑ j ∈ Finset.range n, branchExponentND A C lam sig eps (b.state j) (b.label j) (b.state (j+1))

noncomputable def weight (b : PolicyBranch A N q offset sig n) (C lam eps : ℝ) : ℝ :=
  ((2:ℝ)^N)^(b.exponentSum C lam eps)

theorem weight_pos (b : PolicyBranch A N q offset sig n) (C lam eps : ℝ) : 0 < b.weight C lam eps := by
  unfold weight
  positivity

theorem exponentSum_extend (b : PolicyBranch A N q offset sig n) (C lam eps : ℝ)
    {u : BranchState} {l : BranchLabel} (hu : u.Valid N sig)
    (hstep : BranchStep A N q offset sig (b.state n) l u) :
    (b.extend hu hstep).exponentSum C lam eps = b.exponentSum C lam eps+
      branchExponentND A C lam sig eps (b.state n) l u := by
  unfold exponentSum
  rw [Finset.sum_range_succ]
  congr 1
  · apply Finset.sum_congr rfl
    intro j hj
    have hj := Finset.mem_range.mp hj
    rw [b.extend_state_le hu hstep hj.le,b.extend_label_lt hu hstep hj,
      b.extend_state_le hu hstep (by omega : j+1 ≤ n)]
  · rw [b.extend_state_le hu hstep le_rfl,b.extend_last_label,b.extend_last_state]

theorem weight_extend (b : PolicyBranch A N q offset sig n) (C lam eps : ℝ)
    {u : BranchState} {l : BranchLabel} (hu : u.Valid N sig)
    (hstep : BranchStep A N q offset sig (b.state n) l u) :
    (b.extend hu hstep).weight C lam eps = b.weight C lam eps*
      ((2:ℝ)^N)^(branchExponentND A C lam sig eps (b.state n) l u) := by
  unfold weight
  rw [exponentSum_extend,Real.rpow_add (by positivity)]

theorem weight_eq_product (b : PolicyBranch A N q offset sig n) (C lam eps : ℝ) :
    b.weight C lam eps = ∏ j ∈ Finset.range n,
      ((2:ℝ)^N)^(branchExponentND A C lam sig eps (b.state j) (b.label j) (b.state (j+1))) :=
  Real.rpow_sum_of_pos (by positivity) _ _

theorem weight_zero (b : PolicyBranch A N q offset sig 0) (C lam eps : ℝ) : b.weight C lam eps = 1 := by
  simp [weight,exponentSum]

end PolicyBranch

theorem ProfileLipschitzND.increment_le {A : ℕ → ℝ} {N i j : ℕ} {L : ℝ}
    (hA : ProfileLipschitzND A N L) (hN : 0 < N) (hL : 0 ≤ L)
    (hi : i ≤ N) (hj : j ≤ N) : |A i-A j| ≤ L := 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 _ hL
  have hi' : (i:ℝ) ≤ N := Nat.cast_le.mpr hi
  have hj' : (j:ℝ) ≤ N := Nat.cast_le.mpr hj
  exact abs_le.mpr ⟨by linarith [Nat.cast_nonneg (α := ℝ) i],
    by linarith [Nat.cast_nonneg (α := ℝ) j]⟩

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

theorem BranchStep.cost_le {A : ℕ → ℝ} {N q offset : ℕ} {sig L : ℝ}
    (hA : ProfileLipschitzND A N L) (hN : 0 < N) (hq : 0 < q) (hL : 0 ≤ L)
    {s u : BranchState} {l : BranchLabel} (h : BranchStep A N q offset sig s l u)
    (hs : s.Valid N sig) (hu : u.Valid N sig) : branchCost A s l u ≤ L := 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 hL hn.2 hsd.2 hud.2
  · exact hL
  · exact hA.minimum_cost_le hN hL hn.1 (hud.1.trans hud.2) (hud.1.trans hud.2)
  · exact hL
  · exact hL
  · exact hA.minimum_cost_le hN hL hn.1 (hud.1.trans hud.2) (hud.1.trans hud.2)

theorem BranchStep.exponent_leND {A : ℕ → ℝ} {N q offset : ℕ} {C lam sig eps L : ℝ}
    (hA : ProfileLipschitzND A N L) (hN : 0 < N) (hq : 0 < q)
    (hL : 0 ≤ L) (hloss : C*(lam+sig) ≤ 1)
    {s u : BranchState} {l : BranchLabel} (h : BranchStep A N q offset sig s l u)
    (hs : s.Valid N sig) (hu : u.Valid N sig) :
    branchExponentND A C lam sig eps s l u ≤ 3*L+1+eps := by
  have hc := h.cost_le hA hN hq hL hs hu
  have hsd := BranchState.valid_depths hs
  have hud := BranchState.valid_depths hu
  have hi := abs_le.mp (hA.increment_le hN hL (hud.1.trans hud.2) (hsd.1.trans hsd.2))
  unfold branchExponentND
  split_ifs <;> linarith

theorem PolicyBranch.ancestor_exponent_boundND {A : ℕ → ℝ} {N q n offset : ℕ}
    {C lam sig eps L : ℝ} (b : PolicyBranch A N q offset sig n)
    (hA : ProfileLipschitzND A N L) (hN : 0 < N) (hq : 0 < q)
    (hL : 0 ≤ L) (hloss : C*(lam+sig) ≤ 1) :
    b.exponentSum C lam eps ≤ (n:ℝ)*(3*L+1+eps) := by
  apply le_trans (Finset.sum_le_sum fun j hj =>
    (b.step j (Finset.mem_range.mp hj)).exponent_leND hA hN hq hL hloss
      (b.valid j (by have := Finset.mem_range.mp hj; omega))
      (b.valid (j+1) (by have := Finset.mem_range.mp hj; omega)))
  simp only [Finset.sum_const,Finset.card_range,nsmul_eq_mul,le_refl]

theorem uniform_source_weighted_terminalND (offset : ℕ) {lam sig kap eta L C : ℝ}
    (hlam : 0 ≤ lam) (hsig : 0 < sig) (hkap : 0 < kap) (hkap1 : kap ≤ 1)
    (hgap : sig < kap/1000) (heta : 0 < eta) (hL : 0 ≤ L) (hC : 0 ≤ C) :
    ∃ N₀ : ℕ, 0 < N₀ ∧ ∀ N ≥ N₀, ∀ A : ℕ → ℝ,
      ProfileLipschitzND A N L → ∀ n : ℕ,
      ∀ b : PolicyBranch A N (sourcePolicyBlock N kap) offset sig n,
      (b.state 0).start+10*sourcePolicyBlock N kap ≤ (b.state 0).finish →
      b.weight C lam (eta/(2*(1+20/kap+1/sig))) *
        ((2:ℝ)^N)^(200*L*(sourcePolicyBlock N kap:ℝ)/N+C*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*L*kap+100*C*(lam+sig)/kap+eta) := by
  obtain ⟨N₀,hN₀,h₀⟩ := uniform_source_branch_exponentND offset hlam hsig hkap hkap1 hgap heta hL hC
  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 uniform_source_weighted_errorND (offset : ℕ) {lam sig kap T eps L C B : ℝ}
    (hsig : 0 < sig) (hkap : 0 < kap) (hkap1 : kap ≤ 1) (hgap : sig < kap/1000)
    (hL : 0 ≤ L) (hloss : C*(lam+sig) ≤ 1) (heps : eps ≤ 1)
    (hT : (3*L+2)*(20/kap+1/sig)+B ≤ T) :
    ∃ N₀ : ℕ, 0 < N₀ ∧ ∀ N ≥ N₀, ∀ A : ℕ → ℝ,
      ProfileLipschitzND A N L → ∀ n : ℕ,
      ∀ b : PolicyBranch A N (sourcePolicyBlock N kap) offset sig n,
      b.weight C lam eps*((2:ℝ)^N)^(-T) ≤ ((2:ℝ)^N)^(-B) := by
  obtain ⟨N₀,hN₀,h₀⟩ := uniform_source_ceiling_slack hsig hgap
  refine ⟨N₀,hN₀,?_⟩
  intro N hN A hA n b
  have hNp : 0 < N := by omega
  have hn := (source_branch_count_bounds hNp hsig hkap hkap1 (h₀ N hN).1 b).2.2
  have he := b.ancestor_exponent_boundND (eps := eps) hA hNp (sourcePolicyBlock_pos hNp hkap) hL hloss
  have hexp : b.exponentSum C lam eps-T ≤ -B := by
    have h₁ := mul_le_mul_of_nonneg_left hn (show 0 ≤ 3*L+2 by positivity)
    have h₂ := mul_le_mul_of_nonneg_left heps (Nat.cast_nonneg (α := ℝ) n)
    nlinarith
  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)) (by simpa [sub_eq_add_neg] using hexp)

end CurrentFalconer.DimensionalPolicy
end GraphLiteralSupport
end
end

end OAI