| import Mathlib |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| section |
|
|
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps.Irrep |
| open Representation |
|
|
| variable {G H V W : Type*} [Group G] [Group H] |
| [AddCommMonoid V] [Module ℂ V] [AddCommMonoid W] [Module ℂ W] |
| (φ : H →* G) (ρ : Representation ℂ G V) (σ : Representation ℂ H W) |
|
|
| def toCoind (f : IntertwiningMap (ρ.comp φ) σ) : IntertwiningMap ρ (coind φ σ) where |
| toLinearMap := { |
| toFun := fun v => ⟨fun g => f (ρ g v), by |
| intro h g |
| change f (ρ (φ h * g) v) = σ h (f (ρ g v)) |
| rw [map_mul,Module.End.mul_apply] |
| exact IntertwiningMap.isIntertwining _ _ f h (ρ g v)⟩ |
| map_add' := by intro a b; ext g; simp only [map_add]; rfl |
| map_smul' := by intro c a; ext g; simp only [map_smul]; rfl } |
| isIntertwining' a := by |
| ext v g |
| change f (ρ g (ρ a v)) = f (ρ (g*a) v) |
| rw [map_mul,Module.End.mul_apply] |
|
|
| def fromCoind (f : IntertwiningMap ρ (coind φ σ)) : IntertwiningMap (ρ.comp φ) σ where |
| toLinearMap := { |
| toFun := fun v => (f v).val 1 |
| map_add' := by intros; simp only [map_add]; rfl |
| map_smul' := by intros; simp only [map_smul]; rfl } |
| isIntertwining' h := by |
| ext v |
| have he := congrArg (fun u : coindV φ σ => u.val 1) |
| (IntertwiningMap.isIntertwining _ _ f (φ h) v) |
| change (f (ρ (φ h) v)).val 1 = σ h ((f v).val 1) |
| rw [he] |
| change (f v).val (1*φ h) = _ |
| simpa only [one_mul,mul_one] using (f v).property h 1 |
|
|
| def coindHomEquiv : IntertwiningMap (ρ.comp φ) σ ≃ₗ[ℂ] IntertwiningMap ρ (coind φ σ) where |
| toFun := toCoind φ ρ σ |
| invFun := fromCoind φ ρ σ |
| left_inv f := by ext v; change f (ρ 1 v) = f v; simp |
| right_inv f := by |
| ext v g |
| change (f (ρ g v)).val 1 = (f v).val g |
| rw [IntertwiningMap.isIntertwining] |
| change (f v).val (1*g) = _ |
| rw [one_mul] |
| map_add' a b := by ext v g; rfl |
| map_smul' c a := by ext v g; rfl |
|
|
| variable [Fintype G] [Fintype H] [Module.Finite ℂ V] [Module.Finite ℂ W] |
|
|
| lemma multiplicity_symm (σ : Representation ℂ G W) : |
| Module.finrank ℂ (IntertwiningMap ρ σ) = Module.finrank ℂ (IntertwiningMap σ ρ) := by |
| let : AddCommGroup V := Module.addCommMonoidToAddCommGroup ℂ |
| let : AddCommGroup W := Module.addCommMonoidToAddCommGroup ℂ |
| let : Invertible (Nat.card G : ℂ) := invertibleOfNonzero (by exact_mod_cast Nat.card_pos.ne') |
| have h₁ := card_inv_mul_sum_char_mul_char_eq_finrank ρ σ |
| have h₂ := card_inv_mul_sum_char_mul_char_eq_finrank σ ρ |
| have he : ∑ g : G, σ.character g * ρ.character g⁻¹ = |
| ∑ g : G, ρ.character g * σ.character g⁻¹ := by |
| rw [← Equiv.sum_comp (Equiv.inv G) (fun g => ρ.character g * σ.character g⁻¹)] |
| simp only [Equiv.inv_apply,inv_inv,mul_comm] |
| apply Nat.cast_injective (R := ℂ) |
| exact h₁.symm.trans ((congrArg (fun z : ℂ => (Nat.card G : ℂ)⁻¹*z) he).trans h₂) |
|
|
| def coindEvaluation {I : Type*} (r : I → G) : coindV φ σ →ₗ[ℂ] (I → W) where |
| toFun := fun f i => f.val (r i) |
| map_add' := by intros; rfl |
| map_smul' := by intros; rfl |
|
|
| omit [Fintype G] [Fintype H] [Module.Finite ℂ W] in |
| lemma coindEvaluation_injective {I : Type*} (r : I → G) |
| (hr : ∀ g : G, ∃ h : H, ∃ i : I, g = φ h * r i) : |
| Function.Injective (coindEvaluation φ σ r) := by |
| intro f a he |
| apply Subtype.ext |
| funext g |
| obtain ⟨h,i,rfl⟩ := hr g |
| rw [f.property,a.property] |
| exact congrArg (σ h) (congrFun he i) |
|
|
| omit [Fintype G] [Fintype H] in |
| lemma coind_finrank_le {I : Type*} [Fintype I] (r : I → G) |
| (hr : ∀ g : G, ∃ h : H, ∃ i : I, g = φ h * r i) : |
| Module.finrank ℂ (coindV φ σ) ≤ Fintype.card I * Module.finrank ℂ W := by |
| let : AddCommGroup W := Module.addCommMonoidToAddCommGroup ℂ |
| simpa only [Module.finrank_pi_fintype,Finset.sum_const,Finset.card_univ,smul_eq_mul] using |
| (LinearMap.finrank_le_finrank_of_injective (coindEvaluation_injective φ σ r hr)) |
|
|
| end BinaryCoordinateSweeps.Irrep |
|
|
| end |
|
|
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps.Irrep |
| open Representation Equiv Equiv.Perm |
|
|
| variable {A B X : Type*} [Fintype A] [Fintype B] [Fintype X] |
| (e : A ⊕ B ≃ X) |
|
|
| def blockPerm : Equiv.Perm A →* Equiv.Perm X := |
| e.permCongrHom.toMonoidHom.comp ((sumCongrHom A B).comp (MonoidHom.inl _ _)) |
|
|
| omit [Fintype A] [Fintype B] [Fintype X] in |
| lemma blockPerm_inr (a : Equiv.Perm A) (b : B) : |
| blockPerm e a (e (Sum.inr b)) = e (Sum.inr b) := by |
| change e (Equiv.sumCongr a (1:Equiv.Perm B) (e.symm (e (Sum.inr b)))) = _ |
| rw [e.symm_apply_apply] |
| rfl |
|
|
| omit [Fintype X] in |
| lemma blockPerm_of_fixed (g : Equiv.Perm X) (hg : ∀ b, g (e (Sum.inr b)) = e (Sum.inr b)) : |
| ∃ a : Equiv.Perm A, blockPerm e a = g := by |
| let d := e.symm.permCongr g |
| have hd (b : B) : d (Sum.inr b) = Sum.inr b := by |
| change e.symm (g (e (Sum.inr b))) = _ |
| rw [hg,e.symm_apply_apply] |
| have hh : d ∈ (sumCongrHom A B).range := by |
| apply mem_sumCongrHom_range_of_perm_mapsTo_inl |
| apply (perm_mapsTo_inl_iff_mapsTo_inr d).mpr |
| rintro y ⟨b,rfl⟩ |
| exact ⟨b,(hd b).symm⟩ |
| obtain ⟨⟨a,b⟩,hab⟩ := hh |
| have hb : b = 1 := by |
| ext x |
| have hx := Equiv.congr_fun hab (Sum.inr x) |
| rw [hd] at hx |
| exact Sum.inr_injective hx |
| subst b |
| refine ⟨a,?_⟩ |
| change e.permCongr ((sumCongrHom A B) (a,1)) = g |
| have he := congrArg e.permCongr hab |
| simpa only [d,← Equiv.permCongr_symm,Equiv.apply_symm_apply] using he |
|
|
| def basePlacement : B ↪ X := ⟨fun b => e (Sum.inr b), e.injective.comp Sum.inr_injective⟩ |
|
|
| omit [Fintype A] [Fintype X] in |
| lemma placement_extension (x : B ↪ X) : ∃ g : Equiv.Perm X, ∀ b, g (basePlacement e b) = x b := |
| Equiv.Perm.exists_extending_pair (basePlacement e) x (basePlacement e).injective x.injective |
|
|
| def placementSection (x : B ↪ X) : Equiv.Perm X := (placement_extension e x).choose |
|
|
| omit [Fintype A] [Fintype X] in |
| lemma placementSection_apply (x : B ↪ X) (b : B) : |
| placementSection e x (basePlacement e b) = x b := (placement_extension e x).choose_spec b |
|
|
| omit [Fintype X] in |
| lemma placementSection_covers (g : Equiv.Perm X) : |
| ∃ a : Equiv.Perm A, ∃ x : B ↪ X, g = blockPerm e a * (placementSection e x)⁻¹ := by |
| let x : B ↪ X := (basePlacement e).trans g.symm.toEmbedding |
| have hx : ∀ b, (g*placementSection e x) (e (Sum.inr b)) = e (Sum.inr b) := by |
| intro b |
| change g (placementSection e x (basePlacement e b)) = _ |
| rw [placementSection_apply] |
| exact g.apply_symm_apply _ |
| obtain ⟨a,ha⟩ := blockPerm_of_fixed e (g*placementSection e x) hx |
| exact ⟨a,x,by rw [ha,mul_inv_cancel_right]⟩ |
|
|
| variable {W : Type*} [AddCommMonoid W] [Module ℂ W] [Module.Finite ℂ W] |
| (σ : Representation ℂ (Equiv.Perm A) W) |
|
|
| theorem placement_coind_finrank : |
| Module.finrank ℂ (coindV (blockPerm e) σ) ≤ |
| Fintype.card (B ↪ X) * Module.finrank ℂ W := |
| coind_finrank_le (blockPerm e) σ (fun x => (placementSection e x)⁻¹) |
| (placementSection_covers e) |
|
|
| theorem placement_coind_finrank_pow : |
| Module.finrank ℂ (coindV (blockPerm e) σ) ≤ |
| (Fintype.card X)^(Fintype.card B) * Module.finrank ℂ W := by |
| apply (placement_coind_finrank e σ).trans |
| apply Nat.mul_le_mul_right |
| simpa only [Fintype.card_fun] using |
| Fintype.card_le_of_injective (fun x : B ↪ X => (x : B → X)) DFunLike.coe_injective |
|
|
| end BinaryCoordinateSweeps.Irrep |
|
|
| end |
|
|
| end OAI |
|
|
