File: Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean

full_name: nonZeroDivisorsLeft
code: /-- The collection of elements of a `MonoidWithZero` that are not left zero divisors form a
`Submonoid`. -/
def nonZeroDivisorsLeft : Submonoid M₀ 
goal: Submonoid M₀

full_name: mem_nonZeroDivisorsLeft_iff
code: @[simp] lemma mem_nonZeroDivisorsLeft_iff {x : M₀} :
    x ∈ nonZeroDivisorsLeft M₀ ↔ ∀ y, y * x = 0 → y = 0 
goal: x ∈ nonZeroDivisorsLeft M₀ ↔ ∀ (y : M₀), y * x = 0 → y = 0

full_name: nmem_nonZeroDivisorsLeft_iff
code: lemma nmem_nonZeroDivisorsLeft_iff {r : M₀} :
    r ∉ nonZeroDivisorsLeft M₀ ↔ {s | s * r = 0 ∧ s ≠ 0}.Nonempty 
goal: r ∉ nonZeroDivisorsLeft M₀ ↔ {s | s * r = 0 ∧ s ≠ 0}.Nonempty

full_name: nonZeroDivisorsRight
code: /-- The collection of elements of a `MonoidWithZero` that are not right zero divisors form a
`Submonoid`. -/
def nonZeroDivisorsRight : Submonoid M₀ 
goal: Submonoid M₀

full_name: mem_nonZeroDivisorsRight_iff
code: @[simp] lemma mem_nonZeroDivisorsRight_iff {x : M₀} :
    x ∈ nonZeroDivisorsRight M₀ ↔ ∀ y, x * y = 0 → y = 0 
goal: x ∈ nonZeroDivisorsRight M₀ ↔ ∀ (y : M₀), x * y = 0 → y = 0

full_name: nmem_nonZeroDivisorsRight_iff
code: lemma nmem_nonZeroDivisorsRight_iff {r : M₀} :
    r ∉ nonZeroDivisorsRight M₀ ↔ {s | r * s = 0 ∧ s ≠ 0}.Nonempty 
goal: r ∉ nonZeroDivisorsRight M₀ ↔ {s | r * s = 0 ∧ s ≠ 0}.Nonempty

full_name: nonZeroDivisorsLeft_eq_right
code: lemma nonZeroDivisorsLeft_eq_right (M₀ : Type*) [CommMonoidWithZero M₀] :
    nonZeroDivisorsLeft M₀ = nonZeroDivisorsRight M₀ 
goal: nonZeroDivisorsLeft M₀ = nonZeroDivisorsRight M₀

full_name: coe_nonZeroDivisorsLeft_eq
code: @[simp] lemma coe_nonZeroDivisorsLeft_eq [NoZeroDivisors M₀] [Nontrivial M₀] :
    nonZeroDivisorsLeft M₀ = {x : M₀ | x ≠ 0} 
goal: ↑(nonZeroDivisorsLeft M₀) = {x | x ≠ 0}

full_name: coe_nonZeroDivisorsRight_eq
code: @[simp] lemma coe_nonZeroDivisorsRight_eq [NoZeroDivisors M₀] [Nontrivial M₀] :
    nonZeroDivisorsRight M₀ = {x : M₀ | x ≠ 0} 
goal: ↑(nonZeroDivisorsRight M₀) = {x | x ≠ 0}

full_name: nonZeroDivisors
code: /-- The submonoid of non-zero-divisors of a `MonoidWithZero` `R`. -/
def nonZeroDivisors (R : Type*) [MonoidWithZero R] : Submonoid R 
goal: Submonoid R

full_name: nonZeroDivisors._aux_Mathlib_Algebra_GroupWithZero_NonZeroDivisors___unexpand_nonZeroDivisors_1
code: /-- The notation for the submonoid of non-zerodivisors. -/
scoped[nonZeroDivisors] notation:9000 R "⁰" => nonZeroDivisors R
goal: Lean.PrettyPrinter.Unexpander

