| import OAI.Combinatorics.EditApproximation.Binary.BinaryDistanceWork |
| import OAI.Combinatorics.EditApproximation.Definitions |
|
|
|
|
| namespace OAI |
|
|
| /-! Boolean tests for the affine errors in band membership. The literal |
| product, both subtractions and final comparison have charged bit work. -/ |
|
|
| namespace EditApproximation |
| namespace BinaryFraction |
| |
| theorem canonicalMulWithWork_width (a b : BinaryFraction) (B : ℕ) |
| (ha : a.width ≤ B) (hb : b.width ≤ B) : |
| (a.canonicalMulWithWork b).1.width ≤ 4 * B + 2 := by |
| have hs := UnreducedRational.storageBits_mul a.representation b.representation |
| have ha' := representation_storageBits_le a |
| have hb' := representation_storageBits_le b |
| have hw := canonicalMulWithWork_self_width a b |
| rw [canonicalMulWithWork_representation] at hw |
| omega |
|
|
|
|
|
|
| @[simp] theorem affineErrorWithWork_value (position offset velocity prediction tolerance : BinaryFraction) : |
| (affineErrorWithWork position offset velocity prediction tolerance).1 = true ↔ |
| |position.value - offset.value - velocity.value * prediction.value| ≤ tolerance.value := by |
| simp only [affineErrorWithWork, leWithWork_value, absolute_value, |
| subWithWork_value, canonicalMulWithWork_value] |
|
|
| def affineGuardBitBudget (B : ℕ) : ℕ := |
| 6000 * (B + 1) ^ 2 + 1 + 2000 * (B + 1) ^ 2 + |
| (6000 * (12 * B + 9) ^ 2 + 1) + |
| (1000 * (96 * B + 71) ^ 2 + 1) + 4 |
|
|
| theorem affineErrorWithWork_cost (position offset velocity prediction tolerance : BinaryFraction) |
| (B : ℕ) (hp : position.width ≤ B) (ho : offset.width ≤ B) |
| (hv : velocity.width ≤ B) (hpred : prediction.width ≤ B) (ht : tolerance.width ≤ B) : |
| (affineErrorWithWork position offset velocity prediction tolerance).2 ≤ affineGuardBitBudget B := by |
| have hdw := subWithWork_width position offset B hp ho |
| have hmw := canonicalMulWithWork_width velocity prediction B hv hpred |
| have hd := subWithWork_cost position offset B hp ho |
| have hm := canonicalMulWithWork_cost velocity prediction B hv hpred |
| have hew := subWithWork_width (position.subWithWork offset).1 |
| (velocity.canonicalMulWithWork prediction).1 (12 * B + 8) (by omega) (by omega) |
| have he := subWithWork_cost (position.subWithWork offset).1 |
| (velocity.canonicalMulWithWork prediction).1 (12 * B + 8) (by omega) (by omega) |
| have hc := leWithWork_cost ((position.subWithWork offset).1.subWithWork |
| (velocity.canonicalMulWithWork prediction).1).1.absolute tolerance (96 * B + 70) |
| (by simpa only [absolute_width] using (hew.trans (by omega : 8 * (12 * B + 8) + 6 ≤ 96 * B + 70))) (by omega) |
| simp only [Nat.add_assoc, Nat.reduceAdd] at he hc |
| change _ + _ + _ + _ + 4 ≤ _ |
| unfold affineGuardBitBudget |
| omega |
|
|
| /-- Threshold used in every internal-cut predicate. -/ |
|
|
|
|
| @[simp] theorem bandToleranceWithWork_value (tau theta : BinaryFraction) (b M : ℕ) : |
| (bandToleranceWithWork tau theta b M).1.value = tau.value * theta.value * b / M := by |
| simp only [bandToleranceWithWork, divWithWork_value, canonicalMulWithWork_value, nat_value] |
|
|
| theorem divWithWork_width_uniform (a b : BinaryFraction) (B : ℕ) |
| (ha : a.width ≤ B) (hb : b.width ≤ B) : |
| (a.divWithWork b).1.width ≤ 4 * B + 4 := by |
| have hs := UnreducedRational.storageBits_div a.representation b.representation |
| have ha' := representation_storageBits_le a |
| have hb' := representation_storageBits_le b |
| have hw := divWithWork_self_width a b |
| rw [divWithWork_representation] at hw |
| omega |
|
|
| def bandToleranceBitBudget (B : ℕ) : ℕ := |
| 2000 * (B + 1) ^ 2 + 2000 * (4 * B + 3) ^ 2 + |
| 2100 * (16 * B + 12) ^ 2 + 2 * B + 3 |
|
|
| theorem bandToleranceWithWork_bounds (tau theta : BinaryFraction) (b M B : ℕ) |
| (htau : tau.width ≤ B) (htheta : theta.width ≤ B) |
| (hb : Nat.size b + 2 ≤ B) (hM : Nat.size M + 2 ≤ B) : |
| (bandToleranceWithWork tau theta b M).1.width ≤ 64 * B + 44 ∧ |
| (bandToleranceWithWork tau theta b M).2 ≤ bandToleranceBitBudget B := by |
| have hpw := canonicalMulWithWork_width tau theta B htau htheta |
| have hp := canonicalMulWithWork_cost tau theta B htau htheta |
| have hsw := canonicalMulWithWork_width (canonicalMulWithWork tau theta).1 (nat b) |
| (4 * B + 2) hpw ((nat_width_le b).trans (by omega)) |
| have hs := canonicalMulWithWork_cost (canonicalMulWithWork tau theta).1 (nat b) |
| (4 * B + 2) hpw ((nat_width_le b).trans (by omega)) |
| have htw := divWithWork_width_uniform (canonicalMulWithWork |
| (canonicalMulWithWork tau theta).1 (nat b)).1 (nat M) (16 * B + 10) |
| (by omega) ((nat_width_le M).trans (by omega)) |
| have ht := divWithWork_cost (canonicalMulWithWork |
| (canonicalMulWithWork tau theta).1 (nat b)).1 (nat M) (16 * B + 10) |
| (by omega) ((nat_width_le M).trans (by omega)) |
| refine ⟨by dsimp only [bandToleranceWithWork]; omega, ?_⟩ |
| simp only [Nat.add_assoc, Nat.reduceAdd] at hs ht |
| change _ + _ + _ + Nat.size b + Nat.size M + 3 ≤ _ |
| unfold bandToleranceBitBudget |
| omega |
|
|
| end BinaryFraction |
| end EditApproximation |
|
|
| end OAI |
|
|
