| import Mathlib |
| import OAI.MathematicalPhysics.PEPSFilters.LocalOperators |
| import OAI.MathematicalPhysics.PEPSSubvolume.SpectralPowers |
|
|
| namespace OAI |
|
|
| /-! Hermitian trace representatives and spanning by reflections. -/ |
|
|
| noncomputable section |
| open scoped BigOperators ComplexOrder |
| open scoped BigOperators ComplexOrder Matrix.Norms.L2Operator |
| open scoped BigOperators |
| open scoped Topology |
| open Filter |
| open PolynomialPEPS.PinnedEntropy |
|
|
| open scoped MatrixOrder |
| namespace PolynomialPEPS.Subvolume.HermitianFunctional |
| variable {ι : Type*} [Fintype ι] [DecidableEq ι] |
| |
| theorem map_star_of_real (l : Matrix ι ι ℂ →ₗ[ℂ] ℂ) |
| (h : ∀ H : Matrix ι ι ℂ, H.IsHermitian → (l H).im = 0) |
| (A : Matrix ι ι ℂ) : l (star A) = star (l A) := by |
| have hplus : (A+star A).IsHermitian := by |
| change star (A+star A) = A+star A |
| simp [add_comm] |
| have hminus : (Complex.I • (A-star A)).IsHermitian := by |
| change star (Complex.I • (A-star A)) = Complex.I • (A-star A) |
| simp [star_sub,star_smul,RCLike.star_def,smul_sub,neg_smul] |
| abel |
| have hp := h (A+star A) hplus |
| have hm := h (Complex.I • (A-star A)) hminus |
| simp only [map_add,Complex.add_im] at hp |
| simp only [map_smul,map_sub,smul_eq_mul,Complex.mul_im,Complex.I_re, |
| Complex.I_im,zero_mul,one_mul,zero_add,Complex.sub_re] at hm |
| apply Complex.ext |
| · simpa [RCLike.star_def] using (sub_eq_zero.mp hm).symm |
| · simp only [RCLike.star_def,Complex.conj_im] |
| linarith |
|
|
| def representative (l : Matrix ι ι ℂ →ₗ[ℂ] ℂ) : Matrix ι ι ℂ := |
| fun i j => l (Matrix.single j i 1) |
|
|
| theorem apply_eq_trace (l : Matrix ι ι ℂ →ₗ[ℂ] ℂ) (A : Matrix ι ι ℂ) : |
| l A = (representative l * A).trace := by |
| rw [Matrix.matrix_eq_sum_single A] |
| simp only [map_sum,Matrix.mul_sum,Matrix.trace_sum] |
| apply Finset.sum_congr rfl |
| intro i hi |
| apply Finset.sum_congr rfl |
| intro j hj |
| rw [← show A i j • Matrix.single i j (1 : ℂ) = Matrix.single i j (A i j) from by |
| simp [Matrix.smul_single], map_smul] |
| simp [representative,smul_eq_mul,mul_comm,Matrix.trace_mul_single] |
|
|
| theorem isHermitian_of_trace_real (B : Matrix ι ι ℂ) |
| (h : ∀ H : Matrix ι ι ℂ, H.IsHermitian → (B*H).trace.im=0) : B.IsHermitian := by |
| let l : Matrix ι ι ℂ →ₗ[ℂ] ℂ := |
| (Matrix.traceLinearMap ι ℂ ℂ).comp (LinearMap.mulLeft ℂ B) |
| have hs := map_star_of_real l h |
| apply Matrix.IsHermitian.ext |
| intro i j |
| have hij := hs (Matrix.single i j 1) |
| simpa [l,Matrix.star_eq_conjTranspose,Matrix.conjTranspose_single, |
| Matrix.trace_mul_single] using hij.symm |
|
|
| theorem commuting_transition (F B : Matrix ι ι ℂ) (hF : F.PosSemidef) |
| (hFB : (F*B).IsHermitian) (hBF : (B*F).IsHermitian) : Commute F B := by |
| have h1 : star B * F = F*B := by |
| simpa only [star_mul,hF.isHermitian.star_eq] using hFB.star_eq |
| have h2 : F * star B = B*F := by |
| simpa only [star_mul,hF.isHermitian.star_eq] using hBF.star_eq |
| have hc : Commute (F*F) B := by |
| change (F*F)*B = B*(F*F) |
| calc |
| (F*F)*B = F*(F*B) := mul_assoc _ _ _ |
| _ = F*(star B*F) := by rw [h1] |
| _ = (F*star B)*F := (mul_assoc _ _ _).symm |
| _ = B*(F*F) := by rw [h2,mul_assoc] |
| have hroot := hc.cfcₙ_nnreal NNReal.sqrt |
| change Commute (CFC.sqrt (F*F)) B at hroot |
| simpa only [CFC.sqrt_mul_self F hF.nonneg] using hroot |
|
|
| theorem moment_commute (l : Matrix ι ι ℂ →ₗ[ℂ] ℂ) (F : Matrix ι ι ℂ) |
| (hF : F.PosSemidef) |
| (hleft : ∀ H : Matrix ι ι ℂ, H.IsHermitian → (l (H*F)).im=0) |
| (hright : ∀ H : Matrix ι ι ℂ, H.IsHermitian → (l (F*H)).im=0) |
| (A : Matrix ι ι ℂ) : l (A*F) = l (F*A) := by |
| let B := representative l |
| have hFB : (F*B).IsHermitian := isHermitian_of_trace_real _ (fun H hH => by |
| have hb := hleft H hH |
| rw [apply_eq_trace] at hb |
| change (F*B*H).trace.im = 0 |
| rw [← Matrix.trace_mul_cycle B H F,mul_assoc] |
| exact hb) |
| have hBF : (B*F).IsHermitian := isHermitian_of_trace_real _ (fun H hH => by |
| have hb := hright H hH |
| rw [apply_eq_trace] at hb |
| simpa [B,mul_assoc] using hb) |
| have hc := commuting_transition F B hF hFB hBF |
| rw [apply_eq_trace,apply_eq_trace] |
| change (B*(A*F)).trace = (B*(F*A)).trace |
| calc |
| (B*(A*F)).trace = (F*B*A).trace := by rw [← mul_assoc,Matrix.trace_mul_cycle] |
| _ = (B*(F*A)).trace := by rw [hc.eq,mul_assoc] |
|
|
| end PolynomialPEPS.Subvolume.HermitianFunctional |
|
|
| namespace PolynomialPEPS.Subvolume.ReflectionSpan |
| open scoped BigOperators ComplexOrder Matrix.Norms.L2Operator |
| open PolynomialPEPS.Subvolume.SpectralCurve |
| variable {ι : Type*} [Fintype ι] [DecidableEq ι] |
|
|
| def reflection (U : unitary (Matrix ι ι ℂ)) (i : ι) : unitary (Matrix ι ι ℂ) := |
| ⟨spectralHom U (fun j => if j=i then -1 else 1), by |
| let d : ι → ℂ := fun j => if j=i then -1 else 1 |
| have hd : star d = d := by |
| ext j |
| by_cases h : j=i <;> simp [d,h] |
| have hsq : d*d = 1 := by |
| ext j |
| by_cases h : j=i <;> simp [d,h] |
| change star (spectralHom U d)*spectralHom U d = 1 ∧ |
| spectralHom U d*star (spectralHom U d) = 1 |
| constructor <;> rw [← map_star,hd,← map_mul,hsq,map_one]⟩ |
| |
| theorem reflection_star (U : unitary (Matrix ι ι ℂ)) (i : ι) : |
| star (reflection U i : Matrix ι ι ℂ) = (reflection U i : Matrix ι ι ℂ) := by |
| change star (spectralHom U _) = spectralHom U _ |
| rw [← map_star] |
| congr 1 |
| ext j |
| by_cases h : j=i <;> simp [h] |
| |
| theorem reflection_eq (U : unitary (Matrix ι ι ℂ)) (i : ι) : |
| (reflection U i : Matrix ι ι ℂ) = |
| 1-(2:ℂ) • spectralHom U (Pi.single i 1) := by |
| have hd : (fun j : ι => if j=i then (-1 : ℂ) else 1) = |
| 1-(2:ℂ) • Pi.single i 1 := by |
| ext j |
| by_cases h : j=i <;> norm_num [Pi.single_apply,h] |
| change spectralHom U _ = _ |
| rw [hd,map_sub,map_smul,map_one] |
| |
| theorem zero_of_hermitian_tests (l : Matrix ι ι ℂ →ₗ[ℂ] ℂ) |
| (h : ∀ H : Matrix ι ι ℂ, H.IsHermitian → l H = 0) |
| (A : Matrix ι ι ℂ) : l A = 0 := by |
| have hplus : (A+star A).IsHermitian := by |
| change star (A+star A) = A+star A |
| simp [add_comm] |
| have hminus : (Complex.I • (A-star A)).IsHermitian := by |
| change star (Complex.I • (A-star A)) = Complex.I • (A-star A) |
| simp [star_sub,star_smul,RCLike.star_def,smul_sub,neg_smul] |
| abel |
| have hp := h (A+star A) hplus |
| have hm := h (Complex.I • (A-star A)) hminus |
| simp only [map_add] at hp |
| have hm' : l A = l (star A) := by |
| apply sub_eq_zero.mp |
| simpa [map_smul,map_sub,smul_eq_mul] using hm |
| rw [← hm'] at hp |
| have hz : (2:ℂ)*l A = 0 := by simpa [two_mul] using hp |
| exact (mul_eq_zero.mp hz).resolve_left (by norm_num) |
|
|
| theorem zero_of_reflection_tests (l : Matrix ι ι ℂ →ₗ[ℂ] ℂ) |
| (h : ∀ W : unitary (Matrix ι ι ℂ), star (W : Matrix ι ι ℂ)=W → l W = 0) |
| (A : Matrix ι ι ℂ) : l A = 0 := by |
| have h1 : l 1 = 0 := h 1 (by simp) |
| have hP (U : unitary (Matrix ι ι ℂ)) (i : ι) : |
| l (spectralHom U (Pi.single i 1)) = 0 := by |
| have hs := h (reflection U i) (reflection_star U i) |
| rw [reflection_eq,map_sub,map_smul,h1] at hs |
| simpa [smul_eq_mul] using hs |
| apply zero_of_hermitian_tests l ?_ A |
| intro H hH |
| let U := hH.eigenvectorUnitary |
| have hdiag : (fun j => (hH.eigenvalues j : ℂ)) = |
| ∑ i, (hH.eigenvalues i : ℂ) • Pi.single i 1 := by |
| ext j |
| simp [Pi.single_apply,Finset.sum_apply,Pi.smul_apply] |
| have hrep : H = spectralHom U (fun j => (hH.eigenvalues j : ℂ)) := hH.spectral_theorem |
| rw [hrep,hdiag,map_sum,map_sum] |
| simp only [map_smul,hP,smul_zero,Finset.sum_const_zero] |
|
|
| end PolynomialPEPS.Subvolume.ReflectionSpan |
|
|
| end |
|
|
| end OAI |
|
|
