File: Mathlib/RingTheory/OreLocalization/Ring.lean

full_name: OreLocalization.zero_smul
code: protected theorem zero_smul (x : X[S⁻¹]) : (0 : R[S⁻¹]) • x = 0 
goal: 0 • x = 0

full_name: OreLocalization.add_smul
code: protected theorem add_smul (y z : R[S⁻¹]) (x : X[S⁻¹]) :
    (y + z) • x = y • x + z • x 
goal: (y + z) • x = y • x + z • x

full_name: OreLocalization.zero_mul
code: protected theorem zero_mul (x : R[S⁻¹]) : 0 * x = 0 
goal: 0 * x = 0

full_name: OreLocalization.mul_zero
code: protected theorem mul_zero (x : R[S⁻¹]) : x * 0 = 0 
goal: x * 0 = 0

full_name: OreLocalization.left_distrib
code: protected theorem left_distrib (x y z : R[S⁻¹]) : x * (y + z) = x * y + x * z 
goal: x * (y + z) = x * y + x * z

full_name: OreLocalization.right_distrib
code: theorem right_distrib (x y z : R[S⁻¹]) : (x + y) * z = x * z + y * z 
goal: (x + y) * z = x * z + y * z

full_name: OreLocalization.instSemiring
code: instance : Semiring R[S⁻¹] 
goal: Semiring (OreLocalization S R)

full_name: OreLocalization.instModule
code: instance : Module R[S⁻¹] X[S⁻¹] 
goal: Module (OreLocalization S R) (OreLocalization S X)

full_name: OreLocalization.instModuleOfIsScalarTower
code: instance {R₀} [Semiring R₀] [Module R₀ X] [Module R₀ R]
    [IsScalarTower R₀ R X] [IsScalarTower R₀ R R] :
    Module R₀ X[S⁻¹] 
goal: Module R₀ (OreLocalization S X)

full_name: OreLocalization.nsmul_eq_nsmul
code: @[simp]
lemma nsmul_eq_nsmul (n : ℕ) (x : X[S⁻¹]) :
    letI inst := OreLocalization.instModuleOfIsScalarTower (R₀ := ℕ) (R := R) (X := X) (S := S)
    HSMul.hSMul (self := @instHSMul _ _ inst.toSMul) n x = n • x 
goal: n • x = n • x

full_name: OreLocalization.numeratorRingHom_apply
code: /-- The ring homomorphism from `R` to `R[S⁻¹]`, mapping `r : R` to the fraction `r /ₒ 1`. -/
@[simps!]
def numeratorRingHom : R →+* R[S⁻¹] 
goal: OreLocalization.numeratorRingHom r = r /ₒ 1

full_name: OreLocalization.numeratorRingHom
code: /-- The ring homomorphism from `R` to `R[S⁻¹]`, mapping `r : R` to the fraction `r /ₒ 1`. -/
@[simps!]
def numeratorRingHom : R →+* R[S⁻¹] 
goal: R →+* OreLocalization S R

full_name: OreLocalization.instAlgebra
code: instance {R₀} [CommSemiring R₀] [Algebra R₀ R] : Algebra R₀ R[S⁻¹] 
goal: Algebra R₀ (OreLocalization S R)

full_name: OreLocalization.universalHom
code: /-- The universal lift from a ring homomorphism `f : R →+* T`, which maps elements in `S` to
units of `T`, to a ring homomorphism `R[S⁻¹] →+* T`. This extends the construction on
monoids. -/
def universalHom : R[S⁻¹] →+* T 
goal: OreLocalization S R →+* T

full_name: OreLocalization.universalHom_apply
code: theorem universalHom_apply {r : R} {s : S} :
    universalHom f fS hf (r /ₒ s) = ((fS s)⁻¹ : Units T) * f r 
goal: (OreLocalization.universalHom f fS hf) (r /ₒ s) = ↑(fS s)⁻¹ * f r

full_name: OreLocalization.universalHom_commutes
code: theorem universalHom_commutes {r : R} : universalHom f fS hf (numeratorHom r) = f r 
goal: (OreLocalization.universalHom f fS hf) (OreLocalization.numeratorHom r) = f r

