lean/OAI/Combinatorics/EditApproximation/Binary/BinaryBandGuardWork.lean

import OAI.Combinatorics.EditApproximation.Binary.BinaryPrefixWork
import OAI.Combinatorics.EditApproximation.Binary.BinaryAffineGuard
import OAI.Combinatorics.EditApproximation.Refinement.ComputedBands
import OAI.Combinatorics.EditApproximation.Definitions


namespace OAI

/-! Exact finite band predicates evaluated on stored Boolean fractions.
The cut tests use the actual finite prefix minimum; the other tests are
Boolean comparisons of the actual interval endpoints. -/

namespace EditApproximation

open Finset



@[simp] theorem naturalEqualWithWork_value (a b : ℕ) :
    (naturalEqualWithWork a b).1 = true ↔ a = b := by
  simp only [naturalEqualWithWork, decide_eq_true_eq, binaryNaturalCompareWithWork_eq]

theorem naturalEqualWithWork_cost (a b B : ℕ) (ha : Nat.size a ≤ B) (hb : Nat.size b ≤ B) :
    (naturalEqualWithWork a b).2 ≤ 8 * B + 2 := by
  have h := binaryNaturalCompareWithWork_cost a b
  change (binaryNaturalCompareWithWork a b).2 + 1 ≤ _
  omega



@[simp] theorem zeroConnectionWithWork_value {n : ℕ} (start finish : ℕ)
    (states : List (TargetInterval n)) :
    (zeroConnectionWithWork start states finish).1 = true ↔
      connectionBudget start states finish = 0 := by
  induction states generalizing start with
  | nil =>
    change (naturalEqualWithWork start finish).1 = true ↔ Nat.dist start finish = 0
    exact (naturalEqualWithWork_value start finish).trans
      ⟨Nat.dist_eq_zero, Nat.eq_of_dist_eq_zero⟩
  | cons state rest ih =>
    change ((naturalEqualWithWork start state.lo).1 &&
      (zeroConnectionWithWork state.hi rest finish).1) = true ↔
        Nat.dist start state.lo + connectionBudget state.hi rest finish = 0
    rw [Bool.and_eq_true, naturalEqualWithWork_value, ih, Nat.add_eq_zero_iff]
    constructor
    · rintro ⟨hs, ht⟩
      exact ⟨Nat.dist_eq_zero hs, ht⟩
    · rintro ⟨hs, ht⟩
      exact ⟨Nat.eq_of_dist_eq_zero hs, ht⟩

theorem zeroConnectionWithWork_cost {n : ℕ} (start finish : ℕ)
    (states : List (TargetInterval n)) (B : ℕ)
    (hs : Nat.size start ≤ B) (hf : Nat.size finish ≤ B)
    (he : ∀ s ∈ states, Nat.size s.lo ≤ B ∧ Nat.size s.hi ≤ B) :
    (zeroConnectionWithWork start states finish).2 ≤ (states.length + 1) * (8 * B + 3) := by
  induction states generalizing start with
  | nil =>
    have h := naturalEqualWithWork_cost start finish B hs hf
    simpa only [zeroConnectionWithWork, List.length_nil, zero_add, one_mul] using
      h.trans (by omega : 8 * B + 2 ≤ 8 * B + 3)
  | cons state rest ih =>
    have hstate := he state List.mem_cons_self
    have hc := naturalEqualWithWork_cost start state.lo B hs hstate.1
    have ht := ih state.hi hstate.2 (fun s h => he s (List.mem_cons_of_mem _ h))
    change _ + _ + 1 ≤ _
    simp only [List.length_cons]
    rw [show rest.length + 1 + 1 = (rest.length + 1) + 1 by omega, Nat.add_mul, Nat.one_mul]
    omega

/-- Construct a translated endpoint by the actual binary subtract/add routines. -/


@[simp] theorem translatedEndpointWithWork_value (reference root endpoint : ℕ) (h : root ≤ endpoint) :
    (translatedEndpointWithWork reference root endpoint).1 = reference + (endpoint - root) := by
  simp only [translatedEndpointWithWork, binaryNaturalAddWithWork_value,
    binaryNaturalSubtractWithWork_value endpoint root h]

