Download data/lean/OAI/Analysis/FreeEntropy/Basic.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 65.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/FreeEntropy/Basic.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/FreeEntropy/Basic.lean
-
curl -L -o Basic.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/FreeEntropy/Basic.lean
65.7 kB
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
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