full_name: nonZeroDivisors.«_aux_Mathlib_Algebra_GroupWithZero_NonZeroDivisors___macroRules_nonZeroDivisors_term_⁰_1»
code: /-- The notation for the submonoid of non-zerodivisors. -/
scoped[nonZeroDivisors] notation:9000 R "⁰" => nonZeroDivisors R
goal: Lean.Macro

full_name: nonZeroSMulDivisors
code: /-- Let `R` be a monoid with zero and `M` an additive monoid with an `R`-action, then the collection
of non-zero smul-divisors forms a submonoid. These elements are also called `M`-regular. -/
def nonZeroSMulDivisors (R : Type*) [MonoidWithZero R] (M : Type _) [Zero M] [MulAction R M] :
    Submonoid R 
goal: Submonoid R

full_name: nonZeroSMulDivisors._aux_Mathlib_Algebra_GroupWithZero_NonZeroDivisors___unexpand_nonZeroSMulDivisors_1
code: /-- The notation for the submonoid of non-zero smul-divisors. -/
scoped[nonZeroSMulDivisors] notation:9000 R "⁰[" M "]" => nonZeroSMulDivisors R M
goal: Lean.PrettyPrinter.Unexpander

full_name: nonZeroSMulDivisors.«_aux_Mathlib_Algebra_GroupWithZero_NonZeroDivisors___macroRules_nonZeroSMulDivisors_term_⁰[_]_1»
code: /-- The notation for the submonoid of non-zero smul-divisors. -/
scoped[nonZeroSMulDivisors] notation:9000 R "⁰[" M "]" => nonZeroSMulDivisors R M
goal: Lean.Macro

full_name: mem_nonZeroDivisors_iff
code: theorem mem_nonZeroDivisors_iff {r : M} : r ∈ M⁰ ↔ ∀ x, x * r = 0 → x = 0 
goal: r ∈ M⁰ ↔ ∀ (x : M), x * r = 0 → x = 0

full_name: nmem_nonZeroDivisors_iff
code: lemma nmem_nonZeroDivisors_iff {r : M} : r ∉ M⁰ ↔ {s | s * r = 0 ∧ s ≠ 0}.Nonempty 
goal: r ∉ M⁰ ↔ {s | s * r = 0 ∧ s ≠ 0}.Nonempty

full_name: mul_right_mem_nonZeroDivisors_eq_zero_iff
code: theorem mul_right_mem_nonZeroDivisors_eq_zero_iff {x r : M} (hr : r ∈ M⁰) : x * r = 0 ↔ x = 0 
goal: x * r = 0 ↔ x = 0

full_name: mul_right_coe_nonZeroDivisors_eq_zero_iff
code: @[simp]
theorem mul_right_coe_nonZeroDivisors_eq_zero_iff {x : M} {c : M⁰} : x * c = 0 ↔ x = 0 
goal: x * ↑c = 0 ↔ x = 0

full_name: mul_left_mem_nonZeroDivisors_eq_zero_iff
code: theorem mul_left_mem_nonZeroDivisors_eq_zero_iff {r x : M₁} (hr : r ∈ M₁⁰) : r * x = 0 ↔ x = 0 
goal: r * x = 0 ↔ x = 0

full_name: mul_left_coe_nonZeroDivisors_eq_zero_iff
code: @[simp]
theorem mul_left_coe_nonZeroDivisors_eq_zero_iff {c : M₁⁰} {x : M₁} : (c : M₁) * x = 0 ↔ x = 0 
goal: ↑c * x = 0 ↔ x = 0

full_name: mul_cancel_right_mem_nonZeroDivisors
code: theorem mul_cancel_right_mem_nonZeroDivisors {x y r : R} (hr : r ∈ R⁰) : x * r = y * r ↔ x = y 
goal: x * r = y * r ↔ x = y

full_name: mul_cancel_right_coe_nonZeroDivisors
code: theorem mul_cancel_right_coe_nonZeroDivisors {x y : R} {c : R⁰} : x * c = y * c ↔ x = y 
goal: x * ↑c = y * ↑c ↔ x = y

