lean/OAI/Combinatorics/EditApproximation/Binary/BinaryCellGridWork.lean

import OAI.Combinatorics.EditApproximation.Binary.BinaryCellCenters
import OAI.Combinatorics.EditApproximation.Binary.BinaryLocalGridWork
import OAI.Combinatorics.EditApproximation.Binary.BinaryAffineGuard

namespace OAI

/-! Word-size bounds for the literal whole-cell index scans. The
cardinalities here are the emitted local ranges, not the target length. -/

namespace EditApproximation
namespace BinaryFraction

private theorem naturalWordSize_le (bits : List Bool) : Nat.size (bitWordValue bits) ≤ bits.length :=
  Nat.size_le.mpr (bitWordValue_lt_pow_length bits)

def cellCoordinateSetupBitBudget (B : ℕ) : ℕ :=
  100 * (B + 1) + 4200 * (B + 6) ^ 2 + 400 * (4 * B + 21) ^ 2 + 100 * (4 * B + 25)

theorem cellCoordinatesWithWork_bounds (side : BinaryFraction) (p radius B : ℕ)
    (hs : side.width ≤ B) (hp : Nat.size p ≤ B) (hr : Nat.size radius ≤ B) :
    (cellCoordinatesWithWork side p radius).2 ≤
      cellCoordinateSetupBitBudget B + (localCellCoordinates side.value p radius).length ∧
      ∀ x ∈ (cellCoordinatesWithWork side p radius).1, Nat.size x ≤ 4 * B + 23 := by
  let lower := saturatingSubtractWithWork p radius
  let upper := binaryNaturalAddWithWork p radius
  let firstQ := divWithWork (nat (bitWordValue lower.1)) side
  let lastQ := divWithWork (nat (bitWordValue upper.1)) side
  let first := naturalFloorWithWork firstQ.1
  let last := naturalFloorWithWork lastQ.1
  let stop := binaryNaturalAddWithWork (bitWordValue last.1) 1
  let count := saturatingSubtractWithWork (bitWordValue stop.1) (bitWordValue first.1)
  have hl : Nat.size (bitWordValue lower.1) ≤ B := by
    rw [saturatingSubtractWithWork_value]
    exact (Nat.size_le_size (Nat.sub_le _ _)).trans hp
  have hu : Nat.size (bitWordValue upper.1) ≤ B + 2 := by
    rw [binaryNaturalAddWithWork_value]
    exact (binaryNaturalAdd_size_le p radius).trans (by omega)
  have hfl := divWithWork_width_uniform (nat (bitWordValue lower.1)) side (B + 4)
    ((nat_width_le _).trans (by omega)) (by omega)
  have hll := divWithWork_width_uniform (nat (bitWordValue upper.1)) side (B + 4)
    ((nat_width_le _).trans (by omega)) (by omega)
  have hfc := divWithWork_cost (nat (bitWordValue lower.1)) side (B + 4)
    ((nat_width_le _).trans (by omega)) (by omega)
  have hlc := divWithWork_cost (nat (bitWordValue upper.1)) side (B + 4)
    ((nat_width_le _).trans (by omega)) (by omega)
  change firstQ.1.width ≤ _ at hfl
  change lastQ.1.width ≤ _ at hll
  change firstQ.2 ≤ _ at hfc
  change lastQ.2 ≤ _ at hlc
  simp only [Nat.add_assoc, Nat.reduceAdd] at hfc hlc
  have hf := naturalFloorWithWork_bounds firstQ.1
  have hl' := naturalFloorWithWork_bounds lastQ.1
  have hfirst : Nat.size (bitWordValue first.1) ≤ 4 * B + 20 :=
    ((naturalWordSize_le _).trans hf.1).trans (by omega)
  have hlast : Nat.size (bitWordValue last.1) ≤ 4 * B + 20 :=
    ((naturalWordSize_le _).trans hl'.1).trans (by omega)
  have hstop : Nat.size (bitWordValue stop.1) ≤ 4 * B + 23 := by
    rw [binaryNaturalAddWithWork_value]
    exact (binaryNaturalAdd_size_le _ 1).trans (by simp only [Nat.size_one]; omega)
  have hfloorFirst : first.2 ≤ 200 * (4 * B + 21) ^ 2 :=
    hf.2.trans (Nat.mul_le_mul_left _ (Nat.pow_le_pow_left (by omega) _))
  have hfloorLast : last.2 ≤ 200 * (4 * B + 21) ^ 2 :=
    hl'.2.trans (Nat.mul_le_mul_left _ (Nat.pow_le_pow_left (by omega) _))
  have hlowCost := saturatingSubtractWithWork_cost p radius
  have huppCost := binaryNaturalAddWithWork_cost p radius
  have hstopCost := binaryNaturalAddWithWork_cost (bitWordValue last.1) 1
  have hcountCost := saturatingSubtractWithWork_cost (bitWordValue stop.1) (bitWordValue first.1)
  change lower.2 ≤ _ at hlowCost
  change upper.2 ≤ _ at huppCost
  change stop.2 ≤ _ at hstopCost
  change count.2 ≤ _ at hcountCost
  simp only [Nat.size_one] at hstopCost
  have hlength : (List.range' (bitWordValue first.1) (bitWordValue count.1)).length =
      (localCellCoordinates side.value p radius).length := by
    have hv := congrArg List.length (cellCoordinatesWithWork_value side p radius)
    simpa only [cellCoordinatesWithWork, lower, upper, firstQ, lastQ, first, last,
      stop, count] using hv
  constructor
  · change lower.2 + upper.2 + firstQ.2 + lastQ.2 + first.2 + last.2 + stop.2 + count.2 +
      (List.range' (bitWordValue first.1) (bitWordValue count.1)).length + Nat.size p + Nat.size radius + 9 ≤ _
    rw [hlength]
    unfold cellCoordinateSetupBitBudget
    omega
  · intro x hx
    have hx' : x ∈ List.range' (bitWordValue first.1) (bitWordValue count.1) := by
      simpa only [cellCoordinatesWithWork, lower, upper, firstQ, lastQ, first, last,
        stop, count] using hx
    obtain ⟨j, hj, hxj⟩ := List.mem_range'.mp hx'
    have hcount : bitWordValue count.1 = bitWordValue stop.1 - bitWordValue first.1 :=
      saturatingSubtractWithWork_value _ _
    have hxstop : x ≤ bitWordValue stop.1 := by omega
    exact (Nat.size_le_size hxstop).trans hstop

theorem cellCoordinatesWithWork_cost (side : BinaryFraction) (p radius B : ℕ)
    (hs : side.width ≤ B) (hp : Nat.size p ≤ B) (hr : Nat.size radius ≤ B) :
    (cellCoordinatesWithWork side p radius).2 ≤
      cellCoordinateSetupBitBudget B + (localCellCoordinates side.value p radius).length :=
  (cellCoordinatesWithWork_bounds side p radius B hs hp hr).1

def targetCellsBitBudget (left right B : ℕ) : ℕ :=
  2 * cellCoordinateSetupBitBudget B + left + right + left * (5 * right + 3) + 2

theorem targetCellsWithWork_cost {n : ℕ} (side : BinaryFraction) (radius B : ℕ)
    (query : TargetInterval n) (hs : side.width ≤ B) (hn : Nat.size n ≤ B)
    (hr : Nat.size radius ≤ B) :
    (targetCellsWithWork side radius query).2 ≤ targetCellsBitBudget
      (localCellCoordinates side.value query.lo radius).length
      (localCellCoordinates side.value query.hi radius).length B := by
  let left := cellCoordinatesWithWork side query.lo radius
  let right := cellCoordinatesWithWork side query.hi radius
  have hl := cellCoordinatesWithWork_cost side query.lo radius B hs
    ((Nat.size_le_size (query.ordered.trans query.valid)).trans hn) hr
  have hh := cellCoordinatesWithWork_cost side query.hi radius B hs
    ((Nat.size_le_size query.valid).trans hn) hr
  have hm (lo : ℕ) : (arithmeticMapWithWork (fun hi => ((lo, hi), 1)) right.1).2 ≤
      right.1.length * 4 := arithmeticMapWithWork_cost _ _ 1 (fun _ _ => le_rfl)
  have hf := arithmeticFlatMapWithWork_cost
    (fun lo => arithmeticMapWithWork (fun hi => ((lo, hi), 1)) right.1) left.1
    (right.1.length * 4) right.1.length (fun lo _ => hm lo)
    (fun _ _ => by simp only [arithmeticMapWithWork_value, List.length_map]; exact le_rfl)
  change left.2 ≤ _ at hl
  change right.2 ≤ _ at hh
  change left.2 + right.2 + (arithmeticFlatMapWithWork
    (fun lo => arithmeticMapWithWork (fun hi => ((lo, hi), 1)) right.1) left.1).2 + 2 ≤ _
  have hleft : left.1.length = (localCellCoordinates side.value query.lo radius).length :=
    congrArg List.length (cellCoordinatesWithWork_value side query.lo radius)
  have hright : right.1.length = (localCellCoordinates side.value query.hi radius).length :=
    congrArg List.length (cellCoordinatesWithWork_value side query.hi radius)
  have hflat : (arithmeticFlatMapWithWork
      (fun lo => arithmeticMapWithWork (fun hi => ((lo, hi), 1)) right.1) left.1).2 ≤
      (localCellCoordinates side.value query.lo radius).length *
        (5 * (localCellCoordinates side.value query.hi radius).length + 3) := by
    calc
      _ ≤ left.1.length * (right.1.length * 4 + right.1.length + 3) := hf
      _ = _ := by rw [hleft, hright]; ring
  unfold targetCellsBitBudget
  omega


theorem targetCellsWithWork_keys {n : ℕ} (side : BinaryFraction) (radius B : ℕ)
    (query : TargetInterval n) (hs : side.width ≤ B) (hn : Nat.size n ≤ B)
    (hr : Nat.size radius ≤ B) (cell : ℕ × ℕ)
    (hcell : cell ∈ (targetCellsWithWork side radius query).1) :
    Nat.size cell.1 ≤ 4 * B + 23 ∧ Nat.size cell.2 ≤ 4 * B + 23 := by
  have hl := (cellCoordinatesWithWork_bounds side query.lo radius B hs
    ((Nat.size_le_size (query.ordered.trans query.valid)).trans hn) hr).2
  have hh := (cellCoordinatesWithWork_bounds side query.hi radius B hs
    ((Nat.size_le_size query.valid).trans hn) hr).2
  simp only [targetCellsWithWork, arithmeticFlatMapWithWork_value,
    arithmeticMapWithWork_value] at hcell
  obtain ⟨lo, hlo, hc⟩ := List.mem_flatMap.mp hcell
  obtain ⟨hi, hhi, rfl⟩ := List.mem_map.mp hc
  exact ⟨hl lo hlo, hh hi hhi⟩

def cellGridSetupBitBudget (B : ℕ) : ℕ := 2000000 * (B + 100) ^ 2

def cellGridPointBitBudget (B : ℕ) : ℕ := 1000 * (B + 100) ^ 2

def cellGridPointsBitBudget (count B : ℕ) : ℕ :=
  cellGridSetupBitBudget B + count * (cellGridPointBitBudget B + 5)

theorem cellGridPointsWithWork_bounds (side : BinaryFraction) (g cell B : ℕ)
    (hs : side.width ≤ B) (hg : Nat.size g ≤ B) (hc : Nat.size cell ≤ B) :
    (cellGridPointsWithWork side g cell).2 ≤
      cellGridPointsBitBudget (cellGridPoints side.value g cell).length B ∧
      ∀ x ∈ (cellGridPointsWithWork side g cell).1, Nat.size x ≤ 17 * B + 78 := by
  let next := binaryNaturalAddWithWork cell 1
  let lower := canonicalMulWithWork (nat cell) side
  let upper := canonicalMulWithWork (nat (bitWordValue next.1)) side
  let firstQ := divWithWork lower.1 (nat g)
  let lastQ := divWithWork upper.1 (nat g)
  let first := naturalCeilingWithWork firstQ.1
  let last := naturalCeilingWithWork lastQ.1
  let count := saturatingSubtractWithWork (bitWordValue last.1) (bitWordValue first.1)
  let indices := List.range' (bitWordValue first.1) (bitWordValue count.1)
  have hnext : Nat.size (bitWordValue next.1) ≤ B + 2 := by
    rw [binaryNaturalAddWithWork_value]
    have hv := naturalWordSize_le (binaryNaturalAddWithWork cell 1).1
    rw [binaryNaturalAddWithWork_value] at hv
    have hl := bitAddWithWork_length cell.bits (1 : ℕ).bits false
    have h : Nat.size (cell + 1) ≤ max (Nat.size cell) 1 + 1 := by
      simpa only [binaryNaturalAddWithWork, Nat.size_eq_bits_len, Nat.size_one] using hv.trans hl
    omega
  have hlow := canonicalMulWithWork_width (nat cell) side (B + 4)
    ((nat_width_le cell).trans (by omega)) (by omega)
  have hupp := canonicalMulWithWork_width (nat (bitWordValue next.1)) side (B + 4)
    ((nat_width_le _).trans (by omega)) (by omega)
  change lower.1.width ≤ _ at hlow
  change upper.1.width ≤ _ at hupp
  have hfirstQ := divWithWork_width_uniform lower.1 (nat g) (4 * B + 18)
    (by omega) ((nat_width_le g).trans (by omega))
  have hlastQ := divWithWork_width_uniform upper.1 (nat g) (4 * B + 18)
    (by omega) ((nat_width_le g).trans (by omega))
  change firstQ.1.width ≤ _ at hfirstQ
  change lastQ.1.width ≤ _ at hlastQ
  have hfirst : Nat.size (bitWordValue first.1) ≤ 16 * B + 78 := by
    have h := (naturalWordSize_le first.1).trans (naturalCeilingWithWork_length firstQ.1)
    omega
  have hlast : Nat.size (bitWordValue last.1) ≤ 16 * B + 78 := by
    have h := (naturalWordSize_le last.1).trans (naturalCeilingWithWork_length lastQ.1)
    omega
  have hindex (i : ℕ) (hi : i ∈ indices) : Nat.size i ≤ 16 * B + 78 := by
    obtain ⟨j, hj, hij⟩ := List.mem_range'.mp hi
    have hcount : bitWordValue count.1 = bitWordValue last.1 - bitWordValue first.1 :=
      saturatingSubtractWithWork_value _ _
    have hle : i ≤ bitWordValue last.1 := by omega
    exact (Nat.size_le_size hle).trans hlast
  let point := fun i =>
    let product := binaryNaturalMulWithWork g i
    (bitWordValue product.1, product.2 + Nat.size i + 2)
  have hpoint (i : ℕ) (hi : i ∈ indices) : (point i).2 ≤ cellGridPointBitBudget B := by
    have hm := binaryNaturalMulWithWork_cost g i
    have his := hindex i hi
    dsimp only [point]
    unfold cellGridPointBitBudget
    nlinarith only [hm, his, hg, Nat.zero_le B]
  have hmap := arithmeticMapWithWork_cost point indices (cellGridPointBitBudget B) hpoint
  have hmaplen : indices.length = (cellGridPoints side.value g cell).length := by
    have hv := congrArg List.length (cellGridPointsWithWork_value side g cell)
    simpa only [cellGridPointsWithWork, arithmeticMapWithWork_value, List.length_map] using hv
  have hnextc := binaryNaturalAddWithWork_cost cell 1
  have hlowc := canonicalMulWithWork_cost (nat cell) side (B + 4)
    ((nat_width_le cell).trans (by omega)) (by omega)
  have huppc := canonicalMulWithWork_cost (nat (bitWordValue next.1)) side (B + 4)
    ((nat_width_le _).trans (by omega)) (by omega)
  have hfirstc := divWithWork_cost lower.1 (nat g) (4 * B + 18)
    (by omega) ((nat_width_le g).trans (by omega))
  have hlastc := divWithWork_cost upper.1 (nat g) (4 * B + 18)
    (by omega) ((nat_width_le g).trans (by omega))
  have hfc := (naturalCeilingWithWork_cost firstQ.1).trans
    (Nat.mul_le_mul_left 500 (Nat.pow_le_pow_left (by omega : firstQ.1.width + 1 ≤ 16 * B + 77) 2))
  have hlc := (naturalCeilingWithWork_cost lastQ.1).trans
    (Nat.mul_le_mul_left 500 (Nat.pow_le_pow_left (by omega : lastQ.1.width + 1 ≤ 16 * B + 77) 2))
  have hcc := saturatingSubtractWithWork_cost (bitWordValue last.1) (bitWordValue first.1)
  change next.2 ≤ _ at hnextc
  change lower.2 ≤ _ at hlowc
  change upper.2 ≤ _ at huppc
  change firstQ.2 ≤ _ at hfirstc
  change lastQ.2 ≤ _ at hlastc
  change first.2 ≤ _ at hfc
  change last.2 ≤ _ at hlc
  change count.2 ≤ _ at hcc
  simp only [Nat.size_one, Nat.add_assoc, Nat.reduceAdd] at hnextc hlowc huppc hfirstc hlastc
  have hsetup : next.2 + lower.2 + upper.2 + firstQ.2 + lastQ.2 + first.2 + last.2 + count.2 +
      Nat.size cell + Nat.size g + 10 ≤ cellGridSetupBitBudget B := by
    unfold cellGridSetupBitBudget
    nlinarith only [hnextc, hlowc, huppc, hfirstc, hlastc, hfc, hlc, hcc,
      hfirst, hlast, hc, hg, Nat.zero_le B]
  constructor
  · change next.2 + lower.2 + upper.2 + firstQ.2 + lastQ.2 + first.2 + last.2 + count.2 +
      (arithmeticMapWithWork point indices).2 + indices.length + Nat.size cell + Nat.size g + 10 ≤ _
    unfold cellGridPointsBitBudget
    rw [← hmaplen]
    nlinarith only [hsetup, hmap, Nat.zero_le indices.length]
  · intro x hx
    have hx' : x ∈ (arithmeticMapWithWork point indices).1 := by
      simpa only [cellGridPointsWithWork, next, lower, upper, firstQ, lastQ, first,
        last, count, indices, point] using hx
    rw [arithmeticMapWithWork_value] at hx'
    obtain ⟨i, hi, rfl⟩ := List.mem_map.mp hx'
    dsimp only [point]
    rw [binaryNaturalMulWithWork_value]
    have hprod := natural_product_bit_length g i
    have hidx := hindex i hi
    omega

theorem cellGridPointsWithWork_cost (side : BinaryFraction) (g cell B : ℕ)
    (hs : side.width ≤ B) (hg : Nat.size g ≤ B) (hc : Nat.size cell ≤ B) :
    (cellGridPointsWithWork side g cell).2 ≤
      cellGridPointsBitBudget (cellGridPoints side.value g cell).length B :=
  (cellGridPointsWithWork_bounds side g cell B hs hg hc).1


def cellStatesBitBudget (left right B : ℕ) : ℕ :=
  cellGridPointsBitBudget left B + cellGridPointsBitBudget right B +
    left * (right * (16 * (17 * B + 78) + 11) + right + 3) + 2

theorem cellStatesWithWork_cost (n g B : ℕ) (side : BinaryFraction) (cell : ℕ × ℕ)
    (hn : Nat.size n ≤ B) (hg : Nat.size g ≤ B) (hs : side.width ≤ B)
    (hleft : Nat.size cell.1 ≤ B) (hright : Nat.size cell.2 ≤ B) :
    (cellStatesWithWork n g side cell).2 ≤ cellStatesBitBudget
      (cellGridPoints side.value g cell.1).length (cellGridPoints side.value g cell.2).length B := by
  let left := cellGridPointsWithWork side g cell.1
  let right := cellGridPointsWithWork side g cell.2
  have hl := cellGridPointsWithWork_bounds side g cell.1 B hs hg hleft
  have hr := cellGridPointsWithWork_bounds side g cell.2 B hs hg hright
  have htest (lo : ℕ) (hlo : lo ∈ left.1) :
      (filterMapWithWork (makeStateWithWork n lo) right.1).2 ≤
        right.1.length * (16 * (17 * B + 78) + 11) := by
    exact filterMapWithWork_cost _ _ (16 * (17 * B + 78) + 8) (fun hi hhi =>
      makeStateWithWork_cost n lo hi (17 * B + 78) (by omega) (hl.2 lo hlo) (hr.2 hi hhi))
  have hlen (lo : ℕ) : (filterMapWithWork (makeStateWithWork n lo) right.1).1.length ≤
      right.1.length := by
    rw [filterMapWithWork_value]
    exact List.length_filterMap_le _ _
  have hf := arithmeticFlatMapWithWork_cost (fun lo => filterMapWithWork (makeStateWithWork n lo) right.1)
    left.1 (right.1.length * (16 * (17 * B + 78) + 11)) right.1.length
    htest (fun lo _ => hlen lo)
  have hll : left.1.length = (cellGridPoints side.value g cell.1).length :=
    congrArg List.length (cellGridPointsWithWork_value side g cell.1)
  have hrl : right.1.length = (cellGridPoints side.value g cell.2).length :=
    congrArg List.length (cellGridPointsWithWork_value side g cell.2)
  rw [hll, hrl] at hf
  change left.2 + right.2 + (arithmeticFlatMapWithWork
    (fun lo => filterMapWithWork (makeStateWithWork n lo) right.1) left.1).2 + 2 ≤ _
  unfold cellStatesBitBudget
  have hlc : left.2 ≤ _ := hl.1
  have hrc : right.2 ≤ _ := hr.1
  omega

end BinaryFraction
end EditApproximation

end OAI