import Mathlib

namespace OAI

section
noncomputable section
open scoped BigOperators Classical MatrixOrder Matrix.Norms.L2Operator ComplexOrder
namespace RowColumn.MatrixState
variable {I J : Type*} [Fintype I] [Fintype J]

def hsVector : Matrix I J ℂ →ₗ[ℂ] EuclideanSpace ℂ (I × J) where
  toFun M := WithLp.toLp 2 (fun z => M z.1 z.2)
  map_add' _ _ := rfl
  map_smul' _ _ := rfl

lemma hsVector_inner (M N : Matrix I J ℂ) :
    inner ℂ (hsVector M) (hsVector N) = (M.conjTranspose*N).trace := by
  change (∑ z : I × J, N z.1 z.2 * star (M z.1 z.2)) = _
  rw [Fintype.sum_prod_type]
  simp only [Matrix.trace, Matrix.diag, Matrix.mul_apply, Matrix.conjTranspose_apply]
  rw [Finset.sum_comm]
  simp only [mul_comm]

lemma hsVector_norm_sq (M : Matrix I J ℂ) :
    ‖hsVector M‖^2 = (M.conjTranspose*M).trace.re := by
  rw [← hsVector_inner M M, inner_self_eq_norm_sq_to_K]
  simp only [← Complex.ofReal_pow, RCLike.ofReal_eq_complex_ofReal, Complex.ofReal_re]

lemma trace_mH_mul_le (M N : Matrix I J ℂ) :
    (M.conjTranspose*N).trace.re ≤ Real.sqrt ((M.conjTranspose*M).trace.re) *
      Real.sqrt ((N.conjTranspose*N).trace.re) := by
  rw [← hsVector_inner M N, ← hsVector_norm_sq M, ← hsVector_norm_sq N,
    Real.sqrt_sq (norm_nonneg _), Real.sqrt_sq (norm_nonneg _)]
  exact (Complex.re_le_norm _).trans (norm_inner_le_norm _ _)

variable [DecidableEq I]

lemma trace_mul_psd_nonneg (A B : Matrix I I ℂ) (hA : A.PosSemidef) (hB : B.PosSemidef) :
    0 ≤ (A*B).trace.re := by
  let R : Matrix I I ℂ := CFC.sqrt B
  have hs : R.conjTranspose=R := (Matrix.nonneg_iff_posSemidef.mp (CFC.sqrt_nonneg B)).isHermitian.eq
  have hsq : R*R=B := CFC.sqrt_mul_sqrt_self B hB.nonneg
  have hh := (hA.conjTranspose_mul_mul_same R).trace_nonneg
  rw [hs] at hh
  have ht : (R*A*R).trace=(A*B).trace := by
    rw [Matrix.trace_mul_cycle,hsq,Matrix.trace_mul_comm]
  rw [ht] at hh
  exact hh.1

lemma trace_mul_mono (A B T : Matrix I I ℂ) (h : A ≤ B) (hT : T.PosSemidef) :
    (A*T).trace.re ≤ (B*T).trace.re := by
  have hh := trace_mul_psd_nonneg (B-A) T h hT
  rw [sub_mul,Matrix.trace_sub,Complex.sub_re] at hh
  linarith

lemma trace_sqrt_conjugate_le_one (A B U : Matrix I I ℂ) (hA : A.PosSemidef) (hB : B.PosSemidef)
    (hTA : A.trace.re ≤ 1) (hTB : B.trace.re ≤ 1) (hU : U ∈ unitary (Matrix I I ℂ)) :
    (CFC.sqrt A * U * CFC.sqrt B * U.conjTranspose).trace.re ≤ 1 := by
  let X : Matrix I I ℂ := CFC.sqrt A
  let Y : Matrix I I ℂ := U * CFC.sqrt B * U.conjTranspose
  have hx : X.conjTranspose=X := (Matrix.nonneg_iff_posSemidef.mp (CFC.sqrt_nonneg A)).isHermitian.eq
  have hy : Y.conjTranspose=Y := by simp [Y,Matrix.conjTranspose_mul,
    (Matrix.nonneg_iff_posSemidef.mp (CFC.sqrt_nonneg B)).isHermitian.eq, mul_assoc]
  have hy2 : Y*Y=U*B*U.conjTranspose := by
    have hu : U.conjTranspose*U=1 := hU.1
    dsimp only [Y]
    calc
      _=U*CFC.sqrt B*(U.conjTranspose*U)*CFC.sqrt B*U.conjTranspose := by noncomm_ring
      _=U*B*U.conjTranspose := by rw [hu,mul_one]; rw [mul_assoc U, CFC.sqrt_mul_sqrt_self B hB.nonneg]
  have hx2 : X*X=A := CFC.sqrt_mul_sqrt_self A hA.nonneg
  have ht : (Y*Y).trace=B.trace := by
    rw [hy2,Matrix.trace_mul_cycle]
    have hu : U.conjTranspose*U=1 := hU.1
    rw [hu,one_mul]
  have hc := trace_mH_mul_le X Y
  rw [hx,hy,hx2,ht] at hc
  have hsA : Real.sqrt A.trace.re ≤ 1 := (Real.sqrt_le_one).mpr hTA
  have hsB : Real.sqrt B.trace.re ≤ 1 := (Real.sqrt_le_one).mpr hTB
  have hprod := mul_le_mul hsA hsB (Real.sqrt_nonneg _) (by norm_num : (0:ℝ) ≤ 1)
  have hh := hc.trans hprod
  simpa only [X,Y,← mul_assoc,one_mul] using hh
end RowColumn.MatrixState

