import Mathlib
import OAI.Probability.BinarySweep.MatrixBounds.SchattenBounds

namespace OAI

noncomputable section
open scoped BigOperators Classical Matrix.Norms.L2Operator

namespace BinaryCoordinateSweeps.TraceHolder
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

lemma alternating_prod {R : Type*} [Monoid R] (q : ℕ) (x y : R) :
    (List.ofFn (fun i : Fin (2*q) => if i.val%2=0 then x else y)).prod=(x*y)^q := by
  induction q with
  | zero => simp
  | succ q ih =>
    rw [show 2*(q+1)=2*q+1+1 by omega]
    simp only [List.ofFn_succ,List.prod_cons,Fin.val_zero,Fin.val_succ]
    norm_num only [Nat.zero_mod,Nat.reduceMod,ite_eq_left,ite_eq_right]
    have he (i : Fin (2*q)) : (i.val+1+1)%2=i.val%2 := by omega
    simp_rw [he]
    rw [ih,pow_succ']
    exact (mul_assoc _ _ _).symm

lemma alternating_prod_real (q : ℕ) (x y : ℝ) :
    (∏i : Fin (2*q), if i.val%2=0 then x else y)=(x*y)^q := by
  rw [← List.prod_ofFn]
  exact alternating_prod q x y

lemma alternating_gram (q : ℕ) (A : M ι) :
    (List.ofFn (fun i : Fin (2*q) => if i.val%2=0 then star A else A)).prod=
      (star A*A)^q := alternating_prod q _ _

lemma mul_pow_rotate {R : Type*} [Monoid R] (q : ℕ) (x y : R) :
    (x*y)^(q+1)=x*(y*x)^q*y := by
  induction q with
  | zero => simp
  | succ q ih => rw [pow_succ,ih,pow_succ]; simp only [mul_assoc]

lemma matrixMoment_smul (q : ℕ) (r : ℝ) (A : M ι) :
    matrixMoment q (r • A)=r^(2*q)*matrixMoment q A := by
  unfold matrixMoment
  rw [star_smul,star_trivial,smul_mul_smul_comm,smul_pow,Matrix.trace_smul]
  simp only [Complex.real_smul,Complex.mul_re,Complex.ofReal_re,Complex.ofReal_im,zero_mul,sub_zero]
  rw [← pow_two,← pow_mul]

lemma momentRoot_pow {q : ℕ} (hq : 0 < q) (A : M ι) :
    (matrixMoment q A ^ (((2*q:ℕ):ℝ)⁻¹))^(2*q)=matrixMoment q A := by
  rw [← Real.rpow_natCast,← Real.rpow_mul (matrixMoment_nonneg q A),
    inv_mul_cancel₀ (show ((2*q:ℕ):ℝ)≠0 by positivity),Real.rpow_one]

lemma matrixMoment_of_density_sandwich_le {q : ℕ} (hq : 0<q)
    (d : ι → ℝ) (hd : ∀i, 0≤d i) (hs : ∑i, d i=1)
    (U V : M ι) (hU : ‖U‖≤1) (hV : ‖V‖≤1) :
    matrixMoment q (U*diagPower d ((((2*q:ℕ):ℝ)⁻¹ : ℝ) : ℂ)*V) ≤ 1 := by
  let D := diagPower d ((((2*q:ℕ):ℝ)⁻¹ : ℝ) : ℂ)
  have hD : star D=D := by
    unfold D
    rw [diagPower_real d hd (by positivity)]
    exact star_diagReal _
  have hb := trace_diagonal_sandwich_pos (show 0<2*q by omega)
    (fun _ => d) (fun _ => hd) (fun _ => hs)
    (fun _ => ((2*q:ℕ):ℝ)⁻¹) (fun _ => by positivity)
    (by simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul];
        exact mul_inv_cancel₀ (by positivity))
    (fun i : Fin (2*q) => if i.val%2=0 then star V else U)
    (fun i : Fin (2*q) => if i.val%2=0 then star U else V)
    (by intro i; split_ifs <;> simpa only [norm_star] using (by assumption))
    (by intro i; split_ifs <;> simpa only [norm_star] using (by assumption))
  have he : (fun i : Fin (2*q) =>
      (if i.val%2=0 then star V else U)*D*(if i.val%2=0 then star U else V))=
      fun i => if i.val%2=0 then star (U*D*V) else U*D*V := by
    funext i
    split_ifs <;> simp only [star_mul,hD,mul_assoc]
  change ‖Matrix.trace (List.ofFn (fun i : Fin (2*q) =>
    (if i.val%2=0 then star V else U)*D*(if i.val%2=0 then star U else V))).prod‖≤1 at hb
  rw [he,alternating_gram] at hb
  exact (Complex.re_le_norm _).trans hb

