File: Mathlib/Algebra/Field/Basic.lean

full_name: add_div
code: theorem add_div (a b c : α) : (a + b) / c = a / c + b / c 
goal: (a + b) / c = a / c + b / c

full_name: div_add_div_same
code: @[field_simps]
theorem div_add_div_same (a b c : α) : a / c + b / c = (a + b) / c 
goal: a / c + b / c = (a + b) / c

full_name: same_add_div
code: theorem same_add_div (h : b ≠ 0) : (b + a) / b = 1 + a / b 
goal: (b + a) / b = 1 + a / b

full_name: div_add_same
code: theorem div_add_same (h : b ≠ 0) : (a + b) / b = a / b + 1 
goal: (a + b) / b = a / b + 1

full_name: one_add_div
code: theorem one_add_div (h : b ≠ 0) : 1 + a / b = (b + a) / b 
goal: 1 + a / b = (b + a) / b

full_name: div_add_one
code: theorem div_add_one (h : b ≠ 0) : a / b + 1 = (a + b) / b 
goal: a / b + 1 = (a + b) / b

full_name: inv_add_inv'
code: /-- See `inv_add_inv` for the more convenient version when `K` is commutative. -/
theorem inv_add_inv' (ha : a ≠ 0) (hb : b ≠ 0) :
    a⁻¹ + b⁻¹ = a⁻¹ * (a + b) * b⁻¹ 
goal: a⁻¹ + b⁻¹ = a⁻¹ * (a + b) * b⁻¹

full_name: one_div_mul_add_mul_one_div_eq_one_div_add_one_div
code: theorem one_div_mul_add_mul_one_div_eq_one_div_add_one_div (ha : a ≠ 0) (hb : b ≠ 0) :
    1 / a * (a + b) * (1 / b) = 1 / a + 1 / b 
goal: 1 / a * (a + b) * (1 / b) = 1 / a + 1 / b

full_name: add_div_eq_mul_add_div
code: theorem add_div_eq_mul_add_div (a b : α) (hc : c ≠ 0) : a + b / c = (a * c + b) / c 
goal: a + b / c = (a * c + b) / c

full_name: add_div'
code: @[field_simps]
theorem add_div' (a b c : α) (hc : c ≠ 0) : b + a / c = (b * c + a) / c 
goal: b + a / c = (b * c + a) / c

full_name: div_add'
code: @[field_simps]
theorem div_add' (a b c : α) (hc : c ≠ 0) : a / c + b = (a + b * c) / c 
goal: a / c + b = (a + b * c) / c

full_name: Commute.div_add_div
code: protected theorem Commute.div_add_div (hbc : Commute b c) (hbd : Commute b d) (hb : b ≠ 0)
    (hd : d ≠ 0) : a / b + c / d = (a * d + b * c) / (b * d) 
goal: a / b + c / d = (a * d + b * c) / (b * d)

full_name: Commute.one_div_add_one_div
code: protected theorem Commute.one_div_add_one_div (hab : Commute a b) (ha : a ≠ 0) (hb : b ≠ 0) :
    1 / a + 1 / b = (a + b) / (a * b) 
goal: 1 / a + 1 / b = (a + b) / (a * b)

full_name: Commute.inv_add_inv
code: protected theorem Commute.inv_add_inv (hab : Commute a b) (ha : a ≠ 0) (hb : b ≠ 0) :
    a⁻¹ + b⁻¹ = (a + b) / (a * b) 
goal: a⁻¹ + b⁻¹ = (a + b) / (a * b)

full_name: one_div_neg_one_eq_neg_one
code: theorem one_div_neg_one_eq_neg_one : (1 : K) / -1 = -1 
goal: 1 / -1 = -1

full_name: one_div_neg_eq_neg_one_div
code: theorem one_div_neg_eq_neg_one_div (a : K) : 1 / -a = -(1 / a) 
goal: 1 / -a = -(1 / a)

full_name: div_neg_eq_neg_div
code: theorem div_neg_eq_neg_div (a b : K) : b / -a = -(b / a) 
goal: b / -a = -(b / a)

full_name: neg_div
code: theorem neg_div (a b : K) : -b / a = -(b / a) 
goal: -b / a = -(b / a)

full_name: neg_div'
code: @[field_simps]
theorem neg_div' (a b : K) : -(b / a) = -b / a 
goal: -(b / a) = -b / a

full_name: neg_div_neg_eq
code: @[simp]
theorem neg_div_neg_eq (a b : K) : -a / -b = a / b 
goal: -a / -b = a / b

full_name: neg_inv
code: theorem neg_inv : -a⁻¹ = (-a)⁻¹ 
goal: -a⁻¹ = (-a)⁻¹

