ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AlgHom.toRingHom_toRatAlgHom
@[simp]
theorem AlgHom.toRingHom_toRatAlgHom [Ring R] [Ring S] [Algebra ℚ R] [Algebra ℚ S]
    (f : R →ₐ[ℚ] S) : (f : R →+* S).toRatAlgHom = f 
Arguments: {R : Type u_1} {S : Type u_2} [Ring R] [Ring S] [Algebra ℚ R] [Algebra ℚ S] (f : R →ₐ[ℚ] S)
Goal: (↑f).toRatAlgHom = f
-- RingHom.equivRatAlgHom_symm_apply
@[simps]
def RingHom.equivRatAlgHom [Ring R] [Ring S] [Algebra ℚ R] [Algebra ℚ S] :
    (R →+* S) ≃ (R →ₐ[ℚ] S) 
Arguments: {R : Type u_1} {S : Type u_2} [Ring R] [Ring S] [Algebra ℚ R] [Algebra ℚ S] (self : R →ₐ[ℚ] S)
Goal: RingHom.equivRatAlgHom.symm self = self.toRingHom
-- RingHom.equivRatAlgHom_apply
@[simps]
def RingHom.equivRatAlgHom [Ring R] [Ring S] [Algebra ℚ R] [Algebra ℚ S] :
    (R →+* S) ≃ (R →ₐ[ℚ] S) 
Arguments: {R : Type u_1} {S : Type u_2} [Ring R] [Ring S] [Algebra ℚ R] [Algebra ℚ S] (f : R →+* S)
Goal: RingHom.equivRatAlgHom f = f.toRatAlgHom
-- AddChar.map_add_eq_mul'
structure AddChar where
    toFun : A → M
    map_zero_eq_one' : toFun 0 = 1
    map_add_eq_mul' : ∀ a b : A, toFun (a + b) = toFun a * toFun b
Arguments: {A : Type u_1} [AddMonoid A] {M : Type u_2} [Monoid M] (self : AddChar A M) (a b : A)
Goal: self.toFun (a + b) = self.toFun a * self.toFun b
-- AddChar.map_zero_eq_one'
structure AddChar where
    toFun : A → M
    map_zero_eq_one' : toFun 0 = 1
    map_add_eq_mul' : ∀ a b : A, toFun (a + b) = toFun a * toFun b
Arguments: {A : Type u_1} [AddMonoid A] {M : Type u_2} [Monoid M] (self : AddChar A M)
Goal: self.toFun 0 = 1
-- AddChar.ext
@[ext] lemma ext (f g : AddChar A M) (h : ∀ x : A, f x = g x) : f = g 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (f g : AddChar A M) (h : ∀ (x : A), f x = g x)
Goal: f = g
-- AddChar.coe_mk
@[simp] lemma coe_mk (f : A → M)
    (map_zero_eq_one' : f 0 = 1) (map_add_eq_mul' : ∀ a b : A, f (a + b) = f a * f b) :
    AddChar.mk f map_zero_eq_one' map_add_eq_mul' = f 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (f : A → M) (map_zero_eq_one' : f 0 = 1) (map_add_eq_mul' : ∀ (a b : A), f (a + b) = f a * f b)
Goal: ⇑{ toFun := f, map_zero_eq_one' := map_zero_eq_one', map_add_eq_mul' := map_add_eq_mul' } = f
-- AddChar.map_zero_eq_one
@[simp] lemma map_zero_eq_one (ψ : AddChar A M) : ψ 0 = 1 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (ψ : AddChar A M)
Goal: ψ 0 = 1
-- AddChar.map_add_eq_mul
lemma map_add_eq_mul (ψ : AddChar A M) (x y : A) : ψ (x + y) = ψ x * ψ y 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (ψ : AddChar A M) (x y : A)
Goal: ψ (x + y) = ψ x * ψ y
-- AddChar.toMonoidHom_apply
@[simp] lemma toMonoidHom_apply (ψ : AddChar A M) (a : Multiplicative A) :
  ψ.toMonoidHom a = ψ (Multiplicative.toAdd a) 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (ψ : AddChar A M) (a : Multiplicative A)
Goal: ψ.toMonoidHom a = ψ (Multiplicative.toAdd a)
-- AddChar.map_nsmul_eq_pow
lemma map_nsmul_eq_pow (ψ : AddChar A M) (n : ℕ) (x : A) : ψ (n • x) = ψ x ^ n 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (ψ : AddChar A M) (n : ℕ) (x : A)
Goal: ψ (n • x) = ψ x ^ n
-- AddChar.coe_toMonoidHomEquiv
@[simp, norm_cast] lemma coe_toMonoidHomEquiv (ψ : AddChar A M) :
    ⇑(toMonoidHomEquiv ψ) = ψ ∘ Multiplicative.toAdd 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (ψ : AddChar A M)
