lean/OAI/Combinatorics/LowSpaceSubsetSum/Streams/DictionaryStream.lean

import OAI.Combinatorics.LowSpaceSubsetSum.Streams.BoundedDictionary
import OAI.Combinatorics.LowSpaceSubsetSum.Streams.RowMerge

namespace OAI

/-!
# A bounded dictionary driven by a stream cursor

The executable loop reads one key, updates the trie and its counters, and
tail-calls with the next cursor. Lists and finite key sets below are proof
views only; the loop stores neither a trace nor a set of all possible keys.
-/

namespace LowSpaceSubsetSum.BinaryTrie

def keySet : Tree → Finset (List Bool)
  | .empty => ∅
  | .leaf => {[]}
  | .node zero one => (keySet zero).image (List.cons false) ∪
      (keySet one).image (List.cons true)

theorem mem_keySet (t : Tree) (key : List Bool) :
    key ∈ keySet t ↔ contains t key = true := by
  induction t generalizing key with
  | empty => simp [keySet, contains]
  | leaf => cases key <;> simp [keySet, contains]
  | node zero one ih0 ih1 =>
    cases key with
    | nil => simp [keySet, contains]
    | cons b key => cases b <;> simp [keySet, contains, ih0, ih1]

theorem card_keySet (t : Tree) : (keySet t).card = entries t := by
  induction t with
  | empty => simp [keySet, entries]
  | leaf => simp [keySet, entries]
  | node zero one ih0 ih1 =>
    have hd : Disjoint ((keySet zero).image (List.cons false))
        ((keySet one).image (List.cons true)) := by
      apply Finset.disjoint_left.mpr
      intro x hx hy
      obtain ⟨a, _, rfl⟩ := Finset.mem_image.mp hx
      obtain ⟨b, _, hb⟩ := Finset.mem_image.mp hy
      cases hb
    rw [keySet, Finset.card_union_of_disjoint hd,
      Finset.card_image_of_injective _ (fun _ _ h => (List.cons.inj h).2),
      Finset.card_image_of_injective _ (fun _ _ h => (List.cons.inj h).2), ih0, ih1]
    rfl

theorem keySet_width {t : Tree} {width : ℕ} (ht : HasWidth t width)
    {key : List Bool} (hk : key ∈ keySet t) : key.length = width := by
  induction t generalizing width key with
  | empty => simp [keySet] at hk
  | leaf =>
    have hkey : key = [] := by simpa [keySet] using hk
    rw [hkey]
    exact ht.symm
  | node zero one ih0 ih1 =>
    cases width with
    | zero => exact ht.elim
    | succ width =>
      rcases Finset.mem_union.mp hk with h | h
      · obtain ⟨q, hq, rfl⟩ := Finset.mem_image.mp h
        simp [ih0 ht.1 hq]
      · obtain ⟨q, hq, rfl⟩ := Finset.mem_image.mp h
        simp [ih1 ht.2 hq]

theorem keySet_insert {t : Tree} {key : List Bool} {width : ℕ}
    (ht : HasWidth t width) (hk : key.length = width) :
    keySet (insert t key) = Insert.insert key (keySet t) := by
  ext query
  by_cases hq : query.length = width
  · rw [mem_keySet, contains_insert_iff ht hk hq, Finset.mem_insert, mem_keySet]
  · have hnew : query ∉ keySet (insert t key) :=
      fun h => hq (keySet_width (insert_hasWidth ht hk) h)
    have hold : query ∉ keySet t := fun h => hq (keySet_width ht h)
    have hne : query ≠ key := fun h => hq (by simpa only [h] using hk)
    simp [hnew, hold, hne]

