openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Separators /BudgetedSeparatorCheck.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.BudgetedSeparatorTraversal | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.BudgetedSeparatorTerminal | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.StoredSeparatorCheck | |
| namespace OAI | |
| /-! # A fully budgeted checker on the four prepared blocks | |
| Cached lengths drive every guard. The terminal sort, each pair of filters, | |
| and the next block are reached only after their allowances are available. | |
| The callback result carries the unspent allowance into the next branch. | |
| -/ | |
| namespace LowSpaceSubsetSum.BudgetedSeparatorCheck | |
| open BudgetedSeparatorCall BudgetedSeparatorFlow StoredSeparatorCheck | |
| variable {n g : ℕ} | |
| def header (capacity nx ny budget : ℕ) : Outcome Bool := | |
| BudgetedSeparatorCall.run 4 (fun _ => (decide (nx + ny ≤ capacity), 3)) budget | |
| private theorem header_account (capacity nx ny budget : ℕ) : | |
| Account budget (header capacity nx ny budget) := | |
| ⟨BudgetedSeparatorCall.work _ _ _ (by norm_num), | |
| fun a left h => BudgetedSeparatorCall.spent _ _ _ (by norm_num) a left h⟩ | |
| def execute (capacity : ℕ) (target : ℤ) : | |
| List (Block n g) → List (StoredEntry n) → List (StoredEntry n) → | |
| ℕ → ℕ → ℕ → Outcome Bool | |
| | [], xs, ys, nx, ny, budget => | |
| bind (header capacity nx ny budget) fun fits left => | |
| if fits then BudgetedSeparatorTerminal.run target xs ys nx ny left | |
| else pure false left | |
| | b :: rest, xs, ys, nx, ny, budget => | |
| bind (header capacity nx ny budget) fun fits left => | |
| if fits then | |
| BudgetedSeparatorTraversal.execute b.queryBound b.leftQuery b.rightQuery | |
| (fun _ as bs na nb remaining => execute capacity target rest as bs na nb remaining) | |
| b.depth 0 b.familySize xs ys nx ny left | |
| else pure false left | |
| theorem account (capacity : ℕ) (target : ℤ) (blocks : List (Block n g)) | |
| (xs ys : List (StoredEntry n)) (nx ny budget : ℕ) | |
| (hx : xs.length = nx) (hy : ys.length = ny) : | |
| Account budget (execute capacity target blocks xs ys nx ny budget) := by | |
| induction blocks generalizing xs ys nx ny budget with | |
| | nil => | |
| rw [execute] | |
| apply bind_account _ _ _ (header_account _ _ _ _) | |
| intro fits left _ | |
| split | |
| · exact ⟨BudgetedSeparatorTerminal.work target xs ys nx ny left hx hy, | |
| fun result remaining h => BudgetedSeparatorTerminal.spent target xs ys nx ny left | |
| hx hy result remaining h⟩ | |
| · exact pure_account _ _ | |
| | cons b rest ih => | |
| rw [execute] | |
| apply bind_account _ _ _ (header_account _ _ _ _) | |
| intro fits left _ | |
| split | |
| · exact BudgetedSeparatorTraversal.account b.queryBound b.leftQuery b.rightQuery | |
| b.leftQuery_work b.rightQuery_work | |
| (fun _ as bs na nb remaining => execute capacity target rest as bs na nb remaining) | |
| (fun _ as bs na nb remaining ha hb => ih as bs na nb remaining ha hb) | |
| b.depth 0 b.familySize xs ys nx ny left hx hy | |
| · exact pure_account _ _ | |
| def reference (capacity : ℕ) (target : ℤ) : | |
| List (Block n g) → List (StoredEntry n) → List (StoredEntry n) → Bool × ℕ | |
| | [], xs, ys => | |
| if xs.length + ys.length ≤ capacity then | |
| ((StoredEntryTerminal.run target xs ys).1, | |
| 4 + BudgetedSeparatorTerminal.charge n xs.length ys.length) | |
| else (false, 4) | |
| | b :: rest, xs, ys => | |
| if xs.length + ys.length ≤ capacity then | |
| let out := BudgetedSeparatorTraversal.reference b.queryBound b.leftQuery b.rightQuery | |
| (fun _ as bs => reference capacity target rest as bs) b.depth 0 b.familySize xs ys | |
| (out.1, 4 + out.2) | |
| else (false, 4) | |
| end LowSpaceSubsetSum.BudgetedSeparatorCheck | |
| end OAI | |