theorem translatedEndpointWithWork_cost (reference root endpoint B : ℕ)
    (h : root ≤ endpoint) (hr : Nat.size reference ≤ B)
    (hroot : Nat.size root ≤ B) (he : Nat.size endpoint ≤ B) :
    (translatedEndpointWithWork reference root endpoint).2 ≤ 36 * B + 4 := by
  have hd := binaryNaturalSubtractWithWork_cost endpoint root
  have ha := binaryNaturalAddWithWork_cost reference
    (bitWordValue (binaryNaturalSubtractWithWork endpoint root).1)
  have hw : Nat.size (bitWordValue (binaryNaturalSubtractWithWork endpoint root).1) ≤ B := by
    rw [binaryNaturalSubtractWithWork_value endpoint root h]
    exact (Nat.size_le_size (Nat.sub_le endpoint root)).trans he
  change _ + _ + 2 ≤ _
  omega

namespace BinaryFraction

private theorem nat_dist_cast (a b : ℕ) : (Nat.dist a b : ℚ) = |(a : ℚ) - b| := by
  rcases le_total a b with h | h
  · rw [Nat.dist_eq_sub_of_le h, Nat.cast_sub h, abs_of_nonpos (sub_nonpos.mpr (by exact_mod_cast h))]
    ring
  · rw [Nat.dist_eq_sub_of_le_right h, Nat.cast_sub h, abs_of_nonneg (sub_nonneg.mpr (by exact_mod_cast h))]



@[simp] theorem naturalDistanceLeWithWork_value (a b radius : ℕ) :
    (naturalDistanceLeWithWork a b radius).1 = true ↔ Nat.dist a b ≤ radius := by
  simp only [naturalDistanceLeWithWork, leWithWork_value, distanceWithWork_value, nat_value]
  rw [← nat_dist_cast]
  constructor <;> intro h <;> exact_mod_cast h

def naturalDistanceBitBudget (B : ℕ) : ℕ :=
  6000 * (B + 1) ^ 2 + 2 + (1000 * (8 * B + 7) ^ 2 + 1) + 3 * B + 3

theorem naturalDistanceLeWithWork_cost (a b radius B : ℕ)
    (ha : Nat.size a + 2 ≤ B) (hb : Nat.size b + 2 ≤ B)
    (hr : Nat.size radius + 2 ≤ B) :
    (naturalDistanceLeWithWork a b radius).2 ≤ naturalDistanceBitBudget B := by
  have hdw := distanceWithWork_width (nat a) (nat b) B
    ((nat_width_le a).trans ha) ((nat_width_le b).trans hb)
  have hd := distanceWithWork_cost (nat a) (nat b) B
    ((nat_width_le a).trans ha) ((nat_width_le b).trans hb)
  have hc := leWithWork_cost (distanceWithWork (nat a) (nat b)).1 (nat radius)
    (8 * B + 6) hdw ((nat_width_le radius).trans (by omega))
  simp only [Nat.add_assoc, Nat.reduceAdd] at hc
  change _ + _ + Nat.size a + Nat.size b + Nat.size radius + 3 ≤ _
  unfold naturalDistanceBitBudget
  omega

def cutGuardWithWork {nx ny M : ℕ} (parent : TargetInterval nx)
    (r : TargetInterval ny) (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ [])
    (child : Fin M → TargetInterval ny → BinaryFraction) (states : Fin M → TargetInterval ny)
    (velocity tolerance : BinaryFraction) (j : Fin M) : Bool × ℕ :=
  if j.val = 0 then (true, 1) else
    let shift := subWithWork (nat (states j).lo) (nat (sourceChild parent j).lo)
    let offset := subWithWork (nat r.lo) (nat parent.lo)
    let prediction := prefixMinimumWithWork parent r actions hne child j.val shift.1
    let result := affineErrorWithWork shift.1 offset.1 velocity prediction.1 tolerance
    (result.1, shift.2 + offset.2 + prediction.2 + result.2 +
      Nat.size (states j).lo + Nat.size (sourceChild parent j).lo + Nat.size r.lo + Nat.size parent.lo + 5)

@[simp] theorem cutGuardWithWork_value {nx ny M : ℕ} (parent : TargetInterval nx)
    (r : TargetInterval ny) (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ [])
    (child : Fin M → TargetInterval ny → BinaryFraction) (states : Fin M → TargetInterval ny)
    (velocity tolerance : BinaryFraction) (j : Fin M) :
    (cutGuardWithWork parent r actions hne child states velocity tolerance j).1 = true ↔
      (0 < j.val → |bandCutShift parent states j - ((r.lo : ℚ) - parent.lo) - velocity.value *
        rationalWidePrefixMinimum parent r actions hne (fun i q => (child i q).value)
          j.val (bandCutShift parent states j)| ≤ tolerance.value) := by
  by_cases hj : j.val = 0
  · simp [cutGuardWithWork, hj]
  · rw [cutGuardWithWork, ite_eq_right hj]
    dsimp only
    rw [affineErrorWithWork_value]
    simp only [subWithWork_value, nat_value, prefixMinimumWithWork_value, bandCutShift]
    constructor
    · intro h _
      exact h
    · intro h
      exact h (Nat.pos_of_ne_zero hj)

