/- Copyright (c) 2025 Joseph Tooby-Smith. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Joseph Tooby-Smith -/ import HepLean.PerturbationTheory.Algebras.CrAnAlgebra.NormalOrder import HepLean.PerturbationTheory.Koszul.KoszulSign /-! # Normal ordering of the operator algebra -/ namespace FieldSpecification variable {𝓕 : FieldSpecification} namespace ProtoOperatorAlgebra variable {π“ž : ProtoOperatorAlgebra 𝓕} open CrAnAlgebra open FieldStatistic /-! ## Normal order of super-commutators. The main result of this section is `crAnF_normalOrder_superCommute_eq_zero_mul`. -/ lemma crAnF_normalOrder_superCommute_ofCrAnList_create_create_ofCrAnList (Ο†c Ο†c' : 𝓕.CrAnStates) (hΟ†c : 𝓕 |>ᢜ Ο†c = CreateAnnihilate.create) (hΟ†c' : 𝓕 |>ᢜ Ο†c' = CreateAnnihilate.create) (Ο†s Ο†s' : List 𝓕.CrAnStates) : π“ž.crAnF (normalOrder (ofCrAnList Ο†s * superCommute (ofCrAnState Ο†c) (ofCrAnState Ο†c') * ofCrAnList Ο†s')) = 0 := by rw [normalOrder_superCommute_ofCrAnList_create_create_ofCrAnList Ο†c Ο†c' hΟ†c hΟ†c' Ο†s Ο†s'] rw [map_smul, map_mul, map_mul, map_mul, π“ž.superCommute_create_create Ο†c Ο†c' hΟ†c hΟ†c'] simp lemma crAnF_normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList (Ο†a Ο†a' : 𝓕.CrAnStates) (hΟ†a : 𝓕 |>ᢜ Ο†a = CreateAnnihilate.annihilate) (hΟ†a' : 𝓕 |>ᢜ Ο†a' = CreateAnnihilate.annihilate) (Ο†s Ο†s' : List 𝓕.CrAnStates) : π“ž.crAnF (normalOrder (ofCrAnList Ο†s * superCommute (ofCrAnState Ο†a) (ofCrAnState Ο†a') * ofCrAnList Ο†s')) = 0 := by rw [normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList Ο†a Ο†a' hΟ†a hΟ†a' Ο†s Ο†s'] rw [map_smul, map_mul, map_mul, map_mul, π“ž.superCommute_annihilate_annihilate Ο†a Ο†a' hΟ†a hΟ†a'] simp lemma crAnF_normalOrder_superCommute_ofCrAnList_ofCrAnList_eq_zero (Ο†a Ο†a' : 𝓕.CrAnStates) (Ο†s Ο†s' : List 𝓕.CrAnStates) : π“ž.crAnF (normalOrder (ofCrAnList Ο†s * superCommute (ofCrAnState Ο†a) (ofCrAnState Ο†a') * ofCrAnList Ο†s')) = 0 := by rcases CreateAnnihilate.eq_create_or_annihilate (𝓕 |>ᢜ Ο†a) with hΟ†a | hΟ†a <;> rcases CreateAnnihilate.eq_create_or_annihilate (𝓕 |>ᢜ Ο†a') with hΟ†a' | hΟ†a' Β· rw [normalOrder_superCommute_ofCrAnList_create_create_ofCrAnList Ο†a Ο†a' hΟ†a hΟ†a' Ο†s Ο†s'] rw [map_smul, map_mul, map_mul, map_mul, π“ž.superCommute_create_create Ο†a Ο†a' hΟ†a hΟ†a'] simp Β· rw [normalOrder_superCommute_create_annihilate Ο†a Ο†a' hΟ†a hΟ†a' (ofCrAnList Ο†s) (ofCrAnList Ο†s')] simp Β· rw [normalOrder_superCommute_annihilate_create Ο†a' Ο†a hΟ†a' hΟ†a (ofCrAnList Ο†s) (ofCrAnList Ο†s')] simp Β· rw [normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList Ο†a Ο†a' hΟ†a hΟ†a' Ο†s Ο†s'] rw [map_smul, map_mul, map_mul, map_mul, π“ž.superCommute_annihilate_annihilate Ο†a Ο†a' hΟ†a hΟ†a'] simp lemma crAnF_normalOrder_superCommute_ofCrAnList_eq_zero (Ο†a Ο†a' : 𝓕.CrAnStates) (Ο†s : List 𝓕.CrAnStates) (a : 𝓕.CrAnAlgebra) : π“ž.crAnF (normalOrder (ofCrAnList Ο†s * superCommute (ofCrAnState Ο†a) (ofCrAnState Ο†a') * a)) = 0 := by change (π“ž.crAnF.toLinearMap βˆ˜β‚— normalOrder βˆ˜β‚— mulLinearMap ((ofCrAnList Ο†s * superCommute (ofCrAnState Ο†a) (ofCrAnState Ο†a')))) a = 0 have hf : π“ž.crAnF.toLinearMap βˆ˜β‚— normalOrder βˆ˜β‚— mulLinearMap ((ofCrAnList Ο†s * superCommute (ofCrAnState Ο†a) (ofCrAnState Ο†a'))) = 0 := by apply ofCrAnListBasis.ext intro l simp only [ofListBasis_eq_ofList, LinearMap.coe_comp, Function.comp_apply, AlgHom.toLinearMap_apply, LinearMap.zero_apply] exact crAnF_normalOrder_superCommute_ofCrAnList_ofCrAnList_eq_zero Ο†a Ο†a' Ο†s l rw [hf] simp lemma crAnF_normalOrder_superCommute_ofCrAnState_eq_zero_mul (Ο†a Ο†a' : 𝓕.CrAnStates) (a b : 𝓕.CrAnAlgebra) : π“ž.crAnF (normalOrder (a * superCommute (ofCrAnState Ο†a) (ofCrAnState Ο†a') * b)) = 0 := by rw [mul_assoc] change (π“ž.crAnF.toLinearMap βˆ˜β‚— normalOrder βˆ˜β‚— mulLinearMap.flip ((superCommute (ofCrAnState Ο†a) (ofCrAnState Ο†a') * b))) a = 0 have hf : (π“ž.crAnF.toLinearMap βˆ˜β‚— normalOrder βˆ˜β‚— mulLinearMap.flip ((superCommute (ofCrAnState Ο†a) (ofCrAnState Ο†a') * b))) = 0 := by apply ofCrAnListBasis.ext intro l simp only [mulLinearMap, ofListBasis_eq_ofList, LinearMap.coe_comp, Function.comp_apply, LinearMap.flip_apply, LinearMap.coe_mk, AddHom.coe_mk, AlgHom.toLinearMap_apply, LinearMap.zero_apply] rw [← mul_assoc] exact crAnF_normalOrder_superCommute_ofCrAnList_eq_zero Ο†a Ο†a' _ _ rw [hf] simp lemma crAnF_normalOrder_superCommute_ofCrAnState_ofCrAnList_eq_zero_mul (Ο†a : 𝓕.CrAnStates) (Ο†s : List 𝓕.CrAnStates) (a b : 𝓕.CrAnAlgebra) : π“ž.crAnF (normalOrder (a * superCommute (ofCrAnState Ο†a) (ofCrAnList Ο†s) * b)) = 0 := by rw [← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList_eq_sum] rw [Finset.mul_sum, Finset.sum_mul] rw [map_sum, map_sum] apply Fintype.sum_eq_zero intro n rw [← mul_assoc, ← mul_assoc] rw [mul_assoc _ _ b, ofCrAnList_singleton] rw [crAnF_normalOrder_superCommute_ofCrAnState_eq_zero_mul] lemma crAnF_normalOrder_superCommute_ofCrAnList_ofCrAnState_eq_zero_mul (Ο†a : 𝓕.CrAnStates) (Ο†s : List 𝓕.CrAnStates) (a b : 𝓕.CrAnAlgebra) : π“ž.crAnF (normalOrder (a * superCommute (ofCrAnList Ο†s) (ofCrAnState Ο†a) * b)) = 0 := by rw [← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList_symm, ofCrAnList_singleton] simp only [FieldStatistic.instCommGroup.eq_1, FieldStatistic.ofList_singleton, mul_neg, Algebra.mul_smul_comm, neg_mul, Algebra.smul_mul_assoc, map_neg, map_smul] rw [crAnF_normalOrder_superCommute_ofCrAnState_ofCrAnList_eq_zero_mul] simp lemma crAnF_normalOrder_superCommute_ofCrAnList_ofCrAnList_eq_zero_mul (Ο†s Ο†s' : List 𝓕.CrAnStates) (a b : 𝓕.CrAnAlgebra) : π“ž.crAnF (normalOrder (a * superCommute (ofCrAnList Ο†s) (ofCrAnList Ο†s') * b)) = 0 := by rw [superCommute_ofCrAnList_ofCrAnList_eq_sum, Finset.mul_sum, Finset.sum_mul] rw [map_sum, map_sum] apply Fintype.sum_eq_zero intro n rw [← mul_assoc, ← mul_assoc] rw [mul_assoc _ _ b] rw [crAnF_normalOrder_superCommute_ofCrAnList_ofCrAnState_eq_zero_mul] lemma crAnF_normalOrder_superCommute_ofCrAnList_eq_zero_mul (Ο†s : List 𝓕.CrAnStates) (a b c : 𝓕.CrAnAlgebra) : π“ž.crAnF (normalOrder (a * superCommute (ofCrAnList Ο†s) c * b)) = 0 := by change (π“ž.crAnF.toLinearMap βˆ˜β‚— normalOrder βˆ˜β‚— mulLinearMap.flip b βˆ˜β‚— mulLinearMap a βˆ˜β‚— superCommute (ofCrAnList Ο†s)) c = 0 have hf : (π“ž.crAnF.toLinearMap βˆ˜β‚— normalOrder βˆ˜β‚— mulLinearMap.flip b βˆ˜β‚— mulLinearMap a βˆ˜β‚— superCommute (ofCrAnList Ο†s)) = 0 := by apply ofCrAnListBasis.ext intro Ο†s' simp only [mulLinearMap, LinearMap.coe_mk, AddHom.coe_mk, ofListBasis_eq_ofList, LinearMap.coe_comp, Function.comp_apply, LinearMap.flip_apply, AlgHom.toLinearMap_apply, LinearMap.zero_apply] rw [crAnF_normalOrder_superCommute_ofCrAnList_ofCrAnList_eq_zero_mul] rw [hf] simp @[simp] lemma crAnF_normalOrder_superCommute_eq_zero_mul (a b c d : 𝓕.CrAnAlgebra) : π“ž.crAnF (normalOrder (a * superCommute d c * b)) = 0 := by change (π“ž.crAnF.toLinearMap βˆ˜β‚— normalOrder βˆ˜β‚— mulLinearMap.flip b βˆ˜β‚— mulLinearMap a βˆ˜β‚— superCommute.flip c) d = 0 have hf : (π“ž.crAnF.toLinearMap βˆ˜β‚— normalOrder βˆ˜β‚— mulLinearMap.flip b βˆ˜β‚— mulLinearMap a βˆ˜β‚— superCommute.flip c) = 0 := by apply ofCrAnListBasis.ext intro Ο†s simp only [mulLinearMap, LinearMap.coe_mk, AddHom.coe_mk, ofListBasis_eq_ofList, LinearMap.coe_comp, Function.comp_apply, LinearMap.flip_apply, AlgHom.toLinearMap_apply, LinearMap.zero_apply] rw [crAnF_normalOrder_superCommute_ofCrAnList_eq_zero_mul] rw [hf] simp @[simp] lemma crAnF_normalOrder_superCommute_eq_zero_mul_right (b c d : 𝓕.CrAnAlgebra) : π“ž.crAnF (normalOrder (superCommute d c * b)) = 0 := by rw [← crAnF_normalOrder_superCommute_eq_zero_mul 1 b c d] simp @[simp] lemma crAnF_normalOrder_superCommute_eq_zero_mul_left (a c d : 𝓕.CrAnAlgebra) : π“ž.crAnF (normalOrder (a * superCommute d c)) = 0 := by rw [← crAnF_normalOrder_superCommute_eq_zero_mul a 1 c d] simp @[simp] lemma crAnF_normalOrder_superCommute_eq_zero (c d : 𝓕.CrAnAlgebra) : π“ž.crAnF (normalOrder (superCommute d c)) = 0 := by rw [← crAnF_normalOrder_superCommute_eq_zero_mul 1 1 c d] simp /-! ## Swapping terms in a normal order. -/ lemma crAnF_normalOrder_ofState_ofState_swap (Ο† Ο†' : 𝓕.States) : π“ž.crAnF (normalOrder (ofState Ο† * ofState Ο†')) = 𝓒(𝓕 |>β‚› Ο†, 𝓕 |>β‚› Ο†') β€’ π“ž.crAnF (normalOrder (ofState Ο†' * ofState Ο†)) := by rw [← ofStateList_singleton, ← ofStateList_singleton, ofStateList_mul_ofStateList_eq_superCommute] simp lemma crAnF_normalOrder_ofCrAnState_ofCrAnList_swap (Ο† : 𝓕.CrAnStates) (Ο†s : List 𝓕.CrAnStates) : π“ž.crAnF (normalOrder (ofCrAnState Ο† * ofCrAnList Ο†s)) = 𝓒(𝓕 |>β‚› Ο†, 𝓕 |>β‚› Ο†s) β€’ π“ž.crAnF (normalOrder (ofCrAnList Ο†s * ofCrAnState Ο†)) := by rw [← ofCrAnList_singleton, ofCrAnList_mul_ofCrAnList_eq_superCommute] simp lemma crAnF_normalOrder_ofCrAnState_ofStatesList_swap (Ο† : 𝓕.CrAnStates) (Ο†' : List 𝓕.States) : π“ž.crAnF (normalOrder (ofCrAnState Ο† * ofStateList Ο†')) = 𝓒(𝓕 |>β‚› Ο†, 𝓕 |>β‚› Ο†') β€’ π“ž.crAnF (normalOrder (ofStateList Ο†' * ofCrAnState Ο†)) := by rw [← ofCrAnList_singleton, ofCrAnList_mul_ofStateList_eq_superCommute] simp lemma crAnF_normalOrder_anPart_ofStatesList_swap (Ο† : 𝓕.States) (Ο†' : List 𝓕.States) : π“ž.crAnF (normalOrder (anPart (StateAlgebra.ofState Ο†) * ofStateList Ο†')) = 𝓒(𝓕 |>β‚› Ο†, 𝓕 |>β‚› Ο†') β€’ π“ž.crAnF (normalOrder (ofStateList Ο†' * anPart (StateAlgebra.ofState Ο†))) := by match Ο† with | .negAsymp Ο† => simp | .position Ο† => simp only [anPart_position, instCommGroup.eq_1] rw [crAnF_normalOrder_ofCrAnState_ofStatesList_swap] rfl | .posAsymp Ο† => simp only [anPart_posAsymp, instCommGroup.eq_1] rw [crAnF_normalOrder_ofCrAnState_ofStatesList_swap] rfl lemma crAnF_normalOrder_ofStatesList_anPart_swap (Ο† : 𝓕.States) (Ο†' : List 𝓕.States) : π“ž.crAnF (normalOrder (ofStateList Ο†' * anPart (StateAlgebra.ofState Ο†))) = 𝓒(𝓕 |>β‚› Ο†, 𝓕 |>β‚› Ο†') β€’ π“ž.crAnF (normalOrder (anPart (StateAlgebra.ofState Ο†) * ofStateList Ο†')) := by rw [crAnF_normalOrder_anPart_ofStatesList_swap] simp [smul_smul, FieldStatistic.exchangeSign_mul_self] lemma crAnF_normalOrder_ofStatesList_mul_anPart_swap (Ο† : 𝓕.States) (Ο†' : List 𝓕.States) : π“ž.crAnF (normalOrder (ofStateList Ο†') * anPart (StateAlgebra.ofState Ο†)) = 𝓒(𝓕 |>β‚› Ο†, 𝓕 |>β‚› Ο†') β€’ π“ž.crAnF (normalOrder (anPart (StateAlgebra.ofState Ο†) * ofStateList Ο†')) := by rw [← normalOrder_mul_anPart] rw [crAnF_normalOrder_ofStatesList_anPart_swap] /-! ## Super commutators with a normal ordered term as sums -/ lemma crAnF_ofCrAnState_superCommute_normalOrder_ofCrAnList_eq_sum (Ο† : 𝓕.CrAnStates) (Ο†s : List 𝓕.CrAnStates) : π“ž.crAnF (⟨ofCrAnState Ο†, normalOrder (ofCrAnList Ο†s)βŸ©β‚›ca) = βˆ‘ n : Fin Ο†s.length, 𝓒(𝓕 |>β‚› Ο†, 𝓕 |>β‚› (Ο†s.take n)) β€’ π“ž.crAnF (⟨ofCrAnState Ο†, ofCrAnState Ο†s[n]βŸ©β‚›ca) * π“ž.crAnF (normalOrder (ofCrAnList (Ο†s.eraseIdx n))) := by rw [normalOrder_ofCrAnList, map_smul, map_smul] rw [crAnF_superCommute_ofCrAnState_ofCrAnList_eq_sum, sum_normalOrderList_length] simp only [instCommGroup.eq_1, List.get_eq_getElem, normalOrderList_get_normalOrderEquiv, normalOrderList_eraseIdx_normalOrderEquiv, Algebra.smul_mul_assoc, map_sum, map_smul, map_mul, Finset.smul_sum, Fin.getElem_fin] congr funext n rw [ofCrAnList_eq_normalOrder, map_smul, mul_smul_comm, smul_smul, smul_smul] by_cases hs : (𝓕 |>β‚› Ο†) = (𝓕 |>β‚› Ο†s[n]) Β· congr erw [normalOrderSign_eraseIdx, ← hs] trans (normalOrderSign Ο†s * normalOrderSign Ο†s) * (𝓒(𝓕 |>β‚› (Ο†s.get n), 𝓕 |>β‚› ((normalOrderList Ο†s).take (normalOrderEquiv n))) * 𝓒(𝓕 |>β‚› (Ο†s.get n), 𝓕 |>β‚› ((normalOrderList Ο†s).take (normalOrderEquiv n)))) * 𝓒(𝓕 |>β‚› (Ο†s.get n), 𝓕 |>β‚› (Ο†s.take n)) Β· ring_nf rw [hs] rfl Β· simp [hs] Β· erw [π“ž.superCommute_different_statistics _ _ hs] simp lemma crAnF_ofCrAnState_superCommute_normalOrder_ofStateList_eq_sum (Ο† : 𝓕.CrAnStates) (Ο†s : List 𝓕.States) : π“ž.crAnF (⟨ofCrAnState Ο†, normalOrder (ofStateList Ο†s)βŸ©β‚›ca) = βˆ‘ n : Fin Ο†s.length, 𝓒(𝓕 |>β‚› Ο†, 𝓕 |>β‚› (Ο†s.take n)) β€’ π“ž.crAnF (⟨ofCrAnState Ο†, ofState Ο†s[n]βŸ©β‚›ca) * π“ž.crAnF (normalOrder (ofStateList (Ο†s.eraseIdx n))) := by conv_lhs => rw [ofStateList_sum, map_sum, map_sum, map_sum] enter [2, s] rw [crAnF_ofCrAnState_superCommute_normalOrder_ofCrAnList_eq_sum, CrAnSection.sum_over_length] enter [2, n] rw [CrAnSection.take_statistics_eq_take_state_statistics, smul_mul_assoc] rw [Finset.sum_comm] refine Finset.sum_congr rfl (fun n _ => ?_) simp only [instCommGroup.eq_1, Fin.coe_cast, Fin.getElem_fin, CrAnSection.sum_eraseIdxEquiv n _ n.prop, CrAnSection.eraseIdxEquiv_symm_getElem, CrAnSection.eraseIdxEquiv_symm_eraseIdx, ← Finset.smul_sum, Algebra.smul_mul_assoc] conv_lhs => enter [2, 2, n] rw [← Finset.mul_sum] rw [← Finset.sum_mul, ← map_sum, ← map_sum, ← ofState, ← map_sum, ← map_sum, ← ofStateList_sum] lemma crAnF_anPart_superCommute_normalOrder_ofStateList_eq_sum (Ο† : 𝓕.States) (Ο†s : List 𝓕.States) : π“ž.crAnF (⟨anPart (StateAlgebra.ofState Ο†), normalOrder (ofStateList Ο†s)βŸ©β‚›ca) = βˆ‘ n : Fin Ο†s.length, 𝓒(𝓕 |>β‚› Ο†, 𝓕 |>β‚› (Ο†s.take n)) β€’ π“ž.crAnF (⟨anPart (StateAlgebra.ofState Ο†), ofState Ο†s[n]βŸ©β‚›ca) * π“ž.crAnF (normalOrder (ofStateList (Ο†s.eraseIdx n))) := by match Ο† with | .negAsymp Ο† => simp | .position Ο† => simp only [anPart_position, instCommGroup.eq_1, Fin.getElem_fin, Algebra.smul_mul_assoc] rw [crAnF_ofCrAnState_superCommute_normalOrder_ofStateList_eq_sum] simp [crAnStatistics] | .posAsymp Ο† => simp only [anPart_posAsymp, instCommGroup.eq_1, Fin.getElem_fin, Algebra.smul_mul_assoc] rw [crAnF_ofCrAnState_superCommute_normalOrder_ofStateList_eq_sum] simp [crAnStatistics] /-! ## Multiplying with normal ordered terms -/ lemma crAnF_anPart_mul_normalOrder_ofStatesList_eq_superCommute (Ο† : 𝓕.States) (Ο†' : List 𝓕.States) : π“ž.crAnF (anPart (StateAlgebra.ofState Ο†) * normalOrder (ofStateList Ο†')) = π“ž.crAnF (normalOrder (anPart (StateAlgebra.ofState Ο†) * ofStateList Ο†')) + π“ž.crAnF (⟨anPart (StateAlgebra.ofState Ο†), normalOrder (ofStateList Ο†')βŸ©β‚›ca) := by rw [anPart_mul_normalOrder_ofStateList_eq_superCommute] simp only [instCommGroup.eq_1, map_add, map_smul] congr rw [crAnF_normalOrder_anPart_ofStatesList_swap] lemma crAnF_ofState_mul_normalOrder_ofStatesList_eq_superCommute (Ο† : 𝓕.States) (Ο†' : List 𝓕.States) : π“ž.crAnF (ofState Ο† * normalOrder (ofStateList Ο†')) = π“ž.crAnF (normalOrder (ofState Ο† * ofStateList Ο†')) + π“ž.crAnF (⟨anPart (StateAlgebra.ofState Ο†), normalOrder (ofStateList Ο†')βŸ©β‚›ca) := by conv_lhs => rw [ofState_eq_crPart_add_anPart] rw [add_mul, map_add, crAnF_anPart_mul_normalOrder_ofStatesList_eq_superCommute, ← add_assoc, ← normalOrder_crPart_mul, ← map_add] conv_lhs => lhs rw [← map_add, ← add_mul, ← ofState_eq_crPart_add_anPart] /-- In the expansion of `ofState Ο† * normalOrder (ofStateList Ο†s)` the element of `π“ž.A` associated with contracting `Ο†` with the (optional) `n`th element of `Ο†s`. -/ noncomputable def contractStateAtIndex (Ο† : 𝓕.States) (Ο†s : List 𝓕.States) (n : Option (Fin Ο†s.length)) : π“ž.A := match n with | none => 1 | some n => 𝓒(𝓕 |>β‚› Ο†, 𝓕 |>β‚› (Ο†s.take n)) β€’ π“ž.crAnF (⟨anPart (StateAlgebra.ofState Ο†), ofState Ο†s[n]βŸ©β‚›ca) lemma crAnF_ofState_mul_normalOrder_ofStatesList_eq_sum (Ο† : 𝓕.States) (Ο†s : List 𝓕.States) : π“ž.crAnF (ofState Ο† * normalOrder (ofStateList Ο†s)) = βˆ‘ n : Option (Fin Ο†s.length), contractStateAtIndex Ο† Ο†s n * π“ž.crAnF (normalOrder (ofStateList (HepLean.List.optionEraseZ Ο†s Ο† n))) := by rw [crAnF_ofState_mul_normalOrder_ofStatesList_eq_superCommute] rw [crAnF_anPart_superCommute_normalOrder_ofStateList_eq_sum] simp only [instCommGroup.eq_1, Fin.getElem_fin, Algebra.smul_mul_assoc, contractStateAtIndex, Fintype.sum_option, one_mul] rfl /-! ## Cons vs insertIdx for a normal ordered term. -/ lemma crAnF_ofState_normalOrder_insert (Ο† : 𝓕.States) (Ο†s : List 𝓕.States) (k : Fin Ο†s.length.succ) : π“ž.crAnF (normalOrder (ofStateList (Ο† :: Ο†s))) = 𝓒(𝓕 |>β‚› Ο†, 𝓕 |>β‚› Ο†s.take k) β€’ π“ž.crAnF (normalOrder (ofStateList (Ο†s.insertIdx k Ο†))) := by have hl : Ο†s.insertIdx k Ο† = Ο†s.take k ++ [Ο†] ++ Ο†s.drop k := by rw [HepLean.List.insertIdx_eq_take_drop] simp rw [hl] rw [ofStateList_append, ofStateList_append] rw [ofStateList_mul_ofStateList_eq_superCommute, add_mul] simp only [instCommGroup.eq_1, Nat.succ_eq_add_one, ofList_singleton, Algebra.smul_mul_assoc, map_add, map_smul, crAnF_normalOrder_superCommute_eq_zero_mul_right, add_zero, smul_smul, exchangeSign_mul_self_swap, one_smul] rw [← ofStateList_append, ← ofStateList_append] simp end ProtoOperatorAlgebra end FieldSpecification