ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AlgHom.equalizer_eq_top
@[simp]
theorem equalizer_eq_top {φ ψ : F} : equalizer φ ψ = ⊤ ↔ φ = ψ 
Arguments: {R : Type u_1} {A : Type u_2} {B : Type u_3} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] [Algebra R B] {F : Type u_4} [FunLike F A B] [AlgHomClass F R A B] {φ ψ : F}
Goal: AlgHom.equalizer φ ψ = ⊤ ↔ φ = ψ
-- AlgHom.equalizer_same
@[simp]
theorem equalizer_same (φ : F) : equalizer φ φ = ⊤ 
Arguments: {R : Type u_1} {A : Type u_2} {B : Type u_3} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] [Algebra R B] {F : Type u_4} [FunLike F A B] [AlgHomClass F R A B] (φ : F)
Goal: AlgHom.equalizer φ φ = ⊤
-- AlgHom.le_equalizer
theorem le_equalizer {φ ψ : F} {S : Subalgebra R A} : S ≤ equalizer φ ψ ↔ Set.EqOn φ ψ S 
Arguments: {R : Type u_1} {A : Type u_2} {B : Type u_3} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] [Algebra R B] {F : Type u_4} [FunLike F A B] [AlgHomClass F R A B] {φ ψ : F} {S : Subalgebra R A}
Goal: S ≤ AlgHom.equalizer φ ψ ↔ Set.EqOn ⇑φ ⇑ψ ↑S
-- AlgHom.eqOn_sup
theorem eqOn_sup {φ ψ : F} {S T : Subalgebra R A} (hS : Set.EqOn φ ψ S) (hT : Set.EqOn φ ψ T) :
    Set.EqOn φ ψ ↑(S ⊔ T) 
Arguments: {R : Type u_1} {A : Type u_2} {B : Type u_3} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] [Algebra R B] {F : Type u_4} [FunLike F A B] [AlgHomClass F R A B] {φ ψ : F} {S T : Subalgebra R A} (hS : Set.EqOn ⇑φ ⇑ψ ↑S) (hT : Set.EqOn ⇑φ ⇑ψ ↑T)
Goal: Set.EqOn ⇑φ ⇑ψ ↑(S ⊔ T)
-- AlgHom.ext_on_codisjoint
theorem ext_on_codisjoint {φ ψ : F} {S T : Subalgebra R A} (hST : Codisjoint S T)
    (hS : Set.EqOn φ ψ S) (hT : Set.EqOn φ ψ T) : φ = ψ 
Arguments: {R : Type u_1} {A : Type u_2} {B : Type u_3} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] [Algebra R B] {F : Type u_4} [FunLike F A B] [AlgHomClass F R A B] {φ ψ : F} {S T : Subalgebra R A} (hST : Codisjoint S T) (hS : Set.EqOn ⇑φ ⇑ψ ↑S) (hT : Set.EqOn ⇑φ ⇑ψ ↑T)
Goal: φ = ψ
-- Subalgebra.map_comap_eq
theorem map_comap_eq (f : A →ₐ[R] B) (S : Subalgebra R B) : (S.comap f).map f = S ⊓ f.range 
Arguments: {R : Type u_1} {A : Type u_2} {B : Type u_3} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] [Algebra R B] (f : A →ₐ[R] B) (S : Subalgebra R B)
Goal: Subalgebra.map f (Subalgebra.comap f S) = S ⊓ f.range
-- Subalgebra.map_comap_eq_self
theorem map_comap_eq_self
    {f : A →ₐ[R] B} {S : Subalgebra R B} (h : S ≤ f.range) : (S.comap f).map f = S 
Arguments: {R : Type u_1} {A : Type u_2} {B : Type u_3} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] [Algebra R B] {f : A →ₐ[R] B} {S : Subalgebra R B} (h : S ≤ f.range)
Goal: Subalgebra.map f (Subalgebra.comap f S) = S
-- Subalgebra.map_comap_eq_self_of_surjective
theorem map_comap_eq_self_of_surjective
    {f : A →ₐ[R] B} (hf : Function.Surjective f) (S : Subalgebra R B) : (S.comap f).map f = S 
Arguments: {R : Type u_1} {A : Type u_2} {B : Type u_3} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] [Algebra R B] {f : A →ₐ[R] B} (hf : Function.Surjective ⇑f) (S : Subalgebra R B)
Goal: Subalgebra.map f (Subalgebra.comap f S) = S
-- Subalgebra.comap_map_eq_self_of_injective
theorem comap_map_eq_self_of_injective
    {f : A →ₐ[R] B} (hf : Function.Injective f) (S : Subalgebra R A) : (S.map f).comap f = S 
