import OAI.Combinatorics.EditApproximation.Binary.BitMemoHeap
import OAI.Combinatorics.EditApproximation.Binary.BitQueryKeysSpace
import OAI.Combinatorics.EditApproximation.Binary.BinaryNormalizationSpace
import OAI.Combinatorics.EditApproximation.Definitions


namespace OAI.EditApproximation.BitQuery

/- The allocation trace of a query, without a proof relating allocations to work.
The trace retains every allocation and every adaptive continuation. -/


namespace Footprint

def cells {ι β : Type*} {program : BitQuery ι β} (oracle : ι → BinaryFraction) :
    Footprint program → ℕ
  | .done _ => 0
  | .read key _ next => 3 + cells oracle (next (oracle key))
  | .charge localCells next => localCells + cells oracle next





















theorem runCells_congr {ι κ : Type*}
    (ask : ι → BinaryMemo BinaryFraction → BitRecursiveMemoResult κ)
    (childCells otherCells : ι → BinaryMemo BinaryFraction → ℕ)
    (h : ∀ key memory, childCells key memory = otherCells key memory)
    {program : BitQuery ι BinaryFraction} (heap : Footprint program)
    (memory : BinaryMemo BinaryFraction) :
    heap.runCells ask childCells memory = heap.runCells ask otherCells memory := by
  induction heap generalizing memory with
  | done => rfl
  | read key next continuation ih => simp only [runCells, h, ih]
  | charge localCells next ih => simp only [runCells, ih]

end Footprint

namespace Heap

/-- Forget only the local allocation/work certificates, preserving the exact trace. -/
def footprint {ι β : Type*} {program : BitQuery ι β} : Heap program → Footprint program
  | .done value => .done value
  | .read key next continuation => .read key next (fun word => (continuation word).footprint)
  | .charge localCells _ next => .charge localCells next.footprint

@[simp] theorem footprint_done {ι β : Type*} (value : β) :
    (Heap.done (ι := ι) value).footprint = .done value := rfl

@[simp] theorem footprint_read {ι β : Type*} (key : ι) (next : BinaryFraction → BitQuery ι β)
    (continuation : ∀ word, Heap (next word)) :
    (Heap.read key next continuation).footprint =
      .read key next (fun word => (continuation word).footprint) := rfl

@[simp] theorem footprint_charge {ι β : Type*} {steps : ℕ} {program : BitQuery ι β}
    (allocation : ℕ) (bound : allocation ≤ 3 * steps) (heap : Heap program) :
    (Heap.charge allocation bound heap).footprint = .charge allocation heap.footprint := rfl

@[simp] theorem footprint_cells {ι β : Type*} {program : BitQuery ι β}
    (oracle : ι → BinaryFraction) (heap : Heap program) :
    heap.footprint.cells oracle = heap.cells oracle := by
  induction heap with
  | done => rfl
  | read key next continuation ih => simp only [footprint, Footprint.cells, cells, ih]
  | charge localCells bound next ih => simp only [footprint, Footprint.cells, cells, ih]

@[simp] theorem footprint_bind {ι α β : Type*} {program : BitQuery ι α} (heap : Heap program)
    (next : α → BitQuery ι β) (allocation : ∀ value, Heap (next value)) :
    (heap.bind next allocation).footprint =
      heap.footprint.bind next (fun value => (allocation value).footprint) := by
  induction heap with
  | done => rfl
  | read key continuation stored ih =>
    simp only [bind, footprint, Footprint.bind]
    congr 1
    funext word
    exact ih word
  | charge localCells bound tail ih =>
    exact congrArg (Footprint.charge localCells) ih

@[simp] theorem footprint_compute {ι β : Type*} (execution : β × ℕ) (allocation : ℕ)
    (bound : allocation ≤ 3 * execution.2) :
    (Heap.compute (ι := ι) execution allocation bound).footprint =
      Footprint.compute execution allocation := rfl

@[simp] theorem footprint_chargeOf {ι β : Type*} {steps : ℕ} {program : BitQuery ι β}
    (allocation : ℕ) (bound : allocation ≤ steps) (heap : Heap program) :
    (Heap.chargeOf allocation bound heap).footprint = Footprint.chargeOf allocation heap.footprint := rfl

@[simp] theorem footprint_computeOf {ι β : Type*} (execution : β × ℕ) (allocation : ℕ)
    (bound : allocation ≤ execution.2) :
    (Heap.computeOf (ι := ι) execution allocation bound).footprint =
      Footprint.computeOf execution allocation := rfl

@[simp] theorem footprint_collect {ι κ β : Type*} (reader : κ → BitQuery ι BinaryFraction)
    (allocation : ∀ key, Heap (reader key)) (inputs : List κ)
    (next : List BinaryFraction → BitQuery ι β) (continuation : ∀ words, Heap (next words)) :
    (Heap.collect reader allocation inputs next continuation).footprint =
      Footprint.collect reader (fun key => (allocation key).footprint) inputs next
        (fun words => (continuation words).footprint) := by
  induction inputs generalizing next with
  | nil => rfl
  | cons key rest ih =>
    change ((allocation key).bind _ _).footprint = _
    rw [footprint_bind]
    apply congrArg (Footprint.bind (allocation key).footprint _)
    funext word
    exact congrArg (Footprint.charge 1) (ih _ _)

