File size: 6,607 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 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 | import OAI.Combinatorics.EditApproximation.Refinement.PhysicalRationalWarmup
import OAI.Combinatorics.EditApproximation.Geometry.LocalInitialCones
import OAI.Combinatorics.EditApproximation.Definitions
namespace OAI
/-! One literal refinement update with finite selected-group cones and online action values. -/
namespace EditApproximation
open Finset
theorem rationalMinimum_map_mono {ι : Type*} (indices : List ι)
(fallback fallback' : ℚ) (value value' : ι → ℚ)
(hfallback : fallback ≤ fallback') (hvalue : ∀ i ∈ indices, value i ≤ value' i) :
rationalMinimum fallback (indices.map value) ≤ rationalMinimum fallback' (indices.map value') := by
induction indices with
| nil => exact hfallback
| cons i rest ih =>
exact min_le_min (hvalue i (by simp)) (ih fun j hj => hvalue j (by simp [hj]))
theorem rationalBellman_mono {Parent Child : Type*} {M : ℕ}
(fallback : Parent → ℚ) (distance : Parent → Parent → ℚ) (L : ℚ)
(actions : List (RationalBellmanAction Parent Child M)) {child child' : Child → ℚ}
(hchild : child ≤ child') (q : Parent) :
rationalBellman fallback distance L actions child q ≤ rationalBellman fallback distance L actions child' q := by
apply rationalMinimum_map_mono _ _ _ _ _ le_rfl
intro action _
exact add_le_add le_rfl (sum_le_sum fun i _ => hchild (action.childState i))
theorem rationalBellman_le_action {Parent Child : Type*} {M : ℕ}
(fallback : Parent → ℚ) (distance : Parent → Parent → ℚ) (L : ℚ)
(actions : List (RationalBellmanAction Parent Child M)) (child : Child → ℚ)
(q : Parent) (action : RationalBellmanAction Parent Child M) (haction : action ∈ actions) :
rationalBellman fallback distance L actions child q ≤ rationalActionValue distance L child q action :=
rationalMinimum_le_member _ _ (List.mem_map.mpr ⟨action, haction, rfl⟩)
theorem rationalOnlineMinimum_lower (lower : ℚ) (values : List ℚ)
(hvalues : ∀ v ∈ values, lower ≤ v) {online : ℚ}
(honline : rationalOnlineMinimum values = some online) : lower ≤ online := by
cases values with
| nil => cases honline
| cons first rest =>
have heq : rationalMinimum first rest = online := Option.some.inj honline
rw [← heq]
exact (le_rationalMinimum_iff _ _ _).2
⟨hvalues first (by simp), fun v hv => hvalues v (by simp [hv])⟩
def rationalWideStepCone {nx ny M : ℕ} (parent : TargetInterval nx)
(representatives : List (ℕ × TargetInterval ny)) (P : ℕ)
(initial : TargetInterval ny → ℚ) (L : ℚ)
(old current : Fin M × TargetInterval ny → ℚ)
(groups : List (RationalBellmanAction (TargetInterval ny) (Fin M × TargetInterval ny) M))
(q : TargetInterval ny) : ℚ :=
rationalMinimum (rationalBellman initial (fun q r => targetEndpointDistance q r) L
(rationalActualWideActions parent representatives P) old q)
(groups.map (rationalActionValue (fun q r => targetEndpointDistance q r) L current q))
def rationalWideStep {nx ny M : ℕ} (parent : TargetInterval nx)
(representatives : List (ℕ × TargetInterval ny)) (P : ℕ)
(initial : TargetInterval ny → ℚ) (L delta : ℚ)
(old current : Fin M × TargetInterval ny → ℚ)
(groups online : List (RationalBellmanAction (TargetInterval ny) (Fin M × TargetInterval ny) M))
(q : TargetInterval ny) : ℚ :=
rationalRefinementUpdate delta (rationalWideStepCone parent representatives P initial L old current groups q)
(rationalOnlineMinimum (online.map (rationalActionValue (fun q r => targetEndpointDistance q r) L current q)))
/-- Both lower candidates are genuine current-child wide Bellman cones.
The sampled choices enter only through literal membership in the wide list. -/
theorem rationalWideStep_bellman_sandwich {nx ny M : ℕ} (parent : TargetInterval nx)
(representatives : List (ℕ × TargetInterval ny)) (P : ℕ)
(initial : TargetInterval ny → ℚ) (L delta : ℚ)
(old current : Fin M × TargetInterval ny → ℚ) (hmono : current ≤ old)
(groups online : List (RationalBellmanAction (TargetInterval ny) (Fin M × TargetInterval ny) M))
(hgroups : ∀ action ∈ groups, action ∈ rationalActualWideActions parent representatives P)
(honline : ∀ action ∈ online, action ∈ rationalActualWideActions parent representatives P)
(q : TargetInterval ny) :
rationalBellman initial (fun q r => targetEndpointDistance q r) L
(rationalActualWideActions parent representatives P) current q ≤
rationalWideStep parent representatives P initial L delta old current groups online q ∧
rationalWideStep parent representatives P initial L delta old current groups online q ≤
rationalBellman initial (fun q r => targetEndpointDistance q r) L
(rationalActualWideActions parent representatives P) old q := by
let actions := rationalActualWideActions (M := M) parent representatives P
let distance := fun q r : TargetInterval ny => (targetEndpointDistance q r : ℚ)
let lower := rationalBellman initial distance L actions current q
let upper := rationalBellman initial distance L actions old q
let cone := rationalWideStepCone parent representatives P initial L old current groups q
have hcone : lower ≤ cone := by
apply (le_rationalMinimum_iff _ _ _).2
refine ⟨rationalBellman_mono initial distance L actions hmono q, ?_⟩
intro value hvalue
obtain ⟨action, ha, rfl⟩ := List.mem_map.mp hvalue
exact rationalBellman_le_action initial distance L actions current q action (hgroups action ha)
have hupper : cone ≤ upper := rationalMinimum_le_fallback _ _
have honlineLower : ∀ value ∈ online.map (rationalActionValue distance L current q), lower ≤ value := by
intro value hvalue
obtain ⟨action, ha, rfl⟩ := List.mem_map.mp hvalue
exact rationalBellman_le_action initial distance L actions current q action (honline action ha)
change lower ≤ rationalRefinementUpdate delta cone
(rationalOnlineMinimum (online.map (rationalActionValue distance L current q))) ∧
rationalRefinementUpdate delta cone
(rationalOnlineMinimum (online.map (rationalActionValue distance L current q))) ≤ upper
cases hmin : rationalOnlineMinimum (online.map (rationalActionValue distance L current q)) with
| none => exact ⟨hcone, hupper⟩
| some value =>
have hlower := rationalOnlineMinimum_lower lower _ honlineLower hmin
exact ⟨le_min hcone (hlower.trans (le_max_right _ _)), (min_le_left _ _).trans hupper⟩
end EditApproximation
end OAI
|