ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CoxeterSystem.getD_rightInvSeq_mul_self
theorem getD_rightInvSeq_mul_self (ω : List B) (j : ℕ) :
    ((ris ω).getD j 1) * ((ris ω).getD j 1) = 1 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B) (j : ℕ)
Goal: (cs.rightInvSeq ω).getD j 1 * (cs.rightInvSeq ω).getD j 1 = 1
-- CoxeterSystem.getD_leftInvSeq_mul_self
theorem getD_leftInvSeq_mul_self (ω : List B) (j : ℕ) :
    ((lis ω).getD j 1) * ((lis ω).getD j 1) = 1 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B) (j : ℕ)
Goal: (cs.leftInvSeq ω).getD j 1 * (cs.leftInvSeq ω).getD j 1 = 1
-- CoxeterSystem.rightInvSeq_drop
theorem rightInvSeq_drop (ω : List B) (j : ℕ) :
    ris (ω.drop j) = (ris ω).drop j 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B) (j : ℕ)
Goal: cs.rightInvSeq (List.drop j ω) = List.drop j (cs.rightInvSeq ω)
-- CoxeterSystem.leftInvSeq_take
theorem leftInvSeq_take (ω : List B) (j : ℕ) :
    lis (ω.take j) = (lis ω).take j 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B) (j : ℕ)
Goal: cs.leftInvSeq (List.take j ω) = List.take j (cs.leftInvSeq ω)
-- CoxeterSystem.isReflection_of_mem_rightInvSeq
theorem isReflection_of_mem_rightInvSeq (ω : List B) {t : W} (ht : t ∈ ris ω) :
    cs.IsReflection t 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B) {t : W} (ht : t ∈ cs.rightInvSeq ω)
Goal: cs.IsReflection t
-- CoxeterSystem.isReflection_of_mem_leftInvSeq
theorem isReflection_of_mem_leftInvSeq (ω : List B) {t : W} (ht : t ∈ lis ω) :
    cs.IsReflection t 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B) {t : W} (ht : t ∈ cs.leftInvSeq ω)
Goal: cs.IsReflection t
-- CoxeterSystem.wordProd_mul_getD_rightInvSeq
theorem wordProd_mul_getD_rightInvSeq (ω : List B) (j : ℕ) :
    π ω * ((ris ω).getD j 1) = π (ω.eraseIdx j) 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B) (j : ℕ)
Goal: cs.wordProd ω * (cs.rightInvSeq ω).getD j 1 = cs.wordProd (ω.eraseIdx j)
-- CoxeterSystem.getD_leftInvSeq_mul_wordProd
theorem getD_leftInvSeq_mul_wordProd (ω : List B) (j : ℕ) :
    ((lis ω).getD j 1) * π ω = π (ω.eraseIdx j) 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B) (j : ℕ)
Goal: (cs.leftInvSeq ω).getD j 1 * cs.wordProd ω = cs.wordProd (ω.eraseIdx j)
-- CoxeterSystem.isRightInversion_of_mem_rightInvSeq
theorem isRightInversion_of_mem_rightInvSeq {ω : List B} (hω : cs.IsReduced ω) {t : W}
    (ht : t ∈ ris ω) : cs.IsRightInversion (π ω) t 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {ω : List B} (hω : cs.IsReduced ω) {t : W} (ht : t ∈ cs.rightInvSeq ω)
Goal: cs.IsRightInversion (cs.wordProd ω) t
-- CoxeterSystem.isLeftInversion_of_mem_leftInvSeq
theorem isLeftInversion_of_mem_leftInvSeq {ω : List B} (hω : cs.IsReduced ω) {t : W}
    (ht : t ∈ lis ω) : cs.IsLeftInversion (π ω) t 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {ω : List B} (hω : cs.IsReduced ω) {t : W} (ht : t ∈ cs.leftInvSeq ω)
