File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

full_name: Units.ne_zero
code: /-- An element of the unit group of a nonzero monoid with zero represented as an element
    of the monoid is nonzero. -/
@[simp]
theorem ne_zero [Nontrivial M₀] (u : M₀ˣ) : (u : M₀) ≠ 0 
goal: ↑u ≠ 0

full_name: Units.mul_left_eq_zero
code: @[simp]
theorem mul_left_eq_zero (u : M₀ˣ) {a : M₀} : a * u = 0 ↔ a = 0 
goal: a * ↑u = 0 ↔ a = 0

full_name: Units.mul_right_eq_zero
code: @[simp]
theorem mul_right_eq_zero (u : M₀ˣ) {a : M₀} : ↑u * a = 0 ↔ a = 0 
goal: ↑u * a = 0 ↔ a = 0

full_name: IsUnit.ne_zero
code: theorem ne_zero [Nontrivial M₀] {a : M₀} (ha : IsUnit a) : a ≠ 0 
goal: a ≠ 0

full_name: IsUnit.mul_right_eq_zero
code: theorem mul_right_eq_zero {a b : M₀} (ha : IsUnit a) : a * b = 0 ↔ b = 0 
goal: a * b = 0 ↔ b = 0

full_name: IsUnit.mul_left_eq_zero
code: theorem mul_left_eq_zero {a b : M₀} (hb : IsUnit b) : a * b = 0 ↔ a = 0 
goal: a * b = 0 ↔ a = 0

full_name: isUnit_zero_iff
code: @[simp]
theorem isUnit_zero_iff : IsUnit (0 : M₀) ↔ (0 : M₀) = 1 
goal: IsUnit 0 ↔ 0 = 1

full_name: not_isUnit_zero
code: theorem not_isUnit_zero [Nontrivial M₀] : ¬IsUnit (0 : M₀) 
goal: ¬IsUnit 0

full_name: Ring.inverse
code: /-- Introduce a function `inverse` on a monoid with zero `M₀`, which sends `x` to `x⁻¹` if `x` is
invertible and to `0` otherwise.  This definition is somewhat ad hoc, but one needs a fully (rather
than partially) defined inverse function for some purposes, including for calculus.

Note that while this is in the `Ring` namespace for brevity, it requires the weaker assumption
`MonoidWithZero M₀` instead of `Ring M₀`. -/
noncomputable def inverse : M₀ → M₀ 
goal: M₀ → M₀

full_name: Ring.inverse_unit
code: /-- By definition, if `x` is invertible then `inverse x = x⁻¹`. -/
@[simp]
theorem inverse_unit (u : M₀ˣ) : inverse (u : M₀) = (u⁻¹ : M₀ˣ) 
goal: Ring.inverse ↑u = ↑u⁻¹

full_name: Ring.inverse_non_unit
code: /-- By definition, if `x` is not invertible then `inverse x = 0`. -/
@[simp]
theorem inverse_non_unit (x : M₀) (h : ¬IsUnit x) : inverse x = 0 
goal: Ring.inverse x = 0

full_name: Ring.mul_inverse_cancel
code: theorem mul_inverse_cancel (x : M₀) (h : IsUnit x) : x * inverse x = 1 
goal: x * Ring.inverse x = 1

full_name: Ring.inverse_mul_cancel
code: theorem inverse_mul_cancel (x : M₀) (h : IsUnit x) : inverse x * x = 1 
goal: Ring.inverse x * x = 1

full_name: Ring.mul_inverse_cancel_right
code: theorem mul_inverse_cancel_right (x y : M₀) (h : IsUnit x) : y * x * inverse x = y 
goal: y * x * Ring.inverse x = y

full_name: Ring.inverse_mul_cancel_right
code: theorem inverse_mul_cancel_right (x y : M₀) (h : IsUnit x) : y * inverse x * x = y 
goal: y * Ring.inverse x * x = y

full_name: Ring.mul_inverse_cancel_left
code: theorem mul_inverse_cancel_left (x y : M₀) (h : IsUnit x) : x * (inverse x * y) = y 
goal: x * (Ring.inverse x * y) = y

full_name: Ring.inverse_mul_cancel_left
code: theorem inverse_mul_cancel_left (x y : M₀) (h : IsUnit x) : inverse x * (x * y) = y 
goal: Ring.inverse x * (x * y) = y

