import OAI.Probability.CriticalZ3.RelayProbability

namespace OAI

universe uD uV

open _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical Filter Topology

open scoped ENNReal BigOperators Matrix

/-! Finite balanced directed boundaries admit closed edge-simple trails.
This is used only for the planar contour dependency of the main proof. -/
open Classical Function
namespace FiniteTrails
variable {D : Type uD} {V : Type uV} [Fintype D]

noncomputable def successor (tail head : D → V)
    (hbal : ∀ v, Fintype.card {d // head d = v} = Fintype.card {d // tail d = v}) :
    Equiv.Perm D :=
  (Equiv.sigmaFiberEquiv head).symm.trans
    ((Equiv.sigmaCongrRight (fun v => Fintype.equivOfCardEq (hbal v))).trans
      (Equiv.sigmaFiberEquiv tail))

theorem successor_tail (tail head : D → V)
    (hbal : ∀ v, Fintype.card {d // head d = v} = Fintype.card {d // tail d = v})
    (d : D) : tail (successor tail head hbal d) = head d := by
  exact (Fintype.equivOfCardEq (hbal (head d)) ⟨d,rfl⟩).property

/-- Some cycle class has nonzero weight whenever the total weight does. -/
theorem exists_cycle_nonzero (σ : Equiv.Perm D) (w : D → ℤ)
    (hw : ∑ d, w d ≠ 0) :
    ∃ d, (∑ e : D, if σ.SameCycle d e then w e else 0) ≠ 0 := by
  let Q := Quotient (Equiv.Perm.SameCycle.setoid σ)
  let q : D → Q := Quotient.mk _
  have hs : ∑ c : Q, (∑ e : D, if q e = c then w e else 0) = ∑ e, w e := by
    calc
      _ = ∑ e : D, ∑ c : Q, if q e = c then w e else 0 := Finset.sum_comm
      _ = _ := by
        apply Finset.sum_congr rfl
        intro e _
        exact (Finset.sum_ite_eq Finset.univ (q e) (fun _ => w e)).trans (ite_eq_left (Finset.mem_univ _))
  by_contra! h
  have hz : (∑ c : Q, ∑ e : D, if q e = c then w e else 0) = 0 := by
    apply Finset.sum_eq_zero
    intro c _
    obtain ⟨d,rfl⟩ := Quotient.exists_rep c
    convert h d using 1
    apply Finset.sum_congr rfl
    intro e _
    have he : q e = Quotient.mk (Equiv.Perm.SameCycle.setoid σ) d ↔ σ.SameCycle d e := by
      rw [Quotient.eq]
      exact Equiv.Perm.sameCycle_comm
    simp only [he]
  exact hw (hs.symm.trans hz)

theorem period_pos (σ : Equiv.Perm D) (d : D) : 0 < minimalPeriod σ d :=
  minimalPeriod_pos_of_mem_periodicPts (σ.injective.mem_periodicPts d)

noncomputable def cycleEquiv (σ : Equiv.Perm D) (d : D) :
    Fin (minimalPeriod σ d) ≃ {e // σ.SameCycle d e} := by
  let f : Fin (minimalPeriod σ d) → {e // σ.SameCycle d e} := fun i =>
    ⟨σ^[i.val] d,by
      rw [←Equiv.Perm.coe_pow]
      exact Equiv.Perm.SameCycle.rfl.pow_right⟩
  apply Equiv.ofBijective f
  constructor
  · intro i j hij
    apply Fin.ext
    exact (iterate_eq_iterate_iff_of_lt_minimalPeriod i.isLt j.isLt).mp (congrArg Subtype.val hij)
  · intro e
    obtain ⟨k,hk⟩ := e.property.exists_nat_pow_eq
    refine ⟨⟨k % minimalPeriod σ d,Nat.mod_lt _ (period_pos σ d)⟩,?_⟩
    apply Subtype.ext
    change σ^[k % minimalPeriod σ d] d = e.val
    rw [iterate_mod_minimalPeriod_eq,←Equiv.Perm.coe_pow]
    exact hk

def next {n : ℕ} (hn : 0 < n) (i : Fin n) : Fin n :=
  ⟨(i.val+1)%n,Nat.mod_lt _ hn⟩

/-- A closed trail has distinct edges and retains the nonzero marked crossing sum. -/
theorem exists_closed_trail (tail head : D → V)
    (hbal : ∀ v, Fintype.card {d // head d = v} = Fintype.card {d // tail d = v})
    (w : D → ℤ) (hw : ∑ d, w d ≠ 0) :
    ∃ n : ℕ, ∃ hn : 0 < n, ∃ e : Fin n → D, Function.Injective e ∧
      (∀ i : Fin n, tail (e (next hn i)) = head (e i)) ∧ (∑ i, w (e i)) ≠ 0 := by
  let σ := successor tail head hbal
  obtain ⟨d,hd⟩ := exists_cycle_nonzero σ w hw
  let n := minimalPeriod σ d
  have hn : 0 < n := period_pos σ d
  let e : Fin n → D := fun i => σ^[i.val] d
  refine ⟨n,hn,e,?_,?_,?_⟩
  · intro i j hij
    apply Fin.ext
    exact (iterate_eq_iterate_iff_of_lt_minimalPeriod i.isLt j.isLt).mp hij
  · intro i
    have he : e (next hn i) = σ (e i) := by
      change σ^[(i.val+1)%n] d = σ (σ^[i.val] d)
      rw [iterate_mod_minimalPeriod_eq,Function.iterate_succ_apply']
    rw [he]
    exact successor_tail tail head hbal (e i)
  · have hs := (cycleEquiv σ d).sum_comp (fun z : {e // σ.SameCycle d e} => w z.val)
    have ht : (∑ z : {e // σ.SameCycle d e}, w z.val) =
        ∑ e : D, if σ.SameCycle d e then w e else 0 := by
      rw [←Finset.sum_filter]; exact (Finset.sum_subtype _ (by simp) w).symm
    rw [ht] at hs
    exact hs.symm ▸ hd

end FiniteTrails

end OAI