openAI-math-dataset / lean /OAI /RepresentationTheory /UniversalSquare /Contraction /TwoPathContraction.lean
| import Mathlib | |
| import OAI.RepresentationTheory.Saxl.Main | |
| import OAI.RepresentationTheory.UniversalSquare.Balance.WordPacking | |
| namespace OAI | |
| /-! Two Path Contraction. -/ | |
| section | |
| noncomputable section | |
| namespace Saxl.Columns | |
| lemma dualBlockWord_singleton (r : ℕ) (N : ℕ → Band.Mat) : | |
| dualBlockWord [r] N = columnWedge r N := by | |
| classical | |
| unfold dualBlockWord columnWedge | |
| change (∑ π : Equiv.Perm (Fin r) × Unit, sg (rs := [r]) π • | |
| Path.pureWord (fun q => N (row (perm (rs := [r]) π (enumerate [r] q))))) = _ | |
| rw [Fintype.sum_prod_type] | |
| simp only [Fintype.sum_unique, sg, mul_one] | |
| apply Finset.sum_congr rfl | |
| intro π hπ | |
| congr 2 | |
| funext j | |
| change N (row (perm (rs := [r]) (π, ()) (enumerate [r] (Fin.castAdd 0 j)))) = _ | |
| erw [enumerate_left r [] j] | |
| rfl | |
| lemma dotProduct_cast {m n d : ℕ} (hn : m = n) | |
| (x : WordSpace m d) (y : WordSpace n d) : | |
| dotProduct (fun w => x (w ∘ Fin.cast hn)) y = | |
| dotProduct x (fun w => y (w ∘ Fin.cast hn.symm)) := by | |
| subst n | |
| rfl | |
| lemma columnWedge_path_nonzero (r : ℕ) (hr : 2*r+1 ≤ 4) : | |
| dotProduct (columnWedge (2*r+1) (fun i => Band.conjugation (Band.basis i))) | |
| (Path.bandWord r) ≠ 0 := by | |
| have h := odd_path_ordered_contraction r [2*r+1] (by | |
| intro a ha | |
| obtain rfl := List.mem_singleton.mp ha | |
| exact ⟨by omega, hr⟩) | |
| (by simp) | |
| rw [dualBlockWord_singleton] at h | |
| exact h | |
| theorem two_path_contraction (p r : ℕ) (rs : List ℕ) | |
| (hp : 2*p+1 ≤ 4) (hrs : ∀ a ∈ rs, 1 ≤ a ∧ a ≤ 4) | |
| (hr : rs.sum = 2*r+1) : | |
| dotProduct (dualBlockWord ((2*p+1)::rs) | |
| (fun i => Band.conjugation (Band.basis i))) | |
| (positionProduct finSumFinEquiv.symm (Path.bandWord p) | |
| (fun w => Path.bandWord r (w ∘ Fin.cast hr.symm))) ≠ 0 := by | |
| rw [dualBlockWord_cons] | |
| erw [positionProduct_pair] | |
| apply mul_ne_zero (columnWedge_path_nonzero p hp) | |
| erw [← dotProduct_cast hr] | |
| exact odd_path_ordered_contraction r rs hrs hr | |
| theorem two_path_cyclic_support (p r : ℕ) (rs : List ℕ) | |
| (hp : 2*p+1 ≤ 4) (hrs : ∀ a ∈ rs, 1 ≤ a ∧ a ≤ 4) | |
| (hr : rs.sum = 2*r+1) (μ : YoungDiagram) | |
| (hc : ((2*p+1)::rs).Perm μ.transpose.rowLens) | |
| (t : Tableau ((2*p+1)+rs.sum) μ) : | |
| ∃ F : Representation.IntertwiningMap (spechtRep t) | |
| (cyclic (wordRep ((2*p+1)+rs.sum) 4) | |
| (positionProduct finSumFinEquiv.symm (Path.bandWord p) | |
| (fun w => Path.bandWord r (w ∘ Fin.cast hr.symm)))).toRepresentation, | |
| F ≠ 0 := by | |
| obtain ⟨e, he, he'⟩ := place_columns μ hc | |
| let s : Tableau ((2*p+1)+rs.sum) μ := (enumerate ((2*p+1)::rs)).trans e | |
| apply specht_to_cyclic_of_vector_pair t | |
| ⟨polytabloid s, polytabloid_mem_all t s⟩ | |
| (fun i a => Band.conjugation (Band.basis i.val) (Path.parts a).1 (Path.parts a).2) | |
| change dotProduct (wordMap _ (polytabloid ((enumerate _).trans e))) _ ≠ 0 | |
| erw [mapped_placed_columns e he he' (fun i => Band.conjugation (Band.basis i))] | |
| exact two_path_contraction p r rs hp hrs hr | |
| lemma positionProduct_move {n a b d : ℕ} (e f : Fin n ≃ Fin a ⊕ Fin b) | |
| (x : WordSpace a d) (y : WordSpace b d) : | |
| positionProduct f x y = wordRep n d (e.trans f.symm) (positionProduct e x y) := by | |
| funext w | |
| change x (leftWord f w) * y (rightWord f w) = | |
| x (leftWord e (w ∘ (e.trans f.symm))) * y (rightWord e (w ∘ (e.trans f.symm))) | |
| congr 1 <;> apply congrArg | |
| · funext i | |
| simp [leftWord] | |
| · funext i | |
| simp [rightWord] | |
| theorem two_path_cyclic_support_placed {n : ℕ} (p r : ℕ) (rs : List ℕ) | |
| (hp : 2*p+1 ≤ 4) (hrs : ∀ a ∈ rs, 1 ≤ a ∧ a ≤ 4) | |
| (hr : rs.sum = 2*r+1) (μ : YoungDiagram) | |
| (hc : ((2*p+1)::rs).Perm μ.transpose.rowLens) | |
| (t : Tableau n μ) (e : Fin n ≃ Fin (2*p+1) ⊕ Fin (2*r+1)) : | |
| ∃ F : Representation.IntertwiningMap (spechtRep t) | |
| (cyclic (wordRep n 4) | |
| (positionProduct e (Path.bandWord p) (Path.bandWord r))).toRepresentation, | |
| F ≠ 0 := by | |
| let d : Fin n ≃ Fin (2*p+1) ⊕ Fin rs.sum := | |
| e.trans ((Equiv.refl _).sumCongr (finCongr hr.symm)) | |
| have hd : n = (2*p+1)+rs.sum := by | |
| simpa only [Fintype.card_fin, Fintype.card_sum] using Fintype.card_congr d | |
| subst n | |
| have heq : positionProduct e (Path.bandWord p) (Path.bandWord r) = | |
| positionProduct d (Path.bandWord p) | |
| (fun w => Path.bandWord r (w ∘ Fin.cast hr.symm)) := by | |
| funext w | |
| change Path.bandWord p (leftWord e w) * Path.bandWord r (rightWord e w) = | |
| Path.bandWord p (leftWord d w) * | |
| Path.bandWord r (rightWord d w ∘ Fin.cast hr.symm) | |
| rfl | |
| rw [heq, positionProduct_move finSumFinEquiv.symm d, cyclic_action_eq] | |
| exact two_path_cyclic_support p r rs hp hrs hr μ hc t | |
| theorem odd_column_split (q : ℕ) (μ : YoungDiagram) | |
| (hn : μ.card = 2*q+2) (hμ : μ.colLen 0 ≤ 4) | |
| (ho : ∃ j, μ.colLen j % 2 = 1) : | |
| ∃ p rs, p ≤ q ∧ 2*p+1 ≤ 4 ∧ | |
| (∀ a ∈ rs, 1 ≤ a ∧ a ≤ 4) ∧ rs.sum = 2*(q-p)+1 ∧ | |
| ((2*p+1)::rs).Perm μ.transpose.rowLens := by | |
| classical | |
| obtain ⟨j,hj⟩ := ho | |
| have hp : 0 < μ.colLen j := by omega | |
| have hjlt : j < μ.transpose.colLen 0 := by | |
| rw [YoungDiagram.colLen_transpose] | |
| exact YoungDiagram.mem_iff_lt_rowLen.mp (YoungDiagram.mem_iff_lt_colLen.mpr hp) | |
| have hmem : μ.colLen j ∈ μ.transpose.rowLens := by | |
| have hjl : j < μ.transpose.rowLens.length := by simpa using hjlt | |
| have he := List.getElem_mem hjl | |
| simpa only [YoungDiagram.get_rowLens, YoungDiagram.rowLen_transpose] using he | |
| let rs := μ.transpose.rowLens.erase (μ.colLen j) | |
| have hperm : ((μ.colLen j)::rs).Perm μ.transpose.rowLens := | |
| (List.perm_cons_erase hmem).symm | |
| have hs : μ.colLen j + rs.sum = 2*q+2 := by | |
| have h := hperm.sum_eq | |
| rw [List.sum_cons, ← card_eq_sum_rowLens, transpose_card, hn] at h | |
| exact h | |
| have hu := (μ.colLen_anti 0 j (Nat.zero_le _)).trans hμ | |
| refine ⟨(μ.colLen j)/2, rs, ?_, ?_, ?_, ?_, ?_⟩ | |
| · omega | |
| · omega | |
| · intro a ha | |
| have ha' := List.mem_of_mem_erase ha | |
| exact Path.fourRow_column_lengths μ hμ a ha' | |
| · omega | |
| · have he : 2*(μ.colLen j/2)+1 = μ.colLen j := by omega | |
| simpa only [he] using hperm | |
| end Saxl.Columns | |
| end | |
| end | |
| end OAI | |