full_name: Ring.inverse_mul_eq_iff_eq_mul
code: theorem inverse_mul_eq_iff_eq_mul (x y z : M₀) (h : IsUnit x) : inverse x * y = z ↔ y = x * z 
goal: Ring.inverse x * y = z ↔ y = x * z

full_name: Ring.eq_mul_inverse_iff_mul_eq
code: theorem eq_mul_inverse_iff_mul_eq (x y z : M₀) (h : IsUnit z) : x = y * inverse z ↔ x * z = y 
goal: x = y * Ring.inverse z ↔ x * z = y

full_name: Ring.inverse_one
code: @[simp]
theorem inverse_one : inverse (1 : M₀) = 1 
goal: Ring.inverse 1 = 1

full_name: Ring.inverse_zero
code: @[simp]
theorem inverse_zero : inverse (0 : M₀) = 0 
goal: Ring.inverse 0 = 0

full_name: IsUnit.ring_inverse
code: theorem IsUnit.ring_inverse {a : M₀} : IsUnit a → IsUnit (Ring.inverse a)
  
goal: IsUnit a → IsUnit (Ring.inverse a)

full_name: isUnit_ring_inverse
code: @[simp]
theorem isUnit_ring_inverse {a : M₀} : IsUnit (Ring.inverse a) ↔ IsUnit a 
goal: IsUnit (Ring.inverse a) ↔ IsUnit a

full_name: Units.mk0
code: /-- Embed a non-zero element of a `GroupWithZero` into the unit group.
  By combining this function with the operations on units,
  or the `/ₚ` operation, it is possible to write a division
  as a partial function with three arguments. -/
def mk0 (a : G₀) (ha : a ≠ 0) : G₀ˣ 
goal: G₀ˣ

full_name: Units.mk0_one
code: @[simp]
theorem mk0_one (h := one_ne_zero) : mk0 (1 : G₀) h = 1 
goal: Units.mk0 1 h = 1

full_name: Units.val_mk0
code: @[simp]
theorem val_mk0 {a : G₀} (h : a ≠ 0) : (mk0 a h : G₀) = a 
goal: ↑(Units.mk0 a h) = a

full_name: Units.mk0_val
code: @[simp]
theorem mk0_val (u : G₀ˣ) (h : (u : G₀) ≠ 0) : mk0 (u : G₀) h = u 
goal: Units.mk0 (↑u) h = u

full_name: Units.mul_inv'
code: theorem mul_inv' (u : G₀ˣ) : u * (u : G₀)⁻¹ = 1 
goal: ↑u * (↑u)⁻¹ = 1

full_name: Units.inv_mul'
code: theorem inv_mul' (u : G₀ˣ) : (u⁻¹ : G₀) * u = 1 
goal: (↑u)⁻¹ * ↑u = 1

full_name: Units.mk0_inj
code: @[simp]
theorem mk0_inj {a b : G₀} (ha : a ≠ 0) (hb : b ≠ 0) : Units.mk0 a ha = Units.mk0 b hb ↔ a = b 
goal: Units.mk0 a ha = Units.mk0 b hb ↔ a = b

full_name: Units.exists0
code: /-- In a group with zero, an existential over a unit can be rewritten in terms of `Units.mk0`. -/
theorem exists0 {p : G₀ˣ → Prop} : (∃ g : G₀ˣ, p g) ↔ ∃ (g : G₀) (hg : g ≠ 0), p (Units.mk0 g hg) 
goal: (∃ g, p g) ↔ ∃ g hg, p (Units.mk0 g hg)

full_name: Units.exists0'
code: /-- An alternative version of `Units.exists0`. This one is useful if Lean cannot
figure out `p` when using `Units.exists0` from right to left. -/
theorem exists0' {p : ∀ g : G₀, g ≠ 0 → Prop} :
    (∃ (g : G₀) (hg : g ≠ 0), p g hg) ↔ ∃ g : G₀ˣ, p g g.ne_zero 
goal: (∃ g hg, p g hg) ↔ ∃ g, p ↑g ⋯

full_name: Units.exists_iff_ne_zero
code: @[simp]
theorem exists_iff_ne_zero {p : G₀ → Prop} : (∃ u : G₀ˣ, p u) ↔ ∃ x ≠ 0, p x 
goal: (∃ u, p ↑u) ↔ ∃ x, x ≠ 0 ∧ p x

