openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Storage /BudgetedCheckerCells.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.BudgetedSeparatorCells | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Storage.StoredTerminalCells | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Storage.StoredQueryCells | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.BudgetedSeparatorArrays | |
| namespace OAI | |
| /-! # Full interrupted-checker buffer lifetime | |
| The header, the interval traversal and the terminal run in the same order | |
| as the budgeted checker. The added peak field accounts for live temporary | |
| lists and continuation cells; shared entry payloads and tables are external. | |
| -/ | |
| namespace LowSpaceSubsetSum.BudgetedCheckerCells | |
| open BudgetedSeparatorCells StoredSeparatorCheck | |
| variable {n g : ℕ} | |
| def run (scratch capacity : ℕ) (target : ℤ) : | |
| List (Block n g) → List (StoredEntry n) → List (StoredEntry n) → | |
| ℕ → ℕ → ℕ → Execution Bool | |
| | [], xs, ys, nx, ny, budget => | |
| scope 8 (BudgetedSeparatorCheck.header capacity nx ny budget) fun fits left => | |
| if fits then StoredTerminalCells.budgeted target xs ys nx ny left | |
| else (BudgetedSeparatorFlow.pure false left, 0) | |
| | b :: rest, xs, ys, nx, ny, budget => | |
| scope 8 (BudgetedSeparatorCheck.header capacity nx ny budget) fun fits left => | |
| if fits then | |
| BudgetedSeparatorCells.run scratch b.queryBound b.leftQuery b.rightQuery | |
| (fun _ as bs na nb remaining => run scratch capacity target rest as bs na nb remaining) | |
| b.depth 0 b.familySize xs ys nx ny left | |
| else (BudgetedSeparatorFlow.pure false left, 0) | |
| theorem run_value (scratch capacity : ℕ) (target : ℤ) (blocks : List (Block n g)) | |
| (xs ys : List (StoredEntry n)) (nx ny budget : ℕ) : | |
| (run scratch capacity target blocks xs ys nx ny budget).1 = | |
| BudgetedSeparatorCheck.execute capacity target blocks xs ys nx ny budget := by | |
| induction blocks generalizing xs ys nx ny budget with | |
| | nil => | |
| simp only [run, scope_value, BudgetedSeparatorCheck.execute] | |
| congr 1 | |
| funext fits left | |
| split | |
| · exact StoredTerminalCells.budgeted_value _ _ _ _ _ _ | |
| · rfl | |
| | cons b rest ih => | |
| simp only [run, scope_value, BudgetedSeparatorCheck.execute] | |
| congr 1 | |
| funext fits left | |
| split | |
| · simp only [BudgetedSeparatorCells.run_value, ih] | |
| · rfl | |
| def bound (scratch n C : ℕ) : List (Block n g) → ℕ | |
| | [] => 8 + 72 * (n + 1) * (C + 1) | |
| | b :: rest => 8 + (b.depth + 1) * (8 * (C + 1) + scratch) + bound scratch n C rest | |
| theorem run_cells (scratch capacity : ℕ) (target : ℤ) (blocks : List (Block n g)) | |
| (xs ys : List (StoredEntry n)) (nx ny budget C : ℕ) | |
| (hx : xs.length = nx) (hy : ys.length = ny) (hsize : nx + ny ≤ C) : | |
| (run scratch capacity target blocks xs ys nx ny budget).2 ≤ bound scratch n C blocks := by | |
| induction blocks generalizing xs ys nx ny budget with | |
| | nil => | |
| rw [run, bound] | |
| apply scope_cells | |
| intro fits left _ | |
| split | |
| · exact StoredTerminalCells.budgeted_cells target xs ys nx ny left C hx hy hsize | |
| · exact Nat.zero_le _ | |
| | cons b rest ih => | |
| rw [run, bound] | |
| refine le_trans (scope_cells 8 (BudgetedSeparatorCheck.header capacity nx ny budget) _ | |
| ((b.depth + 1) * (8 * (C + 1) + scratch) + bound scratch n C rest) ?_) ?_ | |
| · intro fits left _ | |
| split | |
| · apply BudgetedSeparatorCells.run_cells | |
| · intro j as bs na nb remaining ha hb hc | |
| exact ih as bs na nb remaining ha hb (by omega) | |
| · exact hx | |
| · exact hy | |
| · exact hsize | |
| · exact Nat.zero_le _ | |
| · omega | |
| def arrays (scratch capacity : ℕ) (target : ℤ) (blocks : List (Block n g)) | |
| (left right : Array (StoredEntry n)) (budget : ℕ) : Execution Bool := | |
| scope (4 * (left.size + right.size + 1)) (BudgetedSeparatorArrays.convert left right budget) | |
| fun lists remaining => run scratch capacity target blocks lists.1 lists.2 | |
| left.size right.size remaining | |
| theorem arrays_value (scratch capacity : ℕ) (target : ℤ) (blocks : List (Block n g)) | |
| (left right : Array (StoredEntry n)) (budget : ℕ) : | |
| (arrays scratch capacity target blocks left right budget).1 = | |
| BudgetedSeparatorArrays.execute capacity target blocks left right budget := by | |
| simp only [arrays, scope_value, run_value, BudgetedSeparatorArrays.execute] | |
| theorem arrays_cells (scratch capacity : ℕ) (target : ℤ) (blocks : List (Block n g)) | |
| (left right : Array (StoredEntry n)) (budget C : ℕ) (hsize : left.size + right.size ≤ C) : | |
| (arrays scratch capacity target blocks left right budget).2 ≤ | |
| 4 * (C + 1) + bound scratch n C blocks := by | |
| apply le_trans (scope_cells _ _ _ (bound scratch n C blocks) ?_) | |
| · omega | |
| · intro lists remaining h | |
| obtain ⟨rfl, _, _⟩ := BudgetedSeparatorCall.value _ _ _ _ _ h | |
| exact run_cells scratch capacity target blocks left.toList right.toList | |
| left.size right.size remaining C (by simp) (by simp) hsize | |
| theorem bound_le (scratch C depth : ℕ) (blocks : List (Block n g)) | |
| (hd : ∀ b ∈ blocks, b.depth ≤ depth) : | |
| bound scratch n C blocks ≤ 8 + 72 * (n + 1) * (C + 1) + | |
| blocks.length * (8 + (depth + 1) * (8 * (C + 1) + scratch)) := by | |
| induction blocks with | |
| | nil => simp [bound] | |
| | cons b rest ih => | |
| have hb := hd b (by simp) | |
| have hr := ih (fun d hd' => hd d (by simp [hd'])) | |
| have hm := Nat.mul_le_mul_right (8 * (C + 1) + scratch) (Nat.add_le_add_right hb 1) | |
| simp only [bound, List.length_cons] | |
| nlinarith only [hr, hm] | |
| end LowSpaceSubsetSum.BudgetedCheckerCells | |
| end OAI | |