ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Submonoid.closure_eq_image_prod
@[to_additive]
theorem closure_eq_image_prod (s : Set M) :
    (closure s : Set M) = List.prod '' { l : List M | ∀ x ∈ l, x ∈ s } 
Arguments: {M : Type u_1} [Monoid M] (s : Set M)
Goal: ↑(Submonoid.closure s) = List.prod '' {l | ∀ x ∈ l, x ∈ s}
-- AddSubmonoid.closure_eq_image_sum
@[to_additive]
theorem closure_eq_image_prod (s : Set M) :
    (closure s : Set M) = List.prod '' { l : List M | ∀ x ∈ l, x ∈ s } 
Arguments: {M : Type u_1} [AddMonoid M] (s : Set M)
Goal: ↑(AddSubmonoid.closure s) = List.sum '' {l | ∀ x ∈ l, x ∈ s}
-- AddSubmonoid.exists_list_of_mem_closure
@[to_additive]
theorem exists_list_of_mem_closure {s : Set M} {x : M} (hx : x ∈ closure s) :
    ∃ l : List M, (∀ y ∈ l, y ∈ s) ∧ l.prod = x 
Arguments: {M : Type u_1} [AddMonoid M] {s : Set M} {x : M} (hx : x ∈ AddSubmonoid.closure s)
Goal: ∃ l, (∀ y ∈ l, y ∈ s) ∧ l.sum = x
-- Submonoid.exists_list_of_mem_closure
@[to_additive]
theorem exists_list_of_mem_closure {s : Set M} {x : M} (hx : x ∈ closure s) :
    ∃ l : List M, (∀ y ∈ l, y ∈ s) ∧ l.prod = x 
Arguments: {M : Type u_1} [Monoid M] {s : Set M} {x : M} (hx : x ∈ Submonoid.closure s)
Goal: ∃ l, (∀ y ∈ l, y ∈ s) ∧ l.prod = x
-- Submonoid.exists_multiset_of_mem_closure
@[to_additive]
theorem exists_multiset_of_mem_closure {M : Type*} [CommMonoid M] {s : Set M} {x : M}
    (hx : x ∈ closure s) : ∃ l : Multiset M, (∀ y ∈ l, y ∈ s) ∧ l.prod = x 
Arguments: {M : Type u_4} [CommMonoid M] {s : Set M} {x : M} (hx : x ∈ Submonoid.closure s)
Goal: ∃ l, (∀ y ∈ l, y ∈ s) ∧ l.prod = x
-- AddSubmonoid.exists_multiset_of_mem_closure
@[to_additive]
theorem exists_multiset_of_mem_closure {M : Type*} [CommMonoid M] {s : Set M} {x : M}
    (hx : x ∈ closure s) : ∃ l : Multiset M, (∀ y ∈ l, y ∈ s) ∧ l.prod = x 
Arguments: {M : Type u_4} [AddCommMonoid M] {s : Set M} {x : M} (hx : x ∈ AddSubmonoid.closure s)
Goal: ∃ l, (∀ y ∈ l, y ∈ s) ∧ l.sum = x
-- AddSubmonoid.closure_induction_left
@[to_additive (attr := elab_as_elim)]
theorem closure_induction_left {s : Set M} {p : (m : M) → m ∈ closure s → Prop}
    (one : p 1 (one_mem _))
    (mul_left : ∀ x (hx : x ∈ s), ∀ (y) hy, p y hy → p (x * y) (mul_mem (subset_closure hx) hy))
    {x : M} (h : x ∈ closure s) :
    p x h 
Arguments: {M : Type u_1} [AddMonoid M] {s : Set M} {p : (m : M) → m ∈ AddSubmonoid.closure s → Prop} (one : p 0 ⋯) (mul_left : ∀ (x : M) (hx : x ∈ s) (y : M) (hy : y ∈ AddSubmonoid.closure s), p y hy → p (x + y) ⋯) {x : M} (h : x ∈ AddSubmonoid.closure s)
Goal: p x h
-- Submonoid.closure_induction_left
@[to_additive (attr := elab_as_elim)]
theorem closure_induction_left {s : Set M} {p : (m : M) → m ∈ closure s → Prop}
    (one : p 1 (one_mem _))
    (mul_left : ∀ x (hx : x ∈ s), ∀ (y) hy, p y hy → p (x * y) (mul_mem (subset_closure hx) hy))
    {x : M} (h : x ∈ closure s) :
    p x h 