Goal: cs.IsLeftInversion (cs.wordProd ω) t
-- CoxeterSystem.prod_rightInvSeq
theorem prod_rightInvSeq (ω : List B) : prod (ris ω) = (π ω)⁻¹ 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B)
Goal: (cs.rightInvSeq ω).prod = (cs.wordProd ω)⁻¹
-- CoxeterSystem.prod_leftInvSeq
theorem prod_leftInvSeq (ω : List B) : prod (lis ω) = (π ω)⁻¹ 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B)
Goal: (cs.leftInvSeq ω).prod = (cs.wordProd ω)⁻¹
-- CoxeterSystem.IsReduced.nodup_rightInvSeq
theorem IsReduced.nodup_rightInvSeq {ω : List B} (rω : cs.IsReduced ω) : List.Nodup (ris ω) 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {ω : List B} (rω : cs.IsReduced ω)
Goal: (cs.rightInvSeq ω).Nodup
-- CoxeterSystem.IsReduced.nodup_leftInvSeq
theorem IsReduced.nodup_leftInvSeq {ω : List B} (rω : cs.IsReduced ω) : List.Nodup (lis ω) 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {ω : List B} (rω : cs.IsReduced ω)
Goal: (cs.leftInvSeq ω).Nodup
-- ULiftable.up_down
theorem up_down {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [ULiftable f g] {α}
    (x : g (ULift.{v₀} α)) : up (down x : f α) = x 
Arguments: {f : Type u₀ → Type u₁} {g : Type (max u₀ v₀) → Type v₁} [ULiftable f g] {α : Type u₀} (x : g (ULift.{v₀, u₀} α))
Goal: ULiftable.up (ULiftable.down x) = x
-- ULiftable.down_up
theorem down_up {f : Type u₀ → Type u₁} {g : Type max u₀ v₀ → Type v₁} [ULiftable f g] {α}
    (x : f α) : down (up x : g (ULift.{v₀} α)) = x 
Arguments: {f : Type u₀ → Type u₁} {g : Type (max u₀ v₀) → Type v₁} [ULiftable f g] {α : Type u₀} (x : f α)
Goal: ULiftable.down (ULiftable.up x) = x
-- commutatorElement_eq_one_iff_mul_comm
theorem commutatorElement_eq_one_iff_mul_comm : ⁅g₁, g₂⁆ = 1 ↔ g₁ * g₂ = g₂ * g₁ 
Arguments: {G : Type u_1} [Group G] {g₁ g₂ : G}
Goal: ⁅g₁, g₂⁆ = 1 ↔ g₁ * g₂ = g₂ * g₁
-- commutatorElement_eq_one_iff_commute
theorem commutatorElement_eq_one_iff_commute : ⁅g₁, g₂⁆ = 1 ↔ Commute g₁ g₂ 
Arguments: {G : Type u_1} [Group G] {g₁ g₂ : G}
Goal: ⁅g₁, g₂⁆ = 1 ↔ Commute g₁ g₂
-- Commute.commutator_eq
theorem Commute.commutator_eq (h : Commute g₁ g₂) : ⁅g₁, g₂⁆ = 1 
Arguments: {G : Type u_1} [Group G] {g₁ g₂ : G} (h : Commute g₁ g₂)
Goal: ⁅g₁, g₂⁆ = 1
-- commutatorElement_one_right
@[simp]
theorem commutatorElement_one_right : ⁅g, (1 : G)⁆ = 1 
Arguments: {G : Type u_1} [Group G] (g : G)
Goal: ⁅g, 1⁆ = 1
-- commutatorElement_one_left
@[simp]
theorem commutatorElement_one_left : ⁅(1 : G), g⁆ = 1 
Arguments: {G : Type u_1} [Group G] (g : G)
Goal: ⁅1, g⁆ = 1
-- commutatorElement_self
@[simp]
theorem commutatorElement_self : ⁅g, g⁆ = 1 
Arguments: {G : Type u_1} [Group G] (g : G)
Goal: ⁅g, g⁆ = 1
-- commutatorElement_inv
@[simp]
theorem commutatorElement_inv : ⁅g₁, g₂⁆⁻¹ = ⁅g₂, g₁⁆ 
Arguments: {G : Type u_1} [Group G] (g₁ g₂ : G)
Goal: ⁅g₁, g₂⁆⁻¹ = ⁅g₂, g₁⁆
-- map_commutatorElement
theorem map_commutatorElement : (f ⁅g₁, g₂⁆ : G') = ⁅f g₁, f g₂⁆ 
Arguments: {G : Type u_1} {G' : Type u_2} {F : Type u_3} [Group G] [Group G'] [FunLike F G G'] [MonoidHomClass F G G'] (f : F) (g₁ g₂ : G)
Goal: f ⁅g₁, g₂⁆ = ⁅f g₁, f g₂⁆
-- conjugate_commutatorElement
theorem conjugate_commutatorElement : g₃ * ⁅g₁, g₂⁆ * g₃⁻¹ = ⁅g₃ * g₁ * g₃⁻¹, g₃ * g₂ * g₃⁻¹⁆ 
Arguments: {G : Type u_1} [Group G] (g₁ g₂ g₃ : G)
Goal: g₃ * ⁅g₁, g₂⁆ * g₃⁻¹ = ⁅g₃ * g₁ * g₃⁻¹, g₃ * g₂ * g₃⁻¹⁆
-- Subgroup.commutator_def
theorem commutator_def (H₁ H₂ : Subgroup G) :
    ⁅H₁, H₂⁆ = closure { g | ∃ g₁ ∈ H₁, ∃ g₂ ∈ H₂, ⁅g₁, g₂⁆ = g } 
Arguments: {G : Type u_1} [Group G] (H₁ H₂ : Subgroup G)
Goal: ⁅H₁, H₂⁆ = Subgroup.closure {g | ∃ g₁ ∈ H₁, ∃ g₂ ∈ H₂, ⁅g₁, g₂⁆ = g}
-- Subgroup.commutator_mem_commutator
theorem commutator_mem_commutator (h₁ : g₁ ∈ H₁) (h₂ : g₂ ∈ H₂) : ⁅g₁, g₂⁆ ∈ ⁅H₁, H₂⁆ 
Arguments: {G : Type u_1} [Group G] {g₁ g₂ : G} {H₁ H₂ : Subgroup G} (h₁ : g₁ ∈ H₁) (h₂ : g₂ ∈ H₂)
Goal: ⁅g₁, g₂⁆ ∈ ⁅H₁, H₂⁆
-- Subgroup.commutator_le
theorem commutator_le : ⁅H₁, H₂⁆ ≤ H₃ ↔ ∀ g₁ ∈ H₁, ∀ g₂ ∈ H₂, ⁅g₁, g₂⁆ ∈ H₃ 
Arguments: {G : Type u_1} [Group G] {H₁ H₂ H₃ : Subgroup G}
Goal: ⁅H₁, H₂⁆ ≤ H₃ ↔ ∀ g₁ ∈ H₁, ∀ g₂ ∈ H₂, ⁅g₁, g₂⁆ ∈ H₃
-- Subgroup.commutator_mono
theorem commutator_mono (h₁ : H₁ ≤ K₁) (h₂ : H₂ ≤ K₂) : ⁅H₁, H₂⁆ ≤ ⁅K₁, K₂⁆ 
Arguments: {G : Type u_1} [Group G] {H₁ H₂ K₁ K₂ : Subgroup G} (h₁ : H₁ ≤ K₁) (h₂ : H₂ ≤ K₂)
Goal: ⁅H₁, H₂⁆ ≤ ⁅K₁, K₂⁆
-- Subgroup.commutator_eq_bot_iff_le_centralizer
theorem commutator_eq_bot_iff_le_centralizer : ⁅H₁, H₂⁆ = ⊥ ↔ H₁ ≤ centralizer H₂ 
Arguments: {G : Type u_1} [Group G] {H₁ H₂ : Subgroup G}
Goal: ⁅H₁, H₂⁆ = ⊥ ↔ H₁ ≤ Subgroup.centralizer ↑H₂
-- Subgroup.commutator_commutator_eq_bot_of_rotate
theorem commutator_commutator_eq_bot_of_rotate (h1 : ⁅⁅H₂, H₃⁆, H₁⁆ = ⊥) (h2 : ⁅⁅H₃, H₁⁆, H₂⁆ = ⊥) :
    ⁅⁅H₁, H₂⁆, H₃⁆ = ⊥ 
Arguments: {G : Type u_1} [Group G] {H₁ H₂ H₃ : Subgroup G} (h1 : ⁅⁅H₂, H₃⁆, H₁⁆ = ⊥) (h2 : ⁅⁅H₃, H₁⁆, H₂⁆ = ⊥)
Goal: ⁅⁅H₁, H₂⁆, H₃⁆ = ⊥
-- Subgroup.commutator_comm_le
theorem commutator_comm_le : ⁅H₁, H₂⁆ ≤ ⁅H₂, H₁⁆ 
Arguments: {G : Type u_1} [Group G] (H₁ H₂ : Subgroup G)
Goal: ⁅H₁, H₂⁆ ≤ ⁅H₂, H₁⁆
-- Subgroup.commutator_comm
theorem commutator_comm : ⁅H₁, H₂⁆ = ⁅H₂, H₁⁆ 
Arguments: {G : Type u_1} [Group G] (H₁ H₂ : Subgroup G)
Goal: ⁅H₁, H₂⁆ = ⁅H₂, H₁⁆
-- Subgroup.commutator_def'
theorem commutator_def' [H₁.Normal] [H₂.Normal] :
    ⁅H₁, H₂⁆ = normalClosure { g | ∃ g₁ ∈ H₁, ∃ g₂ ∈ H₂, ⁅g₁, g₂⁆ = g } 
Arguments: {G : Type u_1} [Group G] (H₁ H₂ : Subgroup G) [H₁.Normal] [H₂.Normal]
Goal: ⁅H₁, H₂⁆ = Subgroup.normalClosure {g | ∃ g₁ ∈ H₁, ∃ g₂ ∈ H₂, ⁅g₁, g₂⁆ = g}
-- Subgroup.commutator_le_right
theorem commutator_le_right [h : H₂.Normal] : ⁅H₁, H₂⁆ ≤ H₂ 
Arguments: {G : Type u_1} [Group G] (H₁ H₂ : Subgroup G) [h : H₂.Normal]
Goal: ⁅H₁, H₂⁆ ≤ H₂
-- Subgroup.commutator_le_left
theorem commutator_le_left [H₁.Normal] : ⁅H₁, H₂⁆ ≤ H₁ 
Arguments: {G : Type u_1} [Group G] (H₁ H₂ : Subgroup G) [H₁.Normal]
Goal: ⁅H₁, H₂⁆ ≤ H₁
-- Subgroup.commutator_bot_left
@[simp]
theorem commutator_bot_left : ⁅(⊥ : Subgroup G), H₁⁆ = ⊥ 
Arguments: {G : Type u_1} [Group G] (H₁ : Subgroup G)
Goal: ⁅⊥, H₁⁆ = ⊥
-- Subgroup.commutator_bot_right
@[simp]
theorem commutator_bot_right : ⁅H₁, ⊥⁆ = (⊥ : Subgroup G) 
Arguments: {G : Type u_1} [Group G] (H₁ : Subgroup G)
Goal: ⁅H₁, ⊥⁆ = ⊥
-- Subgroup.commutator_le_inf
theorem commutator_le_inf [Normal H₁] [Normal H₂] : ⁅H₁, H₂⁆ ≤ H₁ ⊓ H₂ 
Arguments: {G : Type u_1} [Group G] (H₁ H₂ : Subgroup G) [H₁.Normal] [H₂.Normal]
Goal: ⁅H₁, H₂⁆ ≤ H₁ ⊓ H₂
-- Subgroup.map_commutator
theorem map_commutator (f : G →* G') : map f ⁅H₁, H₂⁆ = ⁅map f H₁, map f H₂⁆ 
Arguments: {G : Type u_1} {G' : Type u_2} [Group G] [Group G'] (H₁ H₂ : Subgroup G) (f : G →* G')
Goal: Subgroup.map f ⁅H₁, H₂⁆ = ⁅Subgroup.map f H₁, Subgroup.map f H₂⁆
-- Subgroup.commutator_le_map_commutator
theorem commutator_le_map_commutator {f : G →* G'} {K₁ K₂ : Subgroup G'} (h₁ : K₁ ≤ H₁.map f)
    (h₂ : K₂ ≤ H₂.map f) : ⁅K₁, K₂⁆ ≤ ⁅H₁, H₂⁆.map f 
Arguments: {G : Type u_1} {G' : Type u_2} [Group G] [Group G'] {H₁ H₂ : Subgroup G} {f : G →* G'} {K₁ K₂ : Subgroup G'} (h₁ : K₁ ≤ Subgroup.map f H₁) (h₂ : K₂ ≤ Subgroup.map f H₂)
Goal: ⁅K₁, K₂⁆ ≤ Subgroup.map f ⁅H₁, H₂⁆
-- Subgroup.commutator_prod_prod
theorem commutator_prod_prod (K₁ K₂ : Subgroup G') :
    ⁅H₁.prod K₁, H₂.prod K₂⁆ = ⁅H₁, H₂⁆.prod ⁅K₁, K₂⁆ 
Arguments: {G : Type u_1} {G' : Type u_2} [Group G] [Group G'] (H₁ H₂ : Subgroup G) (K₁ K₂ : Subgroup G')
Goal: ⁅H₁.prod K₁, H₂.prod K₂⁆ = ⁅H₁, H₂⁆.prod ⁅K₁, K₂⁆
-- Subgroup.commutator_pi_pi_le
theorem commutator_pi_pi_le {η : Type*} {Gs : η → Type*} [∀ i, Group (Gs i)]
    (H K : ∀ i, Subgroup (Gs i)) :
    ⁅Subgroup.pi Set.univ H, Subgroup.pi Set.univ K⁆ ≤ Subgroup.pi Set.univ fun i => ⁅H i, K i⁆ 
Arguments: {η : Type u_4} {Gs : η → Type u_5} [(i : η) → Group (Gs i)] (H K : (i : η) → Subgroup (Gs i))
Goal: ⁅Subgroup.pi Set.univ H, Subgroup.pi Set.univ K⁆ ≤ Subgroup.pi Set.univ fun i => ⁅H i, K i⁆
-- Subgroup.commutator_pi_pi_of_finite
theorem commutator_pi_pi_of_finite {η : Type*} [Finite η] {Gs : η → Type*} [∀ i, Group (Gs i)]
    (H K : ∀ i, Subgroup (Gs i)) : ⁅Subgroup.pi Set.univ H, Subgroup.pi Set.univ K⁆ =
    Subgroup.pi Set.univ fun i => ⁅H i, K i⁆ 
Arguments: {η : Type u_4} [Finite η] {Gs : η → Type u_5} [(i : η) → Group (Gs i)] (H K : (i : η) → Subgroup (Gs i))
Goal: ⁅Subgroup.pi Set.univ H, Subgroup.pi Set.univ K⁆ = Subgroup.pi Set.univ fun i => ⁅H i, K i⁆
-- commutatorSet_def
theorem commutatorSet_def : commutatorSet G = { g | ∃ g₁ g₂ : G, ⁅g₁, g₂⁆ = g } 
Arguments: (G : Type u_1) [Group G]
Goal: commutatorSet G = {g | ∃ g₁ g₂, ⁅g₁, g₂⁆ = g}
-- one_mem_commutatorSet
theorem one_mem_commutatorSet : (1 : G) ∈ commutatorSet G 
Arguments: (G : Type u_1) [Group G]
Goal: 1 ∈ commutatorSet G
-- mem_commutatorSet_iff
theorem mem_commutatorSet_iff : g ∈ commutatorSet G ↔ ∃ g₁ g₂ : G, ⁅g₁, g₂⁆ = g 
Arguments: {G : Type u_1} [Group G] {g : G}
Goal: g ∈ commutatorSet G ↔ ∃ g₁ g₂, ⁅g₁, g₂⁆ = g
-- commutator_mem_commutatorSet
theorem commutator_mem_commutatorSet : ⁅g₁, g₂⁆ ∈ commutatorSet G 
Arguments: {G : Type u_1} [Group G] (g₁ g₂ : G)
Goal: ⁅g₁, g₂⁆ ∈ commutatorSet G
-- AddSubgroup.cyclic_of_min
theorem AddSubgroup.cyclic_of_min {H : AddSubgroup G} {a : G}
    (ha : IsLeast { g : G | g ∈ H ∧ 0 < g } a) : H = AddSubgroup.closure {a} 
Arguments: {G : Type u_1} [LinearOrderedAddCommGroup G] [Archimedean G] {H : AddSubgroup G} {a : G} (ha : IsLeast {g | g ∈ H ∧ 0 < g} a)
Goal: H = AddSubgroup.closure {a}
-- AddSubgroup.exists_isLeast_pos
theorem AddSubgroup.exists_isLeast_pos {H : AddSubgroup G} (hbot : H ≠ ⊥) {a : G} (h₀ : 0 < a)
    (hd : Disjoint (H : Set G) (Ioo 0 a)) : ∃ b, IsLeast { g : G | g ∈ H ∧ 0 < g } b 
Arguments: {G : Type u_1} [LinearOrderedAddCommGroup G] [Archimedean G] {H : AddSubgroup G} (hbot : H ≠ ⊥) {a : G} (h₀ : 0 < a) (hd : Disjoint (↑H) (Set.Ioo 0 a))
Goal: ∃ b, IsLeast {g | g ∈ H ∧ 0 < g} b
-- AddSubgroup.cyclic_of_isolated_zero
theorem AddSubgroup.cyclic_of_isolated_zero {H : AddSubgroup G} {a : G} (h₀ : 0 < a)
    (hd : Disjoint (H : Set G) (Ioo 0 a)) : ∃ b, H = closure {b} 
Arguments: {G : Type u_1} [LinearOrderedAddCommGroup G] [Archimedean G] {H : AddSubgroup G} {a : G} (h₀ : 0 < a) (hd : Disjoint (↑H) (Set.Ioo 0 a))
Goal: ∃ b, H = AddSubgroup.closure {b}
-- Int.subgroup_cyclic
theorem Int.subgroup_cyclic (H : AddSubgroup ℤ) : ∃ a, H = AddSubgroup.closure {a} 
Arguments: (H : AddSubgroup ℤ)
Goal: ∃ a, H = AddSubgroup.closure {a}
-- Module.finite_of_fg_torsion
theorem finite_of_fg_torsion [AddCommGroup M] [Module ℤ M] [Module.Finite ℤ M]
    (hM : Module.IsTorsion ℤ M) : _root_.Finite M 
Arguments: (M : Type u) [AddCommGroup M] [Module ℤ M] [Module.Finite ℤ M] (hM : Module.IsTorsion ℤ M)
Goal: Finite M
-- AddCommGroup.equiv_free_prod_directSum_zmod
theorem equiv_free_prod_directSum_zmod [hG : AddGroup.FG G] :
    ∃ (n : ℕ) (ι : Type) (_ : Fintype ι) (p : ι → ℕ) (_ : ∀ i, Nat.Prime <| p i) (e : ι → ℕ),
      Nonempty <| G ≃+ (Fin n →₀ ℤ) × ⨁ i : ι, ZMod (p i ^ e i) 
Arguments: (G : Type u) [AddCommGroup G] [hG : AddGroup.FG G]
Goal: ∃ n ι x p, ∃ (_ : ∀ (i : ι), Nat.Prime (p i)), ∃ e, Nonempty (G ≃+ (Fin n →₀ ℤ) × ⨁ (i : ι), ZMod (p i ^ e i))
-- AddCommGroup.equiv_directSum_zmod_of_finite
theorem equiv_directSum_zmod_of_finite [Finite G] :
    ∃ (ι : Type) (_ : Fintype ι) (p : ι → ℕ) (_ : ∀ i, Nat.Prime <| p i) (e : ι → ℕ),
      Nonempty <| G ≃+ ⨁ i : ι, ZMod (p i ^ e i) 
Arguments: (G : Type u) [AddCommGroup G] [Finite G]
Goal: ∃ ι x p, ∃ (_ : ∀ (i : ι), Nat.Prime (p i)), ∃ e, Nonempty (G ≃+ ⨁ (i : ι), ZMod (p i ^ e i))
-- AddCommGroup.equiv_directSum_zmod_of_finite'
lemma equiv_directSum_zmod_of_finite' (G : Type*) [AddCommGroup G] [Finite G] :
    ∃ (ι : Type) (_ : Fintype ι) (n : ι → ℕ),
      (∀ i, 1 < n i) ∧ Nonempty (G ≃+ ⨁ i, ZMod (n i)) 
Arguments: (G : Type u_1) [AddCommGroup G] [Finite G]
Goal: ∃ ι x n, (∀ (i : ι), 1 < n i) ∧ Nonempty (G ≃+ ⨁ (i : ι), ZMod (n i))
-- AddCommGroup.finite_of_fg_torsion
theorem finite_of_fg_torsion [hG' : AddGroup.FG G] (hG : AddMonoid.IsTorsion G) : Finite G 
Arguments: (G : Type u) [AddCommGroup G] [hG' : AddGroup.FG G] (hG : AddMonoid.IsTorsion G)
Goal: Finite G
-- CommGroup.finite_of_fg_torsion
theorem finite_of_fg_torsion [CommGroup G] [Group.FG G] (hG : Monoid.IsTorsion G) : Finite G 
Arguments: (G : Type u) [CommGroup G] [Group.FG G] (hG : Monoid.IsTorsion G)
Goal: Finite G
-- derivedSeries_zero
@[simp]
theorem derivedSeries_zero : derivedSeries G 0 = ⊤ 
Arguments: (G : Type u_1) [Group G]
Goal: derivedSeries G 0 = ⊤
-- derivedSeries_succ
@[simp]
theorem derivedSeries_succ (n : ℕ) :
    derivedSeries G (n + 1) = ⁅derivedSeries G n, derivedSeries G n⁆ 
Arguments: (G : Type u_1) [Group G] (n : ℕ)
Goal: derivedSeries G (n + 1) = ⁅derivedSeries G n, derivedSeries G n⁆
-- derivedSeries_normal
theorem derivedSeries_normal (n : ℕ) : (derivedSeries G n).Normal 
Arguments: (G : Type u_1) [Group G] (n : ℕ)
Goal: (derivedSeries G n).Normal
-- derivedSeries_one
@[simp 1100]
theorem derivedSeries_one : derivedSeries G 1 = commutator G 
Arguments: (G : Type u_1) [Group G]
Goal: derivedSeries G 1 = commutator G
-- map_derivedSeries_le_derivedSeries
theorem map_derivedSeries_le_derivedSeries (n : ℕ) :
    (derivedSeries G n).map f ≤ derivedSeries G' n 
Arguments: {G : Type u_1} {G' : Type u_2} [Group G] [Group G'] (f : G →* G') (n : ℕ)
Goal: Subgroup.map f (derivedSeries G n) ≤ derivedSeries G' n
-- derivedSeries_le_map_derivedSeries
theorem derivedSeries_le_map_derivedSeries (hf : Function.Surjective f) (n : ℕ) :
    derivedSeries G' n ≤ (derivedSeries G n).map f 
Arguments: {G : Type u_1} {G' : Type u_2} [Group G] [Group G'] {f : G →* G'} (hf : Function.Surjective ⇑f) (n : ℕ)
Goal: derivedSeries G' n ≤ Subgroup.map f (derivedSeries G n)
-- map_derivedSeries_eq
theorem map_derivedSeries_eq (hf : Function.Surjective f) (n : ℕ) :
    (derivedSeries G n).map f = derivedSeries G' n 
Arguments: {G : Type u_1} {G' : Type u_2} [Group G] [Group G'] {f : G →* G'} (hf : Function.Surjective ⇑f) (n : ℕ)
Goal: Subgroup.map f (derivedSeries G n) = derivedSeries G' n
-- IsSolvable.solvable
@[mk_iff isSolvable_def]
class IsSolvable : Prop where
    solvable : ∃ n : ℕ, derivedSeries G n = ⊥
Arguments: {G : Type u_1} [Group G] [self : IsSolvable G]
Goal: ∃ n, derivedSeries G n = ⊥
-- isSolvable_def
@[mk_iff isSolvable_def]
class IsSolvable : Prop where
    solvable : ∃ n : ℕ, derivedSeries G n = ⊥
Arguments: (G : Type u_1) [Group G]
Goal: IsSolvable G ↔ ∃ n, derivedSeries G n = ⊥
-- isSolvable_of_comm
theorem isSolvable_of_comm {G : Type*} [hG : Group G] (h : ∀ a b : G, a * b = b * a) :
    IsSolvable G 
Arguments: {G : Type u_3} [hG : Group G] (h : ∀ (a b : G), a * b = b * a)
Goal: IsSolvable G
-- isSolvable_of_top_eq_bot
theorem isSolvable_of_top_eq_bot (h : (⊤ : Subgroup G) = ⊥) : IsSolvable G 
Arguments: (G : Type u_1) [Group G] (h : ⊤ = ⊥)
Goal: IsSolvable G
-- solvable_of_ker_le_range
theorem solvable_of_ker_le_range {G' G'' : Type*} [Group G'] [Group G''] (f : G' →* G)
    (g : G →* G'') (hfg : g.ker ≤ f.range) [hG' : IsSolvable G'] [hG'' : IsSolvable G''] :
    IsSolvable G 
Arguments: {G : Type u_1} [Group G] {G' : Type u_3} {G'' : Type u_4} [Group G'] [Group G''] (f : G' →* G) (g : G →* G'') (hfg : g.ker ≤ f.range) [hG' : IsSolvable G'] [hG'' : IsSolvable G'']
Goal: IsSolvable G
-- solvable_of_solvable_injective
theorem solvable_of_solvable_injective (hf : Function.Injective f) [IsSolvable G'] :
    IsSolvable G 
Arguments: {G : Type u_1} {G' : Type u_2} [Group G] [Group G'] {f : G →* G'} (hf : Function.Injective ⇑f) [IsSolvable G']
Goal: IsSolvable G
-- solvable_of_surjective
theorem solvable_of_surjective (hf : Function.Surjective f) [IsSolvable G] : IsSolvable G' 
Arguments: {G : Type u_1} {G' : Type u_2} [Group G] [Group G'] {f : G →* G'} (hf : Function.Surjective ⇑f) [IsSolvable G]
Goal: IsSolvable G'
-- IsSimpleGroup.derivedSeries_succ
theorem IsSimpleGroup.derivedSeries_succ {n : ℕ} : derivedSeries G n.succ = commutator G 
Arguments: {G : Type u_1} [Group G] [IsSimpleGroup G] {n : ℕ}
Goal: derivedSeries G n.succ = commutator G
-- IsSimpleGroup.comm_iff_isSolvable
theorem IsSimpleGroup.comm_iff_isSolvable : (∀ a b : G, a * b = b * a) ↔ IsSolvable G 
Arguments: {G : Type u_1} [Group G] [IsSimpleGroup G]
Goal: (∀ (a b : G), a * b = b * a) ↔ IsSolvable G
-- not_solvable_of_mem_derivedSeries
theorem not_solvable_of_mem_derivedSeries {g : G} (h1 : g ≠ 1)
    (h2 : ∀ n : ℕ, g ∈ derivedSeries G n) : ¬IsSolvable G 
Arguments: {G : Type u_1} [Group G] {g : G} (h1 : g ≠ 1) (h2 : ∀ (n : ℕ), g ∈ derivedSeries G n)
Goal: ¬IsSolvable G
-- Equiv.Perm.fin_5_not_solvable
theorem Equiv.Perm.fin_5_not_solvable : ¬IsSolvable (Equiv.Perm (Fin 5)) 
Goal: ¬IsSolvable (Equiv.Perm (Fin 5))
-- Equiv.Perm.not_solvable
theorem Equiv.Perm.not_solvable (X : Type*) (hX : 5 ≤ Cardinal.mk X) :
    ¬IsSolvable (Equiv.Perm X) 
Arguments: (X : Type u_3) (hX : 5 ≤ Cardinal.mk X)
Goal: ¬IsSolvable (Equiv.Perm X)
-- Monoid.Foldl.ofFreeMonoid_apply
@[simps]
def Foldl.ofFreeMonoid (f : β → α → β) : FreeMonoid α →* Monoid.Foldl β 
Arguments: {α β : Type u} (f : β → α → β) (xs : FreeMonoid α)
Goal: (Monoid.Foldl.ofFreeMonoid f) xs = MulOpposite.op (flip (List.foldl f) (FreeMonoid.toList xs))
-- Monoid.Foldr.ofFreeMonoid_apply
@[simps]
def Foldr.ofFreeMonoid (f : α → β → β) : FreeMonoid α →* Monoid.Foldr β 
Arguments: {α β : Type u} (f : α → β → β) (xs : FreeMonoid α)
Goal: ∀ (a : β), (Monoid.Foldr.ofFreeMonoid f) xs a = flip (List.foldr f) (FreeMonoid.toList xs) a
-- Monoid.foldlM.ofFreeMonoid_apply
@[simps]
def foldlM.ofFreeMonoid [LawfulMonad m] (f : β → α → m β) : FreeMonoid α →* Monoid.foldlM m β 
Arguments: {m : Type u → Type u} [Monad m] {α β : Type u} [LawfulMonad m] (f : β → α → m β) (xs : FreeMonoid α)
Goal: (Monoid.foldlM.ofFreeMonoid f) xs = MulOpposite.op (flip (List.foldlM f) (FreeMonoid.toList xs))
-- Monoid.foldrM.ofFreeMonoid_apply
@[simps]
def foldrM.ofFreeMonoid [LawfulMonad m] (f : α → β → m β) : FreeMonoid α →* Monoid.foldrM m β 
Arguments: {m : Type u → Type u} [Monad m] {α β : Type u} [LawfulMonad m] (f : α → β → m β) (xs : FreeMonoid α)
Goal: ∀ (a : CategoryTheory.KleisliCat.mk m β),
  (Monoid.foldrM.ofFreeMonoid f) xs a = flip (List.foldrM f) (FreeMonoid.toList xs) a
-- Traversable.Free.map_eq_map
theorem Free.map_eq_map (f : α → β) (xs : List α) :
    f <$> xs = (FreeMonoid.toList (FreeMonoid.map f (FreeMonoid.ofList xs))) 
Arguments: {α β : Type u} (f : α → β) (xs : List α)
Goal: f <$> xs = FreeMonoid.toList ((FreeMonoid.map f) (FreeMonoid.ofList xs))
-- Traversable.foldl.unop_ofFreeMonoid
theorem foldl.unop_ofFreeMonoid (f : β → α → β) (xs : FreeMonoid α) (a : β) :
    unop (Foldl.ofFreeMonoid f xs) a = List.foldl f a (FreeMonoid.toList xs) 
Arguments: {α β : Type u} (f : β → α → β) (xs : FreeMonoid α) (a : β)
Goal: MulOpposite.unop ((Monoid.Foldl.ofFreeMonoid f) xs) a = List.foldl f a (FreeMonoid.toList xs)
-- Traversable.foldMap_hom
theorem foldMap_hom [Monoid α] [Monoid β] (f : α →* β) (g : γ → α) (x : t γ) :
    f (foldMap g x) = foldMap (f ∘ g) x 
Arguments: {α β γ : Type u} {t : Type u → Type u} [Traversable t] [LawfulTraversable t] [Monoid α] [Monoid β] (f : α →* β) (g : γ → α) (x : t γ)
Goal: f (Traversable.foldMap g x) = Traversable.foldMap (⇑f ∘ g) x
-- Traversable.foldMap_hom_free
theorem foldMap_hom_free [Monoid β] (f : FreeMonoid α →* β) (x : t α) :
    f (foldMap FreeMonoid.of x) = foldMap (f ∘ FreeMonoid.of) x 
Arguments: {α β : Type u} {t : Type u → Type u} [Traversable t] [LawfulTraversable t] [Monoid β] (f : FreeMonoid α →* β) (x : t α)
Goal: f (Traversable.foldMap FreeMonoid.of x) = Traversable.foldMap (⇑f ∘ FreeMonoid.of) x
-- Traversable.foldl.ofFreeMonoid_comp_of
@[simp]
theorem foldl.ofFreeMonoid_comp_of (f : α → β → α) :
    Foldl.ofFreeMonoid f ∘ FreeMonoid.of = Foldl.mk ∘ flip f 
Arguments: {α β : Type u} (f : α → β → α)
Goal: ⇑(Monoid.Foldl.ofFreeMonoid f) ∘ FreeMonoid.of = Monoid.Foldl.mk ∘ flip f
-- Traversable.foldr.ofFreeMonoid_comp_of
@[simp]
theorem foldr.ofFreeMonoid_comp_of (f : β → α → α) :
    Foldr.ofFreeMonoid f ∘ FreeMonoid.of = Foldr.mk ∘ f 
Arguments: {α β : Type u} (f : β → α → α)
Goal: ⇑(Monoid.Foldr.ofFreeMonoid f) ∘ FreeMonoid.of = Monoid.Foldr.mk ∘ f
-- Traversable.foldlm.ofFreeMonoid_comp_of
@[simp]
theorem foldlm.ofFreeMonoid_comp_of {m} [Monad m] [LawfulMonad m] (f : α → β → m α) :
    foldlM.ofFreeMonoid f ∘ FreeMonoid.of = foldlM.mk ∘ flip f 
Arguments: {α β : Type u} {m : Type u → Type u} [Monad m] [LawfulMonad m] (f : α → β → m α)
Goal: ⇑(Monoid.foldlM.ofFreeMonoid f) ∘ FreeMonoid.of = Monoid.foldlM.mk ∘ flip f
-- Traversable.foldrm.ofFreeMonoid_comp_of
@[simp]
theorem foldrm.ofFreeMonoid_comp_of {m} [Monad m] [LawfulMonad m] (f : β → α → m α) :
    foldrM.ofFreeMonoid f ∘ FreeMonoid.of = foldrM.mk ∘ f 
Arguments: {α β : Type u} {m : Type u → Type u} [Monad m] [LawfulMonad m] (f : β → α → m α)
Goal: ⇑(Monoid.foldrM.ofFreeMonoid f) ∘ FreeMonoid.of = Monoid.foldrM.mk ∘ f