full_name: OreLocalization.universalHom_unique
code: theorem universalHom_unique (φ : R[S⁻¹] →+* T) (huniv : ∀ r : R, φ (numeratorHom r) = f r) :
    φ = universalHom f fS hf 
goal: φ = OreLocalization.universalHom f fS hf

full_name: OreLocalization.instRing
code: instance : Ring R[S⁻¹] 
goal: Ring (OreLocalization S R)

full_name: OreLocalization.zsmul_eq_zsmul
code: @[simp]
lemma zsmul_eq_zsmul (n : ℤ) (x : X[S⁻¹]) :
    letI inst := OreLocalization.instModuleOfIsScalarTower (R₀ := ℤ) (R := R) (X := X) (S := S)
    HSMul.hSMul (self := @instHSMul _ _ inst.toSMul) n x = n • x 
goal: n • x = n • x

full_name: OreLocalization.numeratorHom_inj
code: theorem numeratorHom_inj (hS : S ≤ nonZeroDivisorsRight R) :
    Function.Injective (numeratorHom : R → R[S⁻¹]) 
goal: Function.Injective ⇑OreLocalization.numeratorHom

full_name: OreLocalization.subsingleton_iff
code: theorem subsingleton_iff :
    Subsingleton R[S⁻¹] ↔ 0 ∈ S 
goal: Subsingleton (OreLocalization S R) ↔ 0 ∈ S

full_name: OreLocalization.nontrivial_iff
code: theorem nontrivial_iff :
    Nontrivial R[S⁻¹] ↔ 0 ∉ S 
goal: Nontrivial (OreLocalization S R) ↔ 0 ∉ S

full_name: OreLocalization.nontrivial_of_nonZeroDivisors
code: theorem nontrivial_of_nonZeroDivisors [Nontrivial R] (hS : S ≤ R⁰) :
    Nontrivial R[S⁻¹] 
goal: Nontrivial (OreLocalization S R)

full_name: OreLocalization.nontrivial
code: instance nontrivial : Nontrivial R[R⁰⁻¹] 
goal: Nontrivial (OreLocalization (nonZeroDivisors R) R)

full_name: OreLocalization.inv
code: /-- The inversion of Ore fractions for a ring without zero divisors, satisying `0⁻¹ = 0` and
`(r /ₒ r')⁻¹ = r' /ₒ r` for `r ≠ 0`. -/
@[irreducible]
protected def inv : R[R⁰⁻¹] → R[R⁰⁻¹] 
goal: OreLocalization (nonZeroDivisors R) R → OreLocalization (nonZeroDivisors R) R

full_name: OreLocalization.inv'
code: instance inv' : Inv R[R⁰⁻¹] 
goal: Inv (OreLocalization (nonZeroDivisors R) R)

full_name: OreLocalization.inv_def
code: protected theorem inv_def {r : R} {s : R⁰} :
    (r /ₒ s)⁻¹ =
      if hr : r = (0 : R) then (0 : R[R⁰⁻¹])
      else s /ₒ ⟨r, fun _ => eq_zero_of_ne_zero_of_mul_right_eq_zero hr⟩ 
goal: (r /ₒ s)⁻¹ = if hr : r = 0 then 0 else ↑s /ₒ ⟨r, ⋯⟩

full_name: OreLocalization.mul_inv_cancel
code: protected theorem mul_inv_cancel (x : R[R⁰⁻¹]) (h : x ≠ 0) : x * x⁻¹ = 1 
goal: x * x⁻¹ = 1

full_name: OreLocalization.inv_zero
code: protected theorem inv_zero : (0 : R[R⁰⁻¹])⁻¹ = 0 
goal: 0⁻¹ = 0

full_name: OreLocalization.instDivisionRingNonZeroDivisors
code: instance : DivisionRing R[R⁰⁻¹] 
goal: DivisionRing (OreLocalization (nonZeroDivisors R) R)

full_name: OreLocalization.instCommSemiring
code: instance : CommSemiring R[S⁻¹] 
goal: CommSemiring (OreLocalization S R)

full_name: OreLocalization.instCommRing
code: instance : CommRing R[S⁻¹] 
goal: CommRing (OreLocalization S R)

full_name: OreLocalization.instFieldNonZeroDivisors
code: noncomputable
instance : Field R[R⁰⁻¹] 
goal: Field (OreLocalization (nonZeroDivisors R) R)