File: Mathlib/RingTheory/OreLocalization/Basic.lean

full_name: OreLocalization.oreEqv
code: /-- The setoid on `R × S` used for the Ore localization. -/
@[to_additive AddOreLocalization.oreEqv "The setoid on `R × S` used for the Ore localization."]
def oreEqv : Setoid (X × S) 
goal: Setoid (X × ↥S)

full_name: AddOreLocalization.oreEqv
code: /-- The setoid on `R × S` used for the Ore localization. -/
@[to_additive AddOreLocalization.oreEqv "The setoid on `R × S` used for the Ore localization."]
def oreEqv : Setoid (X × S) 
goal: Setoid (X × ↥S)

full_name: OreLocalization
code: /-- The Ore localization of a monoid and a submonoid fulfilling the Ore condition. -/
@[to_additive AddOreLocalization "The Ore localization of an additive monoid and a submonoid
fulfilling the Ore condition."]
def OreLocalization {R : Type*} [Monoid R] (S : Submonoid R) [OreSet S]
    (X : Type*) [MulAction R X] 
goal: Type (max u_1 u_2)

full_name: AddOreLocalization
code: /-- The Ore localization of a monoid and a submonoid fulfilling the Ore condition. -/
@[to_additive AddOreLocalization "The Ore localization of an additive monoid and a submonoid
fulfilling the Ore condition."]
def OreLocalization {R : Type*} [Monoid R] (S : Submonoid R) [OreSet S]
    (X : Type*) [MulAction R X] 
goal: Type (max u_1 u_2)

full_name: OreLocalization.«term__[_⁻¹_]»
code: @[inherit_doc OreLocalization]
scoped syntax:1075 term noWs atomic("[" term "⁻¹" noWs "]") : term
goal: Lean.TrailingParserDescr

full_name: OreLocalization.«_aux_Mathlib_RingTheory_OreLocalization_Basic___macroRules_term__[_]_1»
code: macro_rules | `($R[$S⁻¹]) => ``(OreLocalization $S $R)
goal: Lean.Macro

full_name: AddOreLocalization.oreSub
code: /-- The division in the Ore localization `X[S⁻¹]`, as a fraction of an element of `X` and `S`. -/
@[to_additive "The subtraction in the Ore localization,
as a difference of an element of `X` and `S`."]
def oreDiv (r : X) (s : S) : X[S⁻¹] 
goal: AddOreLocalization S X

full_name: OreLocalization.oreDiv
code: /-- The division in the Ore localization `X[S⁻¹]`, as a fraction of an element of `X` and `S`. -/
@[to_additive "The subtraction in the Ore localization,
as a difference of an element of `X` and `S`."]
def oreDiv (r : X) (s : S) : X[S⁻¹] 
goal: OreLocalization S X

full_name: OreLocalization._aux_Mathlib_RingTheory_OreLocalization_Basic___unexpand_OreLocalization_oreDiv_1
code: @[inherit_doc]
infixl:70 " /ₒ " => oreDiv
goal: Lean.PrettyPrinter.Unexpander

full_name: OreLocalization.«_aux_Mathlib_RingTheory_OreLocalization_Basic___macroRules_OreLocalization_term_/ₒ__1»
code: @[inherit_doc]
infixl:70 " /ₒ " => oreDiv
goal: Lean.Macro

full_name: OreLocalization._aux_Mathlib_RingTheory_OreLocalization_Basic___unexpand_AddOreLocalization_oreSub_1
code: @[inherit_doc]
infixl:65 " -ₒ " => _root_.AddOreLocalization.oreSub
goal: Lean.PrettyPrinter.Unexpander

full_name: OreLocalization.«_aux_Mathlib_RingTheory_OreLocalization_Basic___macroRules_OreLocalization_term_-ₒ__1»
code: @[inherit_doc]
infixl:65 " -ₒ " => _root_.AddOreLocalization.oreSub
goal: Lean.Macro

full_name: OreLocalization.ind
code: @[to_additive (attr := elab_as_elim, cases_eliminator, induction_eliminator)]
protected theorem ind {β : X[S⁻¹] → Prop}
    (c : ∀ (r : X) (s : S), β (r /ₒ s)) : ∀ q, β q 
goal: β q

full_name: AddOreLocalization.ind
code: @[to_additive (attr := elab_as_elim, cases_eliminator, induction_eliminator)]
protected theorem ind {β : X[S⁻¹] → Prop}
    (c : ∀ (r : X) (s : S), β (r /ₒ s)) : ∀ q, β q 
goal: β q

full_name: AddOreLocalization.oreSub_eq_iff
code: @[to_additive]
theorem oreDiv_eq_iff {r₁ r₂ : X} {s₁ s₂ : S} :
    r₁ /ₒ s₁ = r₂ /ₒ s₂ ↔ ∃ (u : S) (v : R), u • r₂ = v • r₁ ∧ u * s₂ = v * s₁ 
goal: r₁ -ₒ s₁ = r₂ -ₒ s₂ ↔ ∃ u v, u +ᵥ r₂ = v +ᵥ r₁ ∧ ↑u + ↑s₂ = v + ↑s₁

full_name: OreLocalization.oreDiv_eq_iff
code: @[to_additive]
theorem oreDiv_eq_iff {r₁ r₂ : X} {s₁ s₂ : S} :
    r₁ /ₒ s₁ = r₂ /ₒ s₂ ↔ ∃ (u : S) (v : R), u • r₂ = v • r₁ ∧ u * s₂ = v * s₁ 
goal: r₁ /ₒ s₁ = r₂ /ₒ s₂ ↔ ∃ u v, u • r₂ = v • r₁ ∧ ↑u * ↑s₂ = v * ↑s₁

full_name: OreLocalization.expand
code: /-- A fraction `r /ₒ s` is equal to its expansion by an arbitrary factor `t` if `t * s ∈ S`. -/
@[to_additive "A difference `r -ₒ s` is equal to its expansion by an
arbitrary translation `t` if `t + s ∈ S`."]
protected theorem expand (r : X) (s : S) (t : R) (hst : t * (s : R) ∈ S) :
    r /ₒ s = t • r /ₒ ⟨t * s, hst⟩ 
goal: r /ₒ s = t • r /ₒ ⟨t * ↑s, hst⟩

full_name: AddOreLocalization.expand
code: /-- A fraction `r /ₒ s` is equal to its expansion by an arbitrary factor `t` if `t * s ∈ S`. -/
@[to_additive "A difference `r -ₒ s` is equal to its expansion by an
arbitrary translation `t` if `t + s ∈ S`."]
protected theorem expand (r : X) (s : S) (t : R) (hst : t * (s : R) ∈ S) :
    r /ₒ s = t • r /ₒ ⟨t * s, hst⟩ 
goal: r -ₒ s = t +ᵥ r -ₒ ⟨t + ↑s, hst⟩

full_name: OreLocalization.expand'
code: /-- A fraction is equal to its expansion by a factor from `S`. -/
@[to_additive "A difference is equal to its expansion by a summand from `S`."]
protected theorem expand' (r : X) (s s' : S) : r /ₒ s = s' • r /ₒ (s' * s) 
goal: r /ₒ s = s' • r /ₒ (s' * s)

full_name: AddOreLocalization.expand'
code: /-- A fraction is equal to its expansion by a factor from `S`. -/
@[to_additive "A difference is equal to its expansion by a summand from `S`."]
protected theorem expand' (r : X) (s s' : S) : r /ₒ s = s' • r /ₒ (s' * s) 
goal: r -ₒ s = s' +ᵥ r -ₒ (s' + s)

full_name: OreLocalization.eq_of_num_factor_eq
code: /-- Fractions which differ by a factor of the numerator can be proven equal if
those factors expand to equal elements of `R`. -/
@[to_additive "Differences whose minuends differ by a common summand can be proven equal if
those summands expand to equal elements of `R`."]
protected theorem eq_of_num_factor_eq {r r' r₁ r₂ : R} {s t : S} (h : t * r = t * r') :
    r₁ * r * r₂ /ₒ s = r₁ * r' * r₂ /ₒ s 
goal: r₁ * r * r₂ /ₒ s = r₁ * r' * r₂ /ₒ s

full_name: AddOreLocalization.eq_of_num_factor_eq
code: /-- Fractions which differ by a factor of the numerator can be proven equal if
those factors expand to equal elements of `R`. -/
@[to_additive "Differences whose minuends differ by a common summand can be proven equal if
those summands expand to equal elements of `R`."]
protected theorem eq_of_num_factor_eq {r r' r₁ r₂ : R} {s t : S} (h : t * r = t * r') :
    r₁ * r * r₂ /ₒ s = r₁ * r' * r₂ /ₒ s 
goal: r₁ + r + r₂ -ₒ s = r₁ + r' + r₂ -ₒ s

full_name: AddOreLocalization.liftExpand
code: /-- A function or predicate over `X` and `S` can be lifted to `X[S⁻¹]` if it is invariant
under expansion on the left. -/
@[to_additive "A function or predicate over `X` and `S` can be lifted to the localizaton if it is
invariant under expansion on the left."]
def liftExpand {C : Sort*} (P : X → S → C)
    (hP : ∀ (r : X) (t : R) (s : S) (ht : t * s ∈ S), P r s = P (t • r) ⟨t * s, ht⟩) :
    X[S⁻¹] → C 
goal: AddOreLocalization S X → C

full_name: OreLocalization.liftExpand
code: /-- A function or predicate over `X` and `S` can be lifted to `X[S⁻¹]` if it is invariant
under expansion on the left. -/
@[to_additive "A function or predicate over `X` and `S` can be lifted to the localizaton if it is
invariant under expansion on the left."]
def liftExpand {C : Sort*} (P : X → S → C)
    (hP : ∀ (r : X) (t : R) (s : S) (ht : t * s ∈ S), P r s = P (t • r) ⟨t * s, ht⟩) :
    X[S⁻¹] → C 
goal: OreLocalization S X → C

full_name: OreLocalization.liftExpand_of
code: @[to_additive (attr := simp)]
theorem liftExpand_of {C : Sort*} {P : X → S → C}
    {hP : ∀ (r : X) (t : R) (s : S) (ht : t * s ∈ S), P r s = P (t • r) ⟨t * s, ht⟩} (r : X)
    (s : S) : liftExpand P hP (r /ₒ s) = P r s 
goal: OreLocalization.liftExpand P hP (r /ₒ s) = P r s

full_name: AddOreLocalization.liftExpand_of
code: @[to_additive (attr := simp)]
theorem liftExpand_of {C : Sort*} {P : X → S → C}
    {hP : ∀ (r : X) (t : R) (s : S) (ht : t * s ∈ S), P r s = P (t • r) ⟨t * s, ht⟩} (r : X)
    (s : S) : liftExpand P hP (r /ₒ s) = P r s 
goal: AddOreLocalization.liftExpand P hP (r -ₒ s) = P r s

full_name: OreLocalization.lift₂Expand
code: /-- A version of `liftExpand` used to simultaneously lift functions with two arguments
in `X[S⁻¹]`. -/
@[to_additive "A version of `liftExpand` used to simultaneously lift functions with two arguments"]
def lift₂Expand {C : Sort*} (P : X → S → X → S → C)
    (hP :
      ∀ (r₁ : X) (t₁ : R) (s₁ : S) (ht₁ : t₁ * s₁ ∈ S) (r₂ : X) (t₂ : R) (s₂ : S)
        (ht₂ : t₂ * s₂ ∈ S),
        P r₁ s₁ r₂ s₂ = P (t₁ • r₁) ⟨t₁ * s₁, ht₁⟩ (t₂ • r₂) ⟨t₂ * s₂, ht₂⟩) :
    X[S⁻¹] → X[S⁻¹] → C 
goal: OreLocalization S X → OreLocalization S X → C

full_name: AddOreLocalization.lift₂Expand
code: /-- A version of `liftExpand` used to simultaneously lift functions with two arguments
in `X[S⁻¹]`. -/
@[to_additive "A version of `liftExpand` used to simultaneously lift functions with two arguments"]
def lift₂Expand {C : Sort*} (P : X → S → X → S → C)
    (hP :
      ∀ (r₁ : X) (t₁ : R) (s₁ : S) (ht₁ : t₁ * s₁ ∈ S) (r₂ : X) (t₂ : R) (s₂ : S)
        (ht₂ : t₂ * s₂ ∈ S),
        P r₁ s₁ r₂ s₂ = P (t₁ • r₁) ⟨t₁ * s₁, ht₁⟩ (t₂ • r₂) ⟨t₂ * s₂, ht₂⟩) :
    X[S⁻¹] → X[S⁻¹] → C 
goal: AddOreLocalization S X → AddOreLocalization S X → C

full_name: OreLocalization.lift₂Expand_of
code: @[to_additive (attr := simp)]
theorem lift₂Expand_of {C : Sort*} {P : X → S → X → S → C}
    {hP :
      ∀ (r₁ : X) (t₁ : R) (s₁ : S) (ht₁ : t₁ * s₁ ∈ S) (r₂ : X) (t₂ : R) (s₂ : S)
        (ht₂ : t₂ * s₂ ∈ S),
        P r₁ s₁ r₂ s₂ = P (t₁ • r₁) ⟨t₁ * s₁, ht₁⟩ (t₂ • r₂) ⟨t₂ * s₂, ht₂⟩}
    (r₁ : X) (s₁ : S) (r₂ : X) (s₂ : S) : lift₂Expand P hP (r₁ /ₒ s₁) (r₂ /ₒ s₂) = P r₁ s₁ r₂ s₂ 
goal: OreLocalization.lift₂Expand P hP (r₁ /ₒ s₁) (r₂ /ₒ s₂) = P r₁ s₁ r₂ s₂

full_name: AddOreLocalization.lift₂Expand_of
code: @[to_additive (attr := simp)]
theorem lift₂Expand_of {C : Sort*} {P : X → S → X → S → C}
    {hP :
      ∀ (r₁ : X) (t₁ : R) (s₁ : S) (ht₁ : t₁ * s₁ ∈ S) (r₂ : X) (t₂ : R) (s₂ : S)
        (ht₂ : t₂ * s₂ ∈ S),
        P r₁ s₁ r₂ s₂ = P (t₁ • r₁) ⟨t₁ * s₁, ht₁⟩ (t₂ • r₂) ⟨t₂ * s₂, ht₂⟩}
    (r₁ : X) (s₁ : S) (r₂ : X) (s₂ : S) : lift₂Expand P hP (r₁ /ₒ s₁) (r₂ /ₒ s₂) = P r₁ s₁ r₂ s₂ 
goal: AddOreLocalization.lift₂Expand P hP (r₁ -ₒ s₁) (r₂ -ₒ s₂) = P r₁ s₁ r₂ s₂

full_name: _private.Mathlib.RingTheory.OreLocalization.Basic.0.OreLocalization.vadd'
code: @[to_additive]
private def smul' (r₁ : R) (s₁ : S) (r₂ : X) (s₂ : S) : X[S⁻¹] 
goal: AddOreLocalization S X

full_name: _private.Mathlib.RingTheory.OreLocalization.Basic.0.OreLocalization.smul'
code: @[to_additive]
private def smul' (r₁ : R) (s₁ : S) (r₂ : X) (s₂ : S) : X[S⁻¹] 
goal: OreLocalization S X

full_name: _private.Mathlib.RingTheory.OreLocalization.Basic.0.OreLocalization.vadd'_char
code: @[to_additive]
private theorem smul'_char (r₁ : R) (r₂ : X) (s₁ s₂ : S) (u : S) (v : R) (huv : u * r₁ = v * s₂) :
    OreLocalization.smul' r₁ s₁ r₂ s₂ = v • r₂ /ₒ (u * s₁) 
goal: OreLocalization.vadd' r₁ s₁ r₂ s₂ = v +ᵥ r₂ -ₒ (u + s₁)

full_name: _private.Mathlib.RingTheory.OreLocalization.Basic.0.OreLocalization.smul'_char
code: @[to_additive]
private theorem smul'_char (r₁ : R) (r₂ : X) (s₁ s₂ : S) (u : S) (v : R) (huv : u * r₁ = v * s₂) :
    OreLocalization.smul' r₁ s₁ r₂ s₂ = v • r₂ /ₒ (u * s₁) 
goal: OreLocalization.smul' r₁ s₁ r₂ s₂ = v • r₂ /ₒ (u * s₁)

full_name: _private.Mathlib.RingTheory.OreLocalization.Basic.0.OreLocalization.smul''
code: /-- The multiplication on the Ore localization of monoids. -/
@[to_additive]
private def smul'' (r : R) (s : S) : X[S⁻¹] → X[S⁻¹] 
goal: OreLocalization S X → OreLocalization S X

full_name: _private.Mathlib.RingTheory.OreLocalization.Basic.0.OreLocalization.vadd''
code: /-- The multiplication on the Ore localization of monoids. -/
@[to_additive]
private def smul'' (r : R) (s : S) : X[S⁻¹] → X[S⁻¹] 
goal: AddOreLocalization S X → AddOreLocalization S X

full_name: OreLocalization.smul
code: /-- The scalar multiplication on the Ore localization of monoids. -/
@[to_additive (attr := irreducible)
  "the vector addition on the Ore localization of additive monoids."]
protected def smul : R[S⁻¹] → X[S⁻¹] → X[S⁻¹] 
goal: OreLocalization S R → OreLocalization S X → OreLocalization S X

full_name: AddOreLocalization.vadd
code: /-- The scalar multiplication on the Ore localization of monoids. -/
@[to_additive (attr := irreducible)
  "the vector addition on the Ore localization of additive monoids."]
protected def smul : R[S⁻¹] → X[S⁻¹] → X[S⁻¹] 
goal: AddOreLocalization S R → AddOreLocalization S X → AddOreLocalization S X

full_name: AddOreLocalization.instVAdd
code: @[to_additive]
instance : SMul R[S⁻¹] X[S⁻¹] 
goal: VAdd (AddOreLocalization S R) (AddOreLocalization S X)

full_name: OreLocalization.instSMul
code: @[to_additive]
instance : SMul R[S⁻¹] X[S⁻¹] 
goal: SMul (OreLocalization S R) (OreLocalization S X)

full_name: OreLocalization.instMul
code: @[to_additive]
instance : Mul R[S⁻¹] 
goal: Mul (OreLocalization S R)

full_name: AddOreLocalization.instAdd
code: @[to_additive]
instance : Mul R[S⁻¹] 
goal: Add (AddOreLocalization S R)

full_name: OreLocalization.oreDiv_smul_oreDiv
code: @[to_additive]
theorem oreDiv_smul_oreDiv {r₁ : R} {r₂ : X} {s₁ s₂ : S} :
    (r₁ /ₒ s₁) • (r₂ /ₒ s₂) = oreNum r₁ s₂ • r₂ /ₒ (oreDenom r₁ s₂ * s₁) 
goal: (r₁ /ₒ s₁) • (r₂ /ₒ s₂) = OreLocalization.oreNum r₁ s₂ • r₂ /ₒ (OreLocalization.oreDenom r₁ s₂ * s₁)

full_name: AddOreLocalization.oreSub_vadd_oreSub
code: @[to_additive]
theorem oreDiv_smul_oreDiv {r₁ : R} {r₂ : X} {s₁ s₂ : S} :
    (r₁ /ₒ s₁) • (r₂ /ₒ s₂) = oreNum r₁ s₂ • r₂ /ₒ (oreDenom r₁ s₂ * s₁) 
goal: r₁ -ₒ s₁ +ᵥ (r₂ -ₒ s₂) = AddOreLocalization.oreMin r₁ s₂ +ᵥ r₂ -ₒ (AddOreLocalization.oreSubtra r₁ s₂ + s₁)

full_name: AddOreLocalization.oreSub_add_oreSub
code: @[to_additive]
theorem oreDiv_mul_oreDiv {r₁ : R} {r₂ : R} {s₁ s₂ : S} :
    (r₁ /ₒ s₁) * (r₂ /ₒ s₂) = oreNum r₁ s₂ * r₂ /ₒ (oreDenom r₁ s₂ * s₁) 
goal: r₁ -ₒ s₁ + (r₂ -ₒ s₂) = AddOreLocalization.oreMin r₁ s₂ + r₂ -ₒ (AddOreLocalization.oreSubtra r₁ s₂ + s₁)

full_name: OreLocalization.oreDiv_mul_oreDiv
code: @[to_additive]
theorem oreDiv_mul_oreDiv {r₁ : R} {r₂ : R} {s₁ s₂ : S} :
    (r₁ /ₒ s₁) * (r₂ /ₒ s₂) = oreNum r₁ s₂ * r₂ /ₒ (oreDenom r₁ s₂ * s₁) 
goal: r₁ /ₒ s₁ * (r₂ /ₒ s₂) = OreLocalization.oreNum r₁ s₂ * r₂ /ₒ (OreLocalization.oreDenom r₁ s₂ * s₁)

full_name: OreLocalization.oreDiv_smul_char
code: /-- A characterization lemma for the scalar multiplication on the Ore localization,
allowing for a choice of Ore numerator and Ore denominator. -/
@[to_additive "A characterization lemma for the vector addition on the Ore localization,
allowing for a choice of Ore minuend and Ore subtrahend."]
theorem oreDiv_smul_char (r₁ : R) (r₂ : X) (s₁ s₂ : S) (r' : R) (s' : S) (huv : s' * r₁ = r' * s₂) :
    (r₁ /ₒ s₁) • (r₂ /ₒ s₂) = r' • r₂ /ₒ (s' * s₁) 
goal: (r₁ /ₒ s₁) • (r₂ /ₒ s₂) = r' • r₂ /ₒ (s' * s₁)

full_name: AddOreLocalization.oreSub_vadd_char
code: /-- A characterization lemma for the scalar multiplication on the Ore localization,
allowing for a choice of Ore numerator and Ore denominator. -/
@[to_additive "A characterization lemma for the vector addition on the Ore localization,
allowing for a choice of Ore minuend and Ore subtrahend."]
theorem oreDiv_smul_char (r₁ : R) (r₂ : X) (s₁ s₂ : S) (r' : R) (s' : S) (huv : s' * r₁ = r' * s₂) :
    (r₁ /ₒ s₁) • (r₂ /ₒ s₂) = r' • r₂ /ₒ (s' * s₁) 
goal: r₁ -ₒ s₁ +ᵥ (r₂ -ₒ s₂) = r' +ᵥ r₂ -ₒ (s' + s₁)

full_name: AddOreLocalization.oreSub_add_char
code: /-- A characterization lemma for the multiplication on the Ore localization, allowing for a choice
of Ore numerator and Ore denominator. -/
@[to_additive "A characterization lemma for the addition on the Ore localization,
allowing for a choice of Ore minuend and Ore subtrahend."]
theorem oreDiv_mul_char (r₁ r₂ : R) (s₁ s₂ : S) (r' : R) (s' : S) (huv : s' * r₁ = r' * s₂) :
    r₁ /ₒ s₁ * (r₂ /ₒ s₂) = r' * r₂ /ₒ (s' * s₁) 
goal: r₁ -ₒ s₁ + (r₂ -ₒ s₂) = r' + r₂ -ₒ (s' + s₁)

full_name: OreLocalization.oreDiv_mul_char
code: /-- A characterization lemma for the multiplication on the Ore localization, allowing for a choice
of Ore numerator and Ore denominator. -/
@[to_additive "A characterization lemma for the addition on the Ore localization,
allowing for a choice of Ore minuend and Ore subtrahend."]
theorem oreDiv_mul_char (r₁ r₂ : R) (s₁ s₂ : S) (r' : R) (s' : S) (huv : s' * r₁ = r' * s₂) :
    r₁ /ₒ s₁ * (r₂ /ₒ s₂) = r' * r₂ /ₒ (s' * s₁) 
goal: r₁ /ₒ s₁ * (r₂ /ₒ s₂) = r' * r₂ /ₒ (s' * s₁)

full_name: AddOreLocalization.oreSubVAddChar'
code: /-- Another characterization lemma for the scalar multiplication on the Ore localizaion delivering
Ore witnesses and conditions bundled in a sigma type. -/
@[to_additive "Another characterization lemma for the vector addition on the
  Ore localizaion delivering Ore witnesses and conditions bundled in a sigma type."]
def oreDivSMulChar' (r₁ : R) (r₂ : X) (s₁ s₂ : S) :
    Σ'r' : R, Σ's' : S, s' * r₁ = r' * s₂ ∧ (r₁ /ₒ s₁) • (r₂ /ₒ s₂) = r' • r₂ /ₒ (s' * s₁) 
goal: (r' : R) ×' (s' : ↥S) ×' ↑s' + r₁ = r' + ↑s₂ ∧ r₁ -ₒ s₁ +ᵥ (r₂ -ₒ s₂) = r' +ᵥ r₂ -ₒ (s' + s₁)

full_name: OreLocalization.oreDivSMulChar'
code: /-- Another characterization lemma for the scalar multiplication on the Ore localizaion delivering
Ore witnesses and conditions bundled in a sigma type. -/
@[to_additive "Another characterization lemma for the vector addition on the
  Ore localizaion delivering Ore witnesses and conditions bundled in a sigma type."]
def oreDivSMulChar' (r₁ : R) (r₂ : X) (s₁ s₂ : S) :
    Σ'r' : R, Σ's' : S, s' * r₁ = r' * s₂ ∧ (r₁ /ₒ s₁) • (r₂ /ₒ s₂) = r' • r₂ /ₒ (s' * s₁) 
goal: (r' : R) ×' (s' : ↥S) ×' ↑s' * r₁ = r' * ↑s₂ ∧ (r₁ /ₒ s₁) • (r₂ /ₒ s₂) = r' • r₂ /ₒ (s' * s₁)

full_name: AddOreLocalization.oreSubAddChar'
code: /-- Another characterization lemma for the multiplication on the Ore localizaion delivering
Ore witnesses and conditions bundled in a sigma type. -/
@[to_additive "Another characterization lemma for the addition on the Ore localizaion delivering
  Ore witnesses and conditions bundled in a sigma type."]
def oreDivMulChar' (r₁ r₂ : R) (s₁ s₂ : S) :
    Σ'r' : R, Σ's' : S, s' * r₁ = r' * s₂ ∧ r₁ /ₒ s₁ * (r₂ /ₒ s₂) = r' * r₂ /ₒ (s' * s₁) 
goal: (r' : R) ×' (s' : ↥S) ×' ↑s' + r₁ = r' + ↑s₂ ∧ r₁ -ₒ s₁ + (r₂ -ₒ s₂) = r' + r₂ -ₒ (s' + s₁)

full_name: OreLocalization.oreDivMulChar'
code: /-- Another characterization lemma for the multiplication on the Ore localizaion delivering
Ore witnesses and conditions bundled in a sigma type. -/
@[to_additive "Another characterization lemma for the addition on the Ore localizaion delivering
  Ore witnesses and conditions bundled in a sigma type."]
def oreDivMulChar' (r₁ r₂ : R) (s₁ s₂ : S) :
    Σ'r' : R, Σ's' : S, s' * r₁ = r' * s₂ ∧ r₁ /ₒ s₁ * (r₂ /ₒ s₂) = r' * r₂ /ₒ (s' * s₁) 
goal: (r' : R) ×' (s' : ↥S) ×' ↑s' * r₁ = r' * ↑s₂ ∧ r₁ /ₒ s₁ * (r₂ /ₒ s₂) = r' * r₂ /ₒ (s' * s₁)

full_name: OreLocalization.one
code: /-- `1` in the localization, defined as `1 /ₒ 1`. -/
@[to_additive (attr := irreducible) "`0` in the additive localization, defined as `0 -ₒ 0`."]
protected def one : R[S⁻¹] 
goal: OreLocalization S R

full_name: AddOreLocalization.zero
code: /-- `1` in the localization, defined as `1 /ₒ 1`. -/
@[to_additive (attr := irreducible) "`0` in the additive localization, defined as `0 -ₒ 0`."]
protected def one : R[S⁻¹] 
goal: AddOreLocalization S R

full_name: OreLocalization.instOne
code: @[to_additive]
instance : One R[S⁻¹] 
goal: One (OreLocalization S R)

full_name: AddOreLocalization.instZero
code: @[to_additive]
instance : One R[S⁻¹] 
goal: Zero (AddOreLocalization S R)

full_name: AddOreLocalization.zero_def
code: @[to_additive]
protected theorem one_def : (1 : R[S⁻¹]) = 1 /ₒ 1 
goal: 0 = 0 -ₒ 0

full_name: OreLocalization.one_def
code: @[to_additive]
protected theorem one_def : (1 : R[S⁻¹]) = 1 /ₒ 1 
goal: 1 = 1 /ₒ 1

full_name: OreLocalization.instInhabited
code: @[to_additive]
instance : Inhabited R[S⁻¹] 
goal: Inhabited (OreLocalization S R)

full_name: AddOreLocalization.instInhabited
code: @[to_additive]
instance : Inhabited R[S⁻¹] 
goal: Inhabited (AddOreLocalization S R)

full_name: AddOreLocalization.sub_eq_zero'
code: @[to_additive (attr := simp)]
protected theorem div_eq_one' {r : R} (hr : r ∈ S) : r /ₒ ⟨r, hr⟩ = 1 
goal: r -ₒ ⟨r, hr⟩ = 0

full_name: OreLocalization.div_eq_one'
code: @[to_additive (attr := simp)]
protected theorem div_eq_one' {r : R} (hr : r ∈ S) : r /ₒ ⟨r, hr⟩ = 1 
goal: r /ₒ ⟨r, hr⟩ = 1

full_name: OreLocalization.div_eq_one
code: @[to_additive (attr := simp)]
protected theorem div_eq_one {s : S} : (s : R) /ₒ s = 1 
goal: ↑s /ₒ s = 1

full_name: AddOreLocalization.sub_eq_zero
code: @[to_additive (attr := simp)]
protected theorem div_eq_one {s : S} : (s : R) /ₒ s = 1 
goal: ↑s -ₒ s = 0

full_name: OreLocalization.one_smul
code: @[to_additive]
protected theorem one_smul (x : X[S⁻¹]) : (1 : R[S⁻¹]) • x = x 
goal: 1 • x = x

full_name: AddOreLocalization.zero_vadd
code: @[to_additive]
protected theorem one_smul (x : X[S⁻¹]) : (1 : R[S⁻¹]) • x = x 
goal: 0 +ᵥ x = x

full_name: OreLocalization.one_mul
code: @[to_additive]
protected theorem one_mul (x : R[S⁻¹]) : 1 * x = x 
goal: 1 * x = x

full_name: AddOreLocalization.zero_add
code: @[to_additive]
protected theorem one_mul (x : R[S⁻¹]) : 1 * x = x 
goal: 0 + x = x

full_name: OreLocalization.mul_one
code: @[to_additive]
protected theorem mul_one (x : R[S⁻¹]) : x * 1 = x 
goal: x * 1 = x

full_name: AddOreLocalization.add_zero
code: @[to_additive]
protected theorem mul_one (x : R[S⁻¹]) : x * 1 = x 
goal: x + 0 = x

full_name: AddOreLocalization.add_vadd
code: @[to_additive]
protected theorem mul_smul (x y : R[S⁻¹]) (z : X[S⁻¹]) : (x * y) • z = x • y • z 
goal: x + y +ᵥ z = x +ᵥ (y +ᵥ z)

full_name: OreLocalization.mul_smul
code: @[to_additive]
protected theorem mul_smul (x y : R[S⁻¹]) (z : X[S⁻¹]) : (x * y) • z = x • y • z 
goal: (x * y) • z = x • y • z

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

full_name: AddOreLocalization.add_assoc
code: @[to_additive]
protected theorem mul_assoc (x y z : R[S⁻¹]) : x * y * z = x * (y * z) 
goal: x + y + z = x + (y + z)

full_name: OreLocalization.npow
code: /-- `npow` of `OreLocalization` -/
@[to_additive (attr := irreducible) "`nsmul` of `AddOreLocalization`"]
protected def npow : ℕ → R[S⁻¹] → R[S⁻¹] 
goal: ℕ → OreLocalization S R → OreLocalization S R

full_name: AddOreLocalization.nsmul
code: /-- `npow` of `OreLocalization` -/
@[to_additive (attr := irreducible) "`nsmul` of `AddOreLocalization`"]
protected def npow : ℕ → R[S⁻¹] → R[S⁻¹] 
goal: ℕ → AddOreLocalization S R → AddOreLocalization S R

full_name: OreLocalization.instMonoid
code: @[to_additive]
instance : Monoid R[S⁻¹] 
goal: Monoid (OreLocalization S R)

full_name: AddOreLocalization.instAddMonoid
code: @[to_additive]
instance : Monoid R[S⁻¹] 
goal: AddMonoid (AddOreLocalization S R)

full_name: AddOreLocalization.instAddActionOreLocalization
code: @[to_additive]
instance instMulActionOreLocalization : MulAction R[S⁻¹] X[S⁻¹] 
goal: AddAction (AddOreLocalization S R) (AddOreLocalization S X)

full_name: OreLocalization.instMulActionOreLocalization
code: @[to_additive]
instance instMulActionOreLocalization : MulAction R[S⁻¹] X[S⁻¹] 
goal: MulAction (OreLocalization S R) (OreLocalization S X)

full_name: AddOreLocalization.add_neg
code: @[to_additive]
protected theorem mul_inv (s s' : S) : ((s : R) /ₒ s') * ((s' : R) /ₒ s) = 1 
goal: ↑s -ₒ s' + (↑s' -ₒ s) = 0

full_name: OreLocalization.mul_inv
code: @[to_additive]
protected theorem mul_inv (s s' : S) : ((s : R) /ₒ s') * ((s' : R) /ₒ s) = 1 
goal: ↑s /ₒ s' * (↑s' /ₒ s) = 1

full_name: OreLocalization.one_div_smul
code: @[to_additive (attr := simp)]
protected theorem one_div_smul {r : X} {s t : S} : ((1 : R) /ₒ t) • (r /ₒ s) = r /ₒ (s * t) 
goal: (1 /ₒ t) • (r /ₒ s) = r /ₒ (s * t)

full_name: AddOreLocalization.zero_sub_vadd
code: @[to_additive (attr := simp)]
protected theorem one_div_smul {r : X} {s t : S} : ((1 : R) /ₒ t) • (r /ₒ s) = r /ₒ (s * t) 
goal: 0 -ₒ t +ᵥ (r -ₒ s) = r -ₒ (s + t)

full_name: OreLocalization.one_div_mul
code: @[to_additive (attr := simp)]
protected theorem one_div_mul {r : R} {s t : S} : (1 /ₒ t) * (r /ₒ s) = r /ₒ (s * t) 
goal: 1 /ₒ t * (r /ₒ s) = r /ₒ (s * t)

full_name: AddOreLocalization.zero_sub_add
code: @[to_additive (attr := simp)]
protected theorem one_div_mul {r : R} {s t : S} : (1 /ₒ t) * (r /ₒ s) = r /ₒ (s * t) 
goal: 0 -ₒ t + (r -ₒ s) = r -ₒ (s + t)

full_name: OreLocalization.smul_cancel
code: @[to_additive (attr := simp)]
protected theorem smul_cancel {r : X} {s t : S} : ((s : R) /ₒ t) • (r /ₒ s) = r /ₒ t 
goal: (↑s /ₒ t) • (r /ₒ s) = r /ₒ t

full_name: AddOreLocalization.vadd_cancel
code: @[to_additive (attr := simp)]
protected theorem smul_cancel {r : X} {s t : S} : ((s : R) /ₒ t) • (r /ₒ s) = r /ₒ t 
goal: ↑s -ₒ t +ᵥ (r -ₒ s) = r -ₒ t

full_name: OreLocalization.mul_cancel
code: @[to_additive (attr := simp)]
protected theorem mul_cancel {r : R} {s t : S} : ((s : R) /ₒ t) * (r /ₒ s) = r /ₒ t 
goal: ↑s /ₒ t * (r /ₒ s) = r /ₒ t

full_name: AddOreLocalization.add_cancel
code: @[to_additive (attr := simp)]
protected theorem mul_cancel {r : R} {s t : S} : ((s : R) /ₒ t) * (r /ₒ s) = r /ₒ t 
goal: ↑s -ₒ t + (r -ₒ s) = r -ₒ t

full_name: OreLocalization.smul_cancel'
code: @[to_additive (attr := simp)]
protected theorem smul_cancel' {r₁ : R} {r₂ : X} {s t : S} :
    ((r₁ * s) /ₒ t) • (r₂ /ₒ s) = (r₁ • r₂) /ₒ t 
goal: (r₁ * ↑s /ₒ t) • (r₂ /ₒ s) = r₁ • r₂ /ₒ t

full_name: AddOreLocalization.vadd_cancel'
code: @[to_additive (attr := simp)]
protected theorem smul_cancel' {r₁ : R} {r₂ : X} {s t : S} :
    ((r₁ * s) /ₒ t) • (r₂ /ₒ s) = (r₁ • r₂) /ₒ t 
goal: r₁ + ↑s -ₒ t +ᵥ (r₂ -ₒ s) = r₁ +ᵥ r₂ -ₒ t

full_name: AddOreLocalization.add_cancel'
code: @[to_additive (attr := simp)]
protected theorem mul_cancel' {r₁ r₂ : R} {s t : S} :
    ((r₁ * s) /ₒ t) * (r₂ /ₒ s) = (r₁ * r₂) /ₒ t 
goal: r₁ + ↑s -ₒ t + (r₂ -ₒ s) = r₁ + r₂ -ₒ t

full_name: OreLocalization.mul_cancel'
code: @[to_additive (attr := simp)]
protected theorem mul_cancel' {r₁ r₂ : R} {s t : S} :
    ((r₁ * s) /ₒ t) * (r₂ /ₒ s) = (r₁ * r₂) /ₒ t 
goal: r₁ * ↑s /ₒ t * (r₂ /ₒ s) = r₁ * r₂ /ₒ t

full_name: OreLocalization.smul_div_one
code: @[to_additive (attr := simp)]
theorem smul_div_one {p : R} {r : X} {s : S} : (p /ₒ s) • (r /ₒ 1) = (p • r) /ₒ s 
goal: (p /ₒ s) • (r /ₒ 1) = p • r /ₒ s

full_name: AddOreLocalization.vadd_sub_zero
code: @[to_additive (attr := simp)]
theorem smul_div_one {p : R} {r : X} {s : S} : (p /ₒ s) • (r /ₒ 1) = (p • r) /ₒ s 
goal: p -ₒ s +ᵥ (r -ₒ 0) = p +ᵥ r -ₒ s

full_name: AddOreLocalization.add_sub_zero
code: @[to_additive (attr := simp)]
theorem mul_div_one {p r : R} {s : S} : (p /ₒ s) * (r /ₒ 1) = (p * r) /ₒ s 
goal: p -ₒ s + (r -ₒ 0) = p + r -ₒ s

full_name: OreLocalization.mul_div_one
code: @[to_additive (attr := simp)]
theorem mul_div_one {p r : R} {s : S} : (p /ₒ s) * (r /ₒ 1) = (p * r) /ₒ s 
goal: p /ₒ s * (r /ₒ 1) = p * r /ₒ s

full_name: OreLocalization.numeratorUnit
code: /-- The fraction `s /ₒ 1` as a unit in `R[S⁻¹]`, where `s : S`. -/
@[to_additive "The difference `s -ₒ 0` as a an additive unit."]
def numeratorUnit (s : S) : Units R[S⁻¹] 
goal: (OreLocalization S R)ˣ

full_name: AddOreLocalization.numeratorAddUnit
code: /-- The fraction `s /ₒ 1` as a unit in `R[S⁻¹]`, where `s : S`. -/
@[to_additive "The difference `s -ₒ 0` as a an additive unit."]
def numeratorUnit (s : S) : Units R[S⁻¹] 
goal: AddUnits (AddOreLocalization S R)

full_name: OreLocalization.numeratorHom
code: /-- The multiplicative homomorphism from `R` to `R[S⁻¹]`, mapping `r : R` to the
fraction `r /ₒ 1`. -/
@[to_additive "The additive homomorphism from `R` to `AddOreLocalization R S`,
  mapping `r : R` to the difference `r -ₒ 0`."]
def numeratorHom : R →* R[S⁻¹] 
goal: R →* OreLocalization S R

full_name: AddOreLocalization.numeratorHom
code: /-- The multiplicative homomorphism from `R` to `R[S⁻¹]`, mapping `r : R` to the
fraction `r /ₒ 1`. -/
@[to_additive "The additive homomorphism from `R` to `AddOreLocalization R S`,
  mapping `r : R` to the difference `r -ₒ 0`."]
def numeratorHom : R →* R[S⁻¹] 
goal: R →+ AddOreLocalization S R

full_name: OreLocalization.numeratorHom_apply
code: @[to_additive]
theorem numeratorHom_apply {r : R} : numeratorHom r = r /ₒ (1 : S) 
goal: OreLocalization.numeratorHom r = r /ₒ 1

full_name: AddOreLocalization.numeratorHom_apply
code: @[to_additive]
theorem numeratorHom_apply {r : R} : numeratorHom r = r /ₒ (1 : S) 
goal: AddOreLocalization.numeratorHom r = r -ₒ 0

full_name: OreLocalization.numerator_isUnit
code: @[to_additive]
theorem numerator_isUnit (s : S) : IsUnit (numeratorHom (s : R) : R[S⁻¹]) 
goal: IsUnit (OreLocalization.numeratorHom ↑s)

full_name: AddOreLocalization.numerator_isAddUnit
code: @[to_additive]
theorem numerator_isUnit (s : S) : IsUnit (numeratorHom (s : R) : R[S⁻¹]) 
goal: IsAddUnit (AddOreLocalization.numeratorHom ↑s)

full_name: OreLocalization.universalMulHom
code: /-- The universal lift from a morphism `R →* T`, which maps elements of `S` to units of `T`,
to a morphism `R[S⁻¹] →* T`. -/
@[to_additive "The universal lift from a morphism `R →+ T`, which maps elements of `S` to
  additive-units of `T`, to a morphism `AddOreLocalization R S →+ T`."]
def universalMulHom (hf : ∀ s : S, f s = fS s) : R[S⁻¹] →* T 
goal: OreLocalization S R →* T

full_name: AddOreLocalization.universalAddHom
code: /-- The universal lift from a morphism `R →* T`, which maps elements of `S` to units of `T`,
to a morphism `R[S⁻¹] →* T`. -/
@[to_additive "The universal lift from a morphism `R →+ T`, which maps elements of `S` to
  additive-units of `T`, to a morphism `AddOreLocalization R S →+ T`."]
def universalMulHom (hf : ∀ s : S, f s = fS s) : R[S⁻¹] →* T 
goal: AddOreLocalization S R →+ T

full_name: AddOreLocalization.universalAddHom_apply
code: @[to_additive]
theorem universalMulHom_apply {r : R} {s : S} :
    universalMulHom f fS hf (r /ₒ s) = ((fS s)⁻¹ : Units T) * f r 
goal: (AddOreLocalization.universalAddHom f fS hf) (r -ₒ s) = ↑(-fS s) + f r

full_name: OreLocalization.universalMulHom_apply
code: @[to_additive]
theorem universalMulHom_apply {r : R} {s : S} :
    universalMulHom f fS hf (r /ₒ s) = ((fS s)⁻¹ : Units T) * f r 
goal: (OreLocalization.universalMulHom f fS hf) (r /ₒ s) = ↑(fS s)⁻¹ * f r

full_name: AddOreLocalization.universalAddHom_commutes
code: @[to_additive]
theorem universalMulHom_commutes {r : R} : universalMulHom f fS hf (numeratorHom r) = f r 
goal: (AddOreLocalization.universalAddHom f fS hf) (AddOreLocalization.numeratorHom r) = f r

full_name: OreLocalization.universalMulHom_commutes
code: @[to_additive]
theorem universalMulHom_commutes {r : R} : universalMulHom f fS hf (numeratorHom r) = f r 
goal: (OreLocalization.universalMulHom f fS hf) (OreLocalization.numeratorHom r) = f r

full_name: OreLocalization.universalMulHom_unique
code: /-- The universal morphism `universalMulHom` is unique. -/
@[to_additive "The universal morphism `universalAddHom` is unique."]
theorem universalMulHom_unique (φ : R[S⁻¹] →* T) (huniv : ∀ r : R, φ (numeratorHom r) = f r) :
    φ = universalMulHom f fS hf 
goal: φ = OreLocalization.universalMulHom f fS hf

full_name: AddOreLocalization.universalAddHom_unique
code: /-- The universal morphism `universalMulHom` is unique. -/
@[to_additive "The universal morphism `universalAddHom` is unique."]
theorem universalMulHom_unique (φ : R[S⁻¹] →* T) (huniv : ∀ r : R, φ (numeratorHom r) = f r) :
    φ = universalMulHom f fS hf 
goal: φ = AddOreLocalization.universalAddHom f fS hf

full_name: AddOreLocalization.hvadd
code: /-- Scalar multiplication in a monoid localization. -/
@[to_additive (attr := irreducible) "Vector addition in an additive monoid localization."]
protected def hsmul (c : R) :
    X[S⁻¹] → X[S⁻¹] 
goal: AddOreLocalization S X → AddOreLocalization S X

full_name: OreLocalization.hsmul
code: /-- Scalar multiplication in a monoid localization. -/
@[to_additive (attr := irreducible) "Vector addition in an additive monoid localization."]
protected def hsmul (c : R) :
    X[S⁻¹] → X[S⁻¹] 
goal: OreLocalization S X → OreLocalization S X

full_name: AddOreLocalization.instVAddOfIsScalarTower
code: @[to_additive (attr := nolint unusedArguments)]
instance [SMul R X] [SMul R M] [IsScalarTower R M X] [IsScalarTower R M M] : SMul R (X[S⁻¹]) 
goal: VAdd R (AddOreLocalization S X)

full_name: OreLocalization.instSMulOfIsScalarTower
code: @[to_additive (attr := nolint unusedArguments)]
instance [SMul R X] [SMul R M] [IsScalarTower R M X] [IsScalarTower R M M] : SMul R (X[S⁻¹]) 
goal: SMul R (OreLocalization S X)

full_name: AddOreLocalization.vadd_oreSub
code: @[to_additive]
theorem smul_oreDiv (r : R) (x : X) (s : S) :
    r • (x /ₒ s) = oreNum (r • 1) s • x /ₒ oreDenom (r • 1) s 
goal: r +ᵥ (x -ₒ s) = AddOreLocalization.oreMin (r +ᵥ 0) s +ᵥ x -ₒ AddOreLocalization.oreSubtra (r +ᵥ 0) s

full_name: OreLocalization.smul_oreDiv
code: @[to_additive]
theorem smul_oreDiv (r : R) (x : X) (s : S) :
    r • (x /ₒ s) = oreNum (r • 1) s • x /ₒ oreDenom (r • 1) s 
goal: r • (x /ₒ s) = OreLocalization.oreNum (r • 1) s • x /ₒ OreLocalization.oreDenom (r • 1) s

full_name: OreLocalization.oreDiv_one_smul
code: @[to_additive (attr := simp)]
theorem oreDiv_one_smul (r : M) (x : X[S⁻¹]) : (r /ₒ (1 : S)) • x = r • x 
goal: (r /ₒ 1) • x = r • x

full_name: AddOreLocalization.oreSub_zero_vadd
code: @[to_additive (attr := simp)]
theorem oreDiv_one_smul (r : M) (x : X[S⁻¹]) : (r /ₒ (1 : S)) • x = r • x 
goal: r -ₒ 0 +ᵥ x = r +ᵥ x

full_name: OreLocalization.smul_one_smul
code: @[to_additive]
theorem smul_one_smul (r : R) (x : X[S⁻¹]) : (r • 1 : M) • x = r • x 
goal: (r • 1) • x = r • x

full_name: AddOreLocalization.vadd_zero_vadd
code: @[to_additive]
theorem smul_one_smul (r : R) (x : X[S⁻¹]) : (r • 1 : M) • x = r • x 
goal: r +ᵥ 0 +ᵥ x = r +ᵥ x

full_name: OreLocalization.smul_one_oreDiv_one_smul
code: @[to_additive]
theorem smul_one_oreDiv_one_smul (r : R) (x : X[S⁻¹]) :
    ((r • 1 : M) /ₒ (1 : S)) • x = r • x 
goal: (r • 1 /ₒ 1) • x = r • x

full_name: AddOreLocalization.vadd_zero_oreSub_zero_vadd
code: @[to_additive]
theorem smul_one_oreDiv_one_smul (r : R) (x : X[S⁻¹]) :
    ((r • 1 : M) /ₒ (1 : S)) • x = r • x 
goal: r +ᵥ 0 -ₒ 0 +ᵥ x = r +ᵥ x

full_name: OreLocalization.instIsScalarTower
code: @[to_additive]
instance : IsScalarTower R R' X[S⁻¹] 
goal: IsScalarTower R R' (OreLocalization S X)

full_name: AddOreLocalization.instIsScalarTower
code: @[to_additive]
instance : IsScalarTower R R' X[S⁻¹] 
goal: VAddAssocClass R R' (AddOreLocalization S X)

full_name: AddOreLocalization.instVAddCommClass
code: @[to_additive]
instance [SMulCommClass R R' M] : SMulCommClass R R' X[S⁻¹] 
goal: VAddCommClass R R' (AddOreLocalization S X)

full_name: OreLocalization.instSMulCommClass
code: @[to_additive]
instance [SMulCommClass R R' M] : SMulCommClass R R' X[S⁻¹] 
goal: SMulCommClass R R' (OreLocalization S X)

full_name: AddOreLocalization.instIsScalarTower_1
code: @[to_additive]
instance : IsScalarTower R M[S⁻¹] X[S⁻¹] 
goal: VAddAssocClass R (AddOreLocalization S M) (AddOreLocalization S X)

full_name: OreLocalization.instIsScalarTower_1
code: @[to_additive]
instance : IsScalarTower R M[S⁻¹] X[S⁻¹] 
goal: IsScalarTower R (OreLocalization S M) (OreLocalization S X)

full_name: OreLocalization.instSMulCommClass_1
code: @[to_additive]
instance [SMulCommClass R M M] : SMulCommClass R M[S⁻¹] X[S⁻¹] 
goal: SMulCommClass R (OreLocalization S M) (OreLocalization S X)

full_name: AddOreLocalization.instVAddCommClass_1
code: @[to_additive]
instance [SMulCommClass R M M] : SMulCommClass R M[S⁻¹] X[S⁻¹] 
goal: VAddCommClass R (AddOreLocalization S M) (AddOreLocalization S X)

full_name: AddOreLocalization.instIsCentralVAdd
code: @[to_additive]
instance [SMul Rᵐᵒᵖ M] [SMul Rᵐᵒᵖ X] [IsScalarTower Rᵐᵒᵖ M M] [IsScalarTower Rᵐᵒᵖ M X]
  [IsCentralScalar R M] : IsCentralScalar R X[S⁻¹] 
goal: IsCentralVAdd R (AddOreLocalization S X)

full_name: OreLocalization.instIsCentralScalar
code: @[to_additive]
instance [SMul Rᵐᵒᵖ M] [SMul Rᵐᵒᵖ X] [IsScalarTower Rᵐᵒᵖ M M] [IsScalarTower Rᵐᵒᵖ M X]
  [IsCentralScalar R M] : IsCentralScalar R X[S⁻¹] 
goal: IsCentralScalar R (OreLocalization S X)

full_name: OreLocalization.instMulActionOfIsScalarTower
code: @[to_additive]
instance {R} [Monoid R] [MulAction R M] [IsScalarTower R M M]
    [MulAction R X] [IsScalarTower R M X] : MulAction R X[S⁻¹] 
goal: MulAction R (OreLocalization S X)

full_name: AddOreLocalization.instAddActionOfIsScalarTower
code: @[to_additive]
instance {R} [Monoid R] [MulAction R M] [IsScalarTower R M M]
    [MulAction R X] [IsScalarTower R M X] : MulAction R X[S⁻¹] 
goal: AddAction R (AddOreLocalization S X)

full_name: OreLocalization.smul_oreDiv_one
code: @[to_additive]
theorem smul_oreDiv_one (r : R) (x : X) : r • (x /ₒ (1 : S)) = (r • x) /ₒ (1 : S) 
goal: r • (x /ₒ 1) = r • x /ₒ 1

full_name: AddOreLocalization.vadd_oreSub_zero
code: @[to_additive]
theorem smul_oreDiv_one (r : R) (x : X) : r • (x /ₒ (1 : S)) = (r • x) /ₒ (1 : S) 
goal: r +ᵥ (x -ₒ 0) = r +ᵥ x -ₒ 0

full_name: OreLocalization.oreDiv_mul_oreDiv_comm
code: @[to_additive]
theorem oreDiv_mul_oreDiv_comm {r₁ r₂ : R} {s₁ s₂ : S} :
    r₁ /ₒ s₁ * (r₂ /ₒ s₂) = r₁ * r₂ /ₒ (s₁ * s₂) 
goal: r₁ /ₒ s₁ * (r₂ /ₒ s₂) = r₁ * r₂ /ₒ (s₁ * s₂)

full_name: AddOreLocalization.oreSub_add_oreSub_comm
code: @[to_additive]
theorem oreDiv_mul_oreDiv_comm {r₁ r₂ : R} {s₁ s₂ : S} :
    r₁ /ₒ s₁ * (r₂ /ₒ s₂) = r₁ * r₂ /ₒ (s₁ * s₂) 
goal: r₁ -ₒ s₁ + (r₂ -ₒ s₂) = r₁ + r₂ -ₒ (s₁ + s₂)

full_name: OreLocalization.instCommMonoid
code: @[to_additive]
instance : CommMonoid R[S⁻¹] 
goal: CommMonoid (OreLocalization S R)

full_name: AddOreLocalization.instAddCommMonoid
code: @[to_additive]
instance : CommMonoid R[S⁻¹] 
goal: AddCommMonoid (AddOreLocalization S R)

full_name: OreLocalization.zero
code: /-- `0` in the localization, defined as `0 /ₒ 1`. -/
@[irreducible]
protected def zero : X[S⁻¹] 
goal: OreLocalization S X

full_name: OreLocalization.instZero
code: instance : Zero X[S⁻¹] 
goal: Zero (OreLocalization S X)

full_name: OreLocalization.zero_def
code: protected theorem zero_def : (0 : X[S⁻¹]) = 0 /ₒ 1 
goal: 0 = 0 /ₒ 1

full_name: OreLocalization.zero_oreDiv'
code: @[simp]
theorem zero_oreDiv' (s : S) : (0 : R) /ₒ s = 0 
goal: 0 /ₒ s = 0

full_name: OreLocalization.instMonoidWithZero
code: instance : MonoidWithZero R[S⁻¹] 
goal: MonoidWithZero (OreLocalization S R)

full_name: OreLocalization.instCommMonoidWithZero
code: instance : CommMonoidWithZero R[S⁻¹] 
goal: CommMonoidWithZero (OreLocalization S R)

full_name: _private.Mathlib.RingTheory.OreLocalization.Basic.0.OreLocalization.add''
code: private def add'' (r₁ : X) (s₁ : S) (r₂ : X) (s₂ : S) : X[S⁻¹] 
goal: OreLocalization S X

full_name: _private.Mathlib.RingTheory.OreLocalization.Basic.0.OreLocalization.add''_char
code: private theorem add''_char (r₁ : X) (s₁ : S) (r₂ : X) (s₂ : S) (rb : R) (sb : R)
    (hb : sb * s₁ = rb * s₂) (h : sb * s₁ ∈ S) :
    add'' r₁ s₁ r₂ s₂ = (sb • r₁ + rb • r₂) /ₒ ⟨sb * s₁, h⟩ 
goal: OreLocalization.add'' r₁ s₁ r₂ s₂ = (sb • r₁ + rb • r₂) /ₒ ⟨sb * ↑s₁, h⟩

full_name: _private.Mathlib.RingTheory.OreLocalization.Basic.0.OreLocalization.add'
code: private def add' (r₂ : X) (s₂ : S) : X[S⁻¹] → X[S⁻¹] 
goal: OreLocalization S X → OreLocalization S X

full_name: _private.Mathlib.RingTheory.OreLocalization.Basic.0.OreLocalization.add
code: /-- The addition on the Ore localization. -/
@[irreducible]
private def add : X[S⁻¹] → X[S⁻¹] → X[S⁻¹] 
goal: OreLocalization S X → OreLocalization S X → OreLocalization S X

full_name: OreLocalization.instAdd
code: instance : Add X[S⁻¹] 
goal: Add (OreLocalization S X)

full_name: OreLocalization.oreDiv_add_oreDiv
code: theorem oreDiv_add_oreDiv {r r' : X} {s s' : S} :
    r /ₒ s + r' /ₒ s' =
      (oreDenom (s : R) s' • r + oreNum (s : R) s' • r') /ₒ (oreDenom (s : R) s' * s) 
goal: r /ₒ s + r' /ₒ s' =
  (OreLocalization.oreDenom (↑s) s' • r + OreLocalization.oreNum (↑s) s' • r') /ₒ (OreLocalization.oreDenom (↑s) s' * s)

full_name: OreLocalization.oreDiv_add_char'
code: theorem oreDiv_add_char' {r r' : X} (s s' : S) (rb : R) (sb : R)
    (h : sb * s = rb * s') (h' : sb * s ∈ S) :
    r /ₒ s + r' /ₒ s' = (sb • r + rb • r') /ₒ ⟨sb * s, h'⟩ 
goal: r /ₒ s + r' /ₒ s' = (sb • r + rb • r') /ₒ ⟨sb * ↑s, h'⟩

full_name: OreLocalization.oreDiv_add_char
code: /-- A characterization of the addition on the Ore localizaion, allowing for arbitrary Ore
numerator and Ore denominator. -/
theorem oreDiv_add_char {r r' : X} (s s' : S) (rb : R) (sb : S) (h : sb * s = rb * s') :
    r /ₒ s + r' /ₒ s' = (sb • r + rb • r') /ₒ (sb * s) 
goal: r /ₒ s + r' /ₒ s' = (sb • r + rb • r') /ₒ (sb * s)

full_name: OreLocalization.oreDivAddChar'
code: /-- Another characterization of the addition on the Ore localization, bundling up all witnesses
and conditions into a sigma type. -/
def oreDivAddChar' (r r' : X) (s s' : S) :
    Σ'r'' : R,
      Σ's'' : S, s'' * s = r'' * s' ∧ r /ₒ s + r' /ₒ s' = (s'' • r + r'' • r') /ₒ (s'' * s) 
goal: (r'' : R) ×' (s'' : ↥S) ×' ↑s'' * ↑s = r'' * ↑s' ∧ r /ₒ s + r' /ₒ s' = (s'' • r + r'' • r') /ₒ (s'' * s)

full_name: OreLocalization.add_oreDiv
code: @[simp]
theorem add_oreDiv {r r' : X} {s : S} : r /ₒ s + r' /ₒ s = (r + r') /ₒ s 
goal: r /ₒ s + r' /ₒ s = (r + r') /ₒ s

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

full_name: OreLocalization.zero_oreDiv
code: @[simp]
theorem zero_oreDiv (s : S) : (0 : X) /ₒ s = 0 
goal: 0 /ₒ s = 0

full_name: OreLocalization.zero_add
code: protected theorem zero_add (x : X[S⁻¹]) : 0 + x = x 
goal: 0 + x = x

full_name: OreLocalization.add_zero
code: protected theorem add_zero (x : X[S⁻¹]) : x + 0 = x 
goal: x + 0 = x

full_name: _private.Mathlib.RingTheory.OreLocalization.Basic.0.OreLocalization.nsmul
code: @[irreducible]
private def nsmul : ℕ → X[S⁻¹] → X[S⁻¹] 
goal: ℕ → OreLocalization S X → OreLocalization S X

full_name: OreLocalization.instAddMonoid
code: instance : AddMonoid X[S⁻¹] 
goal: AddMonoid (OreLocalization S X)

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

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

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

full_name: OreLocalization.instDistribMulActionOfIsScalarTower
code: instance {R₀} [Monoid R₀] [MulAction R₀ X] [MulAction R₀ R]
    [IsScalarTower R₀ R X] [IsScalarTower R₀ R R] :
    DistribMulAction R₀ X[S⁻¹] 
goal: DistribMulAction R₀ (OreLocalization S X)

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

full_name: OreLocalization.instAddCommMonoidOreLocalization
code: instance instAddCommMonoidOreLocalization : AddCommMonoid X[S⁻¹] 
goal: AddCommMonoid (OreLocalization S X)

full_name: OreLocalization.neg
code: /-- Negation on the Ore localization is defined via negation on the numerator. -/
@[irreducible]
protected def neg : X[S⁻¹] → X[S⁻¹] 
goal: OreLocalization S X → OreLocalization S X

full_name: OreLocalization.instNegOreLocalization
code: instance instNegOreLocalization : Neg X[S⁻¹] 
goal: Neg (OreLocalization S X)

full_name: OreLocalization.neg_def
code: @[simp]
protected theorem neg_def (r : X) (s : S) : -(r /ₒ s) = -r /ₒ s 
goal: -(r /ₒ s) = -r /ₒ s

full_name: OreLocalization.add_left_neg
code: protected theorem add_left_neg (x : X[S⁻¹]) : -x + x = 0 
goal: -x + x = 0

full_name: OreLocalization.zsmul
code: /-- `zsmul` of `OreLocalization` -/
@[irreducible]
protected def zsmul : ℤ → X[S⁻¹] → X[S⁻¹] 
goal: ℤ → OreLocalization S X → OreLocalization S X

full_name: OreLocalization.instAddGroupOreLocalization
code: instance instAddGroupOreLocalization : AddGroup X[S⁻¹] 
goal: AddGroup (OreLocalization S X)

full_name: OreLocalization.instAddCommGroup
code: instance : AddCommGroup X[S⁻¹] 
goal: AddCommGroup (OreLocalization S X)