Goal: ⇑(AddChar.toMonoidHomEquiv ψ) = ⇑ψ ∘ ⇑Multiplicative.toAdd
-- AddChar.coe_toMonoidHomEquiv_symm
@[simp, norm_cast] lemma coe_toMonoidHomEquiv_symm (ψ : Multiplicative A →* M) :
    ⇑(toMonoidHomEquiv.symm ψ) = ψ ∘ Multiplicative.ofAdd 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (ψ : Multiplicative A →* M)
Goal: ⇑(AddChar.toMonoidHomEquiv.symm ψ) = ⇑ψ ∘ ⇑Multiplicative.ofAdd
-- AddChar.toMonoidHomEquiv_apply
@[simp] lemma toMonoidHomEquiv_apply (ψ : AddChar A M) (a : Multiplicative A) :
    toMonoidHomEquiv ψ a = ψ (Multiplicative.toAdd a) 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (ψ : AddChar A M) (a : Multiplicative A)
Goal: (AddChar.toMonoidHomEquiv ψ) a = ψ (Multiplicative.toAdd a)
-- AddChar.toMonoidHomEquiv_symm_apply
@[simp] lemma toMonoidHomEquiv_symm_apply (ψ : Multiplicative A →* M) (a : A) :
    toMonoidHomEquiv.symm ψ a = ψ (Multiplicative.ofAdd a) 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (ψ : Multiplicative A →* M) (a : A)
Goal: (AddChar.toMonoidHomEquiv.symm ψ) a = ψ (Multiplicative.ofAdd a)
-- AddChar.coe_toAddMonoidHom
@[simp] lemma coe_toAddMonoidHom (ψ : AddChar A M) : ⇑ψ.toAddMonoidHom = Additive.ofMul ∘ ψ 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (ψ : AddChar A M)
Goal: ⇑ψ.toAddMonoidHom = ⇑Additive.ofMul ∘ ⇑ψ
-- AddChar.toAddMonoidHom_apply
@[simp] lemma toAddMonoidHom_apply (ψ : AddChar A M) (a : A) :
    ψ.toAddMonoidHom a = Additive.ofMul (ψ a) 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (ψ : AddChar A M) (a : A)
Goal: ψ.toAddMonoidHom a = Additive.ofMul (ψ a)
-- AddChar.coe_toAddMonoidHomEquiv
@[simp, norm_cast]
lemma coe_toAddMonoidHomEquiv (ψ : AddChar A M) :
    ⇑(toAddMonoidHomEquiv ψ) = Additive.ofMul ∘ ψ 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (ψ : AddChar A M)
Goal: ⇑(AddChar.toAddMonoidHomEquiv ψ) = ⇑Additive.ofMul ∘ ⇑ψ
-- AddChar.coe_toAddMonoidHomEquiv_symm
@[simp, norm_cast] lemma coe_toAddMonoidHomEquiv_symm (ψ : A →+ Additive M) :
    ⇑(toAddMonoidHomEquiv.symm ψ) = Additive.toMul ∘ ψ 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (ψ : A →+ Additive M)
Goal: ⇑(AddChar.toAddMonoidHomEquiv.symm ψ) = ⇑Additive.toMul ∘ ⇑ψ
-- AddChar.toAddMonoidHomEquiv_apply
@[simp] lemma toAddMonoidHomEquiv_apply (ψ : AddChar A M) (a : A) :
    toAddMonoidHomEquiv ψ a = Additive.ofMul (ψ a) 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (ψ : AddChar A M) (a : A)
Goal: (AddChar.toAddMonoidHomEquiv ψ) a = Additive.ofMul (ψ a)
-- AddChar.toAddMonoidHomEquiv_symm_apply
@[simp] lemma toAddMonoidHomEquiv_symm_apply (ψ : A →+ Additive M) (a : A) :
    toAddMonoidHomEquiv.symm ψ a = Additive.toMul (ψ a) 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (ψ : A →+ Additive M) (a : A)
Goal: (AddChar.toAddMonoidHomEquiv.symm ψ) a = Additive.toMul (ψ a)
-- AddChar.coe_one
@[simp, norm_cast] lemma coe_one : ⇑(1 : AddChar A M) = 1 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M]
Goal: ⇑1 = 1
-- AddChar.one_apply
@[simp] lemma one_apply (a : A) : (1 : AddChar A M) a = 1 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (a : A)
Goal: 1 a = 1
-- MonoidHom.coe_compAddChar
@[simp, norm_cast]
lemma _root_.MonoidHom.coe_compAddChar {N : Type*} [Monoid N] (f : M →* N) (φ : AddChar A M) :
    f.compAddChar φ = f ∘ φ 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] {N : Type u_5} [Monoid N] (f : M →* N) (φ : AddChar A M)
