File size: 3,397 Bytes
5d5048e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 | 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
|