File: Mathlib/Algebra/Algebra/Tower.lean

full_name: Algebra.lsmul
code: /-- The `R`-algebra morphism `A → End (M)` corresponding to the representation of the algebra `A`
on the `B`-module `M`.

This is a stronger version of `DistribMulAction.toLinearMap`, and could also have been
called `Algebra.toModuleEnd`.

The typeclasses correspond to the situation where the types act on each other as
```
R ----→ B
| ⟍     |
|   ⟍   |
↓     ↘ ↓
A ----→ M
```
where the diagram commutes, the action by `R` commutes with everything, and the action by `A` and
`B` on `M` commute.

Typically this is most useful with `B = R` as `Algebra.lsmul R R A : A →ₐ[R] Module.End R M`.
However this can be used to get the fact that left-multiplication by `A` is right `A`-linear, and
vice versa, as
```lean
example : A →ₐ[R] Module.End Aᵐᵒᵖ A := Algebra.lsmul R Aᵐᵒᵖ A
example : Aᵐᵒᵖ →ₐ[R] Module.End A A := Algebra.lsmul R A A
```
respectively; though `LinearMap.mulLeft` and `LinearMap.mulRight` can also be used here.
-/
def lsmul : A →ₐ[R] Module.End B M 
goal: A →ₐ[R] Module.End B M

full_name: Algebra.lsmul_coe
code: @[simp]
theorem lsmul_coe (a : A) : (lsmul R B M a : M → M) = (a • ·) 
goal: ⇑((Algebra.lsmul R B M) a) = fun x => a • x

full_name: IsScalarTower.algebraMap_smul
code: theorem algebraMap_smul [SMul R M] [IsScalarTower R A M] (r : R) (x : M) :
    algebraMap R A r • x = r • x 
goal: (algebraMap R A) r • x = r • x

full_name: IsScalarTower.of_algebraMap_smul
code: theorem of_algebraMap_smul [SMul R M] (h : ∀ (r : R) (x : M), algebraMap R A r • x = r • x) :
    IsScalarTower R A M 
goal: IsScalarTower R A M

full_name: IsScalarTower.of_compHom
code: theorem of_compHom : letI := MulAction.compHom M (algebraMap R A : R →* A); IsScalarTower R A M 
goal: IsScalarTower R A M

full_name: IsScalarTower.of_algebraMap_eq
code: theorem of_algebraMap_eq [Algebra R A]
    (h : ∀ x, algebraMap R A x = algebraMap S A (algebraMap R S x)) : IsScalarTower R S A 
goal: IsScalarTower R S A

full_name: IsScalarTower.of_algebraMap_eq'
code: /-- See note [partially-applied ext lemmas]. -/
theorem of_algebraMap_eq' [Algebra R A]
    (h : algebraMap R A = (algebraMap S A).comp (algebraMap R S)) : IsScalarTower R S A 
goal: IsScalarTower R S A

full_name: IsScalarTower.algebraMap_eq
code: theorem algebraMap_eq : algebraMap R A = (algebraMap S A).comp (algebraMap R S) 
goal: algebraMap R A = (algebraMap S A).comp (algebraMap R S)

full_name: IsScalarTower.algebraMap_apply
code: theorem algebraMap_apply (x : R) : algebraMap R A x = algebraMap S A (algebraMap R S x) 
goal: (algebraMap R A) x = (algebraMap S A) ((algebraMap R S) x)

full_name: IsScalarTower.Algebra.ext
code: @[ext]
theorem Algebra.ext {S : Type u} {A : Type v} [CommSemiring S] [Semiring A] (h1 h2 : Algebra S A)
    (h : ∀ (r : S) (x : A), (by have I := h1; exact r • x) = r • x) : h1 = h2 
goal: h1 = h2

full_name: IsScalarTower.toAlgHom
code: /-- In a tower, the canonical map from the middle element to the top element is an
algebra homomorphism over the bottom element. -/
def toAlgHom : S →ₐ[R] A 
goal: S →ₐ[R] A

full_name: IsScalarTower.toAlgHom_apply
code: theorem toAlgHom_apply (y : S) : toAlgHom R S A y = algebraMap S A y 
goal: (IsScalarTower.toAlgHom R S A) y = (algebraMap S A) y