Goal: ⇑(f.compAddChar φ) = ⇑f ∘ ⇑φ
-- MonoidHom.compAddChar_apply
@[simp, norm_cast]
lemma _root_.MonoidHom.compAddChar_apply (f : M →* N) (φ : AddChar A M) : f.compAddChar φ = f ∘ φ 
Arguments: {A : Type u_1} {M : Type u_3} {N : Type u_4} [AddMonoid A] [Monoid M] [Monoid N] (f : M →* N) (φ : AddChar A M)
Goal: ⇑(f.compAddChar φ) = ⇑f ∘ ⇑φ
-- MonoidHom.compAddChar_injective_left
lemma _root_.MonoidHom.compAddChar_injective_left (ψ : AddChar A M) (hψ : Surjective ψ) :
    Injective fun f : M →* N ↦ f.compAddChar ψ 
Arguments: {A : Type u_1} {M : Type u_3} {N : Type u_4} [AddMonoid A] [Monoid M] [Monoid N] (ψ : AddChar A M) (hψ : Function.Surjective ⇑ψ)
Goal: Function.Injective fun f => f.compAddChar ψ
-- MonoidHom.compAddChar_injective_right
lemma _root_.MonoidHom.compAddChar_injective_right (f : M →* N) (hf : Injective f) :
    Injective fun ψ : AddChar B M ↦ f.compAddChar ψ 
Arguments: {B : Type u_2} {M : Type u_3} {N : Type u_4} [AddMonoid B] [Monoid M] [Monoid N] (f : M →* N) (hf : Function.Injective ⇑f)
Goal: Function.Injective fun ψ => f.compAddChar ψ
-- AddChar.coe_compAddMonoidHom
@[simp, norm_cast]
lemma coe_compAddMonoidHom (φ : AddChar B M) (f : A →+ B) : φ.compAddMonoidHom f = φ ∘ f 
Arguments: {A : Type u_1} {B : Type u_2} {M : Type u_3} [AddMonoid A] [AddMonoid B] [Monoid M] (φ : AddChar B M) (f : A →+ B)
Goal: ⇑(φ.compAddMonoidHom f) = ⇑φ ∘ ⇑f
-- AddChar.compAddMonoidHom_apply
@[simp] lemma compAddMonoidHom_apply (ψ : AddChar B M) (f : A →+ B)
    (a : A) : ψ.compAddMonoidHom f a = ψ (f a) 
Arguments: {A : Type u_1} {B : Type u_2} {M : Type u_3} [AddMonoid A] [AddMonoid B] [Monoid M] (ψ : AddChar B M) (f : A →+ B) (a : A)
Goal: (ψ.compAddMonoidHom f) a = ψ (f a)
-- AddChar.compAddMonoidHom_injective_left
lemma compAddMonoidHom_injective_left (f : A →+ B) (hf : Surjective f) :
    Injective fun ψ : AddChar B M ↦ ψ.compAddMonoidHom f 
Arguments: {A : Type u_1} {B : Type u_2} {M : Type u_3} [AddMonoid A] [AddMonoid B] [Monoid M] (f : A →+ B) (hf : Function.Surjective ⇑f)
Goal: Function.Injective fun ψ => ψ.compAddMonoidHom f
-- AddChar.compAddMonoidHom_injective_right
lemma compAddMonoidHom_injective_right (ψ : AddChar B M) (hψ : Injective ψ) :
    Injective fun f : A →+ B ↦ ψ.compAddMonoidHom f 