Arguments: {R : Type u_1} {A : Type u_2} {B : Type u_3} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] [Algebra R B] {f : A →ₐ[R] B} (hf : Function.Injective ⇑f) (S : Subalgebra R A)
Goal: Subalgebra.comap f (Subalgebra.map f S) = S
-- Pi.nonUnitalRingHom_apply
@[simps]
protected def nonUnitalRingHom {γ : Type w} [∀ i, NonUnitalNonAssocSemiring (f i)]
    [NonUnitalNonAssocSemiring γ] (g : ∀ i, γ →ₙ+* f i) : γ →ₙ+* ∀ i, f i 
Arguments: {I : Type u} {f : I → Type v} {γ : Type w} [(i : I) → NonUnitalNonAssocSemiring (f i)] [NonUnitalNonAssocSemiring γ] (g : (i : I) → γ →ₙ+* f i) (x : γ) (b : I)
Goal: (Pi.nonUnitalRingHom g) x b = (g b) x
-- Pi.nonUnitalRingHom_injective
theorem nonUnitalRingHom_injective {γ : Type w} [Nonempty I]
    [∀ i, NonUnitalNonAssocSemiring (f i)] [NonUnitalNonAssocSemiring γ] (g : ∀ i, γ →ₙ+* f i)
    (hg : ∀ i, Function.Injective (g i)) : Function.Injective (Pi.nonUnitalRingHom g) 
Arguments: {I : Type u} {f : I → Type v} {γ : Type w} [Nonempty I] [(i : I) → NonUnitalNonAssocSemiring (f i)] [NonUnitalNonAssocSemiring γ] (g : (i : I) → γ →ₙ+* f i) (hg : ∀ (i : I), Function.Injective ⇑(g i))
Goal: Function.Injective ⇑(Pi.nonUnitalRingHom g)
-- Pi.ringHom_apply
@[simps]
protected def ringHom {γ : Type w} [∀ i, NonAssocSemiring (f i)] [NonAssocSemiring γ]
    (g : ∀ i, γ →+* f i) : γ →+* ∀ i, f i 
Arguments: {I : Type u} {f : I → Type v} {γ : Type w} [(i : I) → NonAssocSemiring (f i)] [NonAssocSemiring γ] (g : (i : I) → γ →+* f i) (x : γ) (b : I)
Goal: (Pi.ringHom g) x b = (g b) x
-- Pi.ringHom_injective
theorem ringHom_injective {γ : Type w} [Nonempty I] [∀ i, NonAssocSemiring (f i)]
    [NonAssocSemiring γ] (g : ∀ i, γ →+* f i) (hg : ∀ i, Function.Injective (g i)) :
    Function.Injective (Pi.ringHom g) 
Arguments: {I : Type u} {f : I → Type v} {γ : Type w} [Nonempty I] [(i : I) → NonAssocSemiring (f i)] [NonAssocSemiring γ] (g : (i : I) → γ →+* f i) (hg : ∀ (i : I), Function.Injective ⇑(g i))
Goal: Function.Injective ⇑(Pi.ringHom g)
-- Pi.evalNonUnitalRingHom_apply
@[simps!]
def Pi.evalNonUnitalRingHom (f : I → Type v) [∀ i, NonUnitalNonAssocSemiring (f i)] (i : I) :
    (∀ i, f i) →ₙ+* f i 
Arguments: {I : Type u} (f : I → Type v) [(i : I) → NonUnitalNonAssocSemiring (f i)] (i : I) (g : (i : I) → f i)
Goal: (Pi.evalNonUnitalRingHom f i) g = g i
-- Pi.constNonUnitalRingHom_apply
@[simps]
def Pi.constNonUnitalRingHom (α β : Type*) [NonUnitalNonAssocSemiring β] : β →ₙ+* α → β 
Arguments: (α : Type u_1) (β : Type u_2) [NonUnitalNonAssocSemiring β] (a : β)
Goal: ∀ (a_1 : α), (Pi.constNonUnitalRingHom α β) a a_1 = Function.const α a a_1
-- NonUnitalRingHom.compLeft_apply
@[simps]
protected def NonUnitalRingHom.compLeft {α β : Type*} [NonUnitalNonAssocSemiring α]
    [NonUnitalNonAssocSemiring β] (f : α →ₙ+* β) (I : Type*) : (I → α) →ₙ+* I → β 
