| import Mathlib |
| import OAI.Probability.CriticalPercolation.Exploration.CompileStop |
| import OAI.Probability.CriticalPercolation.GraphGeometry.MapVertices |
|
|
| 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] |
|
|
| noncomputable def targetSearch (G : BondGraph V E) (B : Set V) |
| (order : List (Dart (Option V) E)) (a : V) : SearchTree E (State (Option V) E) := |
| search (G.wireTargets B) order (collapseTarget B a) {none} |
|
|
| theorem targetSearch_moments (G : BondGraph V E) (B : Set V) |
| (order : List (Dart (Option V) E)) (ho : Exhaustive (G.wireTargets B) 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 ((targetSearch G B order a).score p F w) ≤ 1 ∧ |
| expect w (fun ω => ((targetSearch G B order a).score p F w ω)^2) ≤ 3 := by |
| have hh := search_pivotal_moments (G.wireTargets B) order ho (collapseTarget B a) none hp w h0 h1 |
| have hF : (G.wireTargets B).connects (collapseTarget B a) none = |
| (fun ω : Set E => ∃ b ∈ B, (G.openGraph ω).Reachable a b) := by |
| funext ω |
| exact propext (G.wireTargets_connection B ω a) |
| rw [hF] at hh |
| exact hh |
|
|
| def GoodDarts (G : BondGraph V E) (ds : List (Dart V E)) : Prop := |
| ∀ d ∈ ds, G.ends d.2.1 = s(d.1,d.2.2) |
|
|
| noncomputable def mapDart (B : Set V) (d : Dart V E) : Dart (Option V) E := |
| (collapseTarget B d.1,d.2.1,collapseTarget B d.2.2) |
| noncomputable def mapState (B : Set V) (st : State V E) : State (Option V) E := |
| ⟨st.reached.image (collapseTarget B),st.read⟩ |
| |
| omit [Fintype V] [Fintype E] [DecidableEq E] in |
| lemma target_hit_map (B : Set V) (st : State V E) : |
| (∃ v ∈ (mapState B st).reached, v ∈ ({none} : Set (Option V))) ↔ |
| ∃ v ∈ st.reached, v ∈ B := by |
| constructor |
| · rintro ⟨v,hv,hvt⟩ |
| have hvn : v = none := Set.mem_singleton_iff.mp hvt |
| obtain ⟨u,hu,heq⟩ := Finset.mem_image.mp hv |
| exact ⟨u,hu,(collapseTarget_eq_none B u).mp (heq.trans hvn)⟩ |
| · rintro ⟨v,hv,hvB⟩ |
| refine ⟨none,Finset.mem_image.mpr ⟨v,hv,?_⟩,Set.mem_singleton none⟩ |
| exact (collapseTarget_eq_none B v).mpr hvB |
|
|
| omit [Fintype V] [Fintype E] [DecidableEq E] in |
| lemma mapState_mem (B : Set V) (st : State V E) |
| (hh : ¬∃ v ∈ st.reached, v ∈ B) (v : V) : |
| collapseTarget B v ∈ (mapState B st).reached ↔ v ∈ st.reached := by |
| constructor |
| · intro hv |
| obtain ⟨u,hu,heq⟩ := Finset.mem_image.mp hv |
| have huB : u ∉ B := fun hb => hh ⟨u,hu,hb⟩ |
| have huv := collapseTarget_injective_off B huB heq.symm |
| exact huv ▸ hu |
| · intro hv |
| exact Finset.mem_image.mpr ⟨v,hv,rfl⟩ |
|
|
| omit [Fintype V] [Fintype E] in |
| lemma mapState_closed (B : Set V) (st : State V E) (e : E) : |
| mapState B (st.closed e) = (mapState B st).closed e := rfl |
|
|
| omit [Fintype V] [Fintype E] in |
| lemma mapState_opened (B : Set V) (st : State V E) (e : E) (v : V) : |
| mapState B (st.opened e v) = (mapState B st).opened e (collapseTarget B v) := by |
| simp [mapState,State.opened] |
|
|
| omit [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E] in |
| lemma mapDart_ends (G : BondGraph V E) (B : Set V) (d : Dart V E) |
| (hd : G.ends d.2.1 = s(d.1,d.2.2)) : |
| (G.wireTargets B).ends (mapDart B d).2.1 = s((mapDart B d).1,(mapDart B d).2.2) := by |
| change Sym2.map (collapseTarget B) (G.ends d.2.1) = _ |
| rw [hd] |
|
|
| omit [Fintype V] [Fintype E] [DecidableEq E] in |
| lemma push_mapTarget (G : BondGraph V E) (B : Set V) (order : List (Dart V E)) |
| (hg : GoodDarts G order) (v : V) (hv : v ∉ B) : |
| (push G order v).map (mapDart B) = |
| push (G.wireTargets B) (order.map (mapDart B)) (collapseTarget B v) := by |
| induction order with |
| | nil => rfl |
| | cons d rest ih => |
| have hd := hg d (List.mem_cons_self ..) |
| have hd' := mapDart_ends G B d hd |
| have hrest : GoodDarts G rest := fun d h => hg d (List.mem_cons_of_mem _ h) |
| have heq : collapseTarget B d.1 = collapseTarget B v ↔ d.1 = v := |
| ⟨collapseTarget_injective_off B hv,fun h => congrArg (collapseTarget B) h⟩ |
| simp only [push,List.filter_cons,List.map_cons] at ih ⊢ |
| change (List.map (mapDart B) (if decide (d.1 = v ∧ G.ends d.2.1 = s(d.1,d.2.2)) then |
| d :: rest.filter _ else rest.filter _)) = _ |
| simp only [hd,hd',and_true] |
| change List.map (mapDart B) (if decide (d.1 = v) then d :: rest.filter _ else rest.filter _) = |
| (if decide (collapseTarget B d.1 = collapseTarget B v) then |
| mapDart B d :: (rest.map (mapDart B)).filter _ else (rest.map (mapDart B)).filter _) |
| simp only [heq] |
| split_ifs < |
|
|
| end CriticalPercolation.LazyDFS |
|
|
| end |
| end |
|
|
| end OAI |
|
|
