| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.JoinUserMap |
|
|
| namespace OAI |
|
|
| /-! # Stored-record erasure through buffered joins |
|
|
| The erasure maps both emitted records and reader cursors. Counters and stop |
| flags are preserved, so the work ledger can be transferred to the source |
| parent task without changing the order of equal-weight occurrences. |
| -/ |
|
|
| namespace LowSpaceSubsetSum |
|
|
| universe u v s t w z |
| variable {α : Type u} {β : Type v} {σ : Type s} {σ' : Type t} |
| {τ : Type w} {τ' : Type z} |
|
|
| namespace TieBuffer |
|
|
| def mapAll (f : α → β) (g : σ → σ') (r : Result α σ) : Result β σ' := |
| ⟨r.buffer.map f, g r.cursor, r.queries⟩ |
|
|
| theorem fillAcc_map (f : α → β) (g : σ → σ') |
| (read : σ → Option (α × σ)) (read' : σ' → Option (β × σ')) |
| (hr : ∀ s, read' (g s) = (read s).map (Prod.map f g)) (key : β → ℤ) (K : ℤ) |
| (fuel : ℕ) (s : σ) (buf : Array α) (q : ℕ) : |
| mapAll f g (fillAcc read (fun x => key (f x)) K fuel s buf q) = |
| fillAcc read' key K fuel (g s) (buf.map f) q := by |
| induction fuel generalizing s buf q with |
| | zero => rfl |
| | succ fuel ih => |
| cases h : read s with |
| | none => simp only [fillAcc, hr, h, Option.map_none, mapAll] |
| | some p => |
| rcases p with ⟨x, s'⟩ |
| simp only [fillAcc, hr, h, Option.map_some, Prod.map] |
| split |
| · simpa only [Array.map_push] using ih s' (buf.push x) (q + 1) |
| · rfl |
|
|
| theorem fill_map (f : α → β) (g : σ → σ') |
| (read : σ → Option (α × σ)) (read' : σ' → Option (β × σ')) |
| (hr : ∀ s, read' (g s) = (read s).map (Prod.map f g)) (key : β → ℤ) (K : ℤ) |
| (B : ℕ) (s : σ) : |
| mapAll f g (fill read (fun x => key (f x)) K B s) = fill read' key K B (g s) := |
| by simpa only [fill, Array.map_empty] using fillAcc_map f g read read' hr key K B s #[] 0 |
|
|
| theorem hasKey_map (f : α → β) (g : σ → σ') |
| (read : σ → Option (α × σ)) (read' : σ' → Option (β × σ')) |
| (hr : ∀ s, read' (g s) = (read s).map (Prod.map f g)) (key : β → ℤ) |
| (K : ℤ) (s : σ) : |
| hasKey read' key K (g s) = hasKey read (fun x => key (f x)) K s := by |
| cases h : read s <;> simp only [hasKey, hr, h, Option.map_none, Option.map_some, Prod.map] |
|
|
| end TieBuffer |
|
|
| namespace TieReplay |
|
|
| def mapAll (g : σ → σ') (h : τ → τ') (r : Result σ τ) : Result σ' τ' := |
| ⟨g r.cursor, h r.state, r.queries, r.reports, r.complete, r.halted⟩ |
|
|
| theorem runAcc_map (f : α → β) (g : σ → σ') (h : τ → τ') |
| (read : σ → Option (α × σ)) (read' : σ' → Option (β × σ')) |
| (hr : ∀ s, read' (g s) = (read s).map (Prod.map f g)) (key : β → ℤ) (K : ℤ) |
| (report : α → τ → τ × Bool) (report' : β → τ' → τ' × Bool) |
| (hp : ∀ x a, report' (f x) (h a) = (h (report x a).1, (report x a).2)) |
| (fuel : ℕ) (s : σ) (a : τ) (q r : ℕ) : |
| mapAll g h (runAcc read (fun x => key (f x)) K report fuel s a q r) = |
| runAcc read' key K report' fuel (g s) (h a) q r := by |
| induction fuel generalizing s a q r with |
| | zero => rfl |
| | succ fuel ih => |
| cases hs : read s with |
| | none => simp only [runAcc, hr, hs, Option.map_none, mapAll] |
| | some p => |
| rcases p with ⟨x, s'⟩ |
| simp only [runAcc, hr, hs, Option.map_some, Prod.map] |
| split |
| · rw [hp] |
| split |
| · rfl |
| · exact ih _ _ _ _ |
| · rfl |
|
|
| theorem run_map (f : α → β) (g : σ → σ') (h : τ → τ') |
| (read : σ → Option (α × σ)) (read' : σ' → Option (β × σ')) |
| (hr : ∀ s, read' (g s) = (read s).map (Prod.map f g)) (key : β → ℤ) (K : ℤ) |
| (report : α → τ → τ × Bool) (report' : β → τ' → τ' × Bool) |
| (hp : ∀ x a, report' (f x) (h a) = (h (report x a).1, (report x a).2)) |
| (fuel : ℕ) (s : σ) (a : τ) : |
| mapAll g h (run read (fun x => key (f x)) K report fuel s a) = |
| run read' key K report' fuel (g s) (h a) := |
| runAcc_map f g h read read' hr key K report report' hp fuel s a 0 0 |
|
|
| end TieReplay |
|
|
| namespace BufferReplay |
|
|
| theorem read_map (f : α → β) (xs : Array α) (i : ℕ) : |
| read (xs.map f) i = (read xs i).map (Prod.map f id) := by |
| simp only [read, Array.size_map] |
| split <;> simp only [Option.map_some, Option.map_none, Array.getElem_map, Prod.map, id_eq] |
|
|
| theorem run_map (f : α → β) (key : β → ℤ) (K : ℤ) |
| (report : β → τ → τ × Bool) (xs : Array α) (a : τ) : |
| run (fun x => key (f x)) K (fun x => report (f x)) xs a = |
| run key K report (xs.map f) a := by |
| have h := TieReplay.run_map f id id (read xs) (read (xs.map f)) |
| (read_map f xs) key K (fun x => report (f x)) report (fun _ _ => rfl) xs.size 0 a |
| cases he : TieReplay.run (read xs) (fun x => key (f x)) K |
| (fun x => report (f x)) xs.size 0 a |
| simpa only [run, he, TieReplay.mapAll, id_eq, Array.size_map] using h |
|
|
| end BufferReplay |
|
|
| namespace JoinOne |
|
|
| theorem run_map (f : α → β) (g : σ → σ') |
| (read : σ → Option (α × σ)) (read' : σ' → Option (β × σ')) |
| (hr : ∀ s, read' (g s) = (read s).map (Prod.map f g)) (key : β → ℤ) (K : ℤ) |
| (report : β → τ → τ × Bool) (buffer : Array α) (saved : σ) |
| (long : Bool) (fuel : ℕ) (a : τ) : |
| TieReplay.mapAll g id |
| (run read (fun x => key (f x)) K (fun x => report (f x)) buffer saved long fuel a) = |
| run read' key K report (buffer.map f) (g saved) long fuel a := by |
| simp only [run, BufferReplay.run_map f key K report] |
| split |
| · rfl |
| · split |
| · have h := TieReplay.run_map f g id read read' hr key K |
| (fun x => report (f x)) report (fun _ _ => rfl) fuel saved |
| (BufferReplay.run key K report (buffer.map f) a).state |
| cases he : TieReplay.run read (fun x => key (f x)) K |
| (fun x => report (f x)) fuel saved |
| (BufferReplay.run key K report (buffer.map f) a).state |
| simp only [he, TieReplay.mapAll, id_eq] at h |
| rw [← h] |
| rfl |
| · rfl |
|
|
| end JoinOne |
|
|
| namespace TieGroup |
|
|
| variable {α' β' σ₁' σ₂' : Type*} |
|
|
| def mapReaders (g : σ → σ') (a : State σ τ) : State σ' τ := |
| ⟨g a.last, a.user, a.queries, a.reports, a.restores⟩ |
|
|
| def mapReadersResult (g₁ : σ → σ₁') (g₂ : σ' → σ₂') |
| (r : Result σ σ' τ) : Result σ₁' σ₂' τ := |
| ⟨TieReplay.mapAll g₁ (mapReaders g₂) r.outer, |
| r.fillQueries, r.bufferSize, r.snapshot⟩ |
|
|
| theorem step_mapReaders (f₁ : α → α') (f₂ : β → β') (g : σ → σ') |
| (read : σ → Option (β × σ)) (read' : σ' → Option (β' × σ')) |
| (hr : ∀ s, read' (g s) = (read s).map (Prod.map f₂ g)) (key : β' → ℤ) (K : ℤ) |
| (report : α' → β' → τ → τ × Bool) (buffer : Array β) (saved : σ) |
| (long : Bool) (fuel : ℕ) (x : α) (a : State σ τ) : |
| (mapReaders g (step read (fun y => key (f₂ y)) K |
| (fun x y => report (f₁ x) (f₂ y)) buffer saved long fuel x a).1, |
| (step read (fun y => key (f₂ y)) K |
| (fun x y => report (f₁ x) (f₂ y)) buffer saved long fuel x a).2) = |
| step read' key K report (buffer.map f₂) (g saved) long fuel (f₁ x) (mapReaders g a) := by |
| simp only [step, ← JoinOne.run_map f₂ g read read' hr key K (report (f₁ x))] |
| rfl |
|
|
| theorem run_mapReaders (f₁ : α → α') (f₂ : β → β') (g₁ : σ → σ₁') (g₂ : σ' → σ₂') |
| (read₁ : σ → Option (α × σ)) (read₁' : σ₁' → Option (α' × σ₁')) |
| (read₂ : σ' → Option (β × σ')) (read₂' : σ₂' → Option (β' × σ₂')) |
| (hr₁ : ∀ s, read₁' (g₁ s) = (read₁ s).map (Prod.map f₁ g₁)) |
| (hr₂ : ∀ s, read₂' (g₂ s) = (read₂ s).map (Prod.map f₂ g₂)) |
| (key₁ : α' → ℤ) (key₂ : β' → ℤ) (K : ℤ) |
| (report : α' → β' → τ → τ × Bool) (B fuel₁ fuel₂ : ℕ) |
| (s₁ : σ) (s₂ : σ') (a : τ) : |
| mapReadersResult g₁ g₂ |
| (run read₁ (fun x => key₁ (f₁ x)) read₂ (fun y => key₂ (f₂ y)) K |
| (fun x y => report (f₁ x) (f₂ y)) B fuel₁ fuel₂ s₁ s₂ a) = |
| run read₁' key₁ read₂' key₂ K report B fuel₁ fuel₂ (g₁ s₁) (g₂ s₂) a := by |
| let filled := TieBuffer.fill read₂ (fun y => key₂ (f₂ y)) K B s₂ |
| let long := TieBuffer.hasKey read₂ (fun y => key₂ (f₂ y)) K filled.cursor |
| have hp := fun x st => (step_mapReaders f₁ f₂ g₂ read₂ read₂' hr₂ key₂ K |
| report filled.buffer filled.cursor long fuel₂ x st).symm |
| have hm := TieReplay.run_map f₁ g₁ (mapReaders g₂) read₁ read₁' hr₁ key₁ K |
| (step read₂ (fun y => key₂ (f₂ y)) K (fun x y => report (f₁ x) (f₂ y)) |
| filled.buffer filled.cursor long fuel₂) |
| (step read₂' key₂ K report (filled.buffer.map f₂) (g₂ filled.cursor) long fuel₂) |
| hp fuel₁ s₁ ⟨filled.cursor, a, 0, 0, 0⟩ |
| simp only [run, mapReadersResult, |
| ← TieBuffer.fill_map f₂ g₂ read₂ read₂' hr₂ key₂ K B s₂, |
| TieBuffer.mapAll, Array.size_map, |
| TieBuffer.hasKey_map f₂ g₂ read₂ read₂' hr₂ key₂ K, |
| TieBuffer.hasKey_map f₁ g₁ read₁ read₁' hr₁ key₁ K] |
| rw [hm] |
| rfl |
|
|
| end TieGroup |
|
|
| namespace StreamJoin |
|
|
| variable {α' β' σ₁' σ₂' : Type*} |
|
|
| def mapReaders (g₁ : σ → σ₁') (g₂ : σ' → σ₂') (a : State σ σ' τ) : State σ₁' σ₂' τ := |
| ⟨g₁ a.left, g₂ a.right, a.user, a.queries, a.reports, a.copies, a.done⟩ |
|
|
| def mapReadersStopped (g₁ : σ → σ₁') (g₂ : σ' → σ₂') |
| (a : StoppedResult σ σ' τ) : StoppedResult σ₁' σ₂' τ := |
| ⟨mapReaders g₁ g₂ a.state, a.steps⟩ |
|
|
| theorem step_mapReaders (f₁ : α → α') (f₂ : β → β') (g₁ : σ → σ₁') (g₂ : σ' → σ₂') |
| (read₁ : σ → Option (α × σ)) (read₁' : σ₁' → Option (α' × σ₁')) |
| (read₂ : σ' → Option (β × σ')) (read₂' : σ₂' → Option (β' × σ₂')) |
| (hr₁ : ∀ s, read₁' (g₁ s) = (read₁ s).map (Prod.map f₁ g₁)) |
| (hr₂ : ∀ s, read₂' (g₂ s) = (read₂ s).map (Prod.map f₂ g₂)) |
| (key₁ : α' → ℤ) (key₂ : β' → ℤ) (report : α' → β' → τ → τ × Bool) |
| (B fuel₁ fuel₂ : ℕ) (a : State σ σ' τ) : |
| mapReaders g₁ g₂ (step read₁ (fun x => key₁ (f₁ x)) read₂ (fun y => key₂ (f₂ y)) |
| (fun x y => report (f₁ x) (f₂ y)) B fuel₁ fuel₂ a) = |
| step read₁' key₁ read₂' key₂ report B fuel₁ fuel₂ (mapReaders g₁ g₂ a) := by |
| by_cases hd : a.done = true |
| · simp only [step, mapReaders, hd, ↓reduceIte] |
| · cases h₁ : read₁ a.left with |
| | none => simp only [step, mapReaders, hd, Bool.false_eq_true, ↓reduceIte, |
| hr₁, h₁, Option.map_none] |
| | some p₁ => |
| rcases p₁ with ⟨x, l⟩ |
| cases h₂ : read₂ a.right with |
| | none => simp only [step, mapReaders, hd, Bool.false_eq_true, ↓reduceIte, |
| hr₁, hr₂, h₁, h₂, Option.map_none, Option.map_some, Prod.map] |
| | some p₂ => |
| rcases p₂ with ⟨y, r⟩ |
| simp only [step, mapReaders, hd, Bool.false_eq_true, ↓reduceIte, |
| hr₁, hr₂, h₁, h₂, Option.map_some, Prod.map, |
| ← TieGroup.run_mapReaders f₁ f₂ g₁ g₂ read₁ read₁' read₂ read₂' hr₁ hr₂ |
| key₁ key₂ (key₁ (f₁ x)) report B fuel₁ fuel₂, |
| TieGroup.mapReadersResult, TieReplay.mapAll, TieGroup.mapReaders] |
| split |
| · rfl |
| · split <;> rfl |
|
|
| theorem stoppedAcc_mapReaders (f₁ : α → α') (f₂ : β → β') |
| (g₁ : σ → σ₁') (g₂ : σ' → σ₂') |
| (read₁ : σ → Option (α × σ)) (read₁' : σ₁' → Option (α' × σ₁')) |
| (read₂ : σ' → Option (β × σ')) (read₂' : σ₂' → Option (β' × σ₂')) |
| (hr₁ : ∀ s, read₁' (g₁ s) = (read₁ s).map (Prod.map f₁ g₁)) |
| (hr₂ : ∀ s, read₂' (g₂ s) = (read₂ s).map (Prod.map f₂ g₂)) |
| (key₁ : α' → ℤ) (key₂ : β' → ℤ) (report : α' → β' → τ → τ × Bool) |
| (B fuel₁ fuel₂ fuel : ℕ) (a : State σ σ' τ) : |
| mapReadersStopped g₁ g₂ (stoppedAcc read₁ (fun x => key₁ (f₁ x)) |
| read₂ (fun y => key₂ (f₂ y)) (fun x y => report (f₁ x) (f₂ y)) B fuel₁ fuel₂ fuel a) = |
| stoppedAcc read₁' key₁ read₂' key₂ report B fuel₁ fuel₂ fuel (mapReaders g₁ g₂ a) := by |
| induction fuel generalizing a with |
| | zero => rfl |
| | succ fuel ih => |
| by_cases hd : a.done = true |
| · simp only [stoppedAcc, mapReadersStopped, mapReaders, hd, ↓reduceIte] |
| · have hdone : (mapReaders g₁ g₂ a).done = a.done := rfl |
| have hm := ih (step read₁ (fun x => key₁ (f₁ x)) read₂ (fun y => key₂ (f₂ y)) |
| (fun x y => report (f₁ x) (f₂ y)) B fuel₁ fuel₂ a) |
| simp only [stoppedAcc, hdone, hd, Bool.false_eq_true, ↓reduceIte] |
| rw [← step_mapReaders f₁ f₂ g₁ g₂ read₁ read₁' read₂ read₂' hr₁ hr₂ |
| key₁ key₂ report B fuel₁ fuel₂, ← hm] |
| rfl |
|
|
| end StreamJoin |
|
|
| end LowSpaceSubsetSum |
|
|
| end OAI |
|
|
