openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Streams /CountedPrefixSearch.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationJoinLedger | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.PrefixTaskCount | |
| namespace OAI | |
| /-! # Counted depth-first prefix execution | |
| Only the current collector result survives until its overflow test or checker. | |
| On overflow the result is discarded before entering either child. The full | |
| cost tree is an analysis object; execution skips the second child after YES. | |
| Collector and checker implementations carry their own internal costs. | |
| -/ | |
| namespace LowSpaceSubsetSum.CountedPrefixSearch | |
| variable {n : ℕ} | |
| def run (collect : MaskRestriction n → RecordedDictionary.State (Entry (Fin n)) × ℕ) | |
| (check : Array (Entry (Fin n)) → Bool × ℕ) (H : ℕ) : | |
| List (Fin n) → MaskRestriction n → Bool × ℕ | |
| | order, P => | |
| let task := collect P | |
| if task.1.keys.overflow then | |
| match order with | |
| | [] => (false, task.2 + H) | |
| | i :: rest => | |
| let left := run collect check H rest (P.force i false) | |
| if left.1 then (true, task.2 + left.2 + H) else | |
| let right := run collect check H rest (P.force i true) | |
| (right.1, task.2 + left.2 + right.2 + H) | |
| else | |
| let checked := check task.1.records | |
| (checked.1, task.2 + checked.2 + H) | |
| /-- The hypothetical full tree includes a sibling skipped after early YES. -/ | |
| def fullCost (collect : MaskRestriction n → RecordedDictionary.State (Entry (Fin n)) × ℕ) | |
| (check : Array (Entry (Fin n)) → Bool × ℕ) (H : ℕ) : | |
| List (Fin n) → MaskRestriction n → ℕ | |
| | order, P => | |
| let task := collect P | |
| if task.1.keys.overflow then | |
| match order with | |
| | [] => task.2 + H | |
| | i :: rest => task.2 + fullCost collect check H rest (P.force i false) + | |
| fullCost collect check H rest (P.force i true) + H | |
| else task.2 + (check task.1.records).2 + H | |
| theorem run_value (D : RepresentationParentData n) (B : ℕ) | |
| (collect : MaskRestriction n → RecordedDictionary.State (Entry (Fin n)) × ℕ) | |
| (hcollect : ∀ P, (collect P).1 = ({ D with maskRestriction := P }.collect B).state.user) | |
| (check : Array (Entry (Fin n)) → Bool × ℕ) (H : ℕ) | |
| (order : List (Fin n)) (P : MaskRestriction n) : | |
| (run collect check H order P).1 = D.searchRight B (fun a => (check a).1) order P := by | |
| induction order generalizing P with | |
| | nil => | |
| simp only [run, RepresentationParentData.searchRight, hcollect] | |
| split <;> rfl | |
| | cons i order ih => | |
| simp only [run, RepresentationParentData.searchRight, hcollect] | |
| split | |
| · simp only [ih] | |
| split <;> rfl | |
| · rfl | |
| theorem run_work | |
| (collect : MaskRestriction n → RecordedDictionary.State (Entry (Fin n)) × ℕ) | |
| (check : Array (Entry (Fin n)) → Bool × ℕ) (H : ℕ) | |
| (order : List (Fin n)) (P : MaskRestriction n) : | |
| (run collect check H order P).2 ≤ fullCost collect check H order P := by | |
| induction order generalizing P with | |
| | nil => simp only [run, fullCost]; split <;> rfl | |
| | cons i order ih => | |
| have hl := ih (P.force i false) | |
| have hr := ih (P.force i true) | |
| simp only [run, fullCost] | |
| split | |
| · split <;> dsimp only <;> omega | |
| · rfl | |
| /-- Separate task setup, join counters and completed checker calls. This | |
| composes concrete task cost proofs without revisiting the exponential tree. -/ | |
| theorem fullCost_le_ledger (D : RepresentationParentData n) (B : ℕ) | |
| (collect : MaskRestriction n → RecordedDictionary.State (Entry (Fin n)) × ℕ) | |
| (hcollect : ∀ P, (collect P).1 = ({ D with maskRestriction := P }.collect B).state.user) | |
| (check : Array (Entry (Fin n)) → Bool × ℕ) (H A M C K : ℕ) | |
| (hwork : ∀ P, (collect P).2 ≤ A * (D.capacity + 1) + | |
| M * (({ D with maskRestriction := P }).localLedger B).queries + | |
| C * (({ D with maskRestriction := P }).localLedger B).reports + | |
| K * (({ D with maskRestriction := P }).localLedger B).copies) | |
| (order : List (Fin n)) (P : MaskRestriction n) : | |
| fullCost collect check H order P ≤ | |
| (A * (D.capacity + 1) + H) * D.taskStarts B order P + | |
| M * (D.prefixLedger B order P).queries + | |
| C * (D.prefixLedger B order P).reports + | |
| K * (D.prefixLedger B order P).copies + | |
| ((D.completedArrays B order P).map (fun a => (check a).2)).sum := by | |
| induction order generalizing P with | |
| | nil => | |
| have hw := hwork P | |
| simp only [fullCost, hcollect, RepresentationParentData.taskStarts, | |
| RepresentationParentData.prefixLedger, RepresentationParentData.completedArrays] | |
| split <;> simp only [List.map_nil, List.sum_nil, List.map_cons, List.sum_cons, | |
| Nat.add_zero, Nat.mul_one] | |
| · omega | |
| · omega | |
| | cons i order ih => | |
| have hw := hwork P | |
| have h₀ := ih (P.force i false) | |
| have h₁ := ih (P.force i true) | |
| simp only [fullCost, hcollect, RepresentationParentData.taskStarts, | |
| RepresentationParentData.prefixLedger, RepresentationParentData.completedArrays] | |
| split | |
| · simp only [CompressionLedger.add, Nat.mul_add, Nat.mul_one, List.map_append, List.sum_append] | |
| simp only [Nat.mul_add, Nat.mul_one] at hw h₀ h₁ | |
| omega | |
| · simp only [Nat.mul_one, List.map_cons, List.map_nil, List.sum_cons, List.sum_nil, Nat.add_zero] | |
| omega | |
| end LowSpaceSubsetSum.CountedPrefixSearch | |
| end OAI | |