File: Mathlib/Algebra/Module/LocalizedModule.lean

full_name: LocalizedModule.r
code: /-- The equivalence relation on `M × S` where `(m1, s1) ≈ (m2, s2)` if and only if
for some (u : S), u * (s2 • m1 - s1 • m2) = 0-/
/- Porting note: We use small letter `r` since `R` is used for a ring. -/
def r (a b : M × S) : Prop 
goal: Prop

full_name: LocalizedModule.r.isEquiv
code: theorem r.isEquiv : IsEquiv _ (r S M) 
goal: IsEquiv (M × ↥S) (LocalizedModule.r S M)

full_name: LocalizedModule.r.setoid
code: instance r.setoid : Setoid (M × S) 
goal: Setoid (M × ↥S)

full_name: LocalizedModule
code: /-- If `S` is a multiplicative subset of a ring `R` and `M` an `R`-module, then
we can localize `M` by `S`.
-/
-- Porting note(#5171): @[nolint has_nonempty_instance]
def _root_.LocalizedModule : Type max u v 
goal: Type (max u v)

full_name: LocalizedModule.mk
code: /-- The canonical map sending `(m, s) ↦ m/s`-/
def mk (m : M) (s : S) : LocalizedModule S M 
goal: LocalizedModule S M

full_name: LocalizedModule.mk_eq
code: theorem mk_eq {m m' : M} {s s' : S} : mk m s = mk m' s' ↔ ∃ u : S, u • s' • m = u • s • m' 
goal: LocalizedModule.mk m s = LocalizedModule.mk m' s' ↔ ∃ u, u • s' • m = u • s • m'

full_name: LocalizedModule.induction_on
code: @[elab_as_elim, induction_eliminator, cases_eliminator]
theorem induction_on {β : LocalizedModule S M → Prop} (h : ∀ (m : M) (s : S), β (mk m s)) :
    ∀ x : LocalizedModule S M, β x 
goal: β x

full_name: LocalizedModule.induction_on₂
code: @[elab_as_elim]
theorem induction_on₂ {β : LocalizedModule S M → LocalizedModule S M → Prop}
    (h : ∀ (m m' : M) (s s' : S), β (mk m s) (mk m' s')) : ∀ x y, β x y 
goal: β x y

full_name: LocalizedModule.liftOn
code: /-- If `f : M × S → α` respects the equivalence relation `LocalizedModule.r`, then
`f` descents to a map `LocalizedModule M S → α`.
-/
def liftOn {α : Type*} (x : LocalizedModule S M) (f : M × S → α)
    (wd : ∀ (p p' : M × S), p ≈ p' → f p = f p') : α 
goal: α

full_name: LocalizedModule.liftOn_mk
code: theorem liftOn_mk {α : Type*} {f : M × S → α} (wd : ∀ (p p' : M × S), p ≈ p' → f p = f p')
    (m : M) (s : S) : liftOn (mk m s) f wd = f ⟨m, s⟩ 
goal: (LocalizedModule.mk m s).liftOn f wd = f (m, s)

full_name: LocalizedModule.liftOn₂
code: /-- If `f : M × S → M × S → α` respects the equivalence relation `LocalizedModule.r`, then
`f` descents to a map `LocalizedModule M S → LocalizedModule M S → α`.
-/
def liftOn₂ {α : Type*} (x y : LocalizedModule S M) (f : M × S → M × S → α)
    (wd : ∀ (p q p' q' : M × S), p ≈ p' → q ≈ q' → f p q = f p' q') : α 
goal: α

full_name: LocalizedModule.liftOn₂_mk
code: theorem liftOn₂_mk {α : Type*} (f : M × S → M × S → α)
    (wd : ∀ (p q p' q' : M × S), p ≈ p' → q ≈ q' → f p q = f p' q') (m m' : M)
    (s s' : S) : liftOn₂ (mk m s) (mk m' s') f wd = f ⟨m, s⟩ ⟨m', s'⟩ 
goal: (LocalizedModule.mk m s).liftOn₂ (LocalizedModule.mk m' s') f wd = f (m, s) (m', s')

full_name: LocalizedModule.instZero
code: instance : Zero (LocalizedModule S M) 
goal: Zero (LocalizedModule S M)

full_name: LocalizedModule.subsingleton
code: /-- If `S` contains `0` then the localization at `S` is trivial. -/
theorem subsingleton (h : 0 ∈ S) : Subsingleton (LocalizedModule S M) 
goal: Subsingleton (LocalizedModule S M)

full_name: LocalizedModule.zero_mk
code: @[simp]
theorem zero_mk (s : S) : mk (0 : M) s = 0 
goal: LocalizedModule.mk 0 s = 0

full_name: LocalizedModule.instAdd
code: instance : Add (LocalizedModule S M) 
goal: Add (LocalizedModule S M)

full_name: LocalizedModule.mk_add_mk
code: theorem mk_add_mk {m1 m2 : M} {s1 s2 : S} :
    mk m1 s1 + mk m2 s2 = mk (s2 • m1 + s1 • m2) (s1 * s2) 
goal: LocalizedModule.mk m1 s1 + LocalizedModule.mk m2 s2 = LocalizedModule.mk (s2 • m1 + s1 • m2) (s1 * s2)

full_name: _private.Mathlib.Algebra.Module.LocalizedModule.0.LocalizedModule.add_assoc'
code: private theorem add_assoc' (x y z : LocalizedModule S M) : x + y + z = x + (y + z) 
goal: x + y + z = x + (y + z)

full_name: _private.Mathlib.Algebra.Module.LocalizedModule.0.LocalizedModule.add_comm'
code: private theorem add_comm' (x y : LocalizedModule S M) : x + y = y + x 
goal: x + y = y + x

full_name: _private.Mathlib.Algebra.Module.LocalizedModule.0.LocalizedModule.zero_add'
code: private theorem zero_add' (x : LocalizedModule S M) : 0 + x = x 
goal: 0 + x = x

full_name: _private.Mathlib.Algebra.Module.LocalizedModule.0.LocalizedModule.add_zero'
code: private theorem add_zero' (x : LocalizedModule S M) : x + 0 = x 
goal: x + 0 = x

full_name: LocalizedModule.hasNatSMul
code: instance hasNatSMul : SMul ℕ (LocalizedModule S M) 
goal: SMul ℕ (LocalizedModule S M)

full_name: _private.Mathlib.Algebra.Module.LocalizedModule.0.LocalizedModule.nsmul_zero'
code: private theorem nsmul_zero' (x : LocalizedModule S M) : (0 : ℕ) • x = 0 
goal: 0 • x = 0

full_name: _private.Mathlib.Algebra.Module.LocalizedModule.0.LocalizedModule.nsmul_succ'
code: private theorem nsmul_succ' (n : ℕ) (x : LocalizedModule S M) : n.succ • x = n • x + x 
goal: n.succ • x = n • x + x

full_name: LocalizedModule.instAddCommMonoid
code: instance : AddCommMonoid (LocalizedModule S M) 
goal: AddCommMonoid (LocalizedModule S M)

full_name: LocalizedModule.instNeg
code: instance {M : Type*} [AddCommGroup M] [Module R M] : Neg (LocalizedModule S M) 
goal: Neg (LocalizedModule S M)

full_name: LocalizedModule.instAddCommGroup
code: instance {M : Type*} [AddCommGroup M] [Module R M] : AddCommGroup (LocalizedModule S M) 
goal: AddCommGroup (LocalizedModule S M)

full_name: LocalizedModule.mk_neg
code: theorem mk_neg {M : Type*} [AddCommGroup M] [Module R M] {m : M} {s : S} : mk (-m) s = -mk m s 
goal: LocalizedModule.mk (-m) s = -LocalizedModule.mk m s

full_name: LocalizedModule.instMonoid
code: instance {A : Type*} [Semiring A] [Algebra R A] {S : Submonoid R} :
    Monoid (LocalizedModule S A) 
goal: Monoid (LocalizedModule S A)

full_name: LocalizedModule.instSemiring
code: instance {A : Type*} [Semiring A] [Algebra R A] {S : Submonoid R} :
    Semiring (LocalizedModule S A) 
goal: Semiring (LocalizedModule S A)

full_name: LocalizedModule.instCommSemiring
code: instance {A : Type*} [CommSemiring A] [Algebra R A] {S : Submonoid R} :
    CommSemiring (LocalizedModule S A) 
goal: CommSemiring (LocalizedModule S A)

full_name: LocalizedModule.instRing
code: instance {A : Type*} [Ring A] [Algebra R A] {S : Submonoid R} :
    Ring (LocalizedModule S A) 
goal: Ring (LocalizedModule S A)

full_name: LocalizedModule.instCommRing
code: instance {A : Type*} [CommRing A] [Algebra R A] {S : Submonoid R} :
    CommRing (LocalizedModule S A) 
goal: CommRing (LocalizedModule S A)

full_name: LocalizedModule.mk_mul_mk
code: theorem mk_mul_mk {A : Type*} [Semiring A] [Algebra R A] {a₁ a₂ : A} {s₁ s₂ : S} :
    mk a₁ s₁ * mk a₂ s₂ = mk (a₁ * a₂) (s₁ * s₂) 
goal: LocalizedModule.mk a₁ s₁ * LocalizedModule.mk a₂ s₂ = LocalizedModule.mk (a₁ * a₂) (s₁ * s₂)

full_name: LocalizedModule.instSMul
code: noncomputable instance : SMul T (LocalizedModule S M) 
goal: SMul T (LocalizedModule S M)

full_name: LocalizedModule.smul_def
code: theorem smul_def (x : T) (m : M) (s : S) :
    x • mk m s = mk ((IsLocalization.sec S x).1 • m) ((IsLocalization.sec S x).2 * s) 
goal: x • LocalizedModule.mk m s = LocalizedModule.mk ((IsLocalization.sec S x).1 • m) ((IsLocalization.sec S x).2 * s)

full_name: LocalizedModule.mk'_smul_mk
code: theorem mk'_smul_mk (r : R) (m : M) (s s' : S) :
    IsLocalization.mk' T r s • mk m s' = mk (r • m) (s * s') 
goal: IsLocalization.mk' T r s • LocalizedModule.mk m s' = LocalizedModule.mk (r • m) (s * s')

full_name: LocalizedModule.mk_smul_mk
code: theorem mk_smul_mk (r : R) (m : M) (s t : S) :
    Localization.mk r s • mk m t = mk (r • m) (s * t) 
goal: Localization.mk r s • LocalizedModule.mk m t = LocalizedModule.mk (r • m) (s * t)

full_name: _private.Mathlib.Algebra.Module.LocalizedModule.0.LocalizedModule.one_smul_aux
code: private theorem one_smul_aux (p : LocalizedModule S M) : (1 : T) • p = p 
goal: 1 • p = p

full_name: _private.Mathlib.Algebra.Module.LocalizedModule.0.LocalizedModule.mul_smul_aux
code: private theorem mul_smul_aux (x y : T) (p : LocalizedModule S M) :
    (x * y) • p = x • y • p 
goal: (x * y) • p = x • y • p

full_name: _private.Mathlib.Algebra.Module.LocalizedModule.0.LocalizedModule.smul_add_aux
code: private theorem smul_add_aux (x : T) (p q : LocalizedModule S M) :
    x • (p + q) = x • p + x • q 
goal: x • (p + q) = x • p + x • q

full_name: _private.Mathlib.Algebra.Module.LocalizedModule.0.LocalizedModule.smul_zero_aux
code: private theorem smul_zero_aux (x : T) : x • (0 : LocalizedModule S M) = 0 
goal: x • 0 = 0

full_name: _private.Mathlib.Algebra.Module.LocalizedModule.0.LocalizedModule.add_smul_aux
code: private theorem add_smul_aux (x y : T) (p : LocalizedModule S M) :
    (x + y) • p = x • p + y • p 
goal: (x + y) • p = x • p + y • p

full_name: _private.Mathlib.Algebra.Module.LocalizedModule.0.LocalizedModule.zero_smul_aux
code: private theorem zero_smul_aux (p : LocalizedModule S M) : (0 : T) • p = 0 
goal: 0 • p = 0

full_name: LocalizedModule.isModule
code: noncomputable instance isModule : Module T (LocalizedModule S M) 
goal: Module T (LocalizedModule S M)

full_name: LocalizedModule.mk_cancel_common_left
code: @[simp]
theorem mk_cancel_common_left (s' s : S) (m : M) : mk (s' • m) (s' * s) = mk m s 
goal: LocalizedModule.mk (s' • m) (s' * s) = LocalizedModule.mk m s

full_name: LocalizedModule.mk_cancel
code: @[simp]
theorem mk_cancel (s : S) (m : M) : mk (s • m) s = mk m 1 
goal: LocalizedModule.mk (s • m) s = LocalizedModule.mk m 1

full_name: LocalizedModule.mk_cancel_common_right
code: @[simp]
theorem mk_cancel_common_right (s s' : S) (m : M) : mk (s' • m) (s * s') = mk m s 
goal: LocalizedModule.mk (s' • m) (s * s') = LocalizedModule.mk m s

full_name: LocalizedModule.isModule'
code: noncomputable instance isModule' : Module R (LocalizedModule S M) 
goal: Module R (LocalizedModule S M)

full_name: LocalizedModule.smul'_mk
code: theorem smul'_mk (r : R) (s : S) (m : M) : r • mk m s = mk (r • m) s 
goal: r • LocalizedModule.mk m s = LocalizedModule.mk (r • m) s

full_name: LocalizedModule.smul'_mul
code: theorem smul'_mul {A : Type*} [Semiring A] [Algebra R A] (x : T) (p₁ p₂ : LocalizedModule S A) :
    x • p₁ * p₂ = x • (p₁ * p₂) 
goal: x • p₁ * p₂ = x • (p₁ * p₂)

full_name: LocalizedModule.mul_smul'
code: theorem mul_smul' {A : Type*} [Semiring A] [Algebra R A] (x : T) (p₁ p₂ : LocalizedModule S A) :
    p₁ * x • p₂ = x • (p₁ * p₂) 
goal: p₁ * x • p₂ = x • (p₁ * p₂)

full_name: LocalizedModule.instAlgebra
code: noncomputable instance {A : Type*} [Semiring A] [Algebra R A] : Algebra T (LocalizedModule S A) 
goal: Algebra T (LocalizedModule S A)

full_name: LocalizedModule.algebraMap_mk'
code: theorem algebraMap_mk' {A : Type*} [Semiring A] [Algebra R A] (a : R) (s : S) :
    algebraMap _ _ (IsLocalization.mk' T a s) = mk (algebraMap R A a) s 
goal: (algebraMap T (LocalizedModule S A)) (IsLocalization.mk' T a s) = LocalizedModule.mk ((algebraMap R A) a) s

full_name: LocalizedModule.algebraMap_mk
code: theorem algebraMap_mk {A : Type*} [Semiring A] [Algebra R A] (a : R) (s : S) :
    algebraMap _ _ (Localization.mk a s) = mk (algebraMap R A a) s 
goal: (algebraMap (Localization S) (LocalizedModule S A)) (Localization.mk a s) = LocalizedModule.mk ((algebraMap R A) a) s

full_name: LocalizedModule.instIsScalarTower
code: instance : IsScalarTower R T (LocalizedModule S M) 
goal: IsScalarTower R T (LocalizedModule S M)

full_name: LocalizedModule.algebra'
code: noncomputable instance algebra' {A : Type*} [Semiring A] [Algebra R A] :
    Algebra R (LocalizedModule S A) 
goal: Algebra R (LocalizedModule S A)

full_name: LocalizedModule.mkLinearMap
code: /-- The function `m ↦ m / 1` as an `R`-linear map.
-/
@[simps]
def mkLinearMap : M →ₗ[R] LocalizedModule S M 
goal: M →ₗ[R] LocalizedModule S M

full_name: LocalizedModule.mkLinearMap_apply
code: /-- The function `m ↦ m / 1` as an `R`-linear map.
-/
@[simps]
def mkLinearMap : M →ₗ[R] LocalizedModule S M 
goal: (LocalizedModule.mkLinearMap S M) m = LocalizedModule.mk m 1

full_name: LocalizedModule.divBy
code: /-- For any `s : S`, there is an `R`-linear map given by `a/b ↦ a/(b*s)`.
-/
@[simps]
def divBy (s : S) : LocalizedModule S M →ₗ[R] LocalizedModule S M 
goal: LocalizedModule S M →ₗ[R] LocalizedModule S M

full_name: LocalizedModule.divBy_apply
code: /-- For any `s : S`, there is an `R`-linear map given by `a/b ↦ a/(b*s)`.
-/
@[simps]
def divBy (s : S) : LocalizedModule S M →ₗ[R] LocalizedModule S M 
goal: (LocalizedModule.divBy s) p = p.liftOn (fun p => LocalizedModule.mk p.1 (p.2 * s)) ⋯

full_name: LocalizedModule.divBy_mul_by
code: theorem divBy_mul_by (s : S) (p : LocalizedModule S M) :
    divBy s (algebraMap R (Module.End R (LocalizedModule S M)) s p) = p 
goal: (LocalizedModule.divBy s) (((algebraMap R (Module.End R (LocalizedModule S M))) ↑s) p) = p

full_name: LocalizedModule.mul_by_divBy
code: theorem mul_by_divBy (s : S) (p : LocalizedModule S M) :
    algebraMap R (Module.End R (LocalizedModule S M)) s (divBy s p) = p 
goal: ((algebraMap R (Module.End R (LocalizedModule S M))) ↑s) ((LocalizedModule.divBy s) p) = p

full_name: IsLocalizedModule
code: /-- The characteristic predicate for localized module.
`IsLocalizedModule S f` describes that `f : M ⟶ M'` is the localization map identifying `M'` as
`LocalizedModule S M`.
-/
@[mk_iff] class IsLocalizedModule : Prop where
  map_units : ∀ x : S, IsUnit (algebraMap R (Module.End R M') x)
  surj' : ∀ y : M', ∃ x : M × S, x.2 • y = f x.1
  exists_of_eq : ∀ {x₁ x₂}, f x₁ = f x₂ → ∃ c : S, c • x₁ = c • x₂
goal: Prop

full_name: isLocalizedModule_iff
code: /-- The characteristic predicate for localized module.
`IsLocalizedModule S f` describes that `f : M ⟶ M'` is the localization map identifying `M'` as
`LocalizedModule S M`.
-/
@[mk_iff] class IsLocalizedModule : Prop where
  map_units : ∀ x : S, IsUnit (algebraMap R (Module.End R M') x)
  surj' : ∀ y : M', ∃ x : M × S, x.2 • y = f x.1
  exists_of_eq : ∀ {x₁ x₂}, f x₁ = f x₂ → ∃ c : S, c • x₁ = c • x₂
goal: IsLocalizedModule S f ↔
  (∀ (x : ↥S), IsUnit ((algebraMap R (Module.End R M')) ↑x)) ∧
    (∀ (y : M'), ∃ x, x.2 • y = f x.1) ∧ ∀ {x₁ x₂ : M}, f x₁ = f x₂ → ∃ c, c • x₁ = c • x₂

full_name: IsLocalizedModule.surj'
code: /-- The characteristic predicate for localized module.
`IsLocalizedModule S f` describes that `f : M ⟶ M'` is the localization map identifying `M'` as
`LocalizedModule S M`.
-/
@[mk_iff] class IsLocalizedModule : Prop where
  map_units : ∀ x : S, IsUnit (algebraMap R (Module.End R M') x)
  surj' : ∀ y : M', ∃ x : M × S, x.2 • y = f x.1
  exists_of_eq : ∀ {x₁ x₂}, f x₁ = f x₂ → ∃ c : S, c • x₁ = c • x₂
goal: ∃ x, x.2 • y = f x.1

full_name: IsLocalizedModule.map_units
code: /-- The characteristic predicate for localized module.
`IsLocalizedModule S f` describes that `f : M ⟶ M'` is the localization map identifying `M'` as
`LocalizedModule S M`.
-/
@[mk_iff] class IsLocalizedModule : Prop where
  map_units : ∀ x : S, IsUnit (algebraMap R (Module.End R M') x)
  surj' : ∀ y : M', ∃ x : M × S, x.2 • y = f x.1
  exists_of_eq : ∀ {x₁ x₂}, f x₁ = f x₂ → ∃ c : S, c • x₁ = c • x₂
goal: IsUnit ((algebraMap R (Module.End R M')) ↑x)

full_name: IsLocalizedModule.exists_of_eq
code: /-- The characteristic predicate for localized module.
`IsLocalizedModule S f` describes that `f : M ⟶ M'` is the localization map identifying `M'` as
`LocalizedModule S M`.
-/
@[mk_iff] class IsLocalizedModule : Prop where
  map_units : ∀ x : S, IsUnit (algebraMap R (Module.End R M') x)
  surj' : ∀ y : M', ∃ x : M × S, x.2 • y = f x.1
  exists_of_eq : ∀ {x₁ x₂}, f x₁ = f x₂ → ∃ c : S, c • x₁ = c • x₂
goal: f x₁ = f x₂ → ∃ c, c • x₁ = c • x₂

full_name: IsLocalizedModule.surj
code: lemma IsLocalizedModule.surj [IsLocalizedModule S f] (y : M') : ∃ x : M × S, x.2 • y = f x.1 
goal: ∃ x, x.2 • y = f x.1

full_name: IsLocalizedModule.eq_iff_exists
code: lemma IsLocalizedModule.eq_iff_exists [IsLocalizedModule S f] {x₁ x₂} :
    f x₁ = f x₂ ↔ ∃ c : S, c • x₁ = c • x₂ 
goal: f x₁ = f x₂ ↔ ∃ c, c • x₁ = c • x₂

full_name: IsLocalizedModule.of_linearEquiv
code: theorem IsLocalizedModule.of_linearEquiv (e : M' ≃ₗ[R] M'') [hf : IsLocalizedModule S f] :
    IsLocalizedModule S (e ∘ₗ f : M →ₗ[R] M'') 
goal: IsLocalizedModule S (↑e ∘ₗ f)

full_name: isLocalizedModule_id
code: lemma isLocalizedModule_id (R') [CommSemiring R'] [Algebra R R'] [IsLocalization S R'] [Module R' M]
    [IsScalarTower R R' M] : IsLocalizedModule S (.id : M →ₗ[R] M) 
goal: IsLocalizedModule S LinearMap.id

full_name: isLocalizedModule_iff_isLocalization
code: theorem isLocalizedModule_iff_isLocalization {A Aₛ} [CommSemiring A] [Algebra R A] [CommSemiring Aₛ]
    [Algebra A Aₛ] [Algebra R Aₛ] [IsScalarTower R A Aₛ] :
    IsLocalizedModule S (IsScalarTower.toAlgHom R A Aₛ).toLinearMap ↔
      IsLocalization (Algebra.algebraMapSubmonoid A S) Aₛ 
goal: IsLocalizedModule S (IsScalarTower.toAlgHom R A Aₛ).toLinearMap ↔ IsLocalization (Algebra.algebraMapSubmonoid A S) Aₛ

full_name: instIsLocalizedModuleToLinearMapToAlgHomOfIsLocalizationAlgebraMapSubmonoid
code: instance {A Aₛ} [CommSemiring A] [Algebra R A][CommSemiring Aₛ] [Algebra A Aₛ] [Algebra R Aₛ]
    [IsScalarTower R A Aₛ] [h : IsLocalization (Algebra.algebraMapSubmonoid A S) Aₛ] :
    IsLocalizedModule S (IsScalarTower.toAlgHom R A Aₛ).toLinearMap 
goal: IsLocalizedModule S (IsScalarTower.toAlgHom R A Aₛ).toLinearMap

full_name: isLocalizedModule_iff_isLocalization'
code: lemma isLocalizedModule_iff_isLocalization' (R') [CommSemiring R'] [Algebra R R'] :
    IsLocalizedModule S (Algebra.ofId R R').toLinearMap ↔ IsLocalization S R' 
goal: IsLocalizedModule S (Algebra.ofId R R').toLinearMap ↔ IsLocalization S R'

full_name: LocalizedModule.lift'
code: /--
If `g` is a linear map `M → M''` such that all scalar multiplication by `s : S` is invertible, then
there is a linear map `LocalizedModule S M → M''`.
-/
noncomputable def lift' (g : M →ₗ[R] M'')
    (h : ∀ x : S, IsUnit (algebraMap R (Module.End R M'') x)) : LocalizedModule S M → M'' 
goal: LocalizedModule S M → M''

full_name: LocalizedModule.lift'_mk
code: theorem lift'_mk (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x))
    (m : M) (s : S) :
    LocalizedModule.lift' S g h (LocalizedModule.mk m s) = (h s).unit⁻¹.val (g m) 
goal: LocalizedModule.lift' S g h (LocalizedModule.mk m s) = ↑⋯.unit⁻¹ (g m)

full_name: LocalizedModule.lift'_add
code: theorem lift'_add (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x))
    (x y) :
    LocalizedModule.lift' S g h (x + y) =
      LocalizedModule.lift' S g h x + LocalizedModule.lift' S g h y 
goal: LocalizedModule.lift' S g h (x + y) = LocalizedModule.lift' S g h x + LocalizedModule.lift' S g h y

full_name: LocalizedModule.lift'_smul
code: theorem lift'_smul (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x))
    (r : R) (m) : r • LocalizedModule.lift' S g h m = LocalizedModule.lift' S g h (r • m) 
goal: r • LocalizedModule.lift' S g h m = LocalizedModule.lift' S g h (r • m)

full_name: LocalizedModule.lift
code: /--
If `g` is a linear map `M → M''` such that all scalar multiplication by `s : S` is invertible, then
there is a linear map `LocalizedModule S M → M''`.
-/
noncomputable def lift (g : M →ₗ[R] M'')
    (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x)) :
    LocalizedModule S M →ₗ[R] M'' 
goal: LocalizedModule S M →ₗ[R] M''

full_name: LocalizedModule.lift_mk
code: /--
If `g` is a linear map `M → M''` such that all scalar multiplication by `s : S` is invertible, then
`lift g m s = s⁻¹ • g m`.
-/
theorem lift_mk
    (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit (algebraMap R (Module.End R M'') x)) (m : M) (s : S) :
    LocalizedModule.lift S g h (LocalizedModule.mk m s) = (h s).unit⁻¹.val (g m) 
goal: (LocalizedModule.lift S g h) (LocalizedModule.mk m s) = ↑⋯.unit⁻¹ (g m)

full_name: LocalizedModule.lift_comp
code: /--
If `g` is a linear map `M → M''` such that all scalar multiplication by `s : S` is invertible, then
there is a linear map `lift g ∘ mkLinearMap = g`.
-/
theorem lift_comp (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x)) :
    (lift S g h).comp (mkLinearMap S M) = g 
goal: LocalizedModule.lift S g h ∘ₗ LocalizedModule.mkLinearMap S M = g

full_name: LocalizedModule.lift_unique
code: /--
If `g` is a linear map `M → M''` such that all scalar multiplication by `s : S` is invertible and
`l` is another linear map `LocalizedModule S M ⟶ M''` such that `l ∘ mkLinearMap = g` then
`l = lift g`
-/
theorem lift_unique (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x))
    (l : LocalizedModule S M →ₗ[R] M'') (hl : l.comp (LocalizedModule.mkLinearMap S M) = g) :
    LocalizedModule.lift S g h = l 
goal: LocalizedModule.lift S g h = l

full_name: localizedModuleIsLocalizedModule
code: instance localizedModuleIsLocalizedModule :
    IsLocalizedModule S (LocalizedModule.mkLinearMap S M) 
goal: IsLocalizedModule S (LocalizedModule.mkLinearMap S M)

full_name: IsLocalizedModule.fromLocalizedModule'
code: /-- If `(M', f : M ⟶ M')` satisfies universal property of localized module, there is a canonical
map `LocalizedModule S M ⟶ M'`.
-/
noncomputable def fromLocalizedModule' : LocalizedModule S M → M' 
goal: LocalizedModule S M → M'

full_name: IsLocalizedModule.fromLocalizedModule'_mk
code: @[simp]
theorem fromLocalizedModule'_mk (m : M) (s : S) :
    fromLocalizedModule' S f (LocalizedModule.mk m s) =
      (IsLocalizedModule.map_units f s).unit⁻¹.val (f m) 
goal: IsLocalizedModule.fromLocalizedModule' S f (LocalizedModule.mk m s) = ↑⋯.unit⁻¹ (f m)

full_name: IsLocalizedModule.fromLocalizedModule'_add
code: theorem fromLocalizedModule'_add (x y : LocalizedModule S M) :
    fromLocalizedModule' S f (x + y) = fromLocalizedModule' S f x + fromLocalizedModule' S f y 
goal: IsLocalizedModule.fromLocalizedModule' S f (x + y) =
  IsLocalizedModule.fromLocalizedModule' S f x + IsLocalizedModule.fromLocalizedModule' S f y

full_name: IsLocalizedModule.fromLocalizedModule'_smul
code: theorem fromLocalizedModule'_smul (r : R) (x : LocalizedModule S M) :
    r • fromLocalizedModule' S f x = fromLocalizedModule' S f (r • x) 
goal: r • IsLocalizedModule.fromLocalizedModule' S f x = IsLocalizedModule.fromLocalizedModule' S f (r • x)

full_name: IsLocalizedModule.fromLocalizedModule
code: /-- If `(M', f : M ⟶ M')` satisfies universal property of localized module, there is a canonical
map `LocalizedModule S M ⟶ M'`.
-/
noncomputable def fromLocalizedModule : LocalizedModule S M →ₗ[R] M' 
goal: LocalizedModule S M →ₗ[R] M'

full_name: IsLocalizedModule.fromLocalizedModule_mk
code: theorem fromLocalizedModule_mk (m : M) (s : S) :
    fromLocalizedModule S f (LocalizedModule.mk m s) =
      (IsLocalizedModule.map_units f s).unit⁻¹.val (f m) 
goal: (IsLocalizedModule.fromLocalizedModule S f) (LocalizedModule.mk m s) = ↑⋯.unit⁻¹ (f m)

full_name: IsLocalizedModule.fromLocalizedModule.inj
code: theorem fromLocalizedModule.inj : Function.Injective <| fromLocalizedModule S f 
goal: Function.Injective ⇑(IsLocalizedModule.fromLocalizedModule S f)

full_name: IsLocalizedModule.fromLocalizedModule.surj
code: theorem fromLocalizedModule.surj : Function.Surjective <| fromLocalizedModule S f 
goal: Function.Surjective ⇑(IsLocalizedModule.fromLocalizedModule S f)

full_name: IsLocalizedModule.fromLocalizedModule.bij
code: theorem fromLocalizedModule.bij : Function.Bijective <| fromLocalizedModule S f 
goal: Function.Bijective ⇑(IsLocalizedModule.fromLocalizedModule S f)

full_name: IsLocalizedModule.iso_apply
code: /--
If `(M', f : M ⟶ M')` satisfies universal property of localized module, then `M'` is isomorphic to
`LocalizedModule S M` as an `R`-module.
-/
@[simps!]
noncomputable def iso : LocalizedModule S M ≃ₗ[R] M' 
goal: ∀ (a : LocalizedModule S M), (IsLocalizedModule.iso S f) a = IsLocalizedModule.fromLocalizedModule' S f a

full_name: IsLocalizedModule.iso_symm_apply
code: /--
If `(M', f : M ⟶ M')` satisfies universal property of localized module, then `M'` is isomorphic to
`LocalizedModule S M` as an `R`-module.
-/
@[simps!]
noncomputable def iso : LocalizedModule S M ≃ₗ[R] M' 
goal: ∀ (a : M'),
  (IsLocalizedModule.iso S f).symm a = (Equiv.ofBijective ⇑(IsLocalizedModule.fromLocalizedModule S f) ⋯).symm a

full_name: IsLocalizedModule.iso
code: /--
If `(M', f : M ⟶ M')` satisfies universal property of localized module, then `M'` is isomorphic to
`LocalizedModule S M` as an `R`-module.
-/
@[simps!]
noncomputable def iso : LocalizedModule S M ≃ₗ[R] M' 
goal: LocalizedModule S M ≃ₗ[R] M'

full_name: IsLocalizedModule.iso_apply_mk
code: theorem iso_apply_mk (m : M) (s : S) :
    iso S f (LocalizedModule.mk m s) = (IsLocalizedModule.map_units f s).unit⁻¹.val (f m) 
goal: (IsLocalizedModule.iso S f) (LocalizedModule.mk m s) = ↑⋯.unit⁻¹ (f m)

full_name: IsLocalizedModule.iso_symm_apply_aux
code: theorem iso_symm_apply_aux (m : M') :
    (iso S f).symm m =
      LocalizedModule.mk (IsLocalizedModule.surj S f m).choose.1
        (IsLocalizedModule.surj S f m).choose.2 
goal: (IsLocalizedModule.iso S f).symm m = LocalizedModule.mk ⋯.choose.1 ⋯.choose.2

full_name: IsLocalizedModule.iso_symm_apply'
code: theorem iso_symm_apply' (m : M') (a : M) (b : S) (eq1 : b • m = f a) :
    (iso S f).symm m = LocalizedModule.mk a b 
goal: (IsLocalizedModule.iso S f).symm m = LocalizedModule.mk a b

full_name: IsLocalizedModule.iso_symm_comp
code: theorem iso_symm_comp : (iso S f).symm.toLinearMap.comp f = LocalizedModule.mkLinearMap S M 
goal: ↑(IsLocalizedModule.iso S f).symm ∘ₗ f = LocalizedModule.mkLinearMap S M

full_name: IsLocalizedModule.lift
code: /--
If `M'` is a localized module and `g` is a linear map `M → M''` such that all scalar multiplication
by `s : S` is invertible, then there is a linear map `M' → M''`.
-/
noncomputable def lift (g : M →ₗ[R] M'')
    (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x)) : M' →ₗ[R] M'' 
goal: M' →ₗ[R] M''

full_name: IsLocalizedModule.lift_comp
code: theorem lift_comp (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x)) :
    (lift S f g h).comp f = g 
goal: IsLocalizedModule.lift S f g h ∘ₗ f = g

full_name: IsLocalizedModule.lift_apply
code: @[simp]
theorem lift_apply (g : M →ₗ[R] M'') (h) (x) :
    lift S f g h (f x) = g x 
goal: (IsLocalizedModule.lift S f g h) (f x) = g x

full_name: IsLocalizedModule.lift_unique
code: theorem lift_unique (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x))
    (l : M' →ₗ[R] M'') (hl : l.comp f = g) : lift S f g h = l 
goal: IsLocalizedModule.lift S f g h = l

full_name: IsLocalizedModule.is_universal
code: /-- Universal property from localized module:
If `(M', f : M ⟶ M')` is a localized module then it satisfies the following universal property:
For every `R`-module `M''` which every `s : S`-scalar multiplication is invertible and for every
`R`-linear map `g : M ⟶ M''`, there is a unique `R`-linear map `l : M' ⟶ M''` such that
`l ∘ f = g`.
```
M -----f----> M'
|           /
|g       /
|     /   l
v   /
M''
```
-/
theorem is_universal :
    ∀ (g : M →ₗ[R] M'') (_ : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x)),
      ∃! l : M' →ₗ[R] M'', l.comp f = g 
goal: (∀ (x : ↥S), IsUnit ((algebraMap R (Module.End R M'')) ↑x)) → ∃! l, l ∘ₗ f = g

full_name: IsLocalizedModule.ringHom_ext
code: theorem ringHom_ext (map_unit : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x))
    ⦃j k : M' →ₗ[R] M''⦄ (h : j.comp f = k.comp f) : j = k 
goal: j = k

full_name: IsLocalizedModule.linearEquiv
code: /-- If `(M', f)` and `(M'', g)` both satisfy universal property of localized module, then `M', M''`
are isomorphic as `R`-module
-/
noncomputable def linearEquiv [IsLocalizedModule S g] : M' ≃ₗ[R] M'' 
goal: M' ≃ₗ[R] M''

full_name: IsLocalizedModule.smul_injective
code: theorem smul_injective (s : S) : Function.Injective fun m : M' => s • m 
goal: Function.Injective fun m => s • m

full_name: IsLocalizedModule.smul_inj
code: theorem smul_inj (s : S) (m₁ m₂ : M') : s • m₁ = s • m₂ ↔ m₁ = m₂ 
goal: s • m₁ = s • m₂ ↔ m₁ = m₂

full_name: IsLocalizedModule.mk'
code: /-- `mk' f m s` is the fraction `m/s` with respect to the localization map `f`. -/
noncomputable def mk' (m : M) (s : S) : M' 
goal: M'

full_name: IsLocalizedModule.mk'_smul
code: theorem mk'_smul (r : R) (m : M) (s : S) : mk' f (r • m) s = r • mk' f m s 
goal: IsLocalizedModule.mk' f (r • m) s = r • IsLocalizedModule.mk' f m s

full_name: IsLocalizedModule.mk'_add_mk'
code: theorem mk'_add_mk' (m₁ m₂ : M) (s₁ s₂ : S) :
    mk' f m₁ s₁ + mk' f m₂ s₂ = mk' f (s₂ • m₁ + s₁ • m₂) (s₁ * s₂) 
goal: IsLocalizedModule.mk' f m₁ s₁ + IsLocalizedModule.mk' f m₂ s₂ = IsLocalizedModule.mk' f (s₂ • m₁ + s₁ • m₂) (s₁ * s₂)

full_name: IsLocalizedModule.mk'_zero
code: @[simp]
theorem mk'_zero (s : S) : mk' f 0 s = 0 
goal: IsLocalizedModule.mk' f 0 s = 0

full_name: IsLocalizedModule.mk'_one
code: @[simp]
theorem mk'_one (m : M) : mk' f m (1 : S) = f m 
goal: IsLocalizedModule.mk' f m 1 = f m

full_name: IsLocalizedModule.mk'_cancel
code: @[simp]
theorem mk'_cancel (m : M) (s : S) : mk' f (s • m) s = f m 
goal: IsLocalizedModule.mk' f (s • m) s = f m

full_name: IsLocalizedModule.mk'_cancel'
code: @[simp]
theorem mk'_cancel' (m : M) (s : S) : s • mk' f m s = f m 
goal: s • IsLocalizedModule.mk' f m s = f m

full_name: IsLocalizedModule.mk'_cancel_left
code: @[simp]
theorem mk'_cancel_left (m : M) (s₁ s₂ : S) : mk' f (s₁ • m) (s₁ * s₂) = mk' f m s₂ 
goal: IsLocalizedModule.mk' f (s₁ • m) (s₁ * s₂) = IsLocalizedModule.mk' f m s₂

full_name: IsLocalizedModule.mk'_cancel_right
code: @[simp]
theorem mk'_cancel_right (m : M) (s₁ s₂ : S) : mk' f (s₂ • m) (s₁ * s₂) = mk' f m s₁ 
goal: IsLocalizedModule.mk' f (s₂ • m) (s₁ * s₂) = IsLocalizedModule.mk' f m s₁

full_name: IsLocalizedModule.mk'_add
code: theorem mk'_add (m₁ m₂ : M) (s : S) : mk' f (m₁ + m₂) s = mk' f m₁ s + mk' f m₂ s 
goal: IsLocalizedModule.mk' f (m₁ + m₂) s = IsLocalizedModule.mk' f m₁ s + IsLocalizedModule.mk' f m₂ s

full_name: IsLocalizedModule.mk'_eq_mk'_iff
code: theorem mk'_eq_mk'_iff (m₁ m₂ : M) (s₁ s₂ : S) :
    mk' f m₁ s₁ = mk' f m₂ s₂ ↔ ∃ s : S, s • s₁ • m₂ = s • s₂ • m₁ 
goal: IsLocalizedModule.mk' f m₁ s₁ = IsLocalizedModule.mk' f m₂ s₂ ↔ ∃ s, s • s₁ • m₂ = s • s₂ • m₁

full_name: IsLocalizedModule.mk'_neg
code: theorem mk'_neg {M M' : Type*} [AddCommGroup M] [AddCommGroup M'] [Module R M] [Module R M']
    (f : M →ₗ[R] M') [IsLocalizedModule S f] (m : M) (s : S) : mk' f (-m) s = -mk' f m s 
goal: IsLocalizedModule.mk' f (-m) s = -IsLocalizedModule.mk' f m s

full_name: IsLocalizedModule.mk'_sub
code: theorem mk'_sub {M M' : Type*} [AddCommGroup M] [AddCommGroup M'] [Module R M] [Module R M']
    (f : M →ₗ[R] M') [IsLocalizedModule S f] (m₁ m₂ : M) (s : S) :
    mk' f (m₁ - m₂) s = mk' f m₁ s - mk' f m₂ s 
goal: IsLocalizedModule.mk' f (m₁ - m₂) s = IsLocalizedModule.mk' f m₁ s - IsLocalizedModule.mk' f m₂ s

full_name: IsLocalizedModule.mk'_sub_mk'
code: theorem mk'_sub_mk' {M M' : Type*} [AddCommGroup M] [AddCommGroup M'] [Module R M] [Module R M']
    (f : M →ₗ[R] M') [IsLocalizedModule S f] (m₁ m₂ : M) (s₁ s₂ : S) :
    mk' f m₁ s₁ - mk' f m₂ s₂ = mk' f (s₂ • m₁ - s₁ • m₂) (s₁ * s₂) 
goal: IsLocalizedModule.mk' f m₁ s₁ - IsLocalizedModule.mk' f m₂ s₂ = IsLocalizedModule.mk' f (s₂ • m₁ - s₁ • m₂) (s₁ * s₂)

full_name: IsLocalizedModule.mk'_mul_mk'_of_map_mul
code: theorem mk'_mul_mk'_of_map_mul {M M' : Type*} [Semiring M] [Semiring M'] [Module R M]
    [Algebra R M'] (f : M →ₗ[R] M') (hf : ∀ m₁ m₂, f (m₁ * m₂) = f m₁ * f m₂)
    [IsLocalizedModule S f] (m₁ m₂ : M) (s₁ s₂ : S) :
    mk' f m₁ s₁ * mk' f m₂ s₂ = mk' f (m₁ * m₂) (s₁ * s₂) 
goal: IsLocalizedModule.mk' f m₁ s₁ * IsLocalizedModule.mk' f m₂ s₂ = IsLocalizedModule.mk' f (m₁ * m₂) (s₁ * s₂)

full_name: IsLocalizedModule.mk'_mul_mk'
code: theorem mk'_mul_mk' {M M' : Type*} [Semiring M] [Semiring M'] [Algebra R M] [Algebra R M']
    (f : M →ₐ[R] M') [IsLocalizedModule S f.toLinearMap] (m₁ m₂ : M) (s₁ s₂ : S) :
    mk' f.toLinearMap m₁ s₁ * mk' f.toLinearMap m₂ s₂ = mk' f.toLinearMap (m₁ * m₂) (s₁ * s₂) 
goal: IsLocalizedModule.mk' f.toLinearMap m₁ s₁ * IsLocalizedModule.mk' f.toLinearMap m₂ s₂ =
  IsLocalizedModule.mk' f.toLinearMap (m₁ * m₂) (s₁ * s₂)

full_name: IsLocalizedModule.mk'_eq_iff
code: /-- Porting note (#10618): simp can prove this
@[simp] -/
theorem mk'_eq_iff {m : M} {s : S} {m' : M'} : mk' f m s = m' ↔ f m = s • m' 
goal: IsLocalizedModule.mk' f m s = m' ↔ f m = s • m'

full_name: IsLocalizedModule.mk'_eq_zero
code: @[simp]
theorem mk'_eq_zero {m : M} (s : S) : mk' f m s = 0 ↔ f m = 0 
goal: IsLocalizedModule.mk' f m s = 0 ↔ f m = 0

full_name: IsLocalizedModule.mk'_eq_zero'
code: theorem mk'_eq_zero' {m : M} (s : S) : mk' f m s = 0 ↔ ∃ s' : S, s' • m = 0 
goal: IsLocalizedModule.mk' f m s = 0 ↔ ∃ s', s' • m = 0

full_name: IsLocalizedModule.mk_eq_mk'
code: theorem mk_eq_mk' (s : S) (m : M) :
    LocalizedModule.mk m s = mk' (LocalizedModule.mkLinearMap S M) m s 
goal: LocalizedModule.mk m s = IsLocalizedModule.mk' (LocalizedModule.mkLinearMap S M) m s

full_name: IsLocalizedModule.mk'_smul_mk'
code: lemma mk'_smul_mk' (x : R) (m : M) (s t : S) :
    IsLocalization.mk' A x s • mk' f m t = mk' f (x • m) (s * t) 
goal: IsLocalization.mk' A x s • IsLocalizedModule.mk' f m t = IsLocalizedModule.mk' f (x • m) (s * t)

full_name: IsLocalizedModule.eq_zero_iff
code: theorem eq_zero_iff {m : M} : f m = 0 ↔ ∃ s' : S, s' • m = 0 
goal: f m = 0 ↔ ∃ s', s' • m = 0

full_name: IsLocalizedModule.mk'_surjective
code: theorem mk'_surjective : Function.Surjective (Function.uncurry <| mk' f : M × S → M') 
goal: Function.Surjective (Function.uncurry (IsLocalizedModule.mk' f))

full_name: IsLocalizedModule.map
code: /-- A linear map `M →ₗ[R] N` gives a map between localized modules `Mₛ →ₗ[R] Nₛ`. -/
noncomputable
def map : (M →ₗ[R] N) →ₗ[R] (M' →ₗ[R] N') 
goal: (M →ₗ[R] N) →ₗ[R] M' →ₗ[R] N'

full_name: IsLocalizedModule.map_comp
code: lemma map_comp (h : M →ₗ[R] N) : (map S f g h) ∘ₗ f = g ∘ₗ h 
goal: (IsLocalizedModule.map S f g) h ∘ₗ f = g ∘ₗ h

full_name: IsLocalizedModule.map_apply
code: @[simp]
lemma map_apply (h : M →ₗ[R] N) (x) : map S f g h (f x) = g (h x) 
goal: ((IsLocalizedModule.map S f g) h) (f x) = g (h x)

full_name: IsLocalizedModule.map_mk'
code: @[simp]
lemma map_mk' (h : M →ₗ[R] N) (x) (s : S) :
    map S f g h (IsLocalizedModule.mk' f x s) = (IsLocalizedModule.mk' g (h x) s) 
goal: ((IsLocalizedModule.map S f g) h) (IsLocalizedModule.mk' f x s) = IsLocalizedModule.mk' g (h x) s

full_name: IsLocalizedModule.iso_localizedModule_eq_refl
code: /-- The linear map `(LocalizedModule S M) → (LocalizedModule S M)` from `iso` is the identity. -/
lemma iso_localizedModule_eq_refl : iso S (mkLinearMap S M) = refl R (LocalizedModule S M) 
goal: IsLocalizedModule.iso S (LocalizedModule.mkLinearMap S M) = LinearEquiv.refl R (LocalizedModule S M)

full_name: IsLocalizedModule.map_LocalizedModules
code: /-- Formula for `IsLocalizedModule.map` when each localized module is a `LocalizedModule`.-/
lemma map_LocalizedModules (g : M₀ →ₗ[R] M₁) (m : M₀) (s : S) :
    ((map S (mkLinearMap S M₀) (mkLinearMap S M₁)) g)
    (LocalizedModule.mk m s) = LocalizedModule.mk (g m) s 
goal: ((IsLocalizedModule.map S (LocalizedModule.mkLinearMap S M₀) (LocalizedModule.mkLinearMap S M₁)) g)
    (LocalizedModule.mk m s) =
  LocalizedModule.mk (g m) s

full_name: IsLocalizedModule.map_iso_commute
code: lemma map_iso_commute (g : M₀ →ₗ[R] M₁) : (map S f₀ f₁) g ∘ₗ (iso S f₀) =
    (iso S f₁) ∘ₗ (map S (mkLinearMap S M₀) (mkLinearMap S M₁)) g 
goal: (IsLocalizedModule.map S f₀ f₁) g ∘ₗ ↑(IsLocalizedModule.iso S f₀) =
  ↑(IsLocalizedModule.iso S f₁) ∘ₗ
    (IsLocalizedModule.map S (LocalizedModule.mkLinearMap S M₀) (LocalizedModule.mkLinearMap S M₁)) g

full_name: LocalizedModule.map_exact
code: /-- Localization of modules is an exact functor, proven here for `LocalizedModule`.
See `IsLocalizedModule.map_exact` for the more general version. -/
lemma map_exact (g : M₀ →ₗ[R] M₁) (h : M₁ →ₗ[R] M₂) (ex : Exact g h) :
    Exact (map S (mkLinearMap S M₀) (mkLinearMap S M₁) g)
    (map S (mkLinearMap S M₁) (mkLinearMap S M₂) h) 
goal: Function.Exact ⇑((IsLocalizedModule.map S (LocalizedModule.mkLinearMap S M₀) (LocalizedModule.mkLinearMap S M₁)) g)
  ⇑((IsLocalizedModule.map S (LocalizedModule.mkLinearMap S M₁) (LocalizedModule.mkLinearMap S M₂)) h)

full_name: IsLocalizedModule.map_exact
code: /-- Localization of modules is an exact functor. -/
theorem map_exact (g : M₀ →ₗ[R] M₁) (h : M₁ →ₗ[R] M₂) (ex : Function.Exact g h) :
    Function.Exact (map S f₀ f₁ g) (map S f₁ f₂ h) 
goal: Function.Exact ⇑((IsLocalizedModule.map S f₀ f₁) g) ⇑((IsLocalizedModule.map S f₁ f₂) h)

full_name: IsLocalizedModule.mkOfAlgebra
code: theorem mkOfAlgebra {R S S' : Type*} [CommRing R] [CommRing S] [CommRing S'] [Algebra R S]
    [Algebra R S'] (M : Submonoid R) (f : S →ₐ[R] S') (h₁ : ∀ x ∈ M, IsUnit (algebraMap R S' x))
    (h₂ : ∀ y, ∃ x : S × M, x.2 • y = f x.1) (h₃ : ∀ x, f x = 0 → ∃ m : M, m • x = 0) :
    IsLocalizedModule M f.toLinearMap 
goal: IsLocalizedModule M f.toLinearMap

full_name: LocalizedModule.mem_ker_mkLinearMap_iff
code: lemma LocalizedModule.mem_ker_mkLinearMap_iff {S : Submonoid R} {m} :
    m ∈ LinearMap.ker (LocalizedModule.mkLinearMap S M) ↔ ∃ r ∈ S, r • m = 0 
goal: m ∈ LinearMap.ker (LocalizedModule.mkLinearMap S M) ↔ ∃ r ∈ S, r • m = 0

full_name: LocalizedModule.subsingleton_iff_ker_eq_top
code: lemma LocalizedModule.subsingleton_iff_ker_eq_top {S : Submonoid R} :
    Subsingleton (LocalizedModule S M) ↔
      LinearMap.ker (LocalizedModule.mkLinearMap S M) = ⊤ 
goal: Subsingleton (LocalizedModule S M) ↔ LinearMap.ker (LocalizedModule.mkLinearMap S M) = ⊤

full_name: LocalizedModule.subsingleton_iff
code: lemma LocalizedModule.subsingleton_iff {S : Submonoid R} :
    Subsingleton (LocalizedModule S M) ↔ ∀ m : M, ∃ r ∈ S, r • m = 0 
goal: Subsingleton (LocalizedModule S M) ↔ ∀ (m : M), ∃ r ∈ S, r • m = 0