import Mathlib
import OAI.Probability.BinarySweep.Processes.IndependentHistory
import OAI.Probability.BinarySweep.Representations.IrrepSupport
import OAI.Probability.BinarySweep.FiniteLaws.SumDite

namespace OAI

noncomputable section
open scoped BigOperators

namespace BinaryCoordinateSweeps
attribute [local instance] Classical.propDecidable

instance oneAxisOutsideEmpty : IsEmpty {i : Fin 1 // i ≠ 0} :=
  ⟨fun i => i.property (Subsingleton.elim _ _)⟩

noncomputable def oneAxisSlotEquiv (bits : Fin 1 → ℕ) : GridSlot bits ≃ Slot (bits 0) :=
  Equiv.piUnique _
noncomputable def oneAxisChoiceEquiv (bits : Fin 1 → ℕ) :
    GridChoices bits ≃ Equiv.Perm (Slot (bits 0)) :=
  (Equiv.piUnique _).trans (Equiv.funUnique _ _)
noncomputable def oneAxisSweepEquiv (bits : Fin 1 → ℕ) :
    GridChoices bits ≃ Equiv.Perm (GridSlot bits) :=
  (oneAxisChoiceEquiv bits).trans ((oneAxisSlotEquiv bits).symm.permCongr)

lemma oneAxisSweepEquiv_apply (bits : Fin 1 → ℕ) (g : GridChoices bits) :
    oneAxisSweepEquiv bits g = gridSweep bits g := by
  apply Equiv.ext
  intro x
  funext i
  have hi : i = 0 := Subsingleton.elim _ _
  subst i
  simp only [gridSweep, List.ofFn_succ, List.ofFn_zero, List.reverse_cons,
    List.reverse_nil, List.nil_append, List.prod_cons, List.prod_nil, mul_one]
  change _ = gridLayer bits g 0 x 0
  simp only [oneAxisSweepEquiv, oneAxisChoiceEquiv, oneAxisSlotEquiv, Equiv.trans_apply,
    Equiv.permCongr_apply, Equiv.piUnique_apply,
    Equiv.funUnique_apply, gridLayer, Equiv.piSplitAt_apply, Equiv.prodCongrLeft_apply,
    Equiv.piSplitAt_symm_apply, dite_true, eq_self]
  simp only [Equiv.symm_symm, Equiv.piUnique_symm_apply, Equiv.piUnique_apply]
  have aux (y : GridOutside bits default) (i : Fin 1) :
      uniqueElim (α := fun j => Slot (bits j)) ((g default y) (x default)) i =
      (g i (fun j => x j.val)) (x i) := by
    obtain rfl := Unique.eq_default i
    rw [uniqueElim_default]
    apply congrArg (fun y : GridOutside bits default => g default y (x default))
    funext j
    exact (j.property (Subsingleton.elim _ _)).elim
  exact aux _ 0

lemma oneAxis_pathEvent_iff {h : ℕ} {bits : Fin 1 → ℕ} (H : PathFamily bits h)
    (g : GridChoices bits) : pathEvent H g ↔
      ∀ k, gridSweep bits g (H.position 0 k) = H.position (Fin.last 1) k := by
  constructor
  · exact fun hg k => gridSweep_path H g hg k
  · intro hg j k
    have hj : j = 0 := Subsingleton.elim _ _
    subst j
    simpa [gridSweep, List.ofFn_succ] using hg k

def assignmentResidualEquiv {X I : Type*} [Fintype X] [Fintype I]
    (A B : I ↪ X) (c : {x : X // x ∉ Set.range A} ≃ {x : X // x ∉ Set.range B}) :
    {σ : Equiv.Perm X // Assigns A B σ} ≃ Equiv.Perm {x : X // x ∉ Set.range A} := by
  classical
  let eA := Equiv.ofInjective A A.injective
  let eB := Equiv.ofInjective B B.injective
  let e₀ : Set.range A ≃ Set.range B := eA.symm.trans eB
  let e : {σ : Equiv.Perm X // Assigns A B σ} ≃
      {σ : X ≃ X // ∀ x : Set.range A, σ x = e₀ x} :=
    Equiv.subtypeEquiv (Equiv.refl _) (by
      intro σ
      constructor
      · intro hs x
        obtain ⟨i, hi⟩ := x.property
        have hx : x = eA i := Subtype.ext hi.symm
        rw [hx]
        simpa [e₀, eA, eB] using hs i
      · intro hs i
        simpa [e₀, eA, eB] using hs (eA i))
  exact (e.trans (Equiv.Set.compl e₀)).trans (Equiv.equivCongr (Equiv.refl _) c.symm)

lemma assignmentResidualEquiv_apply {X I : Type*} [Fintype X] [Fintype I]
    (A B : I ↪ X) (c : {x : X // x ∉ Set.range A} ≃ {x : X // x ∉ Set.range B})
    (σ : {σ : Equiv.Perm X // Assigns A B σ}) (x : {x : X // x ∉ Set.range A}) :
    (c (assignmentResidualEquiv A B c σ x)).val = σ.val x := by
  simp [assignmentResidualEquiv, Equiv.equivCongr, Equiv.Set.compl]
  rfl

def oneAxisRemainingEquiv {h : ℕ} {bits : Fin 1 → ℕ} (H : PathFamily bits h) :
    {g : GridChoices bits // pathEvent H g} ≃ Equiv.Perm (FreeSlot H 0) := by
  let A : Fin h ↪ GridSlot bits := ⟨H.position 0, H.disjoint 0⟩
  let B : Fin h ↪ GridSlot bits := ⟨H.position (Fin.last 1), H.disjoint _⟩
  exact (Equiv.subtypeEquiv (oneAxisSweepEquiv bits) (by
    intro g
    simpa only [Assigns, oneAxisSweepEquiv_apply, A, B, Function.Embedding.coeFn_mk] using oneAxis_pathEvent_iff H g)).trans
      (assignmentResidualEquiv A B (freeIdentification H))

lemma oneAxisRemainingEquiv_apply {h : ℕ} {bits : Fin 1 → ℕ} (H : PathFamily bits h)
    (g : {g : GridChoices bits // pathEvent H g}) :
    oneAxisRemainingEquiv H g = remainingPerm H g.val g.property := by
  apply Equiv.ext
  intro x
  apply (freeIdentification H).injective
  apply Subtype.ext
  have he := assignmentResidualEquiv_apply
    (⟨H.position 0, H.disjoint 0⟩ : Fin h ↪ GridSlot bits)
    (⟨H.position (Fin.last 1), H.disjoint _⟩ : Fin h ↪ GridSlot bits)
    (freeIdentification H)
    ((Equiv.subtypeEquiv (oneAxisSweepEquiv bits) (by
      intro g
      simpa only [Assigns, oneAxisSweepEquiv_apply, Function.Embedding.coeFn_mk] using oneAxis_pathEvent_iff H g)) g) x
  simpa only [oneAxisRemainingEquiv, Equiv.trans_apply, Equiv.subtypeEquiv_apply,
    oneAxisSweepEquiv_apply, remainingPerm, Equiv.apply_symm_apply, remainingBijection,
    Equiv.coe_fn_mk] using he

lemma oneAxis_gridWeight (bits : Fin 1 → ℕ) (z : ℝ) (g : GridChoices bits) :
    gridWeight bits z g = lineLaw (bits 0) z (oneAxisChoiceEquiv bits g) := by
  simp [gridWeight, oneAxisChoiceEquiv, Equiv.piUnique, Equiv.funUnique]

lemma oneAxis_gridWeight_zero (bits : Fin 1 → ℕ) (g : GridChoices bits) :
    gridWeight bits 0 g = (Fintype.card (Equiv.Perm (GridSlot bits)) : ℝ)⁻¹ := by
  rw [oneAxis_gridWeight]
  simp only [lineLaw, sub_zero, one_mul, zero_mul, add_zero, uniformLaw]
  congr 2
  exact Fintype.card_congr (oneAxisSlotEquiv bits).symm.permCongr

lemma oneAxis_conditionalOperator_zero {h D : ℕ} {bits : Fin 1 → ℕ}
    (H : PathFamily bits h)
    (ρ : Representation ℂ (Equiv.Perm (FreeSlot H 0)) (RepSpace D))
    [ρ.IsIrreducible] (hD : 1 < D) : conditionalOperator H 0 ρ = 0 := by
  have hdim : 1 < Module.finrank ℂ (RepSpace D) := by simpa using hD
  have hsum := Irrep.sum_eq_zero_of_finrank_gt_one ρ hdim
  have hperm : (∑ g : {g : GridChoices bits // pathEvent H g},
      ρ (remainingPerm H g.val g.property)) = 0 := by
    calc
      _ = ∑ g : {g : GridChoices bits // pathEvent H g}, ρ (oneAxisRemainingEquiv H g) := by
        simp only [oneAxisRemainingEquiv_apply]
      _ = 0 := ((oneAxisRemainingEquiv H).sum_comp (fun σ => ρ σ)).trans hsum
  unfold conditionalOperator
  have he : (∑ g : GridChoices bits, if hg : pathEvent H g then
      (gridWeight bits 0 g : ℂ) • ρ (remainingPerm H g hg) else 0) = 0 := by
    rw [sum_dite_zero]
    simp only [oneAxis_gridWeight_zero, ← Finset.smul_sum]
    apply smul_eq_zero.mpr
    right
    convert hperm using 1
  rw [he, smul_zero]
  rfl

end BinaryCoordinateSweeps

end

end OAI