openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Streams /DistinctStreamCount.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.MergedReader | |
| import Mathlib.Data.List.Destutter | |
| namespace OAI | |
| /-! # Counting distinct keys without materializing the output stream | |
| The mutable state consists of a reader state, one previous key and a count. | |
| Sorted keys make adjacent duplicate removal exact. The second component of | |
| the result counts actual reader calls, including a final unsuccessful call. | |
| -/ | |
| namespace LowSpaceSubsetSum.DistinctStreamCount | |
| variable {α σ : Type*} | |
| def tail (read : σ → Option (α × σ)) (key : α → ℤ) : ℕ → σ → ℤ → ℕ × ℕ | |
| | 0, _, _ => (0, 0) | |
| | k + 1, s, previous => | |
| match read s with | |
| | none => (0, 1) | |
| | some (x, s') => | |
| if previous = key x then | |
| let rest := tail read key k s' previous | |
| (rest.1, rest.2 + 1) | |
| else | |
| let rest := tail read key k s' (key x) | |
| (rest.1 + 1, rest.2 + 1) | |
| def run (read : σ → Option (α × σ)) (key : α → ℤ) : ℕ → σ → ℕ × ℕ | |
| | 0, _ => (0, 0) | |
| | k + 1, s => | |
| match read s with | |
| | none => (0, 1) | |
| | some (x, s') => | |
| let rest := tail read key k s' (key x) | |
| (rest.1 + 1, rest.2 + 1) | |
| theorem tail_queries (read : σ → Option (α × σ)) (key : α → ℤ) | |
| (k : ℕ) (s : σ) (previous : ℤ) : (tail read key k s previous).2 ≤ k := by | |
| induction k generalizing s previous with | |
| | zero => rfl | |
| | succ k ih => | |
| simp only [tail] | |
| split | |
| · omega | |
| · rename_i x s' hread | |
| split | |
| · exact Nat.add_le_add_right (ih s' previous) 1 | |
| · exact Nat.add_le_add_right (ih s' (key x)) 1 | |
| theorem run_queries (read : σ → Option (α × σ)) (key : α → ℤ) | |
| (k : ℕ) (s : σ) : (run read key k s).2 ≤ k := by | |
| cases k with | |
| | zero => rfl | |
| | succ k => | |
| simp only [run] | |
| split | |
| · omega | |
| · exact Nat.add_le_add_right (tail_queries read key k _ _) 1 | |
| theorem tail_value (read : σ → Option (α × σ)) (key : α → ℤ) | |
| (view : σ → List α) (hread : RowMerge.IsReader read view) | |
| (k : ℕ) (s : σ) (previous : ℤ) (hk : (view s).length ≤ k) : | |
| (tail read key k s previous).1 + 1 = | |
| (((view s).map key).destutter' (· ≠ ·) previous).length := by | |
| induction k generalizing s previous with | |
| | zero => | |
| have he : view s = [] := List.eq_nil_of_length_eq_zero (by omega) | |
| simp [tail, he] | |
| | succ k ih => | |
| have hr := hread s | |
| cases hs : read s with | |
| | none => | |
| simp only [hs] at hr | |
| simp [tail, hs, hr] | |
| | some p => | |
| obtain ⟨x, s'⟩ := p | |
| simp only [hs] at hr | |
| have hk' : (view s').length ≤ k := by rw [hr, List.length_cons] at hk; omega | |
| rw [hr, List.map_cons, List.destutter'_cons] | |
| by_cases he : previous = key x | |
| · simpa only [tail, hs, ite_eq_left he, ne_eq, he, not_true_eq_false, | |
| ↓reduceIte] using ih s' previous hk' | |
| · have hh := ih s' (key x) hk' | |
| simp only [ne_eq] at hh | |
| simp only [tail, hs, ne_eq, he, not_false_eq_true, | |
| ↓reduceIte, List.length_cons] | |
| omega | |
| theorem run_value (read : σ → Option (α × σ)) (key : α → ℤ) | |
| (view : σ → List α) (hread : RowMerge.IsReader read view) | |
| (k : ℕ) (s : σ) (hk : (view s).length ≤ k) | |
| (hsort : ((view s).map key).Pairwise (· ≤ ·)) : | |
| (run read key k s).1 = ((view s).map key).toFinset.card := by | |
| have hst := hsort.destutter_eq_dedup | |
| have hcard : ((view s).map key).dedup.length = ((view s).map key).toFinset.card := by | |
| rw [← List.toFinset_card_of_nodup (List.nodup_dedup _), List.toFinset_dedup] | |
| rw [← hcard, ← hst] | |
| cases k with | |
| | zero => | |
| have he : view s = [] := List.eq_nil_of_length_eq_zero (by omega) | |
| simp [run, he] | |
| | succ k => | |
| have hr := hread s | |
| cases hs : read s with | |
| | none => | |
| simp only [hs] at hr | |
| simp [run, hs, hr] | |
| | some p => | |
| obtain ⟨x, s'⟩ := p | |
| simp only [hs] at hr | |
| have hk' : (view s').length ≤ k := by rw [hr, List.length_cons] at hk; omega | |
| simpa only [run, hs, hr, List.map_cons, List.destutter_cons'] using | |
| tail_value read key view hread k s' (key x) hk' | |
| end LowSpaceSubsetSum.DistinctStreamCount | |
| end OAI | |