Arguments: {α : Type u_1} {β : Type u_2} [NonUnitalNonAssocSemiring α] [NonUnitalNonAssocSemiring β] (f : α →ₙ+* β) (I : Type u_3) (h : I → α)
Goal: ∀ (a : I), (f.compLeft I) h a = (⇑f ∘ h) a
-- Pi.evalRingHom_apply
@[simps!]
def Pi.evalRingHom (f : I → Type v) [∀ i, NonAssocSemiring (f i)] (i : I) : (∀ i, f i) →+* f i 
Arguments: {I : Type u} (f : I → Type v) [(i : I) → NonAssocSemiring (f i)] (i : I) (g : (i : I) → f i)
Goal: (Pi.evalRingHom f i) g = g i
-- Pi.constRingHom_apply
@[simps]
def Pi.constRingHom (α β : Type*) [NonAssocSemiring β] : β →+* α → β 
Arguments: (α : Type u_1) (β : Type u_2) [NonAssocSemiring β] (a : β)
Goal: ∀ (a_1 : α), (Pi.constRingHom α β) a a_1 = Function.const α a a_1
-- RingHom.compLeft_apply
@[simps]
protected def RingHom.compLeft {α β : Type*} [NonAssocSemiring α] [NonAssocSemiring β]
    (f : α →+* β) (I : Type*) : (I → α) →+* I → β 
Arguments: {α : Type u_1} {β : Type u_2} [NonAssocSemiring α] [NonAssocSemiring β] (f : α →+* β) (I : Type u_3) (h : I → α)
Goal: ∀ (a : I), (f.compLeft I) h a = (⇑f ∘ h) a
-- Int.negOnePow_def
lemma negOnePow_def (n : ℤ) : n.negOnePow = (-1 : ℤˣ) ^ n 
Arguments: (n : ℤ)
Goal: n.negOnePow = (-1) ^ n
-- Int.negOnePow_add
lemma negOnePow_add (n₁ n₂ : ℤ) :
    (n₁ + n₂).negOnePow =  n₁.negOnePow * n₂.negOnePow 
Arguments: (n₁ n₂ : ℤ)
Goal: (n₁ + n₂).negOnePow = n₁.negOnePow * n₂.negOnePow
-- Int.negOnePow_zero
@[simp]
lemma negOnePow_zero : negOnePow 0 = 1 
Goal: Int.negOnePow 0 = 1
-- Int.negOnePow_one
@[simp]
lemma negOnePow_one : negOnePow 1 = -1 
Goal: Int.negOnePow 1 = -1
-- Int.negOnePow_succ
lemma negOnePow_succ (n : ℤ) : (n + 1).negOnePow = - n.negOnePow 
Arguments: (n : ℤ)
Goal: (n + 1).negOnePow = -n.negOnePow
-- Int.negOnePow_even
lemma negOnePow_even (n : ℤ) (hn : Even n) : n.negOnePow = 1 
Arguments: (n : ℤ) (hn : Even n)
Goal: n.negOnePow = 1
-- Int.negOnePow_two_mul
@[simp]
lemma negOnePow_two_mul (n : ℤ) : (2 * n).negOnePow = 1 
Arguments: (n : ℤ)
Goal: (2 * n).negOnePow = 1
-- Int.negOnePow_odd
lemma negOnePow_odd (n : ℤ) (hn : Odd n) : n.negOnePow = -1 
Arguments: (n : ℤ) (hn : Odd n)
Goal: n.negOnePow = -1
-- Int.negOnePow_two_mul_add_one
@[simp]
lemma negOnePow_two_mul_add_one (n : ℤ) : (2 * n + 1).negOnePow = -1 
Arguments: (n : ℤ)
Goal: (2 * n + 1).negOnePow = -1
-- Int.negOnePow_eq_one_iff
lemma negOnePow_eq_one_iff (n : ℤ) : n.negOnePow = 1 ↔ Even n 
Arguments: (n : ℤ)
Goal: n.negOnePow = 1 ↔ Even n
-- Int.negOnePow_eq_neg_one_iff
lemma negOnePow_eq_neg_one_iff (n : ℤ) : n.negOnePow = -1 ↔ Odd n 
Arguments: (n : ℤ)
Goal: n.negOnePow = -1 ↔ Odd n
-- Int.abs_negOnePow
@[simp]
theorem abs_negOnePow (n : ℤ) : |(n.negOnePow : ℤ)| = 1 
Arguments: (n : ℤ)
Goal: |↑n.negOnePow| = 1
-- Int.negOnePow_neg
@[simp]
lemma negOnePow_neg (n : ℤ) : (-n).negOnePow = n.negOnePow 
Arguments: (n : ℤ)
Goal: (-n).negOnePow = n.negOnePow
-- Int.negOnePow_abs
@[simp]
lemma negOnePow_abs (n : ℤ) : |n|.negOnePow = n.negOnePow 
Arguments: (n : ℤ)
Goal: |n|.negOnePow = n.negOnePow
-- Int.negOnePow_sub
lemma negOnePow_sub (n₁ n₂ : ℤ) :
    (n₁ - n₂).negOnePow = n₁.negOnePow * n₂.negOnePow 