full_name: IsScalarTower.coe_toAlgHom
code: @[simp]
theorem coe_toAlgHom : ↑(toAlgHom R S A) = algebraMap S A 
goal: ↑(IsScalarTower.toAlgHom R S A) = algebraMap S A

full_name: IsScalarTower.coe_toAlgHom'
code: @[simp]
theorem coe_toAlgHom' : (toAlgHom R S A : S → A) = algebraMap S A 
goal: ⇑(IsScalarTower.toAlgHom R S A) = ⇑(algebraMap S A)

full_name: AlgHom.map_algebraMap
code: @[simp]
theorem _root_.AlgHom.map_algebraMap (f : A →ₐ[S] B) (r : R) :
    f (algebraMap R A r) = algebraMap R B r 
goal: f ((algebraMap R A) r) = (algebraMap R B) r

full_name: AlgHom.comp_algebraMap_of_tower
code: @[simp]
theorem _root_.AlgHom.comp_algebraMap_of_tower (f : A →ₐ[S] B) :
    (f : A →+* B).comp (algebraMap R A) = algebraMap R B 
goal: (↑f).comp (algebraMap R A) = algebraMap R B

full_name: IsScalarTower.subsemiring
code: instance (priority := 999) subsemiring (U : Subsemiring S) : IsScalarTower U S A 
goal: IsScalarTower (↥U) S A

full_name: IsScalarTower.of_algHom
code: instance (priority := 999) of_algHom {R A B : Type*} [CommSemiring R] [CommSemiring A]
    [CommSemiring B] [Algebra R A] [Algebra R B] (f : A →ₐ[R] B) :
    @IsScalarTower R A B _ f.toRingHom.toAlgebra.toSMul _ 
goal: IsScalarTower R A B

full_name: AlgHom.restrictScalars
code: /-- R ⟶ S induces S-Alg ⥤ R-Alg -/
def restrictScalars (f : A →ₐ[S] B) : A →ₐ[R] B 
goal: A →ₐ[R] B

full_name: AlgHom.restrictScalars_apply
code: theorem restrictScalars_apply (f : A →ₐ[S] B) (x : A) : f.restrictScalars R x = f x 
goal: (AlgHom.restrictScalars R f) x = f x

full_name: AlgHom.coe_restrictScalars
code: @[simp]
theorem coe_restrictScalars (f : A →ₐ[S] B) : (f.restrictScalars R : A →+* B) = f 
goal: ↑(AlgHom.restrictScalars R f) = ↑f

full_name: AlgHom.coe_restrictScalars'
code: @[simp]
theorem coe_restrictScalars' (f : A →ₐ[S] B) : (restrictScalars R f : A → B) = f 
goal: ⇑(AlgHom.restrictScalars R f) = ⇑f

full_name: AlgHom.restrictScalars_injective
code: theorem restrictScalars_injective :
    Function.Injective (restrictScalars R : (A →ₐ[S] B) → A →ₐ[R] B) 
goal: Function.Injective (AlgHom.restrictScalars R)

full_name: AlgEquiv.restrictScalars
code: /-- R ⟶ S induces S-Alg ⥤ R-Alg -/
def restrictScalars (f : A ≃ₐ[S] B) : A ≃ₐ[R] B 
goal: A ≃ₐ[R] B

full_name: AlgEquiv.restrictScalars_apply
code: theorem restrictScalars_apply (f : A ≃ₐ[S] B) (x : A) : f.restrictScalars R x = f x 
goal: (AlgEquiv.restrictScalars R f) x = f x

full_name: AlgEquiv.coe_restrictScalars
code: @[simp]
theorem coe_restrictScalars (f : A ≃ₐ[S] B) : (f.restrictScalars R : A ≃+* B) = f 
goal: ↑(AlgEquiv.restrictScalars R f) = ↑f

full_name: AlgEquiv.coe_restrictScalars'
code: @[simp]
theorem coe_restrictScalars' (f : A ≃ₐ[S] B) : (restrictScalars R f : A → B) = f 
goal: ⇑(AlgEquiv.restrictScalars R f) = ⇑f

