import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationPivotWork

namespace OAI

/-! # Binary search with counted predicate evaluations

The predicate is evaluated exactly once at each nonempty interval. The
count includes endpoint arithmetic and the actual predicate callback cost.
-/

namespace LowSpaceSubsetSum.BinaryPivot

variable {n : ℕ}

def measuredStep (p : Fin n → Bool × ℕ) (c : Cut n) : Cut n × ℕ :=
  if h : c.lo < c.hi then
    let mid := (c.lo + c.hi) / 2
    have hmid : mid < n := by have := c.bounded; dsimp [mid]; omega
    let q := p ⟨mid, hmid⟩
    (if q.1 then
      ⟨mid + 1, c.hi, by dsimp [mid]; omega, c.bounded⟩
    else
      ⟨c.lo, mid, by dsimp [mid]; omega, by have := c.bounded; dsimp [mid]; omega⟩,
      q.2 + 8)
  else (c, 1)

theorem measuredStep_value (p : Fin n → Bool × ℕ) (c : Cut n) :
    (measuredStep p c).1 = step (fun i => (p i).1) c := by
  unfold measuredStep step
  split <;> rfl

theorem measuredStep_work (p : Fin n → Bool × ℕ) (K : ℕ)
    (hp : ∀ i, (p i).2 ≤ K) (c : Cut n) :
    (measuredStep p c).2 ≤ K + 8 := by
  unfold measuredStep
  split
  · rename_i h
    exact Nat.add_le_add_right (hp ⟨(c.lo + c.hi) / 2, by have := c.bounded; omega⟩) 8
  · omega

/-- The accumulator makes the search loop tail recursive. -/
def measuredRun (p : Fin n → Bool × ℕ) : ℕ → Cut n → ℕ → Cut n × ℕ
  | 0, c, work => (c, work)
  | k + 1, c, work =>
    let q := measuredStep p c
    measuredRun p k q.1 (work + q.2)

theorem measuredRun_value (p : Fin n → Bool × ℕ) (k : ℕ) (c : Cut n) (work : ℕ) :
    (measuredRun p k c work).1 = (step (fun i => (p i).1))^[k] c := by
  induction k generalizing c work with
  | zero => rfl
  | succ k ih =>
    rw [measuredRun, ih, measuredStep_value, Function.iterate_succ_apply]

theorem measuredRun_work (p : Fin n → Bool × ℕ) (K : ℕ)
    (hp : ∀ i, (p i).2 ≤ K) (k : ℕ) (c : Cut n) (work : ℕ) :
    (measuredRun p k c work).2 ≤ work + (K + 8) * k := by
  induction k generalizing c work with
  | zero => simp only [measuredRun, Nat.mul_zero, Nat.add_zero, le_refl]
  | succ k ih =>
    have hi := ih (measuredStep p c).1 (work + (measuredStep p c).2)
    have hs := measuredStep_work p K hp c
    change (measuredRun p k (measuredStep p c).1 (work + (measuredStep p c).2)).2 ≤ _
    simp only [Nat.mul_add, Nat.mul_one]
    omega

def measuredSearch (p : Fin n → Bool × ℕ) (k : ℕ) : Cut n × ℕ :=
  measuredRun p k (initial n) 0

theorem measuredSearch_value (p : Fin n → Bool × ℕ) (k : ℕ) :
    (measuredSearch p k).1 = search (fun i => (p i).1) k := measuredRun_value _ _ _ _

theorem measuredSearch_work (p : Fin n → Bool × ℕ) (K : ℕ)
    (hp : ∀ i, (p i).2 ≤ K) (k : ℕ) :
    (measuredSearch p k).2 ≤ (K + 8) * k := by
  simpa only [measuredSearch, Nat.zero_add] using measuredRun_work p K hp k (initial n) 0

end LowSpaceSubsetSum.BinaryPivot

end OAI