| import Mathlib |
| import OAI.Probability.BinarySweep.YoungTheory.CutColumns |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| section |
|
|
| open scoped BigOperators Classical TensorProduct |
|
|
| namespace BinaryCoordinateSweeps.Young |
| lemma tensor_map_injective_complex {V W X Y : Type*} |
| [AddCommMonoid V] [Module ℂ V] [AddCommMonoid W] [Module ℂ W] |
| [AddCommMonoid X] [Module ℂ X] [AddCommMonoid Y] [Module ℂ Y] |
| (f : V →ₗ[ℂ] X) (g : W →ₗ[ℂ] Y) |
| (hf : Function.Injective f) (hg : Function.Injective g) : |
| Function.Injective (TensorProduct.map f g) := by |
| let : AddCommGroup X := Module.addCommMonoidToAddCommGroup ℂ |
| let : AddCommGroup W := Module.addCommMonoidToAddCommGroup ℂ |
| exact TensorProduct.map_injective_of_flat_flat f g hf hg |
|
|
| variable (μ : YoungDiagram) (p : ℕ) |
|
|
| abbrev CutTensor := SpechtSpace (hookPart μ p) ⊗[ℂ] SpechtSpace (southeast μ p) |
| abbrev CutTabloids := Tabloid (hookPart μ p) × Tabloid (southeast μ p) |
|
|
| def cutTensorInclude : CutTensor μ p →ₗ[ℂ] (CutTabloids μ p → ℂ) := |
| TensorProduct.lift { |
| toFun := fun v => { |
| toFun := fun w t => spechtInclude (hookPart μ p) v t.1 * spechtInclude (southeast μ p) w t.2 |
| map_add' := by intro a b; ext t; simp only [map_add,Pi.add_apply,mul_add] |
| map_smul' := by intro c a; ext t; simp only [map_smul,Pi.smul_apply,smul_eq_mul,RingHom.id_apply]; ring } |
| map_add' := by intro a b; ext w t; simp only [map_add,Pi.add_apply,add_mul,LinearMap.add_apply,LinearMap.coe_mk,AddHom.coe_mk] |
| map_smul' := by intro c a; ext w t; simp only [map_smul,Pi.smul_apply,smul_eq_mul,LinearMap.smul_apply,LinearMap.coe_mk,AddHom.coe_mk,RingHom.id_apply]; ring } |
|
|
| @[simp] lemma cutTensorInclude_tmul (v : SpechtSpace (hookPart μ p)) |
| (w : SpechtSpace (southeast μ p)) (t : CutTabloids μ p) : |
| cutTensorInclude μ p (v ⊗ₜ[ℂ] w) t = |
| spechtInclude (hookPart μ p) v t.1 * spechtInclude (southeast μ p) w t.2 := rfl |
|
|
| lemma cutTensorInclude_injective : Function.Injective (cutTensorInclude μ p) := by |
| let T := TensorProduct.map (spechtInclude (hookPart μ p)) (spechtInclude (southeast μ p)) |
| have hT : Function.Injective T := tensor_map_injective_complex |
| (spechtInclude (hookPart μ p)) (spechtInclude (southeast μ p)) |
| (spechtInclude_injective (hookPart μ p)) (spechtInclude_injective (southeast μ p)) |
| let E := TensorProduct.piScalarRight ℂ ℂ (Tabloid (hookPart μ p) → ℂ) (Tabloid (southeast μ p)) |
| have hE (u : CutTensor μ p) (t : CutTabloids μ p) : |
| E (T u) t.2 t.1 = cutTensorInclude μ p u t := by |
| induction u using TensorProduct.inductionOn with |
| | tmul v w => |
| change E (spechtInclude _ v ⊗ₜ[ℂ] spechtInclude _ w) t.2 t.1 = _ |
| simp only [cutTensorInclude_tmul,E,TensorProduct.piScalarRight_apply, |
| TensorProduct.piScalarRightHom_tmul,Pi.smul_apply,smul_eq_mul] |
| exact mul_comm _ _ |
| | add u v hu hv => simp only [map_add,Pi.add_apply,hu,hv] |
| intro u v h |
| apply hT |
| apply E.injective |
| ext s t |
| exact (hE u (t,s)).trans ((congrFun h (t,s)).trans (hE v (t,s)).symm) |
|
|
| def cutRestriction : SpechtSpace μ →ₗ[ℂ] (CutTabloids μ p → ℂ) where |
| toFun v t := spechtInclude μ v (glueTabloid μ p t) |
| map_add' a b := by ext t; simp |
| map_smul' c a := by ext t; simp |
|
|
| lemma cutRestriction_poly : |
| cutRestriction μ p (spechtPoly μ) = |
| cutTensorInclude μ p (spechtPoly (hookPart μ p) ⊗ₜ[ℂ] spechtPoly (southeast μ p)) := by |
| ext t |
| change spechtInclude μ (spechtPoly μ) (glueTabloid μ p t) = _ |
| simp only [spechtInclude_poly,polytabloid_glue,cutTensorInclude_tmul] |
|
|
| lemma cutRestriction_translate (g : G (hookPart μ p) × G (southeast μ p)) : |
| cutRestriction μ p (spechtRep μ (cutPerm μ p g) (spechtPoly μ)) = |
| cutTensorInclude μ p |
| (spechtRep (hookPart μ p) g.1 (spechtPoly (hookPart μ p)) ⊗ₜ[ℂ] |
| spechtRep (southeast μ p) g.2 (spechtPoly (southeast μ p))) := by |
| ext t |
| change spechtInclude μ (spechtRep μ (cutPerm μ p g) (spechtPoly μ)) |
| (glueTabloid μ p t) = _ |
| rw [spechtInclude_rep,tabloidRepresentation_apply,← map_inv,← glueTabloid_smul, |
| spechtInclude_poly,polytabloid_glue,cutTensorInclude_tmul, |
| spechtInclude_rep,spechtInclude_rep] |
| rfl |
|
|
| lemma cut_tensor_orbit_mem_range (g : G (hookPart μ p)) (d : G (southeast μ p)) : |
| cutTensorInclude μ p (spechtRep (hookPart μ p) g (spechtPoly (hookPart μ p)) ⊗ₜ[ℂ] |
| spechtRep (southeast μ p) d (spechtPoly (southeast μ p))) ∈ |
| LinearMap.range (cutRestriction μ p) := |
| ⟨spechtRep μ (cutPerm μ p (g,d)) (spechtPoly μ),cutRestriction_translate μ p (g,d)⟩ |
|
|
| private lemma spechtPoly_span_top (ν : YoungDiagram) : |
| Submodule.span ℂ (Set.range (fun g : G ν => spechtRep ν g (spechtPoly ν))) = ⊤ := |
| Irrep.span_orbit_eq_top (spechtRep ν) (spechtPoly ν) (spechtPoly_ne_zero ν) |
|
|
| lemma cut_tensor_tmul_mem_range (v : SpechtSpace (hookPart μ p)) |
| (w : SpechtSpace (southeast μ p)) : |
| cutTensorInclude μ p (v ⊗ₜ[ℂ] w) ∈ LinearMap.range (cutRestriction μ p) := by |
| have hv : v ∈ Submodule.span ℂ (Set.range (fun g : G (hookPart μ p) => |
| spechtRep (hookPart μ p) g (spechtPoly (hookPart μ p)))) := by |
| rw [spechtPoly_span_top] |
| trivial |
| induction hv using Submodule.span_induction with |
| | mem x hx => |
| obtain ⟨g,rfl⟩ := hx |
| have hw : w ∈ Submodule.span ℂ (Set.range (fun d : G (southeast μ p) => |
| spechtRep (southeast μ p) d (spechtPoly (southeast μ p)))) := by |
| rw [spechtPoly_span_top] |
| trivial |
| induction hw using Submodule.span_induction with |
| | mem y hy => obtain ⟨d,rfl⟩ := hy; exact cut_tensor_orbit_mem_range μ p g d |
| | zero => simp |
| | add x y hx hy hx' hy' => simpa only [TensorProduct.tmul_add,map_add] using Submodule.add_mem _ hx' hy' |
| | smul c x hx hx' => simpa only [TensorProduct.tmul_smul,map_smul] using Submodule.smul_mem _ c hx' |
| | zero => simp |
| | add x y hx hy hx' hy' => simpa only [TensorProduct.add_tmul,map_add] using Submodule.add_mem _ hx' hy' |
| | smul c x hx hx' => simpa only [← TensorProduct.smul_tmul',map_smul] using Submodule.smul_mem _ c hx' |
|
|
| theorem cutTensor_range_le : LinearMap.range (cutTensorInclude μ p) ≤ |
| LinearMap.range (cutRestriction μ p) := by |
| rintro _ ⟨u,rfl⟩ |
| induction u using TensorProduct.inductionOn with |
| | tmul v w => exact cut_tensor_tmul_mem_range μ p v w |
| | add u v hu hv => simpa only [map_add] using Submodule.add_mem _ hu hv |
|
|
| end BinaryCoordinateSweeps.Young |
|
|
| end |
|
|
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps.Irrep |
| open Representation |
|
|
| variable {G V W P : Type*} [Group G] [Fintype G] |
| [AddCommMonoid V] [Module ℂ V] [AddCommMonoid W] [Module ℂ W] |
| [AddCommMonoid P] [Module ℂ P] |
| (ρ : Representation ℂ G V) (σ : Representation ℂ G W) (τ : Representation ℂ G P) |
|
|
| def averageLinear (l : P →ₗ[ℂ] V) : P →ₗ[ℂ] V := |
| (Fintype.card G : ℂ)⁻¹ • ∑ g : G, (ρ g⁻¹).comp (l.comp (τ g)) |
|
|
| lemma averageLinear_apply (l : P →ₗ[ℂ] V) (v : P) : |
| averageLinear ρ τ l v = (Fintype.card G : ℂ)⁻¹ • ∑ g : G, ρ g⁻¹ (l (τ g v)) := by |
| simp only [averageLinear,LinearMap.smul_apply,LinearMap.sum_apply,LinearMap.comp_apply] |
|
|
| lemma averageLinear_intertwines (l : P →ₗ[ℂ] V) (a : G) (v : P) : |
| averageLinear ρ τ l (τ a v) = ρ a (averageLinear ρ τ l v) := by |
| simp only [averageLinear_apply,map_smul,map_sum,← Module.End.mul_apply,← map_mul] |
| congr 1 |
| have hh := Equiv.sum_comp (Equiv.mulRight a) (fun g : G => |
| ρ (a*g⁻¹) (l (τ g v))) |
| rw [← hh] |
| apply Finset.sum_congr rfl |
| intro g _ |
| simp only [Equiv.coe_mulRight,mul_inv_rev,mul_inv_cancel_left] |
|
|
| def averagedIntertwiner (l : P →ₗ[ℂ] V) : IntertwiningMap τ ρ where |
| toLinearMap := averageLinear ρ τ l |
| isIntertwining' a := LinearMap.ext (averageLinear_intertwines ρ τ l a) |
|
|
| lemma averageLinear_lift (l : P →ₗ[ℂ] V) (f : IntertwiningMap ρ σ) |
| (g : IntertwiningMap τ σ) (hl : ∀ v, f (l v) = g v) (v : P) : |
| f (averageLinear ρ τ l v) = g v := by |
| rw [averageLinear_apply,map_smul,map_sum] |
| simp only [hl,IntertwiningMap.isIntertwining, |
| ← Module.End.mul_apply,← map_mul,inv_mul_cancel,map_one,Module.End.one_apply] |
| rw [Finset.sum_const,Finset.card_univ,← Nat.cast_smul_eq_nsmul ℂ,smul_smul, |
| inv_mul_cancel₀ (show (Fintype.card G : ℂ) ≠ 0 from Nat.cast_ne_zero.mpr Fintype.card_ne_zero),one_smul] |
|
|
| theorem lift_intertwiner (f : IntertwiningMap ρ σ) (g : IntertwiningMap τ σ) |
| (h : LinearMap.range g.toLinearMap ≤ LinearMap.range f.toLinearMap) : |
| ∃ l : IntertwiningMap τ ρ, ∀ v, f (l v) = g v := by |
| let : AddCommGroup V := Module.addCommMonoidToAddCommGroup ℂ |
| let : AddCommGroup W := Module.addCommMonoidToAddCommGroup ℂ |
| let : AddCommGroup P := Module.addCommMonoidToAddCommGroup ℂ |
| let f0 := f.toLinearMap.rangeRestrict |
| obtain ⟨r,hr⟩ := f0.exists_rightInverse_of_surjective f.toLinearMap.range_rangeRestrict |
| let g0 : P →ₗ[ℂ] LinearMap.range f.toLinearMap := |
| g.toLinearMap.codRestrict _ (fun v => h ⟨v,rfl⟩) |
| let l := r.comp g0 |
| have hl (v : P) : f (l v) = g v := by |
| have hh := DFunLike.congr_fun hr (g0 v) |
| exact congrArg Subtype.val hh |
| exact ⟨averagedIntertwiner ρ τ l,averageLinear_lift ρ σ τ l f g hl⟩ |
|
|
| end BinaryCoordinateSweeps.Irrep |
|
|
| end |
|
|
| end OAI |
|
|