/-- A fitting universe of keys prevents overflow, even when the stream
contains arbitrarily many repetitions. The initial trie may already hold
some keys from that same universe. -/
theorem build_fits_universe {C width : ℕ} {t : Tree} {keys : List (List Bool)}
    {U : Finset (List Bool)} (ht : HasWidth t width)
    (hwidth : ∀ key ∈ U, key.length = width)
    (htU : keySet t ⊆ U) (hkeys : ∀ key ∈ keys, key ∈ U) (hcap : U.card ≤ C) :
    (build C t keys).overflow = false := by
  induction keys generalizing t with
  | nil => rfl
  | cons key rest ih =>
    have hkU := hkeys key (by simp)
    have hk := hwidth key hkU
    have hr : ∀ q ∈ rest, q ∈ U := fun q h => hkeys q (by simp [h])
    have hnextU : keySet (insert t key) ⊆ U := by
      rw [keySet_insert ht hk]
      exact Finset.insert_subset hkU htU
    have hnext : entries (insert t key) ≤ C := by
      rw [← card_keySet]
      exact (Finset.card_le_card hnextU).trans hcap
    simp only [build]
    split
    · exact ih ht htU hr
    · rw [ite_eq_right (by omega)]
      exact ih (insert_hasWidth ht hk) hnextU hr

theorem build_complete_processed {C : ℕ} {t : Tree} {keys : List (List Bool)}
    (h : (build C t keys).overflow = false) :
    (build C t keys).processed = keys.length := by
  induction keys generalizing t with
  | nil => rfl
  | cons key rest ih =>
    by_cases hdup : contains t key = true
    · simp only [build, hdup, ↓reduceIte, tick] at h ⊢
      simpa only [List.length_cons] using congrArg Nat.succ (ih h)
    · have hnew : contains t key = false := Bool.eq_false_iff.mpr hdup
      by_cases hover : C < entries (insert t key)
      · simp [build, hnew, hover] at h
      · simp only [build, hnew, Bool.false_eq_true, ↓reduceIte, hover, tick] at h ⊢
        simpa only [List.length_cons] using congrArg Nat.succ (ih h)

universe u

structure StreamResult (σ : Type u) where
  cursor : σ
  tree : Tree
  overflow : Bool
  processed : ℕ
  queries : ℕ

/-- Tail-recursive implementation. Every recursive call receives the updated
cursor, trie and counters. A capacity violation stops immediately. -/
def run {σ : Type u} (C : ℕ) (read : σ → Option (List Bool × σ)) :
    ℕ → σ → Tree → ℕ → ℕ → StreamResult σ
  | 0, s, t, processed, queries => ⟨s, t, false, processed, queries⟩
  | fuel + 1, s, t, processed, queries =>
    match read s with
    | none => ⟨s, t, false, processed, queries + 1⟩
    | some (key, next) =>
      if contains t key then run C read fuel next t (processed + 1) (queries + 1)
      else
        let t' := insert t key
        if C < entries t' then ⟨next, t', true, processed + 1, queries + 1⟩
        else run C read fuel next t' (processed + 1) (queries + 1)

/-- Finite output trace, used only to state and prove the loop's behavior. -/
def readKeys {σ : Type u} (read : σ → Option (List Bool × σ)) :
    ℕ → σ → List (List Bool)
  | 0, _ => []
  | fuel + 1, s => match read s with
    | none => []
    | some (key, next) => key :: readKeys read fuel next

theorem run_spec {σ : Type u} (C : ℕ) (read : σ → Option (List Bool × σ))
    (fuel : ℕ) (s : σ) (t : Tree) (processed queries : ℕ) :
    let r := run C read fuel s t processed queries
    let b := build C t (readKeys read fuel s)
    r.tree = b.tree ∧ r.overflow = b.overflow ∧ r.processed = processed + b.processed := by
  induction fuel generalizing s t processed queries with
  | zero => simp [run, readKeys, build]
  | succ fuel ih =>
    cases hr : read s with
    | none => simp [run, readKeys, hr, build]
    | some pair =>
      obtain ⟨key, next⟩ := pair
      simp only [run, readKeys, hr, build]
      split
      · obtain ⟨ht, ho, hp⟩ := ih next t (processed + 1) (queries + 1)
        exact ⟨ht, ho, by simpa only [tick] using hp.trans (by omega)⟩
      · split
        · simp
        · obtain ⟨ht, ho, hp⟩ := ih next (insert t key) (processed + 1) (queries + 1)
          exact ⟨ht, ho, by simpa only [tick] using hp.trans (by omega)⟩