Arguments: {M : Type u_1} [Monoid M] {s : Set M} {p : (m : M) → m ∈ Submonoid.closure s → Prop} (one : p 1 ⋯) (mul_left : ∀ (x : M) (hx : x ∈ s) (y : M) (hy : y ∈ Submonoid.closure s), p y hy → p (x * y) ⋯) {x : M} (h : x ∈ Submonoid.closure s)
Goal: p x h
-- Submonoid.induction_of_closure_eq_top_left
@[to_additive (attr := elab_as_elim)]
theorem induction_of_closure_eq_top_left {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
    (one : p 1) (mul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x 
Arguments: {M : Type u_1} [Monoid M] {s : Set M} {p : M → Prop} (hs : Submonoid.closure s = ⊤) (x : M) (one : p 1) (mul : ∀ x ∈ s, ∀ (y : M), p y → p (x * y))
Goal: p x
-- AddSubmonoid.induction_of_closure_eq_top_left
@[to_additive (attr := elab_as_elim)]
theorem induction_of_closure_eq_top_left {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
    (one : p 1) (mul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x 
Arguments: {M : Type u_1} [AddMonoid M] {s : Set M} {p : M → Prop} (hs : AddSubmonoid.closure s = ⊤) (x : M) (one : p 0) (mul : ∀ x ∈ s, ∀ (y : M), p y → p (x + y))
Goal: p x
-- AddSubmonoid.closure_induction_right
@[to_additive (attr := elab_as_elim)]
theorem closure_induction_right {s : Set M} {p : (m : M) → m ∈ closure s → Prop}
    (one : p 1 (one_mem _))
    (mul_right : ∀ x hx, ∀ (y) (hy : y ∈ s), p x hx → p (x * y) (mul_mem hx (subset_closure hy)))
    {x : M} (h : x ∈ closure s) : p x h 
Arguments: {M : Type u_1} [AddMonoid M] {s : Set M} {p : (m : M) → m ∈ AddSubmonoid.closure s → Prop} (one : p 0 ⋯) (mul_right : ∀ (x : M) (hx : x ∈ AddSubmonoid.closure s) (y : M) (hy : y ∈ s), p x hx → p (x + y) ⋯) {x : M} (h : x ∈ AddSubmonoid.closure s)
Goal: p x h
-- Submonoid.closure_induction_right
@[to_additive (attr := elab_as_elim)]
theorem closure_induction_right {s : Set M} {p : (m : M) → m ∈ closure s → Prop}
    (one : p 1 (one_mem _))
    (mul_right : ∀ x hx, ∀ (y) (hy : y ∈ s), p x hx → p (x * y) (mul_mem hx (subset_closure hy)))
    {x : M} (h : x ∈ closure s) : p x h 
Arguments: {M : Type u_1} [Monoid M] {s : Set M} {p : (m : M) → m ∈ Submonoid.closure s → Prop} (one : p 1 ⋯) (mul_right : ∀ (x : M) (hx : x ∈ Submonoid.closure s) (y : M) (hy : y ∈ s), p x hx → p (x * y) ⋯) {x : M} (h : x ∈ Submonoid.closure s)
Goal: p x h
-- Submonoid.induction_of_closure_eq_top_right
@[to_additive (attr := elab_as_elim)]
theorem induction_of_closure_eq_top_right {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
    (H1 : p 1) (Hmul : ∀ (x), ∀ y ∈ s, p x → p (x * y)) : p x 
Arguments: {M : Type u_1} [Monoid M] {s : Set M} {p : M → Prop} (hs : Submonoid.closure s = ⊤) (x : M) (H1 : p 1) (Hmul : ∀ (x y : M), y ∈ s → p x → p (x * y))
Goal: p x
-- AddSubmonoid.induction_of_closure_eq_top_right
@[to_additive (attr := elab_as_elim)]
theorem induction_of_closure_eq_top_right {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
    (H1 : p 1) (Hmul : ∀ (x), ∀ y ∈ s, p x → p (x * y)) : p x 
Arguments: {M : Type u_1} [AddMonoid M] {s : Set M} {p : M → Prop} (hs : AddSubmonoid.closure s = ⊤) (x : M) (H1 : p 0) (Hmul : ∀ (x y : M), y ∈ s → p x → p (x + y))
Goal: p x
-- Submonoid.mem_powers
theorem mem_powers (n : M) : n ∈ powers n 
Arguments: {M : Type u_1} [Monoid M] (n : M)
Goal: n ∈ Submonoid.powers n
-- Submonoid.coe_powers
theorem coe_powers (x : M) : ↑(powers x) = Set.range fun n : ℕ => x ^ n 
Arguments: {M : Type u_1} [Monoid M] (x : M)
Goal: ↑(Submonoid.powers x) = Set.range fun n => x ^ n
-- Submonoid.mem_powers_iff
theorem mem_powers_iff (x z : M) : x ∈ powers z ↔ ∃ n : ℕ, z ^ n = x 
Arguments: {M : Type u_1} [Monoid M] (x z : M)
Goal: x ∈ Submonoid.powers z ↔ ∃ n, z ^ n = x
-- Submonoid.powers_eq_closure
theorem powers_eq_closure (n : M) : powers n = closure {n} 
Arguments: {M : Type u_1} [Monoid M] (n : M)
Goal: Submonoid.powers n = Submonoid.closure {n}
-- Submonoid.powers_le
lemma powers_le {n : M} {P : Submonoid M} : powers n ≤ P ↔ n ∈ P 
Arguments: {M : Type u_1} [Monoid M] {n : M} {P : Submonoid M}
Goal: Submonoid.powers n ≤ P ↔ n ∈ P
-- Submonoid.powers_one
lemma powers_one : powers (1 : M) = ⊥ 
Arguments: {M : Type u_1} [Monoid M]
Goal: Submonoid.powers 1 = ⊥
-- Submonoid.pow_coe
@[simps!]
def pow (n : M) (m : ℕ) : powers n 
Arguments: {M : Type u_1} [Monoid M] (n : M) (m : ℕ)
Goal: ↑(Submonoid.pow n m) = n ^ m
-- Submonoid.pow_apply
theorem pow_apply (n : M) (m : ℕ) : Submonoid.pow n m = ⟨n ^ m, m, rfl⟩ 
Arguments: {M : Type u_1} [Monoid M] (n : M) (m : ℕ)
Goal: Submonoid.pow n m = ⟨n ^ m, ⋯⟩
-- Submonoid.pow_log_eq_self
@[simp]
theorem pow_log_eq_self [DecidableEq M] {n : M} (p : powers n) : pow n (log p) = p 
Arguments: {M : Type u_1} [Monoid M] [DecidableEq M] {n : M} (p : ↥(Submonoid.powers n))
Goal: Submonoid.pow n (Submonoid.log p) = p
-- Submonoid.pow_right_injective_iff_pow_injective
theorem pow_right_injective_iff_pow_injective {n : M} :
    (Function.Injective fun m : ℕ => n ^ m) ↔ Function.Injective (pow n) 
Arguments: {M : Type u_1} [Monoid M] {n : M}
Goal: (Function.Injective fun m => n ^ m) ↔ Function.Injective (Submonoid.pow n)
-- Submonoid.log_pow_eq_self
@[simp]
theorem log_pow_eq_self [DecidableEq M] {n : M} (h : Function.Injective fun m : ℕ => n ^ m)
    (m : ℕ) : log (pow n m) = m 
Arguments: {M : Type u_1} [Monoid M] [DecidableEq M] {n : M} (h : Function.Injective fun m => n ^ m) (m : ℕ)
Goal: Submonoid.log (Submonoid.pow n m) = m
-- Submonoid.powLogEquiv_apply
@[simps]
def powLogEquiv [DecidableEq M] {n : M} (h : Function.Injective fun m : ℕ => n ^ m) :
    Multiplicative ℕ ≃* powers n 
Arguments: {M : Type u_1} [Monoid M] [DecidableEq M] {n : M} (h : Function.Injective fun m => n ^ m) (m : Multiplicative ℕ)
Goal: (Submonoid.powLogEquiv h) m = Submonoid.pow n (Multiplicative.toAdd m)
-- Submonoid.powLogEquiv_symm_apply
@[simps]
def powLogEquiv [DecidableEq M] {n : M} (h : Function.Injective fun m : ℕ => n ^ m) :
    Multiplicative ℕ ≃* powers n 
Arguments: {M : Type u_1} [Monoid M] [DecidableEq M] {n : M} (h : Function.Injective fun m => n ^ m) (m : ↥(Submonoid.powers n))
Goal: (Submonoid.powLogEquiv h).symm m = Multiplicative.ofAdd (Submonoid.log m)
-- Submonoid.log_mul
theorem log_mul [DecidableEq M] {n : M} (h : Function.Injective fun m : ℕ => n ^ m)
    (x y : powers (n : M)) : log (x * y) = log x + log y 
Arguments: {M : Type u_1} [Monoid M] [DecidableEq M] {n : M} (h : Function.Injective fun m => n ^ m) (x y : ↥(Submonoid.powers n))
Goal: Submonoid.log (x * y) = Submonoid.log x + Submonoid.log y
-- Submonoid.log_pow_int_eq_self
theorem log_pow_int_eq_self {x : ℤ} (h : 1 < x.natAbs) (m : ℕ) : log (pow x m) = m 
Arguments: {x : ℤ} (h : 1 < x.natAbs) (m : ℕ)
Goal: Submonoid.log (Submonoid.pow x m) = m
-- Submonoid.map_powers
@[simp]
theorem map_powers {N : Type*} {F : Type*} [Monoid N] [FunLike F M N] [MonoidHomClass F M N]
    (f : F) (m : M) :
    (powers m).map f = powers (f m) 
Arguments: {M : Type u_1} [Monoid M] {N : Type u_4} {F : Type u_5} [Monoid N] [FunLike F M N] [MonoidHomClass F M N] (f : F) (m : M)
Goal: Submonoid.map f (Submonoid.powers m) = Submonoid.powers (f m)
-- IsScalarTower.of_mclosure_eq_top
@[to_additive]
theorem IsScalarTower.of_mclosure_eq_top {N α} [Monoid M] [MulAction M N] [SMul N α] [MulAction M α]
    {s : Set M} (htop : Submonoid.closure s = ⊤)
    (hs : ∀ x ∈ s, ∀ (y : N) (z : α), (x • y) • z = x • y • z) : IsScalarTower M N α 
Arguments: {M : Type u_1} {N : Type u_4} {α : Type u_5} [Monoid M] [MulAction M N] [SMul N α] [MulAction M α] {s : Set M} (htop : Submonoid.closure s = ⊤) (hs : ∀ x ∈ s, ∀ (y : N) (z : α), (x • y) • z = x • y • z)
Goal: IsScalarTower M N α
-- VAddAssocClass.of_mclosure_eq_top
@[to_additive]
theorem IsScalarTower.of_mclosure_eq_top {N α} [Monoid M] [MulAction M N] [SMul N α] [MulAction M α]
    {s : Set M} (htop : Submonoid.closure s = ⊤)
    (hs : ∀ x ∈ s, ∀ (y : N) (z : α), (x • y) • z = x • y • z) : IsScalarTower M N α 
Arguments: {M : Type u_1} {N : Type u_4} {α : Type u_5} [AddMonoid M] [AddAction M N] [VAdd N α] [AddAction M α] {s : Set M} (htop : AddSubmonoid.closure s = ⊤) (hs : ∀ x ∈ s, ∀ (y : N) (z : α), x +ᵥ y +ᵥ z = x +ᵥ (y +ᵥ z))
Goal: VAddAssocClass M N α
-- VAddCommClass.of_mclosure_eq_top
@[to_additive]
theorem SMulCommClass.of_mclosure_eq_top {N α} [Monoid M] [SMul N α] [MulAction M α] {s : Set M}
    (htop : Submonoid.closure s = ⊤) (hs : ∀ x ∈ s, ∀ (y : N) (z : α), x • y • z = y • x • z) :
    SMulCommClass M N α 
Arguments: {M : Type u_1} {N : Type u_4} {α : Type u_5} [AddMonoid M] [VAdd N α] [AddAction M α] {s : Set M} (htop : AddSubmonoid.closure s = ⊤) (hs : ∀ x ∈ s, ∀ (y : N) (z : α), x +ᵥ (y +ᵥ z) = y +ᵥ (x +ᵥ z))
Goal: VAddCommClass M N α
-- SMulCommClass.of_mclosure_eq_top
@[to_additive]
theorem SMulCommClass.of_mclosure_eq_top {N α} [Monoid M] [SMul N α] [MulAction M α] {s : Set M}
    (htop : Submonoid.closure s = ⊤) (hs : ∀ x ∈ s, ∀ (y : N) (z : α), x • y • z = y • x • z) :
    SMulCommClass M N α 
Arguments: {M : Type u_1} {N : Type u_4} {α : Type u_5} [Monoid M] [SMul N α] [MulAction M α] {s : Set M} (htop : Submonoid.closure s = ⊤) (hs : ∀ x ∈ s, ∀ (y : N) (z : α), x • y • z = y • x • z)
Goal: SMulCommClass M N α
-- Submonoid.sup_eq_range
@[to_additive]
theorem sup_eq_range (s t : Submonoid N) : s ⊔ t = mrange (s.subtype.coprod t.subtype) 
Arguments: {N : Type u_4} [CommMonoid N] (s t : Submonoid N)
Goal: s ⊔ t = MonoidHom.mrange (s.subtype.coprod t.subtype)
-- AddSubmonoid.sup_eq_range
@[to_additive]
theorem sup_eq_range (s t : Submonoid N) : s ⊔ t = mrange (s.subtype.coprod t.subtype) 
Arguments: {N : Type u_4} [AddCommMonoid N] (s t : AddSubmonoid N)
Goal: s ⊔ t = AddMonoidHom.mrange (s.subtype.coprod t.subtype)
-- Submonoid.mem_sup
@[to_additive]
theorem mem_sup {s t : Submonoid N} {x : N} : x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x 
Arguments: {N : Type u_4} [CommMonoid N] {s t : Submonoid N} {x : N}
Goal: x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x
-- AddSubmonoid.mem_sup
@[to_additive]
theorem mem_sup {s t : Submonoid N} {x : N} : x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x 
Arguments: {N : Type u_4} [AddCommMonoid N] {s t : AddSubmonoid N} {x : N}
Goal: x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y + z = x
-- AddSubmonoid.closure_singleton_eq
theorem closure_singleton_eq (x : A) :
    closure ({x} : Set A) = AddMonoidHom.mrange (multiplesHom A x) 
Arguments: {A : Type u_2} [AddMonoid A] (x : A)
Goal: AddSubmonoid.closure {x} = AddMonoidHom.mrange ((multiplesHom A) x)
-- AddSubmonoid.mem_closure_singleton
theorem mem_closure_singleton {x y : A} : y ∈ closure ({x} : Set A) ↔ ∃ n : ℕ, n • x = y 
Arguments: {A : Type u_2} [AddMonoid A] {x y : A}
Goal: y ∈ AddSubmonoid.closure {x} ↔ ∃ n, n • x = y
-- AddSubmonoid.closure_singleton_zero
theorem closure_singleton_zero : closure ({0} : Set A) = ⊥ 
Arguments: {A : Type u_2} [AddMonoid A]
Goal: AddSubmonoid.closure {0} = ⊥
-- MulMemClass.mul_right_mem_add_closure
theorem mul_right_mem_add_closure (ha : a ∈ AddSubmonoid.closure (S : Set R)) (hb : b ∈ S) :
    a * b ∈ AddSubmonoid.closure (S : Set R) 
Arguments: {M : Type u_1} {R : Type u_4} [NonUnitalNonAssocSemiring R] [SetLike M R] [MulMemClass M R] {S : M} {a b : R} (ha : a ∈ AddSubmonoid.closure ↑S) (hb : b ∈ S)
Goal: a * b ∈ AddSubmonoid.closure ↑S
-- MulMemClass.mul_mem_add_closure
theorem mul_mem_add_closure (ha : a ∈ AddSubmonoid.closure (S : Set R))
    (hb : b ∈ AddSubmonoid.closure (S : Set R)) : a * b ∈ AddSubmonoid.closure (S : Set R) 
Arguments: {M : Type u_1} {R : Type u_4} [NonUnitalNonAssocSemiring R] [SetLike M R] [MulMemClass M R] {S : M} {a b : R} (ha : a ∈ AddSubmonoid.closure ↑S) (hb : b ∈ AddSubmonoid.closure ↑S)
Goal: a * b ∈ AddSubmonoid.closure ↑S
-- MulMemClass.mul_left_mem_add_closure
theorem mul_left_mem_add_closure (ha : a ∈ S) (hb : b ∈ AddSubmonoid.closure (S : Set R)) :
    a * b ∈ AddSubmonoid.closure (S : Set R) 
Arguments: {M : Type u_1} {R : Type u_4} [NonUnitalNonAssocSemiring R] [SetLike M R] [MulMemClass M R] {S : M} {a b : R} (ha : a ∈ S) (hb : b ∈ AddSubmonoid.closure ↑S)
Goal: a * b ∈ AddSubmonoid.closure ↑S
-- Submonoid.mem_closure_pair
@[to_additive
      "An element is in the closure of a two-element set if it is a linear combination of
      those two elements."]
theorem mem_closure_pair {A : Type*} [CommMonoid A] (a b c : A) :
    c ∈ Submonoid.closure ({a, b} : Set A) ↔ ∃ m n : ℕ, a ^ m * b ^ n = c 
Arguments: {A : Type u_4} [CommMonoid A] (a b c : A)
Goal: c ∈ Submonoid.closure {a, b} ↔ ∃ m n, a ^ m * b ^ n = c
-- AddSubmonoid.mem_closure_pair
@[to_additive
      "An element is in the closure of a two-element set if it is a linear combination of
      those two elements."]
theorem mem_closure_pair {A : Type*} [CommMonoid A] (a b c : A) :
    c ∈ Submonoid.closure ({a, b} : Set A) ↔ ∃ m n : ℕ, a ^ m * b ^ n = c 
Arguments: {A : Type u_4} [AddCommMonoid A] (a b c : A)
Goal: c ∈ AddSubmonoid.closure {a, b} ↔ ∃ m n, m • a + n • b = c
-- ofMul_image_powers_eq_multiples_ofMul
theorem ofMul_image_powers_eq_multiples_ofMul [Monoid M] {x : M} :
    Additive.ofMul '' (Submonoid.powers x : Set M) = AddSubmonoid.multiples (Additive.ofMul x) 
Arguments: {M : Type u_1} [Monoid M] {x : M}
Goal: ⇑Additive.ofMul '' ↑(Submonoid.powers x) = ↑(AddSubmonoid.multiples (Additive.ofMul x))
-- ofAdd_image_multiples_eq_powers_ofAdd
theorem ofAdd_image_multiples_eq_powers_ofAdd [AddMonoid A] {x : A} :
    Multiplicative.ofAdd '' (AddSubmonoid.multiples x : Set A) =
      Submonoid.powers (Multiplicative.ofAdd x) 
Arguments: {A : Type u_2} [AddMonoid A] {x : A}
Goal: ⇑Multiplicative.ofAdd '' ↑(AddSubmonoid.multiples x) = ↑(Submonoid.powers (Multiplicative.ofAdd x))
-- PNatPowAssoc.ppow_one
class PNatPowAssoc (M : Type*) [Mul M] [Pow M ℕ+] : Prop where
    protected ppow_add : ∀ (k n : ℕ+) (x : M), x ^ (k + n) = x ^ k * x ^ n
    protected ppow_one : ∀ (x : M), x ^ (1 : ℕ+) = x
Arguments: {M : Type u_2} [Mul M] [Pow M ℕ+] [self : PNatPowAssoc M] (x : M)
Goal: x ^ 1 = x
-- PNatPowAssoc.ppow_add
class PNatPowAssoc (M : Type*) [Mul M] [Pow M ℕ+] : Prop where
    protected ppow_add : ∀ (k n : ℕ+) (x : M), x ^ (k + n) = x ^ k * x ^ n
    protected ppow_one : ∀ (x : M), x ^ (1 : ℕ+) = x
Arguments: {M : Type u_2} [Mul M] [Pow M ℕ+] [self : PNatPowAssoc M] (k n : ℕ+) (x : M)
Goal: x ^ (k + n) = x ^ k * x ^ n
-- ppow_add
theorem ppow_add (k n : ℕ+) (x : M) : x ^ (k + n) = x ^ k * x ^ n 
Arguments: {M : Type u_1} [Mul M] [Pow M ℕ+] [PNatPowAssoc M] (k n : ℕ+) (x : M)
Goal: x ^ (k + n) = x ^ k * x ^ n
-- ppow_one
@[simp]
theorem ppow_one (x : M) : x ^ (1 : ℕ+) = x 
Arguments: {M : Type u_1} [Mul M] [Pow M ℕ+] [PNatPowAssoc M] (x : M)
Goal: x ^ 1 = x
-- ppow_mul_assoc
theorem ppow_mul_assoc (k m n : ℕ+) (x : M) :
    (x ^ k * x ^ m) * x ^ n = x ^ k * (x ^ m * x ^ n) 
Arguments: {M : Type u_1} [Mul M] [Pow M ℕ+] [PNatPowAssoc M] (k m n : ℕ+) (x : M)
Goal: x ^ k * x ^ m * x ^ n = x ^ k * (x ^ m * x ^ n)
-- ppow_mul_comm
theorem ppow_mul_comm (m n : ℕ+) (x : M) :
    x ^ m * x ^ n = x ^ n * x ^ m 
Arguments: {M : Type u_1} [Mul M] [Pow M ℕ+] [PNatPowAssoc M] (m n : ℕ+) (x : M)
Goal: x ^ m * x ^ n = x ^ n * x ^ m
-- ppow_mul
theorem ppow_mul (x : M) (m n : ℕ+) : x ^ (m * n) = (x ^ m) ^ n 
Arguments: {M : Type u_1} [Mul M] [Pow M ℕ+] [PNatPowAssoc M] (x : M) (m n : ℕ+)
Goal: x ^ (m * n) = (x ^ m) ^ n
-- ppow_mul'
theorem ppow_mul' (x : M) (m n : ℕ+) : x ^ (m * n) = (x ^ n) ^ m 
Arguments: {M : Type u_1} [Mul M] [Pow M ℕ+] [PNatPowAssoc M] (x : M) (m n : ℕ+)
Goal: x ^ (m * n) = (x ^ n) ^ m
-- ppow_eq_pow
theorem ppow_eq_pow [Monoid M] [Pow M ℕ+] [PNatPowAssoc M] (x : M) (n : ℕ+) :
    x ^ n = x ^ (n : ℕ) 
Arguments: {M : Type u_1} [Monoid M] [Pow M ℕ+] [PNatPowAssoc M] (x : M) (n : ℕ+)
Goal: x ^ n = x ^ ↑n
-- AddEquiv.toMultiplicative_apply_symm_apply
@[simps]
def AddEquiv.toMultiplicative [AddZeroClass G] [AddZeroClass H] :
    G ≃+ H ≃ (Multiplicative G ≃* Multiplicative H) 
Arguments: {G : Type u_1} {H : Type u_2} [AddZeroClass G] [AddZeroClass H] (f : G ≃+ H) (a : Multiplicative H)
Goal: (AddEquiv.toMultiplicative f).symm a = (AddMonoidHom.toMultiplicative f.symm.toAddMonoidHom) a
-- AddEquiv.toMultiplicative_symm_apply_symm_apply
@[simps]
def AddEquiv.toMultiplicative [AddZeroClass G] [AddZeroClass H] :
    G ≃+ H ≃ (Multiplicative G ≃* Multiplicative H) 
Arguments: {G : Type u_1} {H : Type u_2} [AddZeroClass G] [AddZeroClass H] (f : Multiplicative G ≃* Multiplicative H) (a : H)
Goal: (AddEquiv.toMultiplicative.symm f).symm a = (AddMonoidHom.toMultiplicative.symm f.symm.toMonoidHom) a
-- AddEquiv.toMultiplicative_symm_apply_apply
@[simps]
def AddEquiv.toMultiplicative [AddZeroClass G] [AddZeroClass H] :
    G ≃+ H ≃ (Multiplicative G ≃* Multiplicative H) 
Arguments: {G : Type u_1} {H : Type u_2} [AddZeroClass G] [AddZeroClass H] (f : Multiplicative G ≃* Multiplicative H) (a : G)
Goal: (AddEquiv.toMultiplicative.symm f) a = (AddMonoidHom.toMultiplicative.symm f.toMonoidHom) a
-- AddEquiv.toMultiplicative_apply_apply
@[simps]
def AddEquiv.toMultiplicative [AddZeroClass G] [AddZeroClass H] :
    G ≃+ H ≃ (Multiplicative G ≃* Multiplicative H) 
Arguments: {G : Type u_1} {H : Type u_2} [AddZeroClass G] [AddZeroClass H] (f : G ≃+ H) (a : Multiplicative G)
Goal: (AddEquiv.toMultiplicative f) a = (AddMonoidHom.toMultiplicative f.toAddMonoidHom) a
-- MulEquiv.toAdditive_symm_apply_apply
@[simps]
def MulEquiv.toAdditive [MulOneClass G] [MulOneClass H] :
    G ≃* H ≃ (Additive G ≃+ Additive H) 
Arguments: {G : Type u_1} {H : Type u_2} [MulOneClass G] [MulOneClass H] (f : Additive G ≃+ Additive H) (a : G)
Goal: (MulEquiv.toAdditive.symm f) a = (MonoidHom.toAdditive.symm f.toAddMonoidHom) a
-- MulEquiv.toAdditive_apply_apply
@[simps]
def MulEquiv.toAdditive [MulOneClass G] [MulOneClass H] :
    G ≃* H ≃ (Additive G ≃+ Additive H) 
Arguments: {G : Type u_1} {H : Type u_2} [MulOneClass G] [MulOneClass H] (f : G ≃* H) (a : Additive G)
Goal: (MulEquiv.toAdditive f) a = (MonoidHom.toAdditive f.toMonoidHom) a
-- MulEquiv.toAdditive_apply_symm_apply
@[simps]
def MulEquiv.toAdditive [MulOneClass G] [MulOneClass H] :
    G ≃* H ≃ (Additive G ≃+ Additive H) 
Arguments: {G : Type u_1} {H : Type u_2} [MulOneClass G] [MulOneClass H] (f : G ≃* H) (a : Additive H)
Goal: (MulEquiv.toAdditive f).symm a = (MonoidHom.toAdditive f.symm.toMonoidHom) a
-- MulEquiv.toAdditive_symm_apply_symm_apply
@[simps]
def MulEquiv.toAdditive [MulOneClass G] [MulOneClass H] :
    G ≃* H ≃ (Additive G ≃+ Additive H) 
Arguments: {G : Type u_1} {H : Type u_2} [MulOneClass G] [MulOneClass H] (f : Additive G ≃+ Additive H) (a : H)
Goal: (MulEquiv.toAdditive.symm f).symm a = (MonoidHom.toAdditive.symm f.symm.toAddMonoidHom) a
-- AddEquiv.toMultiplicative'_apply_apply
@[simps]
def AddEquiv.toMultiplicative' [MulOneClass G] [AddZeroClass H] :
    Additive G ≃+ H ≃ (G ≃* Multiplicative H) 
Arguments: {G : Type u_1} {H : Type u_2} [MulOneClass G] [AddZeroClass H] (f : Additive G ≃+ H) (a : G)
Goal: (AddEquiv.toMultiplicative' f) a = (AddMonoidHom.toMultiplicative' f.toAddMonoidHom) a
-- AddEquiv.toMultiplicative'_symm_apply_apply
@[simps]
def AddEquiv.toMultiplicative' [MulOneClass G] [AddZeroClass H] :
    Additive G ≃+ H ≃ (G ≃* Multiplicative H) 
Arguments: {G : Type u_1} {H : Type u_2} [MulOneClass G] [AddZeroClass H] (f : G ≃* Multiplicative H) (a : Additive G)
Goal: (AddEquiv.toMultiplicative'.symm f) a = (AddMonoidHom.toMultiplicative'.symm f.toMonoidHom) a
-- AddEquiv.toMultiplicative'_apply_symm_apply
@[simps]
def AddEquiv.toMultiplicative' [MulOneClass G] [AddZeroClass H] :
    Additive G ≃+ H ≃ (G ≃* Multiplicative H) 
Arguments: {G : Type u_1} {H : Type u_2} [MulOneClass G] [AddZeroClass H] (f : Additive G ≃+ H) (a : Multiplicative H)
Goal: (AddEquiv.toMultiplicative' f).symm a = (AddMonoidHom.toMultiplicative'' f.symm.toAddMonoidHom) a
-- AddEquiv.toMultiplicative'_symm_apply_symm_apply
@[simps]
def AddEquiv.toMultiplicative' [MulOneClass G] [AddZeroClass H] :
    Additive G ≃+ H ≃ (G ≃* Multiplicative H) 
Arguments: {G : Type u_1} {H : Type u_2} [MulOneClass G] [AddZeroClass H] (f : G ≃* Multiplicative H) (a : H)
Goal: (AddEquiv.toMultiplicative'.symm f).symm a = (AddMonoidHom.toMultiplicative''.symm f.symm.toMonoidHom) a
-- AddEquiv.toMultiplicative''_apply_apply
@[simps]
def AddEquiv.toMultiplicative'' [AddZeroClass G] [MulOneClass H] :
    G ≃+ Additive H ≃ (Multiplicative G ≃* H) 
Arguments: {G : Type u_1} {H : Type u_2} [AddZeroClass G] [MulOneClass H] (f : G ≃+ Additive H) (a : Multiplicative G)
Goal: (AddEquiv.toMultiplicative'' f) a = (AddMonoidHom.toMultiplicative'' f.toAddMonoidHom) a
-- AddEquiv.toMultiplicative''_apply_symm_apply
@[simps]
def AddEquiv.toMultiplicative'' [AddZeroClass G] [MulOneClass H] :
    G ≃+ Additive H ≃ (Multiplicative G ≃* H) 
Arguments: {G : Type u_1} {H : Type u_2} [AddZeroClass G] [MulOneClass H] (f : G ≃+ Additive H) (a : H)
Goal: (AddEquiv.toMultiplicative'' f).symm a = (AddMonoidHom.toMultiplicative' f.symm.toAddMonoidHom) a
-- AddEquiv.toMultiplicative''_symm_apply_symm_apply
@[simps]
def AddEquiv.toMultiplicative'' [AddZeroClass G] [MulOneClass H] :
    G ≃+ Additive H ≃ (Multiplicative G ≃* H) 
Arguments: {G : Type u_1} {H : Type u_2} [AddZeroClass G] [MulOneClass H] (f : Multiplicative G ≃* H) (a : Additive H)
Goal: (AddEquiv.toMultiplicative''.symm f).symm a = (AddMonoidHom.toMultiplicative'.symm f.symm.toMonoidHom) a
-- AddEquiv.toMultiplicative''_symm_apply_apply
@[simps]
def AddEquiv.toMultiplicative'' [AddZeroClass G] [MulOneClass H] :
    G ≃+ Additive H ≃ (Multiplicative G ≃* H) 
Arguments: {G : Type u_1} {H : Type u_2} [AddZeroClass G] [MulOneClass H] (f : Multiplicative G ≃* H) (a : G)
Goal: (AddEquiv.toMultiplicative''.symm f) a = (AddMonoidHom.toMultiplicative''.symm f.toMonoidHom) a