import OAI.Probability.FreeIsing.Trees.ConnectedExhaustion
import OAI.Probability.FreeIsing.Trees.Parents

namespace OAI

noncomputable section

namespace Problem367

def rootComponentFinset {d : ℕ} (D : Finset (TreeVertex d)) (c : Fin d) :
    Finset (TreeVertex d) := by
  classical
  exact D.filter (fun v => [c] <+: v.1)

def rootComplementFinset {d : ℕ} (D : Finset (TreeVertex d)) (c : Fin d) :
    Finset (TreeVertex d) := by
  classical
  exact D.filter (fun v => ¬ [c] <+: v.1)

@[simp] theorem mem_rootComponentFinset {d : ℕ} {D : Finset (TreeVertex d)}
    {c : Fin d} {v : TreeVertex d} : v ∈ rootComponentFinset D c ↔
      v ∈ D ∧ [c] <+: v.1 := by
  classical
  simp [rootComponentFinset]

@[simp] theorem mem_rootComplementFinset {d : ℕ} {D : Finset (TreeVertex d)}
    {c : Fin d} {v : TreeVertex d} : v ∈ rootComplementFinset D c ↔
      v ∈ D ∧ ¬ [c] <+: v.1 := by
  classical
  simp [rootComplementFinset]

theorem ConnectedFinset.prefix_mem_of_root_mem {d : ℕ}
    {D : Finset (TreeVertex d)} (hD : ConnectedFinset D)
    (hroot : ConnectedHull.root d ∈ D) {u v : TreeVertex d}
    (hv : v ∈ D) (huv : u.1 <+: v.1) : u ∈ D :=
  hD.prefix_mem_of_min_length_le hroot (fun _ _ => Nat.zero_le _) hv huv (Nat.zero_le _)

theorem ConnectedFinset.filter_prefix_connected {d : ℕ}
    {D : Finset (TreeVertex d)} (hD : ConnectedFinset D)
    (hroot : ConnectedHull.root d ∈ D) (r : TreeVertex d) (hr : r ∈ D) :
    ConnectedFinset (D.filter (fun v => r.1 <+: v.1)) := by
  classical
  let E := D.filter (fun v => r.1 <+: v.1)
  have hrE : r ∈ E := Finset.mem_filter.mpr ⟨hr, List.prefix_refl _⟩
  let R := fun x y : TreeVertex d => x ∈ E ∧ y ∈ E ∧ treeAdj x y
  have paths : ∀ n : ℕ, ∀ v : TreeVertex d, v.1.length = n → v ∈ E →
      Relation.ReflTransGen R r v ∧ Relation.ReflTransGen R v r := by
    intro n
    induction n using Nat.strong_induction_on with
    | h n ih =>
      intro v hn hv
      by_cases heq : v = r
      · subst v
        exact ⟨.refl, .refl⟩
      have hv' := Finset.mem_filter.mp hv
      have hnil : v.1 ≠ [] := by
        intro he
        have hre : r.1 = [] := by
          have hlen : r.1.length ≤ 0 := by simpa only [he, List.length_nil] using hv'.2.length_le
          exact List.length_eq_zero_iff.mp (by omega)
        exact heq (Subtype.ext (he.trans hre.symm))
      have hadj := treeAdj_parentVertex hnil
      have hpD : parentVertex v ∈ D :=
        hD.prefix_mem_of_root_mem hroot hv'.1 (List.dropLast_prefix v.1)
      have hpE : parentVertex v ∈ E := Finset.mem_filter.mpr
        ⟨hpD, treeAdj_preserves_prefix hv'.2 hadj.symm heq⟩
      have hlt : (parentVertex v).1.length < n := by
        have hpos := List.length_pos_iff.mpr hnil
        rw [parentVertex_length]
        omega
      obtain ⟨hforward, hbackward⟩ := ih _ hlt _ rfl hpE
      exact ⟨hforward.trans (.single ⟨hpE, hv, hadj⟩),
        (Relation.ReflTransGen.single ⟨hv, hpE, hadj.symm⟩).trans hbackward⟩
  refine ⟨⟨r, hrE⟩, ?_⟩
  intro u hu v hv
  exact (paths _ u rfl hu).2.trans (paths _ v rfl hv).1

