openAI-math-dataset / lean /OAI /RepresentationTheory /UniversalSquare /Support /SquareSemigroup.lean
| import Mathlib | |
| import OAI.RepresentationTheory.Saxl.Main | |
| import OAI.RepresentationTheory.UniversalSquare.Support.KroneckerSemigroup | |
| namespace OAI | |
| /-! Square Semigroup. -/ | |
| section | |
| noncomputable section | |
| open scoped TensorProduct | |
| namespace UniversalTensorSquare | |
| open Saxl Columns | |
| def signTensorCancel {n : ℕ} {X Y : Type*} | |
| [AddCommGroup X] [Module ℂ X] [AddCommGroup Y] [Module ℂ Y] | |
| (ρ : Representation ℂ (Equiv.Perm (Fin n)) X) | |
| (σ : Representation ℂ (Equiv.Perm (Fin n)) Y) : | |
| ((signTwist ρ).tprod (signTwist σ)).Equiv (ρ.tprod σ) where | |
| toLinearEquiv := LinearEquiv.refl ℂ _ | |
| isIntertwining' g := by | |
| ext x y | |
| change (signC g • ρ g x) ⊗ₜ[ℂ] (signC g • σ g y) = ρ g x ⊗ₜ[ℂ] σ g y | |
| rw [TensorProduct.smul_tmul_smul,signC_mul_self,one_smul] | |
| def tensorRepEquiv {G X Y Z W : Type*} [Group G] | |
| [AddCommGroup X] [Module ℂ X] [AddCommGroup Y] [Module ℂ Y] | |
| [AddCommGroup Z] [Module ℂ Z] [AddCommGroup W] [Module ℂ W] | |
| {ρ : Representation ℂ G X} {σ : Representation ℂ G Y} | |
| {τ : Representation ℂ G Z} {υ : Representation ℂ G W} | |
| (e : ρ.Equiv σ) (f : τ.Equiv υ) : (ρ.tprod τ).Equiv (σ.tprod υ) where | |
| toLinearEquiv := TensorProduct.congr e.toLinearEquiv f.toLinearEquiv | |
| isIntertwining' := (e.toIntertwiningMap.tensor f.toIntertwiningMap).isIntertwining' | |
| lemma kronecker_pos_of_shapes {n : ℕ} {α β μ A B T : YoungDiagram} | |
| (ha : α = A) (hb : β = B) (ht : μ = T) | |
| (a : Tableau n α) (b : Tableau n β) (t : Tableau n μ) | |
| (c : Tableau n A) (d : Tableau n B) (u : Tableau n T) | |
| (h : 0 < kronecker a b t) : 0 < kronecker c d u := by | |
| let : AddCommGroup (Specht a ⊗[ℂ] Specht b) := Module.addCommMonoidToAddCommGroup ℂ | |
| let : AddCommGroup (Specht c ⊗[ℂ] Specht d) := Module.addCommMonoidToAddCommGroup ℂ | |
| obtain ⟨F,hF⟩ := (kronecker_pos_iff a b t).mp h | |
| let e := tensorRepEquiv (spechtShapeEquiv ha a c) (spechtShapeEquiv hb b d) | |
| let f := spechtShapeEquiv ht.symm u t | |
| apply (kronecker_pos_iff c d u).mpr | |
| refine ⟨e.toIntertwiningMap.comp (F.comp f.toIntertwiningMap),?_⟩ | |
| intro hz | |
| apply hF | |
| ext x | |
| apply e.injective | |
| have hh := congrArg (fun H => H (f.symm x)) hz | |
| change e (F (f (f.symm x))) = 0 at hh | |
| change e (F x) = e (0 : Specht a ⊗[ℂ] Specht b) | |
| have hx : e (F x) = 0 := by simpa only [f.apply_symm_apply] using hh | |
| exact hx.trans e.toIntertwiningMap.toLinearMap.map_zero.symm | |
| lemma kronecker_pos_input_transpose {n : ℕ} {α μ : YoungDiagram} | |
| (a : Tableau n α) (t : Tableau n μ) | |
| (b : Tableau n α.transpose) (h : 0 < kronecker a a t) : | |
| 0 < kronecker b b t := by | |
| let : AddCommGroup (Specht a ⊗[ℂ] Specht a) := Module.addCommMonoidToAddCommGroup ℂ | |
| let : AddCommGroup (Specht b ⊗[ℂ] Specht b) := Module.addCommMonoidToAddCommGroup ℂ | |
| obtain ⟨e⟩ := specht_sign_transpose a | |
| let f := (e.trans (signTwistEquiv | |
| (spechtShapeEquiv rfl (transposeTableau a) b))) | |
| let g := (tensorRepEquiv f f).trans (signTensorCancel (spechtRep b) (spechtRep b)) | |
| obtain ⟨F,hF⟩ := (kronecker_pos_iff a a t).mp h | |
| apply (kronecker_pos_iff b b t).mpr | |
| refine ⟨g.toIntertwiningMap.comp F,?_⟩ | |
| intro hz | |
| apply hF | |
| ext x | |
| apply g.injective | |
| have hh := congrArg (fun H => H x) hz | |
| change g (F x) = 0 at hh | |
| change g (F x) = g (0 : Specht a ⊗[ℂ] Specht a) | |
| exact hh.trans g.toIntertwiningMap.toLinearMap.map_zero.symm | |
| def SquareOccurs (α μ : YoungDiagram) : Prop := | |
| ∃ (n : ℕ) (a : Tableau n α) (t : Tableau n μ), 0 < kronecker a a t | |
| lemma SquareOccurs.card_eq {α μ : YoungDiagram} (h : SquareOccurs α μ) : | |
| α.card = μ.card := by | |
| obtain ⟨n,a,t,_⟩ := h | |
| exact (tableau_card_eq a).trans (tableau_card_eq t).symm | |
| lemma SquareOccurs.pos {n : ℕ} {α μ : YoungDiagram} (h : SquareOccurs α μ) | |
| (a : Tableau n α) (t : Tableau n μ) : 0 < kronecker a a t := by | |
| obtain ⟨m,b,u,hu⟩ := h | |
| have he : m = n := (tableau_card_eq b).symm.trans (tableau_card_eq a) | |
| subst m | |
| exact kronecker_pos_of_shapes rfl rfl rfl b b u a a t hu | |
| lemma SquareOccurs.input_transpose {α μ : YoungDiagram} (h : SquareOccurs α μ) : | |
| SquareOccurs α.transpose μ := by | |
| obtain ⟨n,a,t,ht⟩ := h | |
| exact ⟨n,transposeTableau a,t,kronecker_pos_input_transpose a t _ ht⟩ | |
| lemma SquareOccurs.target_transpose {α μ : YoungDiagram} | |
| (hs : α.transpose = α) (h : SquareOccurs α μ) : SquareOccurs α μ.transpose := by | |
| have he := h.card_eq | |
| let a := canonicalTableau α rfl | |
| let t := canonicalTableau μ he.symm | |
| exact ⟨α.card,a,transposeTableau t,kronecker_pos_of_shapes rfl rfl rfl _ _ _ _ _ _ | |
| (kronecker_pos_transpose α rfl hs μ he.symm (h.pos a t))⟩ | |
| lemma columnShape_perm {rs ss : List ℕ} (h : rs.Perm ss) : | |
| columnShape rs = columnShape ss := by | |
| apply YoungDiagram.ext | |
| ext ⟨i,j⟩ | |
| simp only [YoungDiagram.mem_cells,YoungDiagram.mem_iff_lt_rowLen] | |
| rw [columnShape_rowLen,columnShape_rowLen,h.countP_eq] | |
| lemma SquareOccurs.append {rs ss ts us : List ℕ} | |
| (h : SquareOccurs (columnShape rs) (columnShape ts)) | |
| (h' : SquareOccurs (columnShape ss) (columnShape us)) : | |
| SquareOccurs (columnShape (rs++ss)) (columnShape (ts++us)) := by | |
| obtain ⟨n,a,t,ht⟩ := h | |
| obtain ⟨m,b,u,hu⟩ := h' | |
| have he : (columnShape (rs++ss)).card = n+m := by | |
| rw [columnShape_card,List.sum_append,columnTableau_sum a,columnTableau_sum b] | |
| have hf : (columnShape (ts++us)).card = n+m := by | |
| rw [columnShape_card,List.sum_append,columnTableau_sum t,columnTableau_sum u] | |
| let A := canonicalTableau _ he | |
| let T := canonicalTableau _ hf | |
| exact ⟨n+m,A,T,kronecker_pos_append a a t b b u A A T ht hu⟩ | |
| lemma columnShape_diagram (μ : YoungDiagram) : | |
| columnShape μ.transpose.rowLens = μ := by | |
| obtain ⟨e,hr,_⟩ := columnShape_placement μ.transpose.rowLens | |
| apply YoungDiagram.ext | |
| ext ⟨i,j⟩ | |
| simp only [YoungDiagram.mem_cells,YoungDiagram.mem_iff_lt_rowLen] | |
| obtain ⟨f,hf,_⟩ := place_columns μ (List.Perm.refl _) | |
| rw [placed_rowLen e hr,placed_rowLen f hf] | |
| lemma columnShape_sorted (rs : List ℕ) (hs : rs.SortedGE) (hp : ∀ a ∈ rs, 0 < a) : | |
| columnShape rs = (YoungDiagram.ofRowLens rs hs).transpose := by | |
| conv_lhs => rw [← YoungDiagram.rowLens_ofRowLens_eq_self hp (hw := hs)] | |
| simpa only [YoungDiagram.transpose_transpose] using | |
| columnShape_diagram ((YoungDiagram.ofRowLens rs hs).transpose) | |
| end UniversalTensorSquare | |
| end | |
| end | |
| end OAI | |