| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.BudgetedSeparatorFlow |
|
|
| namespace OAI |
|
|
| /-! # Tail-recursive residue enumeration with one shared budget |
|
|
| The loop keeps a residue counter and releases each completed bucket before |
| starting its successor. The work accumulator avoids return frames. |
| -/ |
|
|
| namespace LowSpaceSubsetSum.BudgetedResidueLoop |
|
|
| open BudgetedSeparatorFlow |
|
|
| def reference (bucket : ℕ → Bool) : ℕ → ℕ → Bool |
| | _, 0 => false |
| | z, remaining + 1 => if bucket z then true else reference bucket (z + 1) remaining |
|
|
| def loop (bucket : ℕ → ℕ → Option (Bool × ℕ) × ℕ) : |
| ℕ → ℕ → ℕ → ℕ → Option (Bool × ℕ) × ℕ |
| | z, remaining, budget, work => |
| if 4 ≤ budget then |
| match remaining with |
| | 0 => (some (false, budget - 4), work + 1) |
| | remaining + 1 => |
| let out := bucket z (budget - 4) |
| match out.1 with |
| | none => (none, work + out.2 + 2) |
| | some (true, left) => (some (true, left), work + out.2 + 3) |
| | some (false, left) => loop bucket (z + 1) remaining left (work + out.2 + 3) |
| else (none, work + 1) |
|
|
| def run (bucket : ℕ → ℕ → Option (Bool × ℕ) × ℕ) (z remaining budget : ℕ) := |
| loop bucket z remaining budget 0 |
|
|
| def allowance (bill : ℕ → ℕ) : ℕ → ℕ → ℕ |
| | _, 0 => 4 |
| | z, remaining + 1 => 4 + bill z + allowance bill (z + 1) remaining |
|
|
| theorem allowance_eq (bill : ℕ → ℕ) (z count : ℕ) : |
| allowance bill z count = 4 * (count + 1) + |
| ((List.range count).map (fun i => bill (z + i))).sum := by |
| induction count generalizing z with |
| | zero => simp [allowance] |
| | succ count ih => |
| rw [allowance, ih, List.sum_range_succ'] |
| simp only [Nat.add_zero, Nat.succ_eq_add_one] |
| have he : (fun i => bill (z + (i + 1))) = (fun i => bill (z + 1 + i)) := by |
| funext i |
| congr 1 |
| omega |
| rw [he] |
| omega |
|
|
| theorem loop_account (bucket : ℕ → ℕ → Option (Bool × ℕ) × ℕ) |
| (hb : ∀ z budget, Account budget (bucket z budget)) |
| (z remaining budget work : ℕ) : |
| (loop bucket z remaining budget work).2 ≤ work + budget + 1 ∧ |
| ∀ v left, (loop bucket z remaining budget work).1 = some (v, left) → |
| left ≤ budget ∧ (loop bucket z remaining budget work).2 ≤ work + (budget - left) := by |
| induction remaining generalizing z budget work with |
| | zero => |
| rw [loop] |
| split |
| next hbudget => |
| constructor |
| · dsimp only; omega |
| · intro v left h |
| cases h |
| dsimp only |
| omega |
| next hbudget => |
| constructor |
| · dsimp only; omega |
| · intro v left h |
| contradiction |
| | succ remaining ih => |
| rw [loop] |
| split |
| next hbudget => |
| dsimp only |
| generalize he : bucket z (budget - 4) = out |
| have ho := hb z (budget - 4) |
| rw [he] at ho |
| have hw := ho.1 |
| cases hv : out.1 with |
| | none => |
| dsimp only |
| constructor |
| · omega |
| · intro v left h |
| contradiction |
| | some p => |
| rcases p with ⟨v, left⟩ |
| have hs := ho.2 v left hv |
| cases v |
| · dsimp only |
| have hi := ih (z + 1) left (work + out.2 + 3) |
| constructor |
| · omega |
| · intro v rest h |
| have hh := hi.2 v rest h |
| omega |
| · dsimp only |
| constructor |
| · omega |
| · intro v rest h |
| cases h |
| omega |
| next hbudget => |
| constructor |
| · dsimp only; omega |
| · intro v left h |
| contradiction |
|
|
| theorem account (bucket : ℕ → ℕ → Option (Bool × ℕ) × ℕ) |
| (hb : ∀ z budget, Account budget (bucket z budget)) (z remaining budget : ℕ) : |
| Account budget (run bucket z remaining budget) := by |
| simpa only [run, Account, Nat.zero_add] using loop_account bucket hb z remaining budget 0 |
|
|
| theorem value (bucket : ℕ → ℕ → Option (Bool × ℕ) × ℕ) (pureBucket : ℕ → Bool) |
| (hv : ∀ z budget v left, (bucket z budget).1 = some (v, left) → v = pureBucket z) |
| (z remaining budget work : ℕ) (v : Bool) (left : ℕ) |
| (h : (loop bucket z remaining budget work).1 = some (v, left)) : |
| v = reference pureBucket z remaining := by |
| induction remaining generalizing z budget work v left with |
| | zero => |
| rw [loop] at h |
| split at h |
| · cases h; rfl |
| · contradiction |
| | succ remaining ih => |
| rw [loop] at h |
| split at h |
| next hbudget => |
| cases he : (bucket z (budget - 4)).1 with |
| | none => simp only [he] at h; contradiction |
| | some p => |
| rcases p with ⟨v', rest⟩ |
| have heq := hv z (budget - 4) v' rest he |
| cases v' |
| · simp only [he] at h |
| have hi := ih (z + 1) rest (work + (bucket z (budget - 4)).2 + 3) v left h |
| simpa only [reference, ← heq, Bool.false_eq_true, ↓reduceIte] using hi |
| · simp only [he] at h |
| cases h |
| simp only [reference, ← heq, ↓reduceIte] |
| next hbudget => contradiction |
|
|
| theorem remaining (bucket : ℕ → ℕ → Option (Bool × ℕ) × ℕ) (bill : ℕ → ℕ) |
| (hr : ∀ z budget v left, (bucket z budget).1 = some (v, left) → budget ≤ left + bill z) |
| (z count budget work : ℕ) (v : Bool) (left : ℕ) |
| (h : (loop bucket z count budget work).1 = some (v, left)) : |
| budget ≤ left + allowance bill z count := by |
| induction count generalizing z budget work v left with |
| | zero => |
| rw [loop] at h |
| split at h |
| · cases h; simp only [allowance]; omega |
| · contradiction |
| | succ count ih => |
| rw [loop] at h |
| split at h |
| next hbudget => |
| cases he : (bucket z (budget - 4)).1 with |
| | none => simp only [he] at h; contradiction |
| | some p => |
| rcases p with ⟨v', rest⟩ |
| have hb := hr z (budget - 4) v' rest he |
| cases v' |
| · simp only [he] at h |
| have hi := ih (z + 1) rest (work + (bucket z (budget - 4)).2 + 3) v left h |
| simp only [allowance] |
| omega |
| · simp only [he] at h |
| cases h |
| simp only [allowance] |
| omega |
| next hbudget => contradiction |
|
|
| theorem complete (bucket : ℕ → ℕ → Option (Bool × ℕ) × ℕ) (bill : ℕ → ℕ) |
| (hc : ∀ z budget, bill z ≤ budget → ∃ v left, (bucket z budget).1 = some (v, left)) |
| (hr : ∀ z budget v left, (bucket z budget).1 = some (v, left) → budget ≤ left + bill z) |
| (z count budget work : ℕ) (hb : allowance bill z count ≤ budget) : |
| ∃ v left, (loop bucket z count budget work).1 = some (v, left) := by |
| induction count generalizing z budget work with |
| | zero => |
| have hh : 4 ≤ budget := hb |
| exact ⟨false, budget - 4, by rw [loop, ite_eq_left hh]⟩ |
| | succ count ih => |
| have hh : 4 ≤ budget := by simp only [allowance] at hb; omega |
| have hbill : bill z ≤ budget - 4 := by simp only [allowance] at hb; omega |
| obtain ⟨v, left, he⟩ := hc z (budget - 4) hbill |
| have hrest := hr z (budget - 4) v left he |
| cases v |
| · obtain ⟨v', rest, hi⟩ := ih (z + 1) left (work + (bucket z (budget - 4)).2 + 3) |
| (by simp only [allowance] at hb; omega) |
| exact ⟨v', rest, by rw [loop, ite_eq_left hh]; simpa only [he] using hi⟩ |
| · exact ⟨true, left, by rw [loop, ite_eq_left hh]; simp only [he]⟩ |
|
|
| end LowSpaceSubsetSum.BudgetedResidueLoop |
|
|
| end OAI |
|
|