Arguments: (n₁ n₂ : ℤ)
Goal: (n₁ - n₂).negOnePow = n₁.negOnePow * n₂.negOnePow
-- Int.negOnePow_eq_iff
lemma negOnePow_eq_iff (n₁ n₂ : ℤ) :
    n₁.negOnePow = n₂.negOnePow ↔ Even (n₁ - n₂) 
Arguments: (n₁ n₂ : ℤ)
Goal: n₁.negOnePow = n₂.negOnePow ↔ Even (n₁ - n₂)
-- Int.negOnePow_mul_self
@[simp]
lemma negOnePow_mul_self (n : ℤ) : (n * n).negOnePow = n.negOnePow 
Arguments: (n : ℤ)
Goal: (n * n).negOnePow = n.negOnePow
-- Int.coe_negOnePow
lemma coe_negOnePow (K : Type*) (n : ℤ) [Field K] : n.negOnePow = (-1 : K) ^ n 
Arguments: (K : Type u_1) (n : ℤ) [Field K]
Goal: ↑↑n.negOnePow = (-1) ^ n
-- Set.natCast_mem_center
@[simp]
theorem natCast_mem_center [NonAssocSemiring M] (n : ℕ) : (n : M) ∈ Set.center M 
Arguments: (M : Type u_1) [NonAssocSemiring M] (n : ℕ)
Goal: ↑n ∈ Set.center M
-- Set.ofNat_mem_center
@[simp]
theorem ofNat_mem_center [NonAssocSemiring M] (n : ℕ) [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n)) ∈ Set.center M 
Arguments: (M : Type u_1) [NonAssocSemiring M] (n : ℕ) [n.AtLeastTwo]
Goal: OfNat.ofNat n ∈ Set.center M
-- Set.intCast_mem_center
@[simp]
theorem intCast_mem_center [NonAssocRing M] (n : ℤ) : (n : M) ∈ Set.center M 
Arguments: (M : Type u_1) [NonAssocRing M] (n : ℤ)
Goal: ↑n ∈ Set.center M
-- Set.add_mem_center
@[simp]
theorem add_mem_center [Distrib M] {a b : M} (ha : a ∈ Set.center M) (hb : b ∈ Set.center M) :
    a + b ∈ Set.center M  
Arguments: {M : Type u_1} [Distrib M] {a b : M} (ha : a ∈ Set.center M) (hb : b ∈ Set.center M)
Goal: a + b ∈ Set.center M
-- Set.neg_mem_center
@[simp]
theorem neg_mem_center [NonUnitalNonAssocRing M] {a : M} (ha : a ∈ Set.center M) :
    -a ∈ Set.center M 
Arguments: {M : Type u_1} [NonUnitalNonAssocRing M] {a : M} (ha : a ∈ Set.center M)
Goal: -a ∈ Set.center M
-- Distrib.right_distrib
class Distrib (R : Type*) extends Mul R, Add R where
    protected left_distrib : ∀ a b c : R, a * (b + c) = a * b + a * c
    protected right_distrib : ∀ a b c : R, (a + b) * c = a * c + b * c
Arguments: {R : Type u_1} [self : Distrib R] (a b c : R)
Goal: (a + b) * c = a * c + b * c
-- Distrib.left_distrib
class Distrib (R : Type*) extends Mul R, Add R where
    protected left_distrib : ∀ a b c : R, a * (b + c) = a * b + a * c
    protected right_distrib : ∀ a b c : R, (a + b) * c = a * c + b * c
Arguments: {R : Type u_1} [self : Distrib R] (a b c : R)
Goal: a * (b + c) = a * b + a * c
-- LeftDistribClass.left_distrib
class LeftDistribClass (R : Type*) [Mul R] [Add R] : Prop where
    protected left_distrib : ∀ a b c : R, a * (b + c) = a * b + a * c
Arguments: {R : Type u_1} [Mul R] [Add R] [self : LeftDistribClass R] (a b c : R)
Goal: a * (b + c) = a * b + a * c
-- RightDistribClass.right_distrib
class RightDistribClass (R : Type*) [Mul R] [Add R] : Prop where
    protected right_distrib : ∀ a b c : R, (a + b) * c = a * c + b * c
