| import OAI.Combinatorics.EditApproximation.Binary.BinaryBandInputs |
| import OAI.Combinatorics.EditApproximation.Geometry.BandEnvelopes |
| import OAI.Combinatorics.EditApproximation.Definitions |
|
|
|
|
| namespace OAI |
|
|
| /-! The dyadic envelope is found by a bounded sequence of exact Boolean |
| comparisons. The scan starts at `2⁻ᴮ`, doubles at most `2B` times, and uses |
| the stored fraction width `B`; no real logarithm is evaluated. -/ |
|
|
| namespace EditApproximation |
|
|
|
|
|
|
| theorem powerTwoWord_value (n : ℕ) : bitWordValue (powerTwoWord n) = 2 ^ n := by |
| induction n with |
| | zero => simp [powerTwoWord, bitWordValue] |
| | succ n ih => |
| simp only [powerTwoWord, List.replicate_succ, List.cons_append, bitWordValue, |
| Bool.toNat_false, zero_add] at * |
| rw [ih, pow_succ] |
| omega |
|
|
| theorem powerTwoWord_length (n : ℕ) : (powerTwoWord n).length = n + 1 := by |
| simp [powerTwoWord] |
|
|
| namespace BinaryFraction |
|
|
|
|
|
|
| theorem inversePowerTwo_value (n : ℕ) : (inversePowerTwo n).value = (2 : ℚ) ^ (-(n : ℤ)) := by |
| simp only [inversePowerTwo, value, SignedBinary.value, signedMagnitude, Bool.false_eq_true, |
| ↓reduceIte, bitWordValue, Bool.toNat_true, |
| Int.cast_natCast, powerTwoWord_value, Nat.cast_pow, Nat.cast_ofNat, zpow_neg, zpow_natCast] |
| norm_num [one_div] |
|
|
| theorem inversePowerTwo_width (n : ℕ) : (inversePowerTwo n).width = n + 1 := by |
| simp [inversePowerTwo, width, powerTwoWord_length] |
|
|
|
|
|
|
| theorem doubleFraction_value (a : BinaryFraction) : (doubleFraction a).value = 2 * a.value := by |
| cases h : a.numerator.negative <;> |
| simp [doubleFraction, value, SignedBinary.value, signedMagnitude, h, bitWordValue] <;> ring |
|
|
| theorem doubleFraction_width (a : BinaryFraction) : (doubleFraction a).width ≤ a.width + 1 := by |
| unfold doubleFraction width |
| simp only [List.length_cons] |
| omega |
|
|
|
|
|
|
| private theorem dyadicCeiling_eq_of_bounds (r : ℚ) (e : ℤ) (hr : 0 < r) |
| (hlower : (2 : ℚ) ^ (e - 1) < r) (hupper : r ≤ (2 : ℚ) ^ e) : |
| rationalDyadicCeiling r = (2 : ℚ) ^ e := by |
| have hl := (Int.zpow_lt_iff_lt_clog (by decide : 1 < 2) hr).mp hlower |
| have hu := (Int.le_zpow_iff_clog_le (by decide : 1 < 2) hr).mp hupper |
| have he : Int.clog 2 r = e := by omega |
| rw [rationalDyadicCeiling, he] |
|
|
| theorem dyadicScanWithWork_value (a candidate : BinaryFraction) (n : ℕ) (e : ℤ) |
| (ha : 0 < a.value) (hc : candidate.value = (2 : ℚ) ^ e) |
| (hlower : (2 : ℚ) ^ (e - 1) < a.value) |
| (hupper : a.value ≤ candidate.value * (2 : ℚ) ^ n) : |
| (dyadicScanWithWork a candidate n).1.value = rationalDyadicCeiling a.value := by |
| induction n generalizing candidate e with |
| | zero => |
| simp only [pow_zero, mul_one] at hupper |
| exact hc.trans (dyadicCeiling_eq_of_bounds a.value e ha hlower (hc ▸ hupper)).symm |
| | succ n ih => |
| unfold dyadicScanWithWork |
| dsimp only |
| split_ifs with hlt |
| · have hlt' := (ltWithWork_value candidate a).mp hlt |
| have hc' : (doubleFraction candidate).value = (2 : ℚ) ^ (e + 1) := by |
| rw [doubleFraction_value, hc, zpow_add₀ (by norm_num : (2 : ℚ) ≠ 0), zpow_one] |
| ring |
| apply ih _ (e + 1) hc' |
| · simpa only [add_sub_cancel_right, ← hc] using hlt' |
| · rw [doubleFraction_value] |
| simpa only [pow_succ, mul_comm, mul_left_comm, mul_assoc] using hupper |
| · have hupper' : a.value ≤ candidate.value := |
| le_of_not_gt (fun h => hlt ((ltWithWork_value candidate a).mpr h)) |
| exact hc.trans (dyadicCeiling_eq_of_bounds a.value e ha hlower (hc ▸ hupper')).symm |
|
|
| theorem dyadicScanWithWork_width (a candidate : BinaryFraction) (n : ℕ) : |
| (dyadicScanWithWork a candidate n).1.width ≤ candidate.width + n := by |
| induction n generalizing candidate with |
| | zero => simp [dyadicScanWithWork] |
| | succ n ih => |
| unfold dyadicScanWithWork |
| dsimp only |
| split_ifs |
| · exact (ih _).trans (by have h := doubleFraction_width candidate; omega) |
| · change candidate.width ≤ candidate.width + (n + 1) |
| omega |
|
|
| theorem dyadicScanWithWork_cost (a candidate : BinaryFraction) (n W : ℕ) |
| (ha : a.width ≤ W) (hc : candidate.width + n ≤ W) : |
| (dyadicScanWithWork a candidate n).2 ≤ 1 + n * (1000 * (W + 1) ^ 2 + 2) := by |
| induction n generalizing candidate with |
| | zero => simp [dyadicScanWithWork] |
| | succ n ih => |
| have hcmp := ltWithWork_cost candidate a W (by omega) ha |
| have hdouble := doubleFraction_width candidate |
| have hnext := ih (doubleFraction candidate) (by omega) |
| unfold dyadicScanWithWork |
| dsimp only |
| split_ifs |
| · rw [Nat.add_mul, Nat.one_mul] |
| omega |
| · have hp : 1000 * (W + 1) ^ 2 + 2 ≤ (n + 1) * (1000 * (W + 1) ^ 2 + 2) := |
| Nat.le_mul_of_pos_left _ (by omega) |
| omega |
|
|
| theorem positive_value_lower (a : BinaryFraction) (ha : 0 < a.value) : |
| (2 : ℚ) ^ (-(a.width : ℤ)) ≤ a.value := by |
| have hd : (0 : ℚ) < bitWordValue a.denominator := by exact_mod_cast a.denominator_pos |
| have hn : (0 : ℚ) < a.numerator.value := (div_pos_iff_of_pos_right hd).mp ha |
| have hnum : (1 : ℚ) ≤ a.numerator.value := by |
| have hnZ : (0 : ℤ) < a.numerator.value := by exact_mod_cast hn |
| exact_mod_cast (show (1 : ℤ) ≤ a.numerator.value by omega) |
| have hden : (bitWordValue a.denominator : ℚ) ≤ (2 : ℚ) ^ a.width := by |
| exact_mod_cast (bitWordValue_lt_pow_length a.denominator).le.trans |
| (Nat.pow_le_pow_right (by decide) (le_max_right _ _)) |
| rw [zpow_neg, zpow_natCast, ← one_div] |
| change 1 / (2 : ℚ) ^ a.width ≤ (a.numerator.value : ℚ) / bitWordValue a.denominator |
| apply (div_le_div_iff₀ (pow_pos (by norm_num : (0 : ℚ) < 2) _) hd).mpr |
| simpa only [one_mul] using |
| hden.trans (le_mul_of_one_le_left (pow_nonneg (by norm_num) _) hnum) |
|
|
|
|
|
|
| theorem dyadicCeilingWithWork_value (a : BinaryFraction) (ha : 0 < a.value) : |
| (dyadicCeilingWithWork a).1.value = rationalDyadicCeiling a.value := by |
| apply dyadicScanWithWork_value a (inversePowerTwo a.width) (2 * a.width) (-(a.width : ℤ)) ha |
| (inversePowerTwo_value _) |
| · have hpos : (0 : ℚ) < (2 : ℚ) ^ (-(a.width : ℤ) - 1) := zpow_pos (by norm_num) _ |
| have hdouble : (2 : ℚ) ^ (-(a.width : ℤ) - 1) * 2 = (2 : ℚ) ^ (-(a.width : ℤ)) := by |
| rw [← zpow_add_one₀ (by norm_num : (2 : ℚ) ≠ 0)] |
| congr 1 |
| omega |
| have hl := positive_value_lower a ha |
| nlinarith only [hpos, hdouble, hl] |
| · rw [inversePowerTwo_value, ← zpow_natCast] |
| rw [← zpow_add₀ (by norm_num : (2 : ℚ) ≠ 0)] |
| have he : -(a.width : ℤ) + (2 * a.width : ℕ) = (a.width : ℤ) := by omega |
| rw [he, zpow_natCast] |
| exact (le_abs_self _).trans (value_abs_le_pow_width a) |
|
|
| theorem dyadicCeilingWithWork_width (a : BinaryFraction) : |
| (dyadicCeilingWithWork a).1.width ≤ 3 * a.width + 1 := by |
| have h := dyadicScanWithWork_width a (inversePowerTwo a.width) (2 * a.width) |
| rw [inversePowerTwo_width] at h |
| exact h.trans (by omega) |
|
|
| theorem dyadicCeilingWithWork_cost (a : BinaryFraction) : |
| (dyadicCeilingWithWork a).2 ≤ |
| 1 + 2 * a.width * (1000 * (3 * a.width + 2) ^ 2 + 2) + 3 * a.width + 5 := by |
| have h := dyadicScanWithWork_cost a (inversePowerTwo a.width) (2 * a.width) (3 * a.width + 1) |
| (by omega) (by rw [inversePowerTwo_width]; omega) |
| rw [show 3 * a.width + 1 + 1 = 3 * a.width + 2 by omega] at h |
| exact Nat.add_le_add_right (Nat.add_le_add_right h (3 * a.width)) 5 |
|
|
|
|
| theorem dyadicCeilingWithWork_cost_le (a : BinaryFraction) (B : ℕ) (hB : a.width ≤ B) : |
| (dyadicCeilingWithWork a).2 ≤ |
| 1 + 2 * B * (1000 * (3 * B + 2) ^ 2 + 2) + 3 * B + 5 := by |
| have h := dyadicCeilingWithWork_cost a |
| have hs := Nat.pow_le_pow_left (show 3 * a.width + 2 ≤ 3 * B + 2 by omega) 2 |
| have hp := Nat.mul_le_mul (show 2 * a.width ≤ 2 * B by omega) |
| (show 1000 * (3 * a.width + 2) ^ 2 + 2 ≤ 1000 * (3 * B + 2) ^ 2 + 2 by omega) |
| omega |
|
|
| end BinaryFraction |
| end EditApproximation |
|
|
| end OAI |
|
|
