| import OAI.Analysis.FreeEntropy.EquidiscreteSignal |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped ENNReal NNReal ComplexConjugate lp |
| open MeasureTheory Filter |
| namespace FiniteEntropySeparation |
| namespace FreeTensor |
| variable {B N G : Type} [Group G] [DecidableEq B] [DecidableEq N] [DecidableEq G] |
|
|
| omit [Group G] in |
| theorem semicircularB_selfAdjoint [Group G] (b : B) : IsSelfAdjoint (semicircularB (N := N) (G := G) b) := |
| IsSelfAdjoint.add_star_self (creationB (N := N) (G := G) b) |
| theorem semicircularN_selfAdjoint (i : N) : IsSelfAdjoint (semicircularN (B := B) (G := G) i) := |
| IsSelfAdjoint.add_star_self (creationN (B := B) (G := G) i) |
|
|
| theorem backgroundAlgebra_le (J : Set N) : |
| backgroundAlgebra (B := B) (G := G) J ≤ (algebra B N G).toStarSubalgebra.toSubalgebra := by |
| apply Algebra.adjoin_le |
| rintro _ ((⟨b,rfl⟩ | ⟨g,rfl⟩) | ⟨i,_,rfl⟩) |
| · exact semicircularB_mem b |
| · exact unitaryG_mem g |
| · exact semicircularN_mem i |
|
|
| theorem semicircularB_mem_background (J : Set N) (b : B) : |
| semicircularB (N := N) (G := G) b ∈ backgroundAlgebra J := |
| Algebra.subset_adjoin (Or.inl (Or.inl ⟨b,rfl⟩)) |
| theorem semicircularN_mem_background (J : Set N) {i : N} (hi : i ∈ J) : |
| semicircularN (B := B) (G := G) i ∈ backgroundAlgebra J := |
| Algebra.subset_adjoin (Or.inr ⟨i,hi,rfl⟩) |
|
|
| theorem heatTuple_selfAdjoint {H : Type} [NormedAddCommGroup H] [InnerProductSpace ℂ H] |
| [CompleteSpace H] {n : ℕ} (X S : Fin n → H →L[ℂ] H) |
| (hX : ∀ i, IsSelfAdjoint (X i)) (hS : ∀ i, IsSelfAdjoint (S i)) (u : ℝ) (i : Fin n) : |
| IsSelfAdjoint (heatTuple X S u i) := by |
| change star (X i + (Real.sqrt u : ℂ) • S i) = _ |
| simp only [star_add, star_smul, Complex.star_def, Complex.conj_ofReal, (hX i).star_eq, |
| (hS i).star_eq, heatTuple] |
|
|
| theorem heatTuple_mem_background {n : ℕ} (J : Set N) |
| (X S : Fin n → Space B N G →L[ℂ] Space B N G) |
| (hX : ∀ i, X i ∈ backgroundAlgebra J) (hS : ∀ i, S i ∈ backgroundAlgebra J) |
| (u : ℝ) (i : Fin n) : heatTuple X S u i ∈ backgroundAlgebra J := |
| (backgroundAlgebra J).add_mem (hX i) ((backgroundAlgebra J).smul_mem (hS i) _) |
|
|
| end FreeTensor |
|
|
| namespace Model |
| open FreeTensor |
| variable (p : ℕ) [NeZero p] |
| abbrev H := Space (Fin p) (Fin ((p+1)+(p+1))) (Multiplicative (ZMod p)) |
| abbrev M : VonNeumannAlgebra (H p) := algebra (Fin p) (Fin ((p+1)+(p+1))) (Multiplicative (ZMod p)) |
| abbrev τ : TracialVector (M p) := tracialVector _ _ _ |
| def C : Fin (p+1) → H p →L[ℂ] H p := |
| Fin.lastCases (equidiscreteSignal p) (fun i => semicircularB i) |
| def initialIndex (i : Fin (p+1)) : Fin ((p+1)+(p+1)) := Fin.castAdd (p+1) i |
| def auxiliaryIndex (i : Fin (p+1)) : Fin ((p+1)+(p+1)) := Fin.natAdd (p+1) i |
| def initialNoise (i : Fin (p+1)) : H p →L[ℂ] H p := semicircularN (initialIndex p i) |
| def auxiliaryNoise (i : Fin (p+1)) : H p →L[ℂ] H p := semicircularN (auxiliaryIndex p i) |
| def oldNoise : Set (Fin ((p+1)+(p+1))) := Set.range (initialIndex p) |
| def X (h : ℝ) : Fin (p+1) → H p →L[ℂ] H p := heatTuple (C p) (initialNoise p) h |
|
|
| omit [NeZero p] in |
| theorem initialIndex_injective [NeZero p] : Function.Injective (initialIndex p) := Fin.castAdd_injective (p+1) (p+1) |
|
|
| omit [NeZero p] in |
| theorem auxiliaryIndex_injective [NeZero p] : Function.Injective (auxiliaryIndex p) := Fin.natAdd_injective (p+1) (p+1) |
|
|
| omit [NeZero p] in |
| theorem auxiliaryIndex_fresh [NeZero p] (i : Fin (p+1)) : auxiliaryIndex p i ∉ oldNoise p := by |
| rintro ⟨j,h⟩ |
| have hv := congrArg Fin.val h |
| simp only [initialIndex, auxiliaryIndex, Fin.val_castAdd, Fin.val_natAdd] at hv |
| have hj := j.isLt |
| omega |
|
|
| @[simp] theorem C_last : C p (Fin.last p) = equidiscreteSignal p := by simp [C] |
| @[simp] theorem C_castSucc (i : Fin p) : C p i.castSucc = semicircularB i := by simp [C] |
|
|
| theorem C_selfAdjoint (i : Fin (p+1)) : IsSelfAdjoint (C p i) := by |
| induction i using Fin.lastCases with |
| | last => rw [C_last]; exact equidiscreteSignal_selfAdjoint p |
| | cast i => rw [C_castSucc] |
|
|
| theorem C_mem_background (J : Set (Fin ((p+1)+(p+1)))) (i : Fin (p+1)) : |
| C p i ∈ backgroundAlgebra J := by |
| induction i using Fin.lastCases with |
| | last => rw [C_last]; exact equidiscreteSignal_mem_background p J |
| | cast i => rw [C_castSucc] |
|
|
| theorem C_mem (i : Fin (p+1)) : C p i ∈ M p := backgroundAlgebra_le ∅ (C_mem_background p ∅ i) |
|
|
| theorem C_norm_le (hp : 2 ≤ p) (i : Fin (p+1)) : ‖C p i‖ ≤ 2 := by |
| induction i using Fin.lastCases with |
| | last => rw [C_last]; exact (equidiscreteSignal_norm_le p hp).trans (by norm_num) |
| | cast i => rw [C_castSucc] |
|
|
| theorem initialNoise_free : FreeStandardNoise (τ p) (C p) (initialNoise p) := |
| freeStandardNoise ∅ (C p) (C_mem_background p ∅) (initialIndex p) |
| (initialIndex_injective p) (by simp) |
|
|
| theorem X_mem_background (h : ℝ) (i : Fin (p+1)) : |
| X p h i ∈ backgroundAlgebra (oldNoise p) := by |
| apply heatTuple_mem_background _ _ _ (C_mem_background p (oldNoise p)) |
| intro j |
| exact semicircularN_mem_background _ ⟨j,rfl⟩ |
| |
| theorem auxiliaryNoise_free (h : ℝ) : FreeStandardNoise (τ p) (X p h) (auxiliaryNoise p) := |
| freeStandardNoise (oldNoise p) (X p h) (X_mem_background p h) (auxiliaryIndex p) |
| (auxiliaryIndex_injective p) (auxiliaryIndex_fresh p) |
|
|
| theorem X_mem (h : ℝ) (i : Fin (p+1)) : X p h i ∈ M p := |
| backgroundAlgebra_le _ (X_mem_background p h i) |
| theorem X_selfAdjoint (h : ℝ) (i : Fin (p+1)) : IsSelfAdjoint (X p h i) := |
| heatTuple_selfAdjoint (C p) (initialNoise p) (C_selfAdjoint p) |
| (fun _index => semicircularN_selfAdjoint _) h i |
|
|
| omit [NeZero p] in |
| theorem auxiliaryNoise_mem [NeZero p] (i : Fin (p+1)) : auxiliaryNoise p i ∈ M p := semicircularN_mem _ |
|
|
| omit [NeZero p] in |
| theorem auxiliaryNoise_selfAdjoint [NeZero p] (i : Fin (p+1)) : IsSelfAdjoint (auxiliaryNoise p i) := |
| semicircularN_selfAdjoint _ |
|
|
| theorem X_norm_le (hp : 2 ≤ p) (h : ℝ) (i : Fin (p+1)) : |
| ‖X p h i‖ ≤ 2 + 2 * Real.sqrt h := by |
| apply (norm_add_le _ _).trans |
| rw [norm_smul, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg (Real.sqrt_nonneg h)] |
| exact add_le_add (C_norm_le p hp i) |
| (by |
| have hn : ‖initialNoise p i‖ ≤ 2 := semicircularN_norm_le _ |
| nlinarith [Real.sqrt_nonneg h]) |
|
|
| theorem heat_fisher_le (h s : ℝ) (hs : 0 < s) : |
| freeFisher (τ p) (heatTuple (X p h) (auxiliaryNoise p) s) ≤ ENNReal.ofReal ((p+1 : ℕ)/s) := |
| heat_freeFisher_le (oldNoise p) (X p h) (X_mem_background p h) |
| (auxiliaryIndex p) (auxiliaryIndex_injective p) (auxiliaryIndex_fresh p) s hs |
|
|
| theorem heat_fisher_measurable (h : ℝ) : Measurable (fun s : Set.Ioi (0 : ℝ) => |
| freeFisher (τ p) (heatTuple (X p h) (auxiliaryNoise p) s)) := |
| heat_freeFisher_measurable (oldNoise p) (X p h) (X_mem_background p h) |
| (auxiliaryIndex p) (auxiliaryIndex_injective p) (auxiliaryIndex_fresh p) |
|
|
| end Model |
| end FiniteEntropySeparation |
|
|
| end |
|
|
| end OAI |
|
|