Arguments: {R : Type u_1} [Mul R] [Add R] [self : RightDistribClass R] (a b c : R)
Goal: (a + b) * c = a * c + b * c
-- left_distrib
theorem left_distrib [Mul R] [Add R] [LeftDistribClass R] (a b c : R) :
    a * (b + c) = a * b + a * c 
Arguments: {R : Type x} [Mul R] [Add R] [LeftDistribClass R] (a b c : R)
Goal: a * (b + c) = a * b + a * c
-- right_distrib
theorem right_distrib [Mul R] [Add R] [RightDistribClass R] (a b c : R) :
    (a + b) * c = a * c + b * c 
Arguments: {R : Type x} [Mul R] [Add R] [RightDistribClass R] (a b c : R)
Goal: (a + b) * c = a * c + b * c
-- distrib_three_right
theorem distrib_three_right [Mul R] [Add R] [RightDistribClass R] (a b c d : R) :
    (a + b + c) * d = a * d + b * d + c * d 
Arguments: {R : Type x} [Mul R] [Add R] [RightDistribClass R] (a b c d : R)
Goal: (a + b + c) * d = a * d + b * d + c * d
-- add_one_mul
theorem add_one_mul [RightDistribClass α] (a b : α) : (a + 1) * b = a * b + b 
Arguments: {α : Type u} [Add α] [MulOneClass α] [RightDistribClass α] (a b : α)
Goal: (a + 1) * b = a * b + b
-- mul_add_one
theorem mul_add_one [LeftDistribClass α] (a b : α) : a * (b + 1) = a * b + a 
Arguments: {α : Type u} [Add α] [MulOneClass α] [LeftDistribClass α] (a b : α)
Goal: a * (b + 1) = a * b + a
-- one_add_mul
theorem one_add_mul [RightDistribClass α] (a b : α) : (1 + a) * b = b + a * b 
Arguments: {α : Type u} [Add α] [MulOneClass α] [RightDistribClass α] (a b : α)
Goal: (1 + a) * b = b + a * b
-- mul_one_add
theorem mul_one_add [LeftDistribClass α] (a b : α) : a * (1 + b) = a + a * b 
Arguments: {α : Type u} [Add α] [MulOneClass α] [LeftDistribClass α] (a b : α)
Goal: a * (1 + b) = a + a * b
-- two_mul
theorem two_mul (n : α) : 2 * n = n + n 
Arguments: {α : Type u} [NonAssocSemiring α] (n : α)
Goal: 2 * n = n + n
-- mul_two
theorem mul_two (n : α) : n * 2 = n + n 
Arguments: {α : Type u} [NonAssocSemiring α] (n : α)
Goal: n * 2 = n + n
-- mul_ite
@[to_additive]
theorem mul_ite {α} [Mul α] (P : Prop) [Decidable P] (a b c : α) :
    (a * if P then b else c) = if P then a * b else a * c 
Arguments: {α : Type u_1} [Mul α] (P : Prop) [Decidable P] (a b c : α)
Goal: (a * if P then b else c) = if P then a * b else a * c
-- add_ite
@[to_additive]
theorem mul_ite {α} [Mul α] (P : Prop) [Decidable P] (a b c : α) :
    (a * if P then b else c) = if P then a * b else a * c 
Arguments: {α : Type u_1} [Add α] (P : Prop) [Decidable P] (a b c : α)
Goal: (a + if P then b else c) = if P then a + b else a + c
-- ite_add
@[to_additive]
theorem ite_mul {α} [Mul α] (P : Prop) [Decidable P] (a b c : α) :
    (if P then a else b) * c = if P then a * c else b * c 
Arguments: {α : Type u_1} [Add α] (P : Prop) [Decidable P] (a b c : α)
Goal: (if P then a else b) + c = if P then a + c else b + c
-- ite_mul
@[to_additive]
theorem ite_mul {α} [Mul α] (P : Prop) [Decidable P] (a b c : α) :
    (if P then a else b) * c = if P then a * c else b * c 
Arguments: {α : Type u_1} [Mul α] (P : Prop) [Decidable P] (a b c : α)
Goal: (if P then a else b) * c = if P then a * c else b * c
-- ite_sub_ite
theorem ite_sub_ite {α} [Sub α] (P : Prop) [Decidable P] (a b c d : α) :
    ((if P then a else b) - if P then c else d) = if P then a - c else b - d 