def cutGuardWordBudget (M j B : ℕ) : ℕ :=
  prefixWordBudget M j (8 * B + 6) + 76 * B + 50

def cutGuardBitBudget (M j v B : ℕ) : ℕ :=
  2 * (6000 * (B + 1) ^ 2 + 1) +
    prefixMinimumBitBudget M j v (8 * B + 6) +
    affineGuardBitBudget (cutGuardWordBudget M j B) + 4 * B + 6

theorem cutGuardWithWork_cost {nx ny M : ℕ} (parent : TargetInterval nx)
    (r : TargetInterval ny) (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ [])
    (child : Fin M → TargetInterval ny → BinaryFraction) (states : Fin M → TargetInterval ny)
    (velocity tolerance : BinaryFraction) (j : Fin M) (B : ℕ)
    (hvel : velocity.width ≤ B) (htol : tolerance.width ≤ 64 * B + 44)
    (hr : Nat.size r.lo + 2 ≤ B) (hp : Nat.size parent.lo + 2 ≤ B)
    (hs : Nat.size (states j).lo + 2 ≤ B)
    (hc : Nat.size (sourceChild parent j).lo + 2 ≤ B)
    (hcut : Nat.size (balancedCut parent.lo (parent.hi - parent.lo) M j.val) + 2 ≤ B)
    (hstates : ∀ action ∈ actions, ∀ i,
      Nat.size (action i).lo + 2 ≤ B ∧ Nat.size (action i).hi + 2 ≤ B)
    (hchild : ∀ action ∈ actions, ∀ i, (child i (action i)).width ≤ B) :
    (cutGuardWithWork parent r actions hne child states velocity tolerance j).2 ≤
      cutGuardBitBudget M j.val actions.length B := by
  by_cases hj : j.val = 0
  · simp only [cutGuardWithWork, hj, ↓reduceIte]
    unfold cutGuardBitBudget
    omega
  · have hshift := subWithWork_width (nat (states j).lo) (nat (sourceChild parent j).lo) B
      ((nat_width_le _).trans hs) ((nat_width_le _).trans hc)
    have hoffset := subWithWork_width (nat r.lo) (nat parent.lo) B
      ((nat_width_le _).trans hr) ((nat_width_le _).trans hp)
    have hshiftCost := subWithWork_cost (nat (states j).lo) (nat (sourceChild parent j).lo) B
      ((nat_width_le _).trans hs) ((nat_width_le _).trans hc)
    have hoffsetCost := subWithWork_cost (nat r.lo) (nat parent.lo) B
      ((nat_width_le _).trans hr) ((nat_width_le _).trans hp)
    have hlarge : B ≤ 8 * B + 6 := by omega
    obtain ⟨hpred, hpredCost⟩ := prefixMinimumWithWork_bounds parent r actions hne child j.val
      (subWithWork (nat (states j).lo) (nat (sourceChild parent j).lo)).1 (8 * B + 6)
      hshift (hr.trans hlarge) (hcut.trans hlarge)
      (fun action ha i => ⟨(hstates action ha i).1.trans hlarge,
        (hstates action ha i).2.trans hlarge⟩)
      (fun action ha i => (hchild action ha i).trans hlarge)
    have herr := affineErrorWithWork_cost
      (subWithWork (nat (states j).lo) (nat (sourceChild parent j).lo)).1
      (subWithWork (nat r.lo) (nat parent.lo)).1 velocity
      (prefixMinimumWithWork parent r actions hne child j.val
        (subWithWork (nat (states j).lo) (nat (sourceChild parent j).lo)).1).1
      tolerance (cutGuardWordBudget M j.val B)
      (by unfold cutGuardWordBudget; omega) (by unfold cutGuardWordBudget; omega)
      (by unfold cutGuardWordBudget; omega) (by unfold cutGuardWordBudget; omega)
      (by unfold cutGuardWordBudget; omega)
    simp only [cutGuardWithWork, hj, ↓reduceIte]
    unfold cutGuardBitBudget
    omega

