Download data/lean/OAI/Analysis/CharacterCriterion/DiagonalIteration.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 17.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CharacterCriterion/DiagonalIteration.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/CharacterCriterion/DiagonalIteration.lean
-
curl -L -o DiagonalIteration.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CharacterCriterion/DiagonalIteration.lean
17.1 kB
| import OAI.Analysis.CharacterCriterion.PrimeSquare | |
| namespace OAI | |
| noncomputable section | |
| open scoped TensorProduct | |
| open scoped InnerProductSpace | |
| open scoped BigOperators | |
| open Set Module | |
| open Topology | |
| open NormedSpace | |
| open scoped ComplexOrder | |
| open scoped ComplexOrder | |
| open scoped InnerProductSpace | |
| open scoped InnerProductSpace | |
| open NormedSpace | |
| open scoped TensorProduct InnerProductSpace | |
| open UniformSpace | |
| variable [KirchbergRordam.GenericRW.Size] | |
| local notation "rankNum" => KirchbergRordam.GenericRW.Size.n | |
| variable [KirchbergRordam.GenericRW.PauliData] | |
| omit [KirchbergRordam.GenericRW.Size] [KirchbergRordam.GenericRW.PauliData] | |
| open Filter Topology BoundedContinuousFunction | |
| open Filter Topology | |
| open Topology | |
| open scoped TensorProduct CStarAlgebra | |
| open scoped CStarAlgebra ComplexOrder | |
| open NormedSpace | |
| open scoped ComplexOrder | |
| open scoped ComplexOrder | |
| open scoped InnerProductSpace | |
| open scoped CStarAlgebra ComplexOrder | |
| namespace KirchbergRordam.DiagonalIteration | |
| open scoped CStarAlgebra ComplexOrder | |
| open Filter Topology | |
| variable {A B : Type*} [CStarAlgebra A] [CStarAlgebra B] | |
| abbrev conj (v : unitary A) := Unitary.conjStarAlgAut β A v | |
| lemma conj_mul (u v : unitary A) (a : A) : conj (u*v) a=conj u (conj v a) := by | |
| simp [conj,Unitary.conjStarAlgAut_apply,mul_assoc] | |
| lemma conj_one (a : A) : conj (1:unitary A) a=a := by simp [conj] | |
| lemma conj_star (u : unitary A) (a : A) : conj (star u) (conj u a)=a := by | |
| simp only [conj,Unitary.conjStarAlgAut_apply,Unitary.coe_star,star_star] | |
| rw [βmul_assoc,βmul_assoc,u.property.1,one_mul,mul_assoc,u.property.1,mul_one] | |
| lemma normalize_cancel (u v : unitary A) (a : A) : | |
| conj (star (u*star v)) (conj u a)=conj v a := by | |
| rw [star_mul,star_star,conj_mul,conj_star] | |
| def piUnitary {ΞΉ : Type*} (v : ΞΉ β unitary A) : unitary (ΞΉβA) := | |
| β¨fun i => v i,β¨by funext i; exact (v i).property.1,by funext i; exact (v i).property.2β©β© | |
| lemma piUnitary_continuous {X ΞΉ : Type*} [TopologicalSpace X] | |
| (v : X β ΞΉ β unitary A) (hv : β i, Continuous (fun x => v x i)) : | |
| Continuous (fun x => piUnitary (v x)) := by | |
| apply Continuous.subtype_mk | |
| exact continuous_pi (fun i => continuous_subtype_val.comp (hv i)) | |
| lemma mapUnitary_continuous (Ο : A βββ[β] B) : Continuous (Unitary.map (StarMonoidHom.ofClass Ο)) := | |
| ((map_continuous Ο).comp continuous_subtype_val).subtype_mk _ | |
| lemma map_pi_conj {ΞΉ : Type*} [Fintype ΞΉ] (Ο : (ΞΉβA) βββ[β] B) | |
| (v : ΞΉβunitary A) (a : ΞΉβA) : Ο (fun i => conj (v i) (a i)) = | |
| conj (Unitary.map (StarMonoidHom.ofClass Ο) (piUnitary v)) (Ο a) := by | |
| change Ο ((fun i => (v i:A))*a*star (fun i => (v i:A)))= | |
| Ο (fun i => (v i:A))*Ο a*star (Ο (fun i => (v i:A))) | |
| rw [map_mul,map_mul,map_star] | |
| structure System where | |
| obj : β β Type* | |
| [cstar : β n, CStarAlgebra (obj n)] | |
| slot : β β Type* | |
| [finite : β n, Fintype (slot n)] | |
| diagonal : β n, (slot n β obj n) βββ[β] obj (n+1) | |
| eigen : β n, slot n β C(unitInterval,unitInterval) | |
| twist : β n, C(unitInterval,unitary (obj (n+1))) | |
| attribute [instance] System.cstar System.finite | |
| namespace System | |
| variable (S : System) | |
| def flat (n : β) : (k : β) β (unitInterval β S.obj n) β unitInterval β S.obj (n+k) | |
| | 0, f, t => f t | |
| | k+1, f, t => S.diagonal (n+k) (fun i => flat n k f (S.eigen (n+k) i t)) | |
| def full (n : β) : (k : β) β (unitInterval β S.obj n) β unitInterval β S.obj (n+k) | |
| | 0, f, t => f t | |
| | k+1, f, t => conj (S.twist (n+k) t) | |
| (S.diagonal (n+k) (fun i => full n k f (S.eigen (n+k) i t))) | |
| def unitaryPath (n : β) : (k : β) β unitInterval β unitary (S.obj (n+k)) | |
| | 0, _ => 1 | |
| | k+1, t => S.twist (n+k) t * Unitary.map (StarMonoidHom.ofClass (S.diagonal (n+k))) | |
| (piUnitary (fun i => unitaryPath n k (S.eigen (n+k) i t))) | |
| lemma full_eq (n k : β) (f : unitInterval β S.obj n) (t : unitInterval) : | |
| S.full n k f t=conj (S.unitaryPath n k t) (S.flat n k f t) := by | |
| induction k generalizing t with | |
| | zero => exact (conj_one _).symm | |
| | succ k ih => | |
| simp only [full,flat,unitaryPath,ih,map_pi_conj,conj_mul] | |
| rfl | |
| lemma flat_continuous (n k : β) (f : unitInterval β S.obj n) (hf : Continuous f) : | |
| Continuous (S.flat n k f) := by | |
| induction k with | |
| | zero => exact hf | |
| | succ k ih => | |
| exact (map_continuous (S.diagonal (n+k))).comp | |
| (continuous_pi (fun i => ih.comp (S.eigen (n+k) i).continuous)) | |
| lemma unitaryPath_continuous (n k : β) : Continuous (S.unitaryPath n k) := by | |
| induction k with | |
| | zero => exact continuous_const | |
| | succ k ih => | |
| exact (S.twist (n+k)).continuous.mul ((mapUnitary_continuous _).comp | |
| (piUnitary_continuous _ (fun i => ih.comp (S.eigen (n+k) i).continuous))) | |
| lemma flat_bound (hlip : β n i, LipschitzWith (1/2) (S.eigen n i)) | |
| (n k : β) (f : unitInterval β S.obj n) (Ξ΅ r : β) (hΞ΅ : 0β€Ξ΅) | |
| (hf : β s t : unitInterval, dist s t β€ (1/2:β)^k*r β βf s-f tββ€Ξ΅) | |
| (s t : unitInterval) (hst : dist s tβ€r) : | |
| βS.flat n k f s-S.flat n k f tββ€Ξ΅ := by | |
| induction k generalizing r s t with | |
| | zero => exact hf s t (by simpa using hst) | |
| | succ k ih => | |
| rw [flat,flat,βmap_sub] | |
| apply (NonUnitalStarAlgHom.norm_apply_le (S.diagonal (n+k)) _).trans | |
| apply (pi_norm_le_iff_of_nonneg hΞ΅).mpr | |
| intro i | |
| apply ih (r/2) | |
| Β· intro x y hxy | |
| apply hf x y | |
| convert hxy using 1; ring | |
| Β· calc | |
| dist (S.eigen (n+k) i s) (S.eigen (n+k) i t) β€ | |
| (1/2:β)*dist s t := (hlip (n+k) i).dist_le_mul s t | |
| _ β€ r/2 := by linarith | |
| lemma flat_eventually_small (hlip : β n i, LipschitzWith (1/2) (S.eigen n i)) | |
| (n : β) (f : C(unitInterval,S.obj n)) (Ξ΅ : β) (hΞ΅ : 0<Ξ΅) : | |
| βαΆ k in atTop, β s t : unitInterval, βS.flat n k f s-S.flat n k f tββ€Ξ΅ := by | |
| obtain β¨Ξ΄,hΞ΄,hfβ© := Metric.uniformContinuous_iff.mp (CompactSpace.uniformContinuous_of_continuous f.continuous) Ξ΅ hΞ΅ | |
| have hp : Tendsto (fun k : β => (1/2:β)^k) atTop (π 0) := | |
| tendsto_pow_atTop_nhds_zero_of_lt_one (by norm_num) (by norm_num) | |
| filter_upwards [hp.eventually (gt_mem_nhds hΞ΄)] with k hk s t | |
| apply S.flat_bound hlip n k f Ξ΅ 1 hΞ΅.le | |
| Β· intro x y hxy | |
| apply le_of_lt | |
| rw [βdist_eq_norm] | |
| apply hf | |
| exact lt_of_le_of_lt (by simpa using hxy) hk | |
| Β· change |(s:β)-(t:β)|β€1 | |
| exact abs_le.mpr β¨by linarith [s.property.1,t.property.2],by linarith [s.property.2,t.property.1]β© | |
| end System | |
| end KirchbergRordam.DiagonalIteration | |
| namespace KirchbergRordam.BalancedDropIteration | |
| open scoped CStarAlgebra ComplexOrder | |
| open Filter Topology | |
| open BalancedDropMultiplicity BalancedDropSystem MatrixDiagonalPath DiagonalIteration | |
| abbrev diagonalSystem : DiagonalIteration.System where | |
| obj n := PrimeDimensionDrop.Fiber (stage n) (stage n+1) | |
| slot n := Slot (stage n) | |
| diagonal n := (CStarMatrix.reindexβ β β (zeroReindex (stage n) (stage_two n))).toStarAlgHom.comp block | |
| eigen n := eigenpath (stage n) | |
| twist n := (MatrixPermutationPath.path 1 | |
| ((zeroReindex (stage n) (stage_two n)).symm.trans (oneReindex (stage n) (stage_two n)))).toContinuousMap | |
| lemma eigen_lipschitz : β n i, LipschitzWith (1/2) (diagonalSystem.eigen n i) := by | |
| intro n i | |
| rcases i with i|i|i | |
| Β· apply LipschitzWith.of_dist_le_mul | |
| intro s t | |
| change |(s:β)/2-(t:β)/2|β€(1/2:β)*|(s:β)-(t:β)| | |
| rw [βsub_div,abs_div] | |
| norm_num | |
| linarith | |
| Β· apply LipschitzWith.of_dist_le_mul | |
| intro s t | |
| change |((s:β)+1)/2-((t:β)+1)/2|β€(1/2:β)*|(s:β)-(t:β)| | |
| rw [βsub_div,add_sub_add_right_eq_sub,abs_div] | |
| norm_num | |
| linarith | |
| Β· exact (LipschitzWith.const _).weaken (by norm_num) | |
| lemma iterate_full (n k : β) (f : BalancedDropLimit.Stage n) (t : unitInterval) : | |
| (BalancedDropLimit.chain.map n (n+k) (Nat.le_add_right n k) f).val t = | |
| diagonalSystem.full n k f.val t := by | |
| induction k generalizing t with | |
| | zero => simp only [Nat.add_zero,BalancedDropLimit.chain.map_self,DiagonalIteration.System.full]; rfl | |
| | succ k ih => | |
| erw [BalancedDropLimit.chain.map_succ n (n+k) (Nat.le_add_right n k)] | |
| change MatrixDiagonalPath.interpolate _ _ t | |
| (block (fun i => (BalancedDropLimit.chain.map n (n+k) _ f).val (eigenpath (stage (n+k)) i t))) = _ | |
| simp only [ih] | |
| rfl | |
| def normalizedPath (n k : β) (t : unitInterval) : | |
| unitary (PrimeDimensionDrop.Fiber (stage (n+k)) (stage (n+k)+1)) := | |
| diagonalSystem.unitaryPath n k t * star (diagonalSystem.unitaryPath n k 0) | |
| lemma normalizedPath_continuous (n k : β) : Continuous (normalizedPath n k) := | |
| (diagonalSystem.unitaryPath_continuous n k).mul continuous_const | |
| @[simp] lemma normalizedPath_zero (n k : β) : normalizedPath n k 0=1 := by | |
| exact mul_inv_cancel _ | |
| lemma untwist (n k : β) (f : BalancedDropLimit.Stage n) (t : unitInterval) : | |
| conj (star (normalizedPath n k t)) | |
| ((BalancedDropLimit.chain.map n (n+k) (Nat.le_add_right n k) f).val t) = | |
| conj (diagonalSystem.unitaryPath n k 0) (diagonalSystem.flat n k f.val t) := by | |
| rw [iterate_full,diagonalSystem.full_eq] | |
| exact DiagonalIteration.normalize_cancel _ _ _ | |
| lemma untwist_norm (n k : β) (f : BalancedDropLimit.Stage n) (t : unitInterval) : | |
| βconj (star (normalizedPath n k t)) | |
| ((BalancedDropLimit.chain.map n (n+k) (Nat.le_add_right n k) f).val t)- | |
| (BalancedDropLimit.chain.map n (n+k) (Nat.le_add_right n k) f).val 0β = | |
| βdiagonalSystem.flat n k f.val t-diagonalSystem.flat n k f.val 0β := by | |
| rw [untwist,iterate_full,diagonalSystem.full_eq] | |
| rw [βmap_sub,StarAlgEquiv.norm_map] | |
| lemma eventually_untwist_small (n : β) (f : BalancedDropLimit.Stage n) (Ξ΅ : β) (hΞ΅ : 0<Ξ΅) : | |
| βαΆ k in atTop, β t : unitInterval, | |
| βconj (star (normalizedPath n k t)) | |
| ((BalancedDropLimit.chain.map n (n+k) (Nat.le_add_right n k) f).val t)- | |
| (BalancedDropLimit.chain.map n (n+k) (Nat.le_add_right n k) f).val 0ββ€Ξ΅ := by | |
| filter_upwards [diagonalSystem.flat_eventually_small eigen_lipschitz n f.val Ξ΅ hΞ΅] with k hk t | |
| rw [untwist_norm] | |
| exact hk t 0 | |
| end KirchbergRordam.BalancedDropIteration | |
| namespace KirchbergRordam.FiniteHalfFlipSequence | |
| open scoped CStarAlgebra ComplexOrder | |
| open Filter Topology | |
| variable {A B : Type*} [CStarAlgebra A] [CStarAlgebra B] | |
| abbrev conj (u : unitary B) := Unitary.conjStarAlgAut β B u | |
| lemma perturbation (Ο Ο : A βββ[β] B) (u : unitary B) (x y : A) : | |
| βconj u (Ο x)-Ο xβ β€ 2*βx-yβ+βconj u (Ο y)-Ο yβ := by | |
| have he : conj u (Ο x)-Ο x = | |
| conj u (Ο (x-y))+(conj u (Ο y)-Ο y)-Ο (x-y) := by | |
| rw [map_sub,map_sub,map_sub] | |
| abel | |
| rw [he] | |
| have h1 : βconj u (Ο (x-y))ββ€βx-yβ := by | |
| rw [StarAlgEquiv.norm_map] | |
| exact NonUnitalStarAlgHom.norm_apply_le Ο _ | |
| have h2 : βΟ (x-y)ββ€βx-yβ := NonUnitalStarAlgHom.norm_apply_le Ο _ | |
| have h3 := norm_sub_le (conj u (Ο (x-y))+(conj u (Ο y)-Ο y)) (Ο (x-y)) | |
| have h4 := norm_add_le (conj u (Ο (x-y))) (conj u (Ο y)-Ο y) | |
| linarith | |
| theorem exists_sequence [TopologicalSpace.SeparableSpace A] | |
| (Ο Ο : A βββ[β] B) | |
| (h : β F : Finset A, β Ξ΅ : β, 0<Ξ΅ β β u : unitary B, | |
| β xβF, βconj u (Ο x)-Ο xββ€Ξ΅) : | |
| β u : β β unitary B, β x : A, | |
| Tendsto (fun n => conj (u n) (Ο x)) atTop (π (Ο x)) := by | |
| classical | |
| let a := TopologicalSpace.denseSeq A | |
| have he (n : β) : 0<(1:β)/((n:β)+1) := by positivity | |
| choose u hu using fun n : β => h ((Finset.range (n+1)).image a) (1/((n:β)+1)) (he n) | |
| refine β¨u,fun x => ?_β© | |
| apply Metric.tendsto_atTop.mpr | |
| intro Ξ΅ hΞ΅ | |
| obtain β¨i,hiβ© := (TopologicalSpace.denseRange_denseSeq A).exists_dist_lt x (by positivity : 0<Ξ΅/4) | |
| have hp : Tendsto (fun n : β => (1:β)/((n:β)+1)) atTop (π 0) := | |
| tendsto_one_div_add_atTop_nhds_zero_nat | |
| obtain β¨N,hNβ© := eventually_atTop.mp (hp.eventually (gt_mem_nhds (by positivity : 0<Ξ΅/2))) | |
| refine β¨max i N,fun n hn => ?_β© | |
| have hin : iβFinset.range (n+1) := Finset.mem_range.mpr (Nat.lt_succ_of_le ((le_max_left i N).trans hn)) | |
| have hb := hu n (a i) (Finset.mem_image_of_mem a hin) | |
| have hp' := perturbation Ο Ο (u n) x (a i) | |
| rw [dist_eq_norm] at hi β’ | |
| have hn' := hN n ((le_max_right i N).trans hn) | |
| have hx : βx-a iβ<Ξ΅/4 := by simpa only [a,norm_sub_rev] using hi | |
| linarith | |
| end KirchbergRordam.FiniteHalfFlipSequence | |
| namespace KirchbergRordam.CStarInductiveLimit | |
| lemma approximation_common_stage (S : System) (F : Finset (Algebra S)) (Ξ΅ : β) (hΞ΅ : 0<Ξ΅) : | |
| β n : β, β a : Algebra S β S.obj n, β xβF, βof S n (a x)-xβ<Ξ΅ := by | |
| classical | |
| choose v hv using fun x : Algebra S => (denseRange_of S).exists_dist_lt x hΞ΅ | |
| let n := F.sup (fun x => (v x).1) | |
| let a : Algebra S β S.obj n := fun x => if hx : xβF then | |
| S.map (v x).1 n (Finset.le_sup (f:=fun x => (v x).1) hx) (v x).2 else 0 | |
| refine β¨n,a,fun x hx => ?_β© | |
| dsimp only [a] | |
| rw [dite_eq_left hx,of_map] | |
| simpa only [dist_eq_norm,norm_sub_rev] using hv x | |
| end KirchbergRordam.CStarInductiveLimit | |
| namespace KirchbergRordam.BalancedDropHalfFlip | |
| open scoped CStarAlgebra ComplexOrder | |
| open Filter Topology | |
| open BalancedDropLimit BalancedDropIteration | |
| open UnitaryDisplacement | |
| universe u | |
| variable {A B : Type u} [CStarAlgebra A] [CStarAlgebra B] | |
| def squareMap (Ο : A βββ[β] B) : MaxTensor.Algebra A A βββ[β] MaxTensor.Algebra B B := | |
| MaxTensor.lift (MaxTensor.includeLeft.comp Ο) (MaxTensor.includeRight.comp Ο) | |
| (fun a b => MaxTensor.legs_commute (Ο a) (Ο b)) | |
| lemma squareMap_left (Ο : A βββ[β] B) (a : A) : | |
| squareMap Ο (MaxTensor.includeLeft a)=MaxTensor.includeLeft (Ο a) := by | |
| exact DFunLike.congr_fun (MaxTensor.lift_includeLeft _ _ _) a | |
| lemma squareMap_right (Ο : A βββ[β] B) (a : A) : | |
| squareMap Ο (MaxTensor.includeRight a)=MaxTensor.includeRight (Ο a) := by | |
| exact DFunLike.congr_fun (MaxTensor.lift_includeRight _ _ _) a | |
| lemma control_map (Ο : A βββ[β] B) (w : unitary (MaxTensor.Algebra A A)) (a : A) : | |
| βconj (Unitary.map (StarMonoidHom.ofClass (squareMap Ο)) w) | |
| (MaxTensor.includeLeft (Ο a))-MaxTensor.includeRight (Ο a)ββ€ | |
| βconj w (MaxTensor.includeLeft a)-MaxTensor.includeRight aβ := by | |
| rw [βsquareMap_left,βsquareMap_right,PrimeSquareUnitary.conj_map,βmap_sub] | |
| exact NonUnitalStarAlgHom.norm_apply_le (squareMap Ο) _ | |
| lemma finite_stage (n : β) (F : Finset (Stage n)) (Ξ΅ : β) (hΞ΅ : 0<Ξ΅) : | |
| β w : unitary (MaxTensor.Algebra Algebra Algebra), β fβF, | |
| βconj w (MaxTensor.includeLeft (inclusion n f))- | |
| MaxTensor.includeRight (inclusion n f)ββ€Ξ΅ := by | |
| have he : βαΆ k in atTop, β fβF, β t : unitInterval, | |
| βconj (star (normalizedPath n k t)) | |
| ((chain.map n (n+k) (Nat.le_add_right n k) f).val t)- | |
| (chain.map n (n+k) (Nat.le_add_right n k) f).val 0ββ€Ξ΅/4 := by | |
| apply (Filter.eventually_all_finset F).mpr | |
| intro f hf | |
| exact eventually_untwist_small n f (Ξ΅/4) (by positivity) | |
| obtain β¨k,hkβ© := he.exists | |
| obtain β¨w,hwβ© := PrimeSquareUnitary.exists_half_flip_control (normalizedPath n k) | |
| (normalizedPath_continuous n k) (normalizedPath_zero n k) | |
| refine β¨Unitary.map (StarMonoidHom.ofClass (squareMap (inclusion (n+k)))) w,fun f hf => ?_β© | |
| have hc := (control_map (inclusion (n+k)) w (chain.map n (n+k) (Nat.le_add_right n k) f)).trans | |
| (hw _ (Ξ΅/4) (hk f hf)) | |
| have hm : inclusion (n+k) (chain.map n (n+k) (Nat.le_add_right n k) f)=inclusion n f := | |
| CStarInductiveLimit.of_map system n (n+k) (Nat.le_add_right n k) f | |
| rw [hm] at hc | |
| have he : 4*(Ξ΅/4)=Ξ΅ := by ring | |
| rwa [he] at hc | |
| lemma common_stage (F : Finset Algebra) (Ξ΅ : β) (hΞ΅ : 0<Ξ΅) : | |
| β n : β, β a : Algebra β Stage n, β xβF, βinclusion n (a x)-xβ<Ξ΅ := | |
| CStarInductiveLimit.approximation_common_stage system F Ξ΅ hΞ΅ | |
| lemma finite_control (F : Finset Algebra) (Ξ΅ : β) (hΞ΅ : 0<Ξ΅) : | |
| β w : unitary (MaxTensor.Algebra Algebra Algebra), β xβF, | |
| βconj w (MaxTensor.includeLeft x)-MaxTensor.includeRight xββ€Ξ΅ := by | |
| classical | |
| obtain β¨n,a,haβ© := common_stage F (Ξ΅/4) (by positivity) | |
| obtain β¨w,hwβ© := finite_stage n (F.image a) (Ξ΅/2) (by positivity) | |
| refine β¨w,fun x hx => ?_β© | |
| have hb := hw (a x) (Finset.mem_image_of_mem a hx) | |
| have hc := FiniteHalfFlipSequence.perturbation MaxTensor.includeLeft MaxTensor.includeRight w x (inclusion n (a x)) | |
| have hd := ha x hx | |
| rw [norm_sub_rev] at hd | |
| change βconj w (MaxTensor.includeLeft x)-MaxTensor.includeRight xββ€ | |
| 2*βx-inclusion n (a x)β+βconj w (MaxTensor.includeLeft (inclusion n (a x)))-MaxTensor.includeRight (inclusion n (a x))β at hc | |
| linarith | |
| theorem exists_half_flip : β w : β β unitary (MaxTensor.Algebra Algebra Algebra), | |
| β x : Algebra, Tendsto (fun n => conj (w n) (MaxTensor.includeLeft x)) atTop | |
| (π (MaxTensor.includeRight x)) := | |
| FiniteHalfFlipSequence.exists_sequence MaxTensor.includeLeft MaxTensor.includeRight finite_control | |
| end KirchbergRordam.BalancedDropHalfFlip | |
| end | |
| end OAI | |