end
end

section

noncomputable section
open scoped BigOperators Classical MatrixOrder Matrix.Norms.L2Operator ComplexOrder
namespace RowColumn.MatrixState
variable {I J K : Type*} [Fintype I] [Fintype J] [Fintype K]
  [DecidableEq I] [DecidableEq J] [DecidableEq K]

lemma toEuclideanCLM_positive_iff (A : Matrix I I ℂ) :
    (Matrix.toEuclideanCLM (𝕜 := ℂ) A).IsPositive ↔ A.PosSemidef := by
  rw [← ContinuousLinearMap.isPositive_toLinearMap_iff]
  exact Matrix.isPositive_toEuclideanLin_iff

lemma trace_toEuclideanCLM (A : Matrix I I ℂ) :
    LinearMap.trace ℂ (EuclideanSpace ℂ I)
      (Matrix.toEuclideanCLM (𝕜 := ℂ) A).toLinearMap = A.trace := by
  exact Matrix.trace_toLin_eq A (EuclideanSpace.basisFun I ℂ).toBasis

omit [Fintype I] [Fintype J] [DecidableEq I] [DecidableEq J] in
lemma hsVector_injective : Function.Injective (hsVector (I := I) (J := J)) := by
  intro a b h
  ext i j
  exact congrArg (fun v : EuclideanSpace ℂ (I × J) => v (i,j)) h

omit [DecidableEq I] [DecidableEq J] in
lemma hsVector_norm_sq_sum (M : Matrix I J ℂ) :
    ‖hsVector M‖^2 = ∑ i, ∑ j, ‖M i j‖^2 := by
  rw [EuclideanSpace.norm_sq_eq, Fintype.sum_prod_type]
  rfl

lemma finite_sum_embedding_le {D E : Type*} [Fintype D] [Fintype E]
    (e : D ↪ E) (f : E → ℝ) (hf : ∀ i, 0 ≤ f i) : ∑ i, f (e i) ≤ ∑ i, f i := by
  rw [← Finset.sum_image (fun i _ j _ h => e.injective h)]
  exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _)
    (fun i _ _ => hf i)

omit [DecidableEq I] [DecidableEq J] in
lemma hsVector_submatrix_norm_sq_le {I' J' : Type*} [Fintype I'] [Fintype J']
    [DecidableEq I'] [DecidableEq J'] (e : I' ↪ I) (f : J' ↪ J) (M : Matrix I J ℂ) :
    ‖hsVector (M.submatrix e f)‖^2 ≤ ‖hsVector M‖^2 := by
  rw [hsVector_norm_sq_sum, hsVector_norm_sq_sum]
  calc
    _ ≤ ∑ i : I', ∑ j : J, ‖M (e i) j‖^2 := Finset.sum_le_sum fun i _ =>
      finite_sum_embedding_le f (fun j => ‖M (e i) j‖^2) (fun _ => sq_nonneg _)
    _ ≤ _ := finite_sum_embedding_le e (fun i => ∑ j, ‖M i j‖^2)
      (fun _ => Finset.sum_nonneg (fun _ _ => sq_nonneg _))

/-- The exact Hilbert--Schmidt trace formula used in the two PSD majorizations. -/
lemma hsVector_sandwich_sq (A B X : Matrix I I ℂ)
    (hA : A.IsHermitian) (hB : B.IsHermitian) :
    ‖hsVector (A * X * B)‖^2 = (A^2 * X * B^2 * X.conjTranspose).trace.re := by
  rw [hsVector_norm_sq]
  simp only [Matrix.conjTranspose_mul, hA.eq, hB.eq]
  congr 1
  calc
    _ = ((B * X.conjTranspose) * (A*A*X*B)).trace := by
      simp only [mul_assoc]
    _ = ((A*A*X*B) * (B * X.conjTranspose)).trace := Matrix.trace_mul_comm _ _
    _ = _ := by simp only [pow_two, mul_assoc]

/-- A concrete finite-algebra Hilbert--Schmidt core, not the operator norm. -/
@[instance_reducible]
def matrixAlgebraCore (A : StarSubalgebra ℂ (Matrix I I ℂ)) : InnerProductSpace.Core ℂ A where
  inner a b := inner ℂ (hsVector a.val) (hsVector b.val)
  conj_inner_symm a b := inner_conj_symm _ _
  re_inner_nonneg a := inner_self_nonneg
  add_left a b c := by
    change inner ℂ (hsVector (a.val + b.val)) (hsVector c.val) = _
    rw [map_add, inner_add_left]
  smul_left a b c := by
    change inner ℂ (hsVector (c • a.val)) (hsVector b.val) = _
    rw [map_smul, inner_smul_left]
  definite a h := Subtype.ext (hsVector_injective (by simpa using inner_self_eq_zero.mp h))

def matrixAlgebraTrace (A : StarSubalgebra ℂ (Matrix I I ℂ)) : A →ₗ[ℂ] ℂ :=
  (Matrix.traceLinearMap I ℂ ℂ).comp A.subtype.toLinearMap

lemma matrixAlgebraCore_inner (A : StarSubalgebra ℂ (Matrix I I ℂ)) (a b : A) :
    (matrixAlgebraCore A).inner a b = matrixAlgebraTrace A (star a * b) := by
  exact hsVector_inner a.val b.val

instance matrixAlgebraIsClosed (A : StarSubalgebra ℂ (Matrix I I ℂ)) : IsClosed (A : Set (Matrix I I ℂ)) :=
  A.toSubalgebra.toSubmodule.closed_of_finiteDimensional

end RowColumn.MatrixState

end
end

end OAI