| import OAI.Combinatorics.LowSpaceSubsetSum.Search.BudgetedReplayLoops |
|
|
| namespace OAI |
|
|
| /-! |
|
|
| The live counter retains the buffer and the two cursors around a fetch. |
| Reader and key calls supply their own scratch traces. The loop drops its old |
| cursor before the tail call, so the bound is independent of the query count. |
| -/ |
|
|
| namespace LowSpaceSubsetSum.BudgetedFillCells |
|
|
| universe u v |
| variable {α : Type u} {σ : Type v} |
|
|
| def loop (charge : ℕ) (read : σ → (Option (α × σ) × ℕ) × ℕ) |
| (key : α → (ℤ × ℕ) × ℕ) (cells : α → ℕ) (stateCells : σ → ℕ) (K : ℤ) : |
| ℕ → σ → Array α → ℕ → ℕ → ℕ → ℕ → ℕ → |
| (Option (TieBuffer.Result α σ × ℕ) × ℕ) × ℕ |
| | fuel, s, buf, q, budget, work, used, peak => |
| let live := max peak (used + stateCells s + 16) |
| if charge ≤ budget then |
| let left := budget - charge |
| match fuel with |
| | 0 => ((some (⟨buf, s, q⟩, left), work + 1), live) |
| | fuel + 1 => |
| let fetched := read s |
| let live := max live (used + stateCells s + fetched.2 + 16) |
| match fetched.1.1 with |
| | none => ((some (⟨buf, s, q + 1⟩, left), work + fetched.1.2 + 5), live) |
| | some (x, s') => |
| let found := key x |
| let live := max live |
| (2 * used + stateCells s + stateCells s' + 2 * cells x + found.2 + 20) |
| if found.1.1 = K then |
| loop charge read key cells stateCells K fuel s' (buf.push x) (q + 1) left |
| (work + (fetched.1.2 + found.1.2 + cells x + 8)) (used + cells x + 1) live |
| else ((some (⟨buf, s, q + 1⟩, left), work + fetched.1.2 + found.1.2 + 6), live) |
| else ((none, work + 1), live) |
|
|
| theorem loop_value (charge : ℕ) (read : σ → (Option (α × σ) × ℕ) × ℕ) |
| (key : α → (ℤ × ℕ) × ℕ) (cells : α → ℕ) (stateCells : σ → ℕ) (K : ℤ) |
| (fuel : ℕ) (s : σ) (buf : Array α) (q budget work used peak : ℕ) : |
| (loop charge read key cells stateCells K fuel s buf q budget work used peak).1 = |
| ((BudgetedFill.execute charge (fun s => (read s).1) (fun x => (key x).1) |
| cells K fuel s buf q budget).1, |
| work + (BudgetedFill.execute charge (fun s => (read s).1) (fun x => (key x).1) |
| cells K fuel s buf q budget).2) := by |
| induction fuel generalizing s buf q budget work used peak with |
| | zero => rw [loop, BudgetedFill.execute]; split <;> rfl |
| | succ fuel ih => |
| rw [loop, BudgetedFill.execute] |
| split |
| · dsimp only |
| cases hr : (read s).1.1 with |
| | none => simp only [Nat.add_assoc] |
| | some p => |
| rcases p with ⟨x, s'⟩ |
| dsimp only |
| split |
| · rw [ih] |
| simp only [Nat.add_assoc] |
| · simp only [Nat.add_assoc] |
| · rfl |
|
|
| theorem loop_cells (charge : ℕ) (read : σ → (Option (α × σ) × ℕ) × ℕ) |
| (key : α → (ℤ × ℕ) × ℕ) (cells : α → ℕ) (stateCells : σ → ℕ) (K : ℤ) |
| (R L S X : ℕ) (hr : ∀ s, (read s).2 ≤ R) (hk : ∀ x, (key x).2 ≤ L) |
| (hs : ∀ s, stateCells s ≤ S) (hx : ∀ x, cells x ≤ X) |
| (fuel : ℕ) (s : σ) (buf : Array α) (q budget work used peak : ℕ) : |
| (loop charge read key cells stateCells K fuel s buf q budget work used peak).2 ≤ |
| max peak (2 * (used + (X + 1) * fuel) + 2 * S + R + L + 2 * X + 40) := by |
| induction fuel generalizing s buf q budget work used peak with |
| | zero => |
| have h := hs s |
| simp only [loop, Nat.mul_zero, Nat.add_zero] |
| split <;> dsimp only |
| all_goals exact max_le_max le_rfl (by omega) |
| | succ fuel ih => |
| have hstate := hs s |
| have hread := hr s |
| rw [loop] |
| split |
| · dsimp only |
| cases hfetch : (read s).1.1 with |
| | none => |
| dsimp only |
| simp only [Nat.mul_add, Nat.mul_one] |
| omega |
| | some p => |
| rcases p with ⟨x, s'⟩ |
| have hstate' := hs s' |
| have hkey := hk x |
| have hcell := hx x |
| dsimp only |
| split |
| · have hi := ih s' (buf.push x) (q + 1) (budget - charge) |
| (work + ((read s).1.2 + (key x).1.2 + cells x + 8)) |
| (used + cells x + 1) |
| (max (max (max peak (used + stateCells s + 16)) |
| (used + stateCells s + (read s).2 + 16)) |
| (2 * used + stateCells s + stateCells s' + 2 * cells x + (key x).2 + 20)) |
| simp only [Nat.mul_add, Nat.mul_one] at hi ⊢ |
| omega |
| · simp only [Nat.mul_add, Nat.mul_one] |
| omega |
| · dsimp only |
| simp only [Nat.mul_add, Nat.mul_one] |
| omega |
|
|
| def run (charge : ℕ) (read : σ → (Option (α × σ) × ℕ) × ℕ) |
| (key : α → (ℤ × ℕ) × ℕ) (cells : α → ℕ) (stateCells : σ → ℕ) (K : ℤ) |
| (B : ℕ) (s : σ) (budget : ℕ) : (Option (TieBuffer.Result α σ × ℕ) × ℕ) × ℕ := |
| loop charge read key cells stateCells K B s |
|
|
| theorem run_value (charge : ℕ) (read : σ → (Option (α × σ) × ℕ) × ℕ) |
| (key : α → (ℤ × ℕ) × ℕ) (cells : α → ℕ) (stateCells : σ → ℕ) (K : ℤ) |
| (B : ℕ) (s : σ) (budget : ℕ) : |
| (run charge read key cells stateCells K B s budget).1 = |
| BudgetedFill.execute charge (fun s => (read s).1) (fun x => (key x).1) |
| cells K B s |
| simpa only [run, Nat.zero_add] using |
| loop_value charge read key cells stateCells K B s |
|
|
| theorem run_cells (charge : ℕ) (read : σ → (Option (α × σ) × ℕ) × ℕ) |
| (key : α → (ℤ × ℕ) × ℕ) (cells : α → ℕ) (stateCells : σ → ℕ) (K : ℤ) |
| (R L S X : ℕ) (hr : ∀ s, (read s).2 ≤ R) (hk : ∀ x, (key x).2 ≤ L) |
| (hs : ∀ s, stateCells s ≤ S) (hx : ∀ x, cells x ≤ X) |
| (B : ℕ) (s : σ) (budget : ℕ) : |
| (run charge read key cells stateCells K B s budget).2 ≤ |
| 2 * ((X + 1) * B + 1) + 2 * S + R + L + 2 * X + 40 := by |
| simpa only [run, Nat.zero_max, Nat.add_comm 1] using |
| loop_cells charge read key cells stateCells K R L S X hr hk hs hx B s |
|
|
| end LowSpaceSubsetSum.BudgetedFillCells |
|
|
| end OAI |
|
|
