openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Storage /BudgetedPrefixCells.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Search.BudgetedPrefixController | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Storage.PreparedCollectCells | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Search.BudgetedParentCollector | |
| namespace OAI | |
| /-! # Live memory through the interrupted depth-first prefix traversal | |
| An overflowing dictionary is released before descending. The suspended | |
| frame retains the two bounded restriction lists, the order tail, and scalar | |
| counters. Sequential children share a single working region. | |
| -/ | |
| namespace LowSpaceSubsetSum.BudgetedPrefixCells | |
| variable {n : ℕ} {I : Instance n} {C : ℕ} | |
| abbrev Execution (α : Type*) := (Option (α × ℕ) × ℕ) × ℕ | |
| def frame (n : ℕ) := 20 * (n + 1) ^ 2 | |
| def run | |
| (collect : StoredRestriction n → ℕ → Execution (StoredEntry.Dictionary I C)) | |
| (check : Array (StoredEntry n) → ℕ → Execution Bool) | |
| (keep : StoredEntry.Dictionary I C → ℕ) : | |
| List (Fin n) → StoredRestriction n → ℕ → Execution Bool | |
| | order, P, budget => | |
| if StoredPrefixController.header n ≤ budget then | |
| let task := collect P (budget - StoredPrefixController.header n) | |
| match task.1.1 with | |
| | none => ((none, task.1.2 + 2), frame n + task.2) | |
| | some (dictionary, available) => | |
| if dictionary.val.keys.overflow then | |
| match order with | |
| | [] => ((some (false, available), task.1.2 + 4), frame n + task.2) | |
| | i :: rest => | |
| let p₀ := P.force i false | |
| let left := run collect check keep rest p₀.1 available | |
| match left.1.1 with | |
| | none => ((none, task.1.2 + p₀.2 + left.1.2 + 6), | |
| frame n + max task.2 left.2) | |
| | some (true, remaining) => | |
| ((some (true, remaining), task.1.2 + p₀.2 + left.1.2 + 6), | |
| frame n + max task.2 left.2) | |
| | some (false, remaining) => | |
| let p₁ := P.force i true | |
| let right := run collect check keep rest p₁.1 remaining | |
| ((right.1.1, task.1.2 + p₀.2 + left.1.2 + p₁.2 + right.1.2 + 8), | |
| frame n + max task.2 (max left.2 right.2)) | |
| else | |
| let checked := check dictionary.val.records available | |
| ((checked.1.1, task.1.2 + checked.1.2 + 4), | |
| frame n + max task.2 (keep dictionary + checked.2)) | |
| else ((none, 1), frame n) | |
| theorem value | |
| (collect : StoredRestriction n → ℕ → Execution (StoredEntry.Dictionary I C)) | |
| (check : Array (StoredEntry n) → ℕ → Execution Bool) | |
| (keep : StoredEntry.Dictionary I C → ℕ) | |
| (order : List (Fin n)) (P : StoredRestriction n) (budget : ℕ) : | |
| (run collect check keep order P budget).1 = | |
| BudgetedPrefixController.run (fun p b => (collect p b).1) | |
| (fun a b => (check a b).1) order P budget := by | |
| induction order generalizing P budget with | |
| | nil => | |
| rw [run, BudgetedPrefixController.run] | |
| dsimp only | |
| split | |
| · split | |
| · simp_all only | |
| · split <;> simp_all only [ite_true, Bool.false_eq_true, ite_false] | |
| · simp_all only | |
| | cons i order ih => | |
| rw [run, BudgetedPrefixController.run] | |
| dsimp only | |
| split | |
| · split | |
| · simp_all only | |
| · split | |
| · simp only [← ih] | |
| split <;> simp_all only [ite_true] | |
| · simp_all only [Bool.false_eq_true, ite_false] | |
| · simp_all only | |
| theorem cells | |
| (collect : StoredRestriction n → ℕ → Execution (StoredEntry.Dictionary I C)) | |
| (check : Array (StoredEntry n) → ℕ → Execution Bool) | |
| (keep : StoredEntry.Dictionary I C → ℕ) | |
| (L R K : ℕ) (hcollect : ∀ p b, (collect p b).2 ≤ L) | |
| (hkeep : ∀ d, keep d ≤ R) | |
| (hcheck : ∀ (d : StoredEntry.Dictionary I C) b, (check d.val.records b).2 ≤ K) | |
| (order : List (Fin n)) (P : StoredRestriction n) (budget : ℕ) : | |
| (run collect check keep order P budget).2 ≤ | |
| frame n * (order.length + 1) + L + R + K := by | |
| induction order generalizing P budget with | |
| | nil => | |
| have ht := hcollect P (budget - StoredPrefixController.header n) | |
| rw [run] | |
| dsimp only | |
| simp only [List.length_nil, Nat.zero_add, Nat.mul_one] | |
| split | |
| · split | |
| · dsimp only; omega | |
| next d available h => | |
| have hk := hkeep d | |
| have hc := hcheck d available | |
| split | |
| · dsimp only; omega | |
| · dsimp only | |
| have hm : max (collect P (budget - StoredPrefixController.header n)).2 | |
| (keep d + (check d.val.records available).2) ≤ L+R+K := max_le (by omega) (by omega) | |
| omega | |
| · omega | |
| | cons i order ih => | |
| have ht := hcollect P (budget - StoredPrefixController.header n) | |
| have hl := ih (P.force i false).1 | |
| have hr := ih (P.force i true).1 | |
| have hu : L ≤ frame n * (order.length + 1) + L + R + K := by omega | |
| rw [run] | |
| dsimp only | |
| simp only [List.length_cons] | |
| split | |
| · split | |
| · dsimp only; nlinarith only [ht, Nat.zero_le (frame n * order.length)] | |
| next d available h => | |
| have hk := hkeep d | |
| have hc := hcheck d available | |
| split | |
| · split | |
| · dsimp only | |
| have hm := max_le (ht.trans hu) (hl available) | |
| nlinarith only [hm] | |
| · dsimp only | |
| have hm := max_le (ht.trans hu) (hl available) | |
| nlinarith only [hm] | |
| next remaining hleft => | |
| dsimp only | |
| have hm := max_le (ht.trans hu) (max_le (hl available) (hr remaining)) | |
| nlinarith only [hm] | |
| · dsimp only | |
| have hm : max (collect P (budget - StoredPrefixController.header n)).2 | |
| (keep d + (check d.val.records available).2) ≤ L+R+K := max_le (by omega) (by omega) | |
| nlinarith only [hm, Nat.zero_le (frame n * order.length)] | |
| · nlinarith only [Nat.zero_le (frame n * order.length)] | |
| def collect (D : RepresentationParentData n) (F : IndexedMask n) | |
| (hF : F.semantic = D.signs) (B : ℕ) (P : StoredRestriction n) (budget : ℕ) : | |
| Execution (StoredEntry.Dictionary D.input D.capacity) := | |
| let out := PreparedCollectCells.run D F P hF B D.capacity budget | |
| ((out.1.1.map (fun (r, b) => (r.dictionary, b)), out.1.2), out.2) | |
| theorem collect_value (D : RepresentationParentData n) (F : IndexedMask n) | |
| (hF : F.semantic = D.signs) (B : ℕ) (P : StoredRestriction n) (budget : ℕ) : | |
| (collect D F hF B P budget).1 = BudgetedParentCollector.collect D F hF B D.capacity P budget := by | |
| simp only [collect, PreparedCollectCells.run_value, BudgetedParentCollector.collect] | |
| theorem collect_cells (D : RepresentationParentData n) (F : IndexedMask n) | |
| (hF : F.semantic = D.signs) (B : ℕ) (P : StoredRestriction n) (budget : ℕ) | |
| (hn : 10000 ≤ n) (hl : ∀ j, (D.pair j).left.occurrences.card ≤ D.capacity) | |
| (hr : ∀ j, (D.pair j).right.occurrences.card ≤ D.capacity) | |
| (hC : D.capacity ≤ 2 ^ n) (hB : B ≤ D.capacity) : | |
| (collect D F hF B P budget).2 ≤ inputScale D.input ^ 14 * (D.capacity + 1) := | |
| PreparedCollectCells.run_cells D F P hF B budget hn hl hr hC hB | |
| end LowSpaceSubsetSum.BudgetedPrefixCells | |
| end OAI | |