full_name: GroupWithZero.eq_zero_or_unit
code: theorem _root_.GroupWithZero.eq_zero_or_unit (a : G₀) : a = 0 ∨ ∃ u : G₀ˣ, a = u 
goal: a = 0 ∨ ∃ u, a = ↑u

full_name: IsUnit.mk0
code: theorem IsUnit.mk0 (x : G₀) (hx : x ≠ 0) : IsUnit x 
goal: IsUnit x

full_name: isUnit_iff_ne_zero
code: @[simp]
theorem isUnit_iff_ne_zero : IsUnit a ↔ a ≠ 0 
goal: IsUnit a ↔ a ≠ 0

full_name: GroupWithZero.noZeroDivisors
code: instance (priority := 10) GroupWithZero.noZeroDivisors : NoZeroDivisors G₀ 
goal: NoZeroDivisors G₀

full_name: Units.mk0_mul
code: @[simp]
theorem Units.mk0_mul (x y : G₀) (hxy) :
    Units.mk0 (x * y) hxy =
      Units.mk0 x (mul_ne_zero_iff.mp hxy).1 * Units.mk0 y (mul_ne_zero_iff.mp hxy).2 
goal: Units.mk0 (x * y) hxy = Units.mk0 x ⋯ * Units.mk0 y ⋯

full_name: div_ne_zero
code: theorem div_ne_zero (ha : a ≠ 0) (hb : b ≠ 0) : a / b ≠ 0 
goal: a / b ≠ 0

full_name: div_eq_zero_iff
code: @[simp]
theorem div_eq_zero_iff : a / b = 0 ↔ a = 0 ∨ b = 0 
goal: a / b = 0 ↔ a = 0 ∨ b = 0

full_name: div_ne_zero_iff
code: theorem div_ne_zero_iff : a / b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0 
goal: a / b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0

full_name: div_self
code: @[simp] lemma div_self (h : a ≠ 0) : a / a = 1 
goal: a / a = 1

full_name: eq_mul_inv_iff_mul_eq₀
code: lemma eq_mul_inv_iff_mul_eq₀ (hc : c ≠ 0) : a = b * c⁻¹ ↔ a * c = b 
goal: a = b * c⁻¹ ↔ a * c = b

full_name: eq_inv_mul_iff_mul_eq₀
code: lemma eq_inv_mul_iff_mul_eq₀ (hb : b ≠ 0) : a = b⁻¹ * c ↔ b * a = c 
goal: a = b⁻¹ * c ↔ b * a = c

full_name: inv_mul_eq_iff_eq_mul₀
code: lemma inv_mul_eq_iff_eq_mul₀ (ha : a ≠ 0) : a⁻¹ * b = c ↔ b = a * c 
goal: a⁻¹ * b = c ↔ b = a * c

full_name: mul_inv_eq_iff_eq_mul₀
code: lemma mul_inv_eq_iff_eq_mul₀ (hb : b ≠ 0) : a * b⁻¹ = c ↔ a = c * b 
goal: a * b⁻¹ = c ↔ a = c * b

full_name: mul_inv_eq_one₀
code: lemma mul_inv_eq_one₀ (hb : b ≠ 0) : a * b⁻¹ = 1 ↔ a = b 
goal: a * b⁻¹ = 1 ↔ a = b

full_name: inv_mul_eq_one₀
code: lemma inv_mul_eq_one₀ (ha : a ≠ 0) : a⁻¹ * b = 1 ↔ a = b 
goal: a⁻¹ * b = 1 ↔ a = b

full_name: mul_eq_one_iff_eq_inv₀
code: lemma mul_eq_one_iff_eq_inv₀ (hb : b ≠ 0) : a * b = 1 ↔ a = b⁻¹ 
goal: a * b = 1 ↔ a = b⁻¹

full_name: mul_eq_one_iff_inv_eq₀
code: lemma mul_eq_one_iff_inv_eq₀ (ha : a ≠ 0) : a * b = 1 ↔ a⁻¹ = b 
goal: a * b = 1 ↔ a⁻¹ = b

full_name: mul_eq_of_eq_mul_inv₀
code: /-- A variant of `eq_mul_inv_iff_mul_eq₀` that moves the nonzero hypothesis to another variable. -/
lemma mul_eq_of_eq_mul_inv₀ (ha : a ≠ 0) (h : a = c * b⁻¹) : a * b = c 
goal: a * b = c

