File size: 5,328 Bytes
e63eb7f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 | import OAI.Combinatorics.EditApproximation.Binary.BinaryReadCostBounds
import OAI.Combinatorics.EditApproximation.Binary.BinaryContinuationReads
namespace OAI
/-! Continuation cost transfer includes both Bellman scans and the
literal online score array, with each child lookup charged. -/
namespace EditApproximation
namespace BinaryFraction
theorem bellmanActionReadWithWork_factor {Parent Child : Type*} {M : ℕ}
(distance : Parent → Parent → BinaryFraction × ℕ) (L : BinaryFraction)
(read : Child → BinaryFraction × ℕ) (query : Parent)
(action : BinaryBellmanAction Parent Child M) (R : ℕ)
(hr : ∀ i, (read (action.childState i)).2 ≤ R) :
(bellmanActionReadWithWork distance L read query action).2 ≤
(bellmanActionWithWork distance L (fun s => (read s).1) query action).2 * tableReadFactor R := by
apply tableReadFactor_absorb _ _ M R
(bellmanActionReadWithWork_cost distance L read query action R hr)
have hs : M ≤ (sumListWithWork (List.ofFn fun i => (read (action.childState i)).1)).2 := by
simp only [sumListWithWork, List.length_ofFn]
omega
unfold bellmanActionWithWork
dsimp only
omega
theorem bellmanReadWithWork_factor {Parent Child : Type*} {M : ℕ}
(distance : Parent → Parent → BinaryFraction × ℕ) (L fallback : BinaryFraction)
(read : Child → BinaryFraction × ℕ) (query : Parent)
(actions : List (BinaryBellmanAction Parent Child M)) (R : ℕ)
(hr : ∀ action ∈ actions, ∀ i, (read (action.childState i)).2 ≤ R) :
(bellmanReadWithWork distance L fallback read query actions).2 ≤
(bellmanWithWork distance L fallback (fun s => (read s).1) query actions).2 * tableReadFactor R := by
have hs := arithmeticMapWithWork_factor
(bellmanActionReadWithWork distance L read query)
(bellmanActionWithWork distance L (fun s => (read s).1) query)
actions (tableReadFactor R) (tableReadFactor_pos R)
(fun action _ => bellmanActionReadWithWork_eq distance L read query action)
(fun action ha => bellmanActionReadWithWork_factor distance L read query action R (hr action ha))
unfold bellmanReadWithWork bellmanWithWork
dsimp only
rw [hs.1]
apply cost_replace_factor _ _ _ _ _ hs.2 (tableReadFactor_pos R) <;> omega
theorem localContinuationReadWithWork_factor {Parent Child : Type*} {M : ℕ}
(distance : Parent → Parent → BinaryFraction × ℕ) (L delta fallback : BinaryFraction)
(old current : Child → BinaryFraction × ℕ) (query : Parent)
(wide groups online : List (BinaryBellmanAction Parent Child M)) (R : ℕ)
(ho : ∀ s, (old s).2 ≤ R) (hn : ∀ s, (current s).2 ≤ R) :
(localContinuationReadWithWork distance L delta fallback old current query wide groups online).2 ≤
(localContinuationWithWork distance L delta fallback (fun s => (old s).1)
(fun s => (current s).1) query wide groups online).2 * tableReadFactor R := by
have hw := bellmanReadWithWork_factor distance L fallback old query wide R (fun _ _ _ => ho _)
have hwq := bellmanReadWithWork_eq distance L fallback old query wide
have hg := bellmanReadWithWork_factor distance L
(bellmanWithWork distance L fallback (fun s => (old s).1) query wide).1 current query groups R
(fun _ _ _ => hn _)
have hgq := bellmanReadWithWork_eq distance L
(bellmanWithWork distance L fallback (fun s => (old s).1) query wide).1 current query groups
have hs := arithmeticMapWithWork_factor
(bellmanActionReadWithWork distance L current query)
(bellmanActionWithWork distance L (fun s => (current s).1) query)
online (tableReadFactor R) (tableReadFactor_pos R)
(fun action _ => bellmanActionReadWithWork_eq distance L current query action)
(fun action _ => bellmanActionReadWithWork_factor distance L current query action R (fun _ => hn _))
have h := Nat.add_le_add (Nat.add_le_add hw hg) hs.2
simp only [← Nat.add_mul] at h
unfold localContinuationReadWithWork localContinuationWithWork
dsimp only
rw [hwq, hgq, hs.1]
apply cost_replace_factor _ _ _ _ _ h (tableReadFactor_pos R) <;> omega
theorem physicalContinuationReadWithWork_factor {nx n M : ℕ} (parent : TargetInterval nx)
(representatives : List (ℕ × TargetInterval n)) (P F : ℕ)
(delta fallback : BinaryFraction) (old current : Fin M × TargetInterval n → BinaryFraction × ℕ)
(groups online : List (BinaryBellmanAction (TargetInterval n) (Fin M × TargetInterval n) M))
(query : TargetInterval n) (R : ℕ) (ho : ∀ s, (old s).2 ≤ R) (hn : ∀ s, (current s).2 ≤ R) :
(physicalContinuationReadWithWork parent representatives P F delta fallback old current groups online query).2 ≤
(physicalContinuationWithWork parent representatives P F delta fallback
(fun s => (old s).1) (fun s => (current s).1) groups online query).2 * tableReadFactor R := by
have h := localContinuationReadWithWork_factor endpointDistanceWithWork
(canonicalMulWithWork (nat 128) (nat F)).1 delta fallback old current query
(wideActionsFromRepresentativesWithWork M parent representatives P).1 groups online R ho hn
unfold physicalContinuationReadWithWork physicalContinuationWithWork
dsimp only
apply cost_replace_factor _ _ _ _ _ h (tableReadFactor_pos R) <;> omega
end BinaryFraction
end EditApproximation
end OAI
|