import Mathlib
import OAI.MathematicalPhysics.PEPSFilters.LocalOperators

namespace OAI

/-! Common eigenbases for positive commuting matrices. -/

noncomputable section
open scoped BigOperators ComplexOrder
open scoped BigOperators ComplexOrder Matrix.Norms.L2Operator
open scoped BigOperators
open scoped Topology
open Filter
open scoped MatrixOrder
open PolynomialPEPS.PinnedEntropy

open scoped BigOperators Matrix.Norms.L2Operator
namespace PolynomialPEPS.Subvolume.JointDiagonalization
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

theorem exists_subordinate {κ E : Type*} [NormedAddCommGroup E]
    [InnerProductSpace ℂ E] [FiniteDimensional ℂ E]
    (V : κ → Submodule ℂ E)
    (horth : OrthogonalFamily ℂ (fun i => V i) (fun i => (V i).subtypeₗᵢ))
    (htop : (⨆ i, V i) = ⊤) :
    ∃ (b : OrthonormalBasis (Fin (Module.finrank ℂ E)) ℂ E)
      (idx : Fin (Module.finrank ℂ E) → κ), ∀ i, b i ∈ V (idx i) := by
  classical
  let : Fintype {i : κ // V i ≠ ⊥} := horth.independent.fintypeNeBotOfFiniteDimensional
  let W : {i : κ // V i ≠ ⊥} → Submodule ℂ E := fun i => V i.val
  have horthW := horth.comp (f := fun i : {i : κ // V i ≠ ⊥} => i.val) Subtype.val_injective
  have htopW : (⨆ i, W i) = ⊤ := (iSup_ne_bot_subtype V).trans htop
  have hV : DirectSum.IsInternal W := horthW.isInternal_iff.mpr
    (by rw [htopW,Submodule.top_orthogonal_eq_bot])
  refine ⟨hV.subordinateOrthonormalBasis rfl horthW,
    (fun i => (hV.subordinateOrthonormalBasisIndex rfl i horthW).val),?_⟩
  exact fun i => hV.subordinateOrthonormalBasis_subordinate rfl i horthW

theorem exists_basis (A B : Matrix ι ι ℂ) (hA : A.IsHermitian)
    (hB : B.IsHermitian) (hAB : Commute A B) :
    ∃ (b : OrthonormalBasis ι ℂ (EuclideanSpace ℂ ι)) (d e : ι → ℂ),
      (∀ i, A.toEuclideanLin (b i) = d i • b i) ∧
      (∀ i, B.toEuclideanLin (b i) = e i • b i) := by
  classical
  have hA' := Matrix.isSymmetric_toEuclideanLin_iff.mpr hA
  have hB' := Matrix.isSymmetric_toEuclideanLin_iff.mpr hB
  have hAB' : Commute A.toEuclideanLin B.toEuclideanLin := by
    change (Matrix.toLpLin 2 2 A).comp (Matrix.toLpLin 2 2 B) =
      (Matrix.toLpLin 2 2 B).comp (Matrix.toLpLin 2 2 A)
    rw [← Matrix.toLpLin_mul_same,← Matrix.toLpLin_mul_same,hAB.eq]
  let V : (ℂ × ℂ) → Submodule ℂ (EuclideanSpace ℂ ι) :=
    fun i => Module.End.eigenspace A.toEuclideanLin i.2 ⊓
      Module.End.eigenspace B.toEuclideanLin i.1
  have horth := hA'.orthogonalFamily_eigenspace_inf_eigenspace hB'
  have htop : (⨆ i, V i) = ⊤ := by
    rw [iSup_prod]
    change (⨆ i : ℂ, ⨆ j : ℂ, Module.End.eigenspace A.toEuclideanLin j ⊓
      Module.End.eigenspace B.toEuclideanLin i) = ⊤
    rw [iSup_comm]
    exact hA'.iSup_iSup_eigenspace_inf_eigenspace_eq_top_of_commute hB' hAB'
  obtain ⟨b₀,idx,hm⟩ := exists_subordinate V horth htop
  let eι : Fin (Module.finrank ℂ (EuclideanSpace ℂ ι)) ≃ ι :=
    Fintype.equivOfCardEq (by simp)
  refine ⟨b₀.reindex eι,(fun i => (idx (eι.symm i)).2),
    (fun i => (idx (eι.symm i)).1),?_,?_⟩
  · intro i
    have h := Module.End.mem_eigenspace_iff.mp (hm (eι.symm i)).1
    simpa only [OrthonormalBasis.reindex_apply] using h
  · intro i
    have h := Module.End.mem_eigenspace_iff.mp (hm (eι.symm i)).2
    simpa only [OrthonormalBasis.reindex_apply] using h

def basisUnitary (b : OrthonormalBasis ι ℂ (EuclideanSpace ℂ ι)) :
    unitary (Matrix ι ι ℂ) :=
  ⟨(EuclideanSpace.basisFun ι ℂ).toBasis.toMatrix b.toBasis,
    (EuclideanSpace.basisFun ι ℂ).toMatrix_orthonormalBasis_mem_unitary b⟩

theorem conjugate_eq_diagonal (A : Matrix ι ι ℂ)
    (b : OrthonormalBasis ι ℂ (EuclideanSpace ℂ ι)) (d : ι → ℂ)
    (hd : ∀ i, A.toEuclideanLin (b i) = d i • b i) :
    A = (basisUnitary b : Matrix ι ι ℂ) * Matrix.diagonal d * star (basisUnitary b : Matrix ι ι ℂ) := by
  let U := basisUnitary b
  have hAU : A*(U : Matrix ι ι ℂ) = (U : Matrix ι ι ℂ)*Matrix.diagonal d := by
    ext i j
    have h := congrArg (fun v : EuclideanSpace ℂ ι => v i) (hd j)
    rw [Matrix.mul_diagonal]
    change (∑ k, A i k * (b j) k) = (b j) i * d j
    simpa [Matrix.toLpLin_apply,Matrix.mulVec,dotProduct,smul_eq_mul,mul_comm] using h
  have hright := congrArg (fun M : Matrix ι ι ℂ => M*star (U : Matrix ι ι ℂ)) hAU
  have hu : (U : Matrix ι ι ℂ)*star (U : Matrix ι ι ℂ) = 1 := Unitary.coe_mul_star_self U
  rw [mul_assoc,hu,mul_one] at hright
  exact hright

theorem exists_unitary (A B : Matrix ι ι ℂ) (hA : A.IsHermitian)
    (hB : B.IsHermitian) (hAB : Commute A B) :
    ∃ (U : unitary (Matrix ι ι ℂ)) (d e : ι → ℂ),
      A = (U : Matrix ι ι ℂ)*Matrix.diagonal d*star (U : Matrix ι ι ℂ) ∧
      B = (U : Matrix ι ι ℂ)*Matrix.diagonal e*star (U : Matrix ι ι ℂ) := by
  obtain ⟨b,d,e,hd,he⟩ := exists_basis A B hA hB hAB
  exact ⟨basisUnitary b,d,e,conjugate_eq_diagonal A b d hd,conjugate_eq_diagonal B b e he⟩

open scoped ComplexOrder

theorem diagonal_nonneg (A : Matrix ι ι ℂ) (hA : A.PosSemidef)
    (U : unitary (Matrix ι ι ℂ)) (d : ι → ℂ)
    (hd : A = (U : Matrix ι ι ℂ)*Matrix.diagonal d*star (U : Matrix ι ι ℂ)) :
    ∀ i, 0 ≤ d i := by
  have hp := hA.conjTranspose_mul_mul_same (U : Matrix ι ι ℂ)
  rw [hd] at hp
  have hu : star (U : Matrix ι ι ℂ)*(U : Matrix ι ι ℂ)=1 := Unitary.coe_star_mul_self U
  rw [← Matrix.star_eq_conjTranspose,← mul_assoc,← mul_assoc,hu,one_mul,
    mul_assoc,hu,mul_one] at hp
  exact Matrix.posSemidef_diagonal_iff.mp hp

theorem exists_positive_unitary (A B : Matrix ι ι ℂ) (hA : A.PosSemidef)
    (hB : B.PosSemidef) (hAB : Commute A B) :
    ∃ (U : unitary (Matrix ι ι ℂ)) (d e : ι → ℝ),
      (∀ i, 0 ≤ d i) ∧ (∀ i, 0 ≤ e i) ∧
      A = (U : Matrix ι ι ℂ)*Matrix.diagonal (fun i => (d i:ℂ))*star (U : Matrix ι ι ℂ) ∧
      B = (U : Matrix ι ι ℂ)*Matrix.diagonal (fun i => (e i:ℂ))*star (U : Matrix ι ι ℂ) := by
  obtain ⟨U,d,e,hd,he⟩ := exists_unitary A B hA.isHermitian hB.isHermitian hAB
  have hd0 := diagonal_nonneg A hA U d hd
  have he0 := diagonal_nonneg B hB U e he
  have hdr (i : ι) : ((d i).re:ℂ) = d i := by
    exact Complex.ext rfl (by simpa using (Complex.nonneg_iff.mp (hd0 i)).2)
  have her (i : ι) : ((e i).re:ℂ) = e i := by
    exact Complex.ext rfl (by simpa using (Complex.nonneg_iff.mp (he0 i)).2)
  refine ⟨U,(fun i => (d i).re),(fun i => (e i).re),
    (fun i => (Complex.nonneg_iff.mp (hd0 i)).1),
    (fun i => (Complex.nonneg_iff.mp (he0 i)).1),?_,?_⟩
  · simpa only [hdr] using hd
  · simpa only [her] using he

end PolynomialPEPS.Subvolume.JointDiagonalization

end

end OAI