Download data/lean/OAI/Analysis/FactorGeneration/AmplificationEncoding.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 8.16 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/FactorGeneration/AmplificationEncoding.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/FactorGeneration/AmplificationEncoding.lean
-
curl -L -o AmplificationEncoding.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/FactorGeneration/AmplificationEncoding.lean
8.16 kB
| import Mathlib.LinearAlgebra.Complex.Module | |
| import OAI.Analysis.FactorGeneration.MatrixEncoding | |
| import OAI.Analysis.FactorGeneration.MatrixSequence | |
| import OAI.Analysis.FactorGeneration.ProjectionEncoding | |
| namespace OAI | |
| noncomputable section | |
| namespace Generator | |
| /-! One arbitrary operator and a pair of self-adjoint operators generate the same weakly closed star algebra. -/ | |
| open scoped ComplexStarModule | |
| section | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| local notation "Op" => H βL[β] H | |
| theorem realPart_mem (S : StarSubalgebra β Op) {x : Op} (hx : x β S) : | |
| (β x : Op) β S := by | |
| rw [realPart_apply_coe, β Complex.coe_smul] | |
| exact S.smul_mem (add_mem hx (star_mem hx)) _ | |
| theorem imaginaryPart_mem (S : StarSubalgebra β Op) {x : Op} (hx : x β S) : | |
| (β x : Op) β S := by | |
| rw [imaginaryPart_apply_coe, β Complex.coe_smul] | |
| exact S.smul_mem (S.smul_mem (sub_mem hx (star_mem hx)) _) _ | |
| theorem mem_iff_parts_mem (S : StarSubalgebra β Op) (x : Op) : | |
| x β S β (β x : Op) β S β§ (β x : Op) β S := by | |
| refine β¨fun hx => β¨realPart_mem S hx, imaginaryPart_mem S hxβ©, ?_β© | |
| rintro β¨hr, hiβ© | |
| rw [β realPart_add_I_smul_imaginaryPart x] | |
| exact add_mem hr (S.smul_mem hi _) | |
| theorem wstar_singleton_eq_parts (x : Op) : | |
| wstar {x} = wstar {(β x : Op), (β x : Op)} := by | |
| apply le_antisymm | |
| Β· apply wstar_le (wstar_closed _) | |
| intro y hy | |
| have hyx : y = x := Set.mem_singleton_iff.mp hy | |
| subst y | |
| apply (mem_iff_parts_mem _ x).mpr | |
| exact β¨subset_wstar _ (by simp), subset_wstar _ (by simp)β© | |
| Β· apply wstar_le (wstar_closed _) | |
| intro y hy | |
| have hx := subset_wstar {x} (Set.mem_singleton x) | |
| rcases Set.mem_insert_iff.mp hy with rfl | hy | |
| Β· exact realPart_mem _ hx | |
| Β· rcases Set.mem_singleton_iff.mp hy with rfl | |
| exact imaginaryPart_mem _ hx | |
| theorem realPart_pack {a b : Op} (ha : IsSelfAdjoint a) (hb : IsSelfAdjoint b) : | |
| (β (a + Complex.I β’ b) : Op) = a := by | |
| simp only [map_add, realPart_I_smul, hb.imaginaryPart, neg_zero, add_zero] | |
| exact ha.coe_realPart | |
| theorem imaginaryPart_pack {a b : Op} (ha : IsSelfAdjoint a) (hb : IsSelfAdjoint b) : | |
| (β (a + Complex.I β’ b) : Op) = b := by | |
| simp only [map_add, ha.imaginaryPart, imaginaryPart_I_smul, zero_add] | |
| exact hb.coe_realPart | |
| theorem wstar_pack {a b : Op} (ha : IsSelfAdjoint a) (hb : IsSelfAdjoint b) : | |
| wstar {a + Complex.I β’ b} = wstar {a, b} := by | |
| rw [wstar_singleton_eq_parts, realPart_pack ha hb, imaginaryPart_pack ha hb] | |
| /-- Exact equivalence in thm:main, without proving either side for II1 factors. -/ | |
| theorem singlyGenerated_iff_two_selfAdjoint (S : StarSubalgebra β Op) : | |
| SinglyGenerated S β β a β S, β b β S, | |
| IsSelfAdjoint a β§ IsSelfAdjoint b β§ wstar {a, b} = S := by | |
| constructor | |
| Β· rintro β¨x, hx, hgenβ© | |
| exact β¨β x, realPart_mem S hx, β x, imaginaryPart_mem S hx, | |
| (β x).property, (β x).property, (wstar_singleton_eq_parts x).symm.trans hgenβ© | |
| Β· rintro β¨a, ha, b, hb, hsa, hsb, hgenβ© | |
| exact β¨a + Complex.I β’ b, add_mem ha (S.smul_mem hb _), | |
| (wstar_pack hsa hsb).trans hgenβ© | |
| end | |
| /-! Two self-adjoint generators for an actual two-by-two amplification | |
| whose actual commutant has four self-adjoint generators. Spectral separation | |
| is proved, and the final generation uses the surjective coefficient map. -/ | |
| open scoped BigOperators | |
| namespace MatrixUnitSystem | |
| open MatrixEncoding | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| variable {M : VonNeumannAlgebra H} | |
| variable (E : MatrixUnitSystem (Fin 2) M.toStarSubalgebra) | |
| def concreteCoefficientHom : Matrix (Fin 2) (Fin 2) E.commutant βββ[β] (H βL[β] H) := | |
| M.toStarSubalgebra.subtype.comp E.coefficientHom | |
| theorem coefficient_corner (a : E.commutant) : | |
| E.concreteCoefficientHom (corner a)=a.val.val*(E.entry 0 0).val := by | |
| have he : corner a=Matrix.single 0 0 a := by ext i j; fin_cases i <;> fin_cases j <;> simp [corner,Matrix.single] | |
| change (E.coefficientHom (corner a)).val=_ | |
| rw [he,E.coefficientHom_single] | |
| rfl | |
| theorem coefficient_diagonal (a : E.commutant) : | |
| E.concreteCoefficientHom (corner a+E21*corner a*E12)=a.val.val := by | |
| have he : corner a+E21*corner a*E12=Matrix.diagonal (fun _ : Fin 2 => a) := by | |
| ext i j | |
| fin_cases i <;> fin_cases j <;> simp [corner,E21,E12,Matrix.diagonal] | |
| rw [he] | |
| change (E.coefficientEval (Matrix.diagonal (fun _ : Fin 2 => a))).val=a.val.val | |
| congr 1 | |
| simp [coefficientEval,Matrix.diagonal,apply_ite,ite_mul,β Finset.mul_sum,E.total] | |
| theorem two_generators_of_four_commutant_generators (aβ aβ aβ aβ : E.commutant) | |
| (hβ : IsSelfAdjoint aβ) (hβ : IsSelfAdjoint aβ) | |
| (hβ : IsSelfAdjoint aβ) (hβ : IsSelfAdjoint aβ) | |
| (hgen : wstar {aβ.val.val,aβ.val.val,aβ.val.val,aβ.val.val}=E.relativeVonNeumann.toStarSubalgebra) : | |
| β A β M,β B β M,IsSelfAdjoint A β§ IsSelfAdjoint B β§ wstar {A,B}=M.toStarSubalgebra := by | |
| let f := E.concreteCoefficientHom | |
| let t := f (encodeA aβ aβ 0) | |
| let q := f E22 | |
| let C : β := 2*βtβ+1 | |
| let A := f (encodeA aβ aβ (algebraMap β E.commutant (C : β))) | |
| let B := f (encodeB aβ aβ) | |
| have hA : A β M := (E.coefficientHom _).property | |
| have hB : B β M := (E.coefficientHom _).property | |
| have hsa : IsSelfAdjoint A := | |
| (encodeA_selfAdjoint hβ hβ (scalar_shift_selfAdjoint C)).map f | |
| have hsb : IsSelfAdjoint B := (encodeB_selfAdjoint hβ hβ).map f | |
| have hq : q*q=q := | |
| (map_mul f E22 E22).symm.trans (congrArg f E22_idempotent) | |
| have hqt : Commute q t := (E22_commute_encodeA aβ aβ).map f | |
| have hsplit : A=C β’ q+t := by | |
| change f _=C β’ f E22+f (encodeA aβ aβ 0) | |
| exact (congrArg f (encodeA_scalar_shift aβ aβ C)).trans | |
| ((map_add f _ _).trans (congrArg (fun x => x + f (encodeA aβ aβ 0)) | |
| ((map_smul f (C : β) E22).trans (Complex.coe_smul C (f E22))))) | |
| let Q := wstar {A,B} | |
| let S := Q.comap f | |
| have hAm : encodeA aβ aβ (algebraMap β E.commutant (C : β)) β S := subset_wstar _ (by simp [A]) | |
| have hBm : encodeB aβ aβ β S := subset_wstar _ (by simp [B]) | |
| have h22 : (E22 : Matrix (Fin 2) (Fin 2) E.commutant) β S := by | |
| change q β wstar {A,B} | |
| apply (wstar_mono (s := {A}) (t := {A,B}) (by simp)) | |
| rw [hsplit] | |
| exact idempotent_mem_wstar_of_gap q t hq hqt C (by dsimp [C]; linarith) | |
| have h11 : (E11 : Matrix (Fin 2) (Fin 2) E.commutant) β S := by | |
| have he : (1 : Matrix (Fin 2) (Fin 2) E.commutant)-E22=E11 := by rw [β complement]; abel | |
| rw [β he] | |
| exact S.sub_mem S.one_mem h22 | |
| obtain β¨_,h12,h21β© := matrix_units_mem S h11 hBm | |
| obtain β¨hcβ,hcβ,hcβ,hcββ© := encoded_corners_mem_scalar S (C : β) h11 hAm hBm | |
| have hcoeff (a : E.commutant) (ha : corner a β S) : a.val.val β Q := by | |
| rw [β E.coefficient_diagonal a] | |
| exact S.add_mem ha (S.mul_mem (S.mul_mem h21 ha) h12) | |
| have hN : E.relativeVonNeumann.toStarSubalgebra β€ Q := by | |
| rw [β hgen] | |
| exact wstar_le (wstar_closed _) (by | |
| rintro _ (rfl | rfl | rfl | rfl) | |
| Β· exact hcoeff aβ hcβ | |
| Β· exact hcoeff aβ hcβ | |
| Β· exact hcoeff aβ hcβ | |
| Β· exact hcoeff aβ hcβ) | |
| have hcorner (a : E.commutant) : corner a β S := by | |
| change f (corner a) β Q | |
| rw [E.coefficient_corner a] | |
| apply Q.mul_mem (hN β¨a,rflβ©) | |
| have hp := E.coefficient_corner (1 : E.commutant) | |
| have he : corner (1 : E.commutant)=E11 := rfl | |
| rw [he] at hp | |
| have hp' : f E11=(E.entry 0 0).val := by simpa using hp | |
| have hh : f E11 β Q := h11 | |
| rwa [hp'] at hh | |
| have htop : S=β€ := eq_top_of_corner_and_units S hcorner h12 h21 | |
| refine β¨A,hA,B,hB,hsa,hsb,le_antisymm ?_ ?_β© | |
| Β· exact wstar_le (Tracial.vonNeumann_wotClosed M) (by rintro _ (rfl | rfl) <;> assumption) | |
| Β· intro x hx | |
| obtain β¨a,haβ© := E.coefficientHom_surjective 0 β¨x,hxβ© | |
| have hm : a β S := by rw [htop]; trivial | |
| change (E.coefficientHom a).val β Q at hm | |
| rwa [ha] at hm | |
| end MatrixUnitSystem | |
| end Generator | |
| end | |
| end OAI | |