Module docstring
{"# Extensionality of monoid homs from ℕ
"}
{"# Extensionality of monoid homs from ℕ
"}
ext_nat'
theorem
[AddZeroClass A] [AddMonoidHomClass F ℕ A] (f g : F) (h : f 1 = g 1) : f = g
lemma ext_nat' [AddZeroClass A] [AddMonoidHomClass F ℕ A] (f g : F) (h : f 1 = g 1) : f = g :=
DFunLike.ext f g <| by
intro n
induction n with
| zero => simp_rw [map_zero f, map_zero g]
| succ n ihn =>
simp [h, ihn]
AddMonoidHom.ext_nat
theorem
[AddZeroClass A] {f g : ℕ →+ A} : f 1 = g 1 → f = g
@[ext]
lemma AddMonoidHom.ext_nat [AddZeroClass A] {f g : ℕℕ →+ A} : f 1 = g 1 → f = g :=
ext_nat' f g
multiplesHom
definition
: M ≃ (ℕ →+ M)
/-- Additive homomorphisms from `ℕ` are defined by the image of `1`. -/
def multiplesHom : M ≃ (ℕ →+ M) where
toFun x :=
{ toFun := fun n ↦ n • x
map_zero' := zero_nsmul x
map_add' := fun _ _ ↦ add_nsmul _ _ _ }
invFun f := f 1
left_inv := one_nsmul
right_inv f := AddMonoidHom.ext_nat <| one_nsmul (f 1)
multiplesHom_apply
theorem
(x : M) (n : ℕ) : multiplesHom M x n = n • x
@[simp] lemma multiplesHom_apply (x : M) (n : ℕ) : multiplesHom M x n = n • x := rfl
multiplesHom_symm_apply
theorem
(f : ℕ →+ M) : (multiplesHom M).symm f = f 1
lemma multiplesHom_symm_apply (f : ℕℕ →+ M) : (multiplesHom M).symm f = f 1 := rfl
AddMonoidHom.apply_nat
theorem
(f : ℕ →+ M) (n : ℕ) : f n = n • f 1
lemma AddMonoidHom.apply_nat (f : ℕℕ →+ M) (n : ℕ) : f n = n • f 1 := by
rw [← multiplesHom_symm_apply, ← multiplesHom_apply, Equiv.apply_symm_apply]
powersHom
definition
: M ≃ (Multiplicative ℕ →* M)
/-- Monoid homomorphisms from `Multiplicative ℕ` are defined by the image
of `Multiplicative.ofAdd 1`. -/
@[to_additive existing]
def powersHom : M ≃ (Multiplicative ℕ →* M) :=
Additive.ofMul.trans <| (multiplesHom _).trans <| AddMonoidHom.toMultiplicative''
powersHom_apply
theorem
(x : M) (n : Multiplicative ℕ) : powersHom M x n = x ^ n.toAdd
@[to_additive existing (attr := simp)]
lemma powersHom_apply (x : M) (n : Multiplicative ℕ) :
powersHom M x n = x ^ n.toAdd := rfl
powersHom_symm_apply
theorem
(f : Multiplicative ℕ →* M) : (powersHom M).symm f = f (Multiplicative.ofAdd 1)
@[to_additive existing (attr := simp)]
lemma powersHom_symm_apply (f : MultiplicativeMultiplicative ℕ →* M) :
(powersHom M).symm f = f (Multiplicative.ofAdd 1) := rfl
MonoidHom.apply_mnat
theorem
(f : Multiplicative ℕ →* M) (n : Multiplicative ℕ) : f n = f (Multiplicative.ofAdd 1) ^ n.toAdd
@[to_additive existing AddMonoidHom.apply_nat]
lemma MonoidHom.apply_mnat (f : MultiplicativeMultiplicative ℕ →* M) (n : Multiplicative ℕ) :
f n = f (Multiplicative.ofAdd 1) ^ n.toAdd := by
rw [← powersHom_symm_apply, ← powersHom_apply, Equiv.apply_symm_apply]
MonoidHom.ext_mnat
theorem
⦃f g : Multiplicative ℕ →* M⦄ (h : f (Multiplicative.ofAdd 1) = g (Multiplicative.ofAdd 1)) : f = g
@[to_additive existing (attr := ext) AddMonoidHom.ext_nat]
lemma MonoidHom.ext_mnat ⦃f g : MultiplicativeMultiplicative ℕ →* M⦄
(h : f (Multiplicative.ofAdd 1) = g (Multiplicative.ofAdd 1)) : f = g :=
MonoidHom.ext fun n ↦ by rw [f.apply_mnat, g.apply_mnat, h]
multiplesAddHom
definition
: M ≃+ (ℕ →+ M)
/-- If `M` is commutative, `multiplesHom` is an additive equivalence. -/
def multiplesAddHom : M ≃+ (ℕ →+ M) where
__ := multiplesHom M
map_add' a b := AddMonoidHom.ext fun n ↦ by simp [nsmul_add]
multiplesAddHom_apply
theorem
(x : M) (n : ℕ) : multiplesAddHom M x n = n • x
@[simp] lemma multiplesAddHom_apply (x : M) (n : ℕ) : multiplesAddHom M x n = n • x := rfl
multiplesAddHom_symm_apply
theorem
(f : ℕ →+ M) : (multiplesAddHom M).symm f = f 1
@[simp] lemma multiplesAddHom_symm_apply (f : ℕℕ →+ M) : (multiplesAddHom M).symm f = f 1 := rfl
powersMulHom
definition
: M ≃* (Multiplicative ℕ →* M)
/-- If `M` is commutative, `powersHom` is a multiplicative equivalence. -/
@[to_additive existing]
def powersMulHom : M ≃* (Multiplicative ℕ →* M) where
__ := powersHom M
map_mul' a b := MonoidHom.ext fun n ↦ by simp [mul_pow]
powersMulHom_apply
theorem
(x : M) (n : Multiplicative ℕ) : powersMulHom M x n = x ^ n.toAdd
@[to_additive existing (attr := simp)]
lemma powersMulHom_apply (x : M) (n : Multiplicative ℕ) : powersMulHom M x n = x ^ n.toAdd := rfl
powersMulHom_symm_apply
theorem
(f : Multiplicative ℕ →* M) : (powersMulHom M).symm f = f (ofAdd 1)
@[to_additive existing (attr := simp)]
lemma powersMulHom_symm_apply (f : MultiplicativeMultiplicative ℕ →* M) : (powersMulHom M).symm f = f (ofAdd 1) :=
rfl