full_name: mul_eq_of_eq_inv_mul₀
code: /-- A variant of `eq_inv_mul_iff_mul_eq₀` that moves the nonzero hypothesis to another variable. -/
lemma mul_eq_of_eq_inv_mul₀ (hb : b ≠ 0) (h : b = a⁻¹ * c) : a * b = c 
goal: a * b = c

full_name: eq_mul_of_inv_mul_eq₀
code: /-- A variant of `inv_mul_eq_iff_eq_mul₀` that moves the nonzero hypothesis to another variable. -/
lemma eq_mul_of_inv_mul_eq₀ (hc : c ≠ 0) (h : b⁻¹ * a = c) : a = b * c 
goal: a = b * c

full_name: eq_mul_of_mul_inv_eq₀
code: /-- A variant of `mul_inv_eq_iff_eq_mul₀` that moves the nonzero hypothesis to another variable. -/
lemma eq_mul_of_mul_inv_eq₀ (hb : b ≠ 0) (h : a * c⁻¹ = b) : a = b * c 
goal: a = b * c

full_name: div_mul_cancel₀
code: @[simp] lemma div_mul_cancel₀ (a : G₀) (h : b ≠ 0) : a / b * b = a 
goal: a / b * b = a

full_name: mul_one_div_cancel
code: lemma mul_one_div_cancel (h : a ≠ 0) : a * (1 / a) = 1 
goal: a * (1 / a) = 1

full_name: one_div_mul_cancel
code: lemma one_div_mul_cancel (h : a ≠ 0) : 1 / a * a = 1 
goal: 1 / a * a = 1

full_name: div_left_inj'
code: lemma div_left_inj' (hc : c ≠ 0) : a / c = b / c ↔ a = b 
goal: a / c = b / c ↔ a = b

full_name: div_eq_iff
code: @[field_simps] lemma div_eq_iff (hb : b ≠ 0) : a / b = c ↔ a = c * b 
goal: a / b = c ↔ a = c * b

full_name: eq_div_iff
code: @[field_simps] lemma eq_div_iff (hb : b ≠ 0) : c = a / b ↔ c * b = a 
goal: c = a / b ↔ c * b = a

full_name: div_eq_iff_mul_eq
code: lemma div_eq_iff_mul_eq (hb : b ≠ 0) : a / b = c ↔ c * b = a 
goal: a / b = c ↔ c * b = a

full_name: eq_div_iff_mul_eq
code: lemma eq_div_iff_mul_eq (hc : c ≠ 0) : a = b / c ↔ a * c = b 
goal: a = b / c ↔ a * c = b

full_name: div_eq_of_eq_mul
code: lemma div_eq_of_eq_mul (hb : b ≠ 0) : a = c * b → a / b = c 
goal: a = c * b → a / b = c

full_name: eq_div_of_mul_eq
code: lemma eq_div_of_mul_eq (hc : c ≠ 0) : a * c = b → a = b / c 
goal: a * c = b → a = b / c

full_name: div_eq_one_iff_eq
code: lemma div_eq_one_iff_eq (hb : b ≠ 0) : a / b = 1 ↔ a = b 
goal: a / b = 1 ↔ a = b

full_name: div_mul_cancel_right₀
code: lemma div_mul_cancel_right₀ (hb : b ≠ 0) (a : G₀) : b / (a * b) = a⁻¹ 
goal: b / (a * b) = a⁻¹

full_name: div_mul_left
code: @[deprecated div_mul_cancel_right₀ (since := "2024-03-20")]
lemma div_mul_left (hb : b ≠ 0) : b / (a * b) = 1 / a 
goal: b / (a * b) = 1 / a

full_name: mul_div_mul_right
code: lemma mul_div_mul_right (a b : G₀) (hc : c ≠ 0) : a * c / (b * c) = a / b 
goal: a * c / (b * c) = a / b

full_name: mul_mul_div
code: lemma mul_mul_div (a : G₀) (hb : b ≠ 0) : a = a * b * (1 / b) 
goal: a = a * b * (1 / b)

full_name: div_div_div_cancel_right
code: lemma div_div_div_cancel_right (a : G₀) (hc : c ≠ 0) : a / c / (b / c) = a / b 
goal: a / c / (b / c) = a / b

full_name: div_mul_div_cancel
code: lemma div_mul_div_cancel (a : G₀) (hc : c ≠ 0) : a / c * (c / b) = a / b 
goal: a / c * (c / b) = a / b