full_name: div_neg
code: theorem div_neg (a : K) : a / -b = -(a / b) 
goal: a / -b = -(a / b)

full_name: inv_neg
code: theorem inv_neg : (-a)⁻¹ = -a⁻¹ 
goal: (-a)⁻¹ = -a⁻¹

full_name: inv_neg_one
code: theorem inv_neg_one : (-1 : K)⁻¹ = -1 
goal: (-1)⁻¹ = -1

full_name: div_neg_self
code: @[simp]
theorem div_neg_self {a : K} (h : a ≠ 0) : a / -a = -1 
goal: a / -a = -1

full_name: neg_div_self
code: @[simp]
theorem neg_div_self {a : K} (h : a ≠ 0) : -a / a = -1 
goal: -a / a = -1

full_name: div_sub_div_same
code: theorem div_sub_div_same (a b c : K) : a / c - b / c = (a - b) / c 
goal: a / c - b / c = (a - b) / c

full_name: same_sub_div
code: theorem same_sub_div {a b : K} (h : b ≠ 0) : (b - a) / b = 1 - a / b 
goal: (b - a) / b = 1 - a / b

full_name: one_sub_div
code: theorem one_sub_div {a b : K} (h : b ≠ 0) : 1 - a / b = (b - a) / b 
goal: 1 - a / b = (b - a) / b

full_name: div_sub_same
code: theorem div_sub_same {a b : K} (h : b ≠ 0) : (a - b) / b = a / b - 1 
goal: (a - b) / b = a / b - 1

full_name: div_sub_one
code: theorem div_sub_one {a b : K} (h : b ≠ 0) : a / b - 1 = (a - b) / b 
goal: a / b - 1 = (a - b) / b

full_name: sub_div
code: theorem sub_div (a b c : K) : (a - b) / c = a / c - b / c 
goal: (a - b) / c = a / c - b / c

full_name: inv_sub_inv'
code: /-- See `inv_sub_inv` for the more convenient version when `K` is commutative. -/
theorem inv_sub_inv' {a b : K} (ha : a ≠ 0) (hb : b ≠ 0) : a⁻¹ - b⁻¹ = a⁻¹ * (b - a) * b⁻¹ 
goal: a⁻¹ - b⁻¹ = a⁻¹ * (b - a) * b⁻¹

full_name: one_div_mul_sub_mul_one_div_eq_one_div_add_one_div
code: theorem one_div_mul_sub_mul_one_div_eq_one_div_add_one_div (ha : a ≠ 0) (hb : b ≠ 0) :
    1 / a * (b - a) * (1 / b) = 1 / a - 1 / b 
goal: 1 / a * (b - a) * (1 / b) = 1 / a - 1 / b

full_name: DivisionRing.isDomain
code: instance (priority := 100) DivisionRing.isDomain : IsDomain K 
goal: IsDomain K

full_name: Commute.div_sub_div
code: protected theorem Commute.div_sub_div (hbc : Commute b c) (hbd : Commute b d) (hb : b ≠ 0)
    (hd : d ≠ 0) : a / b - c / d = (a * d - b * c) / (b * d) 
goal: a / b - c / d = (a * d - b * c) / (b * d)

full_name: Commute.inv_sub_inv
code: protected theorem Commute.inv_sub_inv (hab : Commute a b) (ha : a ≠ 0) (hb : b ≠ 0) :
    a⁻¹ - b⁻¹ = (b - a) / (a * b) 
goal: a⁻¹ - b⁻¹ = (b - a) / (a * b)

full_name: div_add_div
code: theorem div_add_div (a : α) (c : α) (hb : b ≠ 0) (hd : d ≠ 0) :
    a / b + c / d = (a * d + b * c) / (b * d) 
goal: a / b + c / d = (a * d + b * c) / (b * d)

full_name: one_div_add_one_div
code: theorem one_div_add_one_div (ha : a ≠ 0) (hb : b ≠ 0) : 1 / a + 1 / b = (a + b) / (a * b) 
goal: 1 / a + 1 / b = (a + b) / (a * b)

full_name: inv_add_inv
code: theorem inv_add_inv (ha : a ≠ 0) (hb : b ≠ 0) : a⁻¹ + b⁻¹ = (a + b) / (a * b) 
goal: a⁻¹ + b⁻¹ = (a + b) / (a * b)

full_name: div_sub_div
code: @[field_simps]
theorem div_sub_div (a : K) {b : K} (c : K) {d : K} (hb : b ≠ 0) (hd : d ≠ 0) :
    a / b - c / d = (a * d - b * c) / (b * d) 
