import OAI.Combinatorics.GraphThreshold.ProbabilityTreeFacts

namespace OAI

/-! Full-path interpretation of supports and structural disjointness. -/

noncomputable section

namespace LeanBlast.SecondKahnKalai.ProbabilityTree

variable {X : Type} [DecidableEq X]

theorem pathUnion_subset_support {d : ℕ} (T : ProbabilityTree X d) (p : T.Path) :
    T.pathUnion p ⊆ T.support := by
  induction T with
  | leaf => exact Finset.empty_subset _
  | @node d B inst law positive label child ih =>
      rcases p with ⟨b, p⟩
      exact Finset.union_subset (label_subset_support law positive label child b)
        ((ih b p).trans (child_support_subset law positive label child b))

theorem mem_pathUnion_iff {d : ℕ} (T : ProbabilityTree X d) (p : T.Path) (x : X) :
    x ∈ T.pathUnion p ↔ ∃ S ∈ T.pathLabels p, x ∈ S := by
  induction T with
  | leaf => simp [pathUnion, pathLabels]
  | @node d B inst law positive label child ih =>
      rcases p with ⟨b, p⟩
      simp [pathUnion, pathLabels, ih b p]

theorem pathLabel_subset_pathUnion {d : ℕ} (T : ProbabilityTree X d)
    (p : T.Path) {S : Finset X} (hS : S ∈ T.pathLabels p) : S ⊆ T.pathUnion p := by
  intro x hx
  exact (mem_pathUnion_iff T p x).2 ⟨S, hS, hx⟩

theorem pathLabel_subset_support {d : ℕ} (T : ProbabilityTree X d)
    (p : T.Path) {S : Finset X} (hS : S ∈ T.pathLabels p) : S ⊆ T.support :=
  (pathLabel_subset_pathUnion T p hS).trans (pathUnion_subset_support T p)

/-- Every arc coordinate occurs on an actual full path, since all branches continue. -/
theorem mem_support_iff_exists_path {d : ℕ} (T : ProbabilityTree X d) (x : X) :
    x ∈ T.support ↔ ∃ p : T.Path, x ∈ T.pathUnion p := by
  induction T with
  | leaf => simp [support, pathUnion]
  | @node d B inst law positive label child ih =>
      constructor
      · intro hx
        obtain ⟨b, _, hxb⟩ := Finset.mem_biUnion.mp hx
        rcases Finset.mem_union.mp hxb with hlabel | hchild
        · exact ⟨⟨b, choosePath (child b)⟩, Finset.mem_union_left _ hlabel⟩
        · obtain ⟨p, hp⟩ := (ih b).1 hchild
          exact ⟨⟨b, p⟩, Finset.mem_union_right _ hp⟩
      · rintro ⟨⟨b, p⟩, hx⟩
        apply Finset.mem_biUnion.mpr
        refine ⟨b, Finset.mem_univ _, ?_⟩
        rcases Finset.mem_union.mp hx with hlabel | hchild
        · exact Finset.mem_union_left _ hlabel
        · exact Finset.mem_union_right _ ((ih b).2 ⟨p, hchild⟩)

theorem support_eq_pathUnion_biUnion {d : ℕ} (T : ProbabilityTree X d) :
    T.support = Finset.univ.biUnion T.pathUnion := by
  ext x
  simpa only [Finset.mem_biUnion, Finset.mem_univ, true_and] using
    mem_support_iff_exists_path T x

theorem isDisjoint_iff_pathDisjoint {d : ℕ} (T : ProbabilityTree X d) :
    T.IsDisjoint ↔ T.PathDisjoint := by
  induction T with
  | leaf => simp [IsDisjoint, PathDisjoint, pathLabels]
  | @node d B inst law positive label child ih =>
      constructor
      · intro hT p
        rcases p with ⟨b, p⟩
        apply List.pairwise_cons.mpr
        constructor
        · intro S hS
          exact (hT.1 b).mono_right (pathLabel_subset_support (child b) p hS)
        · exact (ih b).1 (hT.2 b) p
      · intro hT
        constructor
        · intro b
          apply Finset.disjoint_left.mpr
          intro x hxLabel hxSupport
          obtain ⟨p, hp⟩ := (mem_support_iff_exists_path (child b) x).1 hxSupport
          obtain ⟨S, hS, hxS⟩ := (mem_pathUnion_iff (child b) p x).1 hp
          have hpw := hT ⟨b, p⟩
          have hdis := (List.pairwise_cons.mp hpw).1 S hS
          exact Finset.disjoint_left.mp hdis hxLabel hxS
        · intro b
          apply (ih b).2
          intro p
          exact (List.pairwise_cons.mp (hT ⟨b, p⟩)).2

theorem incoming_disjoint_subtree_of_pathDisjoint {d : ℕ} {B : Type} [Fintype B]
    {law : FiniteLaw B} {positive : law.IsPositive} {label : B → Finset X}
    {child : B → ProbabilityTree X d}
    (hT : (node B law positive label child).PathDisjoint) (b : B) :
    Disjoint (label b) (child b).support :=
  ((isDisjoint_iff_pathDisjoint _).2 hT).1 b

/-- The locality assertion applies even when disjointness is given in the literal path form. -/
theorem child_dependsOutside_of_pathDisjoint {d : ℕ} {B : Type} [Fintype B]
    {law : FiniteLaw B} {positive : law.IsPositive} {label : B → Finset X}
    {child : B → ProbabilityTree X d}
    (hT : (node B law positive label child).PathDisjoint) (b : B)
    {β : Type*} {f : Finset X → β} (hf : DependsOnlyOn (child b).support f) :
    DependsOutside (label b) f :=
  hf.dependsOutside (incoming_disjoint_subtree_of_pathDisjoint hT b)

theorem coveredBy_mono {d : ℕ} {T : ProbabilityTree X d} {W V : Finset X}
    (h : T.CoveredBy W) (hWV : W ⊆ V) : T.CoveredBy V := by
  obtain ⟨p, hp⟩ := h
  exact ⟨p, hp.trans hWV⟩

theorem coveredBy_univ [Fintype X] {d : ℕ} (T : ProbabilityTree X d) :
    T.CoveredBy Finset.univ :=
  ⟨choosePath T, Finset.subset_univ _⟩

end LeanBlast.SecondKahnKalai.ProbabilityTree

end

end OAI