| import Mathlib |
| import OAI.Probability.BinarySweep.YoungTheory.YoungSpecht |
| |
| namespace OAI |
|
|
| noncomputable section |
|
|
| section |
|
|
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps.Young |
| |
| lemma diagonal_rigidity_aux {X : Type*} [Fintype X] (A B : X → ℝ) |
| (r c : Equiv.Perm X) (hr : ∀ x, A (r x) = A x) |
| (hc : ∀ x, B (c x) = B x) |
| (hd : ∀ x, A ((r*c) x) + B ((r*c) x) = A x + B x) : |
| ∀ x, A (c x) = A x := by |
| have hq (x : X) : B ((r*c) x) = A x + B x - A (c x) := by |
| have he := hd x |
| change A (r (c x)) + _ = _ at he |
| rw [hr] at he |
| linarith |
| have hxc : ∑ x, A (c x) * B x = ∑ x, A x * B x := by |
| simpa only [hc] using Equiv.sum_comp c (fun x => A x * B x) |
| have hxx : ∑ x, (A (c x))^2 = ∑ x, (A x)^2 := |
| Equiv.sum_comp c (fun x => (A x)^2) |
| have hprod : ∑ x, (A (c x) * A x + A (c x) * B x - (A (c x))^2) = |
| ∑ x, A x * B x := by |
| calc |
| _ = ∑ x, A ((r*c) x) * B ((r*c) x) := by |
| apply Finset.sum_congr rfl |
| intro x _ |
| rw [hq] |
| change _ = A (r (c x)) * _ |
| rw [hr] |
| ring |
| _ = _ := Equiv.sum_comp (r*c) (fun x => A x * B x) |
| rw [Finset.sum_sub_distrib, Finset.sum_add_distrib, hxc] at hprod |
| have hcross : ∑ x, A (c x) * A x = ∑ x, (A (c x))^2 := by linarith |
| have hzero : ∑ x, (A (c x) - A x)^2 = 0 := by |
| calc |
| _ = (∑ x, (A (c x))^2) - 2 * (∑ x, A (c x)*A x) + ∑ x, (A x)^2 := by |
| simp only [Finset.mul_sum, ← Finset.sum_sub_distrib, ← Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro x _ |
| ring |
| _ = 0 := by rw [hcross, hxx] |
| intro x |
| have hx : (A (c x) - A x)^2 = 0 := |
| (Finset.sum_eq_zero_iff_of_nonneg (fun x _ => sq_nonneg (A (c x) - A x))).mp hzero x |
| (Finset.mem_univ x) |
| nlinarith [sq_nonneg (A (c x) - A x)] |
|
|
| def diagonal (μ : YoungDiagram) (x : Cell μ) : ℕ := row x + col x |
| abbrev diagonalStabilizer (μ : YoungDiagram) := fiberStabilizer (diagonal μ) |
| instance diagonalStabilizer_fintype (μ : YoungDiagram) : Fintype (diagonalStabilizer μ) := |
| Fintype.ofFinite _ |
|
|
| lemma diagonal_row_column (μ : YoungDiagram) (r : rowStabilizer μ) (c : C μ) |
| (hd : r.val*c.val ∈ diagonalStabilizer μ) : r = 1 ∧ c = 1 := by |
| have he := diagonal_rigidity_aux (fun x : Cell μ => (row x : ℝ)) |
| (fun x => (col x : ℝ)) r.val c.val |
| (fun x => congrArg Nat.cast (r.property x)) (fun x => congrArg Nat.cast (c.property x)) |
| (fun x => by exact_mod_cast hd x) |
| have hc : c.val ∈ rowStabilizer μ := fun x => by exact_mod_cast he x |
| have hi : c.val ∈ rowStabilizer μ ⊓ colStabilizer μ := ⟨hc,c.property⟩ |
| rw [row_col_intersection] at hi |
| have hc1 : c = 1 := Subtype.ext hi |
| have hr1 : r = 1 := by |
| apply Subtype.ext |
| apply Equiv.ext |
| intro x |
| apply Subtype.ext |
| apply Prod.ext (r.property x) |
| have hh := hd x |
| rw [hc1] at hh |
| change row (r.val x) + col (r.val x) = row x + col x at hh |
| rw [r.property] at hh |
| exact Nat.add_left_cancel hh |
| exact ⟨hr1,hc1⟩ |
|
|
| lemma diagonal_column_row (μ : YoungDiagram) (c : C μ) (r : rowStabilizer μ) |
| (hd : c.val*r.val ∈ diagonalStabilizer μ) : c = 1 ∧ r = 1 := by |
| have hi := (diagonalStabilizer μ).inv_mem hd |
| have he : (r⁻¹).val * (c⁻¹).val ∈ diagonalStabilizer μ := by simpa using hi |
| obtain ⟨hr,hc⟩ := diagonal_row_column μ r⁻¹ c⁻¹ he |
| exact ⟨inv_eq_one.mp hc, inv_eq_one.mp hr⟩ |
|
|
| variable (μ : YoungDiagram) |
|
|
| lemma diagonal_tabloid_eq (g h : diagonalStabilizer μ) (c : C μ) : |
| tabloidOfPerm μ (g.val*c.val) = tabloidOfPerm μ h.val ↔ g = h ∧ c = 1 := by |
| constructor |
| · intro he |
| let r : rowStabilizer μ := ⟨(g.val*c.val)⁻¹*h.val, |
| (tabloidOfPerm_eq_iff μ _ _).mp he⟩ |
| have hr : c.val*r.val = g.val⁻¹*h.val := by dsimp only [r] |
| have hd : c.val*r.val ∈ diagonalStabilizer μ := by |
| rw [hr] |
| exact (diagonalStabilizer μ).mul_mem ((diagonalStabilizer μ).inv_mem g.property) h.property |
| obtain ⟨hc,hr1⟩ := diagonal_column_row μ c r hd |
| refine ⟨?_,hc⟩ |
| rw [hc,hr1] at hr |
| have hg : g.val = h.val := inv_mul_eq_one.mp (by simpa using hr.symm) |
| exact Subtype.ext hg |
| · rintro ⟨rfl,rfl⟩ |
| simp |
|
|
| lemma diagonal_poly_coefficient (g h : diagonalStabilizer μ) : |
| tabloidRepresentation μ g.val (polytabloid μ) (tabloidOfPerm μ h.val) = |
| if g = h then (1 : ℂ) else 0 := by |
| rw [polytabloid, columnAnti_apply] |
| simp_rw [rep_basis, smul_tabloidOfPerm, mul_one] |
| rw [map_sum] |
| simp_rw [map_smul, rep_basis, smul_tabloidOfPerm] |
| simp only [Finset.sum_apply, Pi.smul_apply, tabloidBasis, Pi.single_apply] |
| have he (c : C μ) : tabloidOfPerm μ h.val = tabloidOfPerm μ (g.val*c.val) ↔ |
| g = h ∧ c = 1 := (eq_comm).trans (diagonal_tabloid_eq μ g h c) |
| simp only [he] |
| by_cases hgh : g = h |
| · simp [hgh] |
| · simp [hgh] |
|
|
| theorem diagonal_polytabloids_independent : LinearIndependent ℂ |
| (fun g : diagonalStabilizer μ => spechtRep μ g.val (spechtPoly μ)) := by |
| apply LinearIndependent.of_comp (f := spechtInclude μ) |
| rw [Fintype.linearIndependent_iff] |
| intro a ha g |
| have he := congrFun ha (tabloidOfPerm μ g.val) |
| simp only [Finset.sum_apply, Pi.smul_apply, Function.comp_apply, Pi.zero_apply] at he |
| simp_rw [spechtInclude_rep, spechtInclude_poly, diagonal_poly_coefficient] at he |
| simpa using he |
|
|
| theorem diagonal_card_le_dimension : Fintype.card (diagonalStabilizer μ) ≤ |
| Module.finrank ℂ (SpechtSpace μ) := by |
| let : Module.Finite ℂ (SpechtSpace μ) := |
| inferInstanceAs (FiniteDimensional ℂ (SpechtSpace μ)) |
| exact (diagonal_polytabloids_independent μ).fintype_card_le_finrank |
|
|
| end BinaryCoordinateSweeps.Young |
| |
| end |
|
|
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps.Young |
| variable {X Y : Type*} [Fintype X] [Fintype Y] |
|
|
| def fiberQuotientLabel (f : X → Y) : |
| (Equiv.Perm X ⧸ fiberStabilizer f) → (X → Y) := |
| Quotient.lift (fun (g : Equiv.Perm X) => fun x => f (g⁻¹ x)) (by |
| intro g h he |
| have he' := (QuotientGroup.leftRel_apply.mp he : g⁻¹*h ∈ fiberStabilizer f) |
| funext x |
| have hh := he' (h⁻¹ x) |
| simpa using hh) |
|
|
| omit [Fintype X] [Fintype Y] in |
| lemma fiberQuotientLabel_injective (f : X → Y) : |
| Function.Injective (fiberQuotientLabel f) := by |
| intro a b |
| induction a using Quotient.inductionOn with | h g => |
| induction b using Quotient.inductionOn with | h h => |
| intro he |
| apply Quotient.sound |
| apply QuotientGroup.leftRel_apply.mpr |
| intro x |
| have hh := congrFun he (h x) |
| simpa [fiberQuotientLabel] using hh |
|
|
| theorem factorial_le_colorings_mul_stabilizer (f : X → Y) : |
| (Fintype.card X).factorial ≤ |
| (Fintype.card Y)^(Fintype.card X) * Nat.card (fiberStabilizer f) := by |
| have hi : Nat.card (Equiv.Perm X ⧸ fiberStabilizer f) ≤ Nat.card (X → Y) := |
| Nat.card_le_card_of_injective (fiberQuotientLabel f) (fiberQuotientLabel_injective f) |
| have he := Subgroup.card_eq_card_quotient_mul_card_subgroup (fiberStabilizer f) |
| rw [Nat.card_eq_fintype_card, Fintype.card_perm] at he |
| simp only [Nat.card_eq_fintype_card, Fintype.card_fun] at hi |
| simp only [Nat.card_eq_fintype_card] at he ⊢ |
| rw [he] |
| exact Nat.mul_le_mul_right _ hi |
|
|
| end BinaryCoordinateSweeps.Young |
| |
| end |
|
|
| end OAI |
|
|
