| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.DictionaryCallback |
|
|
| namespace OAI |
|
|
| /-! |
| # Dictionary space at every stopped join prefix |
|
|
| The callback invariant is preserved inside buffer replay, suffix replay, |
| tie-group replay, and the outer join loop. Thus the storage bound holds at |
| every watchdog cutoff, without assuming that a join completes. |
| -/ |
|
|
| namespace LowSpaceSubsetSum.DictionaryPrefixes |
|
|
| theorem one_preserves {α σ τ : Type*} |
| (read : σ → Option (α × σ)) (key : α → ℤ) (K : ℤ) |
| (report : α → τ → τ × Bool) (P : τ → Prop) |
| (hstep : ∀ x a, P a → P (report x a).1) |
| (buffer : Array α) (saved : σ) (long : Bool) (fuel : ℕ) (a : τ) (ha : P a) : |
| P (JoinOne.run read key K report buffer saved long fuel a).state := by |
| have hb : P (BufferReplay.run key K report buffer a).state := by |
| exact TieReplay.run_preserves (BufferReplay.read buffer) key K report |
| (fun a _ => P a) (fun x a _ ha => hstep x a ha) buffer.size 0 a ha |
| dsimp only [JoinOne.run] |
| split |
| · exact hb |
| · split |
| · exact TieReplay.run_preserves read key K report (fun a _ => P a) |
| (fun x a _ ha => hstep x a ha) fuel saved _ hb |
| · exact hb |
|
|
| theorem group_preserves {α β σ₁ σ₂ τ : Type*} |
| (read₁ : σ₁ → Option (α × σ₁)) (key₁ : α → ℤ) |
| (read₂ : σ₂ → Option (β × σ₂)) (key₂ : β → ℤ) (K : ℤ) |
| (report : α → β → τ → τ × Bool) (P : τ → Prop) |
| (hstep : ∀ x y a, P a → P (report x y a).1) |
| (B fuel₁ fuel₂ : ℕ) (s₁ : σ₁) (s₂ : σ₂) (a : τ) (ha : P a) : |
| P (TieGroup.run read₁ key₁ read₂ key₂ K report B fuel₁ fuel₂ s₁ s₂ a).outer.state.user := by |
| let filled := TieBuffer.fill read₂ key₂ K B s₂ |
| let long := TieBuffer.hasKey read₂ key₂ K filled.cursor |
| have hs : ∀ x (st : TieGroup.State σ₂ τ) (_r : ℕ), P st.user → |
| P (TieGroup.step read₂ key₂ K report filled.buffer filled.cursor long fuel₂ x st).1.user := by |
| intro x st _ hst |
| exact one_preserves read₂ key₂ K (report x) P (hstep x) |
| filled.buffer filled.cursor long fuel₂ st.user hst |
| exact TieReplay.run_preserves read₁ key₁ K |
| (TieGroup.step read₂ key₂ K report filled.buffer filled.cursor long fuel₂) |
| (fun st _ => P st.user) hs fuel₁ s₁ ⟨filled.cursor, a, 0, 0, 0⟩ ha |
|
|
| theorem step_preserves {α β σ₁ σ₂ τ : Type*} |
| (read₁ : σ₁ → Option (α × σ₁)) (key₁ : α → ℤ) |
| (read₂ : σ₂ → Option (β × σ₂)) (key₂ : β → ℤ) |
| (report : α → β → τ → τ × Bool) (P : τ → Prop) |
| (hstep : ∀ x y a, P a → P (report x y a).1) |
| (B fuel₁ fuel₂ : ℕ) (st : StreamJoin.State σ₁ σ₂ τ) (ha : P st.user) : |
| P (StreamJoin.step read₁ key₁ read₂ key₂ report B fuel₁ fuel₂ st).user := by |
| by_cases hd : st.done = true |
| · simpa only [StreamJoin.step_done _ _ _ _ _ _ _ _ st hd] using ha |
| have hdf : st.done = false := Bool.eq_false_iff.mpr hd |
| cases hx : read₁ st.left with |
| | none => simpa only [StreamJoin.step, hdf, Bool.false_eq_true, ↓reduceIte, hx] using ha |
| | some xp => |
| obtain ⟨x, left'⟩ := xp |
| cases hy : read₂ st.right with |
| | none => |
| simpa only [StreamJoin.step, hdf, Bool.false_eq_true, ↓reduceIte, hx, hy] using ha |
| | some yp => |
| obtain ⟨y, right'⟩ := yp |
| simp only [StreamJoin.step, hdf, Bool.false_eq_true, ↓reduceIte, hx, hy] |
| split |
| · exact ha |
| · split |
| · exact ha |
| · exact group_preserves read₁ key₁ read₂ key₂ (key₁ x) report P hstep |
| B fuel₁ fuel₂ st.left st.right st.user ha |
|
|
| theorem run_preserves {α β σ₁ σ₂ τ : Type*} |
| (read₁ : σ₁ → Option (α × σ₁)) (key₁ : α → ℤ) |
| (read₂ : σ₂ → Option (β × σ₂)) (key₂ : β → ℤ) |
| (report : α → β → τ → τ × Bool) (P : τ → Prop) |
| (hstep : ∀ x y a, P a → P (report x y a).1) |
| (B fuel₁ fuel₂ controlFuel : ℕ) (st : StreamJoin.State σ₁ σ₂ τ) (ha : P st.user) : |
| P (StreamJoin.runAcc read₁ key₁ read₂ key₂ report B fuel₁ fuel₂ controlFuel st).user := by |
| induction controlFuel generalizing st with |
| | zero => exact ha |
| | succ fuel ih => |
| exact ih _ (step_preserves read₁ key₁ read₂ key₂ report P hstep B fuel₁ fuel₂ st ha) |
|
|
| / |
| for the dictionary-space invariant at a stopped control prefix. -/ |
| theorem stopped_safe {α β σ₁ σ₂ : Type*} {C width : ℕ} |
| (read₁ : σ₁ → Option (α × σ₁)) (key₁ : α → ℤ) |
| (read₂ : σ₂ → Option (β × σ₂)) (key₂ : β → ℤ) |
| (encode : α → β → List Bool) (hwidth : ∀ x y, (encode x y).length = width) |
| (B fuel₁ fuel₂ controlFuel : ℕ) (s₁ : σ₁) (s₂ : σ₂) : |
| BinaryTrie.Safe C width (StreamJoin.run read₁ key₁ read₂ key₂ |
| (BinaryTrie.callback C encode) B fuel₁ fuel₂ controlFuel s₁ s₂ ⟨.empty, false, 0⟩).user := by |
| exact run_preserves read₁ key₁ read₂ key₂ (BinaryTrie.callback C encode) |
| (BinaryTrie.Safe C width) (fun x y a ha => BinaryTrie.feed_safe ha _ (hwidth x y)) |
| B fuel₁ fuel₂ controlFuel (StreamJoin.start s₁ s₂ ⟨.empty, false, 0⟩) |
| (BinaryTrie.empty_safe C width) |
|
|
| theorem stopped_nodes {α β σ₁ σ₂ : Type*} {C width : ℕ} |
| (read₁ : σ₁ → Option (α × σ₁)) (key₁ : α → ℤ) |
| (read₂ : σ₂ → Option (β × σ₂)) (key₂ : β → ℤ) |
| (encode : α → β → List Bool) (hwidth : ∀ x y, (encode x y).length = width) |
| (B fuel₁ fuel₂ controlFuel : ℕ) (s₁ : σ₁) (s₂ : σ₂) : |
| BinaryTrie.nodes (StreamJoin.run read₁ key₁ read₂ key₂ (BinaryTrie.callback C encode) |
| B fuel₁ fuel₂ controlFuel s₁ s₂ ⟨.empty, false, 0⟩).user.tree ≤ |
| (width + 1) * (C + 1) := by |
| have h := stopped_safe (C := C) read₁ key₁ read₂ key₂ encode hwidth |
| B fuel₁ fuel₂ controlFuel s₁ s₂ |
| exact (BinaryTrie.nodes_le_width_mul_entries h.hasWidth h.compact).trans |
| (Nat.mul_le_mul_left _ h.bound) |
|
|
| end LowSpaceSubsetSum.DictionaryPrefixes |
|
|
| end OAI |
|
|
