| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.CountedFill |
| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.CountedJoinOne |
| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.CountedReplayPotential |
| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.TieGroup |
|
|
| namespace OAI |
|
|
| /-! # Counted Cartesian tie groups with telescoping replay costs -/ |
|
|
| namespace LowSpaceSubsetSum.CountedTieGroup |
|
|
| universe u v s t w |
| variable {α : Type u} {β : Type v} {σ₁ : Type s} {σ₂ : Type t} {τ : Type w} |
|
|
| def potential (A C B : ℕ) (st : TieGroup.State σ₂ τ) : ℕ := |
| A * st.queries + C * st.reports + B * st.restores |
|
|
| def step (read : σ₂ → Option (β × σ₂) × ℕ) (key : β → ℤ × ℕ) (K : ℤ) |
| (report : α → β → τ → (τ × Bool) × ℕ) (clone : σ₂ → σ₂ × ℕ) |
| (buffer : Array β) (saved : σ₂) (long : Bool) (fuel : ℕ) |
| (x : α) (st : TieGroup.State σ₂ τ) : (TieGroup.State σ₂ τ × Bool) × ℕ := |
| let out := CountedJoinOne.run read key K (report x) clone buffer saved long fuel st.user |
| ((⟨out.1.cursor, out.1.state, st.queries + out.1.queries, st.reports + out.1.reports, |
| st.restores + if long then 1 else 0⟩, out.1.halted), out.2 + 6) |
|
|
| theorem step_value (read : σ₂ → Option (β × σ₂) × ℕ) (key : β → ℤ × ℕ) (K : ℤ) |
| (report : α → β → τ → (τ × Bool) × ℕ) (clone : σ₂ → σ₂ × ℕ) |
| (hclone : ∀ s, (clone s).1 = s) (buffer : Array β) (saved : σ₂) |
| (long : Bool) (fuel : ℕ) (x : α) (st : TieGroup.State σ₂ τ) : |
| (step read key K report clone buffer saved long fuel x st).1 = |
| TieGroup.step (fun s => (read s).1) (fun y => (key y).1) K |
| (fun x y a => (report x y a).1) buffer saved long fuel x st := by |
| simp only [step, CountedJoinOne.run_value read key K (report x) clone hclone, TieGroup.step] |
|
|
| theorem step_work_potential |
| (read : σ₂ → Option (β × σ₂) × ℕ) (key : β → ℤ × ℕ) (K : ℤ) |
| (report : α → β → τ → (τ × Bool) × ℕ) (clone : σ₂ → σ₂ × ℕ) |
| (R L C B : ℕ) (hr : ∀ s, (read s).2 ≤ R) (hk : ∀ y, (key y).2 ≤ L) |
| (hc : ∀ x y a, (report x y a).2 ≤ C) (hcopy : ∀ s, (clone s).2 ≤ B) |
| (buffer : Array β) (saved : σ₂) (long : Bool) (fuel : ℕ) (x : α) (st : TieGroup.State σ₂ τ) : |
| (step read key K report clone buffer saved long fuel x st).2 + |
| potential (max R 4 + L + 8) C B st ≤ |
| potential (max R 4 + L + 8) C B |
| (step read key K report clone buffer saved long fuel x st).1.1 + 13 := by |
| have h := CountedJoinOne.run_work read key K (report x) clone R L C B hr hk (hc x) hcopy |
| buffer saved long fuel st.user |
| cases long <;> simp only [step, potential, Bool.false_eq_true, ↓reduceIte, |
| Nat.mul_add, Nat.mul_one, Nat.add_zero] at h ⊢ <;> omega |
|
|
| def run (read₁ : σ₁ → Option (α × σ₁) × ℕ) (key₁ : α → ℤ × ℕ) |
| (read₂ : σ₂ → Option (β × σ₂) × ℕ) (key₂ : β → ℤ × ℕ) (cells : β → ℕ) (K : ℤ) |
| (report : α → β → τ → (τ × Bool) × ℕ) (clone : σ₂ → σ₂ × ℕ) |
| (B fuel₁ fuel₂ : ℕ) (s₁ : σ₁) (s₂ : σ₂) (a : τ) : TieGroup.Result σ₁ σ₂ τ × ℕ := |
| let filled := CountedFill.fill read₂ key₂ cells K B s₂ |
| let long := CountedFill.hasKey read₂ key₂ K filled.1.cursor |
| let left := CountedFill.hasKey read₁ key₁ K s₁ |
| let saved := if long.1 && left.1 then clone filled.1.cursor else (filled.1.cursor, 0) |
| let out := CountedReplay.run read₁ key₁ K |
| (step read₂ key₂ K report clone filled.1.buffer saved.1 long.1 fuel₂) |
| fuel₁ s₁ ⟨filled.1.cursor, a, 0, 0, 0⟩ |
| (⟨out.1, filled.1.queries, filled.1.buffer.size, long.1 && left.1⟩, |
| filled.2 + long.2 + left.2 + saved.2 + out.2 + 8) |
|
|
| theorem run_value (read₁ : σ₁ → Option (α × σ₁) × ℕ) (key₁ : α → ℤ × ℕ) |
| (read₂ : σ₂ → Option (β × σ₂) × ℕ) (key₂ : β → ℤ × ℕ) (cells : β → ℕ) (K : ℤ) |
| (report : α → β → τ → (τ × Bool) × ℕ) (clone : σ₂ → σ₂ × ℕ) |
| (hclone : ∀ s, (clone s).1 = s) (B fuel₁ fuel₂ : ℕ) (s₁ : σ₁) (s₂ : σ₂) (a : τ) : |
| (run read₁ key₁ read₂ key₂ cells K report clone B fuel₁ fuel₂ s₁ s₂ a).1 = |
| TieGroup.run (fun s => (read₁ s).1) (fun x => (key₁ x).1) |
| (fun s => (read₂ s).1) (fun y => (key₂ y).1) K |
| (fun x y a => (report x y a).1) B fuel₁ fuel₂ s₁ s₂ a := by |
| have hc : ∀ b : Bool, ∀ s, (if b then clone s else (s, 0)).1 = s := by |
| intro b s |
| cases b <;> simp only [Bool.false_eq_true, ↓reduceIte, hclone] |
| simp only [run, hc, CountedReplay.run_value, step_value read₂ key₂ K report clone hclone, |
| CountedFill.fill_value, CountedFill.hasKey_value, TieGroup.run] |
|
|
| / |
| particular, suffix fuel is not multiplied by the number of outer records. -/ |
| theorem run_work |
| (read₁ : σ₁ → Option (α × σ₁) × ℕ) (key₁ : α → ℤ × ℕ) |
| (read₂ : σ₂ → Option (β × σ₂) × ℕ) (key₂ : β → ℤ × ℕ) (cells : β → ℕ) (K : ℤ) |
| (report : α → β → τ → (τ × Bool) × ℕ) (clone : σ₂ → σ₂ × ℕ) |
| (R₁ R₂ L₁ L₂ S C D : ℕ) |
| (hr₁ : ∀ s, (read₁ s).2 ≤ R₁) (hr₂ : ∀ s, (read₂ s).2 ≤ R₂) |
| (hk₁ : ∀ x, (key₁ x).2 ≤ L₁) (hk₂ : ∀ y, (key₂ y).2 ≤ L₂) |
| (hs : ∀ y, cells y ≤ S) (hc : ∀ x y a, (report x y a).2 ≤ C) |
| (hcopy : ∀ s, (clone s).2 ≤ D) |
| (B fuel₁ fuel₂ : ℕ) (s₁ : σ₁) (s₂ : σ₂) (a : τ) : |
| (run read₁ key₁ read₂ key₂ cells K report clone B fuel₁ fuel₂ s₁ s₂ a).2 ≤ |
| (R₁ + R₂ + L₁ + L₂ + S + 50) * |
| ((run read₁ key₁ read₂ key₂ cells K report clone B fuel₁ fuel₂ s₁ s₂ a).1.outer.queries + |
| (run read₁ key₁ read₂ key₂ cells K report clone B fuel₁ fuel₂ s₁ s₂ a).1.fillQueries + |
| (run read₁ key₁ read₂ key₂ cells K report clone B fuel₁ fuel₂ s₁ s₂ a).1.outer.state.queries + 1) + |
| C * (run read₁ key₁ read₂ key₂ cells K report clone B fuel₁ fuel₂ s₁ s₂ a).1.outer.state.reports + |
| D * ((if (run read₁ key₁ read₂ key₂ cells K report clone B fuel₁ fuel₂ s₁ s₂ a).1.snapshot then 1 else 0) + |
| (run read₁ key₁ read₂ key₂ cells K report clone B fuel₁ fuel₂ s₁ s₂ a).1.outer.state.restores) := by |
| let filled := CountedFill.fill read₂ key₂ cells K B s₂ |
| let long := CountedFill.hasKey read₂ key₂ K filled.1.cursor |
| let left := CountedFill.hasKey read₁ key₁ K s₁ |
| let saved := if long.1 && left.1 then clone filled.1.cursor else (filled.1.cursor, 0) |
| let f := step read₂ key₂ K report clone filled.1.buffer saved.1 long.1 fuel₂ |
| let out := CountedReplay.run read₁ key₁ K f fuel₁ s₁ ⟨filled.1.cursor, a, 0, 0, 0⟩ |
| let A := max R₂ 4 + L₂ + 8 |
| let M := R₁ + R₂ + L₁ + L₂ + S + 50 |
| have hp : ∀ x st, (f x st).2 + potential A C D st ≤ |
| potential A C D (f x st).1.1 + 13 := by |
| intro x st |
| exact step_work_potential read₂ key₂ K report clone R₂ L₂ C D hr₂ hk₂ hc hcopy |
| filled.1.buffer saved.1 long.1 fuel₂ x st |
| have ho := CountedReplay.run_work_potential read₁ key₁ K f (potential A C D) |
| R₁ L₁ 13 hr₁ hk₁ hp fuel₁ s₁ ⟨filled.1.cursor, a, 0, 0, 0⟩ |
| change out.2 + potential A C D ⟨filled.1.cursor, a, 0, 0, 0⟩ ≤ |
| (R₁ + L₁ + 13 + 8) * out.1.queries + potential A C D out.1.state + 1 at ho |
| simp only [potential, Nat.mul_zero, Nat.add_zero] at ho |
| have hf := CountedFill.fill_work read₂ key₂ cells K R₂ L₂ S hr₂ hk₂ hs B s₂ |
| change filled.2 ≤ (R₂ + L₂ + S + 8) * filled.1.queries + 1 at hf |
| have hl := CountedFill.hasKey_work read₂ key₂ K R₂ L₂ hr₂ hk₂ filled.1.cursor |
| change long.2 ≤ R₂ + L₂ + 4 at hl |
| have hleft := CountedFill.hasKey_work read₁ key₁ K R₁ L₁ hr₁ hk₁ s₁ |
| change left.2 ≤ R₁ + L₁ + 4 at hleft |
| have hsaved : saved.2 ≤ D * (if long.1 && left.1 then 1 else 0) := by |
| dsimp only [saved] |
| split |
| · simpa only [Nat.mul_one] using hcopy filled.1.cursor |
| · simp |
| have houter := Nat.mul_le_mul_right out.1.queries |
| (show R₁ + L₁ + 13 + 8 ≤ M by dsimp only [M]; omega) |
| have hfill := Nat.mul_le_mul_right filled.1.queries |
| (show R₂ + L₂ + S + 8 ≤ M by dsimp only [M]; omega) |
| have hinner := Nat.mul_le_mul_right out.1.state.queries |
| (show A ≤ M by dsimp only [A, M]; omega) |
| change filled.2 + long.2 + left.2 + saved.2 + out.2 + 8 ≤ |
| M * (out.1.queries + filled.1.queries + out.1.state.queries + 1) + |
| C * out.1.state.reports + D * ((if long.1 && left.1 then 1 else 0) + out.1.state.restores) |
| simp only [Nat.mul_add, Nat.mul_one] |
| dsimp only [M] at houter hfill hinner ⊢ |
| omega |
|
|
| end LowSpaceSubsetSum.CountedTieGroup |
|
|
| end OAI |
|
|
