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