Arguments: {A : Type u_1} {B : Type u_2} {M : Type u_3} [AddMonoid A] [AddMonoid B] [Monoid M] (ψ : AddChar B M) (hψ : Function.Injective ⇑ψ)
Goal: Function.Injective fun f => ψ.compAddMonoidHom f
-- AddChar.eq_one_iff
lemma eq_one_iff : ψ = 1 ↔ ∀ x, ψ x = 1 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] {ψ : AddChar A M}
Goal: ψ = 1 ↔ ∀ (x : A), ψ x = 1
-- AddChar.ne_one_iff
lemma ne_one_iff : ψ ≠ 1 ↔ ∃ x, ψ x ≠ 1 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] {ψ : AddChar A M}
Goal: ψ ≠ 1 ↔ ∃ x, ψ x ≠ 1
-- AddChar.isNontrivial_iff_ne_trivial
@[deprecated ne_one_iff (since := "2024-06-06")]
lemma isNontrivial_iff_ne_trivial (ψ : AddChar A M) : IsNontrivial ψ ↔ ψ ≠ 1 
Arguments: {A : Type u_1} {M : Type u_3} [AddMonoid A] [Monoid M] (ψ : AddChar A M)
Goal: ψ.IsNontrivial ↔ ψ ≠ 1
-- AddChar.coe_mul
@[simp, norm_cast] lemma coe_mul (ψ χ : AddChar A M) : ⇑(ψ * χ) = ψ * χ 
Arguments: {A : Type u_1} {M : Type u_2} [AddMonoid A] [CommMonoid M] (ψ χ : AddChar A M)
Goal: ⇑(ψ * χ) = ⇑ψ * ⇑χ
-- AddChar.coe_pow
@[simp, norm_cast] lemma coe_pow (ψ : AddChar A M) (n : ℕ) : ⇑(ψ ^ n) = ψ ^ n 
Arguments: {A : Type u_1} {M : Type u_2} [AddMonoid A] [CommMonoid M] (ψ : AddChar A M) (n : ℕ)
Goal: ⇑(ψ ^ n) = ⇑ψ ^ n
-- AddChar.mul_apply
@[simp, norm_cast] lemma mul_apply (ψ φ : AddChar A M) (a : A) : (ψ * φ) a = ψ a * φ a 
Arguments: {A : Type u_1} {M : Type u_2} [AddMonoid A] [CommMonoid M] (ψ φ : AddChar A M) (a : A)
Goal: (ψ * φ) a = ψ a * φ a
-- AddChar.pow_apply
@[simp, norm_cast] lemma pow_apply (ψ : AddChar A M) (n : ℕ) (a : A) : (ψ ^ n) a = (ψ a) ^ n 
Arguments: {A : Type u_1} {M : Type u_2} [AddMonoid A] [CommMonoid M] (ψ : AddChar A M) (n : ℕ) (a : A)
Goal: (ψ ^ n) a = ψ a ^ n
-- AddChar.inv_apply
@[simp] lemma inv_apply (ψ : AddChar A M) (x : A) : ψ⁻¹ x = ψ (-x) 
Arguments: {A : Type u_1} {M : Type u_2} [AddCommGroup A] [CommMonoid M] (ψ : AddChar A M) (x : A)
Goal: ψ⁻¹ x = ψ (-x)
-- AddChar.val_isUnit
lemma val_isUnit {A M} [AddGroup A] [Monoid M] (φ : AddChar A M) (a : A) : IsUnit (φ a) 
Arguments: {A : Type u_1} {M : Type u_2} [AddGroup A] [Monoid M] (φ : AddChar A M) (a : A)
Goal: IsUnit (φ a)
-- AddChar.map_neg_eq_inv
lemma map_neg_eq_inv (ψ : AddChar A M) (a : A) : ψ (-a) = (ψ a)⁻¹ 
Arguments: {A : Type u_1} {M : Type u_2} [AddGroup A] [DivisionMonoid M] (ψ : AddChar A M) (a : A)
Goal: ψ (-a) = (ψ a)⁻¹
-- AddChar.map_zsmul_eq_zpow
lemma map_zsmul_eq_zpow (ψ : AddChar A M) (n : ℤ) (a : A) : ψ (n • a) = (ψ a) ^ n 
Arguments: {A : Type u_1} {M : Type u_2} [AddGroup A] [DivisionMonoid M] (ψ : AddChar A M) (n : ℤ) (a : A)
Goal: ψ (n • a) = ψ a ^ n
-- AddChar.inv_apply'
lemma inv_apply' (ψ : AddChar A M) (x : A) : ψ⁻¹ x = (ψ x)⁻¹ 
Arguments: {A : Type u_1} {M : Type u_2} [AddCommGroup A] [DivisionCommMonoid M] (ψ : AddChar A M) (x : A)
Goal: ψ⁻¹ x = (ψ x)⁻¹
-- AddChar.map_sub_eq_div
lemma map_sub_eq_div (ψ : AddChar A M) (a b : A) : ψ (a - b) = ψ a / ψ b 
Arguments: {A : Type u_1} {M : Type u_2} [AddCommGroup A] [DivisionCommMonoid M] (ψ : AddChar A M) (a b : A)
Goal: ψ (a - b) = ψ a / ψ b
-- AddChar.injective_iff
lemma injective_iff {ψ : AddChar A M} : Injective ψ ↔ ∀ ⦃x⦄, ψ x = 1 → x = 0 
Arguments: {A : Type u_1} {M : Type u_2} [AddCommGroup A] [DivisionCommMonoid M] {ψ : AddChar A M}
Goal: Function.Injective ⇑ψ ↔ ∀ ⦃x : A⦄, ψ x = 1 → x = 0
-- AddChar.mulShift_apply
@[simp] lemma mulShift_apply {ψ : AddChar R M} {r : R} {x : R} : mulShift ψ r x = ψ (r * x) 
Arguments: {R : Type u_1} {M : Type u_2} [Ring R] [CommMonoid M] {ψ : AddChar R M} {r x : R}
Goal: (ψ.mulShift r) x = ψ (r * x)
-- AddChar.inv_mulShift
theorem inv_mulShift (ψ : AddChar R M) : ψ⁻¹ = mulShift ψ (-1) 
Arguments: {R : Type u_1} {M : Type u_2} [Ring R] [CommMonoid M] (ψ : AddChar R M)
Goal: ψ⁻¹ = ψ.mulShift (-1)
-- AddChar.mulShift_spec'
theorem mulShift_spec' (ψ : AddChar R M) (n : ℕ) (x : R) : mulShift ψ n x = ψ x ^ n 
Arguments: {R : Type u_1} {M : Type u_2} [Ring R] [CommMonoid M] (ψ : AddChar R M) (n : ℕ) (x : R)
Goal: (ψ.mulShift ↑n) x = ψ x ^ n
-- AddChar.pow_mulShift
theorem pow_mulShift (ψ : AddChar R M) (n : ℕ) : ψ ^ n = mulShift ψ n 
Arguments: {R : Type u_1} {M : Type u_2} [Ring R] [CommMonoid M] (ψ : AddChar R M) (n : ℕ)
Goal: ψ ^ n = ψ.mulShift ↑n
-- AddChar.mulShift_mul
theorem mulShift_mul (ψ : AddChar R M) (r s : R) :
    mulShift ψ r * mulShift ψ s = mulShift ψ (r + s) 