lemma matrixMoment_contract_left {q : ℕ} (hq : 0<q) (C A : M ι) (hC : ‖C‖≤1) :
    matrixMoment q (C*A) ≤ matrixMoment q A := by
  by_cases hz : matrixMoment q A=0
  · have ha := (matrixMoment_eq_zero_iff hq A).mp hz
    simp only [ha,mul_zero]
    exact le_rfl
  have ht := lt_of_le_of_ne (matrixMoment_nonneg q A) (Ne.symm hz)
  obtain ⟨U,V,d,hU,hV,hd,hs,he⟩ := normalized_svd hq A ht
  have hec : C*A = matrixMoment q A ^ (((2*q:ℕ):ℝ)⁻¹) •
      ((C*U)*diagPower d ((((2*q:ℕ):ℝ)⁻¹ : ℝ) : ℂ)*V) := by
    conv_lhs => rw [he]
    rw [mul_smul_comm]
    congr 1
    simp only [mul_assoc]
  rw [hec,matrixMoment_smul,momentRoot_pow hq A]
  exact mul_le_of_le_one_right ht.le (matrixMoment_of_density_sandwich_le hq d hd hs
    (C*U) V ((norm_mul_le _ _).trans ((mul_le_of_le_one_left (norm_nonneg _) hC).trans hU)) hV)

lemma matrixMoment_contract_right {q : ℕ} (hq : 0<q) (A C : M ι) (hC : ‖C‖≤1) :
    matrixMoment q (A*C) ≤ matrixMoment q A := by
  rw [← matrixMoment_star q (A*C),star_mul]
  exact (matrixMoment_contract_left hq (star C) (star A) (by simpa using hC)).trans_eq
    (matrixMoment_star q A)

lemma matrixMoment_mul_left {q : ℕ} (hq : 0<q) (C A : M ι) :
    matrixMoment q (C*A) ≤ ‖C‖^(2*q)*matrixMoment q A := by
  by_cases hc : C=0
  · simp only [hc,zero_mul,norm_zero,zero_pow (by omega : 2*q≠0),
      (matrixMoment_eq_zero_iff hq (0:M ι)).mpr rfl]
    exact le_rfl
  have hn : 0<‖C‖ := norm_pos_iff.mpr hc
  have hf : ‖‖C‖⁻¹ • C‖≤1 := by
    rw [norm_smul,Real.norm_eq_abs,abs_of_pos (inv_pos.mpr hn),inv_mul_cancel₀ hn.ne']
  have he : C=‖C‖ • (‖C‖⁻¹ • C) := by rw [smul_smul,mul_inv_cancel₀ hn.ne',one_smul]
  conv_lhs => rw [he,smul_mul_assoc,matrixMoment_smul]
  exact mul_le_mul_of_nonneg_left (matrixMoment_contract_left hq _ A hf) (pow_nonneg hn.le _)

lemma matrixMoment_unitary_conj (q : ℕ) (U : Matrix.unitaryGroup ι ℂ) (A : M ι) :
    matrixMoment q ((U:M ι)*A*star (U:M ι))=matrixMoment q A := by
  unfold matrixMoment
  have he : star ((U:M ι)*A*star (U:M ι))*((U:M ι)*A*star (U:M ι))=
      (U:M ι)*(star A*A)*star (U:M ι) := by
    simp only [star_mul,star_star,mul_assoc,← mul_assoc (star (U:M ι)) (U:M ι),
      Unitary.coe_star_mul_self,one_mul]
  rw [he,unitary_conj_pow,trace_unitary_conj]

end BinaryCoordinateSweeps.TraceHolder

end

end OAI