File: Mathlib/RingTheory/AlgebraTower.lean

full_name: IsScalarTower.Invertible.algebraTower
code: /-- Suppose that `R → S → A` is a tower of algebras.
If an element `r : R` is invertible in `S`, then it is invertible in `A`. -/
def Invertible.algebraTower (r : R) [Invertible (algebraMap R S r)] :
    Invertible (algebraMap R A r) 
goal: Invertible ((algebraMap R A) r)

full_name: IsScalarTower.invertibleAlgebraCoeNat
code: /-- A natural number that is invertible when coerced to `R` is also invertible
when coerced to any `R`-algebra. -/
def invertibleAlgebraCoeNat (n : ℕ) [inv : Invertible (n : R)] : Invertible (n : A) 
goal: Invertible ↑n

full_name: Basis.algebraMapCoeffs_repr_apply_toFun
code: /-- If `R` and `A` have a bijective `algebraMap R A` and act identically on `M`,
then a basis for `M` as `R`-module is also a basis for `M` as `R'`-module. -/
@[simps! repr_apply_support_val repr_apply_toFun]
noncomputable def Basis.algebraMapCoeffs : Basis ι A M 
goal: ∀ (a : M) (a_1 : ι), ((Basis.algebraMapCoeffs A b h).repr a) a_1 = (algebraMap R A) ((b.repr a) a_1)

full_name: Basis.algebraMapCoeffs
code: /-- If `R` and `A` have a bijective `algebraMap R A` and act identically on `M`,
then a basis for `M` as `R`-module is also a basis for `M` as `R'`-module. -/
@[simps! repr_apply_support_val repr_apply_toFun]
noncomputable def Basis.algebraMapCoeffs : Basis ι A M 
goal: Basis ι A M

full_name: Basis.algebraMapCoeffs_repr_apply_support_val
code: /-- If `R` and `A` have a bijective `algebraMap R A` and act identically on `M`,
then a basis for `M` as `R`-module is also a basis for `M` as `R'`-module. -/
@[simps! repr_apply_support_val repr_apply_toFun]
noncomputable def Basis.algebraMapCoeffs : Basis ι A M 
goal: ∀ (a : M),
  ((Basis.algebraMapCoeffs A b h).repr a).support.val =
    Multiset.filter (fun x => ¬(RingEquiv.ofBijective (algebraMap R A) h).symm.symm ((b.repr a) x) = 0)
      (b.repr a).support.val

full_name: Basis.algebraMapCoeffs_apply
code: theorem Basis.algebraMapCoeffs_apply (i : ι) : b.algebraMapCoeffs A h i = b i 
goal: (Basis.algebraMapCoeffs A b h) i = b i

full_name: Basis.coe_algebraMapCoeffs
code: @[simp]
theorem Basis.coe_algebraMapCoeffs : (b.algebraMapCoeffs A h : ι → M) = b 
goal: ⇑(Basis.algebraMapCoeffs A b h) = ⇑b

full_name: linearIndependent_smul
code: theorem linearIndependent_smul {ι : Type v₁} {b : ι → S} {ι' : Type w₁} {c : ι' → A}
    (hb : LinearIndependent R b) (hc : LinearIndependent S c) :
    LinearIndependent R fun p : ι × ι' => b p.1 • c p.2 
goal: LinearIndependent R fun p => b p.1 • c p.2

full_name: Basis.isScalarTower_of_nonempty
code: theorem Basis.isScalarTower_of_nonempty {ι} [Nonempty ι] (b : Basis ι S A) : IsScalarTower R S S 
goal: IsScalarTower R S S

full_name: Basis.isScalarTower_finsupp
code: theorem Basis.isScalarTower_finsupp {ι} (b : Basis ι S A) : IsScalarTower R S (ι →₀ S) 
goal: IsScalarTower R S (ι →₀ S)

full_name: Basis.smulTower
code: /-- `Basis.smulTower (b : Basis ι R S) (c : Basis ι S A)` is the `R`-basis on `A`
where the `(i, j)`th basis vector is `b i • c j`. -/
noncomputable
def Basis.smulTower {ι : Type v₁} {ι' : Type w₁} (b : Basis ι R S) (c : Basis ι' S A) :
    Basis (ι × ι') R A 
goal: Basis (ι × ι') R A

full_name: Basis.smulTower_repr
code: @[simp]
theorem Basis.smulTower_repr {ι : Type v₁} {ι' : Type w₁}
    (b : Basis ι R S) (c : Basis ι' S A) (x ij) :
    (b.smulTower c).repr x ij = b.repr (c.repr x ij.2) ij.1 
goal: ((b.smulTower c).repr x) ij = (b.repr ((c.repr x) ij.2)) ij.1

full_name: Basis.smulTower_repr_mk
code: theorem Basis.smulTower_repr_mk {ι : Type v₁} {ι' : Type w₁} (b : Basis ι R S) (c : Basis ι' S A)
    (x i j) : (b.smulTower c).repr x (i, j) = b.repr (c.repr x j) i 
goal: ((b.smulTower c).repr x) (i, j) = (b.repr ((c.repr x) j)) i

full_name: Basis.smulTower_apply
code: @[simp]
theorem Basis.smulTower_apply {ι : Type v₁} {ι' : Type w₁}
    (b : Basis ι R S) (c : Basis ι' S A) (ij) :
    (b.smulTower c) ij = b ij.1 • c ij.2 
goal: (b.smulTower c) ij = b ij.1 • c ij.2

full_name: Basis.algebraMap_injective
code: theorem Basis.algebraMap_injective {ι : Type*} [NoZeroDivisors R] [Nontrivial S]
    (b : @Basis ι R S _ _ Algebra.toModule) : Function.Injective (algebraMap R S) 
goal: Function.Injective ⇑(algebraMap R S)

full_name: AlgHom.restrictDomain
code: /-- Restrict the domain of an `AlgHom`. -/
def AlgHom.restrictDomain : B →ₐ[A] D 
goal: B →ₐ[A] D

full_name: AlgHom.extendScalars
code: /-- Extend the scalars of an `AlgHom`. -/
def AlgHom.extendScalars : @AlgHom B C D _ _ _ _ (f.restrictDomain B).toRingHom.toAlgebra 
goal: C →ₐ[B] D

full_name: algHomEquivSigma
code: /-- `AlgHom`s from the top of a tower are equivalent to a pair of `AlgHom`s. -/
def algHomEquivSigma :
    (C →ₐ[A] D) ≃ Σf : B →ₐ[A] D, @AlgHom B C D _ _ _ _ f.toRingHom.toAlgebra 
goal: (C →ₐ[A] D) ≃ (f : B →ₐ[A] D) × (C →ₐ[B] D)