File size: 7,309 Bytes
9b6e014 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 | 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]; ring
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]; group
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
|