theorem ConnectedFinset.filter_not_prefix_connected {d : ℕ}
    {D : Finset (TreeVertex d)} (hD : ConnectedFinset D)
    (hroot : ConnectedHull.root d ∈ D) (r : TreeVertex d) (hr : r.1 ≠ []) :
    ConnectedFinset (D.filter (fun v => ¬ r.1 <+: v.1)) := by
  classical
  let E := D.filter (fun v => ¬ r.1 <+: v.1)
  have hrootE : ConnectedHull.root d ∈ E := by
    apply Finset.mem_filter.mpr
    exact ⟨hroot, by simpa [ConnectedHull.root] using hr⟩
  have paths (v : TreeVertex d) (hv : v ∈ E) :
      Relation.ReflTransGen
        (fun x y : TreeVertex d => x ∈ E ∧ y ∈ E ∧ treeAdj x y)
        (ConnectedHull.root d) v ∧
      Relation.ReflTransGen
        (fun x y : TreeVertex d => x ∈ E ∧ y ∈ E ∧ treeAdj x y)
        v (ConnectedHull.root d) := by
    have hp : ∀ n ≤ v.1.length, ConnectedHull.takeVertex v n ∈ E := by
      intro n hn
      apply Finset.mem_filter.mpr
      refine ⟨hD.prefix_mem_of_root_mem hroot (Finset.mem_filter.mp hv).1
        (List.take_prefix n v.1), ?_⟩
      intro hpre
      exact (Finset.mem_filter.mp hv).2 (hpre.trans (List.take_prefix n v.1))
    simpa only [ConnectedHull.prefix_length] using
      ConnectedHull.prefix_paths E v hp (Nat.le_refl v.1.length)
  refine ⟨⟨ConnectedHull.root d, hrootE⟩, ?_⟩
  intro u hu v hv
  exact (paths u hu).2.trans (paths v hv).1

theorem rootComponentFinset_connected {d : ℕ} {D : Finset (TreeVertex d)}
    (hD : ConnectedFinset D) (hroot : ConnectedHull.root d ∈ D)
    (c : Fin d) (hc : (⟨[c], List.IsChain.singleton c⟩ : TreeVertex d) ∈ D) :
    ConnectedFinset (rootComponentFinset D c) :=
  hD.filter_prefix_connected hroot ⟨[c], List.IsChain.singleton c⟩ hc

theorem rootComplementFinset_connected {d : ℕ} {D : Finset (TreeVertex d)}
    (hD : ConnectedFinset D) (hroot : ConnectedHull.root d ∈ D) (c : Fin d) :
    ConnectedFinset (rootComplementFinset D c) :=
  hD.filter_not_prefix_connected hroot ⟨[c], List.IsChain.singleton c⟩ (by simp)

theorem rootComponentFinset_union_complement {d : ℕ} (D : Finset (TreeVertex d))
    (c : Fin d) : rootComponentFinset D c ∪ rootComplementFinset D c = D := by
  classical
  ext v
  simp only [Finset.mem_union, mem_rootComponentFinset, mem_rootComplementFinset]
  tauto

theorem rootComponentFinset_disjoint_complement {d : ℕ} (D : Finset (TreeVertex d))
    (c : Fin d) : Disjoint (rootComponentFinset D c) (rootComplementFinset D c) := by
  classical
  apply Finset.disjoint_left.mpr
  intro v hv hw
  exact (mem_rootComplementFinset.mp hw).2 (mem_rootComponentFinset.mp hv).2

theorem root_component_crossing_edge {d : ℕ} {c : Fin d} {u v : TreeVertex d}
    (hu : [c] <+: u.1) (hv : ¬ [c] <+: v.1) (hadj : treeAdj u v) :
    u = ⟨[c], List.IsChain.singleton c⟩ ∧ v = ConnectedHull.root d := by
  have hueq : u = (⟨[c], List.IsChain.singleton c⟩ : TreeVertex d) := by
    by_contra hne
    exact hv (treeAdj_preserves_prefix (r := ⟨[c], List.IsChain.singleton c⟩) hu hadj hne)
  refine ⟨hueq, ?_⟩
  subst u
  rcases hadj with ⟨a, ha⟩ | ⟨a, ha⟩
  · exfalso
    apply hv
    rw [ha]
    exact List.prefix_append _ _
  · apply Subtype.ext
    change v.1 = []
    have hlen := congrArg List.length ha
    simp only [List.length_singleton, List.length_append] at hlen
    exact List.length_eq_zero_iff.mp (by omega)