Arguments: {α : Type u_1} [Sub α] (P : Prop) [Decidable P] (a b c d : α)
Goal: ((if P then a else b) - if P then c else d) = if P then a - c else b - d
-- ite_add_ite
theorem ite_add_ite {α} [Add α] (P : Prop) [Decidable P] (a b c d : α) :
    ((if P then a else b) + if P then c else d) = if P then a + c else b + d 
Arguments: {α : Type u_1} [Add α] (P : Prop) [Decidable P] (a b c d : α)
Goal: ((if P then a else b) + if P then c else d) = if P then a + c else b + d
-- ite_zero_mul
lemma ite_zero_mul : ite P a 0 * b = ite P (a * b) 0 
Arguments: {α : Type u} [MulZeroClass α] (P : Prop) [Decidable P] (a b : α)
Goal: (if P then a else 0) * b = if P then a * b else 0
-- mul_ite_zero
lemma mul_ite_zero : a * ite P b 0 = ite P (a * b) 0 
Arguments: {α : Type u} [MulZeroClass α] (P : Prop) [Decidable P] (a b : α)
Goal: (a * if P then b else 0) = if P then a * b else 0
-- ite_zero_mul_ite_zero
lemma ite_zero_mul_ite_zero : ite P a 0 * ite Q b 0 = ite (P ∧ Q) (a * b) 0 
Arguments: {α : Type u} [MulZeroClass α] (P Q : Prop) [Decidable P] [Decidable Q] (a b : α)
Goal: ((if P then a else 0) * if Q then b else 0) = if P ∧ Q then a * b else 0
-- mul_boole
theorem mul_boole {α} [MulZeroOneClass α] (P : Prop) [Decidable P] (a : α) :
    (a * if P then 1 else 0) = if P then a else 0 
Arguments: {α : Type u_1} [MulZeroOneClass α] (P : Prop) [Decidable P] (a : α)
Goal: (a * if P then 1 else 0) = if P then a else 0
-- boole_mul
theorem boole_mul {α} [MulZeroOneClass α] (P : Prop) [Decidable P] (a : α) :
    (if P then 1 else 0) * a = if P then a else 0 
Arguments: {α : Type u_1} [MulZeroOneClass α] (P : Prop) [Decidable P] (a : α)
Goal: (if P then 1 else 0) * a = if P then a else 0
-- add_mul_self_eq
theorem add_mul_self_eq (a b : α) : (a + b) * (a + b) = a * a + 2 * a * b + b * b 
Arguments: {α : Type u} [CommSemiring α] (a b : α)
Goal: (a + b) * (a + b) = a * a + 2 * a * b + b * b
-- add_sq
lemma add_sq (a b : α) : (a + b) ^ 2 = a ^ 2 + 2 * a * b + b ^ 2 
Arguments: {α : Type u} [CommSemiring α] (a b : α)
Goal: (a + b) ^ 2 = a ^ 2 + 2 * a * b + b ^ 2
-- add_sq'
lemma add_sq' (a b : α) : (a + b) ^ 2 = a ^ 2 + b ^ 2 + 2 * a * b 
Arguments: {α : Type u} [CommSemiring α] (a b : α)
Goal: (a + b) ^ 2 = a ^ 2 + b ^ 2 + 2 * a * b
-- HasDistribNeg.mul_neg
class HasDistribNeg (α : Type*) [Mul α] extends InvolutiveNeg α where
    neg_mul : ∀ x y : α, -x * y = -(x * y)
    mul_neg : ∀ x y : α, x * -y = -(x * y)
Arguments: {α : Type u_1} [Mul α] [self : HasDistribNeg α] (x y : α)
Goal: x * -y = -(x * y)
-- HasDistribNeg.neg_mul
class HasDistribNeg (α : Type*) [Mul α] extends InvolutiveNeg α where
    neg_mul : ∀ x y : α, -x * y = -(x * y)
    mul_neg : ∀ x y : α, x * -y = -(x * y)