def bandPredicateWithWork {nx ny M : ℕ} (parent : TargetInterval nx)
    (r : TargetInterval ny) (b : ℕ) (tau theta velocity : BinaryFraction)
    (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ [])
    (child : Fin M → TargetInterval ny → BinaryFraction) (states : Fin M → TargetInterval ny) : Bool × ℕ :=
  let connection := zeroConnectionWithWork r.lo (List.ofFn states) r.hi
  let anchors := allWithWork (fun i : Fin M =>
    let leftAnchor := translatedEndpointWithWork r.lo parent.lo (sourceChild parent i).lo
    let rightAnchor := translatedEndpointWithWork r.lo parent.lo (sourceChild parent i).hi
    let radius := binaryNaturalMulWithWork 6 b
    let left := naturalDistanceLeWithWork leftAnchor.1 (states i).lo (bitWordValue radius.1)
    let right := naturalDistanceLeWithWork rightAnchor.1 (states i).hi (bitWordValue radius.1)
    (left.1 && right.1, leftAnchor.2 + rightAnchor.2 + radius.2 + left.2 + right.2 + 3)) (List.finRange M)
  let tolerance := bandToleranceWithWork tau theta b M
  let cuts := allWithWork (cutGuardWithWork parent r actions hne child states velocity tolerance.1)
    (List.finRange M)
  (connection.1 && anchors.1 && cuts.1, connection.2 + anchors.2 + tolerance.2 + cuts.2 + 4)

@[simp] theorem bandPredicateWithWork_value {nx ny M : ℕ} (parent : TargetInterval nx)
    (r : TargetInterval ny) (b : ℕ) (tau theta velocity : BinaryFraction)
    (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ [])
    (child : Fin M → TargetInterval ny → BinaryFraction) (states : Fin M → TargetInterval ny) :
    (bandPredicateWithWork parent r b tau theta velocity actions hne child states).1 = true ↔
      bandActionPredicate parent r b tau.value theta.value velocity.value actions hne
        (fun i q => (child i q).value) states := by
  have hlo (i : Fin M) : parent.lo ≤ (sourceChild parent i).lo := Nat.le_add_right _ _
  have hhi (i : Fin M) : parent.lo ≤ (sourceChild parent i).hi := Nat.le_add_right _ _
  simp only [bandPredicateWithWork, Bool.and_eq_true, zeroConnectionWithWork_value,
    allWithWork_value, naturalDistanceLeWithWork_value, cutGuardWithWork_value,
    translatedEndpointWithWork_value _ _ _ (hlo _), translatedEndpointWithWork_value _ _ _ (hhi _),
    binaryNaturalMulWithWork_value, bandToleranceWithWork_value, List.mem_finRange, forall_true_left,
    endpointActionConnection, bandActionPredicate]
  exact and_assoc

def anchorGuardBitBudget (B : ℕ) : ℕ :=
  2 * (36 * B + 4) + 80 * (B + 4) + 2 * naturalDistanceBitBudget B + 3

def bandPredicateBitBudget (M B C : ℕ) : ℕ :=
  (M + 1) * (8 * B + 3) + M * (anchorGuardBitBudget B + 3) +
    bandToleranceBitBudget B + M * (C + 3) + 4