theorem run_queries_le {σ : Type u} (C : ℕ) (read : σ → Option (List Bool × σ))
    (fuel : ℕ) (s : σ) (t : Tree) (processed queries : ℕ) :
    (run C read fuel s t processed queries).queries ≤ queries + fuel := by
  induction fuel generalizing s t processed queries with
  | zero => simp [run]
  | succ fuel ih =>
    cases hr : read s with
    | none => simp [run, hr]
    | some pair =>
      obtain ⟨key, next⟩ := pair
      simp only [run, hr]
      split
      · exact (ih next t (processed + 1) (queries + 1)).trans (by omega)
      · split
        · simp
        · exact (ih next (insert t key) (processed + 1) (queries + 1)).trans (by omega)

/-- At most one reader query is spent detecting the end of the stream.
The bound also holds for an overflow stop or an exhausted fuel budget. -/
theorem run_queries_processed {σ : Type u} (C : ℕ)
    (read : σ → Option (List Bool × σ)) (fuel : ℕ) (s : σ) (t : Tree)
    (processed queries : ℕ) :
    (run C read fuel s t processed queries).queries + processed ≤
      queries + (run C read fuel s t processed queries).processed + 1 := by
  induction fuel generalizing s t processed queries with
  | zero => simp [run]
  | succ fuel ih =>
    cases hr : read s with
    | none => simp [run, hr, Nat.add_comm, Nat.add_assoc]
    | some pair =>
      obtain ⟨key, next⟩ := pair
      simp only [run, hr]
      split
      · have h := ih next t (processed + 1) (queries + 1)
        omega
      · split
        · simp [Nat.add_comm, Nat.add_left_comm]
        · have h := ih next (insert t key) (processed + 1) (queries + 1)
          omega

def advance {σ : Type u} (read : σ → Option (List Bool × σ)) : ℕ → σ → σ
  | 0, s => s
  | count + 1, s => match read s with
    | none => s
    | some (_, next) => advance read count next

theorem run_cursor {σ : Type u} (C : ℕ) (read : σ → Option (List Bool × σ))
    (fuel : ℕ) (s : σ) (t : Tree) (processed queries : ℕ) :
    (run C read fuel s t processed queries).cursor =
      advance read (build C t (readKeys read fuel s)).processed s := by
  induction fuel generalizing s t processed queries with
  | zero => rfl
  | succ fuel ih =>
    cases hr : read s with
    | none => simp [run, readKeys, hr, build, advance]
    | some pair =>
      obtain ⟨key, next⟩ := pair
      simp only [run, readKeys, hr, build]
      split
      · simpa only [tick, advance, hr] using ih next t (processed + 1) (queries + 1)
      · split
        · simp [advance, hr]
        · simpa only [tick, advance, hr] using
            ih next (insert t key) (processed + 1) (queries + 1)

theorem readKeys_eq_take {σ : Type u} (read : σ → Option (List Bool × σ))
    (view : σ → List (List Bool)) (hread : RowMerge.IsReader read view)
    (fuel : ℕ) (s : σ) : readKeys read fuel s = (view s).take fuel := by
  induction fuel generalizing s with
  | zero => simp [readKeys]
  | succ fuel ih =>
    have hv := hread s
    cases hr : read s with
    | none =>
      simp only [hr] at hv
      simp [readKeys, hr, hv]
    | some pair =>
      obtain ⟨key, next⟩ := pair
      simp only [hr] at hv
      simp [readKeys, hr, hv, ih]

theorem advance_view {σ : Type u} (read : σ → Option (List Bool × σ))
    (view : σ → List (List Bool)) (hread : RowMerge.IsReader read view)
    (count : ℕ) (s : σ) : view (advance read count s) = (view s).drop count := by
  induction count generalizing s with
  | zero => rfl
  | succ count ih =>
    have hv := hread s
    cases hr : read s with
    | none =>
      simp only [hr] at hv
      simp [advance, hr, hv]
    | some pair =>
      obtain ⟨key, next⟩ := pair
      simp only [hr] at hv
      simp [advance, hr, hv, ih]