goal: a / b - c / d = (a * d - b * c) / (b * d)

full_name: inv_sub_inv
code: theorem inv_sub_inv {a b : K} (ha : a ≠ 0) (hb : b ≠ 0) : a⁻¹ - b⁻¹ = (b - a) / (a * b) 
goal: a⁻¹ - b⁻¹ = (b - a) / (a * b)

full_name: sub_div'
code: @[field_simps]
theorem sub_div' (a b c : K) (hc : c ≠ 0) : b - a / c = (b * c - a) / c 
goal: b - a / c = (b * c - a) / c

full_name: div_sub'
code: @[field_simps]
theorem div_sub' (a b c : K) (hc : c ≠ 0) : a / c - b = (a - c * b) / c 
goal: a / c - b = (a - c * b) / c

full_name: Field.isDomain
code: instance (priority := 100) Field.isDomain : IsDomain K 
goal: IsDomain K

full_name: RingHom.injective
code: protected theorem injective [DivisionRing α] [Semiring β] [Nontrivial β] (f : α →+* β) :
    Injective f 
goal: Function.Injective ⇑f

full_name: DivisionRing.ofIsUnitOrEqZero
code: /-- Constructs a `DivisionRing` structure on a `Ring` consisting only of units and 0. -/
-- See note [reducible non-instances]
noncomputable abbrev DivisionRing.ofIsUnitOrEqZero [Ring R] (h : ∀ a : R, IsUnit a ∨ a = 0) :
    DivisionRing R 
goal: DivisionRing R

full_name: Field.ofIsUnitOrEqZero
code: /-- Constructs a `Field` structure on a `CommRing` consisting only of units and 0. -/
-- See note [reducible non-instances]
noncomputable abbrev Field.ofIsUnitOrEqZero [CommRing R] (h : ∀ a : R, IsUnit a ∨ a = 0) :
    Field R 
goal: Field R

full_name: Function.Injective.divisionSemiring
code: /-- Pullback a `DivisionSemiring` along an injective function. -/
-- See note [reducible non-instances]
protected abbrev divisionSemiring [DivisionSemiring β] (zero : f 0 = 0) (one : f 1 = 1)
    (add : ∀ x y, f (x + y) = f x + f y) (mul : ∀ x y, f (x * y) = f x * f y)
    (inv : ∀ x, f x⁻¹ = (f x)⁻¹) (div : ∀ x y, f (x / y) = f x / f y)
    (nsmul : ∀ (n : ℕ) (x), f (n • x) = n • f x) (nnqsmul : ∀ (q : ℚ≥0) (x), f (q • x) = q • f x)
    (npow : ∀ (x) (n : ℕ), f (x ^ n) = f x ^ n) (zpow : ∀ (x) (n : ℤ), f (x ^ n) = f x ^ n)
    (natCast : ∀ n : ℕ, f n = n) (nnratCast : ∀ q : ℚ≥0, f q = q) : DivisionSemiring α 
goal: DivisionSemiring α

full_name: Function.Injective.divisionRing
code: /-- Pullback a `DivisionSemiring` along an injective function. -/
-- See note [reducible non-instances]
protected abbrev divisionRing [DivisionRing β] (zero : f 0 = 0) (one : f 1 = 1)
    (add : ∀ x y, f (x + y) = f x + f y) (mul : ∀ x y, f (x * y) = f x * f y)
    (neg : ∀ x, f (-x) = -f x) (sub : ∀ x y, f (x - y) = f x - f y) (inv : ∀ x, f x⁻¹ = (f x)⁻¹)
    (div : ∀ x y, f (x / y) = f x / f y)
    (nsmul : ∀ (n : ℕ) (x), f (n • x) = n • f x) (zsmul : ∀ (n : ℤ) (x), f (n • x) = n • f x)
    (nnqsmul : ∀ (q : ℚ≥0) (x), f (q • x) = q • f x) (qsmul : ∀ (q : ℚ) (x), f (q • x) = q • f x)
    (npow : ∀ (x) (n : ℕ), f (x ^ n) = f x ^ n) (zpow : ∀ (x) (n : ℤ), f (x ^ n) = f x ^ n)
    (natCast : ∀ n : ℕ, f n = n) (intCast : ∀ n : ℤ, f n = n) (nnratCast : ∀ q : ℚ≥0, f q = q)
    (ratCast : ∀ q : ℚ, f q = q) : DivisionRing α 
goal: DivisionRing α

