File: Mathlib/Algebra/Ring/Basic.lean

full_name: AddHom.mulLeft
code: /-- Left multiplication by an element of a type with distributive multiplication is an `AddHom`. -/
@[simps (config := .asFn)]
def mulLeft [Distrib R] (r : R) : AddHom R R 
goal: AddHom R R

full_name: AddHom.mulLeft_apply
code: /-- Left multiplication by an element of a type with distributive multiplication is an `AddHom`. -/
@[simps (config := .asFn)]
def mulLeft [Distrib R] (r : R) : AddHom R R 
goal: ⇑(AddHom.mulLeft r) = fun x => r * x

full_name: AddHom.mulRight
code: /-- Left multiplication by an element of a type with distributive multiplication is an `AddHom`. -/
@[simps (config := .asFn)]
def mulRight [Distrib R] (r : R) : AddHom R R 
goal: AddHom R R

full_name: AddHom.mulRight_apply
code: /-- Left multiplication by an element of a type with distributive multiplication is an `AddHom`. -/
@[simps (config := .asFn)]
def mulRight [Distrib R] (r : R) : AddHom R R 
goal: ⇑(AddHom.mulRight r) = fun a => a * r

full_name: AddMonoidHom.mulLeft
code: /-- Left multiplication by an element of a (semi)ring is an `AddMonoidHom` -/
def mulLeft [NonUnitalNonAssocSemiring R] (r : R) : R →+ R 
goal: R →+ R

full_name: AddMonoidHom.coe_mulLeft
code: @[simp]
theorem coe_mulLeft [NonUnitalNonAssocSemiring R] (r : R) :
    (mulLeft r : R → R) = HMul.hMul r 
goal: ⇑(AddMonoidHom.mulLeft r) = HMul.hMul r

full_name: AddMonoidHom.mulRight
code: /-- Right multiplication by an element of a (semi)ring is an `AddMonoidHom` -/
def mulRight [NonUnitalNonAssocSemiring R] (r : R) : R →+ R 
goal: R →+ R

full_name: AddMonoidHom.coe_mulRight
code: @[simp]
theorem coe_mulRight [NonUnitalNonAssocSemiring R] (r : R) :
    (mulRight r) = (· * r) 
goal: ⇑(AddMonoidHom.mulRight r) = fun x => x * r

full_name: AddMonoidHom.mulRight_apply
code: theorem mulRight_apply [NonUnitalNonAssocSemiring R] (a r : R) :
    mulRight r a = a * r 
goal: (AddMonoidHom.mulRight r) a = a * r

full_name: instHasDistribNeg
code: instance instHasDistribNeg : HasDistribNeg αᵐᵒᵖ 
goal: HasDistribNeg αᵐᵒᵖ

full_name: inv_neg'
code: @[simp]
theorem inv_neg' (a : α) : (-a)⁻¹ = -a⁻¹ 
goal: (-a)⁻¹ = -a⁻¹

full_name: vieta_formula_quadratic
code: /-- Vieta's formula for a quadratic equation, relating the coefficients of the polynomial with
  its roots. This particular version states that if we have a root `x` of a monic quadratic
  polynomial, then there is another root `y` such that `x + y` is negative the `a_1` coefficient
  and `x * y` is the `a_0` coefficient. -/
theorem vieta_formula_quadratic {b c x : α} (h : x * x - b * x + c = 0) :
    ∃ y : α, y * y - b * y + c = 0 ∧ x + y = b ∧ x * y = c 
goal: ∃ y, y * y - b * y + c = 0 ∧ x + y = b ∧ x * y = c

full_name: succ_ne_self
code: theorem succ_ne_self {α : Type*} [NonAssocRing α] [Nontrivial α] (a : α) : a + 1 ≠ a 
goal: a + 1 ≠ a

full_name: pred_ne_self
code: theorem pred_ne_self {α : Type*} [NonAssocRing α] [Nontrivial α] (a : α) : a - 1 ≠ a 
goal: a - 1 ≠ a

full_name: IsLeftCancelMulZero.to_noZeroDivisors
code: lemma IsLeftCancelMulZero.to_noZeroDivisors [NonUnitalNonAssocRing α] [IsLeftCancelMulZero α] :
    NoZeroDivisors α 
goal: NoZeroDivisors α

full_name: IsRightCancelMulZero.to_noZeroDivisors
code: lemma IsRightCancelMulZero.to_noZeroDivisors [NonUnitalNonAssocRing α] [IsRightCancelMulZero α] :
    NoZeroDivisors α 
goal: NoZeroDivisors α

full_name: NoZeroDivisors.to_isCancelMulZero
code: instance (priority := 100) NoZeroDivisors.to_isCancelMulZero
    [NonUnitalNonAssocRing α] [NoZeroDivisors α] :
    IsCancelMulZero α 
goal: IsCancelMulZero α

full_name: isCancelMulZero_iff_noZeroDivisors
code: /-- In a ring, `IsCancelMulZero` and `NoZeroDivisors` are equivalent. -/
lemma isCancelMulZero_iff_noZeroDivisors [NonUnitalNonAssocRing α] :
    IsCancelMulZero α ↔ NoZeroDivisors α 
goal: IsCancelMulZero α ↔ NoZeroDivisors α

full_name: NoZeroDivisors.to_isDomain
code: lemma NoZeroDivisors.to_isDomain [Ring α] [h : Nontrivial α] [NoZeroDivisors α] :
    IsDomain α 
goal: IsDomain α

full_name: IsDomain.to_noZeroDivisors
code: instance (priority := 100) IsDomain.to_noZeroDivisors [Ring α] [IsDomain α] :
    NoZeroDivisors α 
goal: NoZeroDivisors α

full_name: Subsingleton.to_isCancelMulZero
code: instance Subsingleton.to_isCancelMulZero [Mul α] [Zero α] [Subsingleton α] : IsCancelMulZero α 
goal: IsCancelMulZero α

full_name: Subsingleton.to_noZeroDivisors
code: instance Subsingleton.to_noZeroDivisors [Mul α] [Zero α] [Subsingleton α] : NoZeroDivisors α 
goal: NoZeroDivisors α

full_name: isDomain_iff_cancelMulZero_and_nontrivial
code: lemma isDomain_iff_cancelMulZero_and_nontrivial [Semiring α] :
    IsDomain α ↔ IsCancelMulZero α ∧ Nontrivial α 
goal: IsDomain α ↔ IsCancelMulZero α ∧ Nontrivial α

full_name: isCancelMulZero_iff_isDomain_or_subsingleton
code: lemma isCancelMulZero_iff_isDomain_or_subsingleton [Semiring α] :
    IsCancelMulZero α ↔ IsDomain α ∨ Subsingleton α 
goal: IsCancelMulZero α ↔ IsDomain α ∨ Subsingleton α

full_name: isDomain_iff_noZeroDivisors_and_nontrivial
code: lemma isDomain_iff_noZeroDivisors_and_nontrivial [Ring α] :
    IsDomain α ↔ NoZeroDivisors α ∧ Nontrivial α 
goal: IsDomain α ↔ NoZeroDivisors α ∧ Nontrivial α

full_name: noZeroDivisors_iff_isDomain_or_subsingleton
code: lemma noZeroDivisors_iff_isDomain_or_subsingleton [Ring α] :
    NoZeroDivisors α ↔ IsDomain α ∨ Subsingleton α 
goal: NoZeroDivisors α ↔ IsDomain α ∨ Subsingleton α