File: Mathlib/Algebra/GroupWithZero/Basic.lean

full_name: left_ne_zero_of_mul
code: theorem left_ne_zero_of_mul : a * b ≠ 0 → a ≠ 0 
goal: a * b ≠ 0 → a ≠ 0

full_name: right_ne_zero_of_mul
code: theorem right_ne_zero_of_mul : a * b ≠ 0 → b ≠ 0 
goal: a * b ≠ 0 → b ≠ 0

full_name: ne_zero_and_ne_zero_of_mul
code: theorem ne_zero_and_ne_zero_of_mul (h : a * b ≠ 0) : a ≠ 0 ∧ b ≠ 0 
goal: a ≠ 0 ∧ b ≠ 0

full_name: mul_eq_zero_of_ne_zero_imp_eq_zero
code: theorem mul_eq_zero_of_ne_zero_imp_eq_zero {a b : M₀} (h : a ≠ 0 → b = 0) : a * b = 0 
goal: a * b = 0

full_name: zero_mul_eq_const
code: /-- To match `one_mul_eq_id`. -/
theorem zero_mul_eq_const : ((0 : M₀) * ·) = Function.const _ 0 
goal: (fun x => 0 * x) = Function.const M₀ 0

full_name: mul_zero_eq_const
code: /-- To match `mul_one_eq_id`. -/
theorem mul_zero_eq_const : (· * (0 : M₀)) = Function.const _ 0 
goal: (fun x => x * 0) = Function.const M₀ 0

full_name: eq_zero_of_mul_self_eq_zero
code: theorem eq_zero_of_mul_self_eq_zero (h : a * a = 0) : a = 0 
goal: a = 0

full_name: mul_ne_zero
code: @[field_simps]
theorem mul_ne_zero (ha : a ≠ 0) (hb : b ≠ 0) : a * b ≠ 0 
goal: a * b ≠ 0

full_name: NeZero.mul
code: instance mul [Zero M₀] [Mul M₀] [NoZeroDivisors M₀] {x y : M₀} [NeZero x] [NeZero y] :
    NeZero (x * y) 
goal: NeZero (x * y)

full_name: eq_zero_of_zero_eq_one
code: /-- In a monoid with zero, if zero equals one, then zero is the only element. -/
theorem eq_zero_of_zero_eq_one (h : (0 : M₀) = 1) (a : M₀) : a = 0 
goal: a = 0

full_name: uniqueOfZeroEqOne
code: /-- In a monoid with zero, if zero equals one, then zero is the unique element.

Somewhat arbitrarily, we define the default element to be `0`.
All other elements will be provably equal to it, but not necessarily definitionally equal. -/
def uniqueOfZeroEqOne (h : (0 : M₀) = 1) : Unique M₀ 
goal: Unique M₀

full_name: subsingleton_iff_zero_eq_one
code: /-- In a monoid with zero, zero equals one if and only if all elements of that semiring
are equal. -/
theorem subsingleton_iff_zero_eq_one : (0 : M₀) = 1 ↔ Subsingleton M₀ 
goal: 0 = 1 ↔ Subsingleton M₀

full_name: eq_of_zero_eq_one
code: theorem eq_of_zero_eq_one (h : (0 : M₀) = 1) (a b : M₀) : a = b 
goal: a = b

full_name: zero_ne_one_or_forall_eq_0
code: /-- In a monoid with zero, either zero and one are nonequal, or zero is the only element. -/
theorem zero_ne_one_or_forall_eq_0 : (0 : M₀) ≠ 1 ∨ ∀ a : M₀, a = 0 
goal: 0 ≠ 1 ∨ ∀ (a : M₀), a = 0

full_name: left_ne_zero_of_mul_eq_one
code: theorem left_ne_zero_of_mul_eq_one (h : a * b = 1) : a ≠ 0 
goal: a ≠ 0

full_name: right_ne_zero_of_mul_eq_one
code: theorem right_ne_zero_of_mul_eq_one (h : a * b = 1) : b ≠ 0 
goal: b ≠ 0

