import Mathlib
import OAI.Probability.BinarySweep.GridBounds.GroupedMoments
import OAI.Probability.BinarySweep.GridBounds.GroupingGeometry
import OAI.Probability.BinarySweep.GridBounds.GridSplitFree
import OAI.Probability.BinarySweep.FiniteLaws.IndependentPush

namespace OAI

noncomputable section

section

open scoped BigOperators Classical

namespace BinaryCoordinateSweeps
open Irrep Representation

lemma finitePush_conditional {b h : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h)
    (z : ℝ) (a : Equiv.Perm (FreeSlot H 0)) :
    finitePush (fun g : ConditionalChoices H => (conditionalChoiceWeight H z g:ℂ))
      (fun g => remainingPerm H g.val g.property) a = (conditionalGroupLaw H z a:ℂ) := by
  simp only [finitePush,conditionalGroupLaw,Complex.ofReal_sum,apply_ite,Complex.ofReal_zero]

lemma independentConditional_expectation {I : Type*} [Fintype I]
    (b h : I → ℕ) (bits : ∀i, Fin (b i) → ℕ) (H : ∀i, PathFamily (bits i) (h i))
    {V : Type*} [AddCommMonoid V] [Module ℂ V] (z : ℝ)
    (F : (∀i, Equiv.Perm (FreeSlot (H i) 0)) → V) :
    (∑a, (∏i, (conditionalGroupLaw (H i) z (a i):ℂ)) • F a) =
      ∑g : ∀i, ConditionalChoices (H i),
        (∏i, (conditionalChoiceWeight (H i) z (g i):ℂ)) •
          F (fun i => remainingPerm (H i) (g i).val (g i).property) := by
  have he := independentPush_expectation
    (fun i (g : ConditionalChoices (H i)) => (conditionalChoiceWeight (H i) z g:ℂ))
    (fun i (g : ConditionalChoices (H i)) => remainingPerm (H i) g.val g.property) F
  simpa only [finitePush_conditional] using he

private lemma sigma_relative {I X Y : Type*} {A B : I → Type*}
    (e : X ≃ Σ i, A i) (f : Y ≃ Σ i, B i) (g r : ∀ i, A i ≃ B i) :
    (e.trans ((Equiv.sigmaCongrRight g).trans f.symm)).trans
      (e.trans ((Equiv.sigmaCongrRight r).trans f.symm)).symm =
      e.symm.permCongr (Equiv.Perm.sigmaCongrRight (fun i => (g i).trans (r i).symm)) := by
  ext x
  simp [Equiv.permCongr_apply, Equiv.sigmaCongrRight, Equiv.Perm.sigmaCongrRight]

namespace GridSplit
variable {m n h : ℕ} (bits : Fin (m+n) → ℕ) (H : PathFamily bits h)

def rowInputEquiv : FreeSlot H 0 ≃
    Σy : GridSlot (rightBits bits), FreeSlot (rowFamily bits H y) 0 := rowFreeEquiv bits H 0

lemma rowRelative_sigma (g : RowSamples bits H) :
    rowRelative bits H g = (rowInputEquiv bits H).symm.permCongr
      (Equiv.Perm.sigmaCongrRight (fun y =>
        remainingPerm (rowFamily bits H y) (g y).val (g y).property)) := by
  exact sigma_relative (rowFreeEquiv bits H 0) (rowFreeEquiv bits H (Fin.last m))
    (fun y => remainingBijection (rowFamily bits H y) (g y).val (g y).property)
    (fun y => freeIdentification (rowFamily bits H y))

lemma columnRelative_sigma (g : ColumnSamples bits H) :
    columnRelative bits H g = (columnFreeEquiv bits H 0).symm.permCongr
      (Equiv.Perm.sigmaCongrRight (fun x =>
        remainingPerm (columnFamily bits H x) (g x).val (g x).property)) := by
  exact sigma_relative (columnFreeEquiv bits H 0) (columnFreeEquiv bits H (Fin.last n))
    (fun x => remainingBijection (columnFamily bits H x) (g x).val (g x).property)
    (fun x => freeIdentification (columnFamily bits H x))

variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V] [FiniteDimensional ℂ V]
  (ρ : Representation ℂ (Equiv.Perm (FreeSlot H 0)) V)