/-- The actual cursor loop completes and retains exactly the streamed keys
when they lie in a fixed-width universe whose cardinality fits the cap. -/
theorem run_complete {σ : Type u} {C width fuel : ℕ}
    (read : σ → Option (List Bool × σ)) (view : σ → List (List Bool))
    (hread : RowMerge.IsReader read view) (s : σ) {U : Finset (List Bool)}
    (hfuel : (view s).length ≤ fuel)
    (hwidth : ∀ key ∈ U, key.length = width)
    (hkeys : ∀ key ∈ view s, key ∈ U) (hcap : U.card ≤ C) :
    let r := run C read fuel s .empty 0 0
    r.overflow = false ∧ r.processed = (view s).length ∧
      ∀ query, query.length = width →
        (contains r.tree query = true ↔ query ∈ view s) := by
  have htrace : readKeys read fuel s = view s := by
    rw [readKeys_eq_take read view hread, List.take_of_length_le hfuel]
  have hfit : (build C .empty (view s)).overflow = false :=
    build_fits_universe (by trivial) hwidth (by simp [keySet]) hkeys hcap
  obtain ⟨ht, ho, hp⟩ := run_spec C read fuel s .empty 0 0
  rw [htrace] at ht ho hp
  refine ⟨ho.trans hfit, ?_, ?_⟩
  · simpa only [Nat.zero_add] using hp.trans (by
      simpa only [Nat.zero_add] using build_complete_processed hfit)
  · intro query hq
    rw [ht, build_complete_contains_iff (by trivial)
      (fun key hk => hwidth key (hkeys key hk)) hfit hq]
    simp [contains]

theorem run_complete_distinct {σ : Type u} {C width fuel : ℕ}
    (read : σ → Option (List Bool × σ)) (view : σ → List (List Bool))
    (hread : RowMerge.IsReader read view) (s : σ)
    (hfuel : (view s).length ≤ fuel)
    (hwidth : ∀ key ∈ view s, key.length = width)
    (hcap : (view s).toFinset.card ≤ C) :
    let r := run C read fuel s .empty 0 0
    r.overflow = false ∧ r.processed = (view s).length ∧
      ∀ query, query.length = width →
        (contains r.tree query = true ↔ query ∈ view s) :=
  run_complete read view hread s hfuel
    (fun key hk => hwidth key (List.mem_toFinset.mp hk))
    (fun _ hk => List.mem_toFinset.mpr hk) hcap

theorem run_complete_exhausts {σ : Type u} {C width fuel : ℕ}
    (read : σ → Option (List Bool × σ)) (view : σ → List (List Bool))
    (hread : RowMerge.IsReader read view) (s : σ)
    (hfuel : (view s).length ≤ fuel)
    (hwidth : ∀ key ∈ view s, key.length = width)
    (hcap : (view s).toFinset.card ≤ C) :
    view (run C read fuel s .empty 0 0).cursor = [] := by
  have htrace : readKeys read fuel s = view s := by
    rw [readKeys_eq_take read view hread, List.take_of_length_le hfuel]
  have hfit : (build C .empty (view s)).overflow = false :=
    build_fits_universe (by trivial)
      (fun key hk => hwidth key (List.mem_toFinset.mp hk))
      (by simp [keySet]) (fun _ hk => List.mem_toFinset.mpr hk) hcap
  rw [run_cursor, htrace, build_complete_processed hfit, advance_view read view hread,
    List.drop_length]

theorem run_complete_from_values {σ : Type u} {α : Type*} [DecidableEq α]
    {C width fuel : ℕ} (read : σ → Option (List Bool × σ))
    (view : σ → List (List Bool)) (hread : RowMerge.IsReader read view) (s : σ)
    (X : Finset α) (encode : α → List Bool) (hfuel : (view s).length ≤ fuel)
    (hwidth : ∀ x ∈ X, (encode x).length = width)
    (hkeys : ∀ key ∈ view s, ∃ x ∈ X, encode x = key) (hcap : X.card ≤ C) :
    let r := run C read fuel s .empty 0 0
    r.overflow = false ∧ r.processed = (view s).length ∧
      ∀ query, query.length = width →
        (contains r.tree query = true ↔ query ∈ view s) := by
  apply run_complete read view hread s hfuel (U := X.image encode)
  · intro key hk
    obtain ⟨x, hx, rfl⟩ := Finset.mem_image.mp hk
    exact hwidth x hx
  · intro key hk
    obtain ⟨x, hx, rfl⟩ := hkeys key hk
    exact Finset.mem_image.mpr ⟨x, hx, rfl⟩
  · exact (Finset.card_image_le).trans hcap

end LowSpaceSubsetSum.BinaryTrie

end OAI