openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Storage /BudgetedStoppedCells.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Search.BudgetedStoppedLoop | |
| namespace OAI | |
| /-! # Constant-retention execution of the stopped join loop | |
| Only the current state survives an iteration. The peak accumulator records | |
| the temporary overlap between the old and returned state; no prior state is | |
| stored in a continuation frame. | |
| -/ | |
| namespace LowSpaceSubsetSum.BudgetedStoppedCells | |
| universe s t w | |
| variable {σ₁ : Type s} {σ₂ : Type t} {τ : Type w} | |
| local notation "State" => StreamJoin.State σ₁ σ₂ τ | |
| local notation "Result" => StreamJoin.StoppedResult σ₁ σ₂ τ | |
| def loop (step : State → ℕ → (Option (State × ℕ) × ℕ) × ℕ) | |
| (cells : State → ℕ) : | |
| ℕ → State → ℕ → ℕ → ℕ → ℕ → (Option (Result × ℕ) × ℕ) × ℕ | |
| | fuel, st, steps, budget, work, peak => | |
| let live := max peak (cells st + 16) | |
| if 4 ≤ budget then | |
| match fuel with | |
| | 0 => ((some (⟨st, steps⟩, budget - 4), work + 1), live) | |
| | fuel + 1 => | |
| if st.done then ((some (⟨st, steps⟩, budget - 4), work + 1), live) else | |
| let next := step st (budget - 4) | |
| let live := max live (cells st + next.2 + 16) | |
| match next.1.1 with | |
| | none => ((none, work + next.1.2 + 2), live) | |
| | some (state, left) => | |
| loop step cells fuel state (steps + 1) left (work + next.1.2 + 3) | |
| (max live (cells st + cells state + 16)) | |
| else ((none, work + 1), live) | |
| theorem loop_value (step : State → ℕ → (Option (State × ℕ) × ℕ) × ℕ) | |
| (cells : State → ℕ) (fuel : ℕ) (st : State) (steps budget work peak : ℕ) : | |
| (loop step cells fuel st steps budget work peak).1 = | |
| BudgetedStoppedLoop.loop (fun st b => (step st b).1) fuel st steps budget work := by | |
| induction fuel generalizing st steps budget work peak with | |
| | zero => rw [loop, BudgetedStoppedLoop.loop]; split <;> rfl | |
| | succ fuel ih => | |
| rw [loop, BudgetedStoppedLoop.loop] | |
| split | |
| · by_cases hd : st.done = true | |
| · simp only [hd, ↓reduceIte] | |
| · simp only [hd, Bool.false_eq_true, ↓reduceIte] | |
| cases hn : (step st (budget - 4)).1.1 with | |
| | none => rfl | |
| | some p => | |
| rcases p with ⟨state, left⟩ | |
| exact ih _ _ _ _ _ | |
| · rfl | |
| theorem loop_cells (step : State → ℕ → (Option (State × ℕ) × ℕ) × ℕ) | |
| (cells : State → ℕ) (S T : ℕ) | |
| (hs : ∀ st, cells st ≤ S) (ht : ∀ st b, (step st b).2 ≤ T) | |
| (fuel : ℕ) (st : State) (steps budget work peak : ℕ) : | |
| (loop step cells fuel st steps budget work peak).2 ≤ max peak (2 * S + T + 32) := by | |
| induction fuel generalizing st steps budget work peak with | |
| | zero => | |
| have h := hs st | |
| rw [loop] | |
| split <;> dsimp only <;> exact max_le_max le_rfl (by omega) | |
| | succ fuel ih => | |
| have h := hs st | |
| have hk := ht st (budget - 4) | |
| rw [loop] | |
| split | |
| · by_cases hd : st.done = true | |
| · simp only [hd, ↓reduceIte] | |
| exact max_le_max le_rfl (by omega) | |
| · simp only [hd, Bool.false_eq_true, ↓reduceIte] | |
| cases hn : (step st (budget - 4)).1.1 with | |
| | none => dsimp only; omega | |
| | some p => | |
| rcases p with ⟨state, left⟩ | |
| have ho := hs state | |
| have hi := ih state (steps + 1) left (work + (step st (budget - 4)).1.2 + 3) | |
| (max (max (max peak (cells st + 16)) | |
| (cells st + (step st (budget - 4)).2 + 16)) (cells st + cells state + 16)) | |
| exact hi.trans (by omega) | |
| · dsimp only | |
| exact max_le_max le_rfl (by omega) | |
| def run (step : State → ℕ → (Option (State × ℕ) × ℕ) × ℕ) (cells : State → ℕ) | |
| (fuel : ℕ) (st : State) (budget : ℕ) := loop step cells fuel st 0 budget 0 0 | |
| theorem run_value (step : State → ℕ → (Option (State × ℕ) × ℕ) × ℕ) (cells : State → ℕ) | |
| (fuel : ℕ) (st : State) (budget : ℕ) : | |
| (run step cells fuel st budget).1 = BudgetedStoppedLoop.run (fun st b => (step st b).1) fuel st budget := | |
| loop_value _ _ _ _ _ _ _ _ | |
| theorem run_cells (step : State → ℕ → (Option (State × ℕ) × ℕ) × ℕ) | |
| (cells : State → ℕ) (S T : ℕ) | |
| (hs : ∀ st, cells st ≤ S) (ht : ∀ st b, (step st b).2 ≤ T) | |
| (fuel : ℕ) (st : State) (budget : ℕ) : | |
| (run step cells fuel st budget).2 ≤ 2 * S + T + 32 := by | |
| simpa only [run, Nat.zero_max] using loop_cells step cells S T hs ht fuel st 0 budget 0 0 | |
| end LowSpaceSubsetSum.BudgetedStoppedCells | |
| end OAI | |