fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
strong_law_ae_of_measurable
(X : ℕ → Ω → E) (hint : Integrable (X 0) μ) (h' : StronglyMeasurable (X 0))
(hindep : Pairwise ((IndepFun · · μ) on X))
(hident : ∀ i, IdentDistrib (X i) (X 0) μ μ) :
∀ᵐ ω ∂μ, Tendsto (fun n : ℕ ↦ (n : ℝ) ⁻¹ • (∑ i ∈ range n, X i ω)) atTop (𝓝 μ[X 0]) := by
/- Choose a simp... | lemma | Probability | [
"Mathlib.Probability.IdentDistrib",
"Mathlib.Probability.Independence.Integrable",
"Mathlib.MeasureTheory.Integral.DominatedConvergence",
"Mathlib.Analysis.SpecificLimits.FloorPow",
"Mathlib.Analysis.PSeries",
"Mathlib.Analysis.Asymptotics.SpecificAsymptotics"
] | Mathlib/Probability/StrongLaw.lean | strong_law_ae_of_measurable | Preliminary lemma for the strong law of large numbers for vector-valued random variables,
assuming measurability in addition to integrability. This is weakened to ae measurability in
the full version `ProbabilityTheory.strong_law_ae`. |
strong_law_ae (X : ℕ → Ω → E) (hint : Integrable (X 0) μ)
(hindep : Pairwise ((IndepFun · · μ) on X))
(hident : ∀ i, IdentDistrib (X i) (X 0) μ μ) :
∀ᵐ ω ∂μ, Tendsto (fun n : ℕ ↦ (n : ℝ) ⁻¹ • (∑ i ∈ range n, X i ω)) atTop (𝓝 μ[X 0]) := by
by_cases h : ∀ᵐ ω ∂μ, X 0 ω = 0
· have I : ∀ᵐ ω ∂μ, ∀ i, X i ω =... | theorem | Probability | [
"Mathlib.Probability.IdentDistrib",
"Mathlib.Probability.Independence.Integrable",
"Mathlib.MeasureTheory.Integral.DominatedConvergence",
"Mathlib.Analysis.SpecificLimits.FloorPow",
"Mathlib.Analysis.PSeries",
"Mathlib.Analysis.Asymptotics.SpecificAsymptotics"
] | Mathlib/Probability/StrongLaw.lean | strong_law_ae | **Strong law of large numbers**, almost sure version: if `X n` is a sequence of independent
identically distributed integrable random variables taking values in a Banach space,
then `n⁻¹ • ∑ i ∈ range n, X i` converges almost surely to `𝔼[X 0]`. We give here the strong
version, due to Etemadi, that only requires pairw... |
strong_law_Lp {p : ℝ≥0∞} (hp : 1 ≤ p) (hp' : p ≠ ∞) (X : ℕ → Ω → E)
(hℒp : MemLp (X 0) p μ) (hindep : Pairwise ((IndepFun · · μ) on X))
(hident : ∀ i, IdentDistrib (X i) (X 0) μ μ) :
Tendsto (fun (n : ℕ) => eLpNorm (fun ω => (n : ℝ) ⁻¹ • (∑ i ∈ range n, X i ω) - μ[X 0]) p μ)
atTop (𝓝 0) := by
by_ca... | theorem | Probability | [
"Mathlib.Probability.IdentDistrib",
"Mathlib.Probability.Independence.Integrable",
"Mathlib.MeasureTheory.Integral.DominatedConvergence",
"Mathlib.Analysis.SpecificLimits.FloorPow",
"Mathlib.Analysis.PSeries",
"Mathlib.Analysis.Asymptotics.SpecificAsymptotics"
] | Mathlib/Probability/StrongLaw.lean | strong_law_Lp | **Strong law of large numbers**, Lᵖ version: if `X n` is a sequence of independent
identically distributed random variables in Lᵖ, then `n⁻¹ • ∑ i ∈ range n, X i`
converges in `Lᵖ` to `𝔼[X 0]`. |
uniformOn (s : Set Ω) : Measure Ω :=
Measure.count[|s] | def | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn | Given a set `s`, `uniformOn s` is the uniform measure on `s`, defined as the counting measure
conditioned by `s`. One should think of `uniformOn s t` as the proportion of `s` that is contained
in `t`.
This is a probability measure when `s` is finite and nonempty and is given by
`ProbabilityTheory.uniformOn_isProbabili... |
@[simp]
uniformOn_empty_meas : (uniformOn ∅ : Measure Ω) = 0 := by simp [uniformOn] | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_empty_meas | null |
uniformOn_empty {s : Set Ω} : uniformOn s ∅ = 0 := by simp | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_empty | null |
@[simp] uniformOn_eq_zero' (hs : MeasurableSet s) : uniformOn s = 0 ↔ s.Infinite ∨ s = ∅ := by
simp [uniformOn, hs] | lemma | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_eq_zero' | See `uniformOn_eq_zero` for a version assuming `MeasurableSingletonClass Ω` instead of
`MeasurableSet s`. |
@[simp] uniformOn_eq_zero [MeasurableSingletonClass Ω] :
uniformOn s = 0 ↔ s.Infinite ∨ s = ∅ := by simp [uniformOn] | lemma | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_eq_zero | See `uniformOn_eq_zero'` for a version assuming `MeasurableSet s` instead of
`MeasurableSingletonClass Ω`. |
finite_of_uniformOn_ne_zero {s t : Set Ω} (h : uniformOn s t ≠ 0) : s.Finite := by
by_contra hs'
simp [uniformOn, cond, Measure.count_apply_infinite hs'] at h | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | finite_of_uniformOn_ne_zero | null |
uniformOn_univ [Fintype Ω] {s : Set Ω} :
uniformOn Set.univ s = Measure.count s / Fintype.card Ω := by
simp [uniformOn, cond_apply, ← ENNReal.div_eq_inv_mul]
variable [MeasurableSingletonClass Ω] | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_univ | null |
uniformOn_isProbabilityMeasure {s : Set Ω} (hs : s.Finite) (hs' : s.Nonempty) :
IsProbabilityMeasure (uniformOn s) := by
apply cond_isProbabilityMeasure_of_finite
· rwa [Measure.count_ne_zero_iff]
· exact (Measure.count_apply_lt_top.2 hs).ne | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_isProbabilityMeasure | null |
uniformOn_singleton (ω : Ω) (t : Set Ω) [Decidable (ω ∈ t)] :
uniformOn {ω} t = if ω ∈ t then 1 else 0 := by
rw [uniformOn, cond_apply (measurableSet_singleton ω), Measure.count_singleton, inv_one,
one_mul]
split_ifs
· rw [(by simpa : ({ω} : Set Ω) ∩ t = {ω}), Measure.count_singleton]
· simpa
variable {... | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_singleton | null |
uniformOn_inter_self (hs : s.Finite) : uniformOn s (s ∩ t) = uniformOn s t := by
rw [uniformOn, cond_inter_self hs.measurableSet] | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_inter_self | null |
uniformOn_self (hs : s.Finite) (hs' : s.Nonempty) : uniformOn s s = 1 := by
rw [uniformOn, cond_apply hs.measurableSet, Set.inter_self, ENNReal.inv_mul_cancel]
· rwa [Measure.count_ne_zero_iff]
· exact (Measure.count_apply_lt_top.2 hs).ne | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_self | null |
uniformOn_eq_one_of (hs : s.Finite) (hs' : s.Nonempty) (ht : s ⊆ t) :
uniformOn s t = 1 := by
haveI := uniformOn_isProbabilityMeasure hs hs'
refine eq_of_le_of_not_lt prob_le_one ?_
rw [not_lt, ← uniformOn_self hs hs']
exact measure_mono ht | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_eq_one_of | null |
pred_true_of_uniformOn_eq_one (h : uniformOn s t = 1) : s ⊆ t := by
have hsf := finite_of_uniformOn_ne_zero (by rw [h]; exact one_ne_zero)
rw [uniformOn, cond_apply hsf.measurableSet, mul_comm] at h
replace h := ENNReal.eq_inv_of_mul_eq_one_left h
rw [inv_inv, Measure.count_apply_finite _ hsf, Measure.count_app... | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | pred_true_of_uniformOn_eq_one | null |
uniformOn_eq_zero_iff (hs : s.Finite) : uniformOn s t = 0 ↔ s ∩ t = ∅ := by
simp [uniformOn, cond_apply hs.measurableSet, Measure.count_apply_eq_top, Set.not_infinite.2 hs,
Measure.count_apply_finite _ (hs.inter_of_left _)] | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_eq_zero_iff | null |
uniformOn_of_univ (hs : s.Finite) (hs' : s.Nonempty) : uniformOn s Set.univ = 1 :=
uniformOn_eq_one_of hs hs' s.subset_univ | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_of_univ | null |
uniformOn_inter (hs : s.Finite) :
uniformOn s (t ∩ u) = uniformOn (s ∩ t) u * uniformOn s t := by
by_cases hst : s ∩ t = ∅
· rw [hst, uniformOn_empty_meas, Measure.coe_zero, Pi.zero_apply, zero_mul,
uniformOn_eq_zero_iff hs, ← Set.inter_assoc, hst, Set.empty_inter]
rw [uniformOn, uniformOn, cond_apply h... | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_inter | null |
uniformOn_inter' (hs : s.Finite) :
uniformOn s (t ∩ u) = uniformOn (s ∩ u) t * uniformOn s u := by
rw [← Set.inter_comm]
exact uniformOn_inter hs | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_inter' | null |
uniformOn_union (hs : s.Finite) (htu : Disjoint t u) :
uniformOn s (t ∪ u) = uniformOn s t + uniformOn s u := by
rw [uniformOn, cond_apply hs.measurableSet, cond_apply hs.measurableSet,
cond_apply hs.measurableSet, Set.inter_union_distrib_left, measure_union, mul_add]
exacts [htu.mono inf_le_right inf_le_ri... | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_union | null |
uniformOn_compl (t : Set Ω) (hs : s.Finite) (hs' : s.Nonempty) :
uniformOn s t + uniformOn s tᶜ = 1 := by
rw [← uniformOn_union hs disjoint_compl_right, Set.union_compl_self,
(uniformOn_isProbabilityMeasure hs hs').measure_univ] | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_compl | null |
uniformOn_disjoint_union (hs : s.Finite) (ht : t.Finite) (hst : Disjoint s t) :
uniformOn s u * uniformOn (s ∪ t) s + uniformOn t u * uniformOn (s ∪ t) t =
uniformOn (s ∪ t) u := by
rcases s.eq_empty_or_nonempty with (rfl | hs') <;> rcases t.eq_empty_or_nonempty with (rfl | ht')
· simp
· simp [uniformOn... | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_disjoint_union | null |
uniformOn_add_compl_eq (u t : Set Ω) (hs : s.Finite) :
uniformOn (s ∩ u) t * uniformOn s u + uniformOn (s ∩ uᶜ) t * uniformOn s uᶜ =
uniformOn s t := by
conv_rhs =>
rw [(by simp : s = s ∩ u ∪ s ∩ uᶜ),
← uniformOn_disjoint_union (hs.inter_of_left _) (hs.inter_of_left _)
(disjoint_compl_right.... | theorem | Probability | [
"Mathlib.Probability.ConditionalProbability",
"Mathlib.MeasureTheory.Measure.Count"
] | Mathlib/Probability/UniformOn.lean | uniformOn_add_compl_eq | A version of the law of total probability for counting probabilities. |
Representation :=
G →* V →ₗ[k] V | abbrev | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | Representation | A representation of `G` on the `k`-module `V` is a homomorphism `G →* (V →ₗ[k] V)`. |
trivial : Representation k G V :=
1
variable {G V}
@[simp] | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | trivial | The trivial representation of `G` on a `k`-module V. |
trivial_apply (g : G) (v : V) : trivial k G V g v = v :=
rfl
variable {k} | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | trivial_apply | null |
IsTrivial (ρ : Representation k G V) : Prop where
out : ∀ g, ρ g = LinearMap.id := by aesop | class | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | IsTrivial | A predicate for representations that fix every element. |
@[simp]
isTrivial_def (ρ : Representation k G V) [IsTrivial ρ] (g : G) :
ρ g = LinearMap.id := IsTrivial.out g | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | isTrivial_def | null |
isTrivial_apply (ρ : Representation k G V) [IsTrivial ρ] (g : G) (x : V) :
ρ g x = x := congr($(isTrivial_def ρ g) x) | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | isTrivial_apply | null |
@[simp]
inv_self_apply (g : G) (x : V) :
ρ g⁻¹ (ρ g x) = x := by
simp [← Module.End.mul_apply, ← map_mul]
@[simp] | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | inv_self_apply | null |
self_inv_apply (g : G) (x : V) :
ρ g (ρ g⁻¹ x) = x := by
simp [← Module.End.mul_apply, ← map_mul] | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | self_inv_apply | null |
apply_bijective (g : G) :
Function.Bijective (ρ g) :=
Equiv.bijective ⟨ρ g, ρ g⁻¹, inv_self_apply ρ g, self_inv_apply ρ g⟩ | lemma | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | apply_bijective | null |
noncomputable asAlgebraHom : MonoidAlgebra k G →ₐ[k] Module.End k V :=
(lift k G _) ρ | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | asAlgebraHom | A `k`-linear representation of `G` on `V` can be thought of as
an algebra map from `MonoidAlgebra k G` into the `k`-linear endomorphisms of `V`. |
asAlgebraHom_def : asAlgebraHom ρ = (lift k G _) ρ :=
rfl
@[simp] | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | asAlgebraHom_def | null |
asAlgebraHom_single (g : G) (r : k) :
asAlgebraHom ρ (MonoidAlgebra.single g r) = r • ρ g := by
simp only [asAlgebraHom_def, MonoidAlgebra.lift_single] | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | asAlgebraHom_single | null |
asAlgebraHom_single_one (g : G) : asAlgebraHom ρ (MonoidAlgebra.single g 1) = ρ g := by simp | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | asAlgebraHom_single_one | null |
asAlgebraHom_of (g : G) : asAlgebraHom ρ (of k G g) = ρ g := by
simp only [MonoidAlgebra.of_apply, asAlgebraHom_single, one_smul] | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | asAlgebraHom_of | null |
@[nolint unusedArguments]
asModule (_ : Representation k G V) :=
V
deriving AddCommMonoid, Module k | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | asModule | If `ρ : Representation k G V`, then `ρ.asModule` is a type synonym for `V`,
which we equip with an instance `Module (MonoidAlgebra k G) ρ.asModule`.
You should use `asModuleEquiv : ρ.asModule ≃+ V` to translate terms. |
asModuleEquiv : ρ.asModule ≃ₗ[k] V :=
LinearEquiv.refl _ _
@[simp] | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | asModuleEquiv | A `k`-linear representation of `G` on `V` can be thought of as
a module over `MonoidAlgebra k G`.
-/
noncomputable instance : Module (MonoidAlgebra k G) ρ.asModule :=
Module.compHom V (asAlgebraHom ρ).toRingHom
/-- The additive equivalence from the `Module (MonoidAlgebra k G)` to the original vector space
of the rep... |
asModuleEquiv_map_smul (r : MonoidAlgebra k G) (x : ρ.asModule) :
ρ.asModuleEquiv (r • x) = ρ.asAlgebraHom r (ρ.asModuleEquiv x) :=
rfl | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | asModuleEquiv_map_smul | null |
asModuleEquiv_symm_map_smul (r : k) (x : V) :
ρ.asModuleEquiv.symm (r • x) = algebraMap k (MonoidAlgebra k G) r • ρ.asModuleEquiv.symm x := by
rw [LinearEquiv.symm_apply_eq]
simp
@[simp] | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | asModuleEquiv_symm_map_smul | null |
asModuleEquiv_symm_map_rho (g : G) (x : V) :
ρ.asModuleEquiv.symm (ρ g x) = MonoidAlgebra.of k G g • ρ.asModuleEquiv.symm x := by
rw [LinearEquiv.symm_apply_eq]
simp | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | asModuleEquiv_symm_map_rho | null |
noncomputable ofModule' (M : Type*) [AddCommMonoid M] [Module k M]
[Module (MonoidAlgebra k G) M] [IsScalarTower k (MonoidAlgebra k G) M] : Representation k G M :=
(MonoidAlgebra.lift k G (M →ₗ[k] M)).symm (Algebra.lsmul k k M) | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | ofModule' | Build a `Representation k G M` from a `[Module (MonoidAlgebra k G) M]`.
This version is not always what we want, as it relies on an existing `[Module k M]`
instance, along with a `[IsScalarTower k (MonoidAlgebra k G) M]` instance.
We remedy this below in `ofModule`
(with the tradeoff that the representation is define... |
noncomputable ofModule : Representation k G (RestrictScalars k (MonoidAlgebra k G) M) :=
(MonoidAlgebra.lift k G
(RestrictScalars k (MonoidAlgebra k G) M →ₗ[k]
RestrictScalars k (MonoidAlgebra k G) M)).symm
(RestrictScalars.lsmul k (MonoidAlgebra k G) M)
/-! | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | ofModule | Build a `Representation` from a `[Module (MonoidAlgebra k G) M]`.
Note that the representation is built on `restrictScalars k (MonoidAlgebra k G) M`,
rather than on `M` itself. |
@[simp]
ofModule_asAlgebraHom_apply_apply (r : MonoidAlgebra k G)
(m : RestrictScalars k (MonoidAlgebra k G) M) :
((ofModule M).asAlgebraHom r) m =
(RestrictScalars.addEquiv _ _ _).symm (r • RestrictScalars.addEquiv _ _ _ m) := by
apply MonoidAlgebra.induction_on r
· intro g
simp only [one_smul, M... | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | ofModule_asAlgebraHom_apply_apply | null |
ofModule_asModule_act (g : G) (x : RestrictScalars k (MonoidAlgebra k G) ρ.asModule) :
ofModule ρ.asModule g x =
(RestrictScalars.addEquiv _ _ _).symm
(ρ.asModuleEquiv.symm (ρ g (ρ.asModuleEquiv (RestrictScalars.addEquiv _ _ _ x)))) := by
apply_fun RestrictScalars.addEquiv _ _ ρ.asModule using
(... | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | ofModule_asModule_act | null |
smul_ofModule_asModule (r : MonoidAlgebra k G) (m : (ofModule M).asModule) :
(RestrictScalars.addEquiv k _ _) ((ofModule M).asModuleEquiv (r • m)) =
r • (RestrictScalars.addEquiv k _ _) ((ofModule M).asModuleEquiv (G := G) m) := by
dsimp
simp only [AddEquiv.apply_symm_apply, ofModule_asAlgebraHom_apply_ap... | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | smul_ofModule_asModule | null |
@[simp]
single_smul (t : k) (g : G) (v : ρ.asModule) :
MonoidAlgebra.single (g : G) t • v = t • ρ g (ρ.asModuleEquiv v) := by
rw [← LinearMap.smul_apply, ← asAlgebraHom_single, ← asModuleEquiv_map_smul]
rfl | lemma | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | single_smul | null |
norm : Module.End k V := ∑ g : G, ρ g
@[simp] | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | norm | Given a representation `(V, ρ)` of a finite group `G`, `norm ρ` is the linear map `V →ₗ[k] V`
defined by `x ↦ ∑ ρ g x` for `g` in `G`. |
norm_comp_self (g : G) : norm ρ ∘ₗ ρ g = norm ρ := by
ext
simpa [norm] using Fintype.sum_bijective (· * g) (Group.mulRight_bijective g) _ _ <| by simp
@[simp] | lemma | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | norm_comp_self | null |
norm_self_apply (g : G) (x : V) : norm ρ (ρ g x) = norm ρ x :=
LinearMap.ext_iff.1 (norm_comp_self _ _) x
@[simp] | lemma | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | norm_self_apply | null |
self_comp_norm (g : G) : ρ g ∘ₗ norm ρ = norm ρ := by
ext
simpa [norm] using Fintype.sum_bijective (g * ·) (Group.mulLeft_bijective g) _ _ <| by simp
@[simp] | lemma | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | self_comp_norm | null |
self_norm_apply (g : G) (x : V) : ρ g (norm ρ x) = norm ρ x :=
LinearMap.ext_iff.1 (self_comp_norm _ _) x | lemma | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | self_norm_apply | null |
@[simps]
subrepresentation (W : Submodule k V) (le_comap : ∀ g, W ≤ W.comap (ρ g)) :
Representation k G W where
toFun g := (ρ g).restrict <| le_comap g
map_one' := by ext; simp
map_mul' _ _ := by ext; simp | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | subrepresentation | Given a `k`-linear `G`-representation `(V, ρ)`, this is the representation defined by
restricting `ρ` to a `G`-invariant `k`-submodule of `V`. |
@[simps]
quotient (W : Submodule k V) (le_comap : ∀ g, W ≤ W.comap (ρ g)) :
Representation k G (V ⧸ W) where
toFun g := Submodule.mapQ _ _ (ρ g) <| le_comap g
map_one' := by ext; simp
map_mul' _ _ := by ext; simp | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | quotient | Given a `k`-linear `G`-representation `(V, ρ)` and a `G`-invariant `k`-submodule `W ≤ V`, this
is the representation induced on `V ⧸ W` by `ρ`. |
apply_eq_of_coe_eq [IsTrivial (ρ.comp S.subtype)] (g h : G) (hgh : (g : G ⧸ S) = h) :
ρ g = ρ h := by
ext x
apply (ρ.apply_bijective g⁻¹).1
simpa [← Module.End.mul_apply, ← map_mul, -isTrivial_def] using
(congr($(isTrivial_def (ρ.comp S.subtype) ⟨g⁻¹ * h, QuotientGroup.eq.1 hgh⟩) x)).symm
variable [S.Norm... | lemma | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | apply_eq_of_coe_eq | null |
ofQuotient [IsTrivial (ρ.comp S.subtype)] :
Representation k (G ⧸ S) V :=
(QuotientGroup.con S).lift ρ <| by
rintro x y ⟨⟨z, hz⟩, rfl⟩
ext w
change ρ (_ * z.unop) _ = _
exact congr($(apply_eq_of_coe_eq ρ S _ _ (by simp_all)) w)
@[simp] | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | ofQuotient | Given a normal subgroup `S ≤ G`, a `G`-representation `ρ` which is trivial on `S` factors
through `G ⧸ S`. |
ofQuotient_coe_apply [IsTrivial (ρ.comp S.subtype)] (g : G) (x : V) :
ofQuotient ρ S (g : G ⧸ S) x = ρ g x :=
rfl | lemma | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | ofQuotient_coe_apply | null |
apply_sub_id_partialSum_eq (n : ℕ) (g : G) (x : V) :
(ρ g - LinearMap.id (R := k) (M := V)) ((Fin.last _).partialSum
(fun (j : Fin (n + 1)) => ρ (g ^ (j : ℕ)) x)) = ρ (g ^ (n + 1)) x - x := by
induction n with
| zero => simp [Fin.partialSum]
| succ n h =>
have : Fin.init (fun (j : Fin (n + 2)) => ρ ... | lemma | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | apply_sub_id_partialSum_eq | null |
noncomputable ofMulAction : Representation k G (H →₀ k) where
toFun g := Finsupp.lmapDomain k k (g • ·)
map_one' := by
ext x y
simp
map_mul' x y := by
ext z w
simp [mul_smul] | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | ofMulAction | A `G`-action on `H` induces a representation `G →* End(k[H])` in the natural way. |
noncomputable leftRegular := ofMulAction k G G | abbrev | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | leftRegular | The natural `k`-linear `G`-representation on `k[G]` induced by left multiplication in `G`. |
noncomputable diagonal (n : ℕ) := ofMulAction k G (Fin n → G)
variable {k G H} | abbrev | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | diagonal | The natural `k`-linear `G`-representation on `k[Gⁿ]` induced by left multiplication in `G`. |
ofMulAction_def (g : G) : ofMulAction k G H g = Finsupp.lmapDomain k k (g • ·) :=
rfl
@[simp] | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | ofMulAction_def | null |
ofMulAction_single (g : G) (x : H) (r : k) :
ofMulAction k G H g (Finsupp.single x r) = Finsupp.single (g • x) r :=
Finsupp.mapDomain_single | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | ofMulAction_single | null |
ofDistribMulAction : Representation k G A where
toFun := fun m =>
{ DistribMulAction.toAddMonoidEnd G A m with
map_smul' := smul_comm _ }
map_one' := by ext; exact one_smul _ _
map_mul' := by intros; ext; exact mul_smul _ _ _
variable {k G A}
@[simp] theorem ofDistribMulAction_apply_apply (g : G) (a : A... | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | ofDistribMulAction | Turns a `k`-module `A` with a compatible `DistribMulAction` of a monoid `G` into a
`k`-linear `G`-representation on `A`. |
norm_ofDistribMulAction_eq {G : Type*} [Group G] [Fintype G]
[DistribMulAction G A] [SMulCommClass G k A] (x : A) :
(ofDistribMulAction k G A).norm x = ∑ g : G, g • x := by
simp [norm] | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | norm_ofDistribMulAction_eq | null |
ofMulDistribMulAction : Representation ℤ M (Additive G) :=
(addMonoidEndRingEquivInt (Additive G) : AddMonoid.End (Additive G) →* _).comp
((monoidEndToAdditive G : _ →* _).comp (MulDistribMulAction.toMonoidEnd M G))
@[simp] theorem ofMulDistribMulAction_apply_apply (g : M) (a : Additive G) :
ofMulDistribMulAc... | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | ofMulDistribMulAction | Turns a `CommGroup` `G` with a `MulDistribMulAction` of a monoid `M` into a
`ℤ`-linear `M`-representation on `Additive G`. |
norm_ofMulDistribMulAction_eq {G M : Type} [Group G] [Fintype G]
[CommGroup M] [MulDistribMulAction G M] (x : Additive M) :
Additive.toMul ((ofMulDistribMulAction G M).norm x) =
∏ g : G, g • Additive.toMul x := by
simp [norm] | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | norm_ofMulDistribMulAction_eq | null |
@[simp]
ofMulAction_apply {H : Type*} [MulAction G H] (g : G) (f : H →₀ k) (h : H) :
ofMulAction k G H g f h = f (g⁻¹ • h) := by
conv_lhs => rw [← smul_inv_smul g h]
let h' := g⁻¹ • h
change ofMulAction k G H g f (g • h') = f h'
have hg : Function.Injective (g • · : H → H) := by
intro h₁ h₂
simp
s... | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | ofMulAction_apply | null |
ofMulAction_self_smul_eq_mul (x : MonoidAlgebra k G) (y : (ofMulAction k G G).asModule) :
x • y = (x * y : MonoidAlgebra k G) := by
induction x using MonoidAlgebra.induction_on with
| hM g =>
change asAlgebraHom (ofMulAction k G G) _ _ = _
ext
simp [(MonoidAlgebra.single_mul_apply)]
| hadd x y hx ... | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | ofMulAction_self_smul_eq_mul | null |
@[simps]
noncomputable ofMulActionSelfAsModuleEquiv :
(ofMulAction k G G).asModule ≃ₗ[MonoidAlgebra k G] MonoidAlgebra k G :=
{ (asModuleEquiv _).toAddEquiv with map_smul' := ofMulAction_self_smul_eq_mul } | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | ofMulActionSelfAsModuleEquiv | If we equip `k[G]` with the `k`-linear `G`-representation induced by the left regular action of
`G` on itself, the resulting object is isomorphic as a `k[G]`-module to `k[G]` with its natural
`k[G]`-module structure. |
asGroupHom : G →* Units (V →ₗ[k] V) :=
MonoidHom.toHomUnits ρ | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | asGroupHom | When `G` is a group, a `k`-linear representation of `G` on `V` can be thought of as
a group homomorphism from `G` into the invertible `k`-linear endomorphisms of `V`. |
asGroupHom_apply (g : G) : ↑(asGroupHom ρ g) = ρ g := by
simp only [asGroupHom, MonoidHom.coe_toHomUnits] | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | asGroupHom_apply | null |
leftRegular_norm_apply :
(leftRegular k G).norm =
(LinearMap.lsmul k _).flip ((leftRegular k G).norm (single 1 1)) ∘ₗ
linearCombination _ (fun _ => 1) := by
ext i : 2
simpa [Representation.norm] using Finset.sum_bijective _
(Group.mulRight_bijective i) (by simp_all) (by simp_all) | lemma | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | leftRegular_norm_apply | null |
leftRegular_norm_eq_zero_iff (x : G →₀ k) :
(leftRegular k G).norm x = 0 ↔ x.linearCombination k (fun _ => (1 : k)) = 0 := by
rw [leftRegular_norm_apply]
constructor
· intro h
simpa [norm, Representation.norm] using Finsupp.ext_iff.1 h 1
· intro h
ext
simp_all | lemma | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | leftRegular_norm_eq_zero_iff | null |
ker_leftRegular_norm_eq :
LinearMap.ker (leftRegular k G).norm =
LinearMap.ker (linearCombination k (fun _ => (1 : k))) := by
ext
exact leftRegular_norm_eq_zero_iff _ | lemma | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | ker_leftRegular_norm_eq | null |
apply_eq_of_leftRegular_eq_of_generator (g : G) (hg : ∀ x, x ∈ Subgroup.zpowers g)
(x : G →₀ k) (hx : leftRegular k G g x = x) (γ : G) :
x γ = x g := by
rcases hg γ with ⟨i, rfl⟩
induction i with
| zero =>
simpa using (Finsupp.ext_iff.1 hx g)
| succ n h =>
simpa [← h, zpow_natCast, zpow_add_one,... | lemma | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | apply_eq_of_leftRegular_eq_of_generator | null |
@[simps]
noncomputable directSum : Representation k G (⨁ i, V i) where
toFun g := DirectSum.lmap (fun _ => ρ _ g)
map_one' := by ext; simp
map_mul' g h := by ext; simp | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | directSum | Given representations of `G` on a family `V i` indexed by `i`, there is a
natural representation of `G` on their direct sum `⨁ i, V i`. |
@[simps!]
noncomputable prod : Representation k G (V × W) where
toFun g := (ρV g).prodMap (ρW g)
map_one' := by simp
map_mul' g h := by simp [prodMap_mul] | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | prod | Given representations of `G` on `V` and `W`, there is a natural representation of `G` on their
product `V × W`. |
noncomputable tprod : Representation k G (V ⊗[k] W) where
toFun g := TensorProduct.map (ρV g) (ρW g)
map_one' := by simp only [map_one, TensorProduct.map_one]
map_mul' g h := by simp only [map_mul, TensorProduct.map_mul]
local notation ρV " ⊗ " ρW => tprod ρV ρW
@[simp] | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | tprod | Given representations of `G` on `V` and `W`, there is a natural representation of `G` on their
tensor product `V ⊗[k] W`. |
tprod_apply (g : G) : (ρV ⊗ ρW) g = TensorProduct.map (ρV g) (ρW g) :=
rfl | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | tprod_apply | null |
smul_tprod_one_asModule (r : MonoidAlgebra k G) (x : V) (y : W) :
r • (show (ρV.tprod 1).asModule from x ⊗ₜ y) = (r • show ρV.asModule from x) ⊗ₜ y := by
change asAlgebraHom (ρV ⊗ 1) _ _ = asAlgebraHom ρV _ _ ⊗ₜ _
simp only [asAlgebraHom_def, MonoidAlgebra.lift_apply, tprod_apply, MonoidHom.one_apply,
Linea... | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | smul_tprod_one_asModule | null |
smul_one_tprod_asModule (r : MonoidAlgebra k G) (x : V) (y : W) :
r • (show (1 ⊗ ρW).asModule from x ⊗ₜ y) = x ⊗ₜ (r • show ρW.asModule from y) := by
change asAlgebraHom (1 ⊗ ρW) _ _ = _ ⊗ₜ asAlgebraHom ρW _ _
simp only [asAlgebraHom_def, MonoidAlgebra.lift_apply, tprod_apply, MonoidHom.one_apply,
LinearMap... | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | smul_one_tprod_asModule | null |
linHom : Representation k G (V →ₗ[k] W) where
toFun g :=
{ toFun := fun f => ρW g ∘ₗ f ∘ₗ ρV g⁻¹
map_add' := fun f₁ f₂ => by simp_rw [add_comp, comp_add]
map_smul' := fun r f => by simp_rw [RingHom.id_apply, smul_comp, comp_smul] }
map_one' := ext fun x => by simp [Module.End.one_eq_id]
map_mul' g... | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | linHom | Given representations of `G` on `V` and `W`, there is a natural representation of `G` on the
module `V →ₗ[k] W`, where `G` acts by conjugation. |
linHom_apply (g : G) (f : V →ₗ[k] W) : (linHom ρV ρW) g f = ρW g ∘ₗ f ∘ₗ ρV g⁻¹ :=
rfl | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | linHom_apply | null |
dual : Representation k G (Module.Dual k V) where
toFun g :=
{ toFun := fun f => f ∘ₗ ρV g⁻¹
map_add' := fun f₁ f₂ => by simp only [add_comp]
map_smul' := fun r f => by
ext
simp only [coe_comp, Function.comp_apply, smul_apply, RingHom.id_apply] }
map_one' := by ext; simp
map_mul' g... | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | dual | The dual of a representation `ρ` of `G` on a module `V`, given by `(dual ρ) g f = f ∘ₗ (ρ g⁻¹)`,
where `f : Module.Dual k V`. |
dual_apply (g : G) : (dual ρV) g = Module.Dual.transpose (R := k) (ρV g⁻¹) :=
rfl | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | dual_apply | null |
dualTensorHom_comm (g : G) :
dualTensorHom k V W ∘ₗ TensorProduct.map (ρV.dual g) (ρW g) =
(linHom ρV ρW) g ∘ₗ dualTensorHom k V W := by
ext; simp [Module.Dual.transpose_apply] | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | dualTensorHom_comm | Given $k$-modules $V, W$, there is a homomorphism $φ : V^* ⊗ W → Hom_k(V, W)$
(implemented by `dualTensorHom` in `Mathlib/LinearAlgebra/Contraction.lean`).
Given representations of $G$ on $V$ and $W$,there are representations of $G$ on $V^* ⊗ W$ and on
$Hom_k(V, W)$.
This lemma says that $φ$ is $G$-linear. |
@[simps -isSimp]
noncomputable finsupp (α : Type*) :
Representation k G (α →₀ A) where
toFun g := lsum k fun i => (lsingle i).comp (ρ g)
map_one' := lhom_ext (fun _ _ => by simp)
map_mul' _ _ := lhom_ext (fun _ _ => by simp)
@[simp] | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | finsupp | The representation on `α →₀ A` defined pointwise by a representation on `A`. |
finsupp_single (g : G) (x : α) (a : A) :
ρ.finsupp α g (single x a) = single x (ρ g a) := by
simp [finsupp_apply] | lemma | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | finsupp_single | null |
noncomputable free (k G : Type*) [CommSemiring k] [Monoid G] (α : Type*) :
Representation k G (α →₀ G →₀ k) :=
finsupp (leftRegular k G) α | abbrev | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | free | The representation on `α →₀ k[G]` defined pointwise by the left regular representation. |
free_single_single (g h : G) (i : α) (r : k) :
free k G α g (single i (single h r)) = single i (single (g * h) r) := by
simp
variable (k G) (α : Type*) | lemma | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | free_single_single | null |
noncomputable finsuppLEquivFreeAsModule :
(α →₀ MonoidAlgebra k G) ≃ₗ[MonoidAlgebra k G] (free k G α).asModule :=
{ AddEquiv.refl _ with
map_smul' _ x := by
simp only [AddEquiv.toEquiv_eq_coe, Equiv.toFun_as_coe, EquivLike.coe_coe,
AddEquiv.refl_apply, RingHom.id_apply]
induction x using F... | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | finsuppLEquivFreeAsModule | The free `k[G]`-module on a type `α` is isomorphic to the representation `free k G α`. |
noncomputable freeAsModuleBasis :
Basis α (MonoidAlgebra k G) (free k G α).asModule where
repr := (finsuppLEquivFreeAsModule k G α).symm | def | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | freeAsModuleBasis | `α` gives a `k[G]`-basis of the representation `free k G α`. |
free_asModule_free :
Module.Free (MonoidAlgebra k G) (free k G α).asModule :=
Module.Free.of_basis (freeAsModuleBasis k G α) | theorem | RepresentationTheory | [
"Mathlib.LinearAlgebra.Contraction",
"Mathlib.Algebra.Group.Equiv.TypeTags"
] | Mathlib/RepresentationTheory/Basic.lean | free_asModule_free | null |
character (V : FDRep k G) (g : G) :=
LinearMap.trace k V (V.ρ g) | def | RepresentationTheory | [
"Mathlib.RepresentationTheory.FDRep",
"Mathlib.LinearAlgebra.Trace",
"Mathlib.RepresentationTheory.Invariants"
] | Mathlib/RepresentationTheory/Character.lean | character | The character of a representation `V : FDRep k G` is the function associating to `g : G` the
trace of the linear map `V.ρ g`. |
char_mul_comm (V : FDRep k G) (g : G) (h : G) :
V.character (h * g) = V.character (g * h) := by simp only [trace_mul_comm, character, map_mul]
@[simp] | theorem | RepresentationTheory | [
"Mathlib.RepresentationTheory.FDRep",
"Mathlib.LinearAlgebra.Trace",
"Mathlib.RepresentationTheory.Invariants"
] | Mathlib/RepresentationTheory/Character.lean | char_mul_comm | null |
char_one (V : FDRep k G) : V.character 1 = Module.finrank k V := by
simp only [character, map_one, trace_one] | theorem | RepresentationTheory | [
"Mathlib.RepresentationTheory.FDRep",
"Mathlib.LinearAlgebra.Trace",
"Mathlib.RepresentationTheory.Invariants"
] | Mathlib/RepresentationTheory/Character.lean | char_one | null |
@[simp]
char_tensor (V W : FDRep k G) : (V ⊗ W).character = V.character * W.character := by
ext g; convert trace_tensorProduct' (V.ρ g) (W.ρ g) | theorem | RepresentationTheory | [
"Mathlib.RepresentationTheory.FDRep",
"Mathlib.LinearAlgebra.Trace",
"Mathlib.RepresentationTheory.Invariants"
] | Mathlib/RepresentationTheory/Character.lean | char_tensor | The character is multiplicative under the tensor product. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.