| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.TieReplay |
| import Mathlib.Data.List.TakeWhile |
|
|
| namespace OAI |
|
|
| /-! |
| # Reporting the stored part of a tie group |
|
|
| The immutable buffer is traversed by one natural index. The same bounded |
| reporter used for a generator suffix applies, so buffer reporting shares |
| the all-outcome stop and query bounds without keeping an output list. |
| -/ |
|
|
| namespace LowSpaceSubsetSum |
| namespace BufferReplay |
|
|
| universe u w |
|
|
| variable {α : Type u} {τ : Type w} |
|
|
| def read (xs : Array α) (i : ℕ) : Option (α × ℕ) := |
| if hi : i < xs.size then some (xs[i], i + 1) else none |
|
|
| def view (xs : Array α) (i : ℕ) : List α := xs.toList.drop i |
|
|
| theorem isReader (xs : Array α) : RowMerge.IsReader (read xs) (view xs) := by |
| intro i |
| by_cases hi : i < xs.size |
| · dsimp only [read] |
| rw [dite_eq_left hi] |
| change xs.toList.drop i = xs[i] :: xs.toList.drop (i + 1) |
| simpa using List.drop_eq_getElem_cons (show i < xs.toList.length by simpa using hi) |
| · dsimp only [read] |
| rw [dite_eq_right hi] |
| change xs.toList.drop i = [] |
| apply List.drop_eq_nil_of_le |
| simpa using Nat.le_of_not_gt hi |
|
|
| def run (key : α → ℤ) (K : ℤ) (report : α → τ → τ × Bool) (xs : Array α) (a : τ) : |
| TieReplay.Result ℕ τ := TieReplay.run (read xs) key K report xs.size 0 a |
|
|
| theorem queries_le (key : α → ℤ) (K : ℤ) (report : α → τ → τ × Bool) |
| (xs : Array α) (a : τ) : (run key K report xs a).queries ≤ xs.size := |
| TieReplay.run_queries_le (read xs) key K report (view xs) (isReader xs) xs.size 0 a |
|
|
| theorem reports_le (key : α → ℤ) (K : ℤ) (report : α → τ → τ × Bool) |
| (xs : Array α) (a : τ) : (run key K report xs a).reports ≤ xs.size := by |
| have h := TieReplay.run_reports_le_potential (read xs) key K report |
| (view xs) (isReader xs) xs.size 0 a |
| have hlen : (TieBuffer.groupView key K (view xs) 0).length ≤ xs.size := by |
| simpa [TieBuffer.groupView, view] using |
| (List.takeWhile_sublist (l := xs.toList) (fun x => decide (key x = K))).length_le |
| exact h.trans hlen |
|
|
| theorem state_complete (key : α → ℤ) (K : ℤ) (report : α → τ → τ × Bool) |
| (hreport : ∀ x a, (report x a).2 = false) (xs : Array α) (a : τ) |
| (hkeys : ∀ x ∈ xs.toList, key x = K) : |
| (run key K report xs a).state = xs.toList.foldl (fun a x => (report x a).1) a := by |
| have hgroup : TieBuffer.groupView key K (view xs) 0 = xs.toList := by |
| simp only [TieBuffer.groupView, view, List.drop_zero] |
| apply List.takeWhile_eq_self_iff.mpr |
| simpa only [decide_eq_true_eq] using hkeys |
| have h := TieReplay.run_state_complete (read xs) key K report hreport (view xs) |
| (isReader xs) xs.size 0 a (by simp [hgroup]) |
| simpa [run, hgroup] using h |
|
|
| theorem filled_buffer_keys {σ : Type*} (reader : σ → Option (α × σ)) |
| (key : α → ℤ) (K : ℤ) (output : σ → List α) |
| (hreader : RowMerge.IsReader reader output) (B : ℕ) (s : σ) : |
| ∀ x ∈ (TieBuffer.fill reader key K B s).buffer.toList, key x = K := by |
| rw [TieBuffer.fill_buffer reader key K output hreader B s] |
| intro x hx |
| have htake : x ∈ (output s).takeWhile (fun y => decide (key y = K)) := |
| List.mem_of_mem_take hx |
| have htrue : decide (key x = K) = true := List.mem_takeWhile_imp (p := fun y => decide (key y = K)) htake |
| exact of_decide_eq_true htrue |
|
|
| end BufferReplay |
| end LowSpaceSubsetSum |
|
|
| end OAI |
|
|
