lean/OAI/Geometry/Convex/GeneralMahler/Frame/Diagonal.lean

import OAI.Geometry.Convex.GeneralMahler.LogDet
import OAI.Geometry.Convex.GeneralMahler.Frame.Selector

namespace OAI
/-! Borel choice of diagonalizing frame. Everything computed in a
diagonalization is defined on a full orthogonal matrix and its entries. -/
noncomputable section
open Set Filter MeasureTheory Metric Matrix Real
open scoped Topology NNReal ENNReal MatrixOrder Matrix.Norms.L2Operator RealInnerProductSpace
namespace GeneralMahler
variable {m:ℕ}
abbrev Frm (m:ℕ) := ↥(unitary (Mat m))
namespace Frm
variable (u v:Frm m)
def loc (A:Mat m) := star u.val*A*u.val
def fixMat (A:Mat m) := u.val*A*star u.val
def eig (A:Mat m) := Matrix.diag (u.loc A)
def Dgn (A:Mat m) := u.loc A = Matrix.diagonal (u.eig A)
lemma m₁ : star u.val*u.val=1 := u.property.1
lemma m₂ : u.val*star u.val=1 := u.property.2

lemma loc_fix (A:Mat m) : u.loc (u.fixMat A)=A := by
  unfold loc fixMat
  simp only [mul_assoc]
  rw [u.m₁,mul_one,← mul_assoc,u.m₁,one_mul]
lemma fix_loc (A:Mat m) : u.fixMat (u.loc A)=A := by
  unfold loc fixMat; simp only [mul_assoc]
  rw [u.m₂,mul_one,← mul_assoc,u.m₂,one_mul]

lemma loc_inj : Function.Injective u.loc := fun _ b h =>
  (u.fix_loc _).symm.trans ((congrArg u.fixMat h).trans (u.fix_loc b))

lemma loc_mul (A B:Mat m) : u.loc (A*B)=u.loc A*u.loc B := by
  unfold loc; simp only [mul_assoc]
  rw [show u.val*(star u.val*(B*u.val))=B*u.val from by rw [← mul_assoc,u.m₂,one_mul]]

lemma loc_star (A:Mat m) : u.loc (star A)=star (u.loc A) := by
  unfold loc; rw [star_mul,star_mul,star_star,mul_assoc]
lemma loc_trace (A:Mat m) : trace (u.loc A) = trace A := by
  unfold loc; rw [trace_mul_comm,← mul_assoc,u.m₂,one_mul]
lemma loc_norm (A:Mat m) : ‖u.loc A‖=‖A‖ := by
  unfold loc; rw [CStarRing.norm_mul_mem_unitary _ u.property,CStarRing.norm_mem_unitary_mul]
  exact (star u).property

lemma loc_one : u.loc 1=1 := by unfold loc; rw [mul_one,u.m₁]
lemma loc_zero : u.loc 0=0 := by simp [loc]
lemma loc_sub (A B:Mat m) : u.loc (A-B)=u.loc A-u.loc B := by simp [loc,mul_sub,sub_mul]
lemma loc_add (A B:Mat m) : u.loc (A+B)=u.loc A+u.loc B := by simp [loc,mul_add,add_mul]
lemma loc_smul (a:ℝ) (A:Mat m) : u.loc (a• A)=a•u.loc A := by simp only [loc,mul_smul_comm,smul_mul_assoc]

lemma fix_mul_cross (A:Mat m) :
    star u.val*A*v.val=u.loc A*(star u.val*v.val) := by
  unfold loc; simp only [mul_assoc]
  rw [show u.val*(star u.val*v.val)=v.val from by rw [← mul_assoc,u.m₂,one_mul]]
lemma fix_mul_cross' (A:Mat m) :
    star u.val*A*v.val= (star u.val*v.val)*v.loc A := by
  unfold loc
  simp only [mul_assoc]
  rw [show v.val*(star v.val*(A*v.val))=A*v.val from by rw [← mul_assoc,v.m₂,one_mul]]

lemma cross_cancel (A B:Mat m) (h:star u.val*A*v.val= star u.val*B*v.val) : A=B := by
  have hi (A:Mat m) : u.val*(star u.val*A*v.val)*star v.val=A := by
    simp only [mul_assoc]; rw [v.m₂,mul_one,← mul_assoc,u.m₂,one_mul]
  exact (hi A).symm.trans ((congrArg (fun x=> u.val*x*star v.val) h).trans (hi B))

def specEval (A:Mat m) (f:ℝ→ℝ) := u.fixMat (Matrix.diagonal (fun i=> f (u.eig A i)))
lemma lSpecEq (A:Mat m) (f:ℝ→ℝ) : u.loc (u.specEval A f) = Matrix.diagonal (fun i=> f (u.eig A i)) :=
  u.loc_fix ..

