| 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))) |
|
|
| / |
| 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 |
|
|