full_name: AlgEquiv.restrictScalars_injective
code: theorem restrictScalars_injective :
    Function.Injective (restrictScalars R : (A ≃ₐ[S] B) → A ≃ₐ[R] B) 
goal: Function.Injective (AlgEquiv.restrictScalars R)

full_name: Submodule.restrictScalars_span
code: /-- If `A` is an `R`-algebra such that the induced morphism `R →+* A` is surjective, then the
`R`-module generated by a set `X` equals the `A`-module generated by `X`. -/
theorem restrictScalars_span (hsur : Function.Surjective (algebraMap R A)) (X : Set M) :
    restrictScalars R (span A X) = span R X 
goal: Submodule.restrictScalars R (Submodule.span A X) = Submodule.span R X

full_name: Submodule.coe_span_eq_span_of_surjective
code: theorem coe_span_eq_span_of_surjective (h : Function.Surjective (algebraMap R A)) (s : Set M) :
    (Submodule.span A s : Set M) = Submodule.span R s 
goal: ↑(Submodule.span A s) = ↑(Submodule.span R s)

full_name: Submodule.smul_mem_span_smul_of_mem
code: theorem smul_mem_span_smul_of_mem {s : Set S} {t : Set A} {k : S} (hks : k ∈ span R s) {x : A}
    (hx : x ∈ t) : k • x ∈ span R (s • t) 
goal: k • x ∈ Submodule.span R (s • t)

full_name: Submodule.span_smul_of_span_eq_top
code: theorem span_smul_of_span_eq_top {s : Set S} (hs : span R s = ⊤) (t : Set A) :
    span R (s • t) = (span S t).restrictScalars R 
goal: Submodule.span R (s • t) = Submodule.restrictScalars R (Submodule.span S t)

full_name: Submodule.smul_mem_span_smul'
code: theorem smul_mem_span_smul' {s : Set S} (hs : span R s = ⊤) {t : Set A} {k : S} {x : A}
    (hx : x ∈ span R (s • t)) : k • x ∈ span R (s • t) 
goal: k • x ∈ Submodule.span R (s • t)

full_name: Submodule.smul_mem_span_smul
code: theorem smul_mem_span_smul {s : Set S} (hs : span R s = ⊤) {t : Set A} {k : S} {x : A}
    (hx : x ∈ span R t) : k • x ∈ span R (s • t) 
goal: k • x ∈ Submodule.span R (s • t)

full_name: Submodule.span_algebraMap_image
code: /-- A variant of `Submodule.span_image` for `algebraMap`. -/
theorem span_algebraMap_image (a : Set R) :
    Submodule.span R (algebraMap R S '' a) = (Submodule.span R a).map (Algebra.linearMap R S) 
goal: Submodule.span R (⇑(algebraMap R S) '' a) = Submodule.map (Algebra.linearMap R S) (Submodule.span R a)

full_name: Submodule.span_algebraMap_image_of_tower
code: theorem span_algebraMap_image_of_tower {S T : Type*} [CommSemiring S] [Semiring T] [Module R S]
    [Algebra R T] [Algebra S T] [IsScalarTower R S T] (a : Set S) :
    Submodule.span R (algebraMap S T '' a) =
      (Submodule.span R a).map ((Algebra.linearMap S T).restrictScalars R) 
goal: Submodule.span R (⇑(algebraMap S T) '' a) = Submodule.map (↑R (Algebra.linearMap S T)) (Submodule.span R a)

full_name: Submodule.map_mem_span_algebraMap_image
code: theorem map_mem_span_algebraMap_image {S T : Type*} [CommSemiring S] [Semiring T] [Algebra R S]
    [Algebra R T] [Algebra S T] [IsScalarTower R S T] (x : S) (a : Set S)
    (hx : x ∈ Submodule.span R a) : algebraMap S T x ∈ Submodule.span R (algebraMap S T '' a) 
goal: (algebraMap S T) x ∈ Submodule.span R (⇑(algebraMap S T) '' a)

full_name: Algebra.lsmul_injective
code: theorem lsmul_injective [NoZeroSMulDivisors A M] {x : A} (hx : x ≠ 0) :
    Function.Injective (lsmul R B M x) 
goal: Function.Injective ⇑((Algebra.lsmul R B M) x)