import Mathlib
import OAI.Probability.CriticalPercolation.Entropy.BinaryParents

namespace OAI

section
section
namespace CriticalPercolation.BinaryLaw
open scoped Classical
open FiniteProduct BondGraph BinaryInterpolation InterpolationForest ExactExposure FiniteEntropy

variable {V E I : Type*} [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E] [Fintype I]
variable (G : BondGraph V E) (order : List (LazyDFS.Dart V E)) (d : ℕ) (x : ℕ → V)
variable (p : ℝ) (w : E → Prop → ℝ) (s n : ℕ) (h : History E n) (ω : E → Bool)

theorem active_cluster_users_le
    (hr : density G order d x p w (seed G w (x 0) (x d) s) n h (configuration ω) ≠ 0)
    (idx : I → ℕ) (hinj : Function.Injective idx)
    (hidx : ∀ i, idx i ∈ activeNodes G d x n h (configuration ω)) (v : V) :
    (clusterUsers G (fun i => (node d x n h (idx i)).1)
      (fun i => (node d x n h (nodeParent G d x (configuration ω) n h (idx i))).1) ω v).card ≤ 2 := by
  classical
  let F := historyForest G d x (configuration ω) n h
  let S := activeNodes G d x n h (configuration ω)
  let users := clusterUsers G (fun i => (node d x n h (idx i)).1)
      (fun i => (node d x n h (F.parent (idx i))).1) ω v
  have hb (i : I) : 2 ≤ idx i ∧ idx i<n+2 :=
    ⟨(Forest.mem_active _).mp (hidx i) |>.2,active_lt G d x n h _ _ (hidx i)⟩
  have hcan (i : I) : Canonical G (anchors d x n h) (configuration ω) (idx i) :=
    active_canonical G order d x p w _ n h _ hr _ (hidx i)
  have hpcan (i : I) : Canonical G (anchors d x n h) (configuration ω) (F.parent (idx i)) :=
    nodeParent_canonical G order d x p w _ n h _ hr _ (hb i).1 (hb i).2
  have hpbound (i : I) : F.parent (idx i)<n+2 := (F.parent_lt _ (hb i).1).trans (hb i).2
  by_cases hu : users.Nonempty
  · obtain ⟨i,hi⟩ := hu
    have hi' := hi
    simp only [users,clusterUsers,Finset.mem_filter,Finset.mem_univ,true_and] at hi'
    obtain ⟨j,hj,hjc,hjv⟩ : ∃ j<n+2, Canonical G (anchors d x n h) (configuration ω) j ∧
        (G.openGraph (configuration ω)).Reachable (node d x n h j).1 v := by
      rcases hi' with hi'|hi'
      · exact ⟨idx i,(hb i).2,hcan i,hi'⟩
      · exact ⟨F.parent (idx i),hpbound i,hpcan i,hi'⟩
    have hm : Set.MapsTo idx (↑users : Set I) (↑(S.filter fun k => k=j ∨ F.parent k=j) : Set ℕ) := by
      intro k hk
      refine Finset.mem_filter.mpr ⟨hidx k,?_⟩
      simp only [users,clusterUsers,Finset.mem_coe,Finset.mem_filter,Finset.mem_univ,true_and] at hk
      rcases hk with hk|hk
      · exact Or.inl (canonical_node_reachable_eq G d x n h (configuration ω) _ j
          (hb k).2 hj (hcan k) hjc (hk.trans hjv.symm))
      · exact Or.inr (canonical_node_reachable_eq G d x n h (configuration ω) _ j
          (hpbound k) hj (hpcan k) hjc (hk.trans hjv.symm))
    have hc : users.card ≤ (S.filter fun k => k=j ∨ F.parent k=j).card :=
      Finset.card_le_card_of_injOn idx hm hinj.injOn
    have ht := terminal_roots G order d x p w s n h (configuration ω) hr
    have hne : F.root (owner G d x n h (configuration ω) (x (interval d n h).1)) ≠
        F.root (owner G d x n h (configuration ω) (x (interval d n h).2)) := by
      change (historyForest G d x (configuration ω) n h).root _ ≠ _
      rw [ht.1,ht.2]
      omega
    exact hc.trans (F.active_pair_multiplicity hne j)
  · have he : users=∅ := Finset.not_nonempty_iff_eq_empty.mp hu
    change users.card ≤ 2
    rw [he,Finset.card_empty]
    omega

