| import Mathlib.Data.Nat.Choose.Bounds |
| import Mathlib.Tactic |
|
|
| namespace OAI |
|
|
| /-! # Constant-state multiplicative binomial computation |
|
|
| Each iteration uses one multiplication and one exact division. The three |
| state fields and the division numerator have linearly bounded bit lengths. |
| -/ |
|
|
| namespace LowSpaceSubsetSum.CountedBinomial |
|
|
| structure State where |
| index : ℕ |
| value : ℕ |
| steps : ℕ |
|
|
| def initial : State := ⟨0, 1, 0⟩ |
|
|
| def step (n : ℕ) (s : State) : State := |
| ⟨s.index + 1, s.value * (n - s.index) / (s.index + 1), s.steps + 1⟩ |
|
|
| def runAcc (n : ℕ) : ℕ → State → State |
| | 0, s => s |
| | fuel + 1, s => runAcc n fuel (step n s) |
|
|
| def run (n k : ℕ) : State := |
| if k ≤ n then runAcc n k initial else ⟨k, 0, 0⟩ |
|
|
| theorem recurrence (n k : ℕ) : |
| n.choose k * (n - k) / (k + 1) = n.choose (k + 1) := by |
| rw [← Nat.choose_succ_right_eq] |
| exact Nat.mul_div_cancel _ (by omega) |
|
|
| theorem step_value (n : ℕ) (s : State) (h : s.value = n.choose s.index) : |
| (step n s).value = n.choose (step n s).index := by |
| change s.value * (n - s.index) / (s.index + 1) = n.choose (s.index + 1) |
| rw [h, recurrence] |
|
|
| theorem runAcc_index (n fuel : ℕ) (s : State) : |
| (runAcc n fuel s).index = s.index + fuel := by |
| induction fuel generalizing s with |
| | zero => simp [runAcc] |
| | succ fuel ih => |
| simpa [runAcc, step, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using (ih (step n s)) |
|
|
| theorem runAcc_steps (n fuel : ℕ) (s : State) : |
| (runAcc n fuel s).steps = s.steps + fuel := by |
| induction fuel generalizing s with |
| | zero => simp [runAcc] |
| | succ fuel ih => |
| simpa [runAcc, step, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using (ih (step n s)) |
|
|
| theorem runAcc_value (n fuel : ℕ) (s : State) (h : s.value = n.choose s.index) : |
| (runAcc n fuel s).value = n.choose (s.index + fuel) := by |
| induction fuel generalizing s with |
| | zero => simpa [runAcc] using h |
| | succ fuel ih => |
| simpa [runAcc, step, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using |
| ih (step n s) (step_value n s h) |
|
|
| theorem run_value (n k : ℕ) : (run n k).value = n.choose k := by |
| unfold run |
| split |
| · simpa [initial] using runAcc_value n k initial (by simp [initial]) |
| · rename_i h |
| exact (Nat.choose_eq_zero_of_lt (by omega)).symm |
|
|
| theorem run_steps (n k : ℕ) : (run n k).steps ≤ n := by |
| unfold run |
| split |
| · rename_i h |
| simpa [runAcc_steps, initial] using h |
| · exact Nat.zero_le _ |
|
|
| /-- The division numerator is exactly divisible by the current index. -/ |
| theorem step_divides (n : ℕ) (s : State) (h : s.value = n.choose s.index) : |
| s.index + 1 ∣ s.value * (n - s.index) := by |
| rw [h, ← Nat.choose_succ_right_eq] |
| exact Nat.dvd_mul_left _ _ |
|
|
| theorem value_bound (n : ℕ) (s : State) (h : s.value = n.choose s.index) : |
| s.value ≤ 2 ^ n := by |
| rw [h] |
| exact Nat.choose_le_two_pow n s.index |
|
|
| theorem numerator_bound (n : ℕ) (s : State) (h : s.value = n.choose s.index) : |
| s.value * (n - s.index) < 2 ^ (2 * n) := by |
| calc |
| s.value * (n - s.index) ≤ 2 ^ n * n := |
| Nat.mul_le_mul (value_bound n s h) (Nat.sub_le _ _) |
| _ < 2 ^ n * 2 ^ n := Nat.mul_lt_mul_of_pos_left n.lt_two_pow_self (by positivity) |
| _ = _ := by rw [← pow_add]; congr 1; omega |
|
|
| /-- This bounds every intermediate prefix state of the multiplicative loop, |
| not only its final returned value. -/ |
| theorem prefix_bounds (n k j : ℕ) (hj : j ≤ k) (hk : k ≤ n) : |
| let s := runAcc n j initial |
| s.index ≤ n ∧ s.steps ≤ n ∧ s.value ≤ 2 ^ n ∧ |
| s.value * (n - s.index) < 2 ^ (2 * n) := by |
| dsimp only |
| have hv : (runAcc n j initial).value = n.choose (runAcc n j initial).index := by |
| rw [runAcc_index] |
| exact runAcc_value n j initial (by simp [initial]) |
| refine ⟨?_, ?_, value_bound n _ hv, numerator_bound n _ hv⟩ |
| · simpa [runAcc_index, initial] using hj.trans hk |
| · simpa [runAcc_steps, initial] using hj.trans hk |
|
|
| end LowSpaceSubsetSum.CountedBinomial |
|
|
| end OAI |
|
|
