lean/OAI/MeasureTheory/Falconer/Recursion/InteriorPolicy.lean

import OAI.MeasureTheory.Falconer.Recursion.Ledger
import Mathlib.Data.Finset.Max

namespace OAI

namespace PlanarFalconer

noncomputable def finiteArgmin (S : Finset ℕ) (f : ℕ → ℝ) : ℕ :=
  if h : S.Nonempty then Classical.choose (Finset.exists_mem_eq_inf' h f) else 0

theorem finiteArgmin_spec {S : Finset ℕ} (hS : S.Nonempty) (f : ℕ → ℝ) :
    finiteArgmin S f ∈ S ∧ ∀ j ∈ S, f (finiteArgmin S f) ≤ f j := by
  rw [finiteArgmin,dite_eq_left hS]
  have hs := Classical.choose_spec (Finset.exists_mem_eq_inf' hS f)
  refine ⟨hs.1,?_⟩
  intro j hj
  rw [← hs.2]
  exact Finset.inf'_le f hj

def policyBlock (N q k : ℕ) : Finset ℕ := Finset.Ico (k*q) (min ((k+1)*q) (N+1))

noncomputable def policyRepresentative (A : ℕ → ℝ) (N q k : ℕ) : ℕ :=
  finiteArgmin (policyBlock N q k) A

def policyBlocks (N q a t : ℕ) : Finset ℕ :=
  (Finset.range (N/q+1)).filter fun k => a+q ≤ k*q ∧ (k+1)*q ≤ t-q+1

noncomputable def policyKey (A : ℕ → ℝ) (N q a t : ℕ) : ℕ :=
  finiteArgmin (policyBlocks N q a t) (fun k => A (policyRepresentative A N q k))

noncomputable def policyDepth (A : ℕ → ℝ) (N q a t : ℕ) : ℕ :=
  policyRepresentative A N q (policyKey A N q a t)

theorem policyBlock_nonempty {N q k : ℕ} (hq : 0 < q) (hk : k*q ≤ N) :
    (policyBlock N q k).Nonempty := by
  apply Finset.nonempty_Ico.mpr
  have he : (k+1)*q = k*q+q := by ring
  omega

theorem policyRepresentative_spec (A : ℕ → ℝ) {N q k : ℕ} (hq : 0 < q) (hk : k*q ≤ N) :
    k*q ≤ policyRepresentative A N q k ∧ policyRepresentative A N q k < (k+1)*q ∧
      policyRepresentative A N q k ≤ N ∧
      ∀ n ∈ policyBlock N q k, A (policyRepresentative A N q k) ≤ A n := by
  have hh := finiteArgmin_spec (policyBlock_nonempty hq hk) A
  have hm := Finset.mem_Ico.mp hh.1
  refine ⟨hm.1,lt_of_lt_of_le hm.2 (min_le_left _ _),?_,hh.2⟩
  exact Nat.le_of_lt_succ (lt_of_lt_of_le hm.2 (min_le_right _ _))

theorem policyBlocks_mem {N q a t k : ℕ} (h : k ∈ policyBlocks N q a t) :
    k ≤ N/q ∧ a+q ≤ k*q ∧ (k+1)*q ≤ t-q+1 := by
  obtain ⟨hk,hl,hr⟩ := Finset.mem_filter.mp h
  exact ⟨Nat.le_of_lt_succ (Finset.mem_range.mp hk),hl,hr⟩

theorem policy_left_block {N q a t : ℕ} (hq : 0 < q) (ht : t ≤ N) (hwide : a+100*q < t) :
    ∃ k ∈ policyBlocks N q a t, k*q ≤ a+2*q := by
  let k := (a+2*q-1)/q
  have hlo := Nat.div_mul_le_self (a+2*q-1) q
  have hhi := Nat.lt_mul_div_succ (a+2*q-1) hq
  have hprod : (k+1)*q = k*q+q := by ring
  change k*q ≤ a+2*q-1 at hlo
  have hceil : a+q ≤ k*q := by
    rw [Nat.mul_comm q] at hhi
    change a+2*q-1 < (k+1)*q at hhi
    omega
  have hend : (k+1)*q ≤ t-q+1 := by omega
  have hkn : k*q ≤ N := by omega
  refine ⟨k,Finset.mem_filter.mpr ⟨Finset.mem_range.mpr ?_,hceil,hend⟩,by omega⟩
  exact Nat.lt_succ_of_le ((Nat.le_div_iff_mul_le hq).mpr hkn)

theorem policy_right_block {N q a t : ℕ} (hq : 0 < q) (ht : t ≤ N) (hwide : a+100*q < t) :
    ∃ k ∈ policyBlocks N q a t, t-2*q ≤ (k+1)*q-1 := by
  let j := (t-q+1)/q
  have hj : 0 < j := Nat.div_pos (by omega) hq
  have hlo := Nat.div_mul_le_self (t-q+1) q
  have hhi := Nat.lt_mul_div_succ (t-q+1) hq
  change j*q ≤ t-q+1 at hlo
  rw [Nat.mul_comm q] at hhi
  change t-q+1 < (j+1)*q at hhi
  have hmul : (j+1)*q = j*q+q := by ring
  have he : (j-1+1)*q = j*q := by rw [Nat.sub_add_cancel hj]
  have he' : (j-1)*q+q = j*q := by simpa only [Nat.add_mul,one_mul] using he
  have hleft : a+q ≤ (j-1)*q := by omega
  have hkn : (j-1)*q ≤ N := by omega
  refine ⟨j-1,Finset.mem_filter.mpr ⟨Finset.mem_range.mpr ?_,hleft,by omega⟩,by omega⟩
  exact Nat.lt_succ_of_le ((Nat.le_div_iff_mul_le hq).mpr hkn)

theorem policyBlocks_nonempty {N q a t : ℕ} (hq : 0 < q) (ht : t ≤ N) (hwide : a+100*q < t) :
    (policyBlocks N q a t).Nonempty := by
  obtain ⟨k,hk,_⟩ := policy_left_block hq ht hwide
  exact ⟨k,hk⟩

theorem policyDepth_minimizes (A : ℕ → ℝ) {N q a t n : ℕ} (hq : 0 < q)
    (hne : (policyBlocks N q a t).Nonempty) (hn : n ≤ N)
    (hblock : n/q ∈ policyBlocks N q a t) : A (policyDepth A N q a t) ≤ A n := by
  have hkey := finiteArgmin_spec hne (fun k => A (policyRepresentative A N q k))
  have hcell : n ∈ policyBlock N q (n/q) := by
    apply Finset.mem_Ico.mpr
    have hlo := Nat.div_mul_le_self n q
    have hhi := Nat.lt_mul_div_succ n hq
    rw [Nat.mul_comm q] at hhi
    exact ⟨hlo,lt_min hhi (Nat.lt_succ_of_le hn)⟩
  exact (hkey.2 _ hblock).trans
    ((policyRepresentative_spec A hq ((Nat.div_mul_le_self n q).trans hn)).2.2.2 n hcell)

theorem policyDepth_interior (A : ℕ → ℝ) {N q a t : ℕ} (hq : 0 < q)
    (hne : (policyBlocks N q a t).Nonempty) :
    a+q ≤ policyDepth A N q a t ∧ policyDepth A N q a t ≤ t-q := by
  have hkey := (finiteArgmin_spec hne (fun k => A (policyRepresentative A N q k))).1
  have hb := policyBlocks_mem hkey
  have hrep := policyRepresentative_spec A hq ((Nat.le_div_iff_mul_le hq).mp hb.1)
  exact ⟨hb.2.1.trans hrep.1,Nat.le_of_lt_succ (hrep.2.1.trans_le hb.2.2)⟩

theorem policy_move_length (A : ℕ → ℝ) {N q a t : ℕ} (hq : 0 < q)
    (hne : (policyBlocks N q a t).Nonempty) :
    let p := policyDepth A N q a t
    let l := min (p-a) (t-p)
    q ≤ l ∧ a ≤ p-l ∧ p+l ≤ t := by
  have hh := policyDepth_interior A hq hne
  dsimp only
  omega

end PlanarFalconer

end OAI