Arguments: {R : Type u_1} {M : Type u_2} [Ring R] [CommMonoid M] (ψ : AddChar R M) (r s : R)
Goal: ψ.mulShift r * ψ.mulShift s = ψ.mulShift (r + s)
-- AddChar.mulShift_mulShift
lemma mulShift_mulShift (ψ : AddChar R M) (r s : R) :
    mulShift (mulShift ψ r) s = mulShift ψ (r * s) 
Arguments: {R : Type u_1} {M : Type u_2} [Ring R] [CommMonoid M] (ψ : AddChar R M) (r s : R)
Goal: (ψ.mulShift r).mulShift s = ψ.mulShift (r * s)
-- AddChar.mulShift_zero
@[simp]
theorem mulShift_zero (ψ : AddChar R M) : mulShift ψ 0 = 1 
Arguments: {R : Type u_1} {M : Type u_2} [Ring R] [CommMonoid M] (ψ : AddChar R M)
Goal: ψ.mulShift 0 = 1
-- AddChar.mulShift_one
@[simp]
lemma mulShift_one (ψ : AddChar R M) : mulShift ψ 1 = ψ 
Arguments: {R : Type u_1} {M : Type u_2} [Ring R] [CommMonoid M] (ψ : AddChar R M)
Goal: ψ.mulShift 1 = ψ
-- AddChar.mulShift_unit_eq_one_iff
lemma mulShift_unit_eq_one_iff (ψ : AddChar R M) {u : R} (hu : IsUnit u) :
    ψ.mulShift u = 1 ↔ ψ = 1 
Arguments: {R : Type u_1} {M : Type u_2} [Ring R] [CommMonoid M] (ψ : AddChar R M) {u : R} (hu : IsUnit u)
Goal: ψ.mulShift u = 1 ↔ ψ = 1
-- Units.val_inv
structure Units (α : Type u) [Monoid α] where
    val : α
    inv : α
    val_inv : val * inv = 1
    inv_val : inv * val = 1
Arguments: {α : Type u} [Monoid α] (self : αˣ)
Goal: ↑self * self.inv = 1
-- Units.inv_val
structure Units (α : Type u) [Monoid α] where
    val : α
    inv : α
    val_inv : val * inv = 1
    inv_val : inv * val = 1
Arguments: {α : Type u} [Monoid α] (self : αˣ)
Goal: self.inv * ↑self = 1
-- AddUnits.val_neg
structure AddUnits (α : Type u) [AddMonoid α] where
    val : α
    neg : α
    val_neg : val + neg = 0
    neg_val : neg + val = 0
Arguments: {α : Type u} [AddMonoid α] (self : AddUnits α)
Goal: ↑self + self.neg = 0
-- AddUnits.neg_val
structure AddUnits (α : Type u) [AddMonoid α] where
    val : α
    neg : α
    val_neg : val + neg = 0
    neg_val : neg + val = 0
