Download data/lean/OAI/Probability/CriticalPercolation/Entropy/BinaryLaw.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 17.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/CriticalPercolation/Entropy/BinaryLaw.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/CriticalPercolation/Entropy/BinaryLaw.lean
-
curl -L -o BinaryLaw.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/CriticalPercolation/Entropy/BinaryLaw.lean
17.4 kB
| import Mathlib | |
| import OAI.Probability.CriticalPercolation.Exploration.SequentialExposure | |
| import OAI.Probability.CriticalPercolation.Entropy.BinaryInterpolation | |
| import OAI.Probability.CriticalPercolation.Exploration.ReachableIncidenceImp | |
| namespace OAI | |
| section | |
| section | |
| namespace CriticalPercolation.BinaryLaw | |
| open scoped Classical | |
| open FiniteProduct BondGraph BinaryInterpolation | |
| universe uE | |
| def History (E : Type uE) : β β Type uE | |
| | 0 => PUnit | |
| | n+1 => History E n Γ Bool Γ Option E | |
| instance historyFintype {E : Type*} [Fintype E] : (n : β) β Fintype (History E n) | |
| | 0 => inferInstanceAs (Fintype PUnit) | |
| | n+1 => by | |
| letI := historyFintype (E := E) n | |
| exact inferInstanceAs (Fintype (History E n Γ Bool Γ Option E)) | |
| def interval {E : Type*} (d : β) : (n : β) β History E n β β Γ β | |
| | 0, _ => (0,d) | |
| | n+1, h => bisect (interval d n h.1).1 (interval d n h.1).2 h.2.1 | |
| lemma interval_bounds {E : Type*} {d : β} (hd : 0<d) (n : β) (h : History E n) : | |
| (interval d n h).1 < (interval d n h).2 β§ (interval d n h).2 β€ d := by | |
| induction n with | |
| | zero => exact β¨hd,le_rflβ© | |
| | succ n ih => | |
| have hi := ih h.1 | |
| have hb := bisect_bounds hi.1 h.2.1 | |
| exact β¨hb.2.1,hb.2.2.trans hi.2β© | |
| def nextIndex {E : Type*} (d : β) (n : β) (h : History E n) : β := | |
| if (interval d n h).2 β€ (interval d n h).1+1 then (interval d n h).1 | |
| else midpoint (interval d n h).1 (interval d n h).2 | |
| lemma nextIndex_bounds {E : Type*} {d : β} (hd : 0<d) (n : β) (h : History E n) : | |
| (interval d n h).1 β€ nextIndex d n h β§ nextIndex d n h < (interval d n h).2 := by | |
| have hi := (interval_bounds hd n h).1 | |
| unfold nextIndex | |
| split_ifs with ht | |
| Β· exact β¨le_rfl,hiβ© | |
| Β· have hm := midpoint_strict (by omega : (interval d n h).1+1 < (interval d n h).2) | |
| exact β¨hm.1.le,hm.2β© | |
| def anchors {V E : Type*} (d : β) (x : β β V) : (n : β) β History E n β List (V Γ Bool) | |
| | 0, _ => [(x 0,true),(x d,false)] | |
| | n+1, h => anchors d x n h.1 ++ [(x (nextIndex d n h.1),h.2.1)] | |
| def anchorSet {V E : Type*} (d : β) (x : β β V) (n : β) (h : History E n) : Set V := | |
| {v | β b, (v,b) β anchors d x n h} | |
| lemma anchors_length {V E : Type*} (d : β) (x : β β V) (n : β) (h : History E n) : | |
| (anchors d x n h).length = n+2 := by | |
| induction n with | |
| | zero => rfl | |
| | succ n ih => simp only [anchors,List.length_append,List.length_singleton,ih] | |
| lemma anchorSet_step {V E : Type*} (d : β) (x : β β V) (n : β) (h : History E (n+1)) : | |
| anchorSet d x (n+1) h = insert (x (nextIndex d n h.1)) (anchorSet d x n h.1) := by | |
| ext v | |
| constructor | |
| Β· rintro β¨b,hbβ© | |
| rcases List.mem_append.mp hb with hb | hb | |
| Β· exact Or.inr β¨b,hbβ© | |
| Β· exact Or.inl (congrArg Prod.fst (List.mem_singleton.mp hb)) | |
| Β· rintro (rfl | β¨b,hbβ©) | |
| Β· exact β¨h.2.1,List.mem_append_right _ (List.mem_singleton_self _)β© | |
| Β· exact β¨b,List.mem_append_left _ hbβ© | |
| lemma endpoint_mem {V E : Type*} {d : β} (_hd : 0<d) (x : β β V) (n : β) (h : History E n) : | |
| x (interval d n h).1 β anchorSet d x n h β§ | |
| x (interval d n h).2 β anchorSet d x n h := by | |
| induction n with | |
| | zero => constructor <;> simp [interval,anchorSet,anchors] | |
| | succ n ih => | |
| have hi := ih h.1 | |
| rw [anchorSet_step] | |
| change x (bisect _ _ _).1 β _ β§ x (bisect _ _ _).2 β _ | |
| unfold bisect | |
| split_ifs with ht hb | |
| Β· exact β¨Or.inr hi.1,Or.inr hi.2β© | |
| Β· have ha : nextIndex d n h.1 = midpoint (interval d n h.1).1 (interval d n h.1).2 := by | |
| rw [nextIndex,ite_eq_right ht] | |
| exact β¨Or.inl (congrArg x ha.symm),Or.inr hi.2β© | |
| Β· have ha : nextIndex d n h.1 = midpoint (interval d n h.1).1 (interval d n h.1).2 := by | |
| rw [nextIndex,ite_eq_right ht] | |
| exact β¨Or.inr hi.1,Or.inl (congrArg x ha.symm)β© | |
| noncomputable def firstIndex (P : β β Prop) : β := | |
| if h : β j, P j then Nat.find h else 0 | |
| lemma firstIndex_spec {P : β β Prop} (h : β j, P j) : P (firstIndex P) := by | |
| rw [firstIndex,dite_eq_left h] | |
| exact Nat.find_spec h | |
| lemma firstIndex_le {P : β β Prop} {j : β} (hj : P j) : firstIndex P β€ j := by | |
| rw [firstIndex,dite_eq_left β¨j,hjβ©] | |
| exact Nat.find_min' _ hj | |
| variable {V E : Type*} (G : BondGraph V E) | |
| def parentPredicate (L : List (V Γ Bool)) (a : V) (Ο : Set E) (m : Option E) (j : β) : Prop := | |
| β z, L[j]? = some z β§ match m with | |
| | none => (G.openGraph Ο).Reachable a z.1 | |
| | some e => β v β G.ends e, (G.openGraph Ο).Reachable z.1 v | |
| noncomputable def parent (L : List (V Γ Bool)) (a : V) (Ο : Set E) (m : Option E) : β := | |
| firstIndex (parentPredicate G L a Ο m) | |
| noncomputable def side (L : List (V Γ Bool)) (a : V) (Ο : Set E) (m : Option E) : Bool := | |
| ((L[parent G L a Ο m]?).getD (a,true)).2 | |
| lemma parentPredicate_congr (L : List (V Γ Bool)) (S : Set V) (a : V) | |
| (hL : β z β L, z.1 β S) (ha : a β S) (Ο Ξ· : Set E) | |
| (h : G.clusterObject Ο S = G.clusterObject Ξ· S) (m : Option E) (j : β) : | |
| parentPredicate G L a Ο m j β parentPredicate G L a Ξ· m j := by | |
| have hr (v : V) (hv : v β S) (u : V) : | |
| (G.openGraph Ο).Reachable v u β (G.openGraph Ξ·).Reachable v u := by | |
| apply G.reachable_incidence_congr | |
| rintro e β¨r,her,hvrβ© | |
| have hib : (G.clusterObject Ο S).2 e β (G.clusterObject Ξ· S).2 e := by rw [h] | |
| have hei : e β G.incidentEdges (G.clusterObject Ο S).1 := β¨r,β¨v,hv,hvrβ©,herβ© | |
| have hei' : e β G.incidentEdges (G.clusterObject Ξ· S).1 := h βΈ hei | |
| change (Ο e β§ e β G.incidentEdges (G.clusterObject Ο S).1) β | |
| (Ξ· e β§ e β G.incidentEdges (G.clusterObject Ξ· S).1) at hib | |
| simpa only [hei,hei',and_true] using hib | |
| unfold parentPredicate | |
| apply exists_congr | |
| intro z | |
| by_cases hz : L[j]? = some z | |
| Β· have hzmem : z β L := List.mem_of_getElem? hz | |
| simp only [hz,true_and] | |
| cases m with | |
| | none => exact hr a ha z.1 | |
| | some e => exact exists_congr (fun v => and_congr_right (fun _ => hr z.1 (hL z hzmem) v)) | |
| Β· simp only [hz,false_and] | |
| lemma side_record (L : List (V Γ Bool)) (S : Set V) (a : V) | |
| (hL : β z β L, z.1 β S) (ha : a β S) (Ο Ξ· : Set E) | |
| (h : G.clusterObject Ο S = G.clusterObject Ξ· S) (m : Option E) : | |
| side G L a Ο m = side G L a Ξ· m := by | |
| have he : parentPredicate G L a Ο m = parentPredicate G L a Ξ· m := | |
| funext (fun j => propext (parentPredicate_congr G L S a hL ha Ο Ξ· h m j)) | |
| simp only [side,parent,he] | |
| section Density | |
| variable [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E] | |
| variable (order : List (LazyDFS.Dart V E)) (d : β) (x : β β V) | |
| variable (p : β) (w : E β Prop β β) (rβ : (E β Prop) β β) | |
| noncomputable def density : (n : β) β History E n β (E β Prop) β β | |
| | 0, _, Ο => rβ Ο | |
| | n+1, h, Ο => | |
| if side G (anchors d x n h.1) (x (nextIndex d n h.1)) Ο h.2.2 = h.2.1 then | |
| density n h.1 Ο * G.contactKernel order (anchorSet d x n h.1) | |
| (x (nextIndex d n h.1)) p w (G.clusterObject Ο (anchorSet d x n h.1)) Ο h.2.2 | |
| else 0 | |
| lemma density_nonneg (hp : p β Set.Ioo 0 1) (h0 : β e, w e False = 1-p) | |
| (h1 : β e, w e True = p) (hrβ : β Ο, 0 β€ rβ Ο) (n : β) (h : History E n) | |
| (Ο : E β Prop) : 0 β€ density G order d x p w rβ n h Ο := by | |
| induction n with | |
| | zero => exact hrβ Ο | |
| | succ n ih => | |
| rw [density] | |
| split_ifs | |
| Β· exact mul_nonneg (ih h.1) (G.contactKernel_nonneg order _ _ hp w h0 h1 _ Ο _) | |
| Β· exact le_rfl | |
| lemma density_record | |
| (hrβ : β Ο Ξ·, G.clusterObject Ο ({x 0,x d} : Set V) = | |
| G.clusterObject Ξ· {x 0,x d} β rβ Ο = rβ Ξ·) | |
| (n : β) (h : History E n) (Ο Ξ· : E β Prop) | |
| (he : G.clusterObject Ο (anchorSet d x n h) = G.clusterObject Ξ· (anchorSet d x n h)) : | |
| density G order d x p w rβ n h Ο = density G order d x p w rβ n h Ξ· := by | |
| induction n with | |
| | zero => | |
| apply hrβ | |
| convert he using 2 <;> ext v <;> simp [anchorSet,anchors,or_comm] | |
| | succ n ih => | |
| have hST : anchorSet d x n h.1 β anchorSet d x (n+1) h := by | |
| rw [anchorSet_step] | |
| exact Set.subset_insert _ _ | |
| have ha : x (nextIndex d n h.1) β anchorSet d x (n+1) h := by | |
| rw [anchorSet_step] | |
| exact Set.mem_insert _ _ | |
| have hs := side_record G (anchors d x n h.1) _ _ | |
| (fun z hz => hST β¨z.2,hzβ©) ha Ο Ξ· he h.2.2 | |
| rw [density,density,hs] | |
| split_ifs | |
| Β· rw [ih h.1 (G.clusterObject_refines hST Ο Ξ· he)] | |
| rw [G.contactKernel_record order _ _ _ _ hST ha p w Ο Ξ· he] | |
| Β· rfl | |
| theorem density_normalized (ho : LazyDFS.Exhaustive G order) | |
| (hp : p β Set.Ioo 0 1) (h0 : β e, w e False = 1-p) (h1 : β e, w e True = p) | |
| (hrβ : β Ο Ξ·, G.clusterObject Ο ({x 0,x d} : Set V) = | |
| G.clusterObject Ξ· {x 0,x d} β rβ Ο = rβ Ξ·) | |
| (hZ : expect w rβ = 1) | |
| (hh : β n (h : History E n), 0 < prob w (fun Ο => β b β anchorSet d x n h, | |
| (G.openGraph Ο).Reachable (x (nextIndex d n h)) b)) (n : β) : | |
| β h : History E n, expect w (density G order d x p w rβ n h) = 1 := by | |
| induction n with | |
| | zero => | |
| change (β _h : PUnit, expect w rβ) = 1 | |
| simpa only [Fintype.sum_unique] using hZ | |
| | succ n ih => | |
| have hs := G.adaptive_marked_step order ho (anchorSet d x n) (anchorSet d x n) | |
| (fun _ => Set.Subset.rfl) (fun h => x (nextIndex d n h)) hp w h0 h1 (hh n) | |
| (density G order d x p w rβ n) | |
| (fun h Ο Ξ· he => density_record G order d x p w rβ hrβ n h Ο Ξ· he) | |
| (fun h Ο m => side G (anchors d x n h) (x (nextIndex d n h)) Ο m) | |
| change (β h : History E n Γ Bool Γ Option E, _) = 1 | |
| rw [Fintype.sum_prod_type] | |
| calc | |
| _ = β h : History E n, expect w (fun Ο => β m : Option E, β b : Bool, | |
| if side G (anchors d x n h) (x (nextIndex d n h)) Ο m = b then | |
| density G order d x p w rβ n h Ο * G.contactKernel order (anchorSet d x n h) | |
| (x (nextIndex d n h)) p w (G.clusterObject Ο (anchorSet d x n h)) Ο m else 0) := by | |
| apply Finset.sum_congr rfl | |
| intro h _ | |
| rw [Fintype.sum_prod_type] | |
| simp_rw [βexpect_sum] | |
| congr 1 | |
| funext Ο | |
| exact Finset.sum_comm | |
| _ = β h : History E n, expect w (density G order d x p w rβ n h) := hs | |
| _ = 1 := ih | |
| end Density | |
| lemma base_left_mem {V E : Type*} (d : β) (x : β β V) (n : β) (h : History E n) : | |
| x 0 β anchorSet d x n h := by | |
| induction n with | |
| | zero => exact β¨true,by simp [anchors]β© | |
| | succ n ih => rw [anchorSet_step]; exact Or.inr (ih h.1) | |
| lemma root_bound [Fintype E] {d : β} (hd : 0<d) (x : β β V) | |
| (w : E β Prop β β) (hw : β e, β b, w e b = 1) (hn : β e b, 0 β€ w e b) | |
| {c : β} (hc1 : cβ€1) | |
| (hc : β j, 0<j β j<d β c β€ prob w (fun Ο => (G.openGraph Ο).Reachable (x 0) (x j))) | |
| (n : β) (h : History E n) : | |
| c β€ prob w (fun Ο => β b β anchorSet d x n h, | |
| (G.openGraph Ο).Reachable (x (nextIndex d n h)) b) := by | |
| let j := nextIndex d n h | |
| have hj : j<d := (nextIndex_bounds hd n h).2.trans_le (interval_bounds hd n h).2 | |
| by_cases hj0 : j=0 | |
| Β· have he : prob w (fun Ο => β b β anchorSet d x n h, | |
| (G.openGraph Ο).Reachable (x j) b) = 1 := by | |
| calc | |
| _ = prob w (fun _ => True) := prob_congr w (fun Ο => β¨fun _ => True.intro, | |
| fun _ => β¨x 0,base_left_mem d x n h,hj0 βΈ SimpleGraph.Reachable.refl _β©β©) | |
| _ = 1 := prob_true w hw | |
| exact hc1.trans_eq he.symm | |
| Β· exact (hc j (by omega) hj).trans (prob_mono w hn (fun Ο hr => | |
| β¨x 0,base_left_mem d x n h,hr.symmβ©)) | |
| lemma reachable_record {S : Set V} {a b : V} (ha : a β S) {Ο Ξ· : Set E} | |
| (h : G.clusterObject Ο S = G.clusterObject Ξ· S) : | |
| (G.openGraph Ο).Reachable a b β (G.openGraph Ξ·).Reachable a b := by | |
| calc | |
| _ β (G.openGraph (G.clusterObject Ο S).2).Reachable a b := | |
| (G.reachable_clusterObject ha).symm | |
| _ β (G.openGraph (G.clusterObject Ξ· S).2).Reachable a b := by rw [h] | |
| _ β _ := G.reachable_clusterObject ha | |
| lemma cluster_record {S : Set V} {a : V} (ha : a β S) {Ο Ξ· : Set E} | |
| (h : G.clusterObject Ο S = G.clusterObject Ξ· S) : G.cluster Ο a = G.cluster Ξ· a := by | |
| ext b | |
| exact reachable_record G ha h | |
| section Seed | |
| variable [Fintype V] [Fintype E] | |
| def endpointEvent (u v : V) (s : β) (Ο : Set E) : Prop := | |
| Β¬ (G.openGraph Ο).Reachable u v β§ | |
| s β€ (G.cluster Ο u).toFinset.card β§ s β€ (G.cluster Ο v).toFinset.card | |
| noncomputable def seed (w : E β Prop β β) (u v : V) (s : β) (Ο : E β Prop) : β := | |
| (prob w (endpointEvent G u v s))β»ΒΉ * if endpointEvent G u v s Ο then 1 else 0 | |
| omit [Fintype E] in | |
| lemma endpointEvent_record (u v : V) (s : β) (Ο Ξ· : Set E) | |
| (h : G.clusterObject Ο {u,v} = G.clusterObject Ξ· {u,v}) : | |
| endpointEvent G u v s Ο β endpointEvent G u v s Ξ· := by | |
| unfold endpointEvent | |
| rw [reachable_record G (Set.mem_insert u {v}) h, | |
| cluster_record G (Set.mem_insert u {v}) h, | |
| cluster_record G (Set.mem_insert_of_mem u (Set.mem_singleton v)) h] | |
| lemma seed_record (w : E β Prop β β) (u v : V) (s : β) (Ο Ξ· : E β Prop) | |
| (h : G.clusterObject Ο {u,v} = G.clusterObject Ξ· {u,v}) : | |
| seed G w u v s Ο = seed G w u v s Ξ· := by | |
| simp only [seed,endpointEvent_record G u v s Ο Ξ· h] | |
| lemma seed_normalized (w : E β Prop β β) (u v : V) (s : β) | |
| (hΞ΄ : 0 < prob w (endpointEvent G u v s)) : expect w (seed G w u v s) = 1 := by | |
| unfold seed | |
| rw [expect_const_mul] | |
| change (prob w (endpointEvent G u v s))β»ΒΉ * prob w (endpointEvent G u v s) = 1 | |
| exact inv_mul_cancelβ hΞ΄.ne' | |
| lemma seed_nonneg (w : E β Prop β β) (u v : V) (s : β) | |
| (hΞ΄ : 0 < prob w (endpointEvent G u v s)) (Ο : E β Prop) : 0 β€ seed G w u v s Ο := by | |
| unfold seed | |
| apply mul_nonneg (inv_nonneg.mpr hΞ΄.le) | |
| split_ifs <;> norm_num | |
| end Seed | |
| section ExactLaw | |
| variable [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E] | |
| theorem endpoint_density_normalized (order : List (LazyDFS.Dart V E)) | |
| (ho : LazyDFS.Exhaustive G order) {d : β} (hd : 2β€d) (x : β β V) | |
| {p : β} (hp : p β Set.Ioo 0 1) (w : E β Prop β β) | |
| (h0 : β e, w e False = 1-p) (h1 : β e, w e True = p) | |
| {c : β} (hc : 0<c) | |
| (hconn : β j k, j<k β kβ€d β k-j<d β | |
| c β€ prob w (fun Ο => (G.openGraph Ο).Reachable (x j) (x k))) | |
| (s : β) (hΞ΄ : 0 < prob w (endpointEvent G (x 0) (x d) s)) (n : β) : | |
| β h : History E n, expect w | |
| (density G order d x p w (seed G w (x 0) (x d) s) n h) = 1 := by | |
| have hw := homogeneous_normalized w p h0 h1 | |
| have hn : β e b, 0 β€ w e b := fun e b => (homogeneous_positive w hp h0 h1 e b).le | |
| apply density_normalized G order d x p w _ ho hp h0 h1 | |
| (seed_record G w (x 0) (x d) s) (seed_normalized G w (x 0) (x d) s hΞ΄) | |
| intro k h | |
| apply hc.trans_le | |
| exact root_bound G (by omega : 0<d) x w hw hn | |
| ((hconn 0 1 (by omega) (by omega) (by omega)).trans (prob_le_one w hw hn _)) | |
| (fun j hj hjd => hconn 0 j hj hjd.le (by simpa using hjd)) k h | |
| lemma kernel_parent_exists (order : List (LazyDFS.Dart V E)) | |
| (d : β) (x : β β V) (n : β) (h : History E n) (a : V) | |
| (p : β) (w : E β Prop β β) (Ο : E β Prop) (m : Option E) | |
| (hk : G.contactKernel order (anchorSet d x n h) a p w | |
| (G.clusterObject Ο (anchorSet d x n h)) Ο m β 0) : | |
| β j, parentPredicate G (anchors d x n h) a Ο m j := by | |
| by_cases ha : a β (G.clusterObject Ο (anchorSet d x n h)).1 | |
| Β· have hm : m=none := by | |
| by_contra hm | |
| simp only [contactKernel,ite_eq_left ha,ite_eq_right hm] at hk | |
| exact hk rfl | |
| subst m | |
| obtain β¨v,β¨b,hbβ©,hrβ© := ha | |
| obtain β¨j,hjβ© := List.mem_iff_getElem?.mp hb | |
| exact β¨j,(v,b),hj,hr.symmβ© | |
| Β· cases m with | |
| | none => simp only [contactKernel,ite_eq_right ha] at hk; exact (hk rfl).elim | |
| | some e => | |
| have he : e β G.cutEdges (G.clusterObject Ο (anchorSet d x n h)).1 := by | |
| by_contra he | |
| simp only [contactKernel,ite_eq_right ha,contactWeight,ite_eq_right he,zero_div] at hk | |
| exact hk rfl | |
| obtain β¨u,v,heq,-,z,β¨b,hbβ©,hrβ© := he | |
| obtain β¨j,hjβ© := List.mem_iff_getElem?.mp hb | |
| refine β¨j,(z,b),hj,v,?_,hrβ© | |
| simp [heq] | |
| omit [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E] in | |
| lemma parent_lt_of_exists (L : List (V Γ Bool)) (a : V) (Ο : Set E) (m : Option E) | |
| (h : β j, parentPredicate G L a Ο m j) : parent G L a Ο m < L.length := by | |
| obtain β¨z,hz,-β© := firstIndex_spec h | |
| exact (List.getElem?_eq_some_iff.mp hz).1 | |
| lemma density_step_support (order : List (LazyDFS.Dart V E)) | |
| (d : β) (x : β β V) (p : β) (w : E β Prop β β) (rβ : (E β Prop) β β) | |
| (n : β) (h : History E (n+1)) (Ο : E β Prop) | |
| (hr : density G order d x p w rβ (n+1) h Ο β 0) : | |
| density G order d x p w rβ n h.1 Ο β 0 β§ | |
| G.contactKernel order (anchorSet d x n h.1) (x (nextIndex d n h.1)) p w | |
| (G.clusterObject Ο (anchorSet d x n h.1)) Ο h.2.2 β 0 β§ | |
| side G (anchors d x n h.1) (x (nextIndex d n h.1)) Ο h.2.2 = h.2.1 := by | |
| rw [density] at hr | |
| split_ifs at hr with hs | |
| Β· exact β¨(mul_ne_zero_iff.mp hr).1,(mul_ne_zero_iff.mp hr).2,hsβ© | |
| Β· exact (hr rfl).elim | |
| end ExactLaw | |
| end CriticalPercolation.BinaryLaw | |
| end | |
| end | |
| end OAI | |