| import Mathlib |
| import OAI.Probability.Ballisticity.Estimates.AdaptiveFailureWeights |
| import OAI.Probability.Ballisticity.Estimates.BufferChildNode |
|
|
| namespace OAI |
|
|
| section |
|
|
| section |
|
|
| open MeasureTheory ProbabilityTheory Filter Function |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| namespace DirectionalTransience |
|
|
| noncomputable def bufferNodeAt {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1) |
| (R₀ z₀ ε α g : ℝ) (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r) |
| (root : AdaptedBufferNode e) : List (ℕ × Bool) → AdaptedBufferNode e |
| | [] => root |
| | p::l => let N := bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root l |
| bufferChildNode e f hef R₀ z₀ ε α g κ N (H N.radius) (hH N.radius) p.1 p.2 |
|
|
| lemma bufferNodeAt_radius {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1) |
| (R₀ z₀ ε α g : ℝ) (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r) |
| (root : AdaptedBufferNode e) (hr : R₀ ≤ root.radius) (l : List (ℕ × Bool)) : |
| R₀ ≤ (bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root l).radius := by |
| cases l with |
| | nil => exact hr |
| | cons p l => exact le_max_left _ _ |
|
|
| lemma bufferNodeAt_valid {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1) |
| {R₀ : ℝ} (hR₀ : 0 ≤ R₀) (z₀ ε α g : ℝ) {κ : ℝ≥0} |
| (hκpos : 0 < κ) (hκ1 : κ ≤ 1) (hg : 0 < g) (hg1 : g ≤ 1) (hε : 0 ≤ ε) |
| (H : ℝ → ℕ) (hH : ∀ r, 0 < H r) (root : AdaptedBufferNode e) |
| (hr : R₀ ≤ root.radius) (hroot : BufferNodeValid e f z₀ κ root) (l : List (ℕ × Bool)) : |
| BufferNodeValid e f z₀ κ (bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root l) := by |
| induction l with |
| | nil => exact hroot |
| | cons p l ih => |
| exact bufferChildNode_valid e f hef R₀ z₀ ε α g hκpos hκ1 hg hg1 hε _ |
| (hR₀.trans (bufferNodeAt_radius e f hef R₀ z₀ ε α g κ H hH root hr l)) ih _ (hH _) p.1 p.2 |
|
|
| noncomputable def bufferNodeDecision {d : ℕ} (e f : Direction d) |
| (z₀ ε α g : ℝ) (H : ℝ → ℕ) (N : AdaptedBufferNode e) (ω : Environment d) : ℕ × Bool := |
| (bufferFirstFailure (realPosition (step e)) f N.level (z₀+(1-ε)*N.radius) g N.law (H N.radius) ω, |
| decide (BufferStageEvent (realPosition (step e)) f (H N.radius) z₀ N.radius ε α g (N.law ω).val ω)) |
|
|
| lemma mem_bufferChildNode_iff {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1) |
| (R₀ z₀ ε α g : ℝ) (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r) |
| (N : AdaptedBufferNode e) (p : ℕ × Bool) (ω : Environment d) : |
| ω ∈ (bufferChildNode e f hef R₀ z₀ ε α g κ N (H N.radius) (hH N.radius) p.1 p.2).active ↔ |
| ω ∈ N.active ∧ bufferNodeDecision e f z₀ ε α g H N ω=p := by |
| change (_ ∧ _ ∧ (_ ↔ p.2=true)) ↔ (_ ∧ (_,decide _)=p) |
| rw [Prod.ext_iff] |
| suffices (BufferStageEvent (realPosition (step e)) f (H N.radius) z₀ N.radius ε α g (N.law ω).val ω ↔ p.2=true) ↔ |
| decide (BufferStageEvent (realPosition (step e)) f (H N.radius) z₀ N.radius ε α g (N.law ω).val ω)=p.2 by tauto |
| cases p.2 <;> simp |
|
|
| noncomputable def bufferHistory {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1) |
| (R₀ z₀ ε α g : ℝ) (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r) |
| (root : AdaptedBufferNode e) (ω : Environment d) : ℕ → List (ℕ × Bool) |
| | 0 => [] |
| | n+1 => let l := bufferHistory e f hef R₀ z₀ ε α g κ H hH root ω n |
| bufferNodeDecision e f z₀ ε α g H (bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root l) ω :: l |
|
|
| lemma bufferHistory_length {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1) |
| (R₀ z₀ ε α g : ℝ) (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r) |
| (root : AdaptedBufferNode e) (ω : Environment d) (n : ℕ) : |
| (bufferHistory e f hef R₀ z₀ ε α g κ H hH root ω n).length=n := by |
| induction n with |
| | zero => rfl |
| | succ n ih => simp only [bufferHistory,List.length_cons,ih] |
|
|
| lemma bufferNodeAt_active_iff_history {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1) |
| (R₀ z₀ ε α g : ℝ) (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r) |
| (root : AdaptedBufferNode e) (ω : Environment d) (l : List (ℕ × Bool)) : |
| ω ∈ (bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root l).active ↔ |
| ω ∈ root.active ∧ bufferHistory e f hef R₀ z₀ ε α g κ H hH root ω l.length=l := by |
| induction l with |
| | nil => simp only [bufferNodeAt,bufferHistory,List.length_nil,and_true] |
| | cons p l ih => |
| rw [bufferNodeAt,mem_bufferChildNode_iff e f hef R₀ z₀ ε α g κ H hH |
| (bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root l) p ω,ih] |
| simp only [List.length_cons,bufferHistory,List.cons.injEq] |
| constructor |
| · rintro ⟨⟨hr,hl⟩,hp⟩ |
| exact ⟨hr,by simpa only [hl] using hp,hl⟩ |
| · rintro ⟨hr,hp,hl⟩ |
| exact ⟨⟨hr,hl⟩,by simpa only [hl] using hp⟩ |
| end DirectionalTransience |
|
|
| end |
|
|
| section |
|
|
| open MeasureTheory ProbabilityTheory Filter Function |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| namespace DirectionalTransience |
|
|
| abbrev BufferWords (n : ℕ) := {l : List (ℕ × Bool) // l.length=n} |
|
|
| noncomputable def bufferTreeSuccess {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1) |
| (R₀ z₀ ε α g : ℝ) (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r) |
| (root : AdaptedBufferNode e) (n : ℕ) : Set (Environment d) := |
| ⋃ l : BufferWords n, {ω | ω ∈ (bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root l.val).active ∧ |
| (bufferNodeDecision e f z₀ ε α g H (bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root l.val) ω).2=true} |
|
|
| lemma bufferTreeSuccess_measurable {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1) |
| (R₀ z₀ ε α g : ℝ) (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r) |
| (root : AdaptedBufferNode e) (n : ℕ) : |
| MeasurableSet (bufferTreeSuccess e f hef R₀ z₀ ε α g κ H hH root n) := by |
| apply MeasurableSet.iUnion |
| intro l |
| let N := bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root l.val |
| have ha : MeasurableSet N.active := rowSigma_le _ _ N.active_rows |
| have hp : Measurable N.law := N.law_rows.mono (rowSigma_le _) le_rfl |
| have he := (measurableSet_bufferStageEvent_rows (realPosition (step e)) f (hH N.radius) |
| z₀ N.radius ε α g (PairAtHeight (realPosition (step e)) N.level) Set.univ |
| (fun x hx => ⟨Set.subset_univ _,Set.subset_univ _⟩)).preimage |
| (hp.prodMk (measurable_id.mono le_rfl (rowSigma_le Set.univ))) |
| convert ha.inter he using 1 |
| ext ω |
| simp only [bufferNodeDecision,decide_eq_true_eq,Set.mem_inter_iff,Set.mem_preimage,Set.mem_ofPred_eq,id_eq] |
| rfl |
|
|
| lemma bufferWords_partition {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1) |
| (R₀ z₀ ε α g : ℝ) (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r) |
| (root : AdaptedBufferNode e) (n : ℕ) : |
| (⋃ l : BufferWords n, (bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root l.val).active) = root.active ∧ |
| Pairwise (Disjoint on fun l : BufferWords n => |
| (bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root l.val).active) := by |
| constructor |
| · ext ω |
| constructor |
| · intro h |
| obtain ⟨l,hl⟩ := Set.mem_iUnion.mp h |
| exact (bufferNodeAt_active_iff_history e f hef R₀ z₀ ε α g κ H hH root ω l.val).mp hl |>.1 |
| · intro hr |
| let l : BufferWords n := ⟨bufferHistory e f hef R₀ z₀ ε α g κ H hH root ω n, |
| bufferHistory_length e f hef R₀ z₀ ε α g κ H hH root ω n⟩ |
| apply Set.mem_iUnion.mpr |
| refine ⟨l,(bufferNodeAt_active_iff_history e f hef R₀ z₀ ε α g κ H hH root ω l.val).mpr ?_⟩ |
| exact ⟨hr,by rw [l.property]⟩ |
| · intro l m hlm |
| apply Set.disjoint_left.mpr |
| intro ω hl hm |
| apply hlm |
| apply Subtype.ext |
| have hl' := (bufferNodeAt_active_iff_history e f hef R₀ z₀ ε α g κ H hH root ω l.val).mp hl |>.2 |
| have hm' := (bufferNodeAt_active_iff_history e f hef R₀ z₀ ε α g κ H hH root ω m.val).mp hm |>.2 |
| rw [l.property] at hl' |
| rw [m.property] at hm' |
| exact hl'.symm.trans hm' |
|
|
| lemma bufferTreeSuccess_iff_decision {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1) |
| (R₀ z₀ ε α g : ℝ) (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r) |
| (root : AdaptedBufferNode e) (ω : Environment d) (hr : ω ∈ root.active) (n : ℕ) : |
| ω ∈ bufferTreeSuccess e f hef R₀ z₀ ε α g κ H hH root n ↔ |
| (bufferNodeDecision e f z₀ ε α g H (bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root |
| (bufferHistory e f hef R₀ z₀ ε α g κ H hH root ω n)) ω).2=true := by |
| constructor |
| · intro h |
| obtain ⟨l,hl,hb⟩ := Set.mem_iUnion.mp h |
| have hh := (bufferNodeAt_active_iff_history e f hef R₀ z₀ ε α g κ H hH root ω l.val).mp hl |>.2 |
| rw [l.property] at hh |
| simpa only [hh] using hb |
| · intro hb |
| let l : BufferWords n := ⟨bufferHistory e f hef R₀ z₀ ε α g κ H hH root ω n, |
| bufferHistory_length e f hef R₀ z₀ ε α g κ H hH root ω n⟩ |
| apply Set.mem_iUnion.mpr |
| refine ⟨l,?_,hb⟩ |
| apply (bufferNodeAt_active_iff_history e f hef R₀ z₀ ε α g κ H hH root ω l.val).mpr |
| exact ⟨hr,by rw [l.property]⟩ |
|
|
| noncomputable def bufferWordSuccesses : List (ℕ × Bool) → ℝ |
| | [] => 0 |
| | p::l => (if p.2 then 1 else 0)+bufferWordSuccesses l |
|
|
| lemma bufferWordSuccesses_history {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1) |
| (R₀ z₀ ε α g : ℝ) (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r) |
| (root : AdaptedBufferNode e) (ω : Environment d) (hr : ω ∈ root.active) (n : ℕ) : |
| bufferWordSuccesses (bufferHistory e f hef R₀ z₀ ε α g κ H hH root ω n) = |
| successes (bufferTreeSuccess e f hef R₀ z₀ ε α g κ H hH root) n ω := by |
| induction n with |
| | zero => simp [bufferHistory,bufferWordSuccesses,successes] |
| | succ n ih => |
| rw [bufferHistory,bufferWordSuccesses,ih,successes_succ] |
| have hb := bufferTreeSuccess_iff_decision e f hef R₀ z₀ ε α g κ H hH root ω hr n |
| simp only [←hb] |
| ring |
|
|
| lemma buffer_failureWeight_on_branch {d : ℕ} (e f : Direction d) (hef : e.1 ≠ f.1) |
| (R₀ z₀ ε α g : ℝ) (κ : ℝ≥0) (H : ℝ → ℕ) (hH : ∀ r, 0 < H r) |
| (root : AdaptedBufferNode e) (s : ℝ) (n : ℕ) (l : BufferWords n) : |
| @Measurable _ _ (rowSigma (BelowHeight (realPosition (step e)) |
| (bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root l.val).level)) _ |
| ((bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root l.val).active.indicator |
| (fun ω => ENNReal.ofReal (failureWeight (bufferTreeSuccess e f hef R₀ z₀ ε α g κ H hH root) s n ω))) := by |
| let N := bufferNodeAt e f hef R₀ z₀ ε α g κ H hH root l.val |
| have he : N.active.indicator (fun ω => ENNReal.ofReal (failureWeight |
| (bufferTreeSuccess e f hef R₀ z₀ ε α g κ H hH root) s n ω)) = |
| N.active.indicator (fun _ => ENNReal.ofReal (Real.exp (s/4*(n:ℝ)-bufferWordSuccesses l.val))) := by |
| apply Set.indicator_congr |
| intro ω hω |
| have hh := (bufferNodeAt_active_iff_history e f hef R₀ z₀ ε α g κ H hH root ω l.val).mp hω |
| have hc := bufferWordSuccesses_history e f hef R₀ z₀ ε α g κ H hH root ω hh.1 n |
| rw [l.property] at hh |
| rw [hh.2] at hc |
| simp only [failureWeight,←hc] |
| change @Measurable _ _ (rowSigma (BelowHeight (realPosition (step e)) N.level)) _ _ |
| rw [he] |
| exact measurable_const.indicator N.active_rows |
| end DirectionalTransience |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