omit [FiniteDimensional ℂ V] in
theorem rowAverage_child_laws (z : ℝ) :
    rowAverage bits H ρ z =
      ∑a : ∀y, Equiv.Perm (FreeSlot (rowFamily bits H y) 0),
        (∏y, (conditionalGroupLaw (rowFamily bits H y) z (a y):ℂ)) •
          ρ ((rowInputEquiv bits H).symm.permCongr (Equiv.Perm.sigmaCongrRight a)) := by
  trans ∑g : RowSamples bits H,
    (∏y, (conditionalChoiceWeight (rowFamily bits H y) z (g y):ℂ)) •
      ρ ((rowInputEquiv bits H).symm.permCongr (Equiv.Perm.sigmaCongrRight
        (fun y => remainingPerm (rowFamily bits H y) (g y).val (g y).property)))
  · unfold rowAverage
    apply Finset.sum_congr rfl
    intro g _
    rw [rowRelative_sigma]
  · let F : (∀y, Equiv.Perm (FreeSlot (rowFamily bits H y) 0)) → Module.End ℂ V :=
      fun a => ρ ((rowInputEquiv bits H).symm.permCongr (Equiv.Perm.sigmaCongrRight a))
    have he := independentConditional_expectation (I := GridSlot (rightBits bits)) (fun _ => m)
      (fun y => Fintype.card (RowLabels bits H y)) (fun _ => leftBits bits) (rowFamily bits H) z
      F
    apply Eq.symm
    refine Eq.trans ?_ (Eq.trans he ?_)
    all_goals
      apply Finset.sum_congr
      · ext g; simp only [Finset.mem_univ]
      · intro g _; rfl

omit [FiniteDimensional ℂ V] in
theorem columnAverage_child_laws (z : ℝ) :
    columnAverage bits H ρ z =
      ∑a : ∀x, Equiv.Perm (FreeSlot (columnFamily bits H x) 0),
        (∏x, (conditionalGroupLaw (columnFamily bits H x) z (a x):ℂ)) •
          ρ ((rowReference bits H).symm.permCongr
            ((columnFreeEquiv bits H 0).symm.permCongr (Equiv.Perm.sigmaCongrRight a))) := by
  trans ∑g : ColumnSamples bits H,
    (∏x, (conditionalChoiceWeight (columnFamily bits H x) z (g x):ℂ)) •
      ρ ((rowReference bits H).symm.permCongr
        ((columnFreeEquiv bits H 0).symm.permCongr (Equiv.Perm.sigmaCongrRight
          (fun x => remainingPerm (columnFamily bits H x) (g x).val (g x).property))))
  · unfold columnAverage
    apply Finset.sum_congr rfl
    intro g _
    rw [columnRelative_sigma]
  · let F : (∀x, Equiv.Perm (FreeSlot (columnFamily bits H x) 0)) → Module.End ℂ V :=
      fun a => ρ ((rowReference bits H).symm.permCongr
        ((columnFreeEquiv bits H 0).symm.permCongr (Equiv.Perm.sigmaCongrRight a)))
    have he := independentConditional_expectation (I := GridSlot (leftBits bits)) (fun _ => n)
      (fun x => Fintype.card (ColumnLabels bits H x)) (fun _ => rightBits bits) (columnFamily bits H) z
      F
    apply Eq.symm
    refine Eq.trans ?_ (Eq.trans he ?_)
    all_goals
      apply Finset.sum_congr
      · ext g; simp only [Finset.mem_univ]
      · intro g _; rfl

end GridSplit
end BinaryCoordinateSweeps

namespace BinaryCoordinateSweeps.GridSplit
open Signed

variable {m n h : ℕ} (bits : Fin (m+n) → ℕ) (H : PathFamily bits h)

local instance rowOrder : LinearOrder (GridSlot (rightBits bits)) :=
  LinearOrder.lift' (Fintype.equivFin _) (Fintype.equivFin _).injective
local instance columnOrder : LinearOrder (GridSlot (leftBits bits)) :=
  LinearOrder.lift' (Fintype.equivFin _) (Fintype.equivFin _).injective

abbrev Junction := FreeSlot H (rightTime (m:=m) 0)
abbrev junctionSize := Fintype.card (Junction bits H)

def junctionEnum : Junction bits H ≃ Fin (junctionSize bits H) := Fintype.equivFin _

def physicalBoard : Fin (junctionSize bits H) ↪
    GridSlot (rightBits bits) × GridSlot (leftBits bits) where
  toFun t := (rightSlot bits ((junctionEnum bits H).symm t).val,
    leftSlot bits ((junctionEnum bits H).symm t).val)
  inj' := by
    intro t u he
    apply (junctionEnum bits H).symm.injective
    apply Subtype.ext
    apply (slotEquiv bits).injective
    exact Prod.ext (congrArg Prod.snd he) (congrArg Prod.fst he)