full_name: div_mul_cancel_of_imp
code: lemma div_mul_cancel_of_imp (h : b = 0 → a = 0) : a / b * b = a 
goal: a / b * b = a

full_name: mul_div_cancel_of_imp
code: lemma mul_div_cancel_of_imp (h : b = 0 → a = 0) : a * b / b = a 
goal: a * b / b = a

full_name: divp_mk0
code: @[simp] lemma divp_mk0 (a : G₀) (hb : b ≠ 0) : a /ₚ Units.mk0 b hb = a / b 
goal: a /ₚ Units.mk0 b hb = a / b

full_name: pow_sub₀
code: lemma pow_sub₀ (a : G₀) (ha : a ≠ 0) (h : n ≤ m) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ 
goal: a ^ (m - n) = a ^ m * (a ^ n)⁻¹

full_name: pow_sub_of_lt
code: lemma pow_sub_of_lt (a : G₀) (h : n < m) : a ^ (m - n) = a ^ m * (a ^ n)⁻¹ 
goal: a ^ (m - n) = a ^ m * (a ^ n)⁻¹

full_name: inv_pow_sub₀
code: lemma inv_pow_sub₀ (ha : a ≠ 0) (h : n ≤ m) : a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n 
goal: a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n

full_name: inv_pow_sub_of_lt
code: lemma inv_pow_sub_of_lt (a : G₀) (h : n < m) : a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n 
goal: a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n

full_name: zpow_sub₀
code: lemma zpow_sub₀ (ha : a ≠ 0) (m n : ℤ) : a ^ (m - n) = a ^ m / a ^ n 
goal: a ^ (m - n) = a ^ m / a ^ n

full_name: zpow_ne_zero
code: lemma zpow_ne_zero {a : G₀} : ∀ n : ℤ, a ≠ 0 → a ^ n ≠ 0
  
goal: a ≠ 0 → a ^ n ≠ 0

full_name: eq_zero_of_zpow_eq_zero
code: lemma eq_zero_of_zpow_eq_zero {n : ℤ} : a ^ n = 0 → a = 0 
goal: a ^ n = 0 → a = 0

full_name: zpow_eq_zero_iff
code: lemma zpow_eq_zero_iff {n : ℤ} (hn : n ≠ 0) : a ^ n = 0 ↔ a = 0 
goal: a ^ n = 0 ↔ a = 0

full_name: zpow_ne_zero_iff
code: lemma zpow_ne_zero_iff {n : ℤ} (hn : n ≠ 0) : a ^ n ≠ 0 ↔ a ≠ 0 
goal: a ^ n ≠ 0 ↔ a ≠ 0

full_name: zpow_neg_mul_zpow_self
code: lemma zpow_neg_mul_zpow_self (n : ℤ) (ha : a ≠ 0) : a ^ (-n) * a ^ n = 1 
goal: a ^ (-n) * a ^ n = 1

full_name: Ring.inverse_eq_inv
code: theorem Ring.inverse_eq_inv (a : G₀) : Ring.inverse a = a⁻¹ 
goal: Ring.inverse a = a⁻¹

full_name: Ring.inverse_eq_inv'
code: @[simp]
theorem Ring.inverse_eq_inv' : (Ring.inverse : G₀ → G₀) = Inv.inv 
goal: Ring.inverse = Inv.inv

