import Mathlib
import OAI.Probability.BinarySweep.Processes.CoordinateLayerEdgeSwap

namespace OAI

noncomputable section
open scoped BigOperators

namespace BinaryCoordinateSweeps

lemma gridSweep_path {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h)
    (g : GridChoices bits) (hg : pathEvent H g) (k : Fin h) :
    gridSweep bits g (H.position 0 k) = H.position (Fin.last b) k :=
  chronological_trajectory b (gridLayer bits g) (fun t => H.position t k) (fun j => hg j k)

abbrev FreeSlot {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h)
    (t : Fin (b + 1)) := {x : GridSlot bits // x ∉ Set.range (H.position t)}

instance freeSlotFintype {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h)
    (t : Fin (b + 1)) : Fintype (FreeSlot H t) := Fintype.ofFinite _

lemma card_freeSlot {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h)
    (t : Fin (b + 1)) : Fintype.card (FreeSlot H t) = gridSize bits - h := by
  classical
  rw [show Fintype.card (FreeSlot H t) =
    Fintype.card (GridSlot bits) - Fintype.card (Set.range (H.position t)) from
      Fintype.card_subtype_compl (fun x => x ∈ Set.range (H.position t))]
  rw [card_gridSlot]
  have hr : Fintype.card (Set.range (H.position t)) = h := by
    let e : Fin h ↪ GridSlot bits := ⟨H.position t, H.disjoint t⟩
    simpa [e] using Fintype.card_range e
  rw [hr]

def freeIdentification {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h) :
    FreeSlot H 0 ≃ FreeSlot H (Fin.last b) :=
  Fintype.equivOfCardEq (by rw [card_freeSlot, card_freeSlot])

def remainingBijection {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h)
    (g : GridChoices bits) (hg : pathEvent H g) :
    FreeSlot H 0 ≃ FreeSlot H (Fin.last b) where
  toFun x := ⟨gridSweep bits g x, by
    rintro ⟨k, hk⟩
    exact x.property ⟨k, (gridSweep bits g).injective ((gridSweep_path H g hg k).trans hk)⟩⟩
  invFun y := ⟨(gridSweep bits g).symm y, by
    rintro ⟨k, hk⟩
    apply y.property
    refine ⟨k, ?_⟩
    rw [← gridSweep_path H g hg k, hk]
    exact (gridSweep bits g).apply_symm_apply y⟩
  left_inv x := by apply Subtype.ext; exact (gridSweep bits g).symm_apply_apply x
  right_inv y := by apply Subtype.ext; exact (gridSweep bits g).apply_symm_apply y

def remainingPerm {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h)
    (g : GridChoices bits) (hg : pathEvent H g) : Equiv.Perm (FreeSlot H 0) :=
  (remainingBijection H g hg).trans (freeIdentification H).symm

def conditionalNormalizer {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h)
    (z : ℝ) : ℝ := by
  classical
  exact ∑ g : GridChoices bits, if pathEvent H g then gridWeight bits z g else 0

def conditionalOperator {b h D : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h)
    (z : ℝ) (ρ : Representation ℂ (Equiv.Perm (FreeSlot H 0)) (RepSpace D)) :
    RepSpace D →L[ℂ] RepSpace D := by
  classical
  exact LinearMap.toContinuousLinearMap
    ((conditionalNormalizer H z : ℂ)⁻¹ • ∑ g : GridChoices bits,
      if hg : pathEvent H g then (gridWeight bits z g : ℂ) • ρ (remainingPerm H g hg)
      else 0)

def lineHoles {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h)
    (j : Fin b) (y : GridOutside bits j) : ℕ := by
  classical
  exact Fintype.card {k : Fin h // (fun i : {i : Fin b // i ≠ j} =>
    H.position j.castSucc k i) = y}

def pathCost {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h) : ℝ :=
  ∑ j, ∑ y : GridOutside bits j,
    Real.log (((2 ^ bits j : ℕ) : ℝ) ^ lineHoles H j y /
      (Nat.descFactorial (2 ^ bits j) (lineHoles H j y) : ℝ))

