ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AddAction.Quotient.mk_vadd_out'
@[to_additive (attr := simp)]
theorem Quotient.mk_smul_out' [QuotientAction β H] (b : β) (q : α ⧸ H) :
    QuotientGroup.mk (b • q.out') = b • q 
Arguments: {α : Type u} {β : Type v} [AddGroup α] [AddMonoid β] [AddAction β α] (H : AddSubgroup α) [AddAction.QuotientAction β H] (b : β) (q : α ⧸ H)
Goal: ↑(b +ᵥ Quotient.out' q) = b +ᵥ q
-- MulAction.Quotient.mk_smul_out'
@[to_additive (attr := simp)]
theorem Quotient.mk_smul_out' [QuotientAction β H] (b : β) (q : α ⧸ H) :
    QuotientGroup.mk (b • q.out') = b • q 
Arguments: {α : Type u} {β : Type v} [Group α] [Monoid β] [MulAction β α] (H : Subgroup α) [MulAction.QuotientAction β H] (b : β) (q : α ⧸ H)
Goal: ↑(b • Quotient.out' q) = b • q
-- MulAction.Quotient.coe_smul_out'
@[to_additive]
theorem Quotient.coe_smul_out' [QuotientAction β H] (b : β) (q : α ⧸ H) : ↑(b • q.out') = b • q 
Arguments: {α : Type u} {β : Type v} [Group α] [Monoid β] [MulAction β α] (H : Subgroup α) [MulAction.QuotientAction β H] (b : β) (q : α ⧸ H)
Goal: ↑(b • Quotient.out' q) = b • q
-- AddAction.Quotient.coe_vadd_out'
@[to_additive]
theorem Quotient.coe_smul_out' [QuotientAction β H] (b : β) (q : α ⧸ H) : ↑(b • q.out') = b • q 
Arguments: {α : Type u} {β : Type v} [AddGroup α] [AddMonoid β] [AddAction β α] (H : AddSubgroup α) [AddAction.QuotientAction β H] (b : β) (q : α ⧸ H)
Goal: ↑(b +ᵥ Quotient.out' q) = b +ᵥ q
-- QuotientGroup.out'_conj_pow_minimalPeriod_mem
theorem _root_.QuotientGroup.out'_conj_pow_minimalPeriod_mem (a : α) (q : α ⧸ H) :
    q.out'⁻¹ * a ^ Function.minimalPeriod (a • ·) q * q.out' ∈ H 
Arguments: {α : Type u} [Group α] (H : Subgroup α) (a : α) (q : α ⧸ H)
Goal: (Quotient.out' q)⁻¹ * a ^ Function.minimalPeriod (fun x => a • x) q * Quotient.out' q ∈ H
-- MulActionHom.toQuotient_apply
@[simp]
theorem _root_.MulActionHom.toQuotient_apply (H : Subgroup α) (g : α) :
    MulActionHom.toQuotient H g = g 
Arguments: {α : Type u} [Group α] (H : Subgroup α) (g : α)
Goal: (MulActionHom.toQuotient H) g = ↑g
-- MulAction.ofQuotientStabilizer_mk
@[to_additive (attr := simp)]
theorem ofQuotientStabilizer_mk (g : α) : ofQuotientStabilizer α x (QuotientGroup.mk g) = g • x 
Arguments: (α : Type u) {β : Type v} [Group α] [MulAction α β] (x : β) (g : α)
Goal: MulAction.ofQuotientStabilizer α x ↑g = g • x
-- AddAction.ofQuotientStabilizer_mk
@[to_additive (attr := simp)]
theorem ofQuotientStabilizer_mk (g : α) : ofQuotientStabilizer α x (QuotientGroup.mk g) = g • x 
Arguments: (α : Type u) {β : Type v} [AddGroup α] [AddAction α β] (x : β) (g : α)
Goal: AddAction.ofQuotientStabilizer α x ↑g = g +ᵥ x
-- AddAction.ofQuotientStabilizer_mem_orbit
@[to_additive]
theorem ofQuotientStabilizer_mem_orbit (g) : ofQuotientStabilizer α x g ∈ orbit α x 
Arguments: (α : Type u) {β : Type v} [AddGroup α] [AddAction α β] (x : β) (g : α ⧸ AddAction.stabilizer α x)
Goal: AddAction.ofQuotientStabilizer α x g ∈ AddAction.orbit α x
-- MulAction.ofQuotientStabilizer_mem_orbit
@[to_additive]
theorem ofQuotientStabilizer_mem_orbit (g) : ofQuotientStabilizer α x g ∈ orbit α x 
Arguments: (α : Type u) {β : Type v} [Group α] [MulAction α β] (x : β) (g : α ⧸ MulAction.stabilizer α x)
Goal: MulAction.ofQuotientStabilizer α x g ∈ MulAction.orbit α x
-- AddAction.ofQuotientStabilizer_vadd
@[to_additive]
theorem ofQuotientStabilizer_smul (g : α) (g' : α ⧸ MulAction.stabilizer α x) :
    ofQuotientStabilizer α x (g • g') = g • ofQuotientStabilizer α x g' 
Arguments: (α : Type u) {β : Type v} [AddGroup α] [AddAction α β] (x : β) (g : α) (g' : α ⧸ AddAction.stabilizer α x)
Goal: AddAction.ofQuotientStabilizer α x (g +ᵥ g') = g +ᵥ AddAction.ofQuotientStabilizer α x g'
-- MulAction.ofQuotientStabilizer_smul
@[to_additive]
theorem ofQuotientStabilizer_smul (g : α) (g' : α ⧸ MulAction.stabilizer α x) :
    ofQuotientStabilizer α x (g • g') = g • ofQuotientStabilizer α x g' 
Arguments: (α : Type u) {β : Type v} [Group α] [MulAction α β] (x : β) (g : α) (g' : α ⧸ MulAction.stabilizer α x)
Goal: MulAction.ofQuotientStabilizer α x (g • g') = g • MulAction.ofQuotientStabilizer α x g'
-- AddAction.injective_ofQuotientStabilizer
@[to_additive]
theorem injective_ofQuotientStabilizer : Function.Injective (ofQuotientStabilizer α x) 
Arguments: (α : Type u) {β : Type v} [AddGroup α] [AddAction α β] (x : β)
Goal: Function.Injective (AddAction.ofQuotientStabilizer α x)
-- MulAction.injective_ofQuotientStabilizer
@[to_additive]
theorem injective_ofQuotientStabilizer : Function.Injective (ofQuotientStabilizer α x) 
Arguments: (α : Type u) {β : Type v} [Group α] [MulAction α β] (x : β)
Goal: Function.Injective (MulAction.ofQuotientStabilizer α x)
-- AddAction.card_orbit_mul_card_stabilizer_eq_card_addGroup
@[to_additive AddAction.card_orbit_mul_card_stabilizer_eq_card_addGroup "Orbit-stabilizer theorem."]
theorem card_orbit_mul_card_stabilizer_eq_card_group (b : β) [Fintype α] [Fintype <| orbit α b]
    [Fintype <| stabilizer α b] :
    Fintype.card (orbit α b) * Fintype.card (stabilizer α b) = Fintype.card α 
Arguments: (α : Type u) {β : Type v} [AddGroup α] [AddAction α β] (b : β) [Fintype α] [Fintype ↑(AddAction.orbit α b)] [Fintype ↥(AddAction.stabilizer α b)]
Goal: Fintype.card ↑(AddAction.orbit α b) * Fintype.card ↥(AddAction.stabilizer α b) = Fintype.card α
-- MulAction.card_orbit_mul_card_stabilizer_eq_card_group
@[to_additive AddAction.card_orbit_mul_card_stabilizer_eq_card_addGroup "Orbit-stabilizer theorem."]
theorem card_orbit_mul_card_stabilizer_eq_card_group (b : β) [Fintype α] [Fintype <| orbit α b]
    [Fintype <| stabilizer α b] :
    Fintype.card (orbit α b) * Fintype.card (stabilizer α b) = Fintype.card α 
Arguments: (α : Type u) {β : Type v} [Group α] [MulAction α β] (b : β) [Fintype α] [Fintype ↑(MulAction.orbit α b)] [Fintype ↥(MulAction.stabilizer α b)]
Goal: Fintype.card ↑(MulAction.orbit α b) * Fintype.card ↥(MulAction.stabilizer α b) = Fintype.card α
-- AddAction.orbitEquivQuotientStabilizer_symm_apply
@[to_additive (attr := simp)]
theorem orbitEquivQuotientStabilizer_symm_apply (b : β) (a : α) :
    ((orbitEquivQuotientStabilizer α b).symm a : β) = a • b 
Arguments: (α : Type u) {β : Type v} [AddGroup α] [AddAction α β] (b : β) (a : α)
Goal: ↑((AddAction.orbitEquivQuotientStabilizer α b).symm ↑a) = a +ᵥ b
-- MulAction.orbitEquivQuotientStabilizer_symm_apply
@[to_additive (attr := simp)]
theorem orbitEquivQuotientStabilizer_symm_apply (b : β) (a : α) :
    ((orbitEquivQuotientStabilizer α b).symm a : β) = a • b 
Arguments: (α : Type u) {β : Type v} [Group α] [MulAction α β] (b : β) (a : α)
Goal: ↑((MulAction.orbitEquivQuotientStabilizer α b).symm ↑a) = a • b
-- MulAction.stabilizer_quotient
@[to_additive (attr := simp)]
theorem stabilizer_quotient {G} [Group G] (H : Subgroup G) :
    MulAction.stabilizer G ((1 : G) : G ⧸ H) = H 
Arguments: {G : Type u_1} [Group G] (H : Subgroup G)
Goal: MulAction.stabilizer G ↑1 = H
-- AddAction.stabilizer_quotient
@[to_additive (attr := simp)]
theorem stabilizer_quotient {G} [Group G] (H : Subgroup G) :
    MulAction.stabilizer G ((1 : G) : G ⧸ H) = H 
Arguments: {G : Type u_1} [AddGroup G] (H : AddSubgroup G)
Goal: AddAction.stabilizer G ↑0 = H
-- MulAction.card_eq_sum_card_group_div_card_stabilizer'
@[to_additive
      "**Class formula** for a finite group acting on a finite type. See
      `AddAction.card_eq_sum_card_addGroup_div_card_stabilizer` for a specialized version using
      `Quotient.out'`."]
theorem card_eq_sum_card_group_div_card_stabilizer' [Fintype α] [Fintype β] [Fintype Ω]
    [∀ b : β, Fintype <| stabilizer α b] {φ : Ω → β} (hφ : LeftInverse Quotient.mk'' φ) :
    Fintype.card β = ∑ ω : Ω, Fintype.card α / Fintype.card (stabilizer α (φ ω)) 
Arguments: (α : Type u) (β : Type v) [Group α] [MulAction α β] [Fintype α] [Fintype β] [Fintype (Quotient (MulAction.orbitRel α β))] [(b : β) → Fintype ↥(MulAction.stabilizer α b)] {φ : Quotient (MulAction.orbitRel α β) → β} (hφ : Function.LeftInverse Quotient.mk'' φ)
Goal: Fintype.card β = ∑ ω : Quotient (MulAction.orbitRel α β), Fintype.card α / Fintype.card ↥(MulAction.stabilizer α (φ ω))
-- AddAction.card_eq_sum_card_addGroup_sub_card_stabilizer'
@[to_additive
      "**Class formula** for a finite group acting on a finite type. See
      `AddAction.card_eq_sum_card_addGroup_div_card_stabilizer` for a specialized version using
      `Quotient.out'`."]
theorem card_eq_sum_card_group_div_card_stabilizer' [Fintype α] [Fintype β] [Fintype Ω]
    [∀ b : β, Fintype <| stabilizer α b] {φ : Ω → β} (hφ : LeftInverse Quotient.mk'' φ) :
    Fintype.card β = ∑ ω : Ω, Fintype.card α / Fintype.card (stabilizer α (φ ω)) 
Arguments: (α : Type u) (β : Type v) [AddGroup α] [AddAction α β] [Fintype α] [Fintype β] [Fintype (Quotient (AddAction.orbitRel α β))] [(b : β) → Fintype ↥(AddAction.stabilizer α b)] {φ : Quotient (AddAction.orbitRel α β) → β} (hφ : Function.LeftInverse Quotient.mk'' φ)
Goal: Fintype.card β = ∑ ω : Quotient (AddAction.orbitRel α β), Fintype.card α / Fintype.card ↥(AddAction.stabilizer α (φ ω))
-- MulAction.card_eq_sum_card_group_div_card_stabilizer
@[to_additive "**Class formula** for a finite group acting on a finite type."]
theorem card_eq_sum_card_group_div_card_stabilizer [Fintype α] [Fintype β] [Fintype Ω]
    [∀ b : β, Fintype <| stabilizer α b] :
    Fintype.card β = ∑ ω : Ω, Fintype.card α / Fintype.card (stabilizer α ω.out') 
Arguments: (α : Type u) (β : Type v) [Group α] [MulAction α β] [Fintype α] [Fintype β] [Fintype (Quotient (MulAction.orbitRel α β))] [(b : β) → Fintype ↥(MulAction.stabilizer α b)]
Goal: Fintype.card β = ∑ ω : Quotient (MulAction.orbitRel α β), Fintype.card α / Fintype.card ↥(MulAction.stabilizer α ω.out')
-- AddAction.card_eq_sum_card_addGroup_sub_card_stabilizer
@[to_additive "**Class formula** for a finite group acting on a finite type."]
theorem card_eq_sum_card_group_div_card_stabilizer [Fintype α] [Fintype β] [Fintype Ω]
    [∀ b : β, Fintype <| stabilizer α b] :
    Fintype.card β = ∑ ω : Ω, Fintype.card α / Fintype.card (stabilizer α ω.out') 
Arguments: (α : Type u) (β : Type v) [AddGroup α] [AddAction α β] [Fintype α] [Fintype β] [Fintype (Quotient (AddAction.orbitRel α β))] [(b : β) → Fintype ↥(AddAction.stabilizer α b)]
Goal: Fintype.card β = ∑ ω : Quotient (AddAction.orbitRel α β), Fintype.card α / Fintype.card ↥(AddAction.stabilizer α ω.out')
-- MulAction.sum_card_fixedBy_eq_card_orbits_mul_card_group
@[to_additive AddAction.sum_card_fixedBy_eq_card_orbits_mul_card_addGroup
      "**Burnside's lemma** : given a finite additive group `G` acting on a set `X`,
      the average number of elements fixed by each `g ∈ G` is the number of orbits. "]
theorem sum_card_fixedBy_eq_card_orbits_mul_card_group [Fintype α] [∀ a : α, Fintype <| fixedBy β a]
    [Fintype Ω] : (∑ a : α, Fintype.card (fixedBy β a)) = Fintype.card Ω * Fintype.card α 
Arguments: (α : Type u) (β : Type v) [Group α] [MulAction α β] [Fintype α] [(a : α) → Fintype ↑(MulAction.fixedBy β a)] [Fintype (Quotient (MulAction.orbitRel α β))]
Goal: ∑ a : α, Fintype.card ↑(MulAction.fixedBy β a) = Fintype.card (Quotient (MulAction.orbitRel α β)) * Fintype.card α
-- AddAction.sum_card_fixedBy_eq_card_orbits_mul_card_addGroup
@[to_additive AddAction.sum_card_fixedBy_eq_card_orbits_mul_card_addGroup
      "**Burnside's lemma** : given a finite additive group `G` acting on a set `X`,
      the average number of elements fixed by each `g ∈ G` is the number of orbits. "]
theorem sum_card_fixedBy_eq_card_orbits_mul_card_group [Fintype α] [∀ a : α, Fintype <| fixedBy β a]
    [Fintype Ω] : (∑ a : α, Fintype.card (fixedBy β a)) = Fintype.card Ω * Fintype.card α 
Arguments: (α : Type u) (β : Type v) [AddGroup α] [AddAction α β] [Fintype α] [(a : α) → Fintype ↑(AddAction.fixedBy β a)] [Fintype (Quotient (AddAction.orbitRel α β))]
Goal: ∑ a : α, Fintype.card ↑(AddAction.fixedBy β a) = Fintype.card (Quotient (AddAction.orbitRel α β)) * Fintype.card α
-- ConjClasses.card_carrier
theorem ConjClasses.card_carrier {G : Type*} [Group G] [Fintype G] (g : G)
    [Fintype (ConjClasses.mk g).carrier] [Fintype <| MulAction.stabilizer (ConjAct G) g] :
    Fintype.card (ConjClasses.mk g).carrier =
      Fintype.card G / Fintype.card (MulAction.stabilizer (ConjAct G) g) 
Arguments: {G : Type u_1} [Group G] [Fintype G] (g : G) [Fintype ↑(ConjClasses.mk g).carrier] [Fintype ↥(MulAction.stabilizer (ConjAct G) g)]
Goal: Fintype.card ↑(ConjClasses.mk g).carrier = Fintype.card G / Fintype.card ↥(MulAction.stabilizer (ConjAct G) g)
-- Subgroup.normalCore_eq_ker
theorem normalCore_eq_ker : H.normalCore = (MulAction.toPermHom G (G ⧸ H)).ker 
Arguments: {G : Type u_1} [Group G] (H : Subgroup G)
Goal: H.normalCore = (MulAction.toPermHom G (G ⧸ H)).ker
-- Subgroup.quotientCentralizerEmbedding_apply
theorem quotientCentralizerEmbedding_apply (g : G) (x : G) :
    quotientCentralizerEmbedding g x = ⟨⁅x, g⁆, x, g, rfl⟩ 
Arguments: {G : Type u_1} [Group G] (g x : G)
Goal: (Subgroup.quotientCentralizerEmbedding g) ↑x = ⟨⁅x, g⁆, ⋯⟩
-- Subgroup.quotientCenterEmbedding_apply
theorem quotientCenterEmbedding_apply {S : Set G} (hS : closure S = ⊤) (g : G) (s : S) :
    quotientCenterEmbedding hS g s = ⟨⁅g, s⁆, g, s, rfl⟩ 
Arguments: {G : Type u_1} [Group G] {S : Set G} (hS : Subgroup.closure S = ⊤) (g : G) (s : ↑S)
Goal: (Subgroup.quotientCenterEmbedding hS) (↑g) s = ⟨⁅g, ↑s⁆, ⋯⟩
-- card_comm_eq_card_conjClasses_mul_card
theorem card_comm_eq_card_conjClasses_mul_card (G : Type*) [Group G] :
    Nat.card { p : G × G // Commute p.1 p.2 } = Nat.card (ConjClasses G) * Nat.card G 
Arguments: (G : Type u_1) [Group G]
Goal: Nat.card { p // Commute p.1 p.2 } = Nat.card (ConjClasses G) * Nat.card G
-- FreeAbelianGroup.lift.of
@[simp]
protected theorem of (x : α) : lift f (of x) = f x 
Arguments: {α : Type u} {β : Type v} [AddCommGroup β] (f : α → β) (x : α)
Goal: (FreeAbelianGroup.lift f) (FreeAbelianGroup.of x) = f x
-- FreeAbelianGroup.lift.unique
protected theorem unique (g : FreeAbelianGroup α →+ β) (hg : ∀ x, g (of x) = f x) {x} :
    g x = lift f x 
Arguments: {α : Type u} {β : Type v} [AddCommGroup β] (f : α → β) (g : FreeAbelianGroup α →+ β) (hg : ∀ (x : α), g (FreeAbelianGroup.of x) = f x) {x : FreeAbelianGroup α}
Goal: g x = (FreeAbelianGroup.lift f) x
-- FreeAbelianGroup.lift.ext
@[ext high]
protected theorem ext (g h : FreeAbelianGroup α →+ β) (H : ∀ x, g (of x) = h (of x)) : g = h 
Arguments: {α : Type u} {β : Type v} [AddCommGroup β] (g h : FreeAbelianGroup α →+ β) (H : ∀ (x : α), g (FreeAbelianGroup.of x) = h (FreeAbelianGroup.of x))
Goal: g = h
-- FreeAbelianGroup.lift.map_hom
theorem map_hom {α β γ} [AddCommGroup β] [AddCommGroup γ] (a : FreeAbelianGroup α) (f : α → β)
    (g : β →+ γ) : g (lift f a) = lift (g ∘ f) a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [AddCommGroup β] [AddCommGroup γ] (a : FreeAbelianGroup α) (f : α → β) (g : β →+ γ)
Goal: g ((FreeAbelianGroup.lift f) a) = (FreeAbelianGroup.lift (⇑g ∘ f)) a
-- FreeAbelianGroup.of_injective
theorem of_injective : Function.Injective (of : α → FreeAbelianGroup α) 
Arguments: {α : Type u}
Goal: Function.Injective FreeAbelianGroup.of
-- FreeAbelianGroup.induction_on
@[elab_as_elim]
protected theorem induction_on {C : FreeAbelianGroup α → Prop} (z : FreeAbelianGroup α) (C0 : C 0)
    (C1 : ∀ x, C <| of x) (Cn : ∀ x, C (of x) → C (-of x)) (Cp : ∀ x y, C x → C y → C (x + y)) :
    C z 
Arguments: {α : Type u} {C : FreeAbelianGroup α → Prop} (z : FreeAbelianGroup α) (C0 : C 0) (C1 : ∀ (x : α), C (FreeAbelianGroup.of x)) (Cn : ∀ (x : α), C (FreeAbelianGroup.of x) → C (-FreeAbelianGroup.of x)) (Cp : ∀ (x y : FreeAbelianGroup α), C x → C y → C (x + y))
Goal: C z
-- FreeAbelianGroup.lift.add'
theorem lift.add' {α β} [AddCommGroup β] (a : FreeAbelianGroup α) (f g : α → β) :
    lift (f + g) a = lift f a + lift g a 
Arguments: {α : Type u_1} {β : Type u_2} [AddCommGroup β] (a : FreeAbelianGroup α) (f g : α → β)
Goal: (FreeAbelianGroup.lift (f + g)) a = (FreeAbelianGroup.lift f) a + (FreeAbelianGroup.lift g) a
-- FreeAbelianGroup.liftAddGroupHom_apply
@[simps!]  -- Porting note: Changed `simps` to `simps!`.
def liftAddGroupHom {α} (β) [AddCommGroup β] (a : FreeAbelianGroup α) : (α → β) →+ β 
Arguments: {α : Type u_1} (β : Type u_2) [AddCommGroup β] (a : FreeAbelianGroup α) (f : α → β)
Goal: (FreeAbelianGroup.liftAddGroupHom β a) f = (FreeAbelianGroup.lift f) a
-- FreeAbelianGroup.lift_neg'
theorem lift_neg' {β} [AddCommGroup β] (f : α → β) : lift (-f) = -lift f 
Arguments: {α : Type u} {β : Type u_1} [AddCommGroup β] (f : α → β)
Goal: FreeAbelianGroup.lift (-f) = -FreeAbelianGroup.lift f
-- FreeAbelianGroup.induction_on'
@[elab_as_elim]
protected theorem induction_on' {C : FreeAbelianGroup α → Prop} (z : FreeAbelianGroup α) (C0 : C 0)
    (C1 : ∀ x, C <| pure x) (Cn : ∀ x, C (pure x) → C (-pure x))
    (Cp : ∀ x y, C x → C y → C (x + y)) : C z 
Arguments: {α : Type u} {C : FreeAbelianGroup α → Prop} (z : FreeAbelianGroup α) (C0 : C 0) (C1 : ∀ (x : α), C (pure x)) (Cn : ∀ (x : α), C (pure x) → C (-pure x)) (Cp : ∀ (x y : FreeAbelianGroup α), C x → C y → C (x + y))
Goal: C z
-- FreeAbelianGroup.map_pure
@[simp]
theorem map_pure (f : α → β) (x : α) : f <$> (pure x : FreeAbelianGroup α) = pure (f x) 
Arguments: {α β : Type u} (f : α → β) (x : α)
Goal: f <$> pure x = pure (f x)
-- FreeAbelianGroup.map_zero
@[simp]
protected theorem map_zero (f : α → β) : f <$> (0 : FreeAbelianGroup α) = 0 
Arguments: {α β : Type u} (f : α → β)
Goal: f <$> 0 = 0
-- FreeAbelianGroup.map_add
@[simp]
protected theorem map_add (f : α → β) (x y : FreeAbelianGroup α) :
    f <$> (x + y) = f <$> x + f <$> y 
Arguments: {α β : Type u} (f : α → β) (x y : FreeAbelianGroup α)
Goal: f <$> (x + y) = f <$> x + f <$> y
-- FreeAbelianGroup.map_neg
@[simp]
protected theorem map_neg (f : α → β) (x : FreeAbelianGroup α) : f <$> (-x) = -f <$> x 
Arguments: {α β : Type u} (f : α → β) (x : FreeAbelianGroup α)
Goal: f <$> (-x) = -f <$> x
-- FreeAbelianGroup.map_sub
@[simp]
protected theorem map_sub (f : α → β) (x y : FreeAbelianGroup α) :
    f <$> (x - y) = f <$> x - f <$> y 
Arguments: {α β : Type u} (f : α → β) (x y : FreeAbelianGroup α)
Goal: f <$> (x - y) = f <$> x - f <$> y
-- FreeAbelianGroup.map_of
@[simp]
theorem map_of (f : α → β) (y : α) : f <$> of y = of (f y) 
Arguments: {α β : Type u} (f : α → β) (y : α)
Goal: f <$> FreeAbelianGroup.of y = FreeAbelianGroup.of (f y)
-- FreeAbelianGroup.pure_bind
theorem pure_bind (f : α → FreeAbelianGroup β) (x) : pure x >>= f = f x 
Arguments: {α β : Type u} (f : α → FreeAbelianGroup β) (x : α)
Goal: pure x >>= f = f x
-- FreeAbelianGroup.zero_bind
@[simp]
theorem zero_bind (f : α → FreeAbelianGroup β) : 0 >>= f = 0 
Arguments: {α β : Type u} (f : α → FreeAbelianGroup β)
Goal: 0 >>= f = 0
-- FreeAbelianGroup.add_bind
@[simp]
theorem add_bind (f : α → FreeAbelianGroup β) (x y : FreeAbelianGroup α) :
    x + y >>= f = (x >>= f) + (y >>= f) 
Arguments: {α β : Type u} (f : α → FreeAbelianGroup β) (x y : FreeAbelianGroup α)
Goal: x + y >>= f = (x >>= f) + (y >>= f)
-- FreeAbelianGroup.neg_bind
@[simp]
theorem neg_bind (f : α → FreeAbelianGroup β) (x : FreeAbelianGroup α) : -x >>= f = -(x >>= f) 
Arguments: {α β : Type u} (f : α → FreeAbelianGroup β) (x : FreeAbelianGroup α)
Goal: -x >>= f = -(x >>= f)
-- FreeAbelianGroup.sub_bind
@[simp]
theorem sub_bind (f : α → FreeAbelianGroup β) (x y : FreeAbelianGroup α) :
    x - y >>= f = (x >>= f) - (y >>= f) 
Arguments: {α β : Type u} (f : α → FreeAbelianGroup β) (x y : FreeAbelianGroup α)
Goal: x - y >>= f = (x >>= f) - (y >>= f)
-- FreeAbelianGroup.pure_seq
@[simp]
theorem pure_seq (f : α → β) (x : FreeAbelianGroup α) : pure f <*> x = f <$> x 
Arguments: {α β : Type u} (f : α → β) (x : FreeAbelianGroup α)
Goal: (Seq.seq (pure f) fun x_1 => x) = f <$> x
-- FreeAbelianGroup.zero_seq
@[simp]
theorem zero_seq (x : FreeAbelianGroup α) : (0 : FreeAbelianGroup (α → β)) <*> x = 0 
Arguments: {α β : Type u} (x : FreeAbelianGroup α)
Goal: (Seq.seq 0 fun x_1 => x) = 0
-- FreeAbelianGroup.add_seq
@[simp]
theorem add_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
    f + g <*> x = (f <*> x) + (g <*> x) 
Arguments: {α β : Type u} (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α)
Goal: (Seq.seq (f + g) fun x_1 => x) = (Seq.seq f fun x_1 => x) + Seq.seq g fun x_1 => x
-- FreeAbelianGroup.neg_seq
@[simp]
theorem neg_seq (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : -f <*> x = -(f <*> x) 
Arguments: {α β : Type u} (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α)
Goal: (Seq.seq (-f) fun x_1 => x) = -Seq.seq f fun x_1 => x
-- FreeAbelianGroup.sub_seq
@[simp]
theorem sub_seq (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) :
    f - g <*> x = (f <*> x) - (g <*> x) 
Arguments: {α β : Type u} (f g : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α)
Goal: (Seq.seq (f - g) fun x_1 => x) = (Seq.seq f fun x_1 => x) - Seq.seq g fun x_1 => x
-- FreeAbelianGroup.seq_zero
@[simp]
theorem seq_zero (f : FreeAbelianGroup (α → β)) : f <*> 0 = 0 
Arguments: {α β : Type u} (f : FreeAbelianGroup (α → β))
Goal: (Seq.seq f fun x => 0) = 0
-- FreeAbelianGroup.seq_add
@[simp]
theorem seq_add (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
    f <*> x + y = (f <*> x) + (f <*> y) 
Arguments: {α β : Type u} (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α)
Goal: (Seq.seq f fun x_1 => x + y) = (Seq.seq f fun x_1 => x) + Seq.seq f fun x => y
-- FreeAbelianGroup.seq_neg
@[simp]
theorem seq_neg (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : f <*> -x = -(f <*> x) 
Arguments: {α β : Type u} (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α)
Goal: (Seq.seq f fun x_1 => -x) = -Seq.seq f fun x_1 => x
-- FreeAbelianGroup.seq_sub
@[simp]
theorem seq_sub (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
    f <*> x - y = (f <*> x) - (f <*> y) 
Arguments: {α β : Type u} (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α)
Goal: (Seq.seq f fun x_1 => x - y) = (Seq.seq f fun x_1 => x) - Seq.seq f fun x => y
-- FreeAbelianGroup.lift_comp
theorem lift_comp {α} {β} {γ} [AddCommGroup γ] (f : α → β) (g : β → γ) (x : FreeAbelianGroup α) :
    lift (g ∘ f) x = lift g (map f x) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [AddCommGroup γ] (f : α → β) (g : β → γ) (x : FreeAbelianGroup α)
Goal: (FreeAbelianGroup.lift (g ∘ f)) x = (FreeAbelianGroup.lift g) ((FreeAbelianGroup.map f) x)
-- FreeAbelianGroup.map_id
theorem map_id : map id = AddMonoidHom.id (FreeAbelianGroup α) 
Arguments: {α : Type u}
Goal: FreeAbelianGroup.map id = AddMonoidHom.id (FreeAbelianGroup α)
-- FreeAbelianGroup.map_id_apply
theorem map_id_apply (x : FreeAbelianGroup α) : map id x = x 
Arguments: {α : Type u} (x : FreeAbelianGroup α)
Goal: (FreeAbelianGroup.map id) x = x
-- FreeAbelianGroup.map_comp
theorem map_comp {f : α → β} {g : β → γ} : map (g ∘ f) = (map g).comp (map f) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {f : α → β} {g : β → γ}
Goal: FreeAbelianGroup.map (g ∘ f) = (FreeAbelianGroup.map g).comp (FreeAbelianGroup.map f)
-- FreeAbelianGroup.map_comp_apply
theorem map_comp_apply {f : α → β} {g : β → γ} (x : FreeAbelianGroup α) :
    map (g ∘ f) x = (map g) ((map f) x) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {f : α → β} {g : β → γ} (x : FreeAbelianGroup α)
Goal: (FreeAbelianGroup.map (g ∘ f)) x = (FreeAbelianGroup.map g) ((FreeAbelianGroup.map f) x)
-- FreeAbelianGroup.map_of_apply
@[simp]
theorem map_of_apply {f : α → β} (a : α) : map f (of a) = of (f a) 
Arguments: {α : Type u} {β : Type v} {f : α → β} (a : α)
Goal: (FreeAbelianGroup.map f) (FreeAbelianGroup.of a) = FreeAbelianGroup.of (f a)
-- FreeAbelianGroup.mul_def
theorem mul_def (x y : FreeAbelianGroup α) :
    x * y = lift (fun x₂ ↦ lift (fun x₁ ↦ of (x₁ * x₂)) x) y 
Arguments: {α : Type u} [Mul α] (x y : FreeAbelianGroup α)
Goal: x * y = (FreeAbelianGroup.lift fun x₂ => (FreeAbelianGroup.lift fun x₁ => FreeAbelianGroup.of (x₁ * x₂)) x) y
-- FreeAbelianGroup.of_mul_of
@[simp]
theorem of_mul_of (x y : α) : of x * of y = of (x * y) 
Arguments: {α : Type u} [Mul α] (x y : α)
Goal: FreeAbelianGroup.of x * FreeAbelianGroup.of y = FreeAbelianGroup.of (x * y)
-- FreeAbelianGroup.of_mul
theorem of_mul (x y : α) : of (x * y) = of x * of y 
Arguments: {α : Type u} [Mul α] (x y : α)
Goal: FreeAbelianGroup.of (x * y) = FreeAbelianGroup.of x * FreeAbelianGroup.of y