lean/OAI/MeasureTheory/Falconer/Recursion/BranchLedger.lean

import OAI.MeasureTheory.Falconer.Graphs.GraphNormalization
import OAI.MeasureTheory.Falconer.Recursion.BranchExponentAlgebra

namespace OAI

/-! # The scheduled branch ledger with the ambient dimension retained

The policy branches and their payment identities are scalar combinatorics.
Their final-potential bound uses the dimension-dependent Lipschitz
constant.
-/
namespace Falconer
open PlanarFalconer
open scoped BigOperators

theorem dimension_profile_increment_le {A : ℕ → ℝ} {N : ℕ} {d : ℝ}
    (hN : 0 < N) (hd : 0 ≤ d)
    (hlip : ∀ i j, i ≤ N → j ≤ N → |A i-A j| ≤ d*|(i:ℝ)-j|/N)
    {i j : ℕ} (hi : i ≤ N) (hj : j ≤ N) : |A i-A j| ≤ d := by
  have hNR : (0:ℝ) < N := Nat.cast_pos.mpr hN
  have hi' : (i:ℝ) ≤ N := Nat.cast_le.mpr hi
  have hj' : (j:ℝ) ≤ N := Nat.cast_le.mpr hj
  have habs : |(i:ℝ)-j| ≤ N := abs_le.mpr
    ⟨by linarith [Nat.cast_nonneg (α := ℝ) i],by linarith [Nat.cast_nonneg (α := ℝ) j]⟩
  calc
    _ ≤ d*|(i:ℝ)-j|/N := hlip i j hi hj
    _ ≤ d*(N:ℝ)/N := div_le_div_of_nonneg_right
      (mul_le_mul_of_nonneg_left habs hd) hNR.le
    _ = d := by field_simp