def ConditionalMomentTarget : Prop :=
  ∃ r : ℕ, 0 < r ∧ ∃ q : ℕ, 0 < q ∧ ∃ zStar : ℝ, 0 < zStar ∧
    ∀ b : ℕ, 1 ≤ b → ∀ bits : Fin b → ℕ, (∀ j, r ≤ bits j ∧ bits j ≤ 2 * r) →
    ∀ h : ℕ, ∀ H : PathFamily bits h, ∀ z : ℝ, 0 ≤ z → z ≤ zStar →
    ∀ D : ℕ, ∀ ρ : Representation ℂ (Equiv.Perm (FreeSlot H 0)) (RepSpace D),
      ρ.IsIrreducible → IsUnitaryRep ρ →
      logMoment (traceMoment q (conditionalOperator H z ρ)) ≤
        ((-cExponent (gridSize bits) * Real.log D +
          eExponent (gridSize bits) * h * Real.log (gridSize bits) - pathCost H : ℝ) : EReal)

theorem pathEvent_nonempty {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h) :
    ∃ g : GridChoices bits, pathEvent H g := by
  classical
  let A (j : Fin b) (y : GridOutside bits j) :=
    {k : Fin h // (fun i : {i : Fin b // i ≠ j} => H.position j.castSucc k i) = y}
  have hp (j : Fin b) (y : GridOutside bits j) :
      ∃ σ : Equiv.Perm (Slot (bits j)), ∀ k : A j y,
        σ (H.position j.castSucc k.val j) = H.position j.succ k.val j := by
    apply Equiv.Perm.exists_extending_pair
    · intro k l he
      apply Subtype.ext
      apply H.disjoint j.castSucc
      funext i
      by_cases hi : i = j
      · subst i; exact he
      · exact (congrFun k.property ⟨i, hi⟩).trans (congrFun l.property ⟨i, hi⟩).symm
    · intro k l he
      apply Subtype.ext
      apply H.disjoint j.succ
      funext i
      by_cases hi : i = j
      · subst i; exact he
      · rw [H.changes_only_stage j k.val i hi, H.changes_only_stage j l.val i hi]
        exact (congrFun k.property ⟨i, hi⟩).trans (congrFun l.property ⟨i, hi⟩).symm
  choose g hg using hp
  refine ⟨g, ?_⟩
  intro j k
  apply (Equiv.piSplitAt j (fun i => Slot (bits i))).injective
  simp only [gridLayer, Equiv.trans_apply, Equiv.apply_symm_apply,
    Equiv.piSplitAt_apply, Equiv.prodCongrLeft_apply]
  apply Prod.ext
  · exact hg j _ ⟨k, rfl⟩
  · funext i
    exact (H.changes_only_stage j k i.val i.property).symm

lemma lineLaw_pos (d : ℕ) {z : ℝ} (hz : 0 ≤ z) (hz1 : z < 1)
    (g : Equiv.Perm (Slot d)) : 0 < lineLaw d z g := by
  have hu : 0 < uniformLaw (Equiv.Perm (Slot d)) g := by
    unfold uniformLaw
    have hc : (0 : ℝ) < Fintype.card (Equiv.Perm (Slot d)) := by exact_mod_cast Fintype.card_pos
    exact inv_pos.mpr hc
  exact add_pos_of_pos_of_nonneg (mul_pos (sub_pos.mpr hz1) hu)
    (mul_nonneg hz (finiteLaw_nonneg (binarySweep d) g))

lemma lineLaw_sum (d : ℕ) (z : ℝ) : ∑ g, lineLaw d z g = 1 := by
  simp only [lineLaw, Finset.sum_add_distrib, ← Finset.mul_sum,
    uniformLaw_sum, binaryLaw, finiteLaw_sum]
  ring

lemma gridWeight_pos {b : ℕ} (bits : Fin b → ℕ) {z : ℝ} (hz : 0 ≤ z) (hz1 : z < 1)
    (g : GridChoices bits) : 0 < gridWeight bits z g := by
  apply Finset.prod_pos
  intro j _
  exact Finset.prod_pos (fun y _ => lineLaw_pos (bits j) hz hz1 (g j y))

lemma gridWeight_sum {b : ℕ} (bits : Fin b → ℕ) (z : ℝ) :
    ∑ g : GridChoices bits, gridWeight bits z g = 1 := by
  classical
  unfold gridWeight
  rw [← Fintype.prod_sum (fun (j : Fin b)
    (g : GridOutside bits j → Equiv.Perm (Slot (bits j))) => ∏ y, lineLaw (bits j) z (g y))]
  have hj (j : Fin b) : ∑ g : GridOutside bits j → Equiv.Perm (Slot (bits j)),
      ∏ y, lineLaw (bits j) z (g y) = 1 := by
    rw [← Fintype.prod_sum (fun (_ : GridOutside bits j)
      (g : Equiv.Perm (Slot (bits j))) => lineLaw (bits j) z g)]
    simp [lineLaw_sum]
  simp [hj]

theorem conditionalNormalizer_pos {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h)
    {z : ℝ} (hz : 0 ≤ z) (hz1 : z < 1) : 0 < conditionalNormalizer H z := by
  classical
  obtain ⟨g, hg⟩ := pathEvent_nonempty H
  apply Finset.sum_pos'
  · intro g' _
    split_ifs
    · exact (gridWeight_pos bits hz hz1 g').le
    · exact le_rfl
  · exact ⟨g, Finset.mem_univ _, by simpa [hg] using gridWeight_pos bits hz hz1 g⟩

variable {G : Type*} [Fintype G] [Group G]

lemma uniformLaw_probability : IsProbability (uniformLaw G) :=
  ⟨fun _ => by unfold uniformLaw; positivity, uniformLaw_sum⟩

lemma convolution_sub_left (p q r : G → ℝ) :
    convolution (fun g => p g - q g) r = fun g => convolution p r g - convolution q r g := by
  funext g
  simp [convolution, sub_mul, Finset.sum_sub_distrib]

lemma convolution_smul_left (a : ℝ) (p q : G → ℝ) :
    convolution (fun g => a * p g) q = fun g => a * convolution p q g := by
  funext g
  simp [convolution, mul_assoc, Finset.mul_sum]

lemma convolution_uniform_right_mass (p : G → ℝ) :
    convolution p (uniformLaw G) = fun g => (∑ x, p x) * uniformLaw G g := by
  funext g
  simp [convolution, uniformLaw, Finset.sum_mul]

lemma convolution_minorization {p q : G → ℝ} (hp : IsProbability p) (hq : IsProbability q)
    (δ : ℝ) (hδ : ∀ g, δ * uniformLaw G g ≤ p g) :
    totalVariation (convolution p q) (uniformLaw G) ≤
      (1 - δ) * totalVariation q (uniformLaw G) := by
  let r : G → ℝ := fun g => p g - δ * uniformLaw G g
  have hr : ∀ g, 0 ≤ r g := fun g => sub_nonneg.mpr (hδ g)
  have hmass : ∑ g, r g = 1 - δ := by
    simp [r, Finset.sum_sub_distrib, ← Finset.mul_sum, hp.2, uniformLaw_sum]
  have he : totalVariation (convolution p q) (uniformLaw G) =
      totalVariation (convolution r q) (convolution r (uniformLaw G)) := by
    have hdiff (g : G) : convolution r q g - convolution r (uniformLaw G) g =
        convolution p q g - uniformLaw G g := by
      rw [show r = (fun g => p g - δ * uniformLaw G g) from rfl,
        convolution_sub_left, convolution_smul_left, convolution_uniform_left hq.2]
      rw [← show r = (fun g => p g - δ * uniformLaw G g) from rfl,
        convolution_uniform_right_mass, hmass]
      ring
    simp only [totalVariation, hdiff]
  rw [he]
  simpa only [hmass] using convolution_tv_contract hr q (uniformLaw G)

end BinaryCoordinateSweeps
end

end OAI