import OAI.Combinatorics.GraphThreshold.ProbabilityTree
import Mathlib.Tactic

namespace OAI

/-! Path and locality facts for the stable finite probability-tree representation. -/

noncomputable section

namespace LeanBlast.SecondKahnKalai

section Locality

variable {X β : Type*} [DecidableEq X] {S T A : Finset X} {f : Finset X → β}

theorem DependsOnlyOn.mono (hf : DependsOnlyOn S f) (hST : S ⊆ T) :
    DependsOnlyOn T f := by
  intro W V hWV
  apply hf W V
  apply Finset.ext
  intro x
  by_cases hx : x ∈ S
  · have hxT := hST hx
    have he := Finset.ext_iff.mp hWV x
    simpa [hx, hxT] using he
  · simp [hx]

theorem DependsOnlyOn.dependsOutside (hf : DependsOnlyOn S f) (hAS : Disjoint A S) :
    DependsOutside A f := by
  intro W V hWV
  apply hf W V
  apply Finset.ext
  intro x
  by_cases hx : x ∈ S
  · have hxA : x ∉ A := fun hxA => Finset.disjoint_left.mp hAS hxA hx
    have he := Finset.ext_iff.mp hWV x
    simpa [hx, hxA] using he
  · simp [hx]

theorem DependsOutside.sdiff_eq (hf : DependsOutside A f) (W : Finset X) :
    f (W \ A) = f W := by
  apply hf
  ext x
  simp

theorem dependsOutside_iff_sdiff :
    DependsOutside A f ↔ ∀ W, f (W \ A) = f W := by
  constructor
  · exact fun hf => hf.sdiff_eq
  · intro hf W V hWV
    rw [← hf W, ← hf V, hWV]

theorem DependsOutside.union_eq (hf : DependsOutside A f) (W U : Finset X) (hU : U ⊆ A) :
    f (W ∪ U) = f W := by
  apply hf
  ext x
  by_cases hx : x ∈ A
  · simp [hx]
  · have hxU : x ∉ U := fun hxU => hx (hU hxU)
    simp [hx, hxU]

end Locality

namespace ProbabilityTree

variable {X : Type}

/-- A finite law of total mass one has a nonempty underlying type. -/
theorem branch_nonempty {B : Type} [Fintype B] (law : FiniteLaw B) : Nonempty B := by
  classical
  by_contra h
  let : IsEmpty B := not_nonempty_iff.mp h
  have ht := law.total
  simp at ht

/-- Every equal-depth probability tree has at least one full path. -/
instance pathNonempty {d : ℕ} (T : ProbabilityTree X d) : Nonempty T.Path := by
  induction T with
  | leaf => exact ⟨PUnit.unit⟩
  | @node d B inst law positive label child ih =>
      let b : B := Classical.choice (branch_nonempty law)
      exact ⟨⟨b, Classical.choice (ih b)⟩⟩

/-- A fixed deterministic full path, used only to resolve finite choices. -/
def choosePath {d : ℕ} (T : ProbabilityTree X d) : T.Path := Classical.choice (pathNonempty T)

@[simp] theorem pathLabels_length {d : ℕ} (T : ProbabilityTree X d) (p : T.Path) :
    (T.pathLabels p).length = d := by
  induction T with
  | leaf => rfl
  | @node d B inst law positive label child ih =>
      rcases p with ⟨b, p⟩
      simpa [pathLabels] using congrArg Nat.succ (ih b p)

section Labels

variable [DecidableEq X]

theorem label_subset_support {d : ℕ} {B : Type} [Fintype B]
    (law : FiniteLaw B) (positive : law.IsPositive) (label : B → Finset X)
    (child : B → ProbabilityTree X d) (b : B) :
    label b ⊆ (node B law positive label child).support := by
  intro x hx
  exact Finset.mem_biUnion.mpr ⟨b, Finset.mem_univ b, Finset.mem_union_left _ hx⟩

theorem child_support_subset {d : ℕ} {B : Type} [Fintype B]
    (law : FiniteLaw B) (positive : law.IsPositive) (label : B → Finset X)
    (child : B → ProbabilityTree X d) (b : B) :
    (child b).support ⊆ (node B law positive label child).support := by
  intro x hx
  exact Finset.mem_biUnion.mpr ⟨b, Finset.mem_univ b, Finset.mem_union_right _ hx⟩

theorem labels_support_subset {d : ℕ} {B : Type} [Fintype B]
    (law : FiniteLaw B) (positive : law.IsPositive) (label : B → Finset X)
    (child : B → ProbabilityTree X d) :
    (Finset.univ.biUnion label) ⊆ (node B law positive label child).support := by
  intro x hx
  obtain ⟨b, _, hxb⟩ := Finset.mem_biUnion.mp hx
  exact label_subset_support law positive label child b hxb

theorem child_dependsOutside {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).IsDisjoint) (b : B)
    {β : Type*} {f : Finset X → β} (hf : DependsOnlyOn (child b).support f) :
    DependsOutside (label b) f :=
  hf.dependsOutside (hT.1 b)

end Labels

end ProbabilityTree

end LeanBlast.SecondKahnKalai

end

end OAI