def rowGrouping : (Σy : GridSlot (rightBits bits), FreeSlot (rowFamily bits H y) 0) ≃
    Fin (junctionSize bits H) :=
  (rowInputEquiv bits H).symm.trans ((rowReference bits H).trans (junctionEnum bits H))

def columnGrouping : (Σx : GridSlot (leftBits bits), FreeSlot (columnFamily bits H x) 0) ≃
    Fin (junctionSize bits H) :=
  (columnFreeEquiv bits H 0).symm.trans (junctionEnum bits H)

lemma rowReference_right (a : FreeSlot H 0) :
    rightSlot bits (rowReference bits H a).val=rightSlot bits a.val := by
  exact right_join bits _ _

lemma rowGrouping_first (t : Fin (junctionSize bits H)) :
    ((rowGrouping bits H).symm t).1=(physicalBoard bits H t).1 := by
  change rightSlot bits ((rowReference bits H).symm ((junctionEnum bits H).symm t)).val =
    rightSlot bits ((junctionEnum bits H).symm t).val
  symm
  simpa only [Equiv.apply_symm_apply] using
    rowReference_right bits H ((rowReference bits H).symm ((junctionEnum bits H).symm t))

lemma columnGrouping_first (t : Fin (junctionSize bits H)) :
    ((columnGrouping bits H).symm t).1=(physicalBoard bits H t).2 := rfl

lemma physicalBoard_row (t : Fin (junctionSize bits H)) :
    groupOf (groupingOrder (rowGrouping bits H)) (groupingPerm (rowGrouping bits H)) t=
      (physicalBoard bits H t).1 := by
  rw [grouping_groupOf,rowGrouping_first]

lemma physicalBoard_column (t : Fin (junctionSize bits H)) :
    groupOf (groupingOrder (columnGrouping bits H)) (groupingPerm (columnGrouping bits H)) t=
      (physicalBoard bits H t).2 := by
  rw [grouping_groupOf,columnGrouping_first]

lemma junctionSize_eq : junctionSize bits H=gridSize bits-h := by
  exact card_freeSlot H _

end BinaryCoordinateSweeps.GridSplit

end

open scoped BigOperators Classical

namespace BinaryCoordinateSweeps.Signed
variable {I A : Type*} [Fintype I] [LinearOrder I] [Fintype A] [DecidableEq A]
  {X : I → Type*} [∀i,Fintype (X i)] {N : ℕ}

def finBlockPermEquiv : (∀i, Equiv.Perm (X i)) ≃
    (∀i, Equiv.Perm (Fin (Fintype.card (X i)))) :=
  Equiv.piCongrRight (fun i => (Fintype.equivFin (X i)).permCongr)

theorem groupedAverage_literal (e : (Σi, X i) ≃ Fin N) (p : A → Bool)
    (w : ∀i, Equiv.Perm (X i) → ℂ) :
    groupedAverage (groupingOrder e) (groupingPerm e) p
      (fun i a => w i ((Fintype.equivFin (X i)).symm.permCongr a)) =
      ∑a : ∀i, Equiv.Perm (X i), (∏i, w i (a i)) •
        actionMatrix p (e.permCongr (Equiv.Perm.sigmaCongrRight a)) := by
  rw [groupedAverage_law,← (finBlockPermEquiv (X:=X)).sum_comp]
  apply Finset.sum_congr rfl
  intro a _
  rw [grouping_permutation]
  have he (i : I) : (Fintype.equivFin (X i)).symm.permCongr
      (finBlockPermEquiv a i)=a i := by
    ext x
    simp [finBlockPermEquiv,Equiv.permCongr_apply]
  simp only [he]
  rfl

lemma groupedAverage_literal_linear (e : (Σi, X i) ≃ Fin N) (p : A → Bool)
    (w : ∀i, Equiv.Perm (X i) → ℂ) :
    (groupedAverage (groupingOrder e) (groupingPerm e) p
      (fun i a => w i ((Fintype.equivFin (X i)).symm.permCongr a))).toEuclideanLin =
      ∑a : ∀i, Equiv.Perm (X i), (∏i, w i (a i)) •
        hilbertTensorRep p N (e.permCongr (Equiv.Perm.sigmaCongrRight a)) := by
  rw [groupedAverage_literal]
  simp only [map_sum,map_smul,actionMatrix_linear]

end BinaryCoordinateSweeps.Signed

end

end OAI