| import Mathlib |
| import OAI.Geometry.SmoothYau.Smoothness.DistanceSquare |
| import OAI.Geometry.SmoothYau.Smoothness.FderivCofactorApply |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace YauCounterexamples |
| section |
| open Set Filter Function |
| open scoped Topology ContDiff Manifold SchwartzMap |
| open Set Filter Manifold Bundle |
| open scoped Topology ContDiff |
| open Set Filter NormedSpace |
| open scoped Topology |
| open scoped Matrix.Norms.Operator |
| variable {ι : Type*} [Fintype ι] [DecidableEq ι] |
| lemma hasDerivAt_det_exp_smul (K : Matrix ι ι ℝ) (t : ℝ) : |
| HasDerivAt (fun s : ℝ => (NormedSpace.exp (s • K)).det) |
| ((NormedSpace.exp (t • K)).det * K.trace) t := by |
| have hu : IsUnit (NormedSpace.exp (t • K)).det := |
| (Matrix.isUnit_iff_isUnit_det _).mp (NormedSpace.isUnit_exp (t • K)) |
| have he := hasDerivAt_exp_smul_const' (𝕂 := ℝ) K t |
| have hd := (differentiable_det (NormedSpace.exp (t • K))).hasFDerivAt.comp_hasDerivAt t he |
| erw [fderiv_det_apply _ _ hu,Matrix.mul_assoc,Matrix.mul_nonsing_inv _ hu,Matrix.mul_one] at hd |
| exact hd |
|
|
| theorem matrix_det_exp (K : Matrix ι ι ℝ) : |
| (NormedSpace.exp K).det = Real.exp K.trace := by |
| let f : ℝ → ℝ := fun t => (NormedSpace.exp (t • K)).det * Real.exp (-t * K.trace) |
| have hf (t : ℝ) : HasDerivAt f 0 t := by |
| have hh := (hasDerivAt_det_exp_smul K t).mul |
| (((hasDerivAt_id t).neg.mul_const K.trace).exp) |
| convert hh using 1 <;> first | rfl | ring |
| have hc := is_const_of_deriv_eq_zero (fun t => (hf t).differentiableAt) |
| (fun t => (hf t).deriv) 1 0 |
| have hfe : (NormedSpace.exp K).det * Real.exp (-K.trace) = 1 := by |
| simpa only [f,one_smul,neg_mul,one_mul,zero_smul,NormedSpace.exp_zero,Matrix.det_one, |
| neg_zero,zero_mul,Real.exp_zero,mul_one] using hc |
| calc (NormedSpace.exp K).det = |
| (NormedSpace.exp K).det * (Real.exp (-K.trace) * Real.exp K.trace) := by |
| rw [← Real.exp_add,neg_add_cancel,Real.exp_zero,mul_one] |
| _ = Real.exp K.trace := by rw [← mul_assoc,hfe,one_mul] |
|
|
| end |
|
|
| open Set Filter Function |
| open scoped Topology ContDiff Manifold SchwartzMap |
| open Set Filter Manifold Bundle |
| open scoped Topology ContDiff |
| open Set Filter NormedSpace |
| open scoped Topology |
| open scoped Matrix.Norms.Operator |
| open scoped Matrix.Norms.Operator |
| variable {ι E : Type*} [Fintype ι] [DecidableEq ι] |
| [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] |
|
|
| def clmMatrixAlgHom (b : Module.Basis ι ℝ E) : (E →L[ℝ] E) →ₐ[ℝ] Matrix ι ι ℝ where |
| toFun K := LinearMap.toMatrix b b K.toLinearMap |
| map_one' := by simp |
| map_mul' A B := by simp [LinearMap.toMatrix_mul] |
| map_zero' := by simp |
| map_add' A B := by simp |
| commutes' r := by |
| change LinearMap.toMatrix b b (r • LinearMap.id) = _ |
| simp [Algebra.algebraMap_eq_smul_one] |
|
|
| lemma clmMatrix_exp (b : Module.Basis ι ℝ E) (K : E →L[ℝ] E) : |
| LinearMap.toMatrix b b (NormedSpace.exp K).toLinearMap = |
| NormedSpace.exp (LinearMap.toMatrix b b K.toLinearMap) := by |
| let : NormedAlgebra ℚ (E →L[ℝ] E) := .restrictScalars ℚ ℝ (E →L[ℝ] E) |
| exact NormedSpace.map_exp (clmMatrixAlgHom b) |
| (clmMatrixAlgHom b).toLinearMap.continuous_of_finiteDimensional K |
|
|
| lemma clm_det_exp (b : Module.Basis ι ℝ E) (K : E →L[ℝ] E) : |
| LinearMap.det (NormedSpace.exp K).toLinearMap = |
| Real.exp (LinearMap.trace ℝ E K.toLinearMap) := by |
| rw [← LinearMap.det_toMatrix b,clmMatrix_exp b K,matrix_det_exp, |
| LinearMap.trace_eq_matrix_trace ℝ b] |
|
|
| def matrixOfForm (b : Module.Basis ι ℝ E) (G : E →L[ℝ] E →L[ℝ] ℝ) : Matrix ι ι ℝ := |
| fun i j => G (b i) (b j) |
|
|
| omit [FiniteDimensional ℝ E] in |
| lemma matrixOfForm_pullback (b : Module.Basis ι ℝ E) (G : E →L[ℝ] E →L[ℝ] ℝ) |
| (D : E →L[ℝ] E) : |
| matrixOfForm b ((D.precomp ℝ).comp (G.comp D)) = |
| (clmMatrixAlgHom b D).transpose * matrixOfForm b G * clmMatrixAlgHom b D := by |
| ext i j |
| change G (D (b i)) (D (b j)) = |
| ((LinearMap.toMatrix b b D.toLinearMap).transpose * matrixOfForm b G * |
| LinearMap.toMatrix b b D.toLinearMap) i j |
| conv_lhs => arg 1; rw [← b.sum_repr (D (b i))] |
| conv_lhs => arg 2; rw [← b.sum_repr (D (b j))] |
| simp only [map_sum,map_smul,_root_.sum_apply,_root_.smul_apply,smul_eq_mul] |
| simp only [Matrix.mul_apply,Matrix.transpose_apply,matrixOfForm, |
| LinearMap.toMatrix_apply,Finset.sum_mul,Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro k _ |
| apply Finset.sum_congr rfl |
| intro l _ |
| change (b.repr (D (b j))) k * ((b.repr (D (b i))) l * G (b l) (b k)) = |
| (b.repr (D (b i))) l * G (b l) (b k) * (b.repr (D (b j))) k |
| ring |
| |
| theorem tracefree_exp_preserves_gram_det (b : Module.Basis ι ℝ E) |
| (G : E →L[ℝ] E →L[ℝ] ℝ) (K : E →L[ℝ] E) |
| (htr : LinearMap.trace ℝ E K.toLinearMap = 0) : |
| (matrixOfForm b (((NormedSpace.exp K).precomp ℝ).comp |
| (G.comp (NormedSpace.exp K)))).det = (matrixOfForm b G).det := by |
| rw [matrixOfForm_pullback,Matrix.det_mul,Matrix.det_mul,Matrix.det_transpose] |
| have hd : (clmMatrixAlgHom b (NormedSpace.exp K)).det = 1 := by |
| change (LinearMap.toMatrix b b (NormedSpace.exp K).toLinearMap).det = 1 |
| rw [LinearMap.det_toMatrix,clm_det_exp b K,htr,Real.exp_zero] |
| rw [hd,one_mul,mul_one] |
|
|
|
|
| end YauCounterexamples |
| end |
|
|
| end OAI |
|
|
