File size: 5,729 Bytes
f205175 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 | import Mathlib
import OAI.Probability.CriticalPercolation.Entropy.BinaryLaw
namespace OAI
section
section
namespace CriticalPercolation.BinaryLaw
open scoped Classical
open FiniteProduct BondGraph BinaryInterpolation
variable {V E : Type*} (G : BondGraph V E)
def Consistent (L : List (V × Bool)) (ω : Set E) : Prop :=
∀ z ∈ L, ∀ t ∈ L, (G.openGraph ω).Reachable z.1 t.1 → z.2=t.2
lemma consistent_append (L : List (V × Bool)) (ω : Set E) (hL : Consistent G L ω)
(a : V) (b : Bool) (hnew : ∀ z ∈ L, (G.openGraph ω).Reachable a z.1 → b=z.2) :
Consistent G (L++[(a,b)]) ω := by
intro z hz t ht hr
rcases List.mem_append.mp hz with hz|hz <;> rcases List.mem_append.mp ht with ht|ht
· exact hL z hz t ht hr
· have he := List.mem_singleton.mp ht
subst t
exact (hnew z hz hr.symm).symm
· have he := List.mem_singleton.mp hz
subst z
exact hnew t ht hr
· have he := List.mem_singleton.mp hz
subst z
have he := List.mem_singleton.mp ht
subst t
rfl
lemma consistent_bases (u v : V) (ω : Set E) (h : ¬(G.openGraph ω).Reachable u v) :
Consistent G [(u,true),(v,false)] ω := by
intro z hz t ht hr
simp only [List.mem_cons,List.not_mem_nil,or_false] at hz ht
rcases hz with rfl|rfl <;> rcases ht with rfl|rfl
· rfl
· exact (h hr).elim
· exact (h hr.symm).elim
· rfl
section Kernel
variable [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E]
lemma kernel_colour_consistent (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)
(hL : Consistent G (anchors d x n h) ω)
(z : V × Bool) (hz : z ∈ anchors d x n h) (hr : (G.openGraph ω).Reachable a z.1) :
side G (anchors d x n h) a ω m = z.2 := by
have ha : a ∈ (G.clusterObject ω (anchorSet d x n h)).1 := ⟨z.1,⟨z.2,hz⟩,hr.symm⟩
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
have hex := kernel_parent_exists G order d x n h a p w ω none hk
obtain ⟨t,ht,hreach⟩ := firstIndex_spec hex
have hparent : (anchors d x n h)[parent G (anchors d x n h) a ω none]? = some t := ht
have hside : side G (anchors d x n h) a ω none = t.2 := by
simp only [side,hparent,Option.getD_some]
rw [hside]
exact hL t (List.mem_of_getElem? ht) z hz (hreach.symm.trans hr)
lemma density_consistent (order : List (LazyDFS.Dart V E))
(d : ℕ) (x : ℕ → V) (p : ℝ) (w : E → Prop → ℝ) (s : ℕ)
(n : ℕ) (h : History E n) (ω : E → Prop)
(hr : density G order d x p w (seed G w (x 0) (x d) s) n h ω ≠ 0) :
Consistent G (anchors d x n h) ω := by
induction n with
| zero =>
have hE : endpointEvent G (x 0) (x d) s ω := by
by_contra hE
simp only [density,seed,ite_eq_right hE,mul_zero] at hr
exact hr rfl
exact consistent_bases G _ _ ω hE.1
| succ n ih =>
obtain ⟨hprev,hk,hs⟩ := density_step_support G order d x p w _ n h ω hr
have hL := ih h.1 hprev
apply consistent_append G _ ω hL
intro z hz hzreach
rw [←hs]
exact kernel_colour_consistent G order d x n h.1 _ p w ω _ hk hL z hz hzreach
end Kernel
lemma endpoint_labels (d : ℕ) (x : ℕ → V) (n : ℕ) (h : History E n) :
(x (interval d n h).1,true) ∈ anchors d x n h ∧
(x (interval d n h).2,false) ∈ anchors d x n h := by
induction n with
| zero => constructor <;> simp [anchors,interval]
| succ n ih =>
have hi := ih h.1
by_cases ht : (interval d n h.1).2 ≤ (interval d n h.1).1+1
· constructor
· exact List.mem_append_left _ (by simpa only [interval,bisect,ite_eq_left ht] using hi.1)
· exact List.mem_append_left _ (by simpa only [interval,bisect,ite_eq_left ht] using hi.2)
· cases hb : h.2.1 <;>
simp only [interval,bisect,hb,Bool.false_eq_true,↓reduceIte,anchors,
List.mem_append,List.mem_singleton,nextIndex,ite_eq_right ht] <;>
simp_all only [or_true,true_or,and_self]
lemma endpoint_separated (d : ℕ) (x : ℕ → V) (n : ℕ) (h : History E n) (ω : Set E)
(hL : Consistent G (anchors d x n h) ω) :
¬(G.openGraph ω).Reachable (x (interval d n h).1) (x (interval d n h).2) := by
intro hr
have hi := endpoint_labels d x n h
have hs := hL _ hi.1 _ hi.2 hr
cases hs
def sideWord {E : Type*} : (n : ℕ) → History E n → List Bool
| 0, _ => []
| n+1, h => sideWord n h.1 ++ [h.2.1]
lemma sideWord_length {E : Type*} (n : ℕ) (h : History E n) : (sideWord n h).length=n := by
induction n with
| zero => rfl
| succ n ih => simp only [sideWord,List.length_append,List.length_singleton,ih]
lemma terminal_append (l r : ℕ) (xs ys : List Bool) :
terminal l r (xs++ys) = terminal (terminal l r xs).1 (terminal l r xs).2 ys := by
induction xs generalizing l r with
| nil => rfl
| cons b xs ih => simpa only [List.cons_append,terminal] using ih (bisect l r b).1 (bisect l r b).2
lemma interval_eq_terminal {E : Type*} (d n : ℕ) (h : History E n) :
interval d n h = terminal 0 d (sideWord n h) := by
induction n with
| zero => rfl
| succ n ih => simp only [sideWord,terminal_append,interval,ih,terminal]
lemma interval_adjacent {E : Type*} {d n : ℕ} (hd : 0<d) (hJ : Nat.clog 2 d ≤ n)
(h : History E n) : (interval d n h).2 = (interval d n h).1+1 := by
rw [interval_eq_terminal]
apply terminal_adjacent hd
simpa only [Nat.sub_zero,sideWord_length] using hJ
end CriticalPercolation.BinaryLaw
end
end
end OAI
|