full_name: zero_pow
code: @[simp] lemma zero_pow : ∀ {n : ℕ}, n ≠ 0 → (0 : M₀) ^ n = 0
  
goal: n ≠ 0 → 0 ^ n = 0

full_name: zero_pow_eq
code: lemma zero_pow_eq (n : ℕ) : (0 : M₀) ^ n = if n = 0 then 1 else 0 
goal: 0 ^ n = if n = 0 then 1 else 0

full_name: pow_eq_zero_of_le
code: lemma pow_eq_zero_of_le : ∀ {m n} (hmn : m ≤ n) (ha : a ^ m = 0), a ^ n = 0
  
goal: a ^ n = 0

full_name: ne_zero_pow
code: lemma ne_zero_pow (hn : n ≠ 0) (ha : a ^ n ≠ 0) : a ≠ 0 
goal: a ≠ 0

full_name: zero_pow_eq_zero
code: @[simp]
lemma zero_pow_eq_zero [Nontrivial M₀] : (0 : M₀) ^ n = 0 ↔ n ≠ 0 
goal: 0 ^ n = 0 ↔ n ≠ 0

full_name: pow_eq_zero
code: lemma pow_eq_zero : ∀ {n}, a ^ n = 0 → a = 0
  
goal: a ^ n = 0 → a = 0

full_name: pow_eq_zero_iff
code: @[simp] lemma pow_eq_zero_iff (hn : n ≠ 0) : a ^ n = 0 ↔ a = 0 
goal: a ^ n = 0 ↔ a = 0

full_name: pow_ne_zero_iff
code: lemma pow_ne_zero_iff (hn : n ≠ 0) : a ^ n ≠ 0 ↔ a ≠ 0 
goal: a ^ n ≠ 0 ↔ a ≠ 0

full_name: pow_ne_zero
code: @[field_simps]
lemma pow_ne_zero (n : ℕ) (h : a ≠ 0) : a ^ n ≠ 0 
goal: a ^ n ≠ 0

full_name: NeZero.pow
code: instance NeZero.pow [NeZero a] : NeZero (a ^ n) 
goal: NeZero (a ^ n)

full_name: sq_eq_zero_iff
code: lemma sq_eq_zero_iff : a ^ 2 = 0 ↔ a = 0 
goal: a ^ 2 = 0 ↔ a = 0

full_name: pow_eq_zero_iff'
code: @[simp] lemma pow_eq_zero_iff' [Nontrivial M₀] : a ^ n = 0 ↔ a = 0 ∧ n ≠ 0 
goal: a ^ n = 0 ↔ a = 0 ∧ n ≠ 0

full_name: CancelMonoidWithZero.to_noZeroDivisors
code: instance (priority := 10) CancelMonoidWithZero.to_noZeroDivisors : NoZeroDivisors M₀ 
goal: NoZeroDivisors M₀

full_name: mul_eq_mul_right_iff
code: @[simp]
theorem mul_eq_mul_right_iff : a * c = b * c ↔ a = b ∨ c = 0 
goal: a * c = b * c ↔ a = b ∨ c = 0

full_name: mul_eq_mul_left_iff
code: @[simp]
theorem mul_eq_mul_left_iff : a * b = a * c ↔ b = c ∨ a = 0 
goal: a * b = a * c ↔ b = c ∨ a = 0

full_name: mul_right_eq_self₀
code: theorem mul_right_eq_self₀ : a * b = a ↔ b = 1 ∨ a = 0 
goal: a * b = a ↔ b = 1 ∨ a = 0

full_name: mul_left_eq_self₀
code: theorem mul_left_eq_self₀ : a * b = b ↔ a = 1 ∨ b = 0 
goal: a * b = b ↔ a = 1 ∨ b = 0

full_name: mul_eq_left₀
code: @[simp]
theorem mul_eq_left₀ (ha : a ≠ 0) : a * b = a ↔ b = 1 
goal: a * b = a ↔ b = 1

full_name: mul_eq_right₀
code: @[simp]
theorem mul_eq_right₀ (hb : b ≠ 0) : a * b = b ↔ a = 1 
goal: a * b = b ↔ a = 1