Arguments: {α : Type u} [AddMonoid α] (self : AddUnits α)
Goal: self.neg + ↑self = 0
-- unique_zero
@[to_additive]
theorem unique_one {α : Type*} [Unique α] [One α] : default = (1 : α) 
Arguments: {α : Type u_1} [Unique α] [Zero α]
Goal: default = 0
-- unique_one
@[to_additive]
theorem unique_one {α : Type*} [Unique α] [One α] : default = (1 : α) 
Arguments: {α : Type u_1} [Unique α] [One α]
Goal: default = 1
-- Units.val_mk
@[to_additive]
theorem val_mk (a : α) (b h₁ h₂) : ↑(Units.mk a b h₁ h₂) = a 
Arguments: {α : Type u} [Monoid α] (a b : α) (h₁ : a * b = 1) (h₂ : b * a = 1)
Goal: ↑{ val := a, inv := b, val_inv := h₁, inv_val := h₂ } = a
-- AddUnits.val_mk
@[to_additive]
theorem val_mk (a : α) (b h₁ h₂) : ↑(Units.mk a b h₁ h₂) = a 
Arguments: {α : Type u} [AddMonoid α] (a b : α) (h₁ : a + b = 0) (h₂ : b + a = 0)
Goal: ↑{ val := a, neg := b, val_neg := h₁, neg_val := h₂ } = a
-- Units.ext
@[to_additive (attr := ext)]
theorem ext : Function.Injective (val : αˣ → α)
  
Arguments: {α : Type u} [Monoid α]
Goal: Function.Injective Units.val
-- AddUnits.ext
@[to_additive (attr := ext)]
theorem ext : Function.Injective (val : αˣ → α)
  
