File: Mathlib/RingTheory/Localization/Module.lean

full_name: span_eq_top_of_isLocalizedModule
code: theorem span_eq_top_of_isLocalizedModule {v : Set M} (hv : span R v = ⊤) :
    span Rₛ (f '' v) = ⊤ 
goal: Submodule.span Rₛ (⇑f '' v) = ⊤

full_name: LinearIndependent.of_isLocalizedModule
code: theorem LinearIndependent.of_isLocalizedModule {ι : Type*} {v : ι → M}
    (hv : LinearIndependent R v) : LinearIndependent Rₛ (f ∘ v) 
goal: LinearIndependent Rₛ (⇑f ∘ v)

full_name: LinearIndependent.localization
code: theorem LinearIndependent.localization {ι : Type*} {b : ι → M} (hli : LinearIndependent R b) :
    LinearIndependent Rₛ b 
goal: LinearIndependent Rₛ b

full_name: Basis.ofIsLocalizedModule
code: /-- If `M` has an `R`-basis, then localizing `M` at `S` has a basis over `R` localized at `S`. -/
noncomputable def Basis.ofIsLocalizedModule : Basis ι Rₛ Mₛ 
goal: Basis ι Rₛ Mₛ

full_name: Basis.ofIsLocalizedModule_apply
code: @[simp]
theorem Basis.ofIsLocalizedModule_apply (i : ι) : b.ofIsLocalizedModule Rₛ S f i = f (b i) 
goal: (Basis.ofIsLocalizedModule Rₛ S f b) i = f (b i)

full_name: Basis.ofIsLocalizedModule_repr_apply
code: @[simp]
theorem Basis.ofIsLocalizedModule_repr_apply (m : M) (i : ι) :
    ((b.ofIsLocalizedModule Rₛ S f).repr (f m)) i = algebraMap R Rₛ (b.repr m i) 
goal: ((Basis.ofIsLocalizedModule Rₛ S f b).repr (f m)) i = (algebraMap R Rₛ) ((b.repr m) i)

full_name: Basis.ofIsLocalizedModule_span
code: theorem Basis.ofIsLocalizedModule_span :
    span R (Set.range (b.ofIsLocalizedModule Rₛ S f)) = LinearMap.range f 
goal: Submodule.span R (Set.range ⇑(Basis.ofIsLocalizedModule Rₛ S f b)) = LinearMap.range f

full_name: LinearIndependent.localization_localization
code: theorem LinearIndependent.localization_localization {ι : Type*} {v : ι → A}
    (hv : LinearIndependent R v) : LinearIndependent Rₛ ((algebraMap A Aₛ) ∘ v) 
goal: LinearIndependent Rₛ (⇑(algebraMap A Aₛ) ∘ v)

full_name: span_eq_top_localization_localization
code: theorem span_eq_top_localization_localization {v : Set A} (hv : span R v = ⊤) :
    span Rₛ (algebraMap A Aₛ '' v) = ⊤ 
goal: Submodule.span Rₛ (⇑(algebraMap A Aₛ) '' v) = ⊤

full_name: Basis.localizationLocalization
code: /-- If `A` has an `R`-basis, then localizing `A` at `S` has a basis over `R` localized at `S`.

A suitable instance for `[Algebra A Aₛ]` is `localizationAlgebra`.
-/
noncomputable def Basis.localizationLocalization {ι : Type*} (b : Basis ι R A) : Basis ι Rₛ Aₛ 
goal: Basis ι Rₛ Aₛ

full_name: Basis.localizationLocalization_apply
code: @[simp]
theorem Basis.localizationLocalization_apply {ι : Type*} (b : Basis ι R A) (i) :
    b.localizationLocalization Rₛ S Aₛ i = algebraMap A Aₛ (b i) 
goal: (Basis.localizationLocalization Rₛ S Aₛ b) i = (algebraMap A Aₛ) (b i)

full_name: Basis.localizationLocalization_repr_algebraMap
code: @[simp]
theorem Basis.localizationLocalization_repr_algebraMap {ι : Type*} (b : Basis ι R A) (x i) :
    (b.localizationLocalization Rₛ S Aₛ).repr (algebraMap A Aₛ x) i =
      algebraMap R Rₛ (b.repr x i) 
goal: ((Basis.localizationLocalization Rₛ S Aₛ b).repr ((algebraMap A Aₛ) x)) i = (algebraMap R Rₛ) ((b.repr x) i)

full_name: Basis.localizationLocalization_span
code: theorem Basis.localizationLocalization_span {ι : Type*} (b : Basis ι R A) :
    Submodule.span R (Set.range (b.localizationLocalization Rₛ S Aₛ)) =
      LinearMap.range (IsScalarTower.toAlgHom R A Aₛ) 
goal: Submodule.span R (Set.range ⇑(Basis.localizationLocalization Rₛ S Aₛ b)) =
  LinearMap.range (IsScalarTower.toAlgHom R A Aₛ)

full_name: LinearIndependent.iff_fractionRing
code: theorem LinearIndependent.iff_fractionRing {ι : Type*} {b : ι → V} :
    LinearIndependent R b ↔ LinearIndependent K b 
goal: LinearIndependent R b ↔ LinearIndependent K b

full_name: LinearMap.extendScalarsOfIsLocalization
code: /-- An `R`-linear map between two `S⁻¹R`-modules is actually `S⁻¹R`-linear. -/
def LinearMap.extendScalarsOfIsLocalization (f : M →ₗ[R] N) : M →ₗ[A] N 
goal: M →ₗ[A] N

full_name: LinearMap.restrictScalars_extendScalarsOfIsLocalization
code: @[simp] lemma LinearMap.restrictScalars_extendScalarsOfIsLocalization (f : M →ₗ[R] N) :
    (f.extendScalarsOfIsLocalization S A).restrictScalars R = f 
goal: ↑R (LinearMap.extendScalarsOfIsLocalization S A f) = f

full_name: LinearMap.extendScalarsOfIsLocalization_apply
code: @[simp] lemma LinearMap.extendScalarsOfIsLocalization_apply (f : M →ₗ[A] N) :
    f.extendScalarsOfIsLocalization S A = f 
goal: LinearMap.extendScalarsOfIsLocalization S A (↑R f) = f

full_name: LinearMap.extendScalarsOfIsLocalization_apply'
code: @[simp] lemma LinearMap.extendScalarsOfIsLocalization_apply' (f : M →ₗ[R] N) (x : M) :
    (f.extendScalarsOfIsLocalization S A) x = f x 
goal: (LinearMap.extendScalarsOfIsLocalization S A f) x = f x