| import OAI.Combinatorics.EditApproximation.Binary.BinaryRepresentativeWork |
|
|
| namespace OAI |
|
|
| /-! Work of the literal representative tail. The sole callback premise is |
| an explicit bound on the already-defined band predicate, whose primitive |
| bound is `bandPredicateWithWork_cost`; no accuracy property is assumed. -/ |
|
|
| namespace EditApproximation |
| namespace BinaryFraction |
|
|
| def bandFromActionsBitBudget (n B C : ℕ) : ℕ := |
| 6000 * (B + 1) ^ 2 + 1000 * (8 * B + 7) ^ 2 + n * (C + 3) + 4 |
|
|
| theorem bandFromActionsWithWork_cost {nx ny M : ℕ} (parent : TargetInterval nx) |
| (r : TargetInterval ny) (b : ℕ) (tau theta velocity : BinaryFraction) |
| (child : Fin M → TargetInterval ny → BinaryFraction) |
| (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ []) (B C : ℕ) |
| (hB : 1 ≤ B) (htau : tau.width ≤ B) (hvel : velocity.width ≤ B) |
| (hC : ∀ states ∈ actions, |
| (bandPredicateWithWork parent r b tau theta velocity actions hne child states).2 ≤ C) : |
| (bandFromActionsWithWork parent r b tau theta velocity child actions hne).2 ≤ |
| bandFromActionsBitBudget actions.length B C := by |
| let margin := subWithWork one tau |
| have hmw := subWithWork_width one tau B (by exact hB) htau |
| have hmc := subWithWork_cost one tau B (by exact hB) htau |
| have hgc := leWithWork_cost velocity.absolute margin.1 (8 * B + 6) |
| (by change velocity.width ≤ _; omega) hmw |
| have hfc := filterWithWork_cost |
| (bandPredicateWithWork parent r b tau theta velocity actions hne child) actions C hC |
| unfold bandFromActionsWithWork |
| dsimp only |
| split_ifs |
| · change margin.2 + (leWithWork velocity.absolute margin.1).2 + |
| (filterWithWork (bandPredicateWithWork parent r b tau theta velocity actions hne child) actions).2 + 2 ≤ _ |
| change margin.2 ≤ _ at hmc |
| unfold bandFromActionsBitBudget |
| simp only [Nat.add_assoc, Nat.reduceAdd] at hgc |
| omega |
| · change margin.2 + (leWithWork velocity.absolute margin.1).2 + 1 ≤ _ |
| change margin.2 ≤ _ at hmc |
| unfold bandFromActionsBitBudget |
| simp only [Nat.add_assoc, Nat.reduceAdd] at hgc |
| omega |
|
|
| def representativeTailInputBudget (M B : ℕ) : ℕ := |
| B + endpointScoreWordBudget M B + stateGapWordBudget B + 1 |
|
|
| def representativeTailBitBudget (M n B C : ℕ) : ℕ := |
| let W := representativeTailInputBudget M B |
| wideMinimumBitBudget M n B + 1000 * (W + 1) ^ 2 + stateGapBitBudget B + |
| 2100 * (W + 2) ^ 2 + bandFromActionsBitBudget n (4 * W + 4) C + 3 |
|
|
| theorem representativeFromActionsWithWork_cost {nx ny M : ℕ} (parent : TargetInterval nx) |
| (r : TargetInterval ny) (sourceLength b : ℕ) (tau theta : BinaryFraction) |
| (child : Fin M → TargetInterval ny → BinaryFraction) |
| (actions : List (Fin M → TargetInterval ny)) (B C : ℕ) |
| (htau : tau.width ≤ B) (hsource : Nat.size sourceLength + 2 ≤ B) |
| (hrl : Nat.size r.lo + 2 ≤ B) (hrh : Nat.size r.hi + 2 ≤ B) |
| (he : ∀ states ∈ actions, ∀ i, Nat.size (states i).lo + 2 ≤ B ∧ |
| Nat.size (states i).hi + 2 ≤ B) |
| (hv : ∀ states ∈ actions, ∀ i, (child i (states i)).width ≤ B) |
| (hC : ∀ (hne : actions ≠ []) (velocity : BinaryFraction), |
| velocity.width ≤ 4 * representativeTailInputBudget M B + 4 → |
| ∀ states ∈ actions, |
| (bandPredicateWithWork parent r b tau theta velocity actions hne child states).2 ≤ C) : |
| (representativeFromActionsWithWork parent r sourceLength b tau theta child actions).2 ≤ |
| representativeTailBitBudget M actions.length B C := by |
| by_cases hnil : actions = [] |
| · simp only [representativeFromActionsWithWork, dite_eq_left hnil] |
| dsimp only [representativeTailBitBudget] |
| omega |
| · let W := representativeTailInputBudget M B |
| let Z := wideMinimumWithWork r child actions hnil |
| have hW : B ≤ W := by dsimp only [W, representativeTailInputBudget]; omega |
| have hWpos : 1 ≤ W := by dsimp only [W, representativeTailInputBudget]; omega |
| have hz := wideMinimumWithWork_bounds r child actions hnil B hrl hrh he hv |
| have hZw : Z.1.width ≤ W := hz.1.trans (by dsimp only [W, representativeTailInputBudget]; omega) |
| have hpositive := ltWithWork_cost zero Z.1 W hWpos hZw |
| have hgap := stateGapWithWork_bounds sourceLength r B hsource hrl hrh |
| have hgapW : (stateGapWithWork sourceLength r).1.width ≤ W := hgap.1.trans (by |
| dsimp only [W, representativeTailInputBudget]; omega) |
| have hvel := divWithWork_width_uniform (stateGapWithWork sourceLength r).1 Z.1 W hgapW hZw |
| have hvelc := divWithWork_cost (stateGapWithWork sourceLength r).1 Z.1 W hgapW hZw |
| have hband := bandFromActionsWithWork_cost parent r b tau theta |
| (divWithWork (stateGapWithWork sourceLength r).1 Z.1).1 child actions hnil (4 * W + 4) C |
| (by omega) (htau.trans (by omega)) hvel (hC hnil _ hvel) |
| unfold representativeFromActionsWithWork |
| rw [dite_eq_right hnil] |
| dsimp only |
| split_ifs |
| · change Z.2 + (ltWithWork zero Z.1).2 + (stateGapWithWork sourceLength r).2 + |
| (divWithWork (stateGapWithWork sourceLength r).1 Z.1).2 + |
| (bandFromActionsWithWork parent r b tau theta |
| (divWithWork (stateGapWithWork sourceLength r).1 Z.1).1 child actions hnil).2 + 3 ≤ |
| wideMinimumBitBudget M actions.length B + 1000 * (W + 1) ^ 2 + stateGapBitBudget B + |
| 2100 * (W + 2) ^ 2 + bandFromActionsBitBudget actions.length (4 * W + 4) C + 3 |
| have hzc : Z.2 ≤ wideMinimumBitBudget M actions.length B := hz.2 |
| omega |
| · change Z.2 + (ltWithWork zero Z.1).2 + 2 ≤ |
| wideMinimumBitBudget M actions.length B + 1000 * (W + 1) ^ 2 + stateGapBitBudget B + |
| 2100 * (W + 2) ^ 2 + bandFromActionsBitBudget actions.length (4 * W + 4) C + 3 |
| have hzc : Z.2 ≤ wideMinimumBitBudget M actions.length B := hz.2 |
| omega |
|
|
| def representativeGuardInputBudget (M vertices B : ℕ) : ℕ := |
| 4 * representativeTailInputBudget M B + 4 + B + M + vertices + 2 |
|
|
| def representativeCompleteBitBudget (M vertices B : ℕ) : ℕ := |
| let S := representativeGuardInputBudget M vertices B |
| representativeTailBitBudget M vertices B |
| (bandPredicateBitBudget M S (S ^ prefixArithmeticDegree)) |
|
|
| / |
| the proved finite-prefix implementation, rather than an assumed callback |
| budget. The premises concern only the stored input widths. -/ |
| theorem representativeFromActionsWithWork_complete_cost {nx ny M : ℕ} (parent : TargetInterval nx) |
| (r : TargetInterval ny) (sourceLength b : ℕ) (tau theta : BinaryFraction) |
| (child : Fin M → TargetInterval ny → BinaryFraction) |
| (actions : List (Fin M → TargetInterval ny)) (B : ℕ) |
| (htau : tau.width ≤ B) (htheta : theta.width ≤ B) |
| (hsourceLength : Nat.size sourceLength + 2 ≤ B) |
| (hb : Nat.size b + 2 ≤ B) (hM : Nat.size M + 2 ≤ B) |
| (hrl : Nat.size r.lo + 2 ≤ B) (hrh : 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) |
| (he : ∀ states ∈ actions, ∀ i, Nat.size (states i).lo + 2 ≤ B ∧ |
| Nat.size (states i).hi + 2 ≤ B) |
| (hv : ∀ states ∈ actions, ∀ i, (child i (states i)).width ≤ B) : |
| (representativeFromActionsWithWork parent r sourceLength b tau theta child actions).2 ≤ |
| representativeCompleteBitBudget M actions.length B := by |
| let S := representativeGuardInputBudget M actions.length B |
| have hBS : B ≤ S := by dsimp only [S, representativeGuardInputBudget]; omega |
| have hS : 2 ≤ S := by dsimp only [S, representativeGuardInputBudget]; omega |
| have hMS : M ≤ S := by dsimp only [S, representativeGuardInputBudget]; omega |
| have hnS : actions.length ≤ S := by dsimp only [S, representativeGuardInputBudget]; omega |
| apply representativeFromActionsWithWork_cost parent r sourceLength b tau theta child actions B |
| (bandPredicateBitBudget M S (S ^ prefixArithmeticDegree)) htau hsourceLength hrl hrh he hv |
| intro hne velocity hvelocity states hstates |
| apply bandPredicateWithWork_cost parent r b tau theta velocity actions hne child states S |
| (S ^ prefixArithmeticDegree) hstates (htau.trans hBS) (htheta.trans hBS) |
| (hvelocity.trans (by dsimp only [S, representativeGuardInputBudget]; omega)) |
| (hb.trans hBS) (hM.trans hBS) (hrl.trans hBS) (hrh.trans hBS) (hp.trans hBS) |
| (fun i => ⟨(hsource i).1.trans hBS, (hsource i).2.trans hBS⟩) |
| (fun i => ⟨(hanchor i).1.trans hBS, (hanchor i).2.trans hBS⟩) |
| (hradius.trans hBS) |
| (fun a ha i => ⟨(he a ha i).1.trans hBS, (he a ha i).2.trans hBS⟩) |
| (fun a ha i => (hv a ha i).trans hBS) |
| intro j |
| exact (prefix_guard_budgets_le_fixed_power M j.val actions.length S S hS hMS |
| (j.isLt.le.trans hMS) hnS le_rfl).2.2.2.2.1 |
|
|
| end BinaryFraction |
| end EditApproximation |
|
|
| end OAI |
|
|
