| import Mathlib |
| import OAI.Probability.CriticalPercolation.Exploration.CompileEmptyReads |
|
|
| namespace OAI |
|
|
| section |
| section |
| open Set MeasureTheory ProbabilityTheory |
| open Set |
| open scoped BigOperators |
| open scoped Classical |
|
|
| namespace CriticalPercolation.LazyDFS |
| open scoped Classical |
| open FiniteProduct SearchTree BondGraph |
|
|
| variable {V E : Type*} [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E] |
|
|
| omit [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E] in |
| lemma exhaustive_mapTarget (G : BondGraph V E) (B : Set V) (order : List (Dart V E)) |
| (ho : Exhaustive G order) : Exhaustive (G.wireTargets B) (order.map (mapDart B)) := by |
| intro v e t he |
| obtain ⟨a,b,hab⟩ : ∃ a b, G.ends e = s(a,b) := Sym2.exists.mp ⟨G.ends e,rfl⟩ |
| change Sym2.map (collapseTarget B) (G.ends e) = s(v,t) at he |
| rw [hab,Sym2.map_mk] at he |
| rcases Sym2.eq_iff.mp he with ⟨ha,hb⟩ | ⟨ha,hb⟩ |
| · exact List.mem_map.mpr ⟨(a,e,b),ho a e b hab,by simp only [mapDart,ha,hb]⟩ |
| · exact List.mem_map.mpr ⟨(b,e,a),ho b e a (hab.trans Sym2.eq_swap), |
| by simp only [mapDart,ha,hb]⟩ |
|
|
| omit [Fintype V] [Fintype E] [DecidableEq E] in |
| lemma mapState_initial (B : Set V) (a : V) : |
| mapState (E := E) B (initial a) = initial (collapseTarget B a) := by |
| simp [mapState,initial] |
|
|
| omit [Fintype E] in |
|
|
| theorem search_reads_targetWiring (G : BondGraph V E) (B : Set V) |
| (order : List (Dart V E)) (horder : GoodDarts G order) (a : V) (ω : E → Bool) : |
| (search G order a B).reads ω = |
| (search (G.wireTargets B) (order.map (mapDart B)) (collapseTarget B a) {none}).reads ω := by |
| by_cases ha : a ∈ B |
| · have hs := compile_stop G order B (rank order (initial a) (push G order a)) |
| (initial a) (push G order a) ⟨a,Finset.mem_singleton_self _,ha⟩ |
| have hn := (collapseTarget_eq_none B a).mpr ha |
| have hs' := compile_stop (G.wireTargets B) (order.map (mapDart B)) {none} |
| (rank (order.map (mapDart B)) (initial (collapseTarget B a)) |
| (push (G.wireTargets B) (order.map (mapDart B)) (collapseTarget B a))) |
| (initial (collapseTarget B a)) |
| (push (G.wireTargets B) (order.map (mapDart B)) (collapseTarget B a)) |
| ⟨collapseTarget B a,Finset.mem_singleton_self _,by simp only [Set.mem_singleton_iff,hn]⟩ |
| unfold search |
| rw [hs,hs']; rfl |
| · let r := rank order (initial (E := E) a) (push G order a) |
| let r' := rank (order.map (mapDart B)) (initial (E := E) (collapseTarget B a)) |
| (push (G.wireTargets B) (order.map (mapDart B)) (collapseTarget B a)) |
| have h := compile_reads_targetWiring G B order horder (max r r') |
| (initial a) (push G order a) (push_goodDarts G order a) ω |
| rw [mapState_initial,push_mapTarget G B order horder a ha] at h |
| have h1 := compile_reads_rank_independent G order B r (max r r') |
| (initial a) (push G order a) ω le_rfl (le_max_left ..) |
| have h2 := compile_reads_rank_independent (G.wireTargets B) (order.map (mapDart B)) {none} |
| r' (max r r') (initial (collapseTarget B a)) |
| (push (G.wireTargets B) (order.map (mapDart B)) (collapseTarget B a)) ω |
| le_rfl (le_max_right ..) |
| exact h1.trans (h.trans h2.symm) |
| |
| theorem search_target_pivotal_moments (G : BondGraph V E) (B : Set V) |
| (order : List (Dart V E)) (horder : GoodDarts G order) (ho : Exhaustive G order) |
| (a : V) {p : ℝ} (hp : p ∈ Set.Ioo 0 1) (w : E → Prop → ℝ) |
| (h0 : ∀ e, w e False = 1-p) (h1 : ∀ e, w e True = p) : |
| let F := fun ω : Set E => ∃ b ∈ B, (G.openGraph ω).Reachable a b |
| expect w ((search G order a B).score p F w) ≤ 1 ∧ |
| expect w (fun ω => ((search G order a B).score p F w ω)^2) ≤ 3 := by |
| let F := fun ω : Set E => ∃ b ∈ B, (G.openGraph ω).Reachable a b |
| have h := targetSearch_moments G B (order.map (mapDart B)) |
| (exhaustive_mapTarget G B order ho) a hp w h0 h1 |
| have heq : (search G order a B).score p F w = |
| (targetSearch G B (order.map (mapDart B)) a).score p F w := by |
| funext ω |
| rw [score_eq_listScore,score_eq_listScore] |
| unfold targetSearch |
| rw [search_reads_targetWiring G B order horder] |
| change expect w ((search G order a B).score p F w) ≤ 1 ∧ _ |
| rw [heq] |
| exact h |
| |
| end CriticalPercolation.LazyDFS |
| |
| namespace CriticalPercolation.SearchTree |
| open scoped Classical |
| open FiniteProduct LazyDFS |
| |
| variable {E R : Type*} [Fintype E] [DecidableEq E] |
| |
| def ClosedFresh (r : E → Prop → ℝ) (p : ℝ) (C : Set E) (used : Finset E) : Prop := |
| ∀ e ∉ used, r e False = (if e ∈ C then 1 else 1-p) ∧ |
| r e True = (if e ∈ C then 0 else p) |
| |
| omit [Fintype E] in |
| lemma closedFresh_pin (r : E → Prop → ℝ) (p : ℝ) (C : Set E) (used : Finset E) |
| (hf : ClosedFresh r p C used) (e : E) (b : Prop) : |
| ClosedFresh (pin r e b) p C (insert e used) := by |
| intro j hj |
| have hj' : j ≠ e ∧ j ∉ used := by simpa only [Finset.mem_insert,not_or] using hj |
| unfold pin |
| simp only [Function.update,dite_eq_right hj'.1] |
| exact hf j hj'.2 |
|
|
| noncomputable def contactScore (T : SearchTree E R) (p : ℝ) (C : Set E) |
| (F : Set E → Prop) (w : E → Prop → ℝ) (ω : E → Prop) : ℝ := |
| match T with |
| | .done _ => 0 |
| | .ask e l r => (if e ∈ C then p*delta w F e else 0) + |
| if ω e then r.contactScore p C F (pin w e True) ω |
| else l.contactScore p C F (pin w e False) ω |
|
|
| noncomputable def terminalProbability (T : SearchTree E R) (F : Set E → Prop) |
| (w : E → Prop → ℝ) (ω : E → Prop) : ℝ := |
| match T with |
| | .done _ => prob w F |
| | .ask e l r => if ω e then r.terminalProbability F (pin w e True) ω |
| else l.terminalProbability F (pin w e False) ω |
|
|
| omit [DecidableEq E] in |
| lemma contact_mean_step (e : E) (l r : SearchTree E R) (p : ℝ) (C : Set E) |
| (F : Set E → Prop) (w v : E → Prop → ℝ) (hv : ∀ e, ∑ b, v e b = 1) : |
| expect v ((.ask e l r : SearchTree E R).contactScore p C F w) = |
| (if e ∈ C then p*delta w F e else 0) + |
| v e True*expect (pin v e True) (r.contactScore p C F (pin w e True)) + |
| v e False*expect (pin v e False) (l.contactScore p C F (pin w e False)) := by |
| change expect v (fun ω => (if e ∈ C then p*delta w F e else 0) + |
| if ω e then r.contactScore p C F (pin w e True) ω |
| else l.contactScore p C F (pin w e False) ω) = _ |
| rw [expect_add,expect_const v hv] |
| erw [expect_prop_ite] |
| ring |
|
|
| omit [DecidableEq E] in |
| lemma terminal_mean_step (e : E) (l r : SearchTree E R) (F : Set E → Prop) |
| (w v : E → Prop → ℝ) : |
| expect v ((.ask e l r : SearchTree E R).terminalProbability F w) = |
| v e True*expect (pin v e True) (r.terminalProbability F (pin w e True)) + |
| v e False*expect (pin v e False) (l.terminalProbability F (pin w e False)) := by |
| exact expect_prop_ite v e _ _ |
|
|
| theorem contact_mean_terminal (T : SearchTree E R) (used : Finset E) (hT : T.Valid used) |
| (p : ℝ) (C : Set E) (F : Set E → Prop) (w v : E → Prop → ℝ) |
| (hw : ∀ e, ∑ b, w e b = 1) (hv : ∀ e, ∑ b, v e b = 1) |
| (hf : Fresh w p used) (hc : ClosedFresh v p C used) : |
| expect v (T.contactScore p C F w) + expect v (T.terminalProbability F w) = prob w F := by |
| induction T generalizing used w v with |
| | done r => |
| change expect v (fun _ => 0) + expect v (fun _ => prob w F) = prob w F |
| rw [expect_zero,expect_const v hv,zero_add] |
| | ask e l r hl hr => |
| have he : w e False = 1-p ∧ w e True = p := hf e hT.1 |
| have hv' := hc e hT.1 |
| have hl' := hl (insert e used) hT.2.1 (pin w e False) (pin v e False) |
| (pin_normalized w hw e False) (pin_normalized v hv e False) |
| (fresh_pin w p used hf e False) (closedFresh_pin v p C used hc e False) |
| have hr' := hr (insert e used) hT.2.2 (pin w e True) (pin v e True) |
| (pin_normalized w hw e True) (pin_normalized v hv e True) |
| (fresh_pin w p used hf e True) (closedFresh_pin v p C used hc e True) |
| have hs : prob w F = w e False*prob (pin w e False) F + |
| w e True*prob (pin w e True) F := expect_split_pin w e _ |
| rw [contact_mean_step e l r p C F w v hv,terminal_mean_step,hv'.1,hv'.2] |
| rw [he.1,he.2] at hs |
| by_cases heC : e ∈ C <;> simp only [heC,↓reduceIte,zero_mul,one_mul,add_zero,zero_add] |
| · unfold delta |
| linear_combination hl' - hs |
| · linear_combination (1-p)*hl' + p*hr' - hs |
|
|
| omit [DecidableEq E] in |
| lemma terminalProbability_nonneg (T : SearchTree E R) (F : Set E → Prop) |
| (w : E → Prop → ℝ) (hn : ∀ e b, 0 ≤ w e b) (ω : E → Prop) : |
| 0 ≤ T.terminalProbability F w ω := by |
| induction T generalizing w with |
| | done r => exact prob_nonneg w hn F |
| | ask e l r hl hr => |
| unfold terminalProbability |
| split_ifs |
| · exact hr (pin w e True) (pin_nonneg w hn e True) |
| · exact hl (pin w e False) (pin_nonneg w hn e False) |
|
|
| theorem contact_mean_le_prob (T : SearchTree E R) (used : Finset E) (hT : T.Valid used) |
| (p : ℝ) (C : Set E) (F : Set E → Prop) (w v : E → Prop → ℝ) |
| (hw : ∀ e, ∑ b, w e b = 1) (hv : ∀ e, ∑ b, v e b = 1) |
| (hnw : ∀ e b, 0 ≤ w e b) (hnv : ∀ e b, 0 ≤ v e b) |
| (hf : Fresh w p used) (hc : ClosedFresh v p C used) : |
| expect v (T.contactScore p C F w) ≤ prob w F := by |
| have ht := contact_mean_terminal T used hT p C F w v hw hv hf hc |
| have hn := expect_nonneg hnv (terminalProbability_nonneg T F w hnw) |
| linarith |
|
|
| omit [DecidableEq E] in |
| lemma expect_square_add_const (v : E → Prop → ℝ) (hv : ∀ e, ∑ b, v e b = 1) |
| (a : ℝ) (f : (E → Prop) → ℝ) : |
| expect v (fun ω => (a+f ω)^2) = a^2+2*a*expect v f+expect v (fun ω => (f ω)^2) := by |
| have heq : (fun ω => (a+f ω)^2) = (fun ω => a^2+2*a*f ω+(f ω)^2) := by |
| funext ω; ring |
| rw [heq,expect_add,expect_add,expect_const v hv,expect_const_mul] |
|
|
| theorem contact_second_le_three_mean (T : SearchTree E R) (used : Finset E) (hT : T.Valid used) |
| {p : ℝ} (hp : p ∈ Set.Ioo 0 1) (C : Set E) (F : Set E → Prop) |
| (hF : ∀ s t, s ⊆ t → F s → F t) (w v : E → Prop → ℝ) |
| (hw : ∀ e, ∑ b, w e b = 1) (hv : ∀ e, ∑ b, v e b = 1) |
| (hnw : ∀ e b, 0 ≤ w e b) (hnv : ∀ e b, 0 ≤ v e b) |
| (hf : Fresh w p used) (hc : ClosedFresh v p C used) : |
| expect v (fun ω => (T.contactScore p C F w ω)^2) ≤ |
| 3*expect v (T.contactScore p C F w) := by |
| induction T generalizing used w v with |
| | done r => |
| change expect v (fun _ => (0:ℝ)^2) ≤ 3*expect v (fun _ => 0) |
| rw [expect_const v hv,expect_zero] |
| norm_num |
| | ask e l r hl hr => |
| have he := hf e hT.1 |
| have hv' := hc e hT.1 |
| have hl' := hl (insert e used) hT.2.1 (pin w e False) (pin v e False) |
| (pin_normalized w hw e False) (pin_normalized v hv e False) |
| (pin_nonneg w hnw e False) (pin_nonneg v hnv e False) |
| (fresh_pin w p used hf e False) (closedFresh_pin v p C used hc e False) |
| have hr' := hr (insert e used) hT.2.2 (pin w e True) (pin v e True) |
| (pin_normalized w hw e True) (pin_normalized v hv e True) |
| (pin_nonneg w hnw e True) (pin_nonneg v hnv e True) |
| (fresh_pin w p used hf e True) (closedFresh_pin v p C used hc e True) |
| let a := if e ∈ C then p*delta w F e else 0 |
| have hsq : (fun ω => ((.ask e l r : SearchTree E R).contactScore p C F w ω)^2) = |
| (fun ω => if ω e then (a+r.contactScore p C F (pin w e True) ω)^2 |
| else (a+l.contactScore p C F (pin w e False) ω)^2) := by |
| funext ω |
| change ((if e ∈ C then p*delta w F e else 0) + |
| if ω e then r.contactScore p C F (pin w e True) ω |
| else l.contactScore p C F (pin w e False) ω)^2 = _ |
| by_cases hω : ω e <;> simp only [hω,↓reduceIte,a] |
| rw [hsq] |
| erw [expect_prop_ite] |
| rw [contact_mean_step e l r p C F w v hv,hv'.1,hv'.2] |
| by_cases heC : e ∈ C |
| · simp only [heC,↓reduceIte,zero_mul,one_mul,add_zero,zero_add] |
| have haeq : a = p*delta w F e := ite_eq_left heC |
| rw [← haeq] |
| change expect (pin v e False) (fun ω => (a+l.contactScore p C F (pin w e False) ω)^2) ≤ |
| 3*(a+expect (pin v e False) (l.contactScore p C F (pin w e False))) |
| rw [expect_square_add_const _ (pin_normalized v hv e False)] |
| have hmean := (contact_mean_le_prob l (insert e used) hT.2.1 p C F |
| (pin w e False) (pin v e False) (pin_normalized w hw e False) |
| (pin_normalized v hv e False) (pin_nonneg w hnw e False) (pin_nonneg v hnv e False) |
| (fresh_pin w p used hf e False) (closedFresh_pin v p C used hc e False)).trans |
| (prob_le_one _ (pin_normalized w hw e False) (pin_nonneg w hnw e False) F) |
| have hd := delta_unit w hw hnw e (by rw [he.1]; exact (sub_pos.mpr hp.2).ne') |
| (by rw [he.2]; exact hp.1.ne') F hF |
| have ha : 0 ≤ a ∧ a ≤ 1 := by |
| simp only [a,heC,↓reduceIte] |
| exact ⟨mul_nonneg hp.1.le hd.1, |
| (mul_le_mul_of_nonneg_left hd.2 hp.1.le).trans (by linarith [hp.2])⟩ |
| have hpair := mul_le_mul_of_nonneg_left hmean ha.1 |
| nlinarith |
| · have ha : a = 0 := ite_eq_right heC |
| simp only [heC,↓reduceIte,ha,zero_add] |
| have hlb := mul_le_mul_of_nonneg_left hl' (sub_pos.mpr hp.2).le |
| have hrb := mul_le_mul_of_nonneg_left hr' hp.1.le |
| linarith |
| |
| end CriticalPercolation.SearchTree |
| |
| end |
| end |
| |
| end OAI |
| |
