| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.RecordedDictionary |
|
|
| namespace OAI |
|
|
| /-! # Counted trie operations and a cached distinct-key count |
|
|
| The capacity test uses the cached count. It does not traverse the whole trie |
| to recompute `entries` after insertion. Equality to the dictionary |
| specification follows from the fixed-width insertion theorem. |
| -/ |
|
|
| namespace LowSpaceSubsetSum.CountedTrie |
|
|
| open BinaryTrie |
|
|
| def contains : Tree → List Bool → Bool × ℕ |
| | .empty, _ => (false, 1) |
| | .leaf, [] => (true, 1) |
| | .leaf, _ :: _ => (false, 1) |
| | .node _ _, [] => (false, 1) |
| | .node zero one, b :: key => |
| let rest := contains (if b then one else zero) key |
| (rest.1, rest.2 + 1) |
|
|
| theorem contains_value (t : Tree) (key : List Bool) : |
| (contains t key).1 = BinaryTrie.contains t key := by |
| induction key generalizing t with |
| | nil => cases t <;> rfl |
| | cons b key ih => cases t <;> simp only [contains, BinaryTrie.contains, ih] |
|
|
| theorem contains_work (t : Tree) (key : List Bool) : |
| (contains t key).2 ≤ key.length + 1 := by |
| induction key generalizing t with |
| | nil => cases t <;> simp [contains] |
| | cons b key ih => |
| cases t with |
| | empty => simp [contains] |
| | leaf => simp [contains] |
| | node zero one => simpa only [contains, List.length_cons] using Nat.add_le_add_right (ih _) 1 |
|
|
| def insert : Tree → List Bool → Tree × ℕ |
| | _, [] => (.leaf, 1) |
| | .node zero one, b :: key => |
| if b then |
| let rest := insert one key |
| (.node zero rest.1, rest.2 + 1) |
| else |
| let rest := insert zero key |
| (.node rest.1 one, rest.2 + 1) |
| | _, b :: key => |
| let rest := insert .empty key |
| (if b then .node .empty rest.1 else .node rest.1 .empty, rest.2 + 1) |
|
|
| theorem insert_value (t : Tree) (key : List Bool) : |
| (insert t key).1 = BinaryTrie.insert t key := by |
| induction key generalizing t with |
| | nil => cases t <;> rfl |
| | cons b key ih => cases t <;> cases b <;> simp only [insert, BinaryTrie.insert, ih, Bool.false_eq_true, ↓reduceIte] |
|
|
| theorem insert_work (t : Tree) (key : List Bool) : |
| (insert t key).2 = key.length + 1 := by |
| induction key generalizing t with |
| | nil => cases t <;> rfl |
| | cons b key ih => cases t <;> cases b <;> simp only [insert, ih, List.length_cons, Bool.false_eq_true, ↓reduceIte] |
|
|
| structure Cached where |
| state : BuildResult |
| count : ℕ |
|
|
| def feed (C : ℕ) (key : List Bool) (r : Cached) : Cached × ℕ := |
| if r.state.overflow then (r, 1) else |
| let seen := contains r.state.tree key |
| if seen.1 then (⟨tick r.state, r.count⟩, seen.2 + 3) else |
| let next := insert r.state.tree key |
| (⟨⟨next.1, decide (C < r.count + 1), r.state.processed + 1⟩, r.count + 1⟩, |
| seen.2 + next.2 + 6) |
|
|
| theorem feed_work (C : ℕ) (key : List Bool) (r : Cached) : |
| (feed C key r).2 ≤ 2 * key.length + 8 := by |
| have hc := contains_work r.state.tree key |
| have hi := insert_work r.state.tree key |
| simp only [feed] |
| split |
| · omega |
| · split <;> dsimp only <;> omega |
|
|
| theorem feed_state {C width : ℕ} (key : List Bool) (r : Cached) |
| (hw : HasWidth r.state.tree width) (hk : key.length = width) |
| (hcount : r.count = entries r.state.tree) : |
| (feed C key r).1.state = BinaryTrie.feed C key r.state := by |
| simp only [feed, contains_value, insert_value] |
| by_cases ho : r.state.overflow = true |
| · simp only [ho, ↓reduceIte, BinaryTrie.feed] |
| · have hf : r.state.overflow = false := Bool.eq_false_iff.mpr ho |
| simp only [hf, Bool.false_eq_true, ↓reduceIte, BinaryTrie.feed] |
| split |
| · rfl |
| · rename_i hn |
| have he := entries_insert hw hk |
| have hc : BinaryTrie.contains r.state.tree key = false := Bool.eq_false_iff.mpr hn |
| simp only [hc, Bool.false_eq_true, ↓reduceIte] at he |
| rw [he, hcount] |
|
|
| theorem feed_count {C width : ℕ} (key : List Bool) (r : Cached) |
| (hw : HasWidth r.state.tree width) (hk : key.length = width) |
| (hcount : r.count = entries r.state.tree) : |
| (feed C key r).1.count = entries (feed C key r).1.state.tree := by |
| simp only [feed, contains_value, insert_value] |
| by_cases ho : r.state.overflow = true |
| · simpa only [ho, ↓reduceIte] using hcount |
| · have hf : r.state.overflow = false := Bool.eq_false_iff.mpr ho |
| simp only [hf, Bool.false_eq_true, ↓reduceIte] |
| split |
| · exact hcount |
| · rename_i hn |
| have he := entries_insert hw hk |
| have hc : BinaryTrie.contains r.state.tree key = false := Bool.eq_false_iff.mpr hn |
| simpa only [hc, Bool.false_eq_true, ↓reduceIte, ← hcount] using he.symm |
|
|
| end LowSpaceSubsetSum.CountedTrie |
|
|
| end OAI |
|
|
