| import Mathlib |
| import OAI.Probability.CriticalPercolation.Exploration.Initial |
| import OAI.Probability.CriticalPercolation.Exploration.ReachableMemPhaseClosed |
| import OAI.Probability.CriticalPercolation.Exploration.ListScore |
| import OAI.Probability.CriticalPercolation.Exploration.ScoreCongrSupport |
| import OAI.Probability.CriticalPercolation.GraphGeometry.Connects |
| import OAI.Probability.CriticalPercolation.GraphGeometry.OpenGraphInsert |
|
|
| namespace OAI |
|
|
| section |
| section |
| open Set MeasureTheory ProbabilityTheory |
| open Set |
| open scoped BigOperators |
| open scoped Classical |
|
|
| namespace CriticalPercolation.LazyDFS |
| open scoped Classical |
|
|
| variable {V E : Type*} [DecidableEq V] [DecidableEq E] [Fintype V] |
|
|
| theorem actual_pivot_no_older_reads (G : BondGraph V E) |
| (order : List (Dart V E)) (ho : Exhaustive G order) (B : Set V) |
| (fuel : ℕ) (st : State V E) (older : List (Dart V E)) (ω : E → Bool) |
| (w a z : V) (f : E) (ha : a ∈ st.reached) (he : G.ends f = s(a,z)) |
| (hf : ω f = true) (hc : ReadConsistent G st ω) |
| (hr : rank order (st.opened f z) (push G order z) ≤ fuel) |
| (hA : ∀ u ∈ st.reached, (G.openGraph {e | e ≠ f ∧ ω e = true}).Reachable w u) |
| (hopen : ∃ t ∈ B, (G.openGraph {e | ω e = true}).Reachable w t) |
| (hclosed : ¬∃ t ∈ B, (G.openGraph {e | Function.update ω f false e = true}).Reachable w t) : |
| (compile G order B fuel (st.opened f z) (push G order z++older)).reads ω = |
| (compile G order B fuel (st.opened f z) (push G order z)).reads ω := by |
| have hopen' := hopen |
| rw [G.openGraph_delete_sup ω f a z hf he] at hopen' |
| rw [← G.openGraph_delete_eq_update] at hclosed |
| obtain ⟨ht,havoid⟩ := Wiring.pivot_component_avoids |
| (G.openGraph {e | e ≠ f ∧ ω e = true}) (st.reached : Set V) B w a z ha hA hopen' hclosed |
| apply phase_no_older_reads G (st.reached : Set V) order ho B fuel (st.opened f z) |
| (push G order z) older ω (opened_phaseFrontier G order ho st f z) |
| (readConsistent_opened G st ω hc ha he) hr |
| (G.openGraph {e | e ≠ f ∧ ω e = true}) |
| (SimpleGraph.fromEdgeSet_mono (Set.image_mono (fun _ h => h.2))) z |
| (Finset.mem_insert_self _ _) havoid ht |
|
|
| end CriticalPercolation.LazyDFS |
|
|
| namespace CriticalPercolation.LazyDFS |
| open scoped Classical |
| open FiniteProduct SearchTree |
|
|
| variable {V E : Type*} [Fintype E] [DecidableEq V] [DecidableEq E] |
|
|
| def PrefixState (G : BondGraph V E) (a : V) (st : State V E) |
| (w : E → Prop → ℝ) : Prop := |
| a ∈ st.reached ∧ ∀ ω : Set E, density w ω ≠ 0 → |
| (∀ v ∈ st.reached, (G.openGraph {e | e ∈ st.read ∧ e ∈ ω}).Reachable a v) ∧ |
| ReadConsistent G st (fun e => decide (ω e)) |
|
|
| omit [DecidableEq V] [DecidableEq E] in |
| lemma prefixState_initial (G : BondGraph V E) (a : V) (w : E → Prop → ℝ) : |
| PrefixState G a (initial a) w := by |
| refine ⟨Finset.mem_singleton_self _,?_⟩ |
| intro ω _ |
| constructor |
| · intro v hv |
| have hv' : v = a := Finset.mem_singleton.mp hv |
| subst v |
| exact .refl _ |
| · intro e he |
| exact (Finset.notMem_empty e he).elim |
|
|
| omit [DecidableEq V] in |
| lemma prefixState_closed (G : BondGraph V E) (a : V) (st : State V E) |
| (w : E → Prop → ℝ) (hs : PrefixState G a st w) (e : E) (h0 : w e False ≠ 0) : |
| PrefixState G a (st.closed e) (pin w e False) := by |
| refine ⟨hs.1,?_⟩ |
| intro ω hω |
| have hold := hs.2 ω (density_pin_old_support w e False ω h0 hω) |
| constructor |
| · intro v hv |
| apply (hold.1 v hv).mono |
| exact G.openGraph_mono (fun j hj => ⟨Finset.mem_insert_of_mem hj.1,hj.2⟩) |
| · apply readConsistent_closed G st (fun j => decide (ω j)) hold.2 |
| have hh := density_pin_support w e False ω hω |
| simp only [hh,decide_false] |
|
|
| lemma prefixState_opened (G : BondGraph V E) (a : V) (st : State V E) |
| (w : E → Prop → ℝ) (hs : PrefixState G a st w) (e : E) (v z : V) |
| (hv : v ∈ st.reached) (he : G.ends e = s(v,z)) (h1 : w e True ≠ 0) : |
| PrefixState G a (st.opened e z) (pin w e True) := by |
| refine ⟨Finset.mem_insert_of_mem hs.1,?_⟩ |
| intro ω hω |
| have hold := hs.2 ω (density_pin_old_support w e True ω h1 hω) |
| have hle : G.openGraph {j | j ∈ st.read ∧ j ∈ ω} ≤ |
| G.openGraph {j | j ∈ (st.opened e z).read ∧ j ∈ ω} := |
| G.openGraph_mono (fun j hj => ⟨Finset.mem_insert_of_mem hj.1,hj.2⟩) |
| constructor |
| · intro u hu |
| rcases Finset.mem_insert.mp hu with rfl | hu |
| · apply ((hold.1 v hv).mono hle).trans |
| apply prop_openEdge_reachable G {j | j ∈ insert e st.read ∧ j ∈ ω} _ he |
| exact ⟨Finset.mem_insert_self _ _,of_eq_true (density_pin_support w e True ω hω)⟩ |
| · exact (hold.1 u hu).mono hle |
| · exact readConsistent_opened G st (fun j => decide (ω j)) hold.2 hv he |
|
|
| omit [DecidableEq V] [DecidableEq E] in |
| lemma prefixState_deleted (G : BondGraph V E) (a : V) (st : State V E) |
| (w : E → Prop → ℝ) (hs : PrefixState G a st w) (f : E) (hf : f ∉ st.read) |
| (ω : Set E) (hω : density w ω ≠ 0) : |
| ∀ v ∈ st.reached, ((G.eraseBond f a).openGraph ω).Reachable a v := by |
| intro v hv |
| exact ((hs.2 ω hω).1 v hv).mono (G.knownGraph_le_eraseBond st.read f a ω hf) |
|
|
| variable [Fintype V] |
|
|
| theorem future_pair_bound (G : BondGraph V E) (order : List (Dart V E)) |
| (ho : Exhaustive G order) (a t v z : V) (f : E) |
| (st : State V E) (older : List (Dart V E)) (fuel : ℕ) |
| (hv : v ∈ st.reached) (hz : z ∉ st.reached) (ht : t ∉ st.reached) (hzt : z ≠ t) |
| (hf : f ∉ st.read) (he : G.ends f = s(v,z)) |
| (hr : rank order (st.opened f z) (push G order z) ≤ fuel) |
| {p : ℝ} (hp : p ∈ Set.Ioo 0 1) (w : E → Prop → ℝ) |
| (hw : ∀ e, ∑ b, w e b = 1) (hn : ∀ e b, 0 ≤ w e b) |
| (fresh : Fresh w p st.read) (hs : PrefixState G a st w) : |
| expect (pin w f True) (fun ω => if openPivot (G.connects a t) f ω then |
| (compile G order {t} fuel (st.opened f z) (push G order z++older)).score p |
| (G.connects a t) (pin w f True) ω else 0) ≤ delta w (G.connects a t) f := by |
| have hb := fresh f hf |
| have h0 : w f False ≠ 0 := by rw [hb.1]; exact (sub_pos.mpr hp.2).ne' |
| have h1 : w f True ≠ 0 := by rw [hb.2]; exact hp.1.ne' |
| have haz : a ≠ z := fun h => hz (h ▸ hs.1) |
| have hat : a ≠ t := fun h => ht (h ▸ hs.1) |
| have hA : ∀ ω : Set E, density w ω ≠ 0 → |
| ∀ u ∈ st.reached, ((G.eraseBond f a).openGraph ω).Reachable a u := |
| prefixState_deleted G a st w hs f hf |
| have hd := G.delta_eq_deleted_joined w hw f h0 h1 a v z t he |
| (fun ω hω => hA ω (density_pin_old_support w f False ω h0 hω) v hv) |
| rw [hd] |
| have hphase := young_phase_score_bound G order {t} f a z t haz hat hzt hp fuel (st.opened f z) |
| (Finset.mem_insert_self _ _) (pin w f True) (pin_normalized w hw f True) |
| (pin_nonneg w hn f True) (fresh_pin w p st.read fresh f True) |
| apply le_trans (le_of_eq ?_) hphase |
| apply expect_congr_support |
| intro ω hω |
| change Set E at ω |
| have hωold := density_pin_old_support w f True ω h1 hω |
| have hopenf : ω f := of_eq_true (density_pin_support w f True ω hω) |
| have hP := G.pivot_eq_deleted_joined f a v z t ω hopenf he (hA ω hωold v hv) |
| erw [hP] |
| by_cases hR : (G.eraseBond f a).joinedPair a z t ω |
| · rw [ite_eq_left hR,ite_eq_left hR] |
| have hactual := hP.mpr hR |
| have hconn : ∀ η : Set E, density (pin w f True) η ≠ 0 → |
| (G.connects a t η ↔ (G.eraseBond f a).wiredEvent a z t η) := by |
| intro η hη |
| exact G.connects_eq_wired_deleted f a v z t η |
| (of_eq_true (density_pin_support w f True η hη)) he |
| (hA η (density_pin_old_support w f True η h1 hη) v hv) |
| apply Eq.trans (SearchTree.score_eq_of_reads_eq _ _ p (G.connects a t) (pin w f True) ω ?_) |
| (SearchTree.score_congr_support _ (st.opened f z).read |
| (compile_valid G order {t} fuel (st.opened f z) (push G order z)) hp |
| (pin w f True) (fresh_pin w p st.read fresh f True) _ _ hconn ω hω) |
| apply actual_pivot_no_older_reads G order ho {t} fuel st older (fun e => decide (ω e)) |
| a v z f hv he (by simp [hopenf]) (hs.2 ω hωold).2 hr |
| · intro u hu |
| have hh := hA ω hωold u hu |
| erw [G.eraseBond_openGraph] at hh |
| convert hh using 1 |
| simp only [decide_eq_true_eq] |
| rfl |
| · refine ⟨t,Set.mem_singleton _,?_⟩ |
| convert hactual.2.1 using 1 |
| simp only [BondGraph.connects,decide_eq_true_eq] |
| rfl |
| · rintro ⟨u,hu,hau⟩ |
| have hu' : u = t := Set.mem_singleton_iff.mp hu |
| subst u |
| apply hactual.2.2 |
| have hsets : {e | Function.update (fun j => decide (ω j)) f false e = true} = |
| (Function.update ω f False : Set E) := by |
| ext e |
| change (Function.update (fun j => decide (ω j)) f false e = true) ↔ Function.update ω f False e |
| by_cases hf' : e = f |
| · subst e |
| erw [Function.update_self,Function.update_self] |
| simp |
| · erw [Function.update_of_ne hf',Function.update_of_ne hf'] |
| simp only [decide_eq_true_eq] |
| erw [hsets] at hau |
| unfold BondGraph.connects |
| convert hau using 1 |
| congr 1 |
| funext e |
| dsimp only [Function.update] |
| split_ifs <;> rfl |
| · rw [ite_eq_right hR,ite_eq_right hR] |
|
|
| end CriticalPercolation.LazyDFS |
|
|
| end |
| end |
|
|
| end OAI |
|
|
