| import OAI.Combinatorics.EditApproximation.Binary.BinaryPrefixReads |
| import OAI.Combinatorics.EditApproximation.Binary.BinaryBandGuardWork |
| import OAI.Combinatorics.EditApproximation.Definitions |
|
|
|
|
| namespace OAI |
|
|
| /-! Literal cut predicates and all-cut loops with costed child readers. -/ |
|
|
| namespace EditApproximation |
|
|
| theorem allWithWork_extra {α : Type*} (read plain : α → Bool × ℕ) (extra : α → ℕ) |
| (xs : List α) (hv : ∀ x ∈ xs, (read x).1 = (plain x).1) |
| (hc : ∀ x ∈ xs, (read x).2 ≤ (plain x).2 + extra x) : |
| (allWithWork read xs).1 = (allWithWork plain xs).1 ∧ |
| (allWithWork read xs).2 ≤ (allWithWork plain xs).2 + (xs.map extra).sum := by |
| have costBound (a a' b b' A B : ℕ) (ha : a ≤ a' + A) (hb : b ≤ b' + B) : |
| a + b + 3 ≤ a' + b' + 3 + (A + B) := by |
| omega |
| induction xs with |
| | nil => exact ⟨rfl, Nat.le_refl _⟩ |
| | cons x xs ih => |
| have hh := hv x List.mem_cons_self |
| have hhCost := hc x List.mem_cons_self |
| have ht := ih (fun y hy => hv y (List.mem_cons_of_mem _ hy)) |
| (fun y hy => hc y (List.mem_cons_of_mem _ hy)) |
| constructor |
| · change ((read x).1 && (allWithWork read xs).1) = |
| ((plain x).1 && (allWithWork plain xs).1) |
| rw [hh, ht.1] |
| · change (read x).2 + (allWithWork read xs).2 + 3 ≤ |
| (plain x).2 + (allWithWork plain xs).2 + 3 + (extra x + (xs.map extra).sum) |
| exact costBound _ _ _ _ _ _ hhCost ht.2 |
|
|
| namespace BinaryFraction |
|
|
|
|
|
|
| theorem cutGuardReadWithWork_eq {nx ny M : ℕ} (parent : TargetInterval nx) (r : TargetInterval ny) |
| (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ []) |
| (read : Fin M → TargetInterval ny → BinaryFraction × ℕ) (states : Fin M → TargetInterval ny) |
| (velocity tolerance : BinaryFraction) (j : Fin M) : |
| (cutGuardReadWithWork parent r actions hne read states velocity tolerance j).1 = |
| (cutGuardWithWork parent r actions hne (fun i q => (read i q).1) states velocity tolerance j).1 := by |
| simp only [cutGuardReadWithWork, cutGuardWithWork] |
| split_ifs |
| · rfl |
| · simp only [prefixMinimumReadWithWork_eq] |
|
|
| theorem cutGuardReadWithWork_cost {nx ny M : ℕ} (parent : TargetInterval nx) (r : TargetInterval ny) |
| (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ []) |
| (read : Fin M → TargetInterval ny → BinaryFraction × ℕ) (states : Fin M → TargetInterval ny) |
| (velocity tolerance : BinaryFraction) (j : Fin M) (R : ℕ) |
| (hr : ∀ action ∈ actions, ∀ i, (read i (action i)).2 ≤ R) : |
| (cutGuardReadWithWork parent r actions hne read states velocity tolerance j).2 ≤ |
| (cutGuardWithWork parent r actions hne (fun i q => (read i q).1) states velocity tolerance j).2 + |
| (actions.length + 1) * (M * (R + 4)) := by |
| have costBound (s o p p' v u w x y A : ℕ) (hp : p ≤ p' + A) : |
| s + o + p + v + u + w + x + y + 5 ≤ s + o + p' + v + u + w + x + y + 5 + A := by |
| omega |
| unfold cutGuardReadWithWork cutGuardWithWork |
| split_ifs |
| · exact Nat.le_add_right _ _ |
| · have h := prefixMinimumReadWithWork_cost parent r actions hne read j.val |
| (subWithWork (nat (states j).lo) (nat (sourceChild parent j).lo)).1 R hr |
| dsimp only |
| rw [prefixMinimumReadWithWork_eq] |
| exact costBound _ _ _ _ _ _ _ _ _ _ h |
| |
| |
| |
| theorem bandPredicateReadWithWork_eq_cost {nx ny M : ℕ} |
| (parent : TargetInterval nx) (r : TargetInterval ny) (b : ℕ) (tau theta velocity : BinaryFraction) |
| (actions : List (Fin M → TargetInterval ny)) (hne : actions ≠ []) |
| (read : Fin M → TargetInterval ny → BinaryFraction × ℕ) (states : Fin M → TargetInterval ny) |
| (R : ℕ) (hr : ∀ action ∈ actions, ∀ i, (read i (action i)).2 ≤ R) : |
| (bandPredicateReadWithWork parent r b tau theta velocity actions hne read states).1 = |
| (bandPredicateWithWork parent r b tau theta velocity actions hne |
| (fun i q => (read i q).1) states).1 ∧ |
| (bandPredicateReadWithWork parent r b tau theta velocity actions hne read states).2 ≤ |
| (bandPredicateWithWork parent r b tau theta velocity actions hne |
| (fun i q => (read i q).1) states).2 + M * ((actions.length + 1) * (M * (R + 4))) := by |
| have costBound (c a t k k' A : ℕ) (hk : k ≤ k' + A) : |
| c + a + t + k + 4 ≤ c + a + t + k' + 4 + A := by |
| omega |
| have h := allWithWork_extra |
| (cutGuardReadWithWork parent r actions hne read states velocity (bandToleranceWithWork tau theta b M).1) |
| (cutGuardWithWork parent r actions hne (fun i q => (read i q).1) states velocity |
| (bandToleranceWithWork tau theta b M).1) |
| (fun _ => (actions.length + 1) * (M * (R + 4))) (List.finRange M) |
| (fun i _ => cutGuardReadWithWork_eq parent r actions hne read states velocity _ i) |
| (fun i _ => cutGuardReadWithWork_cost parent r actions hne read states velocity _ i R hr) |
| simp only [List.map_const', List.length_finRange, List.sum_replicate, smul_eq_mul] at h |
| constructor |
| · simp only [bandPredicateReadWithWork, bandPredicateWithWork, h.1] |
| · unfold bandPredicateReadWithWork bandPredicateWithWork |
| dsimp only |
| exact costBound _ _ _ _ _ _ h.2 |
| |
| end BinaryFraction |
| end EditApproximation |
| |
| end OAI |
| |