abbrev ActiveIndex (n : ℕ) (D : FixedDescriptor n) := {i : Fin n // (D i).2.2 = true}

def activeLeft (d : ℕ) (x : ℕ → V) (n : ℕ) (D : FixedDescriptor n) (i : ActiveIndex n D) : V :=
  (descriptorNode (E := E) d x n D (i.val.val+2)).1

def activeRight (d : ℕ) (x : ℕ → V) (n : ℕ) (D : FixedDescriptor n) (i : ActiveIndex n D) : V :=
  (descriptorNode (E := E) d x n D (descriptorParent (E := E) d x n D (i.val.val+2))).1

omit [Fintype I] in
lemma fixed_cluster_users_le (D : FixedDescriptor n) (m : Fin n → Option E)
    (hz : conditionedMass G order d x p w s n D (ω,m) ≠ 0) (v : V) :
    (clusterUsers G (activeLeft (E := E) d x n D) (activeRight (E := E) d x n D) ω v).card ≤ 2 := by
  classical
  obtain ⟨hD,hr⟩ := conditionedMass_support G order d x p w s n D (ω,m) hz
  let h := fromWords (E := E) n (fun j => (D j).1) m
  have hi (i : ActiveIndex n D) : i.val.val+2 ∈ activeNodes G d x n h (configuration ω) := by
    rw [activeNodes_eq_descriptor G d x n h _ D hD]
    exact Finset.mem_image.mpr ⟨i.val,Finset.mem_filter.mpr ⟨Finset.mem_univ _,i.property⟩,rfl⟩
  have hinj : Function.Injective (fun i : ActiveIndex n D => i.val.val+2) := by
    intro i j he
    apply Subtype.ext
    apply Fin.ext
    dsimp only at he
    omega
  have he := active_cluster_users_le G order d x p w s n h ω hr _ hinj hi v
  have hleft (i : ActiveIndex n D) : (node d x n h (i.val.val+2)).1 = activeLeft (E := E) d x n D i :=
    congrArg Prod.fst (node_eq_descriptor G d x n h _ D hD _)
  have hright (i : ActiveIndex n D) :
      (node d x n h (nodeParent G d x (configuration ω) n h (i.val.val+2))).1 =
      activeRight (E := E) d x n D i := by
    rw [active_parent_eq_descriptor G order d x p w s n h _ hr D hD _ (hi i)]
    exact congrArg Prod.fst (node_eq_descriptor G d x n h _ D hD _)
  simp_rw [hleft,hright] at he
  exact he

noncomputable section Entropy
local instance pairsClassicalFinDecidable (n : ℕ) : DecidableEq (Fin n) := Classical.decEq _

omit [Fintype I] in
lemma configurationMass_support (D : FixedDescriptor n) (η : E → Bool)
    (hη : 0 < pushMass Prod.fst (conditionedMass G order d x p w s n D) η) :
    ∃ m, 0 < conditionedMass G order d x p w s n D (η,m) := by
  by_contra! hn
  have hz : pushMass Prod.fst (conditionedMass G order d x p w s n D) η ≤ 0 := by
    unfold pushMass
    apply Finset.sum_nonpos
    intro z _
    split_ifs with he
    · rcases z with ⟨η',m⟩
      dsimp only at he
      subst η'
      exact hn m
    · rfl
  linarith

omit [Fintype I] in

theorem conditioned_pair_entropy (D : FixedDescriptor n)
    (hp : p ∈ Set.Ioo 0 1) (h0 : ∀ e, w e False = 1-p) (h1 : ∀ e, w e True = p)
    (hδ : 0 < prob w (endpointEvent G (x 0) (x d) s))
    (hD : 0 < descriptorMass G order d x p w s n D) :
    let P := pushMass Prod.fst (conditionedMass G order d x p w s n D)
    (∑ i : ActiveIndex n D,
      divergence (pushMass (pair G (activeLeft (E := E) d x n D i)
        (activeRight (E := E) d x n D i)).bare.run P)
      ((pair G (activeLeft (E := E) d x n D i) (activeRight (E := E) d x n D i)).bare.reference p)) ≤
      16/(2*p*(1-p)) * divergence P (FiniteProduct.density (QueryTree.bitWeight p)) := by
  cases Subsingleton.elim (inferInstance : DecidableEq V) (Classical.decEq V)
  cases Subsingleton.elim (inferInstance : DecidableEq E) (Classical.decEq E)
  dsimp only
  let Q := conditionedMass G order d x p w s n D
  have hQ : ∀ z, 0 ≤ Q z := conditionedMass_nonneg G order d x p w s n hp h0 h1 hδ D hD
  have hQ1 : ∑ z, Q z = 1 := by
    have he := conditionedMass_normalized G order d x p w s n D hD
    refine Eq.trans ?_ he
    apply Finset.sum_congr
    · ext z; simp only [Finset.mem_univ]
    · intro z _; rfl
  apply pair_entropy hp G (activeLeft (E := E) d x n D) (activeRight (E := E) d x n D)
    (pushMass Prod.fst Q) (pushMass_nonneg _ _ hQ) (by rw [pushMass_sum,hQ1])
  intro η hη v
  obtain ⟨m,hm⟩ := configurationMass_support G order d x p w s n D η hη
  exact fixed_cluster_users_le G order d x p w s n η D m hm.ne' v

end Entropy
end CriticalPercolation.BinaryLaw
end
end

end OAI