| import OAI.Combinatorics.EditApproximation.Binary.BinaryPrefixWork |
| import OAI.Combinatorics.EditApproximation.Binary.BinaryAffineGuard |
| import OAI.Combinatorics.EditApproximation.Refinement.ComputedBands |
| import OAI.Combinatorics.EditApproximation.Definitions |
|
|
|
|
| namespace OAI |
|
|
| /-! Exact finite band predicates evaluated on stored Boolean fractions. |
| The cut tests use the actual finite prefix minimum; the other tests are |
| Boolean comparisons of the actual interval endpoints. -/ |
|
|
| namespace EditApproximation |
|
|
| open Finset |
|
|
|
|
|
|
| @[simp] theorem naturalEqualWithWork_value (a b : ℕ) : |
| (naturalEqualWithWork a b).1 = true ↔ a = b := by |
| simp only [naturalEqualWithWork, decide_eq_true_eq, binaryNaturalCompareWithWork_eq] |
|
|
| theorem naturalEqualWithWork_cost (a b B : ℕ) (ha : Nat.size a ≤ B) (hb : Nat.size b ≤ B) : |
| (naturalEqualWithWork a b).2 ≤ 8 * B + 2 := by |
| have h := binaryNaturalCompareWithWork_cost a b |
| change (binaryNaturalCompareWithWork a b).2 + 1 ≤ _ |
| omega |
|
|
|
|
|
|
| @[simp] theorem zeroConnectionWithWork_value {n : ℕ} (start finish : ℕ) |
| (states : List (TargetInterval n)) : |
| (zeroConnectionWithWork start states finish).1 = true ↔ |
| connectionBudget start states finish = 0 := by |
| induction states generalizing start with |
| | nil => |
| change (naturalEqualWithWork start finish).1 = true ↔ Nat.dist start finish = 0 |
| exact (naturalEqualWithWork_value start finish).trans |
| ⟨Nat.dist_eq_zero, Nat.eq_of_dist_eq_zero⟩ |
| | cons state rest ih => |
| change ((naturalEqualWithWork start state.lo).1 && |
| (zeroConnectionWithWork state.hi rest finish).1) = true ↔ |
| Nat.dist start state.lo + connectionBudget state.hi rest finish = 0 |
| rw [Bool.and_eq_true, naturalEqualWithWork_value, ih, Nat.add_eq_zero_iff] |
| constructor |
| · rintro ⟨hs, ht⟩ |
| exact ⟨Nat.dist_eq_zero hs, ht⟩ |
| · rintro ⟨hs, ht⟩ |
| exact ⟨Nat.eq_of_dist_eq_zero hs, ht⟩ |
|
|
| theorem zeroConnectionWithWork_cost {n : ℕ} (start finish : ℕ) |
| (states : List (TargetInterval n)) (B : ℕ) |
| (hs : Nat.size start ≤ B) (hf : Nat.size finish ≤ B) |
| (he : ∀ s ∈ states, Nat.size s.lo ≤ B ∧ Nat.size s.hi ≤ B) : |
| (zeroConnectionWithWork start states finish).2 ≤ (states.length + 1) * (8 * B + 3) := by |
| induction states generalizing start with |
| | nil => |
| have h := naturalEqualWithWork_cost start finish B hs hf |
| simpa only [zeroConnectionWithWork, List.length_nil, zero_add, one_mul] using |
| h.trans (by omega : 8 * B + 2 ≤ 8 * B + 3) |
| | cons state rest ih => |
| have hstate := he state List.mem_cons_self |
| have hc := naturalEqualWithWork_cost start state.lo B hs hstate.1 |
| have ht := ih state.hi hstate.2 (fun s h => he s (List.mem_cons_of_mem _ h)) |
| change _ + _ + 1 ≤ _ |
| simp only [List.length_cons] |
| rw [show rest.length + 1 + 1 = (rest.length + 1) + 1 by omega, Nat.add_mul, Nat.one_mul] |
| omega |
|
|
| /-- Construct a translated endpoint by the actual binary subtract/add routines. -/ |
|
|
|
|
| @[simp] theorem translatedEndpointWithWork_value (reference root endpoint : ℕ) (h : root ≤ endpoint) : |
| (translatedEndpointWithWork reference root endpoint).1 = reference + (endpoint - root) := by |
| simp only [translatedEndpointWithWork, binaryNaturalAddWithWork_value, |
| binaryNaturalSubtractWithWork_value endpoint root h] |
|
|
| theorem translatedEndpointWithWork_cost (reference root endpoint B : ℕ) |
| (h : root ≤ endpoint) (hr : Nat.size reference ≤ B) |
| (hroot : Nat.size root ≤ B) (he : Nat.size endpoint ≤ B) : |
| (translatedEndpointWithWork reference root endpoint).2 ≤ 36 * B + 4 := by |
| have hd := binaryNaturalSubtractWithWork_cost endpoint root |
| have ha := binaryNaturalAddWithWork_cost reference |
| (bitWordValue (binaryNaturalSubtractWithWork endpoint root).1) |
| have hw : Nat.size (bitWordValue (binaryNaturalSubtractWithWork endpoint root).1) ≤ B := by |
| rw [binaryNaturalSubtractWithWork_value endpoint root h] |
| exact (Nat.size_le_size (Nat.sub_le endpoint root)).trans he |
| change _ + _ + 2 ≤ _ |
| omega |
|
|
| namespace BinaryFraction |
|
|
| private theorem nat_dist_cast (a b : ℕ) : (Nat.dist a b : ℚ) = |(a : ℚ) - b| := by |
| rcases le_total a b with h | h |
| · rw [Nat.dist_eq_sub_of_le h, Nat.cast_sub h, abs_of_nonpos (sub_nonpos.mpr (by exact_mod_cast h))] |
| ring |
| · rw [Nat.dist_eq_sub_of_le_right h, Nat.cast_sub h, abs_of_nonneg (sub_nonneg.mpr (by exact_mod_cast h))] |
|
|
|
|
|
|
| @[simp] theorem naturalDistanceLeWithWork_value (a b radius : ℕ) : |
| (naturalDistanceLeWithWork a b radius).1 = true ↔ Nat.dist a b ≤ radius := by |
| simp only [naturalDistanceLeWithWork, leWithWork_value, distanceWithWork_value, nat_value] |
| rw [← nat_dist_cast] |
| constructor <;> intro h <;> exact_mod_cast h |
|
|
| def naturalDistanceBitBudget (B : ℕ) : ℕ := |
| 6000 * (B + 1) ^ 2 + 2 + (1000 * (8 * B + 7) ^ 2 + 1) + 3 * B + 3 |
|
|
| theorem naturalDistanceLeWithWork_cost (a b radius B : ℕ) |
| (ha : Nat.size a + 2 ≤ B) (hb : Nat.size b + 2 ≤ B) |
| (hr : Nat.size radius + 2 ≤ B) : |
| (naturalDistanceLeWithWork a b radius).2 ≤ naturalDistanceBitBudget B := by |
| have hdw := distanceWithWork_width (nat a) (nat b) B |
| ((nat_width_le a).trans ha) ((nat_width_le b).trans hb) |
| have hd := distanceWithWork_cost (nat a) (nat b) B |
| ((nat_width_le a).trans ha) ((nat_width_le b).trans hb) |
| have hc := leWithWork_cost (distanceWithWork (nat a) (nat b)).1 (nat radius) |
| (8 * B + 6) hdw ((nat_width_le radius).trans (by omega)) |
| simp only [Nat.add_assoc, Nat.reduceAdd] at hc |
| change _ + _ + Nat.size a + Nat.size b + Nat.size radius + 3 ≤ _ |
| unfold naturalDistanceBitBudget |
| omega |
|
|
| def cutGuardWithWork {nx ny M : ℕ} (parent : TargetInterval nx) |
| (r : TargetInterval ny) (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ []) |
| (child : Fin M → TargetInterval ny → BinaryFraction) (states : Fin M → TargetInterval ny) |
| (velocity tolerance : BinaryFraction) (j : Fin M) : Bool × ℕ := |
| if j.val = 0 then (true, 1) else |
| let shift := subWithWork (nat (states j).lo) (nat (sourceChild parent j).lo) |
| let offset := subWithWork (nat r.lo) (nat parent.lo) |
| let prediction := prefixMinimumWithWork parent r actions hne child j.val shift.1 |
| let result := affineErrorWithWork shift.1 offset.1 velocity prediction.1 tolerance |
| (result.1, shift.2 + offset.2 + prediction.2 + result.2 + |
| Nat.size (states j).lo + Nat.size (sourceChild parent j).lo + Nat.size r.lo + Nat.size parent.lo + 5) |
|
|
| @[simp] theorem cutGuardWithWork_value {nx ny M : ℕ} (parent : TargetInterval nx) |
| (r : TargetInterval ny) (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ []) |
| (child : Fin M → TargetInterval ny → BinaryFraction) (states : Fin M → TargetInterval ny) |
| (velocity tolerance : BinaryFraction) (j : Fin M) : |
| (cutGuardWithWork parent r actions hne child states velocity tolerance j).1 = true ↔ |
| (0 < j.val → |bandCutShift parent states j - ((r.lo : ℚ) - parent.lo) - velocity.value * |
| rationalWidePrefixMinimum parent r actions hne (fun i q => (child i q).value) |
| j.val (bandCutShift parent states j)| ≤ tolerance.value) := by |
| by_cases hj : j.val = 0 |
| · simp [cutGuardWithWork, hj] |
| · rw [cutGuardWithWork, ite_eq_right hj] |
| dsimp only |
| rw [affineErrorWithWork_value] |
| simp only [subWithWork_value, nat_value, prefixMinimumWithWork_value, bandCutShift] |
| constructor |
| · intro h _ |
| exact h |
| · intro h |
| exact h (Nat.pos_of_ne_zero hj) |
|
|
| def cutGuardWordBudget (M j B : ℕ) : ℕ := |
| prefixWordBudget M j (8 * B + 6) + 76 * B + 50 |
|
|
| def cutGuardBitBudget (M j v B : ℕ) : ℕ := |
| 2 * (6000 * (B + 1) ^ 2 + 1) + |
| prefixMinimumBitBudget M j v (8 * B + 6) + |
| affineGuardBitBudget (cutGuardWordBudget M j B) + 4 * B + 6 |
|
|
| theorem cutGuardWithWork_cost {nx ny M : ℕ} (parent : TargetInterval nx) |
| (r : TargetInterval ny) (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ []) |
| (child : Fin M → TargetInterval ny → BinaryFraction) (states : Fin M → TargetInterval ny) |
| (velocity tolerance : BinaryFraction) (j : Fin M) (B : ℕ) |
| (hvel : velocity.width ≤ B) (htol : tolerance.width ≤ 64 * B + 44) |
| (hr : Nat.size r.lo + 2 ≤ B) (hp : Nat.size parent.lo + 2 ≤ B) |
| (hs : Nat.size (states j).lo + 2 ≤ B) |
| (hc : Nat.size (sourceChild parent j).lo + 2 ≤ B) |
| (hcut : Nat.size (balancedCut parent.lo (parent.hi - parent.lo) M j.val) + 2 ≤ B) |
| (hstates : ∀ action ∈ actions, ∀ i, |
| Nat.size (action i).lo + 2 ≤ B ∧ Nat.size (action i).hi + 2 ≤ B) |
| (hchild : ∀ action ∈ actions, ∀ i, (child i (action i)).width ≤ B) : |
| (cutGuardWithWork parent r actions hne child states velocity tolerance j).2 ≤ |
| cutGuardBitBudget M j.val actions.length B := by |
| by_cases hj : j.val = 0 |
| · simp only [cutGuardWithWork, hj, ↓reduceIte] |
| unfold cutGuardBitBudget |
| omega |
| · have hshift := subWithWork_width (nat (states j).lo) (nat (sourceChild parent j).lo) B |
| ((nat_width_le _).trans hs) ((nat_width_le _).trans hc) |
| have hoffset := subWithWork_width (nat r.lo) (nat parent.lo) B |
| ((nat_width_le _).trans hr) ((nat_width_le _).trans hp) |
| have hshiftCost := subWithWork_cost (nat (states j).lo) (nat (sourceChild parent j).lo) B |
| ((nat_width_le _).trans hs) ((nat_width_le _).trans hc) |
| have hoffsetCost := subWithWork_cost (nat r.lo) (nat parent.lo) B |
| ((nat_width_le _).trans hr) ((nat_width_le _).trans hp) |
| have hlarge : B ≤ 8 * B + 6 := by omega |
| obtain ⟨hpred, hpredCost⟩ := prefixMinimumWithWork_bounds parent r actions hne child j.val |
| (subWithWork (nat (states j).lo) (nat (sourceChild parent j).lo)).1 (8 * B + 6) |
| hshift (hr.trans hlarge) (hcut.trans hlarge) |
| (fun action ha i => ⟨(hstates action ha i).1.trans hlarge, |
| (hstates action ha i).2.trans hlarge⟩) |
| (fun action ha i => (hchild action ha i).trans hlarge) |
| have herr := affineErrorWithWork_cost |
| (subWithWork (nat (states j).lo) (nat (sourceChild parent j).lo)).1 |
| (subWithWork (nat r.lo) (nat parent.lo)).1 velocity |
| (prefixMinimumWithWork parent r actions hne child j.val |
| (subWithWork (nat (states j).lo) (nat (sourceChild parent j).lo)).1).1 |
| tolerance (cutGuardWordBudget M j.val B) |
| (by unfold cutGuardWordBudget; omega) (by unfold cutGuardWordBudget; omega) |
| (by unfold cutGuardWordBudget; omega) (by unfold cutGuardWordBudget; omega) |
| (by unfold cutGuardWordBudget; omega) |
| simp only [cutGuardWithWork, hj, ↓reduceIte] |
| unfold cutGuardBitBudget |
| omega |
|
|
| def bandPredicateWithWork {nx ny M : ℕ} (parent : TargetInterval nx) |
| (r : TargetInterval ny) (b : ℕ) (tau theta velocity : BinaryFraction) |
| (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ []) |
| (child : Fin M → TargetInterval ny → BinaryFraction) (states : Fin M → TargetInterval ny) : Bool × ℕ := |
| let connection := zeroConnectionWithWork r.lo (List.ofFn states) r.hi |
| let anchors := allWithWork (fun i : Fin M => |
| let leftAnchor := translatedEndpointWithWork r.lo parent.lo (sourceChild parent i).lo |
| let rightAnchor := translatedEndpointWithWork r.lo parent.lo (sourceChild parent i).hi |
| let radius := binaryNaturalMulWithWork 6 b |
| let left := naturalDistanceLeWithWork leftAnchor.1 (states i).lo (bitWordValue radius.1) |
| let right := naturalDistanceLeWithWork rightAnchor.1 (states i).hi (bitWordValue radius.1) |
| (left.1 && right.1, leftAnchor.2 + rightAnchor.2 + radius.2 + left.2 + right.2 + 3)) (List.finRange M) |
| let tolerance := bandToleranceWithWork tau theta b M |
| let cuts := allWithWork (cutGuardWithWork parent r actions hne child states velocity tolerance.1) |
| (List.finRange M) |
| (connection.1 && anchors.1 && cuts.1, connection.2 + anchors.2 + tolerance.2 + cuts.2 + 4) |
|
|
| @[simp] theorem bandPredicateWithWork_value {nx ny M : ℕ} (parent : TargetInterval nx) |
| (r : TargetInterval ny) (b : ℕ) (tau theta velocity : BinaryFraction) |
| (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ []) |
| (child : Fin M → TargetInterval ny → BinaryFraction) (states : Fin M → TargetInterval ny) : |
| (bandPredicateWithWork parent r b tau theta velocity actions hne child states).1 = true ↔ |
| bandActionPredicate parent r b tau.value theta.value velocity.value actions hne |
| (fun i q => (child i q).value) states := by |
| have hlo (i : Fin M) : parent.lo ≤ (sourceChild parent i).lo := Nat.le_add_right _ _ |
| have hhi (i : Fin M) : parent.lo ≤ (sourceChild parent i).hi := Nat.le_add_right _ _ |
| simp only [bandPredicateWithWork, Bool.and_eq_true, zeroConnectionWithWork_value, |
| allWithWork_value, naturalDistanceLeWithWork_value, cutGuardWithWork_value, |
| translatedEndpointWithWork_value _ _ _ (hlo _), translatedEndpointWithWork_value _ _ _ (hhi _), |
| binaryNaturalMulWithWork_value, bandToleranceWithWork_value, List.mem_finRange, forall_true_left, |
| endpointActionConnection, bandActionPredicate] |
| exact and_assoc |
|
|
| def anchorGuardBitBudget (B : ℕ) : ℕ := |
| 2 * (36 * B + 4) + 80 * (B + 4) + 2 * naturalDistanceBitBudget B + 3 |
|
|
| def bandPredicateBitBudget (M B C : ℕ) : ℕ := |
| (M + 1) * (8 * B + 3) + M * (anchorGuardBitBudget B + 3) + |
| bandToleranceBitBudget B + M * (C + 3) + 4 |
|
|
| theorem bandPredicateWithWork_cost {nx ny M : ℕ} (parent : TargetInterval nx) |
| (r : TargetInterval ny) (b : ℕ) (tau theta velocity : BinaryFraction) |
| (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ []) |
| (child : Fin M → TargetInterval ny → BinaryFraction) (states : Fin M → TargetInterval ny) |
| (B C : ℕ) (hstatesMem : states ∈ actions) |
| (htau : tau.width ≤ B) (htheta : theta.width ≤ B) (hvel : velocity.width ≤ B) |
| (hb : Nat.size b + 2 ≤ B) (hM : Nat.size M + 2 ≤ B) |
| (hr : Nat.size r.lo + 2 ≤ B) (hrhi : Nat.size r.hi + 2 ≤ B) |
| (hp : Nat.size parent.lo + 2 ≤ B) |
| (hsource : ∀ i : Fin M, Nat.size (sourceChild parent i).lo + 2 ≤ B ∧ |
| Nat.size (sourceChild parent i).hi + 2 ≤ B) |
| (hanchor : ∀ i : Fin M, Nat.size (r.lo + ((sourceChild parent i).lo - parent.lo)) + 2 ≤ B ∧ |
| Nat.size (r.lo + ((sourceChild parent i).hi - parent.lo)) + 2 ≤ B) |
| (hradius : Nat.size (6 * b) + 2 ≤ B) |
| (hstates : ∀ action ∈ actions, ∀ i, |
| Nat.size (action i).lo + 2 ≤ B ∧ Nat.size (action i).hi + 2 ≤ B) |
| (hchild : ∀ action ∈ actions, ∀ i, (child i (action i)).width ≤ B) |
| (hC : ∀ j : Fin M, cutGuardBitBudget M j.val actions.length B ≤ C) : |
| (bandPredicateWithWork parent r b tau theta velocity actions hne child states).2 ≤ |
| bandPredicateBitBudget M B C := by |
| have hstate := hstates states hstatesMem |
| have hlo (i : Fin M) : parent.lo ≤ (sourceChild parent i).lo := Nat.le_add_right _ _ |
| have hhi (i : Fin M) : parent.lo ≤ (sourceChild parent i).hi := Nat.le_add_right _ _ |
| have hconn := zeroConnectionWithWork_cost r.lo r.hi (List.ofFn states) B (by omega) (by omega) (by |
| intro state hs |
| obtain ⟨i, rfl⟩ := List.mem_ofFn.mp hs |
| have := hstate i |
| omega) |
| have hanchorCost (i : Fin M) : |
| (let leftAnchor := translatedEndpointWithWork r.lo parent.lo (sourceChild parent i).lo |
| let rightAnchor := translatedEndpointWithWork r.lo parent.lo (sourceChild parent i).hi |
| let radius := binaryNaturalMulWithWork 6 b |
| let left := naturalDistanceLeWithWork leftAnchor.1 (states i).lo (bitWordValue radius.1) |
| let right := naturalDistanceLeWithWork rightAnchor.1 (states i).hi (bitWordValue radius.1) |
| (left.1 && right.1, leftAnchor.2 + rightAnchor.2 + radius.2 + left.2 + right.2 + 3)).2 ≤ |
| anchorGuardBitBudget B := by |
| have hl := translatedEndpointWithWork_cost r.lo parent.lo (sourceChild parent i).lo B |
| (hlo i) (by omega) (by omega) (by have := hsource i; omega) |
| have hh := translatedEndpointWithWork_cost r.lo parent.lo (sourceChild parent i).hi B |
| (hhi i) (by omega) (by omega) (by have := hsource i; omega) |
| have hrad := binaryNaturalMulWithWork_cost 6 b |
| have hleft := naturalDistanceLeWithWork_cost |
| (translatedEndpointWithWork r.lo parent.lo (sourceChild parent i).lo).1 (states i).lo |
| (bitWordValue (binaryNaturalMulWithWork 6 b).1) B |
| (by rw [translatedEndpointWithWork_value _ _ _ (hlo i)]; exact (hanchor i).1) |
| (hstate i).1 (by rw [binaryNaturalMulWithWork_value]; exact hradius) |
| have hright := naturalDistanceLeWithWork_cost |
| (translatedEndpointWithWork r.lo parent.lo (sourceChild parent i).hi).1 (states i).hi |
| (bitWordValue (binaryNaturalMulWithWork 6 b).1) B |
| (by rw [translatedEndpointWithWork_value _ _ _ (hhi i)]; exact (hanchor i).2) |
| (hstate i).2 (by rw [binaryNaturalMulWithWork_value]; exact hradius) |
| norm_num only [show Nat.size 6 = 3 by decide] at hrad |
| dsimp only |
| unfold anchorGuardBitBudget |
| omega |
| have ha := allWithWork_cost _ (List.finRange M) (anchorGuardBitBudget B) |
| (fun i _ => hanchorCost i) |
| obtain ⟨htw, htc⟩ := bandToleranceWithWork_bounds tau theta b M B htau htheta hb hM |
| have hc := allWithWork_cost |
| (cutGuardWithWork parent r actions hne child states velocity (bandToleranceWithWork tau theta b M).1) |
| (List.finRange M) C (by |
| intro j _ |
| exact (cutGuardWithWork_cost parent r actions hne child states velocity |
| (bandToleranceWithWork tau theta b M).1 j B hvel htw hr hp (hstate j).1 |
| (hsource j).1 (hsource j).1 hstates hchild).trans (hC j)) |
| simp only [List.length_ofFn] at hconn |
| simp only [List.length_finRange] at ha hc |
| change _ + _ + _ + _ + 4 ≤ _ |
| unfold bandPredicateBitBudget |
| dsimp only at ha hc ⊢ |
| omega |
|
|
| end BinaryFraction |
| end EditApproximation |
|
|
| end OAI |
|
|
