import OAI.Combinatorics.LowSpaceSubsetSum.Streams.Trie

namespace OAI

/-!
# Streaming construction of a hard-capacity dictionary

The input is a list of occurrences; equal keys are tested and skipped. The
builder stops at the first new key beyond capacity. Its tree includes the
possibly allocated rejected key, as in the manuscript's implementation.
No Cartesian product or ambient entry set is stored by this procedure.
-/

namespace LowSpaceSubsetSum.BinaryTrie

structure BuildResult where
  tree : Tree
  overflow : Bool
  processed : ℕ

def tick (r : BuildResult) : BuildResult := { r with processed := r.processed + 1 }

def build (C : ℕ) (t : Tree) : List (List Bool) → BuildResult
  | [] => ⟨t, false, 0⟩
  | key :: rest =>
      if contains t key then tick (build C t rest)
      else
        let next := insert t key
        if C < entries next then ⟨next, true, 1⟩
        else tick (build C next rest)

theorem build_processed_le (C : ℕ) (t : Tree) (keys : List (List Bool)) :
    (build C t keys).processed ≤ keys.length := by
  induction keys generalizing t with
  | nil => simp [build]
  | cons key rest ih =>
    simp only [build]
    split
    · simpa [tick] using Nat.add_le_add_right (ih t) 1
    · split
      · simp
      · simpa [tick] using Nat.add_le_add_right (ih (insert t key)) 1

theorem build_hasWidth {C width : ℕ} {t : Tree} {keys : List (List Bool)}
    (ht : HasWidth t width) (hk : ∀ key ∈ keys, key.length = width) :
    HasWidth (build C t keys).tree width := by
  induction keys generalizing t with
  | nil => exact ht
  | cons key rest ih =>
    have hkey := hk key (by simp)
    have hrest : ∀ k ∈ rest, k.length = width := by
      intro k h
      exact hk k (by simp [h])
    simp only [build]
    split
    · exact ih ht hrest
    · split
      · exact insert_hasWidth ht hkey
      · exact ih (insert_hasWidth ht hkey) hrest

theorem build_compact {C : ℕ} {t : Tree} (ht : Compact t)
    (keys : List (List Bool)) : Compact (build C t keys).tree := by
  induction keys generalizing t with
  | nil => exact ht
  | cons key rest ih =>
    simp only [build]
    split
    · exact ih ht
    · split
      · exact insert_compact ht key
      · exact ih (insert_compact ht key)

/-- The capacity is respected on every outcome, including overflow and early
termination. At most one extra key has been allocated. -/
theorem build_entries_le {C width : ℕ} {t : Tree} {keys : List (List Bool)}
    (ht : HasWidth t width) (hk : ∀ key ∈ keys, key.length = width)
    (hcap : entries t ≤ C) : entries (build C t keys).tree ≤ C + 1 := by
  induction keys generalizing t with
  | nil => simpa [build] using hcap.trans (Nat.le_succ C)
  | cons key rest ih =>
    have hkey := hk key (by simp)
    have hrest : ∀ k ∈ rest, k.length = width := by
      intro k h
      exact hk k (by simp [h])
    have he := entries_insert ht hkey
    simp only [build]
    split
    · exact ih ht hrest hcap
    · rename_i hnew
      have hnew' : contains t key = false := Bool.eq_false_iff.mpr hnew
      rw [hnew'] at he
      simp only [Bool.false_eq_true, ↓reduceIte] at he
      split
      · simpa using (show entries (insert t key) ≤ C + 1 by omega)
      · rename_i hfit
        exact ih (insert_hasWidth ht hkey) hrest (by omega)

theorem build_overflow_entries {C width : ℕ} {t : Tree} {keys : List (List Bool)}
    (ht : HasWidth t width) (hk : ∀ key ∈ keys, key.length = width)
    (hcap : entries t ≤ C) (hov : (build C t keys).overflow = true) :
    entries (build C t keys).tree = C + 1 := by
  induction keys generalizing t with
  | nil => simp [build] at hov
  | cons key rest ih =>
    have hkey := hk key (by simp)
    have hrest : ∀ k ∈ rest, k.length = width := by
      intro k h
      exact hk k (by simp [h])
    have he := entries_insert ht hkey
    by_cases hdup : contains t key = true
    · simp only [build, hdup, ↓reduceIte, tick] at hov ⊢
      exact ih ht hrest hcap hov
    · have hnew : contains t key = false := Bool.eq_false_iff.mpr hdup
      rw [hnew] at he
      simp only [Bool.false_eq_true, ↓reduceIte] at he
      by_cases hover : C < entries (insert t key)
      · simp only [build, hnew, Bool.false_eq_true, ↓reduceIte, hover]
        omega
      · simp only [build, hnew, Bool.false_eq_true, ↓reduceIte, hover, tick] at hov ⊢
        exact ih (insert_hasWidth ht hkey) hrest (by omega) hov

/-- A completed build retains exactly the original keys and the input keys,
regardless of how many duplicate occurrences were streamed. -/
theorem build_complete_contains_iff {C width : ℕ} {t : Tree}
    {keys : List (List Bool)} (ht : HasWidth t width)
    (hk : ∀ key ∈ keys, key.length = width)
    (hcomplete : (build C t keys).overflow = false)
    {query : List Bool} (hq : query.length = width) :
    contains (build C t keys).tree query = true ↔
      contains t query = true ∨ query ∈ keys := by
  induction keys generalizing t with
  | nil => simp [build]
  | cons key rest ih =>
    have hkey := hk key (by simp)
    have hrest : ∀ k ∈ rest, k.length = width := by
      intro k h
      exact hk k (by simp [h])
    by_cases hdup : contains t key = true
    · simp only [build, hdup, ↓reduceIte, tick] at hcomplete ⊢
      have hi := ih ht hrest hcomplete
      have hin : query = key → contains t query = true := by
        intro heq
        simpa [heq] using hdup
      rw [hi, List.mem_cons]
      tauto
    · 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 hcomplete
      · simp only [build, hnew, Bool.false_eq_true, ↓reduceIte, hover, tick] at hcomplete ⊢
        have hi := ih (insert_hasWidth ht hkey) hrest hcomplete
        rw [hi, contains_insert_iff ht hkey hq, List.mem_cons]
        tauto

/-- Concrete live-trie space, with the first rejected key included. -/
theorem build_nodes_le {C width : ℕ} {t : Tree} {keys : List (List Bool)}
    (ht : HasWidth t width) (hc : Compact t)
    (hk : ∀ key ∈ keys, key.length = width) (hcap : entries t ≤ C) :
    nodes (build C t keys).tree ≤ (width + 1) * (C + 1) := by
  exact (nodes_le_width_mul_entries (build_hasWidth ht hk) (build_compact hc keys)).trans
    (Nat.mul_le_mul_left (width + 1) (build_entries_le ht hk hcap))

end LowSpaceSubsetSum.BinaryTrie

end OAI