Arguments: {α : Type u_1} [Mul α] [self : HasDistribNeg α] (x y : α)
Goal: -x * y = -(x * y)
-- neg_mul
@[simp]
theorem neg_mul (a b : α) : -a * b = -(a * b) 
Arguments: {α : Type u} [Mul α] [HasDistribNeg α] (a b : α)
Goal: -a * b = -(a * b)
-- mul_neg
@[simp]
theorem mul_neg (a b : α) : a * -b = -(a * b) 
Arguments: {α : Type u} [Mul α] [HasDistribNeg α] (a b : α)
Goal: a * -b = -(a * b)
-- neg_mul_neg
theorem neg_mul_neg (a b : α) : -a * -b = a * b 
Arguments: {α : Type u} [Mul α] [HasDistribNeg α] (a b : α)
Goal: -a * -b = a * b
-- neg_mul_eq_neg_mul
theorem neg_mul_eq_neg_mul (a b : α) : -(a * b) = -a * b 
Arguments: {α : Type u} [Mul α] [HasDistribNeg α] (a b : α)
Goal: -(a * b) = -a * b
-- neg_mul_eq_mul_neg
theorem neg_mul_eq_mul_neg (a b : α) : -(a * b) = a * -b 
Arguments: {α : Type u} [Mul α] [HasDistribNeg α] (a b : α)
Goal: -(a * b) = a * -b
-- neg_mul_comm
theorem neg_mul_comm (a b : α) : -a * b = a * -b 
Arguments: {α : Type u} [Mul α] [HasDistribNeg α] (a b : α)
Goal: -a * b = a * -b
-- neg_eq_neg_one_mul
theorem neg_eq_neg_one_mul (a : α) : -a = -1 * a 
Arguments: {α : Type u} [MulOneClass α] [HasDistribNeg α] (a : α)
Goal: -a = -1 * a
-- mul_neg_one
theorem mul_neg_one (a : α) : a * -1 = -a 
Arguments: {α : Type u} [MulOneClass α] [HasDistribNeg α] (a : α)
Goal: a * -1 = -a
-- neg_one_mul
theorem neg_one_mul (a : α) : -1 * a = -a 
Arguments: {α : Type u} [MulOneClass α] [HasDistribNeg α] (a : α)
Goal: -1 * a = -a
-- mul_sub_left_distrib
theorem mul_sub_left_distrib (a b c : α) : a * (b - c) = a * b - a * c 
Arguments: {α : Type u} [NonUnitalNonAssocRing α] (a b c : α)
Goal: a * (b - c) = a * b - a * c
-- mul_sub_right_distrib
theorem mul_sub_right_distrib (a b c : α) : (a - b) * c = a * c - b * c 
Arguments: {α : Type u} [NonUnitalNonAssocRing α] (a b c : α)
Goal: (a - b) * c = a * c - b * c
-- sub_one_mul
theorem sub_one_mul (a b : α) : (a - 1) * b = a * b - b 
Arguments: {α : Type u} [NonAssocRing α] (a b : α)
Goal: (a - 1) * b = a * b - b
-- mul_sub_one
theorem mul_sub_one (a b : α) : a * (b - 1) = a * b - a 
Arguments: {α : Type u} [NonAssocRing α] (a b : α)
Goal: a * (b - 1) = a * b - a
-- one_sub_mul
theorem one_sub_mul (a b : α) : (1 - a) * b = b - a * b 
Arguments: {α : Type u} [NonAssocRing α] (a b : α)
Goal: (1 - a) * b = b - a * b
-- mul_one_sub
theorem mul_one_sub (a b : α) : a * (1 - b) = a - a * b 
Arguments: {α : Type u} [NonAssocRing α] (a b : α)
Goal: a * (1 - b) = a - a * b
-- Commute.add_right
@[simp]
theorem add_right [Distrib R] {a b c : R} : Commute a b → Commute a c → Commute a (b + c) 
Arguments: {R : Type x} [Distrib R] {a b c : R}
Goal: Commute a b → Commute a c → Commute a (b + c)
-- Commute.add_left
@[simp]
theorem add_left [Distrib R] {a b c : R} : Commute a c → Commute b c → Commute (a + b) c 
Arguments: {R : Type x} [Distrib R] {a b c : R}
Goal: Commute a c → Commute b c → Commute (a + b) c
-- Commute.mul_self_sub_mul_self_eq
theorem mul_self_sub_mul_self_eq [NonUnitalNonAssocRing R] {a b : R} (h : Commute a b) :
    a * a - b * b = (a + b) * (a - b) 
Arguments: {R : Type x} [NonUnitalNonAssocRing R] {a b : R} (h : Commute a b)
Goal: a * a - b * b = (a + b) * (a - b)
-- Commute.mul_self_sub_mul_self_eq'
theorem mul_self_sub_mul_self_eq' [NonUnitalNonAssocRing R] {a b : R} (h : Commute a b) :
    a * a - b * b = (a - b) * (a + b) 
Arguments: {R : Type x} [NonUnitalNonAssocRing R] {a b : R} (h : Commute a b)
Goal: a * a - b * b = (a - b) * (a + b)
-- Commute.mul_self_eq_mul_self_iff
theorem mul_self_eq_mul_self_iff [NonUnitalNonAssocRing R] [NoZeroDivisors R] {a b : R}
    (h : Commute a b) : a * a = b * b ↔ a = b ∨ a = -b 