full_name: mul_cancel_left_mem_nonZeroDivisors
code: @[simp]
theorem mul_cancel_left_mem_nonZeroDivisors {x y r : R'} (hr : r ∈ R'⁰) :
    r * x = r * y ↔ x = y 
goal: r * x = r * y ↔ x = y

full_name: mul_cancel_left_coe_nonZeroDivisors
code: theorem mul_cancel_left_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : (c : R') * x = c * y ↔ x = y 
goal: ↑c * x = ↑c * y ↔ x = y

full_name: dvd_cancel_right_mem_nonZeroDivisors
code: theorem dvd_cancel_right_mem_nonZeroDivisors {x y r : R'} (hr : r ∈ R'⁰) : x * r ∣ y * r ↔ x ∣ y 
goal: x * r ∣ y * r ↔ x ∣ y

full_name: dvd_cancel_right_coe_nonZeroDivisors
code: theorem dvd_cancel_right_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : x * c ∣ y * c ↔ x ∣ y 
goal: x * ↑c ∣ y * ↑c ↔ x ∣ y

full_name: dvd_cancel_left_mem_nonZeroDivisors
code: theorem dvd_cancel_left_mem_nonZeroDivisors {x y r : R'} (hr : r ∈ R'⁰) : r * x ∣ r * y ↔ x ∣ y 
goal: r * x ∣ r * y ↔ x ∣ y

full_name: dvd_cancel_left_coe_nonZeroDivisors
code: theorem dvd_cancel_left_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : c * x ∣ c * y ↔ x ∣ y 
goal: ↑c * x ∣ ↑c * y ↔ x ∣ y

full_name: zero_not_mem_nonZeroDivisors
code: theorem zero_not_mem_nonZeroDivisors [Nontrivial M] : 0 ∉ M⁰ 
goal: 0 ∉ M⁰

full_name: nonZeroDivisors.ne_zero
code: theorem nonZeroDivisors.ne_zero [Nontrivial M] {x} (hx : x ∈ M⁰) : x ≠ 0 
goal: x ≠ 0

full_name: nonZeroDivisors.coe_ne_zero
code: @[simp]
theorem nonZeroDivisors.coe_ne_zero [Nontrivial M] (x : M⁰) : (x : M) ≠ 0 
goal: ↑x ≠ 0

full_name: mul_mem_nonZeroDivisors
code: theorem mul_mem_nonZeroDivisors {a b : M₁} : a * b ∈ M₁⁰ ↔ a ∈ M₁⁰ ∧ b ∈ M₁⁰ 
goal: a * b ∈ M₁⁰ ↔ a ∈ M₁⁰ ∧ b ∈ M₁⁰

full_name: isUnit_of_mem_nonZeroDivisors
code: theorem isUnit_of_mem_nonZeroDivisors {G₀ : Type*} [GroupWithZero G₀] {x : G₀}
    (hx : x ∈ nonZeroDivisors G₀) : IsUnit x 
goal: IsUnit x

full_name: IsUnit.mem_nonZeroDivisors
code: lemma IsUnit.mem_nonZeroDivisors {a : M} (ha : IsUnit a) : a ∈ M⁰ 
goal: a ∈ M⁰

full_name: eq_zero_of_ne_zero_of_mul_right_eq_zero
code: theorem eq_zero_of_ne_zero_of_mul_right_eq_zero [NoZeroDivisors M] {x y : M} (hnx : x ≠ 0)
    (hxy : y * x = 0) : y = 0 
goal: y = 0

full_name: eq_zero_of_ne_zero_of_mul_left_eq_zero
code: theorem eq_zero_of_ne_zero_of_mul_left_eq_zero [NoZeroDivisors M] {x y : M} (hnx : x ≠ 0)
    (hxy : x * y = 0) : y = 0 
goal: y = 0

full_name: mem_nonZeroDivisors_of_ne_zero
code: theorem mem_nonZeroDivisors_of_ne_zero [NoZeroDivisors M] {x : M} (hx : x ≠ 0) : x ∈ M⁰ 
goal: x ∈ M⁰

full_name: mem_nonZeroDivisors_iff_ne_zero
code: theorem mem_nonZeroDivisors_iff_ne_zero [NoZeroDivisors M] [Nontrivial M] {x : M} :
    x ∈ M⁰ ↔ x ≠ 0 
goal: x ∈ M⁰ ↔ x ≠ 0

full_name: map_ne_zero_of_mem_nonZeroDivisors
code: theorem map_ne_zero_of_mem_nonZeroDivisors [Nontrivial M] [ZeroHomClass F M M'] (g : F)
    (hg : Function.Injective (g : M → M')) {x : M} (h : x ∈ M⁰) : g x ≠ 0 
goal: g x ≠ 0

full_name: map_mem_nonZeroDivisors
code: theorem map_mem_nonZeroDivisors [Nontrivial M] [NoZeroDivisors M'] [ZeroHomClass F M M'] (g : F)
    (hg : Function.Injective g) {x : M} (h : x ∈ M⁰) : g x ∈ M'⁰ 
goal: g x ∈ M'⁰

full_name: le_nonZeroDivisors_of_noZeroDivisors
code: theorem le_nonZeroDivisors_of_noZeroDivisors [NoZeroDivisors M] {S : Submonoid M}
    (hS : (0 : M) ∉ S) : S ≤ M⁰ 
goal: S ≤ M⁰

full_name: powers_le_nonZeroDivisors_of_noZeroDivisors
code: theorem powers_le_nonZeroDivisors_of_noZeroDivisors [NoZeroDivisors M] {a : M} (ha : a ≠ 0) :
    Submonoid.powers a ≤ M⁰ 
goal: Submonoid.powers a ≤ M⁰

full_name: map_le_nonZeroDivisors_of_injective
code: theorem map_le_nonZeroDivisors_of_injective [NoZeroDivisors M'] [MonoidWithZeroHomClass F M M']
    (f : F) (hf : Function.Injective f) {S : Submonoid M} (hS : S ≤ M⁰) : S.map f ≤ M'⁰ 
goal: Submonoid.map f S ≤ M'⁰

full_name: nonZeroDivisors_le_comap_nonZeroDivisors_of_injective
code: theorem nonZeroDivisors_le_comap_nonZeroDivisors_of_injective [NoZeroDivisors M']
    [MonoidWithZeroHomClass F M M'] (f : F) (hf : Function.Injective f) : M⁰ ≤ M'⁰.comap f 
goal: M⁰ ≤ Submonoid.comap f M'⁰

full_name: isUnit_iff_mem_nonZeroDivisors_of_finite
code: /-- In a finite ring, an element is a unit iff it is a non-zero-divisor. -/
lemma isUnit_iff_mem_nonZeroDivisors_of_finite [Finite R] {a : R} :
    IsUnit a ↔ a ∈ nonZeroDivisors R 
goal: IsUnit a ↔ a ∈ R⁰

full_name: mem_nonZeroSMulDivisors_iff
code: lemma mem_nonZeroSMulDivisors_iff {x : R} : x ∈ R⁰[M] ↔ ∀ (m : M), x • m = 0 → m = 0 
goal: x ∈ nonZeroSMulDivisors R M ↔ ∀ (m : M), x • m = 0 → m = 0

full_name: unop_nonZeroSMulDivisors_mulOpposite_eq_nonZeroDivisors
code: @[simp]
lemma unop_nonZeroSMulDivisors_mulOpposite_eq_nonZeroDivisors :
    (Rᵐᵒᵖ ⁰[R]).unop = R⁰ 
goal: (nonZeroSMulDivisors Rᵐᵒᵖ R).unop = R⁰

full_name: nonZeroSMulDivisors_mulOpposite_eq_op_nonZeroDivisors
code: /-- The non-zero `•`-divisors with `•` as right multiplication correspond with the non-zero
divisors. Note that the `MulOpposite` is needed because we defined `nonZeroDivisors` with
multiplication on the right. -/
lemma nonZeroSMulDivisors_mulOpposite_eq_op_nonZeroDivisors :
    Rᵐᵒᵖ ⁰[R] = R⁰.op 
goal: nonZeroSMulDivisors Rᵐᵒᵖ R = R⁰.op

full_name: unitsNonZeroDivisorsEquiv_apply
code: /-- The units of the monoid of non-zero divisors of `M₀` are equivalent to the units of `M₀`. -/
@[simps]
def unitsNonZeroDivisorsEquiv : M₀⁰ˣ ≃* M₀ˣ 
goal: ∀ (a : (↥M₀⁰)ˣ), unitsNonZeroDivisorsEquiv a = (↑(Units.map M₀⁰.subtype)).toFun a

full_name: val_inv_unitsNonZeroDivisorsEquiv_symm_apply_coe
code: /-- The units of the monoid of non-zero divisors of `M₀` are equivalent to the units of `M₀`. -/
@[simps]
def unitsNonZeroDivisorsEquiv : M₀⁰ˣ ≃* M₀ˣ 
goal: ↑↑(unitsNonZeroDivisorsEquiv.symm u)⁻¹ = ↑u⁻¹

full_name: val_unitsNonZeroDivisorsEquiv_symm_apply_coe
code: /-- The units of the monoid of non-zero divisors of `M₀` are equivalent to the units of `M₀`. -/
@[simps]
def unitsNonZeroDivisorsEquiv : M₀⁰ˣ ≃* M₀ˣ 
goal: ↑↑(unitsNonZeroDivisorsEquiv.symm u) = ↑u

full_name: unitsNonZeroDivisorsEquiv
code: /-- The units of the monoid of non-zero divisors of `M₀` are equivalent to the units of `M₀`. -/
@[simps]
def unitsNonZeroDivisorsEquiv : M₀⁰ˣ ≃* M₀ˣ 
goal: (↥M₀⁰)ˣ ≃* M₀ˣ

full_name: nonZeroDivisors.associated_coe
code: @[simp, norm_cast] lemma nonZeroDivisors.associated_coe : Associated (a : M₀) b ↔ Associated a b 
goal: Associated ↑a ↑b ↔ Associated a b

full_name: mk_mem_nonZeroDivisors_associates
code: theorem mk_mem_nonZeroDivisors_associates : Associates.mk a ∈ (Associates M₀)⁰ ↔ a ∈ M₀⁰ 
goal: Associates.mk a ∈ (Associates M₀)⁰ ↔ a ∈ M₀⁰

full_name: associatesNonZeroDivisorsEquiv
code: /-- The non-zero divisors of associates of a monoid with zero `M₀` are isomorphic to the associates
of the non-zero divisors of `M₀` under the map `⟨⟦a⟧, _⟩ ↦ ⟦⟨a, _⟩⟧`. -/
def associatesNonZeroDivisorsEquiv : (Associates M₀)⁰ ≃* Associates M₀⁰ 
goal: ↥(Associates M₀)⁰ ≃* Associates ↥M₀⁰

full_name: associatesNonZeroDivisorsEquiv_mk_mk
code: @[simp]
lemma associatesNonZeroDivisorsEquiv_mk_mk (a : M₀) (ha) :
    associatesNonZeroDivisorsEquiv ⟨⟦a⟧, ha⟩ = ⟦⟨a, mk_mem_nonZeroDivisors_associates.1 ha⟩⟧ 
goal: associatesNonZeroDivisorsEquiv ⟨⟦a⟧, ha⟩ = ⟦⟨a, ⋯⟩⟧

full_name: associatesNonZeroDivisorsEquiv_symm_mk_mk
code: @[simp]
lemma associatesNonZeroDivisorsEquiv_symm_mk_mk (a : M₀) (ha) :
    associatesNonZeroDivisorsEquiv.symm ⟦⟨a, ha⟩⟧ = ⟨⟦a⟧, mk_mem_nonZeroDivisors_associates.2 ha⟩ 
goal: associatesNonZeroDivisorsEquiv.symm ⟦⟨a, ha⟩⟧ = ⟨⟦a⟧, ⋯⟩