theorem rootComponentFinset_mono {d : ℕ} (c : Fin d) :
    Monotone (fun D : Finset (TreeVertex d) => rootComponentFinset D c) := by
  intro D E hDE v hv
  exact mem_rootComponentFinset.mpr ⟨hDE (mem_rootComponentFinset.mp hv).1,
    (mem_rootComponentFinset.mp hv).2⟩

theorem rootComplementFinset_mono {d : ℕ} (c : Fin d) :
    Monotone (fun D : Finset (TreeVertex d) => rootComplementFinset D c) := by
  intro D E hDE v hv
  exact mem_rootComplementFinset.mpr ⟨hDE (mem_rootComplementFinset.mp hv).1,
    (mem_rootComplementFinset.mp hv).2⟩

theorem rootComponentFinset_exhausts {d : ℕ} (D : ℕ → Finset (TreeVertex d))
    (hex : ∀ v, ∃ n, v ∈ D n) (c : Fin d) (v : TreeVertex d)
    (hv : [c] <+: v.1) : ∃ n, v ∈ rootComponentFinset (D n) c := by
  obtain ⟨n, hn⟩ := hex v
  exact ⟨n, mem_rootComponentFinset.mpr ⟨hn, hv⟩⟩

theorem singleton_prefix_iff_cons {d : ℕ} (c : Fin d) (v : TreeVertex d) :
    [c] <+: v.1 ↔ ∃ w, v.1 = c :: w := by
  constructor
  · rintro ⟨w, hw⟩
    exact ⟨w, hw.symm⟩
  · rintro ⟨w, hw⟩
    exact ⟨w, hw.symm⟩

theorem rootComponentFinset_eq_filter {d : ℕ} (D : Finset (TreeVertex d)) (c : Fin d) :
    rootComponentFinset D c = (by
      classical
      exact D.filter (fun v => ∃ w, v.1 = c :: w)) := by
  classical
  ext v
  simp only [mem_rootComponentFinset, Finset.mem_filter, singleton_prefix_iff_cons]

theorem rootComplementFinset_eq_sdiff {d : ℕ} (D : Finset (TreeVertex d)) (c : Fin d) :
    rootComplementFinset D c = D \ rootComponentFinset D c := by
  classical
  ext v
  simp only [mem_rootComplementFinset, Finset.mem_sdiff, mem_rootComponentFinset]
  tauto

theorem rootComponentFinset_root_mem {d : ℕ} {D : Finset (TreeVertex d)} (c : Fin d)
    (hc : (⟨[c], List.IsChain.singleton c⟩ : TreeVertex d) ∈ D) :
    (⟨[c], List.IsChain.singleton c⟩ : TreeVertex d) ∈ rootComponentFinset D c :=
  mem_rootComponentFinset.mpr ⟨hc, List.prefix_refl _⟩

theorem rootComplementFinset_root_mem {d : ℕ} {D : Finset (TreeVertex d)} (c : Fin d)
    (hroot : ConnectedHull.root d ∈ D) :
    ConnectedHull.root d ∈ rootComplementFinset D c := by
  apply mem_rootComplementFinset.mpr
  refine ⟨hroot, ?_⟩
  intro h
  have hlen := h.length_le
  change 1 ≤ 0 at hlen
  omega

private theorem mem_inducedEdges_cut {d : ℕ} {D : Finset (TreeVertex d)}
    {u v : TreeVertex d} : (u, v) ∈ inducedEdges D ↔
      u ∈ D ∧ v ∈ D ∧ treeAdj u v ∧ u.1.length < v.1.length := by
  classical
  simp [inducedEdges, and_assoc]

