import Mathlib
import OAI.Probability.BinarySweep.Representations.FiniteUnitaryAverage

namespace OAI

noncomputable section

section

open scoped BigOperators Classical

namespace BinaryCoordinateSweeps

lemma independent_reverse_product {R : Type*} [Semiring R] {n : ℕ}
    {X : Fin n → Type*} [∀j, Fintype (X j)] (A : (j : Fin n) → X j → R) :
    (List.ofFn (fun j => ∑a, A j a)).reverse.prod=
      ∑f : ∀j, X j, (List.ofFn (fun j => A j (f j))).reverse.prod := by
  induction n with
  | zero => simp
  | succ n ih =>
    rw [List.ofFn_succ,List.reverse_cons,List.prod_append,List.prod_singleton,ih]
    rw [←Equiv.sum_comp (Fin.consEquiv X),Fintype.sum_prod_type]
    rw [Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro a _
    rw [Finset.sum_mul]
    apply Finset.sum_congr rfl
    intro f _
    simp only [Fin.consEquiv,Equiv.coe_fn_mk,List.ofFn_succ,List.reverse_cons,
      List.prod_append,List.prod_singleton,Fin.cons_zero,Fin.cons_succ]

lemma weighted_reverse_product {R : Type*} [Semiring R] [Algebra ℂ R] {n : ℕ}
    (w : Fin n → ℂ) (A : Fin n → R) :
    (List.ofFn (fun j => w j • A j)).reverse.prod=
      (∏j,w j) • (List.ofFn A).reverse.prod := by
  induction n with
  | zero => simp
  | succ n ih =>
    simp only [List.ofFn_succ,List.reverse_cons,List.prod_append,List.prod_singleton,
      Fin.prod_univ_succ]
    rw [ih,smul_mul_smul_comm,mul_comm (∏j : Fin n, w j.succ) (w 0)]

lemma independent_average_product {R : Type*} [Semiring R] [Algebra ℂ R] {n : ℕ}
    {X : Fin n → Type*} [∀j, Fintype (X j)]
    (w : (j : Fin n) → X j → ℂ) (A : (j : Fin n) → X j → R) :
    (∑f : ∀j, X j, (∏j,w j (f j)) •
      (List.ofFn (fun j => A j (f j))).reverse.prod)=
      (List.ofFn (fun j => ∑a, w j a • A j a)).reverse.prod := by
  rw [independent_reverse_product]
  exact Finset.sum_congr rfl (fun f _ => (weighted_reverse_product _ _).symm)

lemma reverse_product_norm_le_one {R : Type*} [NormedRing R] [NormOneClass R]
    {n : ℕ} (A : Fin n → R) (hA : ∀j, ‖A j‖≤1) :
    ‖(List.ofFn A).reverse.prod‖≤1 := by
  induction n with
  | zero => simp
  | succ n ih =>
    simp only [List.ofFn_succ,List.reverse_cons,List.prod_append,List.prod_singleton]
    exact (norm_mul_le _ _).trans ((mul_le_of_le_one_left (norm_nonneg _)
      (ih _ (fun index => hA index.succ))).trans (hA 0))

end BinaryCoordinateSweeps

end

open scoped BigOperators Classical

namespace BinaryCoordinateSweeps

lemma pi_single_reverse {I G : Type*} [Fintype I] [DecidableEq I] [Group G]
    (f : I → G) (e : Fin (Fintype.card I) ≃ I) :
    (List.ofFn (fun j => Pi.mulSingle (e j) (f (e j)))).reverse.prod=f := by
  funext i
  have hh := List.prod_map_eq_pow_single (e.symm i)
    (fun j => (Pi.mulSingle (e j) (f (e j)) : I → G) i)
    (l := (List.ofFn (fun j : Fin (Fintype.card I) => j)).reverse) (by
      intro j hj _
      have hne : i ≠ e j := by
        intro he
        apply hj
        exact e.injective (he.symm.trans (e.apply_symm_apply i).symm)
      simp [Pi.mulSingle,hne])
  have hc : ((List.ofFn (fun j : Fin (Fintype.card I) => j)).reverse).count (e.symm i)=1 := by
    apply List.count_eq_one_of_mem
    · exact List.nodup_reverse.mpr (List.nodup_ofFn.mpr Function.injective_id)
    · simp
  rw [hc,pow_one,e.apply_symm_apply,Pi.mulSingle_eq_same] at hh
  simp only [List.map_reverse,List.map_ofFn,Function.comp_def] at hh
  change (Pi.evalMonoidHom (fun _ : I => G) i)
    ((List.ofFn (fun j => Pi.mulSingle (e j) (f (e j)))).reverse.prod)=f i
  rw [map_list_prod,List.map_reverse,List.map_ofFn]
  exact hh

variable {G V : Type*} [Group G] [Fintype G]
  [NormedAddCommGroup V] [InnerProductSpace ℂ V] [FiniteDimensional ℂ V]

def continuousRep (ρ : Representation ℂ G V) : G →* (V →L[ℂ] V) where
  toFun g := (ρ g).toContinuousLinearMap
  map_one' := by ext v; simp
  map_mul' g h := by ext v; simp

lemma complexAverage_sum (ρ : Representation ℂ G V) (p : G → ℂ) :
    complexAverage ρ p=∑g,p g • continuousRep ρ g := by
  ext v
  simp [complexAverage_apply,continuousRep]

theorem pi_average_norm_le_one {I : Type*} [Fintype I] [DecidableEq I] [DecidableEq G] [Nontrivial V]
    (ρ : Representation ℂ (I → G) V) (p : I → G → ℂ)
    (h : ∀i, ‖complexAverage (ρ.comp (MonoidHom.mulSingle (fun _ : I => G) i)) (p i)‖≤1) :
    ‖complexAverage ρ (fun f => ∏i,p i (f i))‖≤1 := by
  let e : Fin (Fintype.card I) ≃ I := (Fintype.equivFin I).symm
  let E : (Fin (Fintype.card I) → G) ≃ (I → G) := Equiv.piCongrLeft (fun _ => G) e
  have he (f : Fin (Fintype.card I) → G) : ∀j, E f (e j)=f j := by
    intro j; simp [E,Equiv.piCongrLeft]
  have hf : complexAverage ρ (fun f => ∏i,p i (f i))=
      (List.ofFn (fun j => complexAverage
        (ρ.comp (MonoidHom.mulSingle (fun _ : I => G) (e j))) (p (e j)))).reverse.prod := by
    rw [complexAverage_sum,←Equiv.sum_comp E]
    simp_rw [←e.prod_comp (fun i => p i (E _ i))]
    have ht (f : Fin (Fintype.card I) → G) : continuousRep ρ (E f)=
        (List.ofFn (fun j => continuousRep ρ (Pi.mulSingle (e j) (f j)))).reverse.prod := by
      rw [←pi_single_reverse (E f) e,map_list_prod,List.map_reverse,List.map_ofFn]
      simp only [Function.comp_def,he]
    simp_rw [ht,he]
    rw [independent_average_product (X := fun _ => G)
      (fun j a => p (e j) a) (fun j a => continuousRep ρ (Pi.mulSingle (e j) a))]
    congr 3
    funext j
    rw [complexAverage_sum]
    rfl
  rw [hf]
  exact reverse_product_norm_le_one _ (fun j => h (e j))

lemma pi_comp_average_norm_le_one {I H : Type*} [Fintype I] [DecidableEq I] [DecidableEq G] [Group H] [Fintype H]
    [Nontrivial V] (ρ : Representation ℂ H V) (φ : (I → G) →* H)
    (p : G → ℂ) (hρ : ∀g v, ‖ρ g v‖=‖v‖)
    (hp : ∀σ : Representation ℂ G V, (∀g v, ‖σ g v‖=‖v‖) →
      ‖complexAverage σ p‖≤1) :
    ‖complexAverage (ρ.comp φ) (fun f => ∏i,p (f i))‖≤1 := by
  apply pi_average_norm_le_one
  intro i
  apply hp
  exact fun g v => hρ _ v

end BinaryCoordinateSweeps

end

end OAI