lean/OAI/Probability/CriticalPercolation/Entropy/BinarySupport.lean

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