lemma frame_cross {A:Mat m} (h:u.Dgn A) (g:v.Dgn A) (i j):
    u.eig A i*(star u.val*v.val) i j=(star u.val*v.val) i j*v.eig A j := by
  have hh := (u.fix_mul_cross v A).symm.trans (u.fix_mul_cross' v A)
  rw [show u.loc A=_ from h, show v.loc A=_ from g] at hh
  simpa only [Matrix.diagonal_mul,Matrix.mul_diagonal] using congrFun (congrFun hh i) j

lemma spec_unique {A:Mat m} (h:u.Dgn A) (g:v.Dgn A) (f:ℝ→ℝ) :
    u.specEval A f=v.specEval A f := by
  apply u.cross_cancel v
  rw [u.fix_mul_cross,u.fix_mul_cross',u.lSpecEq,v.lSpecEq]
  ext i j
  rw [Matrix.diagonal_mul,Matrix.mul_diagonal]
  have hh := u.frame_cross v h g i j
  rcases eq_or_ne ((star u.val*v.val) i j) 0 with hz|hz
  · simp [hz]
  have he : u.eig A i=v.eig A j := mul_right_cancel₀ hz (hh.trans (mul_comm ..))
  rw [he,mul_comm]

def eu {A:Mat m} (h:A.IsHermitian) : Frm m := h.eigenvectorUnitary
lemma eu_loc {A:Mat m} (h:A.IsHermitian) :
    (eu h).loc A= Matrix.diagonal h.eigenvalues := by
  open Unitary in
    have he := h.spectral_theorem
    simp only [conjStarAlgAut_apply,RCLike.ofReal_real_eq_id,Function.id_comp] at he
    exact (congrArg (eu h).loc he).trans ((eu h).loc_fix _)
lemma eu_eig {A:Mat m} (h:A.IsHermitian) : (eu h).eig A=h.eigenvalues := by rw [eig,eu_loc,Matrix.diag_diagonal]
lemma eu_d {A:Mat m} (h:A.IsHermitian) : (eu h).Dgn A := by rw [Dgn,eu_loc,eu_eig]

lemma loc_cfc {A:Mat m} (h:A.IsHermitian) (hu:u.Dgn A) (f:ℝ→ℝ) :
    u.loc (cfc f A)= Matrix.diagonal (fun i=>f (u.eig A i)) := by
  rw [← u.lSpecEq A]
  congr 1
  rw [u.spec_unique (eu h) hu (eu_d h) f,specEval,eu_eig]
  open Unitary in
    rw [Matrix.IsHermitian.cfc_eq h,Matrix.IsHermitian.cfc,conjStarAlgAut_apply]
    simp only [Function.comp_def]
    rfl

lemma cont_loc : Continuous (fun x:Mat m × Frm m=> x.2.loc x.1) := by
  let f := fun x:Mat m × Frm m=> x.2.val
  have hf : Continuous f := continuous_subtype_val.comp continuous_snd
  exact (hf.star.mul continuous_fst).mul hf
lemma cdiag : Continuous (Matrix.diag:Mat m→Fin m→ℝ) :=
  continuous_pi fun i=> (coeffMap i i).continuous
lemma cdiagonal : Continuous (Matrix.diagonal:(Fin m→ℝ)→Mat m) := by
  exact (Matrix.diagonalLinearMap (Fin m) ℝ ℝ).continuous_of_finiteDimensional
lemma Dgn_closed : IsClosed {p:Mat m×Frm m|p.2.Dgn p.1} :=
  isClosed_eq cont_loc (cdiagonal.comp (cdiag.comp cont_loc))

instance frame_cmp : CompactSpace (Frm m) := by
  change CompactSpace (↥((unitary (Mat m)):Set (Mat m)))
  rw [← isCompact_iff_compactSpace]
  let s : Set (Mat m) := unitary (Mat m)
  have hc : IsClosed s := (isClosed_eq (continuous_id.star.mul continuous_id)
    continuous_const).inter (isClosed_eq (continuous_id.mul continuous_id.star)
    continuous_const)
  exact (isCompact_closedBall 0 1).of_isClosed_subset hc
    (fun x hx=> by
      rw [mem_closedBall,dist_zero_right]
      rcases subsingleton_or_nontrivial (Mat m) with h | h
      · have h0 : x = 0 := @Subsingleton.elim _ h x 0
        rw [h0,norm_zero]
        exact zero_le_one
      · let : Nontrivial (Mat m) := h
        rw [CStarRing.norm_of_mem_unitary hx])

abbrev SH (m:ℕ) := {A:Mat m // A.IsHermitian}
lemma selectU :
    ∃ f:SH m→Frm m,Measurable f∧∀ A,(f A).Dgn A.val := by
  let F : Set (SH m × Frm m) := {x|x.2.Dgn x.1.val}
  have hs : IsClosed F :=
    (@Dgn_closed m).preimage ((continuous_subtype_val.comp continuous_fst).prodMk continuous_snd)
  have he (x:SH m) : ∃ y:Frm m,(x,y) ∈ F := ⟨eu x.property,eu_d x.property⟩
  exact Select.selector F he hs

def fr (A:SH m) : Frm m := selectU.choose A
lemma fr_m : Measurable (@fr m) := selectU.choose_spec.1
lemma fr_d (A:SH m) : (fr A).Dgn A.val := selectU.choose_spec.2 A
end Frm
end GeneralMahler

end

end OAI