Download data/lean/OAI/RepresentationTheory/RowColumn/CopyOverlap.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 12.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/RowColumn/CopyOverlap.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/RepresentationTheory/RowColumn/CopyOverlap.lean
-
curl -L -o CopyOverlap.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/RowColumn/CopyOverlap.lean
12.6 kB
| import OAI.RepresentationTheory.RowColumn.Multiplicity | |
| import OAI.LinearAlgebra.MatrixState.HilbertSchmidt | |
| namespace OAI | |
| section | |
| noncomputable section | |
| namespace RowColumn | |
| open scoped BigOperators ComplexConjugate Classical | |
| section HilbertSchmidt | |
| variable {V W : Type*} | |
| [NormedAddCommGroup V] [InnerProductSpace β V] [FiniteDimensional β V] | |
| [NormedAddCommGroup W] [InnerProductSpace β W] [FiniteDimensional β W] | |
| /-- Ordinary squared Hilbert--Schmidt norm on a possibly rectangular map. -/ | |
| def hilbertSchmidtSq (B : V βL[β] W) : β := | |
| (LinearMap.trace β V (B.adjoint.comp B).toLinearMap).re | |
| lemma hilbertSchmidtSq_eq_sum (B : V βL[β] W) | |
| {ΞΉ : Type*} [Fintype ΞΉ] (b : OrthonormalBasis ΞΉ β V) : | |
| hilbertSchmidtSq B = β i, βB (b i)β ^ 2 := by | |
| rw [hilbertSchmidtSq, LinearMap.trace_eq_sum_inner _ b, Complex.re_sum] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| simpa using (B.apply_norm_sq_eq_inner_adjoint_right (b i)).symm | |
| lemma norm_sq_le_hilbertSchmidtSq (B : V βL[β] W) : | |
| βBβ ^ 2 β€ hilbertSchmidtSq B := by | |
| let b := stdOrthonormalBasis β V | |
| have hn : 0 β€ hilbertSchmidtSq B := by | |
| rw [hilbertSchmidtSq_eq_sum B b] | |
| exact Finset.sum_nonneg (fun _ _ => sq_nonneg _) | |
| have hh : βBβ β€ Real.sqrt (hilbertSchmidtSq B) := by | |
| apply B.opNorm_le_bound (Real.sqrt_nonneg _) | |
| intro x | |
| have ha : βB xβ β€ β i, βinner β (b i) xβ * βB (b i)β := by | |
| nth_rw 1 [β b.sum_repr' x] | |
| rw [map_sum] | |
| apply (norm_sum_le _ _).trans | |
| simp only [map_smul, norm_smul] | |
| exact le_rfl | |
| have hb := Real.sum_mul_le_sqrt_mul_sqrt Finset.univ | |
| (fun i => βinner β (b i) xβ) (fun i => βB (b i)β) | |
| rw [b.sum_sq_norm_inner_right, Real.sqrt_sq (norm_nonneg x), | |
| β hilbertSchmidtSq_eq_sum B b, mul_comm] at hb | |
| exact ha.trans hb | |
| exact (pow_le_pow_leftβ (norm_nonneg _) hh 2).trans_eq (Real.sq_sqrt hn) | |
| end HilbertSchmidt | |
| section CopyTrace | |
| variable {V W X : Type*} | |
| [NormedAddCommGroup V] [InnerProductSpace β V] [FiniteDimensional β V] | |
| [NormedAddCommGroup W] [InnerProductSpace β W] [FiniteDimensional β W] | |
| [NormedAddCommGroup X] [InnerProductSpace β X] [FiniteDimensional β X] | |
| {u v : β} | |
| /-- Sum of the genuine range projections for the given isometric copies. -/ | |
| def copyProjection (I : Fin u β V ββα΅’[β] X) : X βL[β] X := | |
| β i, (I i).toContinuousLinearMap.comp (I i).toContinuousLinearMap.adjoint | |
| lemma hilbertSchmidtSq_overlap (I : V ββα΅’[β] X) (J : W ββα΅’[β] X) : | |
| hilbertSchmidtSq (I.toContinuousLinearMap.adjoint.comp J.toContinuousLinearMap) = | |
| (LinearMap.trace β X | |
| ((I.toContinuousLinearMap.comp I.toContinuousLinearMap.adjoint).comp | |
| (J.toContinuousLinearMap.comp J.toContinuousLinearMap.adjoint)).toLinearMap).re := by | |
| unfold hilbertSchmidtSq | |
| simp only [ContinuousLinearMap.adjoint_comp, ContinuousLinearMap.adjoint_adjoint, | |
| ContinuousLinearMap.toLinearMap_comp] | |
| congr 1 | |
| rw [LinearMap.comp_assoc, LinearMap.comp_assoc] | |
| rw [LinearMap.trace_comp_comm'] | |
| simp only [LinearMap.comp_assoc] | |
| /-- The all-copy identity in weighted.tex:126β133, for the actual embeddings. | |
| No overlap bound is an assumption. -/ | |
| lemma allCopy_hilbertSchmidt_identity (I : Fin u β V ββα΅’[β] X) | |
| (J : Fin v β W ββα΅’[β] X) : | |
| β i, β j, hilbertSchmidtSq | |
| ((I i).toContinuousLinearMap.adjoint.comp (J j).toContinuousLinearMap) = | |
| (LinearMap.trace β X ((copyProjection I).comp (copyProjection J)).toLinearMap).re := by | |
| change _ = (LinearMap.trace β X | |
| ((β i, (I i).toContinuousLinearMap.comp (I i).toContinuousLinearMap.adjoint) * | |
| (β j, (J j).toContinuousLinearMap.comp (J j).toContinuousLinearMap.adjoint)).toLinearMap).re | |
| simp only [Finset.sum_mul, Finset.mul_sum, ContinuousLinearMap.toLinearMap_sum, | |
| map_sum, Complex.re_sum] | |
| rw [Finset.sum_comm] | |
| apply Finset.sum_congr rfl | |
| intro j _ | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| exact hilbertSchmidtSq_overlap (I i) (J j) | |
| lemma allCopyOverlap_le_trace (I : Fin u β V ββα΅’[β] X) | |
| (J : Fin v β W ββα΅’[β] X) : | |
| allCopyOverlap I J β€ | |
| (LinearMap.trace β X ((copyProjection I).comp (copyProjection J)).toLinearMap).re := by | |
| rw [β allCopy_hilbertSchmidt_identity I J] | |
| apply Finset.sum_le_sum | |
| intro i _ | |
| apply Finset.sum_le_sum | |
| intro j _ | |
| exact norm_sq_le_hilbertSchmidtSq _ | |
| end CopyTrace | |
| end RowColumn | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open scoped BigOperators Classical ComplexOrder | |
| namespace RowColumn | |
| open CubeShuffle.UnitaryFinite | |
| variable {V W X E G : Type*} | |
| [NormedAddCommGroup V] [InnerProductSpace β V] [FiniteDimensional β V] | |
| [NormedAddCommGroup W] [InnerProductSpace β W] [FiniteDimensional β W] | |
| [NormedAddCommGroup X] [InnerProductSpace β X] [FiniteDimensional β X] | |
| [NormedAddCommGroup E] [InnerProductSpace β E] [FiniteDimensional β E] | |
| {u v : β} | |
| lemma isometry_adjoint_apply (I : V ββα΅’[β] X) (x : V) : | |
| I.toContinuousLinearMap.adjoint (I x) = x := by | |
| apply ext_inner_left β | |
| intro y | |
| rw [ContinuousLinearMap.adjoint_inner_right] | |
| exact I.inner_map_map y x | |
| lemma isometry_adjoint_comp (I : V ββα΅’[β] X) : | |
| I.toContinuousLinearMap.adjoint.comp I.toContinuousLinearMap = 1 := by | |
| ext x | |
| exact isometry_adjoint_apply I x | |
| lemma copyProjection_positive (I : Fin u β V ββα΅’[β] X) : | |
| (copyProjection I).IsPositive := by | |
| apply ContinuousLinearMap.isPositive_sum | |
| intro i _ | |
| exact ContinuousLinearMap.isPositive_self_comp_adjoint _ | |
| lemma copyProjection_trace (I : Fin u β V ββα΅’[β] X) : | |
| LinearMap.trace β X (copyProjection I).toLinearMap = (u * Module.finrank β V : β) := by | |
| simp only [copyProjection, ContinuousLinearMap.toLinearMap_sum, map_sum, | |
| ContinuousLinearMap.toLinearMap_comp] | |
| have h (i : Fin u) : LinearMap.trace β X | |
| ((I i).toContinuousLinearMap.toLinearMap.comp (I i).toContinuousLinearMap.adjoint.toLinearMap) = | |
| (Module.finrank β V : β) := by | |
| rw [LinearMap.trace_comp_comm'] | |
| change LinearMap.trace β V ((I i).toContinuousLinearMap.adjoint.comp | |
| (I i).toContinuousLinearMap).toLinearMap = _ | |
| rw [isometry_adjoint_comp] | |
| exact LinearMap.trace_id β V | |
| simp_rw [h] | |
| simp [Nat.cast_mul] | |
| lemma copyProjection_intertwines [Group G] (Ο : Representation β G V) (Ο : Representation β G X) | |
| (hΟ : IsUnitary Ο) (hΟ : IsUnitary Ο) (I : Fin u β V ββα΅’[β] X) | |
| (hI : β i, Intertwines Ο Ο (I i).toLinearMap) : | |
| Intertwines Ο Ο (copyProjection I).toLinearMap := by | |
| intro g x | |
| simp only [copyProjection, ContinuousLinearMap.coe_coe, sum_apply, ContinuousLinearMap.comp_apply, map_sum] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [show (I i).toContinuousLinearMap.adjoint (Ο g x) = | |
| Ο g ((I i).toContinuousLinearMap.adjoint x) from | |
| adjoint_intertwines (I i).toLinearMap (hI i) hΟ hΟ g x] | |
| exact hI i g _ | |
| lemma allCopyOverlap_comp_isometry (I : Fin u β V ββα΅’[β] X) | |
| (J : Fin v β W ββα΅’[β] X) (K : X ββα΅’[β] E) : | |
| allCopyOverlap (fun i => K.comp (I i)) (fun j => K.comp (J j)) = allCopyOverlap I J := by | |
| unfold allCopyOverlap | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| apply Finset.sum_congr rfl | |
| intro j _ | |
| apply congrArg (fun T : W βL[β] V => βTβ^2) | |
| ext x | |
| change (K.toContinuousLinearMap.comp (I i).toContinuousLinearMap).adjoint | |
| (K (J j x)) = _ | |
| rw [ContinuousLinearMap.adjoint_comp] | |
| change (I i).toContinuousLinearMap.adjoint (K.toContinuousLinearMap.adjoint (K (J j x))) = _ | |
| rw [isometry_adjoint_apply] | |
| rfl | |
| lemma allCopyOverlap_le_count (I : Fin u β V ββα΅’[β] X) | |
| (J : Fin v β W ββα΅’[β] X) : allCopyOverlap I J β€ (u : β) * v := by | |
| unfold allCopyOverlap | |
| have h (i : Fin u) (j : Fin v) : | |
| β(I i).toContinuousLinearMap.adjoint.comp (J j).toContinuousLinearMapβ^2 β€ 1 := by | |
| have hn := ContinuousLinearMap.opNorm_comp_le (I i).toContinuousLinearMap.adjoint | |
| (J j).toContinuousLinearMap | |
| rw [ContinuousLinearMap.adjoint.norm_map] at hn | |
| have hb := mul_le_mul (I i).norm_toContinuousLinearMap_le (J j).norm_toContinuousLinearMap_le | |
| (norm_nonneg _) (by norm_num : (0:β) β€ 1) | |
| have hz : β(I i).toContinuousLinearMap.adjoint.comp (J j).toContinuousLinearMapβ β€ 1 := | |
| hn.trans (by simpa using hb) | |
| nlinarith [norm_nonneg ((I i).toContinuousLinearMap.adjoint.comp (J j).toContinuousLinearMap)] | |
| calc | |
| _ β€ β _i : Fin u, β _j : Fin v, (1 : β) := | |
| Finset.sum_le_sum fun i _ => Finset.sum_le_sum fun j _ => h i j | |
| _ = _ := by simp | |
| end RowColumn | |
| end | |
| end | |
| section | |
| noncomputable section | |
| open scoped BigOperators Classical | |
| namespace RowColumn | |
| open CubeShuffle.UnitaryFinite | |
| variable {G V E : Type*} [Group G] | |
| [NormedAddCommGroup V] [InnerProductSpace β V] [FiniteDimensional β V] | |
| [NormedAddCommGroup E] [InnerProductSpace β E] [FiniteDimensional β E] | |
| (Ο : Representation β G V) (Ο : Representation β G E) | |
| (hΟ : IsUnitary Ο) (hΟ : IsUnitary Ο) | |
| include hΟ hΟ | |
| lemma isometric_adjoint_intertwines (f : Representation.IntertwiningMap Ο Ο) (g : G) (x : E) : | |
| LinearMap.adjoint f.toLinearMap (Ο g x) = Ο g (LinearMap.adjoint f.toLinearMap x) := by | |
| have hf : Intertwines Ο Ο f.toLinearMap := by | |
| intro g y | |
| exact Representation.IntertwiningMap.isIntertwining Ο Ο f g y | |
| have hh := adjoint_intertwines f.toLinearMap hf hΟ hΟ g x | |
| simpa only [LinearMap.adjoint_eq_toCLM_adjoint] using hh | |
| def gramIntertwiner (f : Representation.IntertwiningMap Ο Ο) : Representation.IntertwiningMap Ο Ο where | |
| toLinearMap := (LinearMap.adjoint f.toLinearMap).comp f.toLinearMap | |
| isIntertwining' g := by | |
| ext x | |
| change (LinearMap.adjoint f.toLinearMap) (f (Ο g x)) = | |
| Ο g ((LinearMap.adjoint f.toLinearMap) (f x)) | |
| rw [Representation.IntertwiningMap.isIntertwining] | |
| exact isometric_adjoint_intertwines Ο Ο hΟ hΟ f g (f x) | |
| /-- Every actual nonzero algebraic embedding of irreducible unitary carriers | |
| normalizes to an isometric intertwiner. No normalized embedding is assumed. -/ | |
| theorem isometric_intertwiner_of_injective [Representation.IsIrreducible Ο] | |
| (f : Representation.IntertwiningMap Ο Ο) (hf : Function.Injective f) : | |
| β I : V ββα΅’[β] E, β g x, I (Ο g x)=Ο g (I x) := by | |
| let : Nontrivial V := by | |
| let := IsSimpleModule.nontrivial (MonoidAlgebra β G) Ο.asModule | |
| exact Ο.asModuleEquiv.symm.toEquiv.nontrivial | |
| obtain β¨c,hcβ© := | |
| (Representation.IsIrreducible.algebraMap_intertwiningMap_bijective_of_isAlgClosed (Ο := Ο)).surjective | |
| (gramIntertwiner Ο Ο hΟ hΟ f) | |
| have hgram : (LinearMap.adjoint f.toLinearMap).comp f.toLinearMap = c β’ LinearMap.id := by | |
| change (gramIntertwiner Ο Ο hΟ hΟ f).toLinearMap = _ | |
| rw [β hc] | |
| rfl | |
| have hn (x : V) : βf xβ^2 = c.re * βxβ^2 := by | |
| have hh := congrArg (fun T : V ββ[β] V => inner β x (T x)) hgram | |
| simp only [LinearMap.comp_apply, LinearMap.adjoint_inner_right, LinearMap.smul_apply, | |
| LinearMap.id_apply, inner_smul_right, inner_self_eq_norm_sq_to_K] at hh | |
| change βf.toLinearMap xβ^2 = c.re * βxβ^2 | |
| have he := congrArg Complex.re hh | |
| simpa only [RCLike.ofReal_eq_complex_ofReal, β Complex.ofReal_pow, Complex.mul_re, | |
| Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero, mul_zero] using he | |
| obtain β¨x,hxβ© := exists_ne (0 : V) | |
| have hfx : f x β 0 := by intro h; exact hx (hf (h.trans (map_zero f).symm)) | |
| have hcpos : 0 < c.re := by | |
| have hh := hn x | |
| have hp : 0 < βf xβ^2 := sq_pos_of_ne_zero ((norm_ne_zero_iff).mpr hfx) | |
| have hxnon : 0 β€ βxβ^2 := sq_nonneg _ | |
| nlinarith | |
| let a : β := (Real.sqrt c.re)β»ΒΉ | |
| let F : V ββ[β] E := a β’ f.toLinearMap | |
| have ha : βaβ^2 * c.re = 1 := by | |
| simp only [a, norm_inv, Complex.norm_real, Real.norm_eq_abs, | |
| abs_of_nonneg (Real.sqrt_nonneg _)] | |
| rw [inv_pow, Real.sq_sqrt hcpos.le, inv_mul_cancelβ (ne_of_gt hcpos)] | |
| have hnorm (y : V) : βF yβ = βyβ := by | |
| change βa β’ f yβ=βyβ | |
| rw [norm_smul] | |
| have hh : (βaβ*βf yβ)^2=βyβ^2 := by rw [mul_pow, hn, β mul_assoc, ha, one_mul] | |
| exact (sq_eq_sqβ (mul_nonneg (norm_nonneg a) (norm_nonneg (f y))) (norm_nonneg y)).mp hh | |
| let I : V ββα΅’[β] E := { F with norm_map' := hnorm } | |
| refine β¨I,?_β© | |
| intro g y | |
| change a β’ f (Ο g y)=Ο g (a β’ f y) | |
| rw [Representation.IntertwiningMap.isIntertwining, map_smul] | |
| end RowColumn | |
| end | |
| end | |
| end OAI | |