Module docstring
{"# Homomorphisms and group actions "}
{"# Homomorphisms and group actions "}
Function.Surjective.mulActionLeft
abbrev
{R S M : Type*} [Monoid R] [MulAction R M] [Monoid S] [SMul S M] (f : R →* S) (hf : Surjective f)
(hsmul : ∀ (c) (x : M), f c • x = c • x) : MulAction S M
/-- Push forward the action of `R` on `M` along a compatible surjective map `f : R →* S`.
See also `Function.Surjective.distribMulActionLeft` and `Function.Surjective.moduleLeft`.
-/
@[to_additive
"Push forward the action of `R` on `M` along a compatible surjective map `f : R →+ S`."]
abbrev Function.Surjective.mulActionLeft {R S M : Type*} [Monoid R] [MulAction R M] [Monoid S]
[SMul S M] (f : R →* S) (hf : Surjective f) (hsmul : ∀ (c) (x : M), f c • x = c • x) :
MulAction S M where
smul := (· • ·)
one_smul b := by rw [← f.map_one, hsmul, one_smul]
mul_smul := hf.forall₂.mpr fun a b x ↦ by simp only [← f.map_mul, hsmul, mul_smul]
MulAction.compHom
abbrev
[Monoid N] (g : N →* M) : MulAction N α
/-- A multiplicative action of `M` on `α` and a monoid homomorphism `N → M` induce
a multiplicative action of `N` on `α`.
See note [reducible non-instances]. -/
@[to_additive]
abbrev compHom [Monoid N] (g : N →* M) : MulAction N α where
smul := SMul.comp.smul g
one_smul _ := by simpa [(· • ·)] using MulAction.one_smul ..
mul_smul _ _ _ := by simpa [(· • ·)] using MulAction.mul_smul ..
MulAction.compHom_smul_def
theorem
{E F G : Type*} [Monoid E] [Monoid F] [MulAction F G] (f : E →* F) (a : E) (x : G) :
letI : MulAction E G := MulAction.compHom _ f
a • x = (f a) • x
@[to_additive]
lemma compHom_smul_def
{E F G : Type*} [Monoid E] [Monoid F] [MulAction F G] (f : E →* F) (a : E) (x : G) :
letI : MulAction E G := MulAction.compHom _ f
a • x = (f a) • x := rfl
MulAction.isPretransitive_compHom
theorem
{E F G : Type*} [Monoid E] [Monoid F] [MulAction F G] [IsPretransitive F G] {f : E →* F} (hf : Surjective f) :
letI : MulAction E G := MulAction.compHom _ f
IsPretransitive E G
/-- If an action is transitive, then composing this action with a surjective homomorphism gives
again a transitive action. -/
@[to_additive]
lemma isPretransitive_compHom {E F G : Type*} [Monoid E] [Monoid F] [MulAction F G]
[IsPretransitive F G] {f : E →* F} (hf : Surjective f) :
letI : MulAction E G := MulAction.compHom _ f
IsPretransitive E G := by
let _ : MulAction E G := MulAction.compHom _ f
refine ⟨fun x y ↦ ?_⟩
obtain ⟨m, rfl⟩ : ∃ m : F, m • x = y := exists_smul_eq F x y
obtain ⟨e, rfl⟩ : ∃ e, f e = m := hf m
exact ⟨e, rfl⟩
MulAction.IsPretransitive.of_compHom
theorem
{M N α : Type*} [Monoid M] [Monoid N] [MulAction N α] (f : M →* N)
[h :
letI := compHom α f;
IsPretransitive M α] :
IsPretransitive N α
@[to_additive]
lemma IsPretransitive.of_compHom {M N α : Type*} [Monoid M] [Monoid N] [MulAction N α]
(f : M →* N) [h : letI := compHom α f; IsPretransitive M α] : IsPretransitive N α :=
letI := compHom α f; h.of_smul_eq f rfl
MonoidHom.smulOneHom
definition
{M N} [Monoid M] [MulOneClass N] [MulAction M N] [IsScalarTower M N N] : M →* N
/-- If the multiplicative action of `M` on `N` is compatible with multiplication on `N`, then
`fun x ↦ x • 1` is a monoid homomorphism from `M` to `N`. -/
@[to_additive (attr := simps)
"If the additive action of `M` on `N` is compatible with addition on `N`, then
`fun x ↦ x +ᵥ 0` is an additive monoid homomorphism from `M` to `N`."]
def MonoidHom.smulOneHom {M N} [Monoid M] [MulOneClass N] [MulAction M N] [IsScalarTower M N N] :
M →* N where
toFun x := x • (1 : N)
map_one' := one_smul _ _
map_mul' x y := by rw [smul_one_mul, smul_smul]
monoidHomEquivMulActionIsScalarTower
definition
(M N) [Monoid M] [Monoid N] : (M →* N) ≃ { _inst : MulAction M N // IsScalarTower M N N }
/-- A monoid homomorphism between two monoids M and N can be equivalently specified by a
multiplicative action of M on N that is compatible with the multiplication on N. -/
@[to_additive
"A monoid homomorphism between two additive monoids M and N can be equivalently
specified by an additive action of M on N that is compatible with the addition on N."]
def monoidHomEquivMulActionIsScalarTower (M N) [Monoid M] [Monoid N] :
(M →* N) ≃ {_inst : MulAction M N // IsScalarTower M N N} where
toFun f := ⟨MulAction.compHom N f, SMul.comp.isScalarTower _⟩
invFun := fun ⟨_, _⟩ ↦ MonoidHom.smulOneHom
left_inv f := MonoidHom.ext fun m ↦ mul_one (f m)
right_inv := fun ⟨_, _⟩ ↦ Subtype.ext <| MulAction.ext <| funext₂ <| smul_one_smul N