full_name: Function.Injective.semifield
code: /-- Pullback a `Field` along an injective function. -/
-- See note [reducible non-instances]
protected abbrev semifield [Semifield β] (zero : f 0 = 0) (one : f 1 = 1)
    (add : ∀ x y, f (x + y) = f x + f y) (mul : ∀ x y, f (x * y) = f x * f y)
    (inv : ∀ x, f x⁻¹ = (f x)⁻¹) (div : ∀ x y, f (x / y) = f x / f y)
    (nsmul : ∀ (n : ℕ) (x), f (n • x) = n • f x) (nnqsmul : ∀ (q : ℚ≥0) (x), f (q • x) = q • f x)
    (npow : ∀ (x) (n : ℕ), f (x ^ n) = f x ^ n) (zpow : ∀ (x) (n : ℤ), f (x ^ n) = f x ^ n)
    (natCast : ∀ n : ℕ, f n = n) (nnratCast : ∀ q : ℚ≥0, f q = q) : Semifield α 
goal: Semifield α

full_name: Function.Injective.field
code: /-- Pullback a `Field` along an injective function. -/
-- See note [reducible non-instances]
protected abbrev field [Field β] (zero : f 0 = 0) (one : f 1 = 1)
    (add : ∀ x y, f (x + y) = f x + f y) (mul : ∀ x y, f (x * y) = f x * f y)
    (neg : ∀ x, f (-x) = -f x) (sub : ∀ x y, f (x - y) = f x - f y) (inv : ∀ x, f x⁻¹ = (f x)⁻¹)
    (div : ∀ x y, f (x / y) = f x / f y)
    (nsmul : ∀ (n : ℕ) (x), f (n • x) = n • f x) (zsmul : ∀ (n : ℤ) (x), f (n • x) = n • f x)
    (nnqsmul : ∀ (q : ℚ≥0) (x), f (q • x) = q • f x) (qsmul : ∀ (q : ℚ) (x), f (q • x) = q • f x)
    (npow : ∀ (x) (n : ℕ), f (x ^ n) = f x ^ n) (zpow : ∀ (x) (n : ℤ), f (x ^ n) = f x ^ n)
    (natCast : ∀ n : ℕ, f n = n) (intCast : ∀ n : ℤ, f n = n) (nnratCast : ∀ q : ℚ≥0, f q = q)
    (ratCast : ∀ q : ℚ, f q = q) :
    Field α 
goal: Field α

full_name: OrderDual.instRatCast
code: instance instRatCast [RatCast α] : RatCast αᵒᵈ 
goal: RatCast αᵒᵈ

full_name: OrderDual.instDivisionSemiring
code: instance instDivisionSemiring [DivisionSemiring α] : DivisionSemiring αᵒᵈ 
goal: DivisionSemiring αᵒᵈ

full_name: OrderDual.instDivisionRing
code: instance instDivisionRing [DivisionRing α] : DivisionRing αᵒᵈ 
goal: DivisionRing αᵒᵈ

full_name: OrderDual.instSemifield
code: instance instSemifield [Semifield α] : Semifield αᵒᵈ 
goal: Semifield αᵒᵈ

full_name: OrderDual.instField
code: instance instField [Field α] : Field αᵒᵈ 
goal: Field αᵒᵈ

full_name: toDual_ratCast
code: @[simp] lemma toDual_ratCast [RatCast α] (n : ℚ) : toDual (n : α) = n 
goal: OrderDual.toDual ↑n = ↑n

full_name: ofDual_ratCast
code: @[simp] lemma ofDual_ratCast [RatCast α] (n : ℚ) : (ofDual n : α) = n 
goal: OrderDual.ofDual ↑n = ↑n

full_name: Lex.instRatCast
code: instance instRatCast [RatCast α] : RatCast (Lex α) 
goal: RatCast (Lex α)

full_name: Lex.instDivisionSemiring
code: instance instDivisionSemiring [DivisionSemiring α] : DivisionSemiring (Lex α) 
goal: DivisionSemiring (Lex α)

full_name: Lex.instDivisionRing
code: instance instDivisionRing [DivisionRing α] : DivisionRing (Lex α) 
goal: DivisionRing (Lex α)

full_name: Lex.instSemifield
code: instance instSemifield [Semifield α] : Semifield (Lex α) 
goal: Semifield (Lex α)

full_name: Lex.instField
code: instance instField [Field α] : Field (Lex α) 
goal: Field (Lex α)

full_name: toLex_ratCast
code: @[simp] lemma toLex_ratCast [RatCast α] (n : ℚ) : toLex (n : α) = n 
goal: toLex ↑n = ↑n

full_name: ofLex_ratCast
code: @[simp] lemma ofLex_ratCast [RatCast α] (n : ℚ) : (ofLex n : α) = n 
goal: ofLex ↑n = ↑n