theorem dimension_branch_cost_le {A : ℕ → ℝ} {N q : ℕ} {σ d : ℝ}
    (hN : 0 < N) (hq : 0 < q) (hd : 0 ≤ d)
    (hlip : ∀ i j, i ≤ N → j ≤ N → |A i-A j| ≤ d*|(i:ℝ)-j|/N)
    {s u : BranchState} {l : BranchLabel} (h : BranchStep A N q σ s l u)
    (hs : s.Valid N σ) (hu : u.Valid N σ) : branchCost A s l u ≤ d := by
  have hbound {a t i : ℕ} (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 (dimension_profile_increment_le hN hd hlip hi (hjt.trans ht))
  have hn := h.nested hq hs
  have hsd := BranchState.valid_depths hs
  have hud := BranchState.valid_depths hu
  cases h <;> simp only [branchCost]
  · exact hbound hn.2 hsd.2 hud.2
  · exact hd
  · exact hbound hn.1 (hud.1.trans hud.2) (hud.1.trans hud.2)
  · exact hd
  · exact hd
  · exact hbound hn.1 (hud.1.trans hud.2) (hud.1.trans hud.2)

theorem dimension_ancestor_exponent_bound {A : ℕ → ℝ} {N q n : ℕ} {lam σ ε d : ℝ}
    (b : PolicyBranch A N q σ n) (hN : 0 < N) (hq : 0 < q) (hd : 0 ≤ d)
    (hloss : 0 ≤ 4000*(lam+σ))
    (hlip : ∀ i j, i ≤ N → j ≤ N → |A i-A j| ≤ d*|(i:ℝ)-j|/N) :
    ∑ j ∈ Finset.range n, branchExponent A lam σ ε (b.state j) (b.label j) (b.state (j+1)) ≤
      (n:ℝ)*(3*d+4000*(lam+σ)+ε) := by
  calc
    _ ≤ ∑ _j ∈ Finset.range n, (3*d+4000*(lam+σ)+ε) := by
      apply Finset.sum_le_sum
      intro j hj
      have hj' := Finset.mem_range.mp hj
      have hs := b.valid j hj'.le
      have hu := b.valid (j+1) (by omega)
      have hc := dimension_branch_cost_le hN hq hd hlip (b.step j hj') hs hu
      have hi := abs_le.mp (dimension_profile_increment_le hN hd hlip
        ((BranchState.valid_depths hu).1.trans (BranchState.valid_depths hu).2)
        ((BranchState.valid_depths hs).1.trans (BranchState.valid_depths hs).2))
      unfold branchExponent
      split_ifs <;> linarith
    _ = _ := by simp only [Finset.sum_const,Finset.card_range,nsmul_eq_mul]

theorem dimension_branch_cost_bound {A : ℕ → ℝ} {N q n : ℕ} {σ d : ℝ}
    (b : PolicyBranch A N q σ n) (hN : 0 < N) (hq : 0 < q)
    (hslack : σ*(N:ℝ) ≤ q) (hd : 0 ≤ d)
    (hlip : ∀ i j, i ≤ N → j ≤ N → |A i-A j| ≤ d*|(i:ℝ)-j|/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 hpot (a t f : ℕ) (hw : a+10*q ≤ t) (ht : t ≤ N)
      (haf : a ≤ f) (hft : f ≤ t) :
      potential A a t (10*q) ≤ 2*A f+20*d*(q:ℝ)/N := by
    have hh := last_potential_bound A hQ hw haf hft hd hN
      (fun i _ hit => hlip i f (hit.trans ht) (hft.trans ht))
    convert hh using 1
    push_cast
    ring
  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 := hpot _ _ _ hw hfinal.2 le_rfl hfinal.1
    linarith
  · 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 hdepth := BranchState.valid_depths (b.valid n (by omega))
      have hc := (b.initialSegment n (by omega)).costs_le_potential hq hslack hpwide
      dsimp only [PolicyBranch.initialSegment] at hc
      have hz := hs.short_cost_zero hq (b.valid n (by omega)) hslack (by omega)
      have hf := hpot _ _ _ hpwide hdepth.2 hn.1 (hfinal.1.trans hn.2)
      rw [Finset.sum_range_succ,hz,add_zero]
      linarith

theorem dimension_source_branch_exponent {A : ℕ → ℝ} {N n : ℕ} {lam σ κ η d : ℝ}
    (hN : 0 < N) (hlam : 0 ≤ lam) (hσ : 0 < σ) (hκ : 0 < κ) (hκ1 : κ ≤ 1)
    (hη : 0 < η) (hd : 0 ≤ d)
    (hceil : ⌈10*σ*(N:ℝ)⌉₊ < sourcePolicyBlock N κ)
    (hslack : σ*(N:ℝ) ≤ sourcePolicyBlock N κ)
    (hlip : ∀ i j, i ≤ N → j ≤ N → |A i-A j| ≤ d*|(i:ℝ)-j|/N)
    (b : PolicyBranch A N (sourcePolicyBlock N κ) σ n)
    (hinit : (b.state 0).start+10*sourcePolicyBlock N κ ≤ (b.state 0).finish) :
    ∑ j ∈ Finset.range n,
      branchExponent A lam σ (η/(2*(1+20/κ+1/σ))) (b.state j) (b.label j) (b.state (j+1)) ≤
      2*A (b.state 0).start-
        potential A (b.state 0).start (b.state 0).finish (10*sourcePolicyBlock N κ)+
        20*d*(sourcePolicyBlock N κ:ℝ)/N+80000*(lam+σ)/κ+η/2 := by
  have hc := dimension_branch_cost_bound b hN (sourcePolicyBlock_pos hN hκ)
    hslack hd hlip hinit
  have hb := source_branch_count_bounds hN hσ hκ hκ1 hceil b
  let D : ℝ := 1+20/κ+1/σ
  have hD : 0 < D := by dsimp [D]; positivity
  have hηD : 0 ≤ η/(2*D) := by positivity
  have htime : (n:ℝ)*(η/(2*D)) ≤ η/2 := by
    have hn : (n:ℝ) ≤ D := by dsimp [D]; linarith [hb.2.2]
    calc
      _ ≤ D*(η/(2*D)) := mul_le_mul_of_nonneg_right hn hηD
      _ = η/2 := by field_simp
  have hloss : (branchNonlowCount b.label n:ℝ)*(4000*(lam+σ)) ≤ 80000*(lam+σ)/κ := by
    calc
      _ ≤ (20/κ)*(4000*(lam+σ)) := mul_le_mul_of_nonneg_right hb.1 (by positivity)
      _ = _ := by ring
  rw [branch_exponent_sum]
  dsimp only [D] at htime
  linarith

end Falconer

end OAI