| import Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order |
| import Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic |
| import OAI.Analysis.FactorGeneration.ProjectionLimits |
| import OAI.Analysis.FactorGeneration.TracialInclusion |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace Generator.Tracial |
|
|
| /-! Trace estimates in the actual ambient algebra. The corner scalar uses |
| its normalized trace. These estimates do not assume or assert the existence |
| of a local-quantizing projection. -/ |
| section |
| open UltrapowerBridge |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] |
| variable {M : VonNeumannAlgebra H} (τ : TracialRepresentation M) |
|
|
| theorem cornerTrace_add (x y : M.toStarSubalgebra) : |
| τ.trace (x+y) = τ.trace x + τ.trace y := inner_add_right _ _ _ |
|
|
| theorem trace_sub (x y : M.toStarSubalgebra) : |
| τ.trace (x-y) = τ.trace x - τ.trace y := inner_sub_right _ _ _ |
|
|
| theorem cornerTrace_smul (c : ℂ) (x : M.toStarSubalgebra) : |
| τ.trace (c • x) = c * τ.trace x := inner_smul_right _ _ _ |
|
|
| theorem norm_trace_mul_le (x y : M.toStarSubalgebra) : |
| ‖τ.trace (x*y)‖ ≤ τ.norm₂ x * τ.norm₂ y := by |
| have he := norm_inner_le_norm (𝕜 := ℂ) |
| (((star x : M.toStarSubalgebra) : H →L[ℂ] H) τ.vector) |
| ((y : H →L[ℂ] H) τ.vector) |
| have hi : inner ℂ (((star x : M.toStarSubalgebra) : H →L[ℂ] H) τ.vector) |
| ((y : H →L[ℂ] H) τ.vector) = τ.trace (x*y) := by |
| change inner ℂ (star (x : H →L[ℂ] H) τ.vector) ((y : H →L[ℂ] H) τ.vector) = _ |
| rw [ContinuousLinearMap.star_eq_adjoint,ContinuousLinearMap.adjoint_inner_left] |
| rfl |
| rw [hi] at he |
| change ‖τ.trace (x*y)‖ ≤ τ.norm₂ (star x)*τ.norm₂ y at he |
| simpa only [τ.norm₂_star] using he |
|
|
| /-- The scalar conditional expectation in pMp, expressed in ambient coordinates. -/ |
| def cornerScalar (p : AlgebraProjection M) (x : M.toStarSubalgebra) : ℂ := |
| τ.trace (p.val*x*p.val) / τ.trace p.val |
|
|
| def cornerCentered (p : AlgebraProjection M) (x : M.toStarSubalgebra) : M.toStarSubalgebra := |
| p.val*x*p.val - cornerScalar τ p x • p.val |
|
|
| theorem cornerCentered_support (p : AlgebraProjection M) (x : M.toStarSubalgebra) : |
| p.val * cornerCentered τ p x = cornerCentered τ p x ∧ |
| cornerCentered τ p x * p.val = cornerCentered τ p x := by |
| constructor |
| · simp [cornerCentered,mul_sub,← mul_assoc,p.property.isIdempotentElem.eq] |
| · simp [cornerCentered,sub_mul,mul_assoc,p.property.isIdempotentElem.eq] |
|
|
| theorem cornerCentered_trace (p : AlgebraProjection M) (hp : p.val ≠ 0) |
| (x : M.toStarSubalgebra) : τ.trace (cornerCentered τ p x) = 0 := by |
| have hn : τ.trace p.val ≠ 0 := by |
| intro h |
| have hh := projection_trace_pos τ p.val p.property hp |
| rw [h,Complex.zero_re] at hh |
| exact (lt_irrefl _ hh) |
| rw [cornerCentered,trace_sub,cornerTrace_smul,cornerScalar,div_mul_cancel₀ _ hn,sub_self] |
|
|
| theorem compress_cornerCentered {p q : AlgebraProjection M} (hqp : q ≤ p) |
| (x : M.toStarSubalgebra) : |
| q.val*cornerCentered τ p x*q.val = q.val*x*q.val-cornerScalar τ p x • q.val := by |
| simp only [cornerCentered,mul_sub,sub_mul,mul_smul_comm,smul_mul_assoc] |
| have hl : p.val*q.val=q.val := hqp |
| have hr := projection_mul_of_le hqp |
| simp only [← mul_assoc,hr] |
| simp only [mul_assoc,hl,q.property.isIdempotentElem.eq] |
|
|
| /-- A supported compression has the trace scale sqrt(trace(q)), even against |
| an arbitrary bounded ambient test operator. -/ |
| theorem supported_trace_test_le (q : AlgebraProjection M) (x y : M.toStarSubalgebra) |
| (hx : x*q.val=x) : |
| ‖τ.trace (x*y)‖ ≤ τ.norm₂ x * (τ.norm₂ q.val * ‖y‖) := by |
| calc ‖τ.trace (x*y)‖ = ‖τ.trace (x*(q.val*y))‖ := by rw [← mul_assoc,hx] |
| _ ≤ τ.norm₂ x * τ.norm₂ (q.val*y) := norm_trace_mul_le τ _ _ |
| _ ≤ τ.norm₂ x * (τ.norm₂ q.val * ‖y‖) := |
| mul_le_mul_of_nonneg_left (τ.norm₂_mul_le_right _ _) (norm_nonneg _) |
|
|
| theorem compression_trace_test_le (q : AlgebraProjection M) (x y : M.toStarSubalgebra) |
| (hy : ‖y‖ ≤ 1) : |
| ‖τ.trace ((q.val*x*q.val)*y)‖ ≤ τ.norm₂ (q.val*x*q.val) * τ.norm₂ q.val := by |
| have hx : (q.val*x*q.val)*q.val=q.val*x*q.val := by |
| rw [mul_assoc,q.property.isIdempotentElem.eq] |
| exact (supported_trace_test_le τ q _ y hx).trans |
| (mul_le_mul_of_nonneg_left (by nlinarith [show 0 ≤ τ.norm₂ q.val from norm_nonneg _]) |
| (norm_nonneg _)) |
|
|
| end |
|
|
| /-! Actual noncommutative L1 on the coordinate algebra: trace(sqrt(x* x)). |
| The supported L2-to-L1 estimate retains the square root of the support trace. |
| No quantizing projection or conditional expectation theorem is assumed. -/ |
| section |
| open scoped CStarAlgebra |
| open UltrapowerBridge |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] |
| variable {M : VonNeumannAlgebra H} |
| local instance : CStarAlgebra M.toStarSubalgebra := {} |
| local instance : PartialOrder M.toStarSubalgebra := CStarAlgebra.spectralOrder _ |
| local instance : LE M.toStarSubalgebra := (CStarAlgebra.spectralOrder _).toLE |
| local instance : StarOrderedRing M.toStarSubalgebra := CStarAlgebra.spectralOrderedRing _ |
| variable (τ : TracialRepresentation M) |
|
|
| def traceAbs (x : M.toStarSubalgebra) : M.toStarSubalgebra := CFC.sqrt (star x*x) |
| def norm₁ (x : M.toStarSubalgebra) : ℝ := (τ.trace (traceAbs x)).re |
|
|
| theorem traceAbs_selfAdjoint (x : M.toStarSubalgebra) : IsSelfAdjoint (traceAbs x) := |
| (CFC.sqrt_nonneg _).isSelfAdjoint |
|
|
| theorem traceAbs_sq (x : M.toStarSubalgebra) : traceAbs x * traceAbs x = star x*x := |
| CFC.sqrt_mul_sqrt_self _ (star_mul_self_nonneg x) |
|
|
| theorem traceAbs_norm₂ (x : M.toStarSubalgebra) : τ.norm₂ (traceAbs x) = τ.norm₂ x := by |
| have h := congrArg Complex.re (τ.trace_star_mul (traceAbs x)) |
| rw [(traceAbs_selfAdjoint x).star_eq,traceAbs_sq,τ.trace_star_mul] at h |
| simp only [← Complex.ofReal_pow,Complex.ofReal_re] at h |
| nlinarith [show 0 ≤ τ.norm₂ x from norm_nonneg _, |
| show 0 ≤ τ.norm₂ (traceAbs x) from norm_nonneg _] |
|
|
| theorem trace_nonneg_of_nonneg (a : M.toStarSubalgebra) (ha : 0 ≤ a) : |
| 0 ≤ (τ.trace a).re := by |
| have hs := (CFC.sqrt_nonneg a).isSelfAdjoint.star_eq |
| have h := congrArg Complex.re (τ.trace_star_mul (CFC.sqrt a)) |
| rw [hs,CFC.sqrt_mul_sqrt_self a ha] at h |
| rw [h] |
| simp only [← Complex.ofReal_pow,Complex.ofReal_re] |
| positivity |
|
|
| theorem norm₁_nonneg (x : M.toStarSubalgebra) : 0 ≤ norm₁ τ x := |
| trace_nonneg_of_nonneg τ _ (CFC.sqrt_nonneg _) |
|
|
| theorem norm₁_le_norm₂ (x : M.toStarSubalgebra) : norm₁ τ x ≤ τ.norm₂ x := by |
| exact (Complex.re_le_norm _).trans ((τ.norm_trace_le_norm₂ _).trans_eq (traceAbs_norm₂ τ x)) |
|
|
| /-- Right support passes to the positive square root without a polar decomposition. -/ |
| theorem traceAbs_support (q : AlgebraProjection M) (x : M.toStarSubalgebra) |
| (hx : x*q.val=x) : traceAbs x*q.val=traceAbs x := by |
| have he : star (traceAbs x*(1-q.val))*(traceAbs x*(1-q.val))=0 := by |
| rw [star_mul,star_sub,star_one,q.property.isSelfAdjoint.star_eq, |
| (traceAbs_selfAdjoint x).star_eq] |
| calc (1-q.val)*traceAbs x*(traceAbs x*(1-q.val)) = |
| (1-q.val)*(traceAbs x*traceAbs x)*(1-q.val) := by simp only [mul_assoc] |
| _ = 0 := by |
| rw [traceAbs_sq] |
| simp only [mul_assoc,mul_sub,mul_one,hx,sub_self] |
| have hz := (CStarRing.star_mul_self_eq_zero_iff _).mp he |
| rw [mul_sub,mul_one,sub_eq_zero] at hz |
| exact hz.symm |
|
|
| /-- The trace scale needed in corner local quantization. -/ |
| theorem norm₁_le_support_norm₂ (q : AlgebraProjection M) (x : M.toStarSubalgebra) |
| (hx : x*q.val=x) : norm₁ τ x ≤ τ.norm₂ x * τ.norm₂ q.val := by |
| calc norm₁ τ x ≤ ‖τ.trace (traceAbs x)‖ := Complex.re_le_norm _ |
| _ = ‖τ.trace (traceAbs x*q.val)‖ := by rw [traceAbs_support q x hx] |
| _ ≤ τ.norm₂ (traceAbs x) * τ.norm₂ q.val := norm_trace_mul_le τ _ _ |
| _ = τ.norm₂ x * τ.norm₂ q.val := by rw [traceAbs_norm₂] |
|
|
| theorem compression_norm₁_le (q : AlgebraProjection M) (x : M.toStarSubalgebra) : |
| norm₁ τ (q.val*x*q.val) ≤ τ.norm₂ (q.val*x*q.val)*τ.norm₂ q.val := by |
| apply norm₁_le_support_norm₂ |
| rw [mul_assoc,q.property.isIdempotentElem.eq] |
|
|
| /-- A strict corner L2 estimate supplies the manuscript's actual L1 estimate. -/ |
| theorem compression_norm₁_lt_of_norm₂ (q : AlgebraProjection M) (hq : q.val ≠ 0) |
| (x : M.toStarSubalgebra) (ε : ℝ) |
| (h : τ.norm₂ (q.val*x*q.val) < ε*τ.norm₂ q.val) : |
| norm₁ τ (q.val*x*q.val) < ε*(τ.trace q.val).re := by |
| have hp : 0 < τ.norm₂ q.val := lt_of_le_of_ne (norm_nonneg _) |
| (fun h => hq ((τ.norm₂_eq_zero_iff q.val).mp h.symm)) |
| have he := projection_trace_sq τ q.val q.property |
| calc norm₁ τ (q.val*x*q.val) ≤ τ.norm₂ (q.val*x*q.val)*τ.norm₂ q.val := |
| compression_norm₁_le τ q x |
| _ < (ε*τ.norm₂ q.val)*τ.norm₂ q.val := mul_lt_mul_of_pos_right h hp |
| _ = ε*(τ.trace q.val).re := by rw [he]; ring |
| |
| end |
| |
| /-! A finite compression-energy estimate yields a nonzero corner projection with simultaneous L1 control. -/ |
| section |
| open scoped BigOperators |
| open UltrapowerBridge |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] |
| variable {M : VonNeumannAlgebra H} (τ : TracialRepresentation M) |
|
|
| theorem exists_small_energy_piece {I J : Type*} (s : Finset I) (F : Finset J) |
| (t : I → ℝ) (a : I → J → ℝ) (ε : ℝ) |
| (ht : ∀ i ∈ s, 0 ≤ t i) (ha : ∀ i ∈ s, ∀ j ∈ F, 0 ≤ a i j) |
| (h : ∑ i ∈ s, ∑ j ∈ F, a i j < ε * ∑ i ∈ s, t i) : |
| ∃ i ∈ s, 0 < t i ∧ ∀ j ∈ F, a i j < ε*t i := by |
| classical |
| have hex : ∃ i ∈ s, (∑ j ∈ F, a i j) < ε*t i := by |
| by_contra hn |
| push Not at hn |
| have he := Finset.sum_le_sum hn |
| rw [← Finset.mul_sum] at he |
| exact (not_lt_of_ge he) h |
| obtain ⟨i,hi,he⟩ := hex |
| have htpos : 0 < t i := by |
| by_contra hn |
| have hz : t i=0 := le_antisymm (le_of_not_gt hn) (ht i hi) |
| rw [hz,mul_zero] at he |
| exact (not_lt_of_ge (Finset.sum_nonneg (ha i hi))) he |
| refine ⟨i,hi,htpos,fun j hj => ?_⟩ |
| exact (Finset.single_le_sum (ha i hi) hj).trans_lt he |
|
|
| /-- The aggregate squared L2 budget has exactly the trace weighting required |
| for simultaneous strict L1 estimates on a nonzero subprojection. -/ |
| theorem exists_corner_L1_of_partition_energy {I : Type*} |
| (s : Finset I) (p : AlgebraProjection M) (q : I → AlgebraProjection M) |
| (hq : ∀ i ∈ s, q i ≤ p) (F : Finset M.toStarSubalgebra) |
| (ε : ℝ) (hε : 0 < ε) |
| (henergy : ∑ i ∈ s, ∑ x ∈ F, |
| τ.norm₂ ((q i).val*cornerCentered τ p x*(q i).val)^2 < |
| ε^2 * ∑ i ∈ s, (τ.trace (q i).val).re) : |
| ∃ r : AlgebraProjection M, r ≤ p ∧ r.val ≠ 0 ∧ (∃ i ∈ s, r=q i) ∧ ∀ x ∈ F, |
| norm₁ τ (r.val*cornerCentered τ p x*r.val) < ε*(τ.trace r.val).re := by |
| obtain ⟨i,hi,ht,he⟩ := exists_small_energy_piece s F |
| (fun i => (τ.trace (q i).val).re) |
| (fun i x => τ.norm₂ ((q i).val*cornerCentered τ p x*(q i).val)^2) (ε^2) |
| (fun i hi => by rw [projection_trace_sq τ _ (q i).property]; positivity) |
| (fun i hi x hx => sq_nonneg _) henergy |
| have hn : (q i).val ≠ 0 := by |
| intro hz |
| have hzero : τ.trace (q i).val=0 := by rw [hz]; exact inner_zero_right _ |
| rw [hzero,Complex.zero_re] at ht |
| exact (lt_irrefl _ ht) |
| refine ⟨q i,hq i hi,hn,⟨i,hi,rfl⟩,fun x hx => ?_⟩ |
| apply compression_norm₁_lt_of_norm₂ τ (q i) hn |
| have h := he x hx |
| rw [projection_trace_sq τ _ (q i).property] at h |
| have hnq : 0 ≤ τ.norm₂ (q i).val := norm_nonneg _ |
| have hnx : 0 ≤ τ.norm₂ ((q i).val*cornerCentered τ p x*(q i).val) := norm_nonneg _ |
| nlinarith [mul_nonneg hε.le hnq] |
|
|
| end |
|
|
| /-! The scalar trace estimate for a term with two supported patch letters. |
| It reduces to the actual compressed middle coefficient and keeps trace(q), |
| not trace(p), as the scale of the error. -/ |
| open UltrapowerBridge |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] |
| variable {M : VonNeumannAlgebra H} (τ : TracialRepresentation M) |
|
|
| namespace CornerUnitary |
|
|
| theorem norm₂_eq_support {q : AlgebraProjection M} (v : CornerUnitary q) : |
| τ.norm₂ v.val=τ.norm₂ q.val := by |
| have he := v.trace_norm_sq τ |
| rw [projection_trace_sq τ _ q.property] at he |
| nlinarith [show 0 ≤ τ.norm₂ v.val from norm_nonneg _,show 0 ≤ τ.norm₂ q.val from norm_nonneg _] |
|
|
| end CornerUnitary |
|
|
| theorem two_patch_trace_le (q : AlgebraProjection M) (v w : CornerUnitary q) |
| (a x b : M.toStarSubalgebra) (ha : ‖a‖ ≤ 1) (hb : ‖b‖ ≤ 1) : |
| ‖τ.trace (a*v.val*x*w.val*b)‖ ≤ τ.norm₂ (q.val*x*q.val)*τ.norm₂ q.val := by |
| have he : a*v.val*x*w.val*b = (a*v.val)*(q.val*x*q.val)*(w.val*b) := by |
| simp only [← mul_assoc] |
| rw [mul_assoc a v.val q.val,v.mul_support] |
| simp only [mul_assoc] |
| rw [← mul_assoc q.val w.val b,w.support_mul] |
| have hr : τ.trace ((a*v.val)*(q.val*x*q.val)*(w.val*b)) = |
| τ.trace ((q.val*x*q.val)*(w.val*b*a*v.val)) := by |
| rw [mul_assoc (a*v.val) (q.val*x*q.val) (w.val*b),τ.trace_mul_comm (a*v.val)] |
| simp only [mul_assoc] |
| have hnorm : ‖w.val*b*a‖ ≤ 1 := by |
| have hw : ‖w.val*b‖ ≤ 1 := (norm_mul_le _ _).trans |
| (by nlinarith [w.norm_le_one,norm_nonneg w.val,norm_nonneg b]) |
| exact (norm_mul_le _ _).trans (by nlinarith [norm_nonneg (w.val*b),norm_nonneg a]) |
| rw [he,hr] |
| have hn : τ.norm₂ (w.val*b*a*v.val) ≤ τ.norm₂ q.val := by |
| exact ((τ.norm₂_mul_le _ _).trans (mul_le_of_le_one_left (norm_nonneg _) hnorm)).trans_eq |
| (v.norm₂_eq_support τ) |
| exact (norm_trace_mul_le τ _ _).trans (mul_le_mul_of_nonneg_left hn (norm_nonneg _)) |
|
|
| /-- The middle compression may be corner-centered with respect to a larger |
| residual support. This is the scalar version of the multiple-patch estimate. -/ |
| theorem two_patch_centered_trace_lt (p q : AlgebraProjection M) (hq : q.val ≠ 0) |
| (v w : CornerUnitary q) (a x b : M.toStarSubalgebra) (ha : ‖a‖ ≤ 1) (hb : ‖b‖ ≤ 1) |
| (ε : ℝ) (h : τ.norm₂ (q.val*cornerCentered τ p x*q.val) < ε*τ.norm₂ q.val) : |
| ‖τ.trace (a*v.val*cornerCentered τ p x*w.val*b)‖ < ε*(τ.trace q.val).re := by |
| have hpos : 0 < τ.norm₂ q.val := lt_of_le_of_ne (norm_nonneg _) |
| (fun hz => hq ((τ.norm₂_eq_zero_iff _).mp hz.symm)) |
| calc _ ≤ τ.norm₂ (q.val*cornerCentered τ p x*q.val)*τ.norm₂ q.val := |
| two_patch_trace_le τ q v w a _ b ha hb |
| _ < (ε*τ.norm₂ q.val)*τ.norm₂ q.val := mul_lt_mul_of_pos_right h hpos |
| _ = ε*(τ.trace q.val).re := by rw [projection_trace_sq τ _ q.property]; ring |
| |
| end Generator.Tracial |
| |
| end |
| |
| end OAI |
| |