theorem bandPredicateWithWork_cost {nx ny M : ℕ} (parent : TargetInterval nx)
    (r : TargetInterval ny) (b : ℕ) (tau theta velocity : BinaryFraction)
    (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ [])
    (child : Fin M → TargetInterval ny → BinaryFraction) (states : Fin M → TargetInterval ny)
    (B C : ℕ) (hstatesMem : states ∈ actions)
    (htau : tau.width ≤ B) (htheta : theta.width ≤ B) (hvel : velocity.width ≤ B)
    (hb : Nat.size b + 2 ≤ B) (hM : Nat.size M + 2 ≤ B)
    (hr : Nat.size r.lo + 2 ≤ B) (hrhi : Nat.size r.hi + 2 ≤ B)
    (hp : Nat.size parent.lo + 2 ≤ B)
    (hsource : ∀ i : Fin M, Nat.size (sourceChild parent i).lo + 2 ≤ B ∧
      Nat.size (sourceChild parent i).hi + 2 ≤ B)
    (hanchor : ∀ i : Fin M, Nat.size (r.lo + ((sourceChild parent i).lo - parent.lo)) + 2 ≤ B ∧
      Nat.size (r.lo + ((sourceChild parent i).hi - parent.lo)) + 2 ≤ B)
    (hradius : Nat.size (6 * b) + 2 ≤ B)
    (hstates : ∀ action ∈ actions, ∀ i,
      Nat.size (action i).lo + 2 ≤ B ∧ Nat.size (action i).hi + 2 ≤ B)
    (hchild : ∀ action ∈ actions, ∀ i, (child i (action i)).width ≤ B)
    (hC : ∀ j : Fin M, cutGuardBitBudget M j.val actions.length B ≤ C) :
    (bandPredicateWithWork parent r b tau theta velocity actions hne child states).2 ≤
      bandPredicateBitBudget M B C := by
  have hstate := hstates states hstatesMem
  have hlo (i : Fin M) : parent.lo ≤ (sourceChild parent i).lo := Nat.le_add_right _ _
  have hhi (i : Fin M) : parent.lo ≤ (sourceChild parent i).hi := Nat.le_add_right _ _
  have hconn := zeroConnectionWithWork_cost r.lo r.hi (List.ofFn states) B (by omega) (by omega) (by
    intro state hs
    obtain ⟨i, rfl⟩ := List.mem_ofFn.mp hs
    have := hstate i
    omega)
  have hanchorCost (i : Fin M) :
      (let leftAnchor := translatedEndpointWithWork r.lo parent.lo (sourceChild parent i).lo
       let rightAnchor := translatedEndpointWithWork r.lo parent.lo (sourceChild parent i).hi
       let radius := binaryNaturalMulWithWork 6 b
       let left := naturalDistanceLeWithWork leftAnchor.1 (states i).lo (bitWordValue radius.1)
       let right := naturalDistanceLeWithWork rightAnchor.1 (states i).hi (bitWordValue radius.1)
       (left.1 && right.1, leftAnchor.2 + rightAnchor.2 + radius.2 + left.2 + right.2 + 3)).2 ≤
        anchorGuardBitBudget B := by
    have hl := translatedEndpointWithWork_cost r.lo parent.lo (sourceChild parent i).lo B
      (hlo i) (by omega) (by omega) (by have := hsource i; omega)
    have hh := translatedEndpointWithWork_cost r.lo parent.lo (sourceChild parent i).hi B
      (hhi i) (by omega) (by omega) (by have := hsource i; omega)
    have hrad := binaryNaturalMulWithWork_cost 6 b
    have hleft := naturalDistanceLeWithWork_cost
      (translatedEndpointWithWork r.lo parent.lo (sourceChild parent i).lo).1 (states i).lo
      (bitWordValue (binaryNaturalMulWithWork 6 b).1) B
      (by rw [translatedEndpointWithWork_value _ _ _ (hlo i)]; exact (hanchor i).1)
      (hstate i).1 (by rw [binaryNaturalMulWithWork_value]; exact hradius)
    have hright := naturalDistanceLeWithWork_cost
      (translatedEndpointWithWork r.lo parent.lo (sourceChild parent i).hi).1 (states i).hi
      (bitWordValue (binaryNaturalMulWithWork 6 b).1) B
      (by rw [translatedEndpointWithWork_value _ _ _ (hhi i)]; exact (hanchor i).2)
      (hstate i).2 (by rw [binaryNaturalMulWithWork_value]; exact hradius)
    norm_num only [show Nat.size 6 = 3 by decide] at hrad
    dsimp only
    unfold anchorGuardBitBudget
    omega
  have ha := allWithWork_cost _ (List.finRange M) (anchorGuardBitBudget B)
    (fun i _ => hanchorCost i)
  obtain ⟨htw, htc⟩ := bandToleranceWithWork_bounds tau theta b M B htau htheta hb hM
  have hc := allWithWork_cost
    (cutGuardWithWork parent r actions hne child states velocity (bandToleranceWithWork tau theta b M).1)
    (List.finRange M) C (by
      intro j _
      exact (cutGuardWithWork_cost parent r actions hne child states velocity
        (bandToleranceWithWork tau theta b M).1 j B hvel htw hr hp (hstate j).1
        (hsource j).1 (hsource j).1 hstates hchild).trans (hC j))
  simp only [List.length_ofFn] at hconn
  simp only [List.length_finRange] at ha hc
  change _ + _ + _ + _ + 4 ≤ _
  unfold bandPredicateBitBudget
  dsimp only at ha hc ⊢
  omega

end BinaryFraction
end EditApproximation

end OAI