Arguments: {R : Type x} [NonUnitalNonAssocRing R] [NoZeroDivisors R] {a b : R} (h : Commute a b)
Goal: a * a = b * b ↔ a = b ∨ a = -b
-- Commute.neg_right
theorem neg_right : Commute a b → Commute a (-b) 
Arguments: {R : Type x} [Mul R] [HasDistribNeg R] {a b : R}
Goal: Commute a b → Commute a (-b)
-- Commute.neg_right_iff
@[simp]
theorem neg_right_iff : Commute a (-b) ↔ Commute a b 
Arguments: {R : Type x} [Mul R] [HasDistribNeg R] {a b : R}
Goal: Commute a (-b) ↔ Commute a b
-- Commute.neg_left
theorem neg_left : Commute a b → Commute (-a) b 
Arguments: {R : Type x} [Mul R] [HasDistribNeg R] {a b : R}
Goal: Commute a b → Commute (-a) b
-- Commute.neg_left_iff
@[simp]
theorem neg_left_iff : Commute (-a) b ↔ Commute a b 
Arguments: {R : Type x} [Mul R] [HasDistribNeg R] {a b : R}
Goal: Commute (-a) b ↔ Commute a b
-- Commute.neg_one_right
theorem neg_one_right (a : R) : Commute a (-1) 
Arguments: {R : Type x} [MulOneClass R] [HasDistribNeg R] (a : R)
Goal: Commute a (-1)
-- Commute.neg_one_left
theorem neg_one_left (a : R) : Commute (-1) a 
Arguments: {R : Type x} [MulOneClass R] [HasDistribNeg R] (a : R)
Goal: Commute (-1) a
-- Commute.sub_right
@[simp]
theorem sub_right : Commute a b → Commute a c → Commute a (b - c) 
Arguments: {R : Type x} [NonUnitalNonAssocRing R] {a b c : R}
Goal: Commute a b → Commute a c → Commute a (b - c)
-- Commute.sub_left
@[simp]
theorem sub_left : Commute a c → Commute b c → Commute (a - b) c 
Arguments: {R : Type x} [NonUnitalNonAssocRing R] {a b c : R}
Goal: Commute a c → Commute b c → Commute (a - b) c
-- Commute.sq_sub_sq
protected lemma sq_sub_sq (h : Commute a b) : a ^ 2 - b ^ 2 = (a + b) * (a - b) 
Arguments: {R : Type x} [Ring R] {a b : R} (h : Commute a b)
Goal: a ^ 2 - b ^ 2 = (a + b) * (a - b)
-- Commute.sq_eq_sq_iff_eq_or_eq_neg
protected lemma sq_eq_sq_iff_eq_or_eq_neg (h : Commute a b) : a ^ 2 = b ^ 2 ↔ a = b ∨ a = -b 
Arguments: {R : Type x} [Ring R] {a b : R} [NoZeroDivisors R] (h : Commute a b)
Goal: a ^ 2 = b ^ 2 ↔ a = b ∨ a = -b
-- neg_one_pow_eq_or
lemma neg_one_pow_eq_or : ∀ n : ℕ, (-1 : R) ^ n = 1 ∨ (-1 : R) ^ n = -1
  
Arguments: (R : Type x) [Monoid R] [HasDistribNeg R] (n : ℕ)
Goal: (-1) ^ n = 1 ∨ (-1) ^ n = -1
-- neg_pow
lemma neg_pow (a : R) (n : ℕ) : (-a) ^ n = (-1) ^ n * a ^ n 
Arguments: {R : Type x} [Monoid R] [HasDistribNeg R] (a : R) (n : ℕ)
Goal: (-a) ^ n = (-1) ^ n * a ^ n
-- neg_pow'
lemma neg_pow' (a : R) (n : ℕ) : (-a) ^ n = a ^ n * (-1) ^ n 
Arguments: {R : Type x} [Monoid R] [HasDistribNeg R] (a : R) (n : ℕ)
Goal: (-a) ^ n = a ^ n * (-1) ^ n
-- neg_sq
lemma neg_sq (a : R) : (-a) ^ 2 = a ^ 2 
Arguments: {R : Type x} [Monoid R] [HasDistribNeg R] (a : R)
Goal: (-a) ^ 2 = a ^ 2
-- neg_one_sq
lemma neg_one_sq : (-1 : R) ^ 2 = 1 
Arguments: {R : Type x} [Monoid R] [HasDistribNeg R]
Goal: (-1) ^ 2 = 1