@[simp] theorem footprint_mapKeysWithWork {ι κ β : Type*} (f : ι → κ × ℕ)
    (allocation : ι → ℕ) (ha : ∀ key, allocation key ≤ (f key).2)
    {program : BitQuery ι β} (heap : Heap program) :
    (heap.mapKeysWithWork f allocation ha).footprint = heap.footprint.mapKeysWithWork f allocation := by
  induction heap with
  | done => rfl
  | read key next continuation ih =>
    change Footprint.charge (allocation key)
      (Footprint.read (f key).1 _ (fun word => (mapKeysWithWork f allocation ha (continuation word)).footprint)) =
      Footprint.charge (allocation key)
      (Footprint.read (f key).1 _ (fun word => Footprint.mapKeysWithWork f allocation (continuation word).footprint))
    apply congrArg (Footprint.charge (allocation key))
    apply congrArg (Footprint.read (f key).1 _)
    funext word
    exact ih word
  | charge localCells bound next ih =>
    exact congrArg (Footprint.charge localCells) ih

private theorem map_decidable_cases {p : Prop} (d : Decidable p) {α β : Sort*}
    (f : α → β) (no : ¬p → α) (yes : p → α) :
    f (Decidable.casesOn d no yes) =
      Decidable.casesOn d (fun h => f (no h)) (fun h => f (yes h)) := by
  cases d <;> rfl

private theorem footprint_mpr_congr {ι β : Type*} {p q : BitQuery ι β}
    (eqn : p = q) (a : Heap q) (b : Footprint q) (hab : a.footprint = b) :
    ((congrArg Heap eqn).mpr a).footprint = (congrArg Footprint eqn).mpr b := by
  cases eqn
  exact hab

@[simp] theorem footprint_restrictWithWork {ι : Type*} (P : ι → Prop)
    (test : ι → Bool × ℕ) (htest : ∀ key, (test key).1 = true ↔ P key)
    (allocation : ι → ℕ) (ha : ∀ key, allocation key ≤ (test key).2)
    {program : BitQuery ι BinaryFraction} (heap : Heap program) :
    (heap.restrictWithWork P test htest allocation ha).footprint =
      heap.footprint.restrictWithWork P test htest allocation := by
  induction heap with
  | done => rfl
  | charge localCells bound next ih =>
    exact congrArg (Footprint.charge localCells) ih
  | read key next continuation ih =>
    simp only [footprint_read]
    unfold restrictWithWork Footprint.restrictWithWork
    apply congrArg (Footprint.charge (allocation key))
    rw [map_decidable_cases (f := footprint)]
    congr 1
    · funext h
      apply footprint_mpr_congr (dite_eq_right h)
      exact ih (BinaryFraction.nat 0)
    · funext h
      apply footprint_mpr_congr (dite_eq_left h)
      apply congrArg (Footprint.read _ _)
      funext word
      exact ih word

@[simp] theorem footprint_normalize {ι : Type*} {program : BitQuery ι BinaryFraction}
    (heap : Heap program) (base : List Bool) (hbase : 0 < bitWordValue base) (remaining : ℕ) :
    (heap.normalize base hbase remaining).footprint = heap.footprint.normalize base hbase remaining := by
  exact footprint_bind heap _ _

@[simp] theorem footprint_runCells {ι κ : Type*}
    (ask : ι → BinaryMemo BinaryFraction → BitRecursiveMemoResult κ)
    (childCells : ι → BinaryMemo BinaryFraction → ℕ)
    {program : BitQuery ι BinaryFraction} (heap : Heap program) (memory : BinaryMemo BinaryFraction) :
    heap.footprint.runCells ask childCells memory = heap.runCells ask childCells memory := by
  induction heap generalizing memory with
  | done => rfl
  | read key next continuation ih => simp only [footprint, Footprint.runCells, runCells, ih]
  | charge localCells bound next ih => simp only [footprint, Footprint.runCells, runCells, ih]

@[simp] theorem footprint_rankedBitMemoCells {κ : Type*} (rank : κ → ℕ)
    (program : (key : κ) → BitQuery {child : κ // rank child < rank key} BinaryFraction)
    (heap : ∀ key, Heap (program key))
    (bits : ℕ) (encode addressCells : κ → ℕ) (key : κ) (memory : BinaryMemo BinaryFraction) :
    Footprint.rankedBitMemoCells rank program (fun key => (heap key).footprint)
      bits encode addressCells key memory =
      EditApproximation.rankedBitMemoCells rank program heap bits encode addressCells key memory := by
  have hall : ∀ level key, rank key = level → ∀ memory,
      Footprint.rankedBitMemoCells rank program (fun key => (heap key).footprint)
        bits encode addressCells key memory =
        EditApproximation.rankedBitMemoCells rank program heap bits encode addressCells key memory := by
    intro level
    induction level using Nat.strong_induction_on with
    | h level ih =>
      intro key hlevel memory
      rw [Footprint.rankedBitMemoCells, EditApproximation.rankedBitMemoCells]
      cases hf : (memory.lookupCosted (binaryMemoKey bits (encode key))).1 with
      | some value => rfl
      | none =>
        dsimp only
        congr 1
        rw [← footprint_runCells]
        apply Footprint.runCells_congr
        intro child previous
        exact ih (rank child.val) (hlevel ▸ child.property) child.val rfl previous
  exact hall (rank key) key rfl memory

end Heap
end OAI.EditApproximation.BitQuery