theorem inducedEdges_rootComponent_split {d : ℕ} {D : Finset (TreeVertex d)}
    (hroot : ConnectedHull.root d ∈ D) (c : Fin d)
    (hc : (⟨[c], List.IsChain.singleton c⟩ : TreeVertex d) ∈ D) :
    inducedEdges D = insert (ConnectedHull.root d, ⟨[c], List.IsChain.singleton c⟩)
      (inducedEdges (rootComponentFinset D c) ∪ inducedEdges (rootComplementFinset D c)) := by
  classical
  ext ⟨u, v⟩
  constructor
  · intro he
    obtain ⟨hu, hv, hadj, hlen⟩ := mem_inducedEdges_cut.mp he
    by_cases hcu : [c] <+: u.1
    · by_cases hcv : [c] <+: v.1
      · apply Finset.mem_insert_of_mem
        apply Finset.mem_union.mpr
        exact Or.inl (mem_inducedEdges_cut.mpr
          ⟨mem_rootComponentFinset.mpr ⟨hu, hcu⟩,
            mem_rootComponentFinset.mpr ⟨hv, hcv⟩, hadj, hlen⟩)
      · obtain ⟨rfl, rfl⟩ := root_component_crossing_edge hcu hcv hadj
        change 1 < 0 at hlen
        omega
    · by_cases hcv : [c] <+: v.1
      · obtain ⟨rfl, rfl⟩ := root_component_crossing_edge hcv hcu hadj.symm
        exact Finset.mem_insert_self _ _
      · apply Finset.mem_insert_of_mem
        apply Finset.mem_union.mpr
        exact Or.inr (mem_inducedEdges_cut.mpr
          ⟨mem_rootComplementFinset.mpr ⟨hu, hcu⟩,
            mem_rootComplementFinset.mpr ⟨hv, hcv⟩, hadj, hlen⟩)
  · intro he
    rcases Finset.mem_insert.mp he with heq | he
    · have hu : u = ConnectedHull.root d := congrArg Prod.fst heq
      have hv : v = (⟨[c], List.IsChain.singleton c⟩ : TreeVertex d) := congrArg Prod.snd heq
      subst u
      subst v
      exact mem_inducedEdges_cut.mpr ⟨hroot, hc, Or.inl ⟨c, rfl⟩, by change 0 < 1; omega⟩
    · rcases Finset.mem_union.mp he with he | he
      · obtain ⟨hu, hv, hadj, hlen⟩ := mem_inducedEdges_cut.mp he
        exact mem_inducedEdges_cut.mpr ⟨(mem_rootComponentFinset.mp hu).1,
          (mem_rootComponentFinset.mp hv).1, hadj, hlen⟩
      · obtain ⟨hu, hv, hadj, hlen⟩ := mem_inducedEdges_cut.mp he
        exact mem_inducedEdges_cut.mpr ⟨(mem_rootComplementFinset.mp hu).1,
          (mem_rootComplementFinset.mp hv).1, hadj, hlen⟩

theorem inducedEdges_rootComponent_disjoint {d : ℕ} (D : Finset (TreeVertex d))
    (c : Fin d) : Disjoint (inducedEdges (rootComponentFinset D c))
      (inducedEdges (rootComplementFinset D c)) := by
  classical
  apply Finset.disjoint_left.mpr
  rintro ⟨u, v⟩ hu hv
  exact (mem_rootComplementFinset.mp (mem_inducedEdges_cut.mp hv).1).2
    (mem_rootComponentFinset.mp (mem_inducedEdges_cut.mp hu).1).2

theorem root_bridge_not_mem_inducedEdges_cut {d : ℕ} (D : Finset (TreeVertex d))
    (c : Fin d) : (ConnectedHull.root d, (⟨[c], List.IsChain.singleton c⟩ : TreeVertex d)) ∉
      inducedEdges (rootComponentFinset D c) ∪ inducedEdges (rootComplementFinset D c) := by
  classical
  intro he
  rcases Finset.mem_union.mp he with he | he
  · have h := (mem_rootComponentFinset.mp (mem_inducedEdges_cut.mp he).1).2.length_le
    change 1 ≤ 0 at h
    omega
  · exact (mem_rootComplementFinset.mp (mem_inducedEdges_cut.mp he).2.1).2
      (List.prefix_refl _)

end Problem367

end

end OAI