full_name: left_eq_mul₀
code: @[simp]
theorem left_eq_mul₀ (ha : a ≠ 0) : a = a * b ↔ b = 1 
goal: a = a * b ↔ b = 1

full_name: right_eq_mul₀
code: @[simp]
theorem right_eq_mul₀ (hb : b ≠ 0) : b = a * b ↔ a = 1 
goal: b = a * b ↔ a = 1

full_name: eq_zero_of_mul_eq_self_right
code: /-- An element of a `CancelMonoidWithZero` fixed by right multiplication by an element other
than one must be zero. -/
theorem eq_zero_of_mul_eq_self_right (h₁ : b ≠ 1) (h₂ : a * b = a) : a = 0 
goal: a = 0

full_name: eq_zero_of_mul_eq_self_left
code: /-- An element of a `CancelMonoidWithZero` fixed by left multiplication by an element other
than one must be zero. -/
theorem eq_zero_of_mul_eq_self_left (h₁ : b ≠ 1) (h₂ : b * a = a) : a = 0 
goal: a = 0

full_name: GroupWithZero.mul_left_injective
code: theorem GroupWithZero.mul_left_injective (h : x ≠ 0) :
    Function.Injective fun y => x * y 
goal: Function.Injective fun y => x * y

full_name: GroupWithZero.mul_right_injective
code: theorem GroupWithZero.mul_right_injective (h : x ≠ 0) :
    Function.Injective fun y => y * x 
goal: Function.Injective fun y => y * x

full_name: inv_mul_cancel_right₀
code: @[simp]
theorem inv_mul_cancel_right₀ (h : b ≠ 0) (a : G₀) : a * b⁻¹ * b = a 
goal: a * b⁻¹ * b = a

full_name: inv_mul_cancel_left₀
code: @[simp]
theorem inv_mul_cancel_left₀ (h : a ≠ 0) (b : G₀) : a⁻¹ * (a * b) = b 
goal: a⁻¹ * (a * b) = b

full_name: _private.Mathlib.Algebra.GroupWithZero.Basic.0.inv_eq_of_mul
code: private theorem inv_eq_of_mul (h : a * b = 1) : a⁻¹ = b 
goal: a⁻¹ = b

full_name: GroupWithZero.toDivisionMonoid
code: instance (priority := 100) GroupWithZero.toDivisionMonoid : DivisionMonoid G₀ 
goal: DivisionMonoid G₀

full_name: GroupWithZero.toCancelMonoidWithZero
code: instance (priority := 10) GroupWithZero.toCancelMonoidWithZero : CancelMonoidWithZero G₀ 
goal: CancelMonoidWithZero G₀

full_name: zero_div
code: @[simp]
theorem zero_div (a : G₀) : 0 / a = 0 
goal: 0 / a = 0

full_name: div_zero
code: @[simp]
theorem div_zero (a : G₀) : a / 0 = 0 
goal: a / 0 = 0

full_name: mul_self_mul_inv
code: /-- Multiplying `a` by itself and then by its inverse results in `a`
(whether or not `a` is zero). -/
@[simp]
theorem mul_self_mul_inv (a : G₀) : a * a * a⁻¹ = a 
goal: a * a * a⁻¹ = a

full_name: mul_inv_mul_self
code: /-- Multiplying `a` by its inverse and then by itself results in `a`
(whether or not `a` is zero). -/
@[simp]
theorem mul_inv_mul_self (a : G₀) : a * a⁻¹ * a = a 
goal: a * a⁻¹ * a = a

full_name: inv_mul_mul_self
code: /-- Multiplying `a⁻¹` by `a` twice results in `a` (whether or not `a`
is zero). -/
@[simp]
theorem inv_mul_mul_self (a : G₀) : a⁻¹ * a * a = a 
goal: a⁻¹ * a * a = a

full_name: mul_self_div_self
code: /-- Multiplying `a` by itself and then dividing by itself results in `a`, whether or not `a` is
zero. -/
@[simp]
theorem mul_self_div_self (a : G₀) : a * a / a = a 
goal: a * a / a = a

full_name: div_self_mul_self
code: /-- Dividing `a` by itself and then multiplying by itself results in `a`, whether or not `a` is
zero. -/
@[simp]
theorem div_self_mul_self (a : G₀) : a / a * a = a 
goal: a / a * a = a

full_name: div_self_mul_self'
code: @[simp]
theorem div_self_mul_self' (a : G₀) : a / (a * a) = a⁻¹ 
goal: a / (a * a) = a⁻¹

full_name: one_div_ne_zero
code: theorem one_div_ne_zero {a : G₀} (h : a ≠ 0) : 1 / a ≠ 0 
goal: 1 / a ≠ 0

full_name: inv_eq_zero
code: @[simp]
theorem inv_eq_zero {a : G₀} : a⁻¹ = 0 ↔ a = 0 
goal: a⁻¹ = 0 ↔ a = 0

full_name: zero_eq_inv
code: @[simp]
theorem zero_eq_inv {a : G₀} : 0 = a⁻¹ ↔ 0 = a 
goal: 0 = a⁻¹ ↔ 0 = a

full_name: div_div_self
code: /-- Dividing `a` by the result of dividing `a` by itself results in
`a` (whether or not `a` is zero). -/
@[simp]
theorem div_div_self (a : G₀) : a / (a / a) = a 
goal: a / (a / a) = a

full_name: ne_zero_of_one_div_ne_zero
code: theorem ne_zero_of_one_div_ne_zero {a : G₀} (h : 1 / a ≠ 0) : a ≠ 0 
goal: a ≠ 0

full_name: eq_zero_of_one_div_eq_zero
code: theorem eq_zero_of_one_div_eq_zero {a : G₀} (h : 1 / a = 0) : a = 0 
goal: a = 0

full_name: mul_left_surjective₀
code: theorem mul_left_surjective₀ {a : G₀} (h : a ≠ 0) : Surjective fun g => a * g 
goal: Function.Surjective fun g => a * g

full_name: mul_right_surjective₀
code: theorem mul_right_surjective₀ {a : G₀} (h : a ≠ 0) : Surjective fun g => g * a 
goal: Function.Surjective fun g => g * a

full_name: zero_zpow
code: lemma zero_zpow : ∀ n : ℤ, n ≠ 0 → (0 : G₀) ^ n = 0
  
goal: n ≠ 0 → 0 ^ n = 0

full_name: zero_zpow_eq
code: lemma zero_zpow_eq (n : ℤ) : (0 : G₀) ^ n = if n = 0 then 1 else 0 
goal: 0 ^ n = if n = 0 then 1 else 0

full_name: zpow_add_one₀
code: lemma zpow_add_one₀ (ha : a ≠ 0) : ∀ n : ℤ, a ^ (n + 1) = a ^ n * a
  
goal: a ^ (n + 1) = a ^ n * a

full_name: zpow_sub_one₀
code: lemma zpow_sub_one₀ (ha : a ≠ 0) (n : ℤ) : a ^ (n - 1) = a ^ n * a⁻¹ 
goal: a ^ (n - 1) = a ^ n * a⁻¹

full_name: zpow_add₀
code: lemma zpow_add₀ (ha : a ≠ 0) (m n : ℤ) : a ^ (m + n) = a ^ m * a ^ n 
goal: a ^ (m + n) = a ^ m * a ^ n

full_name: zpow_add'
code: lemma zpow_add' {m n : ℤ} (h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0) :
    a ^ (m + n) = a ^ m * a ^ n 
goal: a ^ (m + n) = a ^ m * a ^ n

full_name: zpow_one_add₀
code: lemma zpow_one_add₀ (h : a ≠ 0) (i : ℤ) : a ^ (1 + i) = a * a ^ i 
goal: a ^ (1 + i) = a * a ^ i

full_name: div_mul_eq_mul_div₀
code: theorem div_mul_eq_mul_div₀ (a b c : G₀) : a / c * b = a * b / c 
goal: a / c * b = a * b / c

full_name: div_sq_cancel
code: lemma div_sq_cancel (a b : G₀) : a ^ 2 * b / a = a * b 
goal: a ^ 2 * b / a = a * b