| import OAI.Analysis.FactorGeneration.PatchingBounds |
| import OAI.Analysis.FactorGeneration.RepresentedCorners |
| import OAI.Analysis.FactorGeneration.ResidualEstimates |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace Generator.Tracial |
|
|
| /-! Construct local patches in the actual f=1 residual. Both residual trace |
| terms are retained. Admissibility of the full extended word family is not asserted. -/ |
| section |
| open scoped BigOperators |
| open UltrapowerBridge |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] |
| variable {N M : VonNeumannAlgebra H} (τ : TracialRepresentation M) |
| theorem unitResidual_scalar_two_moment_bound (v : PartialUnitary M) |
| (hsmall : (τ.trace v.support.val).re ≤ 1/4) |
| (x : M.toStarSubalgebra) (A B : ℝ) (hAB : 0 ≤ A+B) |
| (hA : ‖τ.trace x‖ ≤ A*(τ.trace v.support.val).re) |
| (hB : ‖τ.trace (star v.val*x*v.val)‖ ≤ B*(τ.trace v.support.val).re) : |
| ‖cornerScalar τ (unitResidual v) x‖ ≤ (A+B)/3 := by |
| have htrace : τ.trace ((unitResidual v).val*x*(unitResidual v).val)= |
| τ.trace x-τ.trace (star v.val*x*v.val) := by |
| simpa only [residualCorner,unitResidual,identityProjection,one_mul] using |
| residualCorner_compression_trace τ (identityProjection M) v (one_mul _) x |
| rw [cornerScalar,htrace,norm_div,projection_trace_real τ (unitResidual v), |
| Complex.norm_real,Real.norm_of_nonneg (unitResidual_positive τ v hsmall).le] |
| rw [div_le_iff₀ (unitResidual_positive τ v hsmall)] |
| have hn := norm_sub_le (τ.trace x) (τ.trace (star v.val*x*v.val)) |
| rw [unitResidual_trace,Complex.sub_re,Complex.one_re] |
| nlinarith [mul_le_mul_of_nonneg_left hsmall hAB] |
|
|
| variable (hNM : N ≤ M) |
| variable (hfactor : ∀ c : N.toStarSubalgebra, |
| (∀ a : N.toStarSubalgebra,a*c=c*a) → ∃ z : ℂ,c=z • (1 : N.toStarSubalgebra)) |
| variable (hdiff : ∀ p : N.toStarSubalgebra,IsStarProjection p → p ≠ 0 → |
| ∃ q : N.toStarSubalgebra,IsStarProjection q ∧ q ≠ 0 ∧ q ≠ p ∧ p*q=q ∧ q*p=q) |
| variable (hirr : ∀ c : M.toStarSubalgebra, |
| (∀ a : N.toStarSubalgebra,coordinateInclusion hNM a*c=c*coordinateInclusion hNM a) → |
| ∃ z : ℂ,c=z • (1 : M.toStarSubalgebra)) |
| variable (hsep : TopologicalSpace.IsSeparable (Set.range (baseVector τ))) |
| include hfactor hdiff hirr hsep |
|
|
| theorem exists_unitResidual_local_compression |
| (v : PartialUnitary M) (hvN : v.val.val ∈ N) |
| (hsmall : (τ.trace v.support.val).re ≤ 1/4) |
| {ι : Type*} (F : Finset ι) (x : ι → M.toStarSubalgebra) (A B : ι → ℝ) |
| (hAB : ∀ i ∈ F,0 ≤ A i+B i) |
| (hA : ∀ i ∈ F,‖τ.trace (x i)‖ ≤ A i*(τ.trace v.support.val).re) |
| (hB : ∀ i ∈ F,‖τ.trace (star v.val*x i*v.val)‖ ≤ B i*(τ.trace v.support.val).re) |
| (η : ℝ) (hη : 0 < η) : |
| ∃ q : AlgebraProjection M,q ≤ unitResidual v ∧ q.val ≠ 0 ∧ q.val.val ∈ N ∧ |
| ∀ i ∈ F,τ.norm₂ (q.val*x i*q.val) < (η+(A i+B i)/3)*τ.norm₂ q.val ∧ |
| norm₁ τ (q.val*x i*q.val) < (η+(A i+B i)/3)*(τ.trace q.val).re := by |
| have hp : (unitResidual v).val ≠ 0 := by |
| intro h |
| have hh := unitResidual_positive τ v hsmall |
| rw [h,show τ.trace 0=0 from inner_zero_right _,Complex.zero_re] at hh |
| exact (lt_irrefl _ hh) |
| have hpN : (unitResidual v).val.val ∈ N := by |
| have hvp : v.support.val.val ∈ N := by |
| rw [← v.unitary.initial] |
| exact N.mul_mem (N.toStarSubalgebra.star_mem' hvN) hvN |
| exact N.sub_mem N.one_mem hvp |
| obtain ⟨q,hqp,hq,hqN,hlocal⟩ := exists_irreducible_corner_local_piece τ hNM hfactor hdiff hirr hsep |
| (unitResidual v) hp hpN F x η hη |
| refine ⟨q,hqp,hq,hqN,fun i hi => ?_⟩ |
| have hs := unitResidual_scalar_two_moment_bound τ v hsmall (x i) (A i) (B i) |
| (hAB i hi) (hA i hi) (hB i hi) |
| have hn : τ.norm₂ (q.val*x i*q.val) < (η+(A i+B i)/3)*τ.norm₂ q.val := by |
| have ht := τ.norm₂_add_le (q.val*x i*q.val-cornerScalar τ (unitResidual v) (x i) • q.val) |
| (cornerScalar τ (unitResidual v) (x i) • q.val) |
| rw [sub_add_cancel,τ.norm₂_smul] at ht |
| have hmul := mul_le_mul_of_nonneg_right hs (show 0 ≤ τ.norm₂ q.val from norm_nonneg _) |
| have hh := (hlocal i hi).1 |
| nlinarith only [ht,hmul,hh] |
| exact ⟨hn,compression_norm₁_lt_of_norm₂ τ q hq (x i) _ hn⟩ |
|
|
| /-- Choose the patch unitary after q, so the same q controls all two-letter |
| terms and the signed one-letter traces are as small as prescribed. -/ |
| theorem exists_unitResidual_controlled_patch |
| (v : PartialUnitary M) (hvN : v.val.val ∈ N) |
| (hsmall : (τ.trace v.support.val).re ≤ 1/4) |
| {ι : Type*} (F : Finset ι) (x : ι → M.toStarSubalgebra) (A B : ι → ℝ) |
| (hAB : ∀ i ∈ F,0 ≤ A i+B i) |
| (hA : ∀ i ∈ F,‖τ.trace (x i)‖ ≤ A i*(τ.trace v.support.val).re) |
| (hB : ∀ i ∈ F,‖τ.trace (star v.val*x i*v.val)‖ ≤ B i*(τ.trace v.support.val).re) |
| (L R : Finset M.toStarSubalgebra) (η κ : ℝ) (hη : 0 < η) (hκ : 0 < κ) : |
| ∃ (q : AlgebraProjection M) (w : CornerUnitary q), |
| q ≤ unitResidual v ∧ q.val ≠ 0 ∧ q.val.val ∈ N ∧ w.val.val ∈ N ∧ |
| (∀ a ∈ L,∀ b ∈ R,∀ s : Bool,‖τ.trace (a*signedLetter w.val s*b)‖ < κ*(τ.trace q.val).re) ∧ |
| (∀ i ∈ F,∀ u z : CornerUnitary q,∀ a b : M.toStarSubalgebra,‖a‖ ≤ 1 → ‖b‖ ≤ 1 → |
| ‖τ.trace (a*u.val*x i*z.val*b)‖ < (η+(A i+B i)/3)*(τ.trace q.val).re) := by |
| obtain ⟨q,hqp,hq,hqN,hlocal⟩ := exists_unitResidual_local_compression τ hNM hfactor hdiff hirr hsep |
| v hvN hsmall F x A B hAB hA hB η hη |
| let qN := projectionInSubalgebra q hqN |
| have hqN0 : qN.val ≠ 0 := by |
| intro hz |
| exact hq (Subtype.ext (congrArg (fun a : N.toStarSubalgebra => a.val) hz)) |
| obtain ⟨w,hw⟩ := exists_cornerUnitary_small_signed_traces τ hNM hdiff qN hqN0 L R |
| (κ*(τ.trace q.val).re) (mul_pos hκ (projection_trace_pos τ q.val q.property hq)) |
| let wM : CornerUnitary q := { |
| val := coordinateInclusion hNM w.val |
| initial := by |
| rw [← map_star,← map_mul,w.initial] |
| rfl |
| final := by |
| rw [← map_star,← map_mul,w.final] |
| rfl } |
| refine ⟨q,wM,hqp,hq,hqN,w.val.property,hw,fun i hi u z a b ha hb => ?_⟩ |
| have hh := (hlocal i hi).1 |
| calc _ ≤ τ.norm₂ (q.val*x i*q.val)*τ.norm₂ q.val := two_patch_trace_le τ q u z a (x i) b ha hb |
| _ < ((η+(A i+B i)/3)*τ.norm₂ q.val)*τ.norm₂ q.val := |
| mul_lt_mul_of_pos_right hh (corner_norm₂_pos τ q hq) |
| _ = _ := by rw [projection_trace_sq τ q.val q.property]; ring |
| |
| end |
| |
| /-! A single actual residual patch controls every finite internal word of the |
| source family. All scalar moment premises are proved from admissibility. -/ |
| section |
| open UltrapowerBridge |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] |
| variable {N M : VonNeumannAlgebra H} (τ : TracialRepresentation M) |
| variable (hNM : N ≤ M) |
| variable (hfactor : ∀ c : N.toStarSubalgebra, |
| (∀ a : N.toStarSubalgebra,a*c=c*a) → ∃ z : ℂ,c=z • (1 : N.toStarSubalgebra)) |
| variable (hdiff : ∀ p : N.toStarSubalgebra,IsStarProjection p → p ≠ 0 → |
| ∃ q : N.toStarSubalgebra,IsStarProjection q ∧ q ≠ 0 ∧ q ≠ p ∧ p*q=q ∧ q*p=q) |
| variable (hirr : ∀ c : M.toStarSubalgebra, |
| (∀ a : N.toStarSubalgebra,coordinateInclusion hNM a*c=c*coordinateInclusion hNM a) → |
| ∃ z : ℂ,c=z • (1 : M.toStarSubalgebra)) |
| variable (hsep : TopologicalSpace.IsSeparable (Set.range (baseVector τ))) |
| include hfactor hdiff hirr hsep |
|
|
| theorem exists_admissible_family_patch |
| (F : Finset M.toStarSubalgebra) (hcenter : ∀ x ∈ F,τ.trace x=0) |
| (n : ℕ) (δ : ℝ) (hδ : 0 < δ) |
| (v : PartialUnitary M) |
| (hv : PatchingAdmissibleIn (P := N) τ (identityProjection M) F n (patchingTolerance δ) v) |
| (hsmall : (τ.trace v.support.val).re ≤ 1/4) |
| (κ : ℝ) (hκ : 0 < κ) : |
| ∃ (q : AlgebraProjection M) (w : CornerUnitary q), |
| q ≤ unitResidual v ∧ q.val ≠ 0 ∧ q.val.val ∈ N ∧ w.val.val ∈ N ∧ |
| (∀ a ∈ outerWordFamily v.val F n,∀ b ∈ outerWordFamily v.val F n,∀ s : Bool, |
| ‖τ.trace (a*signedLetter w.val s*b)‖ < κ*(τ.trace q.val).re) ∧ |
| (∀ x ∈ F,∀ xs : List (Bool × M.toStarSubalgebra), |
| xs.length+2 ≤ n → (∀ a ∈ xs,a.2 ∈ F) → |
| ∀ u z : CornerUnitary q,∀ a b : M.toStarSubalgebra,‖a‖ ≤ 1 → ‖b‖ ≤ 1 → |
| ‖τ.trace (a*u.val*(x*patchingWord v.val xs)*z.val*b)‖ < |
| (2*patchingTolerance δ (xs.length+2)/3)*(τ.trace q.val).re) := by |
| let X := middleWordFamily F n |
| let mid := fun i : M.toStarSubalgebra × List (Bool × M.toStarSubalgebra) => |
| i.1*patchingWord v.val i.2 |
| let A := fun i : M.toStarSubalgebra × List (Bool × M.toStarSubalgebra) => |
| middleMomentError (patchingTolerance δ) i.2.length |
| let B := fun i : M.toStarSubalgebra × List (Bool × M.toStarSubalgebra) => |
| patchingTolerance δ (i.2.length+2) |
| have hm := middleWordFamily_moments τ v (identityProjection M) F n |
| (patchingTolerance δ) hv.1 hcenter |
| obtain ⟨q,w,hqp,hq,hqN,hwN,hfirst,hsecond⟩ := exists_unitResidual_controlled_patch τ hNM |
| hfactor hdiff hirr hsep v hv.2 hsmall X mid A B |
| (fun i _ => add_nonneg |
| (middleMomentError_nonneg _ (fun k => (patchingTolerance_pos δ hδ k).le) _) |
| (patchingTolerance_pos δ hδ _).le) |
| (fun i hi => (hm i hi).1) (fun i hi => (hm i hi).2) |
| (outerWordFamily v.val F n) (outerWordFamily v.val F n) |
| (δ/3) κ (by positivity) hκ |
| refine ⟨q,w,hqp,hq,hqN,hwN,hfirst,?_⟩ |
| intro x hx xs hlen hxs u z a b ha hb |
| have hi : (x,xs) ∈ X := (mem_middleWordFamily F n x xs).mpr ⟨hx,hlen,hxs⟩ |
| have hh := hsecond (x,xs) hi u z a b ha hb |
| exact hh.trans_le (mul_le_mul_of_nonneg_right (patchingTolerance_middle_budget δ hδ xs.length) |
| (projection_trace_pos τ q.val q.property hq).le) |
|
|
| end |
|
|
| /-! Trace estimates for each actual binary-mask term, using the constructed |
| finite families. No moment estimate or middle-family extraction is assumed. -/ |
| section |
| open UltrapowerBridge |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] |
| variable {M : VonNeumannAlgebra H} (τ : TracialRepresentation M) |
|
|
| def signedCornerUnitary {q : AlgebraProjection M} (w : CornerUnitary q) (s : Bool) : |
| CornerUnitary q := if s then w.adjoint else w |
|
|
| @[simp] theorem signedCornerUnitary_val {q : AlgebraProjection M} (w : CornerUnitary q) (s : Bool) : |
| (signedCornerUnitary w s).val=signedLetter w.val s := by cases s <;> rfl |
| |
| theorem maskedWord_one_decomposition |
| (xs : List (Bool × M.toStarSubalgebra)) (bs : List Bool) |
| (hlen : bs.length=xs.length) (hcount : bs.count true=1) : |
| ∃ pre a post,xs=pre++a::post ∧ |
| bs=List.replicate pre.length false++true::List.replicate post.length false := by |
| obtain ⟨i,cs,hbs⟩ := exists_first_true bs (by omega) |
| have hc : cs.count true=0 := by simpa [hbs,List.count_replicate] using hcount |
| have hcs := (count_true_zero_iff cs).mp hc |
| have hl : i+1+cs.length=xs.length := by |
| rw [hbs] at hlen |
| simp only [List.length_append,List.length_replicate,List.length_cons] at hlen |
| omega |
| obtain ⟨pre,a,post,hxs,hp⟩ := exists_list_split xs i (by omega) |
| have ht : cs.length=post.length := by rw [hxs,List.length_append,List.length_cons,hp] at hl; omega |
| refine ⟨pre,a,post,hxs,?_⟩ |
| simpa only [hp,ht] using (hbs.trans (congrArg (fun ds => List.replicate i false++true::ds) hcs)) |
|
|
| theorem maskedWord_one_trace_lt (v : PartialUnitary M) {q : AlgebraProjection M} |
| (w : CornerUnitary q) (F : Finset M.toStarSubalgebra) (n : ℕ) (κ : ℝ) |
| (hfirst : ∀ a ∈ outerWordFamily v.val F n,∀ b ∈ outerWordFamily v.val F n,∀ s : Bool, |
| ‖τ.trace (a*signedLetter w.val s*b)‖ < κ*(τ.trace q.val).re) |
| (x₀ : M.toStarSubalgebra) (hx₀ : x₀ ∈ (F : Set M.toStarSubalgebra) ∪ {1}) |
| (xs : List (Bool × M.toStarSubalgebra)) (hn : xs.length ≤ n) |
| (hc : patchingCoefficients (F : Set M.toStarSubalgebra) xs) |
| (bs : List Bool) (hlen : bs.length=xs.length) (hcount : bs.count true=1) : |
| ‖τ.trace (x₀*maskedWord v.val w.val xs bs)‖ < κ*(τ.trace q.val).re := by |
| obtain ⟨pre,a,post,hxs,hbs⟩ := maskedWord_one_decomposition xs bs hlen hcount |
| have hall := patchingCoefficients_mem (F : Set M.toStarSubalgebra) xs hc |
| have hpre : ∀ c ∈ pre,c.2 ∈ (F : Set M.toStarSubalgebra) ∪ {1} := by |
| intro c hc; apply hall c; simp [hxs,hc] |
| have hpost : ∀ c ∈ post,c.2 ∈ (F : Set M.toStarSubalgebra) ∪ {1} := by |
| intro c hc; apply hall c; simp [hxs,hc] |
| have ha : a.2 ∈ (F : Set M.toStarSubalgebra) ∪ {1} := hall a (by simp [hxs]) |
| have hsize : pre.length+1+post.length ≤ n := by simpa [hxs,Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] using hn |
| have hL := mem_outerWordFamily v.val F n x₀ pre hx₀ (by omega) hpre |
| have hR := mem_outerWordFamily v.val F n a.2 post ha (by omega) hpost |
| have hh := hfirst _ hL _ hR a.1 |
| rw [hxs,hbs,maskedWord_one] |
| simpa only [mul_assoc] using hh |
|
|
| theorem maskedWord_two_trace_lt (v : PartialUnitary M) {q : AlgebraProjection M} |
| (w : CornerUnitary q) (F : Finset M.toStarSubalgebra) (n : ℕ) (δ : ℝ) |
| (hF : ∀ x ∈ F,‖x‖ ≤ 1) |
| (hsecond : ∀ x ∈ F,∀ ys : List (Bool × M.toStarSubalgebra), |
| ys.length+2 ≤ n → (∀ a ∈ ys,a.2 ∈ F) → |
| ∀ u z : CornerUnitary q,∀ a b : M.toStarSubalgebra,‖a‖ ≤ 1 → ‖b‖ ≤ 1 → |
| ‖τ.trace (a*u.val*(x*patchingWord v.val ys)*z.val*b)‖ < |
| (2*patchingTolerance δ (ys.length+2)/3)*(τ.trace q.val).re) |
| (x₀ : M.toStarSubalgebra) (h₀ : ‖x₀‖ ≤ 1) |
| (xs : List (Bool × M.toStarSubalgebra)) (hn : xs.length ≤ n) |
| (hc : patchingCoefficients (F : Set M.toStarSubalgebra) xs) |
| (bs : List Bool) (hlen : bs.length=xs.length) (hcount : 2 ≤ bs.count true) : |
| ∃ r,r+2 ≤ xs.length ∧ |
| (bs ≠ exceptionalMask xs.length → r+2 ≤ xs.length-1) ∧ |
| ‖τ.trace (x₀*maskedWord v.val w.val xs bs)‖ < |
| (2*patchingTolerance δ (r+2)/3)*(τ.trace q.val).re := by |
| obtain ⟨pre,a,mid,b,post,cs,hxs,hbs,ha,hm,ht,hsize⟩ := |
| maskedWord_two_decomposition (F : Set M.toStarSubalgebra) xs hc bs hlen hcount |
| have hall := patchingCoefficients_norm (F : Set M.toStarSubalgebra) hF xs hc |
| have hpre : ∀ c ∈ pre,‖c.2‖ ≤ 1 := by intro c hc; apply hall c; simp [hxs,hc] |
| have hpost : ∀ c ∈ post,‖c.2‖ ≤ 1 := by intro c hc; apply hall c; simp [hxs,hc] |
| have hb : ‖b.2‖ ≤ 1 := hall b (by simp [hxs]) |
| have hp := patchingWord_norm_le_one v.val v.unitary.norm_le_one pre hpre |
| have ht' := maskedWord_norm_le_one v.val w.val v.unitary.norm_le_one w.norm_le_one post cs hpost |
| have hL : ‖x₀*patchingWord v.val pre‖ ≤ 1 := (norm_mul_le _ _).trans |
| ((mul_le_mul h₀ hp (norm_nonneg _) (by norm_num)).trans_eq (one_mul 1)) |
| have hR : ‖b.2*maskedWord v.val w.val post cs‖ ≤ 1 := (norm_mul_le _ _).trans |
| ((mul_le_mul hb ht' (norm_nonneg _) (by norm_num)).trans_eq (one_mul 1)) |
| refine ⟨mid.length,hsize,?_,?_⟩ |
| · intro he |
| by_contra h |
| have heq : mid.length+2=xs.length := by omega |
| have heq' : mid.length+2= |
| (List.replicate pre.length false++true::(List.replicate mid.length false++true::cs)).length := by |
| rw [← hbs,hlen,heq] |
| have hh := first_two_eq_exceptional pre.length mid.length cs heq' |
| rw [← hbs,hlen] at hh |
| exact he hh |
| · have hh := hsecond a.2 ha mid (by omega) hm |
| (signedCornerUnitary w a.1) (signedCornerUnitary w b.1) |
| (x₀*patchingWord v.val pre) (b.2*maskedWord v.val w.val post cs) hL hR |
| rw [hxs,hbs,maskedWord_first_two] |
| simpa only [signedCornerUnitary_val,mul_assoc] using hh |
|
|
| end |
|
|
| /-! Strict support growth for the actual f=1 admissible set. The single patch |
| is chosen from the finite coefficient families before any word is tested. -/ |
| open UltrapowerBridge |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] |
| variable {N M : VonNeumannAlgebra H} (τ : TracialRepresentation M) |
|
|
| theorem unitResidual_orthogonal (v : PartialUnitary M) (q : AlgebraProjection M) |
| (hq : q ≤ unitResidual v) : v.support.val*q.val=0 := by |
| change (1-v.support.val)*q.val=q.val at hq |
| have hh : q.val-v.support.val*q.val=q.val := by simpa only [sub_mul,one_mul] using hq |
| exact sub_eq_self.mp hh |
|
|
| def unitResidualPatch (v : PartialUnitary M) (q : AlgebraProjection M) (w : CornerUnitary q) |
| (hq : q ≤ unitResidual v) : PartialUnitary M := |
| ⟨⟨v.support.val+q.val,v.support.property.add q.property (unitResidual_orthogonal v q hq)⟩, |
| v.unitary.patch w (unitResidual_orthogonal v q hq)⟩ |
|
|
| theorem unitResidualPatch_extends (v : PartialUnitary M) (q : AlgebraProjection M) |
| (w : CornerUnitary q) (hq : q ≤ unitResidual v) : v ≤ unitResidualPatch v q w hq := by |
| have hh := v.unitary.patch_extends w (unitResidual_orthogonal v q hq) |
| change (v.unitary.patch w (unitResidual_orthogonal v q hq)).val*v.support.val=v.val |
| simpa only [v.unitary.initial] using hh |
|
|
| theorem unitResidualPatch_trace (v : PartialUnitary M) (q : AlgebraProjection M) |
| (w : CornerUnitary q) (hq : q ≤ unitResidual v) : |
| (τ.trace (unitResidualPatch v q w hq).support.val).re = |
| (τ.trace v.support.val).re+(τ.trace q.val).re := by |
| change (τ.trace (v.support.val+q.val)).re=_ |
| rw [cornerTrace_add,Complex.add_re] |
|
|
| variable (hNM : N ≤ M) |
| variable (hfactor : ∀ c : N.toStarSubalgebra, |
| (∀ a : N.toStarSubalgebra,a*c=c*a) → ∃ z : ℂ,c=z • (1 : N.toStarSubalgebra)) |
| variable (hdiff : ∀ p : N.toStarSubalgebra,IsStarProjection p → p ≠ 0 → |
| ∃ q : N.toStarSubalgebra,IsStarProjection q ∧ q ≠ 0 ∧ q ≠ p ∧ p*q=q ∧ q*p=q) |
| variable (hirr : ∀ c : M.toStarSubalgebra, |
| (∀ a : N.toStarSubalgebra,coordinateInclusion hNM a*c=c*coordinateInclusion hNM a) → |
| ∃ z : ℂ,c=z • (1 : M.toStarSubalgebra)) |
| variable (hsep : TopologicalSpace.IsSeparable (Set.range (baseVector τ))) |
| include hfactor hdiff hirr hsep |
|
|
| /-- The full extension satisfies every original admissibility inequality and |
| has strictly greater support trace. No patch growth premise is assumed. -/ |
| theorem exists_strict_admissible_unit_patch |
| (F : Finset M.toStarSubalgebra) (hF : ∀ x ∈ F,‖x‖ ≤ 1) |
| (hcenter : ∀ x ∈ F,τ.trace x=0) (n : ℕ) (δ : ℝ) (hδ : 0 < δ) |
| (v : PartialUnitary M) |
| (hv : PatchingAdmissibleIn (P := N) τ (identityProjection M) F n (patchingTolerance δ) v) |
| (hsmall : (τ.trace v.support.val).re ≤ 1/4) : |
| ∃ u : PartialUnitary M, |
| PatchingAdmissibleIn (P := N) τ (identityProjection M) F n (patchingTolerance δ) u ∧ |
| v ≤ u ∧ (τ.trace v.support.val).re < (τ.trace u.support.val).re := by |
| classical |
| obtain ⟨q,w,hqp,hq,hqN,hwN,hfirst,hsecond⟩ := exists_admissible_family_patch τ hNM |
| hfactor hdiff hirr hsep F hcenter n δ hδ v hv hsmall (δ/3) (by positivity) |
| let u := unitResidualPatch v q w hqp |
| have htq := projection_trace_pos τ q.val q.property hq |
| have htv : 0 ≤ (τ.trace v.support.val).re := by |
| rw [← v.unitary.trace_norm_sq τ]; positivity |
| have hg : (τ.trace u.support.val).re=(τ.trace v.support.val).re+(τ.trace q.val).re := |
| unitResidualPatch_trace τ v q w hqp |
| refine ⟨u,⟨⟨?_,?_⟩,?_⟩,unitResidualPatch_extends v q w hqp,by rw [hg]; linarith⟩ |
| · exact one_mul _ |
| · intro x₀ hx₀ xs hpos hn hc |
| have h₀ : ‖x₀‖ ≤ 1 := by |
| rcases hx₀ with h | h |
| · exact hF x₀ h |
| · rw [Set.mem_singleton_iff.mp h]; exact (IsStarProjection.one _).norm_le |
| let k := xs.length |
| let A := patchingTolerance δ k*(τ.trace v.support.val).re |
| let B := (2*patchingTolerance δ k/3)*(τ.trace q.val).re |
| let C := (2*patchingTolerance δ (k-1)/3)*(τ.trace q.val).re |
| have hεk := patchingTolerance_pos δ hδ k |
| have hεprev := patchingTolerance_pos δ hδ (k-1) |
| have hA : 0 ≤ A := mul_nonneg (patchingTolerance_pos δ hδ k).le htv |
| have hB : 0 ≤ B := mul_nonneg (by positivity) htq.le |
| have hC : 0 ≤ C := mul_nonneg (by positivity) htq.le |
| have hκ : (δ/3)*(τ.trace q.val).re ≤ C := by |
| have hd : δ ≤ patchingTolerance δ (k-1) := patchingTolerance_mono δ hδ (Nat.zero_le _) |
| apply mul_le_mul_of_nonneg_right _ htq.le |
| linarith |
| have hterm : ∀ bs ∈ binaryMasks k, |
| ‖τ.trace (x₀*maskedWord v.val w.val xs bs)‖ ≤ |
| C+(if bs=List.replicate k false then A else 0)+(if bs=exceptionalMask k then B else 0) := by |
| intro bs hbs |
| have hlen : bs.length=xs.length := (mem_binaryMasks k bs).mp hbs |
| have hAi : 0 ≤ (if bs=List.replicate k false then A else 0) := by split_ifs <;> positivity |
| have hBi : 0 ≤ (if bs=exceptionalMask k then B else 0) := by split_ifs <;> positivity |
| by_cases hz : bs.count true=0 |
| · have he : bs=List.replicate k false := by |
| simpa only [hlen] using (count_true_zero_iff bs).mp hz |
| have hh : ‖τ.trace (x₀*maskedWord v.val w.val xs bs)‖ ≤ A := by |
| rw [he,maskedWord_no_patch] |
| exact hv.1.2 x₀ hx₀ xs hpos hn hc |
| rw [ite_eq_left he] |
| linarith |
| · by_cases ho : bs.count true=1 |
| · have hh := (maskedWord_one_trace_lt τ v w F n (δ/3) hfirst x₀ hx₀ xs hn hc bs hlen ho).le.trans hκ |
| linarith |
| · obtain ⟨r,hr,hex,hbound⟩ := maskedWord_two_trace_lt τ v w F n δ hF hsecond x₀ h₀ xs hn hc bs hlen (by omega) |
| by_cases he : bs=exceptionalMask k |
| · have hmono := patchingTolerance_mono δ hδ hr |
| have hb : (2*patchingTolerance δ (r+2)/3)*(τ.trace q.val).re ≤ B := by |
| apply mul_le_mul_of_nonneg_right _ htq.le |
| linarith |
| have hh := hbound.le.trans hb |
| rw [ite_eq_left he] |
| linarith |
| · have hmono := patchingTolerance_mono δ hδ (hex he) |
| have hb : (2*patchingTolerance δ (r+2)/3)*(τ.trace q.val).re ≤ C := by |
| apply mul_le_mul_of_nonneg_right _ htq.le |
| linarith |
| have hh := hbound.le.trans hb |
| linarith |
| have hsum := sum_three_budgets (binaryMasks k) (binaryMasks_nodup k) |
| (fun bs => ‖τ.trace (x₀*maskedWord v.val w.val xs bs)‖) |
| (List.replicate k false) (exceptionalMask k) C A B hA hB hterm |
| have hbudget : ((binaryMasks k).length : ℝ)*C+B=patchingTolerance δ k*(τ.trace q.val).re := by |
| rw [binaryMasks_length,Nat.cast_pow,Nat.cast_ofNat] |
| have hh := congrArg (fun z : ℝ => z*(τ.trace q.val).re) (patchingTolerance_mask_budget δ k hpos) |
| dsimp [C,B] |
| nlinarith only [hh] |
| have hh := (patching_trace_sum_le τ v.val w.val x₀ xs).trans hsum |
| change ‖τ.trace (x₀*patchingWord (v.val+w.val) xs)‖ ≤ _ |
| rw [hg] |
| dsimp [A] at hh |
| nlinarith only [hh,hbudget] |
| · exact N.add_mem hv.2 hwN |
|
|
| /-- The maximal-element contradiction now gives support trace strictly greater |
| than one quarter in the f=1 scalar-commutant setting. -/ |
| theorem exists_large_admissible_partialUnitary |
| (F : Finset M.toStarSubalgebra) (hF : ∀ x ∈ F,‖x‖ ≤ 1) |
| (hcenter : ∀ x ∈ F,τ.trace x=0) (n : ℕ) (δ : ℝ) (hδ : 0 < δ) : |
| ∃ v : PartialUnitary M, |
| PatchingAdmissibleIn (P := N) τ (identityProjection M) F n (patchingTolerance δ) v ∧ |
| 1/4 < (τ.trace v.support.val).re := by |
| obtain ⟨v,hv,hmax⟩ := exists_maximal_patchingAdmissibleIn τ hNM (identityProjection M) F hF n (patchingTolerance δ) |
| refine ⟨v,hv,?_⟩ |
| by_contra h |
| obtain ⟨u,hu,hvu,hgrow⟩ := exists_strict_admissible_unit_patch τ hNM hfactor hdiff hirr hsep |
| F hF hcenter n δ hδ v hv (by linarith) |
| have hh := PartialUnitary.support_trace_mono τ (hmax u hu hvu) |
| linarith |
|
|
| end Generator.Tracial |
|
|
| end |
|
|
| end OAI |
|
|