Arguments: {α : Type u} [AddMonoid α]
Goal: Function.Injective AddUnits.val
-- AddUnits.eq_iff
@[to_additive (attr := norm_cast)]
theorem eq_iff {a b : αˣ} : (a : α) = b ↔ a = b 
Arguments: {α : Type u} [AddMonoid α] {a b : AddUnits α}
Goal: ↑a = ↑b ↔ a = b
-- Units.eq_iff
@[to_additive (attr := norm_cast)]
theorem eq_iff {a b : αˣ} : (a : α) = b ↔ a = b 
Arguments: {α : Type u} [Monoid α] {a b : αˣ}
Goal: ↑a = ↑b ↔ a = b
-- AddUnits.ext_iff
@[to_additive]
protected theorem ext_iff {a b : αˣ} : a = b ↔ (a : α) = b 
Arguments: {α : Type u} [AddMonoid α] {a b : AddUnits α}
Goal: a = b ↔ ↑a = ↑b
-- Units.ext_iff
@[to_additive]
protected theorem ext_iff {a b : αˣ} : a = b ↔ (a : α) = b 
Arguments: {α : Type u} [Monoid α] {a b : αˣ}
Goal: a = b ↔ ↑a = ↑b
-- Units.mk_val
@[to_additive (attr := simp)]
theorem mk_val (u : αˣ) (y h₁ h₂) : mk (u : α) y h₁ h₂ = u 
Arguments: {α : Type u} [Monoid α] (u : αˣ) (y : α) (h₁ : ↑u * y = 1) (h₂ : y * ↑u = 1)
Goal: { val := ↑u, inv := y, val_inv := h₁, inv_val := h₂ } = u
-- AddUnits.mk_val
@[to_additive (attr := simp)]
theorem mk_val (u : αˣ) (y h₁ h₂) : mk (u : α) y h₁ h₂ = u 
Arguments: {α : Type u} [AddMonoid α] (u : AddUnits α) (y : α) (h₁ : ↑u + y = 0) (h₂ : y + ↑u = 0)
Goal: { val := ↑u, neg := y, val_neg := h₁, neg_val := h₂ } = u
-- Units.val_inv_copy
@[to_additive (attr := simps) "Copy an `AddUnit`, adjusting definitional equalities."]
def copy (u : αˣ) (val : α) (hv : val = u) (inv : α) (hi : inv = ↑u⁻¹) : αˣ 
Arguments: {α : Type u} [Monoid α] (u : αˣ) (val : α) (hv : val = ↑u) (inv : α) (hi : inv = ↑u⁻¹)
Goal: ↑(u.copy val hv inv hi)⁻¹ = inv
-- Units.val_copy
@[to_additive (attr := simps) "Copy an `AddUnit`, adjusting definitional equalities."]
def copy (u : αˣ) (val : α) (hv : val = u) (inv : α) (hi : inv = ↑u⁻¹) : αˣ 
Arguments: {α : Type u} [Monoid α] (u : αˣ) (val : α) (hv : val = ↑u) (inv : α) (hi : inv = ↑u⁻¹)
Goal: ↑(u.copy val hv inv hi) = val
-- AddUnits.val_neg_copy
@[to_additive (attr := simps) "Copy an `AddUnit`, adjusting definitional equalities."]
def copy (u : αˣ) (val : α) (hv : val = u) (inv : α) (hi : inv = ↑u⁻¹) : αˣ 
Arguments: {α : Type u} [AddMonoid α] (u : AddUnits α) (val : α) (hv : val = ↑u) (inv : α) (hi : inv = ↑(-u))
Goal: ↑(-u.copy val hv inv hi) = inv
-- AddUnits.val_copy
@[to_additive (attr := simps) "Copy an `AddUnit`, adjusting definitional equalities."]
def copy (u : αˣ) (val : α) (hv : val = u) (inv : α) (hi : inv = ↑u⁻¹) : αˣ 
Arguments: {α : Type u} [AddMonoid α] (u : AddUnits α) (val : α) (hv : val = ↑u) (inv : α) (hi : inv = ↑(-u))
Goal: ↑(u.copy val hv inv hi) = val
-- AddUnits.copy_eq
@[to_additive]
theorem copy_eq (u : αˣ) (val hv inv hi) : u.copy val hv inv hi = u 
Arguments: {α : Type u} [AddMonoid α] (u : AddUnits α) (val : α) (hv : val = ↑u) (inv : α) (hi : inv = ↑(-u))
Goal: u.copy val hv inv hi = u
-- Units.copy_eq
@[to_additive]
theorem copy_eq (u : αˣ) (val hv inv hi) : u.copy val hv inv hi = u 
Arguments: {α : Type u} [Monoid α] (u : αˣ) (val : α) (hv : val = ↑u) (inv : α) (hi : inv = ↑u⁻¹)
Goal: u.copy val hv inv hi = u
-- Units.val_mul
@[to_additive (attr := simp, norm_cast)]
theorem val_mul : (↑(a * b) : α) = a * b 
Arguments: {α : Type u} [Monoid α] (a b : αˣ)
Goal: ↑(a * b) = ↑a * ↑b
-- AddUnits.val_add
@[to_additive (attr := simp, norm_cast)]
theorem val_mul : (↑(a * b) : α) = a * b 
Arguments: {α : Type u} [AddMonoid α] (a b : AddUnits α)
Goal: ↑(a + b) = ↑a + ↑b
-- AddUnits.val_zero
@[to_additive (attr := simp, norm_cast)]
theorem val_one : ((1 : αˣ) : α) = 1 
Arguments: {α : Type u} [AddMonoid α]
Goal: ↑0 = 0
-- Units.val_one
@[to_additive (attr := simp, norm_cast)]
theorem val_one : ((1 : αˣ) : α) = 1 
Arguments: {α : Type u} [Monoid α]
Goal: ↑1 = 1
-- AddUnits.val_eq_zero
@[to_additive (attr := simp, norm_cast)]
theorem val_eq_one {a : αˣ} : (a : α) = 1 ↔ a = 1 
Arguments: {α : Type u} [AddMonoid α] {a : AddUnits α}
Goal: ↑a = 0 ↔ a = 0
-- Units.val_eq_one
@[to_additive (attr := simp, norm_cast)]
theorem val_eq_one {a : αˣ} : (a : α) = 1 ↔ a = 1 
Arguments: {α : Type u} [Monoid α] {a : αˣ}
Goal: ↑a = 1 ↔ a = 1
-- AddUnits.neg_mk
@[to_additive (attr := simp)]
theorem inv_mk (x y : α) (h₁ h₂) : (mk x y h₁ h₂)⁻¹ = mk y x h₂ h₁ 
Arguments: {α : Type u} [AddMonoid α] (x y : α) (h₁ : x + y = 0) (h₂ : y + x = 0)
Goal: -{ val := x, neg := y, val_neg := h₁, neg_val := h₂ } = { val := y, neg := x, val_neg := h₂, neg_val := h₁ }
-- Units.inv_mk
@[to_additive (attr := simp)]
theorem inv_mk (x y : α) (h₁ h₂) : (mk x y h₁ h₂)⁻¹ = mk y x h₂ h₁ 
Arguments: {α : Type u} [Monoid α] (x y : α) (h₁ : x * y = 1) (h₂ : y * x = 1)
Goal: { val := x, inv := y, val_inv := h₁, inv_val := h₂ }⁻¹ = { val := y, inv := x, val_inv := h₂, inv_val := h₁ }
-- Units.inv_eq_val_inv
@[to_additive (attr := simp)]
theorem inv_eq_val_inv : a.inv = ((a⁻¹ : αˣ) : α) 
Arguments: {α : Type u} [Monoid α] (a : αˣ)
Goal: a.inv = ↑a⁻¹
-- AddUnits.neg_eq_val_neg
@[to_additive (attr := simp)]
theorem inv_eq_val_inv : a.inv = ((a⁻¹ : αˣ) : α) 
Arguments: {α : Type u} [AddMonoid α] (a : AddUnits α)
Goal: a.neg = ↑(-a)
-- Units.inv_mul
@[to_additive (attr := simp)]
theorem inv_mul : (↑a⁻¹ * a : α) = 1 
Arguments: {α : Type u} [Monoid α] (a : αˣ)
Goal: ↑a⁻¹ * ↑a = 1
-- AddUnits.neg_add
@[to_additive (attr := simp)]
theorem inv_mul : (↑a⁻¹ * a : α) = 1 
Arguments: {α : Type u} [AddMonoid α] (a : AddUnits α)
Goal: ↑(-a) + ↑a = 0
-- Units.mul_inv
@[to_additive (attr := simp)]
theorem mul_inv : (a * ↑a⁻¹ : α) = 1 
Arguments: {α : Type u} [Monoid α] (a : αˣ)
Goal: ↑a * ↑a⁻¹ = 1
-- AddUnits.add_neg
@[to_additive (attr := simp)]
theorem mul_inv : (a * ↑a⁻¹ : α) = 1 
Arguments: {α : Type u} [AddMonoid α] (a : AddUnits α)
Goal: ↑a + ↑(-a) = 0
-- Units.commute_coe_inv
@[to_additive] lemma commute_coe_inv : Commute (a : α) ↑a⁻¹ 
Arguments: {α : Type u} [Monoid α] (a : αˣ)
Goal: Commute ↑a ↑a⁻¹
-- AddUnits.addCommute_coe_neg
@[to_additive] lemma commute_coe_inv : Commute (a : α) ↑a⁻¹ 
Arguments: {α : Type u} [AddMonoid α] (a : AddUnits α)
Goal: AddCommute ↑a ↑(-a)
-- Units.commute_inv_coe
@[to_additive] lemma commute_inv_coe : Commute ↑a⁻¹ (a : α) 
Arguments: {α : Type u} [Monoid α] (a : αˣ)
Goal: Commute ↑a⁻¹ ↑a
-- AddUnits.addCommute_neg_coe
@[to_additive] lemma commute_inv_coe : Commute ↑a⁻¹ (a : α) 
Arguments: {α : Type u} [AddMonoid α] (a : AddUnits α)
Goal: AddCommute ↑(-a) ↑a
-- AddUnits.neg_add_of_eq
@[to_additive]
theorem inv_mul_of_eq {a : α} (h : ↑u = a) : ↑u⁻¹ * a = 1 
Arguments: {α : Type u} [AddMonoid α] {u : AddUnits α} {a : α} (h : ↑u = a)
Goal: ↑(-u) + a = 0
-- Units.inv_mul_of_eq
@[to_additive]
theorem inv_mul_of_eq {a : α} (h : ↑u = a) : ↑u⁻¹ * a = 1 
Arguments: {α : Type u} [Monoid α] {u : αˣ} {a : α} (h : ↑u = a)
Goal: ↑u⁻¹ * a = 1
-- Units.mul_inv_of_eq
@[to_additive]
theorem mul_inv_of_eq {a : α} (h : ↑u = a) : a * ↑u⁻¹ = 1 
Arguments: {α : Type u} [Monoid α] {u : αˣ} {a : α} (h : ↑u = a)
Goal: a * ↑u⁻¹ = 1
-- AddUnits.add_neg_of_eq
@[to_additive]
theorem mul_inv_of_eq {a : α} (h : ↑u = a) : a * ↑u⁻¹ = 1 
Arguments: {α : Type u} [AddMonoid α] {u : AddUnits α} {a : α} (h : ↑u = a)
Goal: a + ↑(-u) = 0
-- AddUnits.add_neg_cancel_left
@[to_additive (attr := simp)]
theorem mul_inv_cancel_left (a : αˣ) (b : α) : (a : α) * (↑a⁻¹ * b) = b 
Arguments: {α : Type u} [AddMonoid α] (a : AddUnits α) (b : α)
Goal: ↑a + (↑(-a) + b) = b
-- Units.mul_inv_cancel_left
@[to_additive (attr := simp)]
theorem mul_inv_cancel_left (a : αˣ) (b : α) : (a : α) * (↑a⁻¹ * b) = b 
Arguments: {α : Type u} [Monoid α] (a : αˣ) (b : α)
Goal: ↑a * (↑a⁻¹ * b) = b
-- AddUnits.neg_add_cancel_left
@[to_additive (attr := simp)]
theorem inv_mul_cancel_left (a : αˣ) (b : α) : (↑a⁻¹ : α) * (a * b) = b 
Arguments: {α : Type u} [AddMonoid α] (a : AddUnits α) (b : α)
Goal: ↑(-a) + (↑a + b) = b