| import OAI.Analysis.FourierLLogL.Edges.Wire |
| /-! # Cost of an observed boundary window -/ |
| open Function Set Filter |
| open scoped Topology BigOperators ComplexConjugate |
| noncomputable section |
| namespace OAI |
|
|
| namespace FourierLLogL.Dyadic.Procedure |
| open Law Node Real Period Compress.Params Thermal Fund Scene Fork Road Event Journal |
|
|
| namespace Wire |
| variable {M : ℕ} {s : Scene M} {t : Wire M s} |
| open scoped Classical |
|
|
| private lemma spotted_equal {s : Scene M} (h : ReadyAt s) (hm : 0 < s.mass) |
| (q : Grid M → Prop) (hq : spotted q s.here.lev) : |
| s.actor.prob q = (s.here.dice M).prob q := by |
| let c := s.here.start M |
| have hc : c∈s.here.block M := start_mem h.1.1 h.1.2 |
| have hh (P : Law (Grid M)) (hp : ∀ x, 0 < P x → x∈s.here.block M) : |
| P.prob q = if q c then 1 else 0 := by |
| unfold prob |
| conv_rhs => rw [← Ex_const P (if q c then 1 else 0)] |
| refine Ex_congr_mem _ fun x hx => ?_ |
| have H := hq _ rfl _ (hp x hx) _ hc |
| by_cases hv : q c <;> simp [hv,H] |
| exact (hh _ (piece_support h.1 (actor_def h.1 h.2 hm))).trans (hh _ |
| (fun x hx => (dice_positive h.1).mp hx)).symm |
|
|
| def coverL (n : ℕ) (l : List (Pulse M)) : ℝ := ((l.take n).map Pulse.realized).sum |
|
|
| def fairValue (q : Grid M → Prop) (n : ℕ) (l : List (Pulse M)) (x : Grid M) := |
| if q x then exp (-coverL n l) else 0 |
|
|
| private lemma present {s : Scene M} (t : Wire M s) {a : Bool} (h : t.Valid a) |
| (hm : 0 < s.mass) (n : ℕ) (hn : s.here.lev+n ≤ M) (q : Grid M → Prop) |
| (hq : spotted q (s.here.lev+n)) : |
| s.actor.Ex (fun x => fairValue q n (t.read x) x) ≤ (s.here.dice M).prob q := by |
| classical |
| induction t generalizing n a with |
| | term s => |
| obtain ⟨hh,he⟩ := h |
| have H : n = 0 := by omega |
| subst n |
| simp only [Nat.add_zero] at hq |
| rw [← spotted_equal hh hm _ hq] |
| unfold prob; simp only [fairValue,coverL,List.take_zero,List.map_nil,List.sum_nil, |
| neg_zero,exp_zero]; exact le_rfl |
| | stay s v k ih => |
| cases v <;> exact ih h.2 hm n hn hq |
| | spot s u k ih => |
| obtain ⟨ha,h2,hH,hk⟩ := h |
| have he := hH hm |
| rw [spotEx u k (fairValue q n) he] |
| rw [← Ex_const u.snip.probs ((s.here.dice M).prob q)] |
| apply Ex_mono_mem |
| intro b hb |
| have hx := ih b (hk b) ((true_mass he).mp hb) n |
| (by rw [h2 b]; exact hn) (by rw [h2 b]; exact hq) |
| rw [h2 b] at hx |
| exact hx |
| | link s g k ih => |
| obtain ⟨ha,hG,hV,hk⟩ := h |
| have he : (step s).TrueLaw := step_true ha.1.1 hG ha.2 hm |
| cases n with |
| | zero => |
| simp only [Nat.add_zero] at hq |
| rw [← spotted_equal ha hm _ hq] |
| unfold prob; simp only [fairValue,coverL,List.take_zero,List.map_nil,List.sum_nil, |
| neg_zero,exp_zero]; exact le_rfl |
| | succ n => |
| rw [linkEx g k (fairValue q (n+1)) he] |
| let P := (step s).probs |
| let V (b) := (s.smaller b).actor |
| let Z (b) := fun x => fairValue q (n+1) (⟨s,g,b⟩::(k b).read x) x |
| have HE (b : Bool) : |
| P b * (V b).Ex (Z b) ≤ (1/2)*(s.smaller b |>.here.dice M).prob q := by |
| rcases eq_or_lt_of_le (P.nonneg b) with hi|hi |
| · rw [← hi,zero_mul] |
| apply mul_nonneg (by norm_num) (prob_nonneg _ _) |
| have hP : (s.smaller b).here.lev+n=s.here.lev+(n+1) := by cases b <;> |
| simp [smaller,child,L,R,add_comm n,add_assoc] |
| have H := ih b (hk b) ((true_mass he).mp hi) n (by rw [hP]; exact hn) |
| (by rw [hP]; exact hq) |
| have hZ (x : Grid M) : Z b x = |
| (2*P b)⁻¹ * fairValue q n ((k b).read x) x := by |
| unfold Z fairValue; split_ifs |
| · unfold coverL; simp only [List.take_succ_cons,List.map_cons,List.sum_cons, Pulse.realized] |
| rw [show -(whistle _ _+_)= -whistle (step s) b + -coverL n ((k b).read x) by |
| unfold coverL; ring,exp_add,Real.exp_neg,whistle,exp_log (by change 0< 2* P b; positivity)] |
| rfl |
| · ring |
|
|
| rw [funext hZ,Ex_lmul, ← mul_assoc] |
| rw [show P b*(2*P b)⁻¹=1/2 by field_simp] |
| exact mul_le_mul_of_nonneg_left H (by norm_num) |
| change P.Ex (fun b => (V b).Ex (Z b)) ≤ _ |
| rw [Ex,Fintype.sum_bool] |
| apply (add_le_add (HE true) (HE false)).trans |
| unfold prob |
| rw [dice_child s.here ha.1.1 hG] |
| simp only [smaller,child] |
| linarith |
|
|
| def startMark (i : ℕ) (l : List (Pulse M)) : Prop := |
| reach i * log 2/2 ≤ coverL (reach i) l |
|
|
| private lemma distance_scale (i : ℕ) (main : Bool) : |
| exp ((reach i)*log 2/2)*(4*side (reach i)) ≤ gateWidth main i/4 := by |
| let n := 40+4*i |
| have hi : reach i = 2*n := by unfold reach n; omega |
| have hE : |
| exp (((reach i):ℝ)*log 2/2)*(4*side (reach i)) = 4 * side n := by |
| rw [hi,Nat.cast_mul,Nat.cast_ofNat,show 2*(n:ℝ)*log 2/2=log (2^n) by rw [log_pow]; ring, |
| exp_log (by positivity : 0 < (2:ℝ)^n)] |
| unfold side |
| rw [mul_comm 2 n,pow_mul,one_div,inv_pow] |
| field_simp |
| rw [hE] |
| have he : side n = side 40 * side i ^ 4 := by |
| unfold n side; rw [pow_add,mul_comm 4 i,pow_mul] |
| unfold gateWidth; rw [he] |
| have hQ : side i^4 ≤ side i^2 := |
| pow_le_pow_of_le_one (side_pos _).le (side_le _) (by omega) |
| have h₂ : side i^2 ≤ side i := by |
| simpa using pow_le_pow_of_le_one (side_pos i).le (side_le i) (by omega : 1 ≤ 2) |
| split <;> norm_num [side] at * <;> nlinarith |
|
|
| theorem mark_chance {s : Scene M} (t : Wire M s) {a : Bool} (h : t.Valid a) |
| (hm : 0 < s.mass) (ht : ¬ enter s) (main : Bool) (i : ℕ) (hh : hazard s main i) : |
| let P := s.actor |
| P.prob (flanked s.here i) ≤ 2*P.prob (fun x => startMark i (t.read x)) := by |
| obtain ⟨hx1,hx2⟩ := h.atSrc |
| obtain ⟨hi,hj,hc⟩ := hazard_rule hx1 hx2 hm ht hh |
| let q := flanked (M:=M) s.here i |
| let n := reach i; let r := n * log 2/2 |
| intro P |
| have HH := present t h hm n hi q (flanked_at _ _) |
| have H₁ := HH.trans (flank_prob _ hx1.1 i hi) |
| let f := fun x => fairValue q n (t.read x) x |
| let b := fun x => startMark i (t.read x) |
| let F (x) := if b x then (1:ℝ) else 0 |
| have H : |
| P.prob q ≤ P.prob b + exp r*P.Ex f := by |
| unfold prob |
| rw [← Ex_lmul, ← Ex_add] |
| refine Ex_mono _ fun x => ?_ |
| unfold f fairValue |
| by_cases h1 : q x |
| · simp only [h1,ite_true] |
| split_ifs with H |
| · have H : 0 ≤ exp r * exp (-coverL n (t.read x)) := by positivity |
| linarith |
| rw [zero_add,← exp_add]; apply Real.one_le_exp |
| change ¬ r ≤ coverL n (t.read x) at H; linarith |
| simp only [h1,ite_false]; split_ifs <;> norm_num |
| have hT : exp r * P.Ex f ≤ gateWidth main i /4 := |
| (mul_le_mul_of_nonneg_left H₁ (exp_nonneg _)).trans (distance_scale i main) |
| change gateWidth main i/2 ≤ P.prob q at hc |
| change P.prob q ≤ 2*P.prob b |
| linarith |
|
|
| end Wire |
| end FourierLLogL.Dyadic.Procedure |
|
|
| end OAI |
|
|