full_name: unitsEquivNeZero_symm_apply
code: /-- In a `GroupWithZero` `α`, the unit group `αˣ` is equivalent to the subtype of nonzero
elements. -/
@[simps] def unitsEquivNeZero [GroupWithZero α] : αˣ ≃ {a : α // a ≠ 0} 
goal: unitsEquivNeZero.symm a = Units.mk0 ↑a ⋯

full_name: unitsEquivNeZero
code: /-- In a `GroupWithZero` `α`, the unit group `αˣ` is equivalent to the subtype of nonzero
elements. -/
@[simps] def unitsEquivNeZero [GroupWithZero α] : αˣ ≃ {a : α // a ≠ 0} 
goal: αˣ ≃ { a // a ≠ 0 }

full_name: unitsEquivNeZero_apply_coe
code: /-- In a `GroupWithZero` `α`, the unit group `αˣ` is equivalent to the subtype of nonzero
elements. -/
@[simps] def unitsEquivNeZero [GroupWithZero α] : αˣ ≃ {a : α // a ≠ 0} 
goal: ↑(unitsEquivNeZero a) = ↑a

full_name: CommGroupWithZero.toCancelCommMonoidWithZero
code: instance (priority := 10) CommGroupWithZero.toCancelCommMonoidWithZero :
    CancelCommMonoidWithZero G₀ 
goal: CancelCommMonoidWithZero G₀

full_name: CommGroupWithZero.toDivisionCommMonoid
code: instance (priority := 100) CommGroupWithZero.toDivisionCommMonoid :
    DivisionCommMonoid G₀ 
goal: DivisionCommMonoid G₀

full_name: div_mul_cancel_left₀
code: lemma div_mul_cancel_left₀ (ha : a ≠ 0) (b : G₀) : a / (a * b) = b⁻¹ 
goal: a / (a * b) = b⁻¹

full_name: div_mul_right
code: @[deprecated div_mul_cancel_left₀ (since := "2024-03-22")]
lemma div_mul_right (b : G₀) (ha : a ≠ 0) : a / (a * b) = 1 / b 
goal: a / (a * b) = 1 / b

full_name: mul_div_cancel_left_of_imp
code: lemma mul_div_cancel_left_of_imp (h : a = 0 → b = 0) : a * b / a = b 
goal: a * b / a = b

full_name: mul_div_cancel_of_imp'
code: lemma mul_div_cancel_of_imp' (h : b = 0 → a = 0) : b * (a / b) = a 
goal: b * (a / b) = a

full_name: mul_div_cancel₀
code: lemma mul_div_cancel₀ (a : G₀) (hb : b ≠ 0) : b * (a / b) = a 
goal: b * (a / b) = a

full_name: mul_div_mul_left
code: lemma mul_div_mul_left (a b : G₀) (hc : c ≠ 0) : c * a / (c * b) = a / b 
goal: c * a / (c * b) = a / b

full_name: mul_eq_mul_of_div_eq_div
code: lemma mul_eq_mul_of_div_eq_div (a c : G₀) (hb : b ≠ 0) (hd : d ≠ 0)
    (h : a / b = c / d) : a * d = c * b 
goal: a * d = c * b

full_name: div_eq_div_iff
code: @[field_simps] lemma div_eq_div_iff (hb : b ≠ 0) (hd : d ≠ 0) : a / b = c / d ↔ a * d = c * b 
goal: a / b = c / d ↔ a * d = c * b

full_name: div_eq_div_iff_div_eq_div'
code: /-- The `CommGroupWithZero` version of `div_eq_div_iff_div_eq_div`. -/
lemma div_eq_div_iff_div_eq_div' (hb : b ≠ 0) (hc : c ≠ 0) : a / b = c / d ↔ a / c = b / d 
goal: a / b = c / d ↔ a / c = b / d

full_name: div_div_cancel'
code: lemma div_div_cancel' (ha : a ≠ 0) : a / (a / b) = b 
goal: a / (a / b) = b

full_name: div_div_cancel_left'
code: lemma div_div_cancel_left' (ha : a ≠ 0) : a / b / a = b⁻¹ 
goal: a / b / a = b⁻¹

full_name: div_helper
code: lemma div_helper (b : G₀) (h : a ≠ 0) : 1 / (a * b) * a = 1 / b 
goal: 1 / (a * b) * a = 1 / b

full_name: div_div_div_cancel_left'
code: lemma div_div_div_cancel_left' (a b : G₀) (hc : c ≠ 0) : c / a / (c / b) = b / a 
goal: c / a / (c / b) = b / a

full_name: groupWithZeroOfIsUnitOrEqZero
code: /-- Constructs a `GroupWithZero` structure on a `MonoidWithZero`
  consisting only of units and 0. -/
noncomputable def groupWithZeroOfIsUnitOrEqZero [hM : MonoidWithZero M]
    (h : ∀ a : M, IsUnit a ∨ a = 0) : GroupWithZero M 
goal: GroupWithZero M

full_name: commGroupWithZeroOfIsUnitOrEqZero
code: /-- Constructs a `CommGroupWithZero` structure on a `CommMonoidWithZero`
  consisting only of units and 0. -/
noncomputable def commGroupWithZeroOfIsUnitOrEqZero [hM : CommMonoidWithZero M]
    (h : ∀ a : M, IsUnit a ∨ a = 0) : CommGroupWithZero M 
goal: CommGroupWithZero M