| import OAI.Analysis.FreeEntropy.Model |
|
|
| namespace OAI |
|
|
| universe u1 u2 |
|
|
| noncomputable section |
| open scoped ENNReal NNReal ComplexConjugate |
| open MeasureTheory Filter |
|
|
| namespace FiniteEntropySeparation |
|
|
| variable {H : Type} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] |
|
|
| @[simp] theorem trace_zero {M : VonNeumannAlgebra H} (τ : TracialVector M) : |
| trace τ (0 : H →L[ℂ] H) = 0 := by simp [trace] |
|
|
| theorem trace_add {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| (A B : H →L[ℂ] H) : trace τ (A + B) = trace τ A + trace τ B := by |
| simp [trace] |
|
|
| theorem trace_smul {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| (z : ℂ) (A : H →L[ℂ] H) : trace τ (z • A) = z * trace τ A := by |
| simp [trace] |
|
|
| theorem trace_sum {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| {α : Type u1} (s : Finset α) (A : α → H →L[ℂ] H) : |
| trace τ (∑ a ∈ s, A a) = ∑ a ∈ s, trace τ (A a) := by |
| simp [trace] |
|
|
| theorem ConjugateSystem.unique {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| {n : ℕ} {X : Fin n → H →L[ℂ] H} {ξ η : Fin n → H} |
| (hξ : ConjugateSystem τ X ξ) (hη : ConjugateSystem τ X η) : ξ = η := by |
| funext i |
| have hmem : ξ i - η i ∈ polynomialL2 τ X := |
| (polynomialL2 τ X).sub_mem (hξ i).1 (hη i).1 |
| have hker : polynomialL2 τ X ≤ (innerSL ℂ (ξ i - η i)).ker := by |
| apply Submodule.topologicalClosure_minimal |
| · apply Submodule.span_le.mpr |
| rintro _ ⟨w, rfl⟩ |
| change inner ℂ (ξ i - η i) (wordEval X w τ.vacuum) = 0 |
| rw [inner_sub_left, (hξ i).2 w, (hη i).2 w, sub_self] |
| · exact (innerSL ℂ (ξ i - η i)).isClosed_ker |
| have hd : inner ℂ (ξ i - η i) (ξ i - η i) = 0 := hker hmem |
| exact sub_eq_zero.mp ((inner_self_eq_zero).mp hd) |
|
|
| theorem freeFisher_eq_of_conjugate {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| {n : ℕ} {X : Fin n → H →L[ℂ] H} {ξ : Fin n → H} |
| (hξ : ConjugateSystem τ X ξ) : |
| freeFisher τ X = ENNReal.ofReal (∑ i, ‖ξ i‖ ^ 2) := by |
| apply le_antisymm |
| · exact iInf_le_of_le ξ (iInf_le_of_le hξ le_rfl) |
| · refine le_iInf fun η => le_iInf fun hη => ?_ |
| rw [hξ.unique τ hη] |
|
|
| @[simp] theorem trace_one {M : VonNeumannAlgebra H} (τ : TracialVector M) : |
| trace τ (1 : H →L[ℂ] H) = 1 := by |
| simp [trace, inner_self_eq_norm_sq_to_K, τ.norm_vacuum] |
|
|
| @[simp] theorem wordMoment_nil {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| {n : ℕ} (X : Fin n → H →L[ℂ] H) : wordMoment τ X [] = 1 := by |
| simp [wordMoment, wordEval] |
|
|
| theorem wordVector_mem_polynomialL2 {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| {n : ℕ} (X : Fin n → H →L[ℂ] H) (w : List (Fin n)) : |
| wordEval X w τ.vacuum ∈ polynomialL2 τ X := |
| Submodule.le_topologicalClosure _ (Submodule.subset_span ⟨w, rfl⟩) |
|
|
| instance polynomialL2_complete {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| {n : ℕ} (X : Fin n → H →L[ℂ] H) : CompleteSpace (polynomialL2 τ X) := |
| (Submodule.isClosed_topologicalClosure _).completeSpace_coe |
|
|
| def projectedConjugate {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| {n : ℕ} (X : Fin n → H →L[ℂ] H) (η : Fin n → H) (i : Fin n) : H := |
| (polynomialL2 τ X).starProjection (η i) |
|
|
| theorem projectedConjugate_system {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| {n : ℕ} (X : Fin n → H →L[ℂ] H) (η : Fin n → H) |
| (hη : ∀ i w, inner ℂ (η i) (wordEval X w τ.vacuum) = derivativeMoment τ X i w) : |
| ConjugateSystem τ X (projectedConjugate τ X η) := by |
| intro i |
| refine ⟨(polynomialL2 τ X).starProjection_apply_mem _, fun w => ?_⟩ |
| have h := (polynomialL2 τ X).starProjection_inner_eq_zero (η i) |
| (wordEval X w τ.vacuum) (wordVector_mem_polynomialL2 τ X w) |
| rw [inner_sub_left, hη i w] at h |
| exact (sub_eq_zero.mp h).symm |
|
|
| theorem freeFisher_le_testVectors {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| {n : ℕ} (X : Fin n → H →L[ℂ] H) (η : Fin n → H) |
| (hη : ∀ i w, inner ℂ (η i) (wordEval X w τ.vacuum) = derivativeMoment τ X i w) : |
| freeFisher τ X ≤ ENNReal.ofReal (∑ i, ‖η i‖ ^ 2) := by |
| rw [freeFisher_eq_of_conjugate τ (projectedConjugate_system τ X η hη)] |
| apply ENNReal.ofReal_le_ofReal |
| apply Finset.sum_le_sum |
| intro i _ |
| exact pow_le_pow_left₀ (norm_nonneg _) ((polynomialL2 τ X).norm_starProjection_apply_le _) _ |
|
|
| theorem conjugate_coordinate_pairing {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| {n : ℕ} {X : Fin n → H →L[ℂ] H} {ξ : Fin n → H} |
| (hξ : ConjugateSystem τ X ξ) (i : Fin n) : inner ℂ (ξ i) (X i τ.vacuum) = 1 := by |
| have h := (hξ i).2 [i] |
| simpa [wordEval, derivativeMoment, wordMoment, trace_one] using h |
|
|
| theorem conjugate_norm_sq_lower {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| {n : ℕ} {X : Fin n → H →L[ℂ] H} {ξ : Fin n → H} |
| (hξ : ConjugateSystem τ X ξ) (i : Fin n) : |
| 1 / ‖X i τ.vacuum‖ ^ 2 ≤ ‖ξ i‖ ^ 2 := by |
| have h : 1 ≤ ‖ξ i‖ * ‖X i τ.vacuum‖ := by |
| simpa only [conjugate_coordinate_pairing τ hξ i, norm_one] using |
| norm_inner_le_norm (𝕜 := ℂ) (ξ i) (X i τ.vacuum) |
| have hp : 0 < ‖X i τ.vacuum‖ := by |
| have hn := norm_nonneg (X i τ.vacuum) |
| by_contra hh |
| have hz : ‖X i τ.vacuum‖ = 0 := le_antisymm (not_lt.mp hh) hn |
| rw [hz, mul_zero] at h |
| linarith |
| apply (div_le_iff₀ (sq_pos_of_pos hp)).mpr |
| nlinarith [sq_nonneg (‖ξ i‖ * ‖X i τ.vacuum‖ - 1)] |
|
|
| theorem freeFisher_lower_covariance {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| {n : ℕ} (X : Fin n → H →L[ℂ] H) : |
| ENNReal.ofReal (∑ i, 1 / ‖X i τ.vacuum‖ ^ 2) ≤ freeFisher τ X := by |
| refine le_iInf fun ξ => le_iInf fun hξ => ?_ |
| apply ENNReal.ofReal_le_ofReal |
| exact Finset.sum_le_sum fun i _ => conjugate_norm_sq_lower τ hξ i |
|
|
| def vacuumRankOne {M : VonNeumannAlgebra H} (τ : TracialVector M) : H →L[ℂ] H := |
| InnerProductSpace.rankOne ℂ τ.vacuum τ.vacuum |
|
|
| def commutatorKernel {n : ℕ} (P : H →L[ℂ] H) (X : Fin n → H →L[ℂ] H) |
| (i : Fin n) (w : List (Fin n)) : H →L[ℂ] H := |
| ∑ r : Fin w.length, if w[r.val] = i then |
| wordEval X (w.take r.val) * P * wordEval X (w.drop (r.val + 1)) else 0 |
|
|
| omit [CompleteSpace H] in |
| @[simp] theorem commutatorKernel_nil {n : ℕ} (P : H →L[ℂ] H) |
| (X : Fin n → H →L[ℂ] H) (i : Fin n) : commutatorKernel P X i [] = 0 := by |
| simp [commutatorKernel] |
|
|
| omit [CompleteSpace H] in |
| theorem commutatorKernel_cons {n : ℕ} (P : H →L[ℂ] H) |
| (X : Fin n → H →L[ℂ] H) (i j : Fin n) (w : List (Fin n)) : |
| commutatorKernel P X i (j :: w) = |
| (if j = i then P * wordEval X w else 0) + X j * commutatorKernel P X i w := by |
| simp only [commutatorKernel, List.length_cons, Fin.sum_univ_succ] |
| simp only [Fin.val_zero, Fin.val_succ, List.getElem_cons_zero, List.getElem_cons_succ, |
| List.take_zero, List.take_succ_cons, List.drop_succ_cons, Nat.zero_add, |
| wordEval, List.map_nil, List.prod_nil, one_mul, Finset.mul_sum] |
| congr 1 |
| apply Finset.sum_congr rfl |
| intro r _ |
| split_ifs <;> simp [List.map_cons, List.prod_cons, mul_assoc] |
|
|
| omit [CompleteSpace H] in |
| theorem commutator_word {n : ℕ} (P a : H →L[ℂ] H) (X : Fin n → H →L[ℂ] H) |
| (i : Fin n) (c : ℂ) |
| (h : ∀ j, a * X j = X j * a + if j = i then c • P else 0) |
| (w : List (Fin n)) : |
| a * wordEval X w = wordEval X w * a + c • commutatorKernel P X i w := by |
| induction w with |
| | nil => simp [wordEval] |
| | cons j w ih => |
| have hw : wordEval X (j :: w) = X j * wordEval X w := by simp [wordEval] |
| rw [hw, commutatorKernel_cons, ← mul_assoc, h, add_mul, mul_assoc, ih] |
| by_cases hji : j = i <;> |
| simp [hji, mul_add, mul_assoc, smul_add, _root_.add_assoc, _root_.add_comm, |
| _root_.add_left_comm] |
|
|
| theorem trace_vacuumRankOne_product {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| (A B : H →L[ℂ] H) : trace τ (A * vacuumRankOne τ * B) = trace τ A * trace τ B := by |
| simp only [trace, vacuumRankOne, mul_apply_eq_comp, InnerProductSpace.rankOne_apply, |
| map_smul, inner_smul_right] |
| exact mul_comm _ _ |
|
|
| theorem trace_commutatorKernel {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| {n : ℕ} (X : Fin n → H →L[ℂ] H) (i : Fin n) (w : List (Fin n)) : |
| trace τ (commutatorKernel (vacuumRankOne τ) X i w) = derivativeMoment τ X i w := by |
| rw [commutatorKernel, trace_sum] |
| apply Finset.sum_congr rfl |
| intro r _ |
| split_ifs <;> simp [trace_vacuumRankOne_product, wordMoment] |
|
|
| theorem commutator_integration_by_parts {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| {n : ℕ} (X : Fin n → H →L[ℂ] H) (a : H →L[ℂ] H) (i : Fin n) (c : ℂ) |
| (h : ∀ j, a * X j = X j * a + if j = i then c • vacuumRankOne τ else 0) |
| (hz : a τ.vacuum = 0) (w : List (Fin n)) : |
| inner ℂ (star a τ.vacuum) (wordEval X w τ.vacuum) = c * derivativeMoment τ X i w := by |
| rw [ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_inner_left] |
| change trace τ (a * wordEval X w) = _ |
| rw [commutator_word _ _ _ _ _ h, trace_add, trace_smul, trace_commutatorKernel] |
| have hzero : trace τ (wordEval X w * a) = 0 := by |
| simp [trace, mul_apply_eq_comp, hz] |
| rw [hzero, zero_add] |
|
|
| theorem FreeSubalgebras.mono {κ : Type} {M : VonNeumannAlgebra H} (τ : TracialVector M) |
| {A B : κ → Subalgebra ℂ (H →L[ℂ] H)} (hA : FreeSubalgebras τ A) |
| (hBA : ∀ i, B i ≤ A i) : FreeSubalgebras τ B := by |
| intro k hk j a ha hc hadj |
| exact hA k hk j a (fun r => hBA (j r) (ha r)) hc hadj |
|
|
| namespace Fock |
|
|
| open scoped lp |
| variable {ι : Type} [DecidableEq ι] |
|
|
| abbrev Space (ι : Type) := lp (fun _ : List ι => ℂ) 2 |
|
|
| instance space_nontrivial : Nontrivial (Space ι) := by |
| refine ⟨⟨lp.single 2 ([] : List ι) (1 : ℂ), 0, ?_⟩⟩ |
| intro h |
| have he := congrArg (fun f : Space ι => f []) h |
| simp at he |
|
|
| def basisVector (w : List ι) : Space ι := lp.single 2 w 1 |
|
|
| def coordinateIsometry (w : List ι) : ℂ →ₗᵢ[ℂ] Space ι where |
| toLinearMap := lp.lsingle (𝕜 := ℂ) (E := fun _ : List ι => ℂ) 2 w |
| norm_map' z := lp.norm_single (E := fun _ : List ι => ℂ) (p := 2) (by norm_num) w z |
|
|
| @[simp] theorem coordinateIsometry_apply (w : List ι) (z : ℂ) : |
| coordinateIsometry w z = lp.single 2 w z := rfl |
|
|
| theorem orthogonal_coordinates (f : List ι → List ι) (hf : Function.Injective f) : |
| OrthogonalFamily ℂ (fun _ : List ι => ℂ) (fun w => coordinateIsometry (f w)) := by |
| intro w v hwv a b |
| simp only [coordinateIsometry_apply, lp.inner_single_left] |
| rw [lp.single_apply_ne (E := fun _ : List ι => ℂ) 2 (f v) b (fun h => hwv (hf h))] |
| simp |
|
|
| def injectionIsometry (f : List ι → List ι) (hf : Function.Injective f) : |
| Space ι →ₗᵢ[ℂ] Space ι := |
| (orthogonal_coordinates f hf).linearIsometry |
|
|
| @[simp] theorem injectionIsometry_single (f : List ι → List ι) |
| (hf : Function.Injective f) (w : List ι) (z : ℂ) : |
| injectionIsometry f hf (lp.single 2 w z) = lp.single 2 (f w) z := by |
| exact (orthogonal_coordinates f hf).linearIsometry_apply_single z |
|
|
| def creation (i : ι) : Space ι →L[ℂ] Space ι := |
| (injectionIsometry (List.cons i) (List.cons_injective (a := i))).toContinuousLinearMap |
|
|
| def rightCreation (i : ι) : Space ι →L[ℂ] Space ι := |
| (injectionIsometry (fun w => w ++ [i]) (List.append_left_injective [i])).toContinuousLinearMap |
|
|
| @[simp] theorem creation_single (i : ι) (w : List ι) (z : ℂ) : |
| creation i (lp.single 2 w z) = lp.single 2 (i :: w) z := by |
| exact injectionIsometry_single (List.cons i) List.cons_injective w z |
|
|
| @[simp] theorem rightCreation_single (i : ι) (w : List ι) (z : ℂ) : |
| rightCreation i (lp.single 2 w z) = lp.single 2 (w ++ [i]) z := by |
| exact injectionIsometry_single (fun w => w ++ [i]) (List.append_left_injective [i]) w z |
|
|
| def semicircular (i : ι) : Space ι →L[ℂ] Space ι := creation i + star (creation i) |
|
|
| def rightSemicircular (i : ι) : Space ι →L[ℂ] Space ι := |
| rightCreation i + star (rightCreation i) |
|
|
| theorem semicircular_selfAdjoint (i : ι) : IsSelfAdjoint (semicircular i) := |
| IsSelfAdjoint.add_star_self (creation i) |
|
|
| theorem rightSemicircular_selfAdjoint (i : ι) : IsSelfAdjoint (rightSemicircular i) := |
| IsSelfAdjoint.add_star_self (rightCreation i) |
|
|
| theorem semicircular_norm_le (i : ι) : ‖semicircular i‖ ≤ 2 := by |
| calc |
| ‖semicircular i‖ ≤ ‖creation i‖ + ‖star (creation i)‖ := norm_add_le _ _ |
| _ = 2 := by norm_num [creation, ContinuousLinearMap.star_eq_adjoint, LinearIsometry.norm_toContinuousLinearMap] |
|
|
| @[simp] theorem adjoint_creation_apply (i : ι) (x : Space ι) (w : List ι) : |
| (star (creation i) x) w = x (i :: w) := by |
| have h := ContinuousLinearMap.adjoint_inner_right (creation i) (lp.single 2 w (1 : ℂ)) x |
| simpa [ContinuousLinearMap.star_eq_adjoint, lp.inner_single_left] using h |
|
|
| @[simp] theorem adjoint_rightCreation_apply (i : ι) (x : Space ι) (w : List ι) : |
| (star (rightCreation i) x) w = x (w ++ [i]) := by |
| have h := ContinuousLinearMap.adjoint_inner_right (rightCreation i) (lp.single 2 w (1 : ℂ)) x |
| simpa [ContinuousLinearMap.star_eq_adjoint, lp.inner_single_left] using h |
|
|
| @[simp] theorem annihilation_single_nil (i : ι) (z : ℂ) : |
| star (creation i) (lp.single 2 ([] : List ι) z) = 0 := by |
| apply lp.ext |
| funext w |
| simp [lp.single_apply] |
|
|
| @[simp] theorem annihilation_single_cons (i j : ι) (w : List ι) (z : ℂ) : |
| star (creation i) (lp.single 2 (j :: w) z) = |
| if i = j then lp.single 2 w z else 0 := by |
| apply lp.ext |
| funext v |
| by_cases h : i = j |
| · subst j |
| simp [lp.single_apply, Pi.single_apply] |
| · simp [lp.single_apply, h] |
|
|
| @[simp] theorem rightAnnihilation_single_nil (i : ι) (z : ℂ) : |
| star (rightCreation i) (lp.single 2 ([] : List ι) z) = 0 := by |
| apply lp.ext |
| funext w |
| simp [lp.single_apply] |
|
|
| @[simp] theorem rightAnnihilation_single_append (i j : ι) (w : List ι) (z : ℂ) : |
| star (rightCreation i) (lp.single 2 (w ++ [j]) z) = |
| if i = j then lp.single 2 w z else 0 := by |
| apply lp.ext |
| funext v |
| by_cases h : i = j |
| · subst j |
| simp [lp.single_apply, Pi.single_apply] |
| · simp [lp.single_apply, h] |
|
|
| @[simp] theorem semicircular_single_nil (i : ι) (z : ℂ) : |
| semicircular i (lp.single 2 ([] : List ι) z) = lp.single 2 [i] z := by |
| simp [semicircular] |
|
|
| @[simp] theorem semicircular_single_cons (i j : ι) (w : List ι) (z : ℂ) : |
| semicircular i (lp.single 2 (j :: w) z) = |
| lp.single 2 (i :: j :: w) z + if i = j then lp.single 2 w z else 0 := by |
| simp [semicircular] |
|
|
| @[simp] theorem rightSemicircular_single_nil (i : ι) (z : ℂ) : |
| rightSemicircular i (lp.single 2 ([] : List ι) z) = lp.single 2 [i] z := by |
| simp [rightSemicircular] |
|
|
| @[simp] theorem rightSemicircular_single_append (i j : ι) (w : List ι) (z : ℂ) : |
| rightSemicircular i (lp.single 2 (w ++ [j]) z) = |
| lp.single 2 (w ++ [j, i]) z + if i = j then lp.single 2 w z else 0 := by |
| simp [rightSemicircular] |
|
|
| theorem semicircular_commutes_right (i j : ι) : |
| Commute (semicircular i) (rightSemicircular j) := by |
| show semicircular i * rightSemicircular j = rightSemicircular j * semicircular i |
| apply lp.ext_continuousLinearMap (by norm_num : (2 : ℝ≥0∞) ≠ ⊤) |
| intro w |
| apply ContinuousLinearMap.ext |
| intro z |
| change semicircular i (rightSemicircular j (lp.single 2 w z)) = |
| rightSemicircular j (semicircular i (lp.single 2 w z)) |
| cases w with |
| | nil => |
| simp only [rightSemicircular_single_nil, semicircular_single_nil, |
| semicircular_single_cons] |
| rw [show [i] = [] ++ [i] from rfl, rightSemicircular_single_append] |
| by_cases h : i = j <;> simp [h, eq_comm] |
| | cons k v => |
| induction v using List.reverseRecOn with |
| | nil => |
| rw [show [k] = [] ++ [k] from rfl, rightSemicircular_single_append] |
| simp only [List.nil_append, map_add, semicircular_single_cons] |
| rw [show [i, k] = [i] ++ [k] from rfl, rightSemicircular_single_append] |
| by_cases hik : i = k <;> by_cases hjk : j = k <;> |
| simp [hik, hjk, rightSemicircular_single_nil] |
| | append_singleton v l _ => |
| rw [show k :: (v ++ [l]) = (k :: v) ++ [l] from rfl, |
| rightSemicircular_single_append] |
| simp only [map_add, List.cons_append, semicircular_single_cons] |
| rw [show i :: k :: (v ++ [l]) = (i :: k :: v) ++ [l] from rfl, |
| rightSemicircular_single_append] |
| by_cases hik : i = k <;> by_cases hjl : j = l <;> |
| simp [hik, hjl, rightSemicircular_single_append, add_assoc, add_comm, add_left_comm] |
|
|
| def rightWick : List ι → Space ι →L[ℂ] Space ι |
| | [] => 1 |
| | [i] => rightSemicircular i |
| | i :: j :: w => rightSemicircular i * rightWick (j :: w) - |
| if i = j then rightWick w else 0 |
|
|
| theorem commute_rightWick (A : Space ι →L[ℂ] Space ι) |
| (h : ∀ i, Commute A (rightSemicircular i)) (w : List ι) : |
| Commute A (rightWick w) := by |
| induction w using rightWick.induct with |
| | case1 => exact Commute.one_right A |
| | case2 i => exact h i |
| | case3 i j w ih₁ ih₂ => |
| dsimp only [rightWick] |
| apply ((h i).mul_right ih₁).sub_right |
| split_ifs |
| · exact ih₂ |
| · exact Commute.zero_right A |
|
|
| @[simp] theorem rightWick_vacuum (w : List ι) : |
| rightWick w (basisVector []) = basisVector w.reverse := by |
| induction w using rightWick.induct with |
| | case1 => simp [rightWick] |
| | case2 i => simp [rightWick, basisVector] |
| | case3 i j w ih₁ ih₂ => |
| simp only [rightWick, sub_apply, mul_apply_eq_comp, ih₁] |
| by_cases h : i = j <;> |
| simp only [h, ↓reduceIte, ih₂] <;> |
| simp [basisVector, List.reverse_cons, h, rightSemicircular_single_append] |
|
|
| @[simp] theorem adjoint_rightWick_vacuum (w : List ι) : |
| star (rightWick w) (basisVector []) = basisVector w := by |
| induction w using rightWick.induct with |
| | case1 => simp [rightWick] |
| | case2 i => |
| rw [rightWick, (rightSemicircular_selfAdjoint i).star_eq] |
| simp [basisVector] |
| | case3 i j w ih₁ ih₂ => |
| have hc : Commute (star (rightWick (j :: w))) (semicircular i) := by |
| have h := commute_rightWick (semicircular i) (semicircular_commutes_right i) (j :: w) |
| have hs := congrArg star h.eq |
| change _ * _ = _ * _ |
| simpa only [star_mul, (semicircular_selfAdjoint i).star_eq] using hs |
| have hv : rightSemicircular i (basisVector ([] : List ι)) = |
| semicircular i (basisVector []) := by simp [basisVector] |
| rw [rightWick, star_sub (rightSemicircular i * rightWick (j :: w)) _, star_mul, |
| (rightSemicircular_selfAdjoint i).star_eq, |
| sub_apply, mul_apply_eq_comp] |
| rw [hv, ← mul_apply_eq_comp, hc.eq, mul_apply_eq_comp, ih₁] |
| by_cases h : i = j <;> |
| simp only [h, ↓reduceIte, star_zero, ih₂] <;> |
| simp [h, basisVector] |
|
|
| def algebra (ι : Type) [DecidableEq ι] : VonNeumannAlgebra (Space ι) where |
| toStarSubalgebra := StarSubalgebra.centralizer ℂ (Set.range (rightSemicircular (ι := ι))) |
| centralizer_centralizer' := Set.centralizer_centralizer_centralizer _ |
|
|
| theorem mem_algebra_iff (A : Space ι →L[ℂ] Space ι) : |
| A ∈ algebra ι ↔ ∀ i, Commute A (rightSemicircular i) := by |
| change A ∈ StarSubalgebra.centralizer ℂ (Set.range rightSemicircular) ↔ _ |
| rw [StarSubalgebra.mem_centralizer_iff] |
| simp only [Set.forall_mem_range, (rightSemicircular_selfAdjoint _).star_eq, and_self] |
| exact forall_congr' fun i => eq_comm |
|
|
| theorem semicircular_mem (i : ι) : semicircular i ∈ algebra ι := |
| (mem_algebra_iff _).mpr (semicircular_commutes_right i) |
|
|
| theorem vacuum_separating (A : Space ι →L[ℂ] Space ι) (hA : A ∈ algebra ι) |
| (h0 : A (basisVector []) = 0) : A = 0 := by |
| have hsingle (w : List ι) : A (basisVector w) = 0 := by |
| rw [← List.reverse_reverse w, ← rightWick_vacuum] |
| rw [← mul_apply_eq_comp, |
| (commute_rightWick A ((mem_algebra_iff A).mp hA) w.reverse).eq, |
| mul_apply_eq_comp, h0, map_zero] |
| apply lp.ext_continuousLinearMap (by norm_num : (2 : ℝ≥0∞) ≠ ⊤) |
| intro w |
| apply ContinuousLinearMap.ext |
| intro z |
| change A (lp.single 2 w z) = 0 |
| have hz : lp.single 2 w z = z • basisVector w := by |
| simp [basisVector, ← lp.single_smul] |
| rw [hz, map_smul, hsingle, smul_zero] |
|
|
| theorem adjoint_vacuum_coefficient (A : Space ι →L[ℂ] Space ι) |
| (hA : A ∈ algebra ι) (w : List ι) : |
| (star A (basisVector [])) w = star ((A (basisVector [])) w.reverse) := by |
| have hw : A (basisVector w) = rightWick w.reverse (A (basisVector [])) := by |
| rw [← mul_apply_eq_comp, |
| ← (commute_rightWick A ((mem_algebra_iff A).mp hA) w.reverse).eq, |
| mul_apply_eq_comp, rightWick_vacuum, List.reverse_reverse] |
| calc |
| (star A (basisVector [])) w = inner ℂ (basisVector w) (star A (basisVector [])) := by |
| simp [basisVector, lp.inner_single_left] |
| _ = inner ℂ (A (basisVector w)) (basisVector []) := |
| ContinuousLinearMap.adjoint_inner_right A _ _ |
| _ = inner ℂ (rightWick w.reverse (A (basisVector []))) (basisVector []) := by rw [hw] |
| _ = inner ℂ (A (basisVector [])) (star (rightWick w.reverse) (basisVector [])) := |
| (ContinuousLinearMap.adjoint_inner_right _ _ _).symm |
| _ = star ((A (basisVector [])) w.reverse) := by |
| rw [adjoint_rightWick_vacuum] |
| simp [basisVector, lp.inner_single_right] |
|
|
| theorem vacuum_product_formula (A B : Space ι →L[ℂ] Space ι) |
| (hA : A ∈ algebra ι) : |
| inner ℂ (basisVector []) ((A * B) (basisVector [])) = |
| ∑' w : List ι, (B (basisVector [])) w * (A (basisVector [])) w.reverse := by |
| rw [mul_apply_eq_comp, ← ContinuousLinearMap.adjoint_inner_left A, |
| ← ContinuousLinearMap.star_eq_adjoint, lp.inner_eq_tsum] |
| apply tsum_congr |
| intro w |
| rw [RCLike.inner_apply, adjoint_vacuum_coefficient A hA w] |
| simp |
|
|
| theorem vacuum_tracial (A : Space ι →L[ℂ] Space ι) (hA : A ∈ algebra ι) |
| (B : Space ι →L[ℂ] Space ι) (hB : B ∈ algebra ι) : |
| inner ℂ (basisVector []) ((A * B) (basisVector [])) = |
| inner ℂ (basisVector []) ((B * A) (basisVector [])) := by |
| rw [vacuum_product_formula A B hA, vacuum_product_formula B A hB] |
| let e : List ι ≃ List ι := ⟨List.reverse, List.reverse, List.reverse_reverse, List.reverse_reverse⟩ |
| calc |
| (∑' w : List ι, (B (basisVector [])) w * (A (basisVector [])) w.reverse) = |
| ∑' w : List ι, (B (basisVector [])) w.reverse * (A (basisVector [])) w := by |
| simpa [e] using (e.tsum_eq (fun w : List ι => |
| (B (basisVector [])) w * (A (basisVector [])) w.reverse)).symm |
| _ = _ := tsum_congr fun _ => mul_comm _ _ |
|
|
| def tracialVector (ι : Type) [DecidableEq ι] : TracialVector (algebra ι) where |
| vacuum := basisVector [] |
| norm_vacuum := by |
| simp [basisVector, lp.norm_single (E := fun _ : List ι => ℂ) (p := 2)] |
| tracial := vacuum_tracial |
| separating := vacuum_separating |
|
|
| def vacuumProjection : Space ι →L[ℂ] Space ι := |
| InnerProductSpace.rankOne ℂ (basisVector []) (basisVector []) |
|
|
| @[simp] theorem vacuumProjection_single (w : List ι) (z : ℂ) : |
| vacuumProjection (lp.single 2 w z) = if w = [] then lp.single 2 [] z else 0 := by |
| by_cases h : w = [] |
| · subst w |
| simp [vacuumProjection, basisVector, lp.inner_single_left, ← lp.single_smul] |
| · simp [vacuumProjection, basisVector, lp.inner_single_left, lp.single_apply, h] |
|
|
| theorem creation_commutes_rightCreation (i j : ι) : |
| Commute (creation i) (rightCreation j) := by |
| show creation i * rightCreation j = rightCreation j * creation i |
| apply lp.ext_continuousLinearMap (by norm_num : (2 : ℝ≥0∞) ≠ ⊤) |
| intro w |
| apply ContinuousLinearMap.ext |
| intro z |
| change creation i (rightCreation j (lp.single 2 w z)) = |
| rightCreation j (creation i (lp.single 2 w z)) |
| simp |
|
|
| theorem rightAnnihilation_creation (i j : ι) : |
| star (rightCreation i) * creation j = creation j * star (rightCreation i) + |
| if i = j then vacuumProjection else 0 := by |
| apply lp.ext_continuousLinearMap (by norm_num : (2 : ℝ≥0∞) ≠ ⊤) |
| intro w |
| apply ContinuousLinearMap.ext |
| intro z |
| change star (rightCreation i) (creation j (lp.single 2 w z)) = |
| creation j (star (rightCreation i) (lp.single 2 w z)) + |
| (if i = j then vacuumProjection else 0) (lp.single 2 w z) |
| induction w using List.reverseRecOn with |
| | nil => |
| rw [creation_single, show [j] = [] ++ [j] from rfl, rightAnnihilation_single_append] |
| by_cases h : i = j <;> simp [h] |
| | append_singleton w k _ => |
| rw [creation_single, show j :: (w ++ [k]) = (j :: w) ++ [k] from rfl, |
| rightAnnihilation_single_append] |
| have hp : (if i = j then vacuumProjection else 0) (lp.single 2 (w ++ [k]) z) = 0 := by |
| split_ifs <;> simp |
| rw [hp, rightAnnihilation_single_append] |
| by_cases h : i = k <;> simp [h] |
|
|
| theorem rightAnnihilation_semicircular (i j : ι) : |
| star (rightCreation i) * semicircular j = semicircular j * star (rightCreation i) + |
| if i = j then vacuumProjection else 0 := by |
| have h : star (rightCreation i) * star (creation j) = |
| star (creation j) * star (rightCreation i) := by |
| simpa only [star_mul] using congrArg star (creation_commutes_rightCreation j i).eq |
| rw [semicircular, mul_add, add_mul, rightAnnihilation_creation, h] |
| abel |
|
|
| def derivativeKernel {n : ℕ} (i : Fin n) (w : List (Fin n)) : |
| Space (Fin n) →L[ℂ] Space (Fin n) := |
| ∑ r : Fin w.length, if w[r.val] = i then |
| wordEval semicircular (w.take r.val) * vacuumProjection * |
| wordEval semicircular (w.drop (r.val + 1)) else 0 |
|
|
| @[simp] theorem derivativeKernel_nil {n : ℕ} (i : Fin n) : |
| derivativeKernel i [] = 0 := by simp [derivativeKernel] |
|
|
| theorem derivativeKernel_cons {n : ℕ} (i j : Fin n) (w : List (Fin n)) : |
| derivativeKernel i (j :: w) = |
| (if j = i then vacuumProjection * wordEval semicircular w else 0) + |
| semicircular j * derivativeKernel i w := by |
| simp only [derivativeKernel, List.length_cons, Fin.sum_univ_succ] |
| simp only [Fin.val_zero, Fin.val_succ, List.getElem_cons_zero, List.getElem_cons_succ, |
| List.take_zero, List.take_succ_cons, List.drop_succ_cons, Nat.zero_add, |
| wordEval, List.map_nil, List.prod_nil, one_mul, Finset.mul_sum] |
| congr 1 |
| apply Finset.sum_congr rfl |
| intro r _ |
| split_ifs <;> simp [List.map_cons, List.prod_cons, mul_assoc] |
|
|
| theorem rightAnnihilation_word {n : ℕ} (i : Fin n) (w : List (Fin n)) : |
| star (rightCreation i) * wordEval semicircular w = |
| wordEval semicircular w * star (rightCreation i) + derivativeKernel i w := by |
| induction w with |
| | nil => simp [wordEval] |
| | cons j w ih => |
| have hw : wordEval semicircular (j :: w) = semicircular j * wordEval semicircular w := by |
| simp [wordEval] |
| rw [hw, derivativeKernel_cons, ← mul_assoc, rightAnnihilation_semicircular, |
| add_mul, mul_assoc, ih, mul_add] |
| by_cases h : i = j <;> simp [h, eq_comm, mul_assoc, add_assoc, add_comm, add_left_comm] |
|
|
| theorem trace_projection_product (A B : Space ι →L[ℂ] Space ι) : |
| trace (tracialVector ι) (A * vacuumProjection * B) = |
| trace (tracialVector ι) A * trace (tracialVector ι) B := by |
| simp only [trace, tracialVector, vacuumProjection, mul_apply_eq_comp, |
| InnerProductSpace.rankOne_apply, map_smul, inner_smul_right] |
| exact mul_comm _ _ |
|
|
| theorem trace_derivativeKernel {n : ℕ} (i : Fin n) (w : List (Fin n)) : |
| trace (tracialVector (Fin n)) (derivativeKernel i w) = |
| derivativeMoment (tracialVector (Fin n)) semicircular i w := by |
| rw [derivativeKernel, trace_sum] |
| apply Finset.sum_congr rfl |
| intro r _ |
| split_ifs <;> simp [trace_projection_product, wordMoment] |
|
|
| theorem trace_semicircular_left (i : ι) (A : Space ι →L[ℂ] Space ι) : |
| trace (tracialVector ι) (semicircular i * A) = |
| trace (tracialVector ι) (star (rightCreation i) * A) := by |
| simp only [trace, tracialVector, mul_apply_eq_comp] |
| rw [← ContinuousLinearMap.adjoint_inner_left (semicircular i), |
| ← ContinuousLinearMap.adjoint_inner_left (star (rightCreation i))] |
| simp only [← ContinuousLinearMap.star_eq_adjoint, star_star, |
| (semicircular_selfAdjoint i).star_eq, basisVector, |
| semicircular_single_nil, rightCreation_single, List.nil_append] |
|
|
| theorem semicircular_integration_by_parts {n : ℕ} (i : Fin n) (w : List (Fin n)) : |
| trace (tracialVector (Fin n)) (semicircular i * wordEval semicircular w) = |
| derivativeMoment (tracialVector (Fin n)) semicircular i w := by |
| rw [trace_semicircular_left, rightAnnihilation_word, trace_add, trace_derivativeKernel] |
| suffices trace (tracialVector (Fin n)) |
| (wordEval semicircular w * star (rightCreation i)) = 0 by rw [this, zero_add] |
| simp [trace, tracialVector, basisVector, mul_apply_eq_comp] |
|
|
| theorem semicircular_conjugateSystem (n : ℕ) : |
| ConjugateSystem (tracialVector (Fin n)) semicircular |
| (fun i => semicircular i (basisVector [])) := by |
| intro i |
| constructor |
| · apply Submodule.le_topologicalClosure |
| apply Submodule.subset_span |
| use [i] |
| simp [wordEval, tracialVector] |
| · intro w |
| rw [← semicircular_integration_by_parts] |
| change inner ℂ (semicircular i (basisVector [])) (wordEval semicircular w (basisVector [])) = |
| inner ℂ (basisVector []) (semicircular i (wordEval semicircular w (basisVector []))) |
| conv_lhs => rw [← (semicircular_selfAdjoint i).star_eq] |
| exact ContinuousLinearMap.adjoint_inner_left _ _ _ |
|
|
| theorem semicircular_freeFisher (n : ℕ) : |
| freeFisher (tracialVector (Fin n)) semicircular = (n : ℝ≥0∞) := by |
| rw [freeFisher_eq_of_conjugate _ (semicircular_conjugateSystem n)] |
| simp [basisVector, lp.norm_single (E := fun _ : List (Fin n) => ℂ) (p := 2)] |
|
|
| theorem semicircular_moment_succ {n : ℕ} (i : Fin n) (k : ℕ) : |
| trace (tracialVector (Fin n)) (semicircular i ^ (k + 1)) = |
| ∑ r ∈ Finset.range k, trace (tracialVector (Fin n)) (semicircular i ^ r) * |
| trace (tracialVector (Fin n)) (semicircular i ^ (k - (r + 1))) := by |
| have hw (j : ℕ) : wordEval semicircular (List.replicate j i) = semicircular i ^ j := by |
| simp [wordEval] |
| rw [pow_succ', ← hw k, semicircular_integration_by_parts] |
| simp only [derivativeMoment, List.getElem_replicate, |
| ite_true, wordMoment, List.take_replicate, List.drop_replicate] |
| simp only [hw] |
| rw [Fin.sum_univ_eq_sum_range (fun r => |
| trace (tracialVector (Fin n)) (semicircular i ^ min r k) * |
| trace (tracialVector (Fin n)) (semicircular i ^ (k - (r + 1)))) |
| (List.replicate k i).length, List.length_replicate] |
| apply Finset.sum_congr rfl |
| intro r hr |
| rw [min_eq_left (Nat.le_of_lt (Finset.mem_range.mp hr))] |
|
|
| private theorem sum_range_double {α : Type u2} [AddCommMonoid α] (f : ℕ → α) (k : ℕ) : |
| ∑ r ∈ Finset.range (2 * k), f r = |
| ∑ r ∈ Finset.range k, (f (2 * r) + f (2 * r + 1)) := by |
| induction k with |
| | zero => simp |
| | succ k ih => |
| rw [Nat.mul_succ, show 2 * k + 2 = (2 * k + 1) + 1 by omega] |
| rw [Finset.sum_range_succ, Finset.sum_range_succ, ih, |
| Finset.sum_range_succ, add_assoc] |
|
|
| theorem semicircular_moments {n : ℕ} (i : Fin n) (k : ℕ) : |
| trace (tracialVector (Fin n)) (semicircular i ^ k) = |
| if Even k then (catalan (k / 2) : ℂ) else 0 := by |
| induction k using Nat.strong_induction_on with |
| | h k ih => |
| rcases k with _ | k |
| · simp [trace, tracialVector, basisVector] |
| · rw [semicircular_moment_succ] |
| rcases Nat.even_or_odd' k with ⟨m, rfl | rfl⟩ |
| · rw [ite_eq_right (by rw [Nat.even_iff]; omega : ¬Even (2 * m + 1))] |
| apply Finset.sum_eq_zero |
| intro r hr |
| have hr' := Finset.mem_range.mp hr |
| rw [ih r (by omega), ih (2 * m - (r + 1)) (by omega)] |
| rcases Nat.mod_two_eq_zero_or_one r with he | ho |
| · have : ¬ Even (2 * m - (r + 1)) := by rw [Nat.even_iff]; omega |
| simp [this] |
| · have : ¬ Even r := by rw [Nat.even_iff]; omega |
| simp [this] |
| · have he : Even (2 * m + 1 + 1) := by rw [Nat.even_iff]; omega |
| rw [ite_eq_left he, show (2 * m + 1 + 1) / 2 = m + 1 by omega, |
| Finset.sum_range_succ, sum_range_double] |
| have hs : ∀ r < m, |
| trace (tracialVector (Fin n)) (semicircular i ^ (2 * r)) * |
| trace (tracialVector (Fin n)) (semicircular i ^ (2 * m + 1 - (2 * r + 1))) + |
| trace (tracialVector (Fin n)) (semicircular i ^ (2 * r + 1)) * |
| trace (tracialVector (Fin n)) (semicircular i ^ (2 * m + 1 - (2 * r + 1 + 1))) = |
| (catalan r : ℂ) * (catalan (m - r) : ℂ) := by |
| intro r hr |
| rw [ih (2 * r) (by omega), ih (2 * m + 1 - (2 * r + 1)) (by omega), |
| ih (2 * r + 1) (by omega)] |
| have h₁ : Even (2 * r) := by rw [Nat.even_iff]; omega |
| have h₂ : Even (2 * m + 1 - (2 * r + 1)) := by rw [Nat.even_iff]; omega |
| have h₃ : ¬Even (2 * r + 1) := by rw [Nat.even_iff]; omega |
| simp only [h₁, h₂, h₃, ite_true, ite_false, zero_mul, add_zero] |
| rw [show 2 * r / 2 = r by omega, |
| show (2 * m + 1 - (2 * r + 1)) / 2 = m - r by omega] |
| rw [Finset.sum_congr rfl (fun r hr => hs r (Finset.mem_range.mp hr))] |
| rw [ih (2 * m) (by omega), ih (2 * m + 1 - (2 * m + 1)) (by omega)] |
| have h₁ : Even (2 * m) := by rw [Nat.even_iff]; omega |
| simp only [Nat.sub_self, h₁, ite_true, show Even (0 : ℕ) from ⟨0, rfl⟩, Nat.zero_div, |
| catalan_zero, Nat.cast_one, mul_one] |
| rw [show 2 * m / 2 = m by omega, catalan_succ, |
| Nat.cast_sum, ← Fin.sum_univ_eq_sum_range] |
| rw [Fin.sum_univ_castSucc] |
| simp only [Fin.val_castSucc, Fin.val_last, Nat.sub_self, catalan_zero, |
| mul_one, Nat.cast_mul] |
|
|
| def wordSpace (J : Set ι) : Submodule ℂ (Space ι) := |
| Submodule.span ℂ {x | ∃ w : List ι, (∀ i ∈ w, i ∈ J) ∧ x = basisVector w} |
|
|
| def startsIn (J : Set ι) : Submodule ℂ (Space ι) := |
| Submodule.span ℂ {x | ∃ i ∈ J, ∃ w : List ι, x = basisVector (i :: w)} |
|
|
| def suffixEmbedding (w : List ι) : Space ι →L[ℂ] Space ι := |
| (injectionIsometry (fun v => v ++ w) (List.append_left_injective w)).toContinuousLinearMap |
|
|
| @[simp] theorem suffixEmbedding_basis (w v : List ι) : |
| suffixEmbedding w (basisVector v) = basisVector (v ++ w) := |
| injectionIsometry_single _ (List.append_left_injective w) v 1 |
|
|
| theorem basis_mem_wordSpace {J : Set ι} {w : List ι} (hw : ∀ i ∈ w, i ∈ J) : |
| basisVector w ∈ wordSpace J := Submodule.subset_span ⟨w, hw, rfl⟩ |
|
|
| theorem vacuum_mem_wordSpace (J : Set ι) : basisVector [] ∈ wordSpace J := |
| basis_mem_wordSpace (by simp) |
|
|
| theorem semicircular_preserves_wordSpace {J : Set ι} {i : ι} (hi : i ∈ J) |
| {x : Space ι} (hx : x ∈ wordSpace J) : semicircular i x ∈ wordSpace J := by |
| induction hx using Submodule.span_induction with |
| | mem x hx => |
| obtain ⟨w, hw, rfl⟩ := hx |
| cases w with |
| | nil => |
| simpa [basisVector] using |
| (basis_mem_wordSpace (show ∀ j ∈ [i], j ∈ J by simpa using hi)) |
| | cons j w => |
| change semicircular i (lp.single 2 (j :: w) 1) ∈ wordSpace J |
| rw [semicircular_single_cons] |
| apply Submodule.add_mem |
| · exact basis_mem_wordSpace (by simpa using And.intro hi hw) |
| · split_ifs |
| · exact basis_mem_wordSpace (fun k hk => hw k (List.mem_cons_of_mem _ hk)) |
| · exact Submodule.zero_mem _ |
| | zero => simp |
| | add x y _ _ hx hy => simpa using (wordSpace J).add_mem hx hy |
| | smul z x _ hx => simpa using (wordSpace J).smul_mem z hx |
|
|
| theorem semicircular_suffix {J : Set ι} {i : ι} (hi : i ∈ J) |
| (w : List ι) (hw : ∀ j ∈ w.head?, j ∉ J) {x : Space ι} (hx : x ∈ wordSpace J) : |
| semicircular i (suffixEmbedding w x) = suffixEmbedding w (semicircular i x) := by |
| induction hx using Submodule.span_induction with |
| | mem x hx => |
| obtain ⟨v, hv, rfl⟩ := hx |
| cases v with |
| | nil => |
| cases w with |
| | nil => simp [basisVector, suffixEmbedding, injectionIsometry_single] |
| | cons j w => |
| have hij : i ≠ j := by intro hij; subst i; exact hw j (by simp) hi |
| simp [basisVector, suffixEmbedding, injectionIsometry_single, hij] |
| | cons j v => |
| change semicircular i (suffixEmbedding w (lp.single 2 (j :: v) 1)) = _ |
| rw [show suffixEmbedding w (lp.single 2 (j :: v) 1) = |
| lp.single 2 (j :: (v ++ w)) 1 from suffixEmbedding_basis w (j :: v)] |
| simp only [basisVector, semicircular_single_cons, map_add] |
| split_ifs <;> simp [suffixEmbedding, injectionIsometry_single] |
| | zero => simp |
| | add x y _ _ hx hy => simp [map_add, hx, hy] |
| | smul z x _ hx => simp [hx] |
|
|
| theorem adjoin_suffix {J : Set ι} {A : Space ι →L[ℂ] Space ι} |
| (hA : A ∈ Algebra.adjoin ℂ (semicircular '' J)) (w : List ι) |
| (hw : ∀ j ∈ w.head?, j ∉ J) : |
| ∀ x ∈ wordSpace J, |
| A x ∈ wordSpace J ∧ A (suffixEmbedding w x) = suffixEmbedding w (A x) := by |
| induction hA using Algebra.adjoin_induction with |
| | mem A hA => |
| obtain ⟨i, hi, rfl⟩ := hA |
| exact fun x hx => ⟨semicircular_preserves_wordSpace hi hx, semicircular_suffix hi w hw hx⟩ |
| | algebraMap z => |
| intro x hx |
| constructor |
| · simpa using (wordSpace J).smul_mem z hx |
| · simp |
| | add A B _ _ hA hB => |
| intro x hx |
| exact ⟨(wordSpace J).add_mem (hA x hx).1 (hB x hx).1, |
| by simp only [add_apply, (hA x hx).2, (hB x hx).2, map_add]⟩ |
| | mul A B _ _ hA hB => |
| intro x hx |
| exact ⟨(hA (B x) (hB x hx).1).1, |
| by simp only [mul_apply_eq_comp, (hB x hx).2, (hA (B x) (hB x hx).1).2]⟩ |
|
|
| theorem centered_wordSpace_suffix {J : Set ι} {x : Space ι} (hx : x ∈ wordSpace J) |
| (w : List ι) : suffixEmbedding w (x - x [] • basisVector []) ∈ startsIn J := by |
| induction hx using Submodule.span_induction with |
| | mem x hx => |
| obtain ⟨v, hv, rfl⟩ := hx |
| cases v with |
| | nil => simp [basisVector, lp.single_apply] |
| | cons j v => |
| have hz : (basisVector (j :: v)) [] = 0 := by simp [basisVector, lp.single_apply] |
| rw [hz, zero_smul, sub_zero, suffixEmbedding_basis] |
| exact Submodule.subset_span ⟨j, hv j (by simp), v ++ w, rfl⟩ |
| | zero => simp |
| | add x y _ _ hx hy => |
| have h : (x + y) - (x + y) [] • basisVector [] = |
| (x - x [] • basisVector []) + (y - y [] • basisVector []) := by |
| change (x + y) - (x [] + y []) • basisVector [] = _ |
| rw [add_smul]; abel |
| rw [h, map_add] |
| exact (startsIn J).add_mem hx hy |
| | smul z x _ hx => |
| have h : z • x - (z • x) [] • basisVector [] = |
| z • (x - x [] • basisVector []) := by |
| change z • x - (z * x []) • basisVector [] = _ |
| rw [smul_sub, smul_smul] |
| rw [h, map_smul] |
| exact (startsIn J).smul_mem z hx |
|
|
| theorem trace_eq_vacuum_coefficient (A : Space ι →L[ℂ] Space ι) : |
| trace (tracialVector ι) A = (A (basisVector [])) [] := by |
| simp [trace, tracialVector, basisVector, lp.inner_single_left] |
|
|
| theorem centered_adjoin_basis {J : Set ι} {A : Space ι →L[ℂ] Space ι} |
| (hA : A ∈ Algebra.adjoin ℂ (semicircular '' J)) |
| (hcenter : trace (tracialVector ι) A = 0) (w : List ι) |
| (hw : ∀ j ∈ w.head?, j ∉ J) : A (basisVector w) ∈ startsIn J := by |
| have h := adjoin_suffix hA w hw (basisVector []) (vacuum_mem_wordSpace J) |
| have hzero : (A (basisVector [])) [] = 0 := by |
| rwa [← trace_eq_vacuum_coefficient] |
| have hs := centered_wordSpace_suffix h.1 w |
| simpa only [hzero, zero_smul, sub_zero, ← h.2, suffixEmbedding_basis, List.nil_append] using hs |
|
|
| theorem centered_adjoin_startsIn {J K : Set ι} (hJK : Disjoint J K) |
| {A : Space ι →L[ℂ] Space ι} (hA : A ∈ Algebra.adjoin ℂ (semicircular '' J)) |
| (hcenter : trace (tracialVector ι) A = 0) {x : Space ι} (hx : x ∈ startsIn K) : |
| A x ∈ startsIn J := by |
| induction hx using Submodule.span_induction with |
| | mem x hx => |
| obtain ⟨i, hi, w, rfl⟩ := hx |
| apply centered_adjoin_basis hA hcenter |
| intro j hj hjJ |
| have : j = i := by simpa using hj.symm |
| subst j |
| exact Set.disjoint_left.mp hJK hjJ hi |
| | zero => simp |
| | add x y _ _ hx hy => simpa using (startsIn J).add_mem hx hy |
| | smul z x _ hx => simpa using (startsIn J).smul_mem z hx |
|
|
| theorem startsIn_vacuum_zero {J : Set ι} {x : Space ι} (hx : x ∈ startsIn J) : x [] = 0 := by |
| induction hx using Submodule.span_induction with |
| | mem x hx => |
| obtain ⟨i, _, w, rfl⟩ := hx |
| simp [basisVector, lp.single_apply] |
| | zero => rfl |
| | add x y _ _ hx hy => simp [hx, hy] |
| | smul z x _ hx => simp [hx] |
|
|
| theorem alternating_product_starts {κ : Type} (J : κ → Set ι) |
| (hJ : Pairwise (fun i j => Disjoint (J i) (J j))) : |
| ∀ (k : ℕ) (hk : 0 < k) (j : Fin k → κ) (a : Fin k → Space ι →L[ℂ] Space ι), |
| (∀ r, a r ∈ Algebra.adjoin ℂ (semicircular '' J (j r))) → |
| (∀ r, trace (tracialVector ι) (a r) = 0) → |
| (∀ (r : ℕ) (hr : r + 1 < k), |
| j ⟨r, Nat.lt_trans (Nat.lt_succ_self r) hr⟩ ≠ j ⟨r + 1, hr⟩) → |
| (List.ofFn a).prod (basisVector []) ∈ startsIn (J (j ⟨0, hk⟩)) := by |
| intro k |
| induction k with |
| | zero => intro hk; omega |
| | succ k ih => |
| intro hk j a ha hc hadj |
| rw [List.ofFn_succ, List.prod_cons, mul_apply_eq_comp] |
| cases k with |
| | zero => |
| simpa using centered_adjoin_basis (ha 0) (hc 0) [] (by simp) |
| | succ k => |
| have htail := ih (by omega) (fun r => j r.succ) (fun r => a r.succ) |
| (fun r => ha r.succ) (fun r => hc r.succ) (by |
| intro r hr |
| exact hadj (r + 1) (by omega)) |
| exact centered_adjoin_startsIn (hJ (hadj 0 (by omega))) (ha 0) (hc 0) htail |
|
|
| theorem free_grouped_semicircular {κ : Type} (J : κ → Set ι) |
| (hJ : Pairwise (fun i j => Disjoint (J i) (J j))) : |
| FreeSubalgebras (tracialVector ι) |
| (fun j => Algebra.adjoin ℂ (semicircular '' J j)) := by |
| intro k hk j a ha hc hadj |
| rw [trace_eq_vacuum_coefficient] |
| exact startsIn_vacuum_zero (alternating_product_starts J hJ k hk j a ha hc hadj) |
|
|
| theorem free_semicircular : |
| FreeSubalgebras (tracialVector ι) (fun i : ι => Algebra.adjoin ℂ {semicircular i}) := by |
| simpa only [Set.image_singleton] using free_grouped_semicircular (fun i : ι => {i}) |
| (by intro i j hij; exact Set.disjoint_singleton.mpr hij) |
|
|
| theorem freeStandardNoise {m n : ℕ} (J : Set (Fin m)) |
| (X : Fin n → Space (Fin m) →L[ℂ] Space (Fin m)) |
| (hX : ∀ i, X i ∈ Algebra.adjoin ℂ (semicircular '' J)) |
| (σ : Fin n → Fin m) (hσ : Function.Injective σ) (hs : ∀ i, σ i ∉ J) : |
| FreeStandardNoise (tracialVector (Fin m)) X (fun i => semicircular (σ i)) := by |
| refine ⟨fun i k => semicircular_moments (σ i) k, ?_⟩ |
| let K : Option (Fin n) → Set (Fin m) := fun j => match j with |
| | none => J |
| | some i => {σ i} |
| have hK : Pairwise (fun i j => Disjoint (K i) (K j)) := by |
| intro i j hij |
| cases i with |
| | none => |
| cases j with |
| | none => exact False.elim (hij rfl) |
| | some j => exact Set.disjoint_singleton_right.mpr (hs j) |
| | some i => |
| cases j with |
| | none => exact Set.disjoint_singleton_left.mpr (hs i) |
| | some j => exact Set.disjoint_singleton.mpr (fun h => hij (congrArg some (hσ h))) |
| apply (free_grouped_semicircular K hK).mono |
| intro j |
| cases j with |
| | none => |
| apply Algebra.adjoin_le |
| rintro _ ⟨i, rfl⟩ |
| exact hX i |
| | some i => simp [K] |
|
|
| theorem rightAnnihilation_adjoin {J : Set ι} {i : ι} (hi : i ∉ J) |
| {A : Space ι →L[ℂ] Space ι} (hA : A ∈ Algebra.adjoin ℂ (semicircular '' J)) : |
| Commute (star (rightCreation i)) A := by |
| induction hA using Algebra.adjoin_induction with |
| | mem A hA => |
| obtain ⟨j, hj, rfl⟩ := hA |
| have hij : i ≠ j := by intro h; subst j; exact hi hj |
| show _ * _ = _ * _ |
| simpa [hij] using rightAnnihilation_semicircular i j |
| | algebraMap z => exact Algebra.commutes z _ |>.symm |
| | add A B _ _ hA hB => exact hA.add_right hB |
| | mul A B _ _ hA hB => exact hA.mul_right hB |
|
|
| theorem heat_freeFisher_le {n : ℕ} (J : Set ι) |
| (X : Fin n → Space ι →L[ℂ] Space ι) |
| (hX : ∀ i, X i ∈ Algebra.adjoin ℂ (semicircular '' J)) |
| (σ : Fin n → ι) (hσ : Function.Injective σ) (hs : ∀ i, σ i ∉ J) |
| (u : ℝ) (hu : 0 < u) : |
| freeFisher (tracialVector ι) (heatTuple X (fun i => semicircular (σ i)) u) ≤ |
| ENNReal.ofReal ((n : ℝ) / u) := by |
| let Z := heatTuple X (fun i => semicircular (σ i)) u |
| let η : Fin n → Space ι := fun i => ((Real.sqrt u)⁻¹ : ℂ) • basisVector [σ i] |
| have hc (i j : Fin n) : star (rightCreation (σ i)) * Z j = |
| Z j * star (rightCreation (σ i)) + |
| if j = i then (Real.sqrt u : ℂ) • vacuumRankOne (tracialVector ι) else 0 := by |
| change _ * (X j + (Real.sqrt u : ℂ) • semicircular (σ j)) = _ |
| rw [mul_add, mul_smul_comm, (rightAnnihilation_adjoin (hs i) (hX j)).eq, |
| rightAnnihilation_semicircular] |
| change _ = (X j + (Real.sqrt u : ℂ) • semicircular (σ j)) * |
| star (rightCreation (σ i)) + |
| if j = i then (Real.sqrt u : ℂ) • vacuumProjection else 0 |
| by_cases hij : j = i |
| · subst j |
| simp only [ite_true, add_mul, smul_mul_assoc, add_assoc] |
| congr 1 |
| exact smul_add _ _ _ |
| · have hneq : σ i ≠ σ j := fun h => hij (hσ h).symm |
| simp [hij, hneq, add_mul, smul_mul_assoc] |
| have hu' : Real.sqrt u ≠ 0 := ne_of_gt (Real.sqrt_pos.mpr hu) |
| have hη (i : Fin n) (w : List (Fin n)) : |
| inner ℂ (η i) (wordEval Z w (tracialVector ι).vacuum) = |
| derivativeMoment (tracialVector ι) Z i w := by |
| have h := commutator_integration_by_parts (tracialVector ι) Z |
| (star (rightCreation (σ i))) i (Real.sqrt u) (hc i) |
| (by simp [tracialVector, basisVector]) w |
| simp only [star_star, tracialVector, basisVector, rightCreation_single, |
| List.nil_append] at h |
| change inner ℂ (((Real.sqrt u : ℂ)⁻¹) • lp.single 2 [σ i] 1) |
| (wordEval Z w (lp.single 2 [] 1)) = _ |
| rw [inner_smul_left, h] |
| simp [hu', tracialVector, basisVector] |
| refine (freeFisher_le_testVectors (tracialVector ι) Z η hη).trans ?_ |
| apply ENNReal.ofReal_le_ofReal |
| have hnorm (i : Fin n) : ‖η i‖ ^ 2 = u⁻¹ := by |
| simp [η, norm_smul, basisVector, norm_inv, |
| lp.norm_single (E := fun _ : List ι => ℂ) (p := 2), |
| abs_of_nonneg (Real.sqrt_nonneg u), inv_pow, Real.sq_sqrt (le_of_lt hu)] |
| simp [hnorm, div_eq_mul_inv] |
|
|
| end Fock |
|
|
| namespace LabelHilbert |
| open scoped lp |
| variable {α : Type} [DecidableEq α] |
| abbrev Space (α : Type) := lp (fun _ : α => ℂ) 2 |
|
|
| def basis (a : α) : Space α := lp.single 2 a 1 |
|
|
| def coordinateIsometry (a : α) : ℂ →ₗᵢ[ℂ] Space α where |
| toLinearMap := lp.lsingle (𝕜 := ℂ) (E := fun _ : α => ℂ) 2 a |
| norm_map' z := lp.norm_single (E := fun _ : α => ℂ) (p := 2) (by norm_num) a z |
|
|
| theorem orthogonal_coordinates (f : α → α) (hf : Function.Injective f) : |
| OrthogonalFamily ℂ (fun _ : α => ℂ) (fun a => coordinateIsometry (f a)) := by |
| intro a b hab x y |
| change inner ℂ (lp.single (E := fun _ : α => ℂ) 2 (f a) x) |
| (lp.single (E := fun _ : α => ℂ) 2 (f b) y) = 0 |
| rw [lp.inner_single_left, lp.single_apply_ne (E := fun _ : α => ℂ) 2 (f b) y |
| (fun h => hab (hf h))] |
| simp |
|
|
| def lift (f : α → α) (hf : Function.Injective f) : Space α →L[ℂ] Space α := |
| (orthogonal_coordinates f hf).linearIsometry.toContinuousLinearMap |
|
|
| @[simp] theorem lift_single (f : α → α) (hf : Function.Injective f) (a : α) (z : ℂ) : |
| lift f hf (lp.single 2 a z) = lp.single 2 (f a) z := |
| (orthogonal_coordinates f hf).linearIsometry_apply_single z |
|
|
| @[simp] theorem lift_basis (f : α → α) (hf : Function.Injective f) (a : α) : |
| lift f hf (basis a) = basis (f a) := lift_single f hf a 1 |
|
|
| theorem adjoint_apply (f : α → α) (hf : Function.Injective f) (x : Space α) (a : α) : |
| (star (lift f hf) x) a = x (f a) := by |
| have h := ContinuousLinearMap.adjoint_inner_right (lift f hf) (basis a) x |
| simpa [basis, ContinuousLinearMap.star_eq_adjoint, lp.inner_single_left] using h |
|
|
| theorem adjoint_single_of_inverse (f : α → α) (hf : Function.Injective f) |
| (q : α → Option α) (hq : ∀ a b, q b = some a ↔ f a = b) (b : α) (z : ℂ) : |
| star (lift f hf) (lp.single 2 b z) = (q b).elim 0 (fun a => lp.single 2 a z) := by |
| apply lp.ext |
| funext a |
| rw [adjoint_apply] |
| cases h : q b with |
| | none => |
| have hab : f a ≠ b := fun he => by have := (hq a b).mpr he; simp [h] at this |
| simp [lp.single_apply, hab] |
| | some c => |
| have hfc : f c = b := (hq c b).mp h |
| subst b |
| change (lp.single (E := fun _ : α => ℂ) 2 (f c) z) (f a) = |
| (lp.single (E := fun _ : α => ℂ) 2 c z) a |
| by_cases hac : a = c |
| · subst a; simp |
| · rw [lp.single_apply_ne (E := fun _ : α => ℂ) 2 (f c) z (fun h => hac (hf h)), |
| lp.single_apply_ne (E := fun _ : α => ℂ) 2 c z hac] |
|
|
| theorem lift_mul (f g : α → α) (hf : Function.Injective f) (hg : Function.Injective g) : |
| lift f hf * lift g hg = lift (f ∘ g) (hf.comp hg) := by |
| apply lp.ext_continuousLinearMap (by norm_num : (2 : ℝ≥0∞) ≠ ⊤) |
| intro a |
| apply ContinuousLinearMap.ext |
| intro z |
| change lift f hf (lift g hg (lp.single 2 a z)) = _ |
| simp |
|
|
| theorem lift_commute (f g : α → α) (hf : Function.Injective f) (hg : Function.Injective g) |
| (hfg : Function.Commute f g) : Commute (lift f hf) (lift g hg) := by |
| show _ * _ = _ * _ |
| rw [lift_mul, lift_mul] |
| congr 1 |
| exact funext hfg |
|
|
| end LabelHilbert |
|
|
| namespace FreeTensor |
| variable {B N G : Type} [Group G] |
| abbrev Atom (B G : Type) := List B × G |
| abbrev Word (B N G : Type) := Atom B G × List (N × Atom B G) |
|
|
| def empty : Word B N G := (([], 1), []) |
| def push (a : Atom B G) (i : N) (w : Word B N G) : Word B N G := |
| (a, (i, w.1) :: w.2) |
| def append (w : Word B N G) (i : N) (a : Atom B G) : Word B N G := |
| (w.1, w.2 ++ [(i, a)]) |
| def reverseAtom (a : Atom B G) : Atom B G := (a.1.reverse, a.2⁻¹) |
|
|
| @[simp] theorem reverseAtom_involutive (a : Atom B G) : reverseAtom (reverseAtom a) = a := by |
| simp [reverseAtom] |
|
|
| def reverseAux (a : Atom B G) : List (N × Atom B G) → Word B N G |
| | [] => (reverseAtom a, []) |
| | (i,b) :: t => append (reverseAux b t) i (reverseAtom a) |
| def reverse (w : Word B N G) : Word B N G := reverseAux w.1 w.2 |
|
|
| @[simp] theorem reverse_nil (a : Atom B G) : reverse (a, ([] : List (N × Atom B G))) = |
| (reverseAtom a, []) := rfl |
| @[simp] theorem reverse_push (a : Atom B G) (i : N) (w : Word B N G) : |
| reverse (push a i w) = append (reverse w) i (reverseAtom a) := rfl |
|
|
| omit [Group G] in |
| theorem push_append (a b : Atom B G) (i j : N) (w : Word B N G) : |
| push a i (append w j b) = append (push a i w) j b := rfl |
|
|
| theorem reverse_append (w : Word B N G) (i : N) (a : Atom B G) : |
| reverse (append w i a) = push (reverseAtom a) i (reverse w) := by |
| rcases w with ⟨b, t⟩ |
| induction t generalizing b with |
| | nil => rfl |
| | cons c t ih => |
| rcases c with ⟨j,c⟩ |
| change append (reverse (append (c,t) i a)) j (reverseAtom b) = _ |
| rw [ih, ← push_append] |
| rfl |
|
|
| @[simp] theorem reverse_involutive (w : Word B N G) : reverse (reverse w) = w := by |
| rcases w with ⟨a,t⟩ |
| induction t generalizing a with |
| | nil => simp |
| | cons b t ih => |
| rcases b with ⟨i,b⟩ |
| change reverse (append (reverse (b,t)) i (reverseAtom a)) = _ |
| rw [reverse_append, reverseAtom_involutive, ih] |
| rfl |
|
|
| def leftB (b : B) (w : Word B N G) : Word B N G := ((b :: w.1.1, w.1.2), w.2) |
| def leftN (i : N) (w : Word B N G) : Word B N G := push ([],1) i w |
| def leftG (g : G) (w : Word B N G) : Word B N G := ((w.1.1, g * w.1.2), w.2) |
| def rightB (b : B) (w : Word B N G) : Word B N G := reverse (leftB b (reverse w)) |
| def rightN (i : N) (w : Word B N G) : Word B N G := reverse (leftN i (reverse w)) |
| def rightG (g : G) (w : Word B N G) : Word B N G := reverse (leftG g (reverse w)) |
|
|
| omit [Group G] in |
| theorem leftB_injective (b : B) : Function.Injective (leftB (N := N) (G := G) b) := by |
| rintro ⟨⟨v,g⟩,t⟩ ⟨⟨w,h⟩,s⟩ he |
| simpa [leftB] using he |
| theorem leftN_injective (i : N) : Function.Injective (leftN (B := B) (G := G) i) := by |
| rintro ⟨a,t⟩ ⟨b,s⟩ he |
| simpa [leftN, push] using he |
| theorem leftG_injective (g : G) : Function.Injective (leftG (B := B) (N := N) g) := by |
| rintro ⟨⟨v,h⟩,t⟩ ⟨⟨w,k⟩,s⟩ he |
| simpa [leftG] using he |
| theorem reverse_injective : Function.Injective (reverse (B := B) (N := N) (G := G)) := |
| Function.Involutive.injective reverse_involutive |
| theorem rightB_injective (b : B) : Function.Injective (rightB (N := N) (G := G) b) := |
| reverse_injective.comp ((leftB_injective b).comp reverse_injective) |
| theorem rightN_injective (i : N) : Function.Injective (rightN (B := B) (G := G) i) := |
| reverse_injective.comp ((leftN_injective i).comp reverse_injective) |
| theorem rightG_injective (g : G) : Function.Injective (rightG (B := B) (N := N) g) := |
| reverse_injective.comp ((leftG_injective g).comp reverse_injective) |
|
|
| @[simp] theorem rightB_nil (b : B) (a : Atom B G) : |
| rightB b (a, ([] : List (N × Atom B G))) = ((a.1 ++ [b],a.2),[]) := by |
| simp [rightB, leftB, reverse, reverseAux, reverseAtom] |
| @[simp] theorem rightB_push (b : B) (a : Atom B G) (i : N) (w : Word B N G) : |
| rightB b (push a i w) = push a i (rightB b w) := by |
| have h (v : Word B N G) : leftB b (append v i (reverseAtom a)) = |
| append (leftB b v) i (reverseAtom a) := rfl |
| rw [rightB, reverse_push, h, reverse_append, reverseAtom_involutive] |
| rfl |
| @[simp] theorem rightN_eq_append (i : N) (w : Word B N G) : |
| rightN i w = append w i ([],1) := by |
| rw [rightN, leftN, reverse_push, reverse_involutive] |
| simp [reverseAtom] |
|
|
| @[simp] theorem rightG_nil (g : G) (a : Atom B G) : |
| rightG g (a, ([] : List (N × Atom B G))) = ((a.1,a.2 * g⁻¹),[]) := by |
| simp [rightG, leftG, reverse, reverseAux, reverseAtom] |
| @[simp] theorem rightG_push (g : G) (a : Atom B G) (i : N) (w : Word B N G) : |
| rightG g (push a i w) = push a i (rightG g w) := by |
| have h (v : Word B N G) : leftG g (append v i (reverseAtom a)) = |
| append (leftG g v) i (reverseAtom a) := rfl |
| rw [rightG, reverse_push, h, reverse_append, reverseAtom_involutive] |
| rfl |
|
|
| theorem leftB_rightB (b c : B) : |
| Function.Commute (leftB (N := N) (G := G) b) (rightB c) := by |
| rintro ⟨⟨v,g⟩,t⟩ |
| cases t with |
| | nil => simp [leftB] |
| | cons a t => |
| rcases a with ⟨i,a⟩ |
| change leftB b (rightB c (push (v,g) i (a,t))) = |
| rightB c (push (b::v,g) i (a,t)) |
| rw [rightB_push, rightB_push] |
| rfl |
| theorem leftN_rightB (i : N) (b : B) : |
| Function.Commute (leftN (G := G) i) (rightB b) := by |
| intro w |
| exact (rightB_push b ([],1) i w).symm |
| theorem leftG_rightB (g : G) (b : B) : |
| Function.Commute (leftG (N := N) g) (rightB b) := by |
| rintro ⟨⟨v,h⟩,t⟩ |
| cases t with |
| | nil => simp [leftG] |
| | cons a t => |
| rcases a with ⟨i,a⟩ |
| change leftG g (rightB b (push (v,h) i (a,t))) = |
| rightB b (push (v,g*h) i (a,t)) |
| rw [rightB_push, rightB_push] |
| rfl |
| theorem leftB_rightN (b : B) (i : N) : |
| Function.Commute (leftB (G := G) b) (rightN i) := by |
| intro w |
| simp only [rightN_eq_append] |
| rfl |
| theorem leftN_rightN (i j : N) : |
| Function.Commute (leftN (B := B) (G := G) i) (rightN j) := by |
| intro w |
| simp only [rightN_eq_append] |
| rfl |
| theorem leftG_rightN (g : G) (i : N) : |
| Function.Commute (leftG (B := B) g) (rightN i) := by |
| intro w |
| simp only [rightN_eq_append] |
| rfl |
| theorem leftB_rightG (b : B) (g : G) : |
| Function.Commute (leftB (N := N) b) (rightG g) := by |
| rintro ⟨⟨v,h⟩,t⟩ |
| cases t with |
| | nil => simp [leftB] |
| | cons a t => |
| rcases a with ⟨i,a⟩ |
| change leftB b (rightG g (push (v,h) i (a,t))) = |
| rightG g (push (b::v,h) i (a,t)) |
| rw [rightG_push, rightG_push] |
| rfl |
| theorem leftN_rightG (i : N) (g : G) : |
| Function.Commute (leftN (B := B) i) (rightG g) := by |
| intro w |
| exact (rightG_push g ([],1) i w).symm |
| theorem leftG_rightG (g h : G) : |
| Function.Commute (leftG (B := B) (N := N) g) (rightG h) := by |
| rintro ⟨⟨v,k⟩,t⟩ |
| cases t with |
| | nil => simp [leftG, mul_assoc] |
| | cons a t => |
| rcases a with ⟨i,a⟩ |
| change leftG g (rightG h (push (v,k) i (a,t))) = |
| rightG h (push (v,g*k) i (a,t)) |
| rw [rightG_push, rightG_push] |
| rfl |
|
|
| variable [DecidableEq B] [DecidableEq N] [DecidableEq G] |
| open scoped lp |
| abbrev Space (B N G : Type) := LabelHilbert.Space (Word B N G) |
| def basis (w : Word B N G) : Space B N G := lp.single 2 w 1 |
|
|
| def creationB (b : B) : Space B N G →L[ℂ] Space B N G := |
| LabelHilbert.lift (leftB b) (leftB_injective b) |
| def creationN (i : N) : Space B N G →L[ℂ] Space B N G := |
| LabelHilbert.lift (leftN i) (leftN_injective i) |
| def unitaryG (g : G) : Space B N G →L[ℂ] Space B N G := |
| LabelHilbert.lift (leftG g) (leftG_injective g) |
| def rightCreationB (b : B) : Space B N G →L[ℂ] Space B N G := |
| LabelHilbert.lift (rightB b) (rightB_injective b) |
| def rightCreationN (i : N) : Space B N G →L[ℂ] Space B N G := |
| LabelHilbert.lift (rightN i) (rightN_injective i) |
| def rightUnitaryG (g : G) : Space B N G →L[ℂ] Space B N G := |
| LabelHilbert.lift (rightG g) (rightG_injective g) |
|
|
| omit [Group G] in |
| @[simp] theorem creationB_single (b : B) (w : Word B N G) (z : ℂ) : |
| creationB b (lp.single 2 w z) = lp.single 2 (leftB b w) z := |
| LabelHilbert.lift_single _ _ _ _ |
| @[simp] theorem creationN_single (i : N) (w : Word B N G) (z : ℂ) : |
| creationN i (lp.single 2 w z) = lp.single 2 (leftN i w) z := |
| LabelHilbert.lift_single _ _ _ _ |
| @[simp] theorem unitaryG_single (g : G) (w : Word B N G) (z : ℂ) : |
| unitaryG g (lp.single 2 w z) = lp.single 2 (leftG g w) z := |
| LabelHilbert.lift_single _ _ _ _ |
| @[simp] theorem rightCreationB_single (b : B) (w : Word B N G) (z : ℂ) : |
| rightCreationB b (lp.single 2 w z) = lp.single 2 (rightB b w) z := |
| LabelHilbert.lift_single _ _ _ _ |
| @[simp] theorem rightCreationN_single (i : N) (w : Word B N G) (z : ℂ) : |
| rightCreationN i (lp.single 2 w z) = lp.single 2 (rightN i w) z := |
| LabelHilbert.lift_single _ _ _ _ |
| @[simp] theorem rightUnitaryG_single (g : G) (w : Word B N G) (z : ℂ) : |
| rightUnitaryG g (lp.single 2 w z) = lp.single 2 (rightG g w) z := |
| LabelHilbert.lift_single _ _ _ _ |
|
|
| def removeB (b : B) (w : Word B N G) : Option (Word B N G) := |
| match w.1.1 with |
| | [] => none |
| | c::v => if b = c then some ((v,w.1.2),w.2) else none |
|
|
| def removeN (i : N) (w : Word B N G) : Option (Word B N G) := |
| if w.1 = ([],1) then match w.2 with |
| | [] => none |
| | (j,a)::t => if i = j then some (a,t) else none |
| else none |
|
|
| omit [Group G] [DecidableEq N] [DecidableEq G] in |
| theorem removeB_spec (b : B) (u v : Word B N G) : removeB b v = some u ↔ leftB b u = v := by |
| rcases u with ⟨⟨uv,ug⟩,ut⟩ |
| rcases v with ⟨⟨vv,vg⟩,vt⟩ |
| cases vv with |
| | nil => simp [removeB, leftB] |
| | cons c vv => |
| by_cases h : b = c |
| · subst c; simp [removeB, leftB, eq_comm] |
| · simp [removeB, leftB, h] |
|
|
| theorem removeN_spec (i : N) (u v : Word B N G) : removeN i v = some u ↔ leftN i u = v := by |
| rcases u with ⟨ua,ut⟩ |
| rcases v with ⟨va,vt⟩ |
| by_cases h : va = ([],1) |
| · subst va |
| cases vt with |
| | nil => simp [removeN, leftN, push] |
| | cons a t => |
| rcases a with ⟨j,a⟩ |
| by_cases hij : i = j |
| · subst j; simp [removeN, leftN, push, eq_comm] |
| · simp [removeN, leftN, push, hij] |
| · simp [removeN, leftN, push, h, Ne.symm h] |
|
|
| omit [Group G] in |
| theorem annihilationB_single (b : B) (w : Word B N G) (z : ℂ) : |
| star (creationB b) (lp.single 2 w z) = |
| (removeB b w).elim 0 (fun a => lp.single 2 a z) := |
| LabelHilbert.adjoint_single_of_inverse _ _ _ (removeB_spec b) _ _ |
| theorem annihilationN_single (i : N) (w : Word B N G) (z : ℂ) : |
| star (creationN i) (lp.single 2 w z) = |
| (removeN i w).elim 0 (fun a => lp.single 2 a z) := |
| LabelHilbert.adjoint_single_of_inverse _ _ _ (removeN_spec i) _ _ |
|
|
| omit [DecidableEq B] [DecidableEq N] [DecidableEq G] in |
| theorem right_remove_spec (f : Word B N G → Word B N G) |
| (q : Word B N G → Option (Word B N G)) (hq : ∀ u v, q v = some u ↔ f u = v) |
| (u v : Word B N G) : |
| (q (reverse v)).map reverse = some u ↔ reverse (f (reverse u)) = v := by |
| rw [Option.map_eq_some_iff] |
| constructor |
| · rintro ⟨a,ha,hu⟩ |
| have had : a = reverse u := by rw [← hu, reverse_involutive] |
| rw [had] at ha |
| rw [(hq _ _).mp ha, reverse_involutive] |
| · intro h |
| refine ⟨reverse u, (hq _ _).mpr ?_, reverse_involutive u⟩ |
| have := congrArg reverse h |
| simpa using this |
|
|
| theorem rightAnnihilationB_single (b : B) (w : Word B N G) (z : ℂ) : |
| star (rightCreationB b) (lp.single 2 w z) = |
| ((removeB b (reverse w)).map reverse).elim 0 (fun a => lp.single 2 a z) := |
| LabelHilbert.adjoint_single_of_inverse _ _ _ (right_remove_spec _ _ (removeB_spec b)) _ _ |
| theorem rightAnnihilationN_single (i : N) (w : Word B N G) (z : ℂ) : |
| star (rightCreationN i) (lp.single 2 w z) = |
| ((removeN i (reverse w)).map reverse).elim 0 (fun a => lp.single 2 a z) := |
| LabelHilbert.adjoint_single_of_inverse _ _ _ (right_remove_spec _ _ (removeN_spec i)) _ _ |
|
|
| @[simp] theorem rightAnnihilationN_atom (i : N) (a : Atom B G) (z : ℂ) : |
| star (rightCreationN i) (lp.single 2 (a,[]) z) = 0 := by |
| rw [rightAnnihilationN_single] |
| have hr : removeN i (reverse (a,[])) = none := by |
| dsimp only [reverse_nil, removeN] |
| split <;> rfl |
| rw [hr] |
| rfl |
|
|
| theorem rightAnnihilationN_append (i j : N) (w : Word B N G) (a : Atom B G) (z : ℂ) : |
| star (rightCreationN i) (lp.single 2 (append w j a) z) = |
| if a = ([],1) ∧ i = j then lp.single 2 w z else 0 := by |
| rw [rightAnnihilationN_single, reverse_append] |
| have ha : reverseAtom a = ([],1) ↔ a = ([],1) := by |
| rcases a with ⟨v,g⟩ |
| simp [reverseAtom] |
| by_cases haa : a = ([],1) |
| · subst a |
| by_cases hij : i = j <;> simp [removeN, push, reverseAtom, hij] |
| · simp [removeN, push, ha, haa] |
|
|
| @[simp] theorem rightAnnihilationB_atom_nil (b : B) (g : G) (z : ℂ) : |
| star (rightCreationB (N := N) b) (lp.single 2 (([],g),[]) z) = 0 := by |
| rw [rightAnnihilationB_single] |
| simp [reverse_nil, reverseAtom, removeB] |
|
|
| theorem rightAnnihilationB_atom_append (b c : B) (v : List B) (g : G) (z : ℂ) : |
| star (rightCreationB (N := N) b) (lp.single 2 ((v ++ [c],g),[]) z) = |
| if b = c then lp.single 2 ((v,g),[]) z else 0 := by |
| rw [rightAnnihilationB_single] |
| by_cases h : b = c <;> simp [reverse_nil, reverseAtom, removeB, h] |
|
|
| @[simp] theorem rightAnnihilationB_append_nil (b : B) (w : Word B N G) (i : N) |
| (g : G) (z : ℂ) : |
| star (rightCreationB b) (lp.single 2 (append w i ([],g)) z) = 0 := by |
| rw [rightAnnihilationB_single, reverse_append] |
| simp [reverseAtom, push, removeB] |
|
|
| theorem rightAnnihilationB_append_append (b c : B) (w : Word B N G) (i : N) |
| (v : List B) (g : G) (z : ℂ) : |
| star (rightCreationB b) (lp.single 2 (append w i (v ++ [c],g)) z) = |
| if b = c then lp.single 2 (append w i (v,g)) z else 0 := by |
| rw [rightAnnihilationB_single, reverse_append] |
| have hinv := reverse_involutive w |
| simp only [reverse] at hinv |
| by_cases h : b = c <;> |
| simp [reverseAtom, push, removeB, h, reverse, reverseAux, append, hinv] |
|
|
| theorem creationB_commutes_rightAnnihilationN (b : B) (i : N) : |
| Commute (creationB (G := G) b) (star (rightCreationN i)) := by |
| show _ * _ = _ * _ |
| apply lp.ext_continuousLinearMap (by norm_num : (2 : ℝ≥0∞) ≠ ⊤) |
| intro w |
| apply ContinuousLinearMap.ext |
| intro z |
| change creationB b (star (rightCreationN i) (lp.single 2 w z)) = |
| star (rightCreationN i) (creationB b (lp.single 2 w z)) |
| rcases w with ⟨a,t⟩ |
| induction t using List.reverseRecOn with |
| | nil => simp [leftB] |
| | append_singleton t c _ => |
| rcases c with ⟨j,c⟩ |
| change creationB b (star (rightCreationN i) (lp.single 2 (append (a,t) j c) z)) = _ |
| rw [rightAnnihilationN_append, creationB_single] |
| change creationB b (if c = ([],1) ∧ i = j then lp.single 2 (a,t) z else 0) = |
| star (rightCreationN i) (lp.single 2 (append (leftB b (a,t)) j c) z) |
| rw [rightAnnihilationN_append] |
| split_ifs <;> simp |
|
|
| theorem creationN_commutes_rightAnnihilationB (i : N) (b : B) : |
| Commute (creationN (G := G) i) (star (rightCreationB b)) := by |
| show _ * _ = _ * _ |
| apply lp.ext_continuousLinearMap (by norm_num : (2 : ℝ≥0∞) ≠ ⊤) |
| intro w |
| apply ContinuousLinearMap.ext |
| intro z |
| change creationN i (star (rightCreationB b) (lp.single 2 w z)) = |
| star (rightCreationB b) (creationN i (lp.single 2 w z)) |
| rcases w with ⟨⟨av,g⟩,t⟩ |
| induction t using List.reverseRecOn with |
| | nil => |
| induction av using List.reverseRecOn with |
| | nil => |
| rw [rightAnnihilationB_atom_nil, map_zero, creationN_single] |
| change 0 = star (rightCreationB b) (lp.single 2 (append empty i ([],g)) z) |
| simp |
| | append_singleton v c _ => |
| rw [rightAnnihilationB_atom_append, creationN_single] |
| change creationN i (if b = c then lp.single 2 ((v,g),[]) z else 0) = |
| star (rightCreationB b) (lp.single 2 (append empty i (v ++ [c],g)) z) |
| rw [rightAnnihilationB_append_append] |
| split_ifs <;> simp [leftN, push, append, empty] |
| | append_singleton t c _ => |
| rcases c with ⟨j,⟨v,h⟩⟩ |
| rw [creationN_single] |
| change creationN i (star (rightCreationB b) |
| (lp.single 2 (append ((av,g),t) j (v,h)) z)) = |
| star (rightCreationB b) (lp.single 2 (append (leftN i ((av,g),t)) j (v,h)) z) |
| induction v using List.reverseRecOn with |
| | nil => simp |
| | append_singleton v c _ => |
| rw [rightAnnihilationB_append_append, rightAnnihilationB_append_append] |
| split_ifs <;> simp [leftN, push, append] |
|
|
| end FreeTensor |
|
|
| end FiniteEntropySeparation |
|
|
| end |
|
|
| end OAI |
|
|
