| import Mathlib | |
| import OAI.MathematicalPhysics.BFSS.FrequencyComparison | |
| import OAI.MathematicalPhysics.BFSS.FrequencyOperators | |
| namespace OAI | |
| /-! CAR eigenmodes, actual ground vectors and lowering operators. -/ | |
| namespace BFSSQuantum.AlgebraData | |
| noncomputable section | |
| open Matrix Finset | |
| open scoped ComplexConjugate | |
| variable {N : ℕ} (M : AlgebraData N) | |
| def thetaMode (v : FrequencyIndex N → ℂ) : Fermion N →L[ℂ] Fermion N := | |
| ∑ r, v r • M.thetaPair r | |
| lemma thetaMode_smul (c : ℂ) (v : FrequencyIndex N → ℂ) : | |
| M.thetaMode (c • v) = c • M.thetaMode v := by | |
| simp only [thetaMode,Pi.smul_apply,smul_eq_mul,Finset.smul_sum,smul_smul] | |
| theorem thetaMode_CAR (v w : FrequencyIndex N → ℂ) : | |
| M.thetaMode v*M.thetaMode w+M.thetaMode w*M.thetaMode v = | |
| (∑ r, v r*w r) • (1 : Fermion N →L[ℂ] Fermion N) := by | |
| have hh (r s : FrequencyIndex N) : | |
| (v r • M.thetaPair r)*(w s • M.thetaPair s)+ | |
| (w s • M.thetaPair s)*(v r • M.thetaPair r) = | |
| (v r*w s) • (if r = s then (1 : Fermion N →L[ℂ] Fermion N) else 0) := by | |
| rw [smul_mul_smul,smul_mul_smul,mul_comm (w s)] | |
| rw [←(smul_add (v r*w s) (M.thetaPair r*M.thetaPair s) | |
| (M.thetaPair s*M.thetaPair r)),M.thetaPair_CAR] | |
| unfold thetaMode | |
| simp only [Finset.sum_mul,Finset.mul_sum] | |
| conv_lhs => | |
| arg 2 | |
| rw [Finset.sum_comm] | |
| rw [←Finset.sum_add_distrib] | |
| simp_rw [←Finset.sum_add_distrib,hh] | |
| have hs (r : FrequencyIndex N) : | |
| (∑ s : FrequencyIndex N, (v r*w s) • | |
| (if r = s then (1 : Fermion N →L[ℂ] Fermion N) else 0)) = | |
| (v r*w r) • (1 : Fermion N →L[ℂ] Fermion N) := by | |
| rw [Finset.sum_eq_single r] | |
| · simp | |
| · intro s _ hsr | |
| rw [ite_eq_right (Ne.symm hsr)] | |
| exact (@smul_zero ℂ (Fermion N →L[ℂ] Fermion N) _ _ (v r*w s)) | |
| · intro hr | |
| exact (hr (Finset.mem_univ r)).elim | |
| rw [Finset.sum_comm] | |
| calc | |
| _ = ∑ r : FrequencyIndex N, (v r*w r) • (1 : Fermion N →L[ℂ] Fermion N) := | |
| Finset.sum_congr rfl (fun r _ => hs r) | |
| _ = _ := (@Finset.sum_smul (FrequencyIndex N) ℂ (Fermion N →L[ℂ] Fermion N) | |
| _ _ _ (fun r => v r*w r) Finset.univ 1).symm | |
| lemma thetaMode_star (v : FrequencyIndex N → ℂ) : | |
| star (M.thetaMode v) = M.thetaMode (fun r => conj (v r)) := by | |
| have hs (f : FrequencyIndex N → (Fermion N →L[ℂ] Fermion N)) : | |
| star (∑ r, f r) = ∑ r, star (f r) := star_sum Finset.univ f | |
| have hc (c : ℂ) (A : Fermion N →L[ℂ] Fermion N) : | |
| star (c • A) = conj c • star A := star_smul c A | |
| simp only [thetaMode,hs,hc,M.thetaPair_star] | |
| theorem thetaMode_commutator (K : FrequencyMatrix N) (hK : K.transpose = -K) | |
| (v : FrequencyIndex N → ℂ) : | |
| M.quantizeFrequency K*M.thetaMode v-M.thetaMode v*M.quantizeFrequency K = | |
| M.thetaMode (fun r => Complex.I*∑ s, (K r s : ℂ)*v s) := by | |
| have hd (c : ℂ) (A B : Fermion N →L[ℂ] Fermion N) : | |
| A*(c • B)-(c • B)*A = c • (A*B-B*A) := by | |
| rw [mul_smul_comm,smul_mul_assoc,smul_sub] | |
| unfold thetaMode | |
| simp only [Finset.mul_sum,Finset.sum_mul,←Finset.sum_sub_distrib,hd, | |
| M.quantizeFrequency_commutator K hK,Finset.smul_sum,smul_smul] | |
| rw [Finset.sum_comm] | |
| apply Finset.sum_congr rfl | |
| intro r _ | |
| calc | |
| _ = (∑ s : FrequencyIndex N, v s*(Complex.I*(K r s : ℂ))) • M.thetaPair r := | |
| (@Finset.sum_smul (FrequencyIndex N) ℂ (Fermion N →L[ℂ] Fermion N) | |
| _ _ _ (fun s => v s*(Complex.I*(K r s : ℂ))) Finset.univ (M.thetaPair r)).symm | |
| _ = _ := by | |
| congr 1 | |
| apply Finset.sum_congr rfl | |
| intro s _ | |
| ring | |
| end | |
| end BFSSQuantum.AlgebraData | |
| namespace BFSSQuantum.AlgebraData | |
| noncomputable section | |
| open Matrix Finset | |
| variable {N : ℕ} (M : AlgebraData N) | |
| theorem quantizeFrequency_ground_exists (K : FrequencyMatrix N) (hK : K.transpose = -K) : | |
| ∃ (E : ℝ) (u : Fermion N), u ≠ 0 ∧ M.quantizeFrequency K u = (E : ℂ) • u ∧ | |
| ∀ (e : ℝ) (v : Fermion N), v ≠ 0 → | |
| M.quantizeFrequency K v = (e : ℂ) • v → E ≤ e := by | |
| classical | |
| let T : Fermion N →ₗ[ℂ] Fermion N := (M.quantizeFrequency K).toLinearMap | |
| have hs : T.IsSymmetric := (M.quantizeFrequency_selfAdjoint K hK).isSymmetric | |
| let d := Module.finrank ℂ (Fermion N) | |
| have hd : 0 < d := Module.finrank_pos | |
| let i₀ : Fin d := ⟨0,hd⟩ | |
| obtain ⟨i,hi,hm⟩ := Finset.exists_min_image Finset.univ (hs.eigenvalues rfl) | |
| (show (Finset.univ : Finset (Fin d)).Nonempty from ⟨i₀,Finset.mem_univ i₀⟩) | |
| refine ⟨hs.eigenvalues rfl i,hs.eigenvectorBasis rfl i, | |
| (hs.hasEigenvector_eigenvectorBasis rfl i).2, hs.apply_eigenvectorBasis rfl i,?_⟩ | |
| intro e v hv he | |
| have hev : Module.End.HasEigenvalue T (e : ℂ) := | |
| Module.End.hasEigenvalue_of_hasEigenvector | |
| ⟨Module.End.mem_eigenspace_iff.mpr he,hv⟩ | |
| obtain ⟨j,hj⟩ := hs.exists_eigenvalues_eq rfl hev | |
| have heq : hs.eigenvalues rfl j = e := Complex.ofReal_injective hj | |
| rw [←heq] | |
| exact hm j (Finset.mem_univ j) | |
| theorem quantizeFrequency_ground_killed (K : FrequencyMatrix N) (hK : K.transpose = -K) | |
| (E : ℝ) (u : Fermion N) (hu : M.quantizeFrequency K u = (E : ℂ) • u) | |
| (hmin : ∀ (e : ℝ) (w : Fermion N), w ≠ 0 → | |
| M.quantizeFrequency K w = (e : ℂ) • w → E ≤ e) | |
| (v : FrequencyIndex N → ℂ) (ω : ℝ) (hω : ω < 0) | |
| (hv : ∀ r, Complex.I*(∑ s, (K r s : ℂ)*v s) = (ω : ℂ)*v r) : | |
| M.thetaMode v u = 0 := by | |
| have he : (fun r => Complex.I*(∑ s, (K r s : ℂ)*v s)) = (ω : ℂ) • v := by | |
| funext r | |
| exact hv r | |
| have hc := M.thetaMode_commutator K hK v | |
| rw [he,M.thetaMode_smul] at hc | |
| have hc' := congrArg (fun A : Fermion N →L[ℂ] Fermion N => A u) hc | |
| change M.quantizeFrequency K (M.thetaMode v u) - | |
| M.thetaMode v (M.quantizeFrequency K u) = (ω : ℂ) • M.thetaMode v u at hc' | |
| rw [hu,map_smul] at hc' | |
| have hE : M.quantizeFrequency K (M.thetaMode v u) = | |
| ((E+ω : ℝ) : ℂ) • M.thetaMode v u := by | |
| rw [Complex.ofReal_add,add_smul] | |
| exact eq_add_of_sub_eq' hc' | |
| by_contra hn | |
| have h := hmin (E+ω) (M.thetaMode v u) hn hE | |
| linarith | |
| theorem normal_fermion_ground_lowering (q : Boson N) | |
| (_hq : M.deformedBosonicPotential 1 1 q = 0) : | |
| ∃ (E : ℝ) (u : Fermion N), u ≠ 0 ∧ | |
| M.quantizeFrequency (M.normalFermionFrequency q) u = (E : ℂ) • u ∧ | |
| ∀ (v : FrequencyIndex N → ℂ) (ω : ℝ), ω < 0 → | |
| (∀ r, Complex.I*(∑ s, (M.normalFermionFrequency q r s : ℂ)*v s) = | |
| (ω : ℂ)*v r) → M.thetaMode v u = 0 := by | |
| have hs := M.normalFermionFrequency_skew q | |
| obtain ⟨E,u,hu,he,hm⟩ := M.quantizeFrequency_ground_exists (M.normalFermionFrequency q) hs | |
| refine ⟨E,u,hu,he,?_⟩ | |
| intro v ω hω hv | |
| exact M.quantizeFrequency_ground_killed (M.normalFermionFrequency q) hs E u he hm v ω hω hv | |
| end | |
| end BFSSQuantum.AlgebraData | |
| end OAI | |