ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- FreeAddGroup.quot_liftOn_mk
@[to_additive (attr := simp)]
theorem quot_liftOn_mk (β : Type v) (f : List (α × Bool) → β)
    (H : ∀ L₁ L₂, Red.Step L₁ L₂ → f L₁ = f L₂) : Quot.liftOn (mk L) f H = f L 
Arguments: {α : Type u} {L : List (α × Bool)} (β : Type v) (f : List (α × Bool) → β) (H : ∀ (L₁ L₂ : List (α × Bool)), FreeAddGroup.Red.Step L₁ L₂ → f L₁ = f L₂)
Goal: Quot.liftOn (FreeAddGroup.mk L) f H = f L
-- FreeGroup.quot_map_mk
@[to_additive (attr := simp)]
theorem quot_map_mk (β : Type v) (f : List (α × Bool) → List (β × Bool))
    (H : (Red.Step ⇒ Red.Step) f f) : Quot.map f H (mk L) = mk (f L) 
Arguments: {α : Type u} {L : List (α × Bool)} (β : Type v) (f : List (α × Bool) → List (β × Bool)) (H : (FreeGroup.Red.Step ⇒ FreeGroup.Red.Step) f f)
Goal: Quot.map f H (FreeGroup.mk L) = FreeGroup.mk (f L)
-- FreeAddGroup.quot_map_mk
@[to_additive (attr := simp)]
theorem quot_map_mk (β : Type v) (f : List (α × Bool) → List (β × Bool))
    (H : (Red.Step ⇒ Red.Step) f f) : Quot.map f H (mk L) = mk (f L) 
Arguments: {α : Type u} {L : List (α × Bool)} (β : Type v) (f : List (α × Bool) → List (β × Bool)) (H : (FreeAddGroup.Red.Step ⇒ FreeAddGroup.Red.Step) f f)
Goal: Quot.map f H (FreeAddGroup.mk L) = FreeAddGroup.mk (f L)
-- FreeGroup.one_eq_mk
@[to_additive]
theorem one_eq_mk : (1 : FreeGroup α) = mk [] 
Arguments: {α : Type u}
Goal: 1 = FreeGroup.mk []
-- FreeAddGroup.zero_eq_mk
@[to_additive]
theorem one_eq_mk : (1 : FreeGroup α) = mk [] 
Arguments: {α : Type u}
Goal: 0 = FreeAddGroup.mk []
-- FreeAddGroup.add_mk
@[to_additive (attr := simp)]
theorem mul_mk : mk L₁ * mk L₂ = mk (L₁ ++ L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeAddGroup.mk L₁ + FreeAddGroup.mk L₂ = FreeAddGroup.mk (L₁ ++ L₂)
-- FreeGroup.mul_mk
@[to_additive (attr := simp)]
theorem mul_mk : mk L₁ * mk L₂ = mk (L₁ ++ L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeGroup.mk L₁ * FreeGroup.mk L₂ = FreeGroup.mk (L₁ ++ L₂)
-- FreeAddGroup.negRev_length
@[to_additive (attr := simp)]
theorem invRev_length : (invRev L₁).length = L₁.length 
Arguments: {α : Type u} {L₁ : List (α × Bool)}
Goal: (FreeAddGroup.negRev L₁).length = L₁.length
-- FreeGroup.invRev_length
@[to_additive (attr := simp)]
theorem invRev_length : (invRev L₁).length = L₁.length 
Arguments: {α : Type u} {L₁ : List (α × Bool)}
Goal: (FreeGroup.invRev L₁).length = L₁.length
-- FreeGroup.invRev_invRev
@[to_additive (attr := simp)]
theorem invRev_invRev : invRev (invRev L₁) = L₁ 
Arguments: {α : Type u} {L₁ : List (α × Bool)}
Goal: FreeGroup.invRev (FreeGroup.invRev L₁) = L₁
-- FreeAddGroup.negRev_negRev
@[to_additive (attr := simp)]
theorem invRev_invRev : invRev (invRev L₁) = L₁ 
Arguments: {α : Type u} {L₁ : List (α × Bool)}
Goal: FreeAddGroup.negRev (FreeAddGroup.negRev L₁) = L₁
-- FreeGroup.invRev_empty
@[to_additive (attr := simp)]
theorem invRev_empty : invRev ([] : List (α × Bool)) = [] 
Arguments: {α : Type u}
Goal: FreeGroup.invRev [] = []
-- FreeAddGroup.negRev_empty
@[to_additive (attr := simp)]
theorem invRev_empty : invRev ([] : List (α × Bool)) = [] 
Arguments: {α : Type u}
Goal: FreeAddGroup.negRev [] = []
-- FreeAddGroup.negRev_involutive
@[to_additive]
theorem invRev_involutive : Function.Involutive (@invRev α) 
Arguments: {α : Type u}
Goal: Function.Involutive FreeAddGroup.negRev
-- FreeGroup.invRev_involutive
@[to_additive]
theorem invRev_involutive : Function.Involutive (@invRev α) 
Arguments: {α : Type u}
Goal: Function.Involutive FreeGroup.invRev
-- FreeGroup.invRev_injective
@[to_additive]
theorem invRev_injective : Function.Injective (@invRev α) 
Arguments: {α : Type u}
Goal: Function.Injective FreeGroup.invRev
-- FreeAddGroup.negRev_injective
@[to_additive]
theorem invRev_injective : Function.Injective (@invRev α) 
Arguments: {α : Type u}
Goal: Function.Injective FreeAddGroup.negRev
-- FreeAddGroup.negRev_surjective
@[to_additive]
theorem invRev_surjective : Function.Surjective (@invRev α) 
Arguments: {α : Type u}
Goal: Function.Surjective FreeAddGroup.negRev
-- FreeGroup.invRev_surjective
@[to_additive]
theorem invRev_surjective : Function.Surjective (@invRev α) 
Arguments: {α : Type u}
Goal: Function.Surjective FreeGroup.invRev
-- FreeAddGroup.negRev_bijective
@[to_additive]
theorem invRev_bijective : Function.Bijective (@invRev α) 
Arguments: {α : Type u}
Goal: Function.Bijective FreeAddGroup.negRev
-- FreeGroup.invRev_bijective
@[to_additive]
theorem invRev_bijective : Function.Bijective (@invRev α) 
Arguments: {α : Type u}
Goal: Function.Bijective FreeGroup.invRev
-- FreeGroup.inv_mk
@[to_additive (attr := simp)]
theorem inv_mk : (mk L)⁻¹ = mk (invRev L) 
Arguments: {α : Type u} {L : List (α × Bool)}
Goal: (FreeGroup.mk L)⁻¹ = FreeGroup.mk (FreeGroup.invRev L)
-- FreeAddGroup.neg_mk
@[to_additive (attr := simp)]
theorem inv_mk : (mk L)⁻¹ = mk (invRev L) 
Arguments: {α : Type u} {L : List (α × Bool)}
Goal: -FreeAddGroup.mk L = FreeAddGroup.mk (FreeAddGroup.negRev L)
-- FreeGroup.Red.Step.invRev
@[to_additive]
theorem Red.Step.invRev {L₁ L₂ : List (α × Bool)} (h : Red.Step L₁ L₂) :
    Red.Step (FreeGroup.invRev L₁) (FreeGroup.invRev L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (h : FreeGroup.Red.Step L₁ L₂)
Goal: FreeGroup.Red.Step (FreeGroup.invRev L₁) (FreeGroup.invRev L₂)
-- FreeAddGroup.Red.Step.negRev
@[to_additive]
theorem Red.Step.invRev {L₁ L₂ : List (α × Bool)} (h : Red.Step L₁ L₂) :
    Red.Step (FreeGroup.invRev L₁) (FreeGroup.invRev L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (h : FreeAddGroup.Red.Step L₁ L₂)
Goal: FreeAddGroup.Red.Step (FreeAddGroup.negRev L₁) (FreeAddGroup.negRev L₂)
-- FreeAddGroup.Red.negRev
@[to_additive]
theorem Red.invRev {L₁ L₂ : List (α × Bool)} (h : Red L₁ L₂) : Red (invRev L₁) (invRev L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (h : FreeAddGroup.Red L₁ L₂)
Goal: FreeAddGroup.Red (FreeAddGroup.negRev L₁) (FreeAddGroup.negRev L₂)
-- FreeGroup.Red.invRev
@[to_additive]
theorem Red.invRev {L₁ L₂ : List (α × Bool)} (h : Red L₁ L₂) : Red (invRev L₁) (invRev L₂) 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} (h : FreeGroup.Red L₁ L₂)
Goal: FreeGroup.Red (FreeGroup.invRev L₁) (FreeGroup.invRev L₂)
-- FreeAddGroup.Red.step_negRev_iff
@[to_additive (attr := simp)]
theorem Red.step_invRev_iff :
    Red.Step (FreeGroup.invRev L₁) (FreeGroup.invRev L₂) ↔ Red.Step L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeAddGroup.Red.Step (FreeAddGroup.negRev L₁) (FreeAddGroup.negRev L₂) ↔ FreeAddGroup.Red.Step L₁ L₂
-- FreeGroup.Red.step_invRev_iff
@[to_additive (attr := simp)]
theorem Red.step_invRev_iff :
    Red.Step (FreeGroup.invRev L₁) (FreeGroup.invRev L₂) ↔ Red.Step L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeGroup.Red.Step (FreeGroup.invRev L₁) (FreeGroup.invRev L₂) ↔ FreeGroup.Red.Step L₁ L₂
-- FreeAddGroup.red_negRev_iff
@[to_additive (attr := simp)]
theorem red_invRev_iff : Red (invRev L₁) (invRev L₂) ↔ Red L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeAddGroup.Red (FreeAddGroup.negRev L₁) (FreeAddGroup.negRev L₂) ↔ FreeAddGroup.Red L₁ L₂
-- FreeGroup.red_invRev_iff
@[to_additive (attr := simp)]
theorem red_invRev_iff : Red (invRev L₁) (invRev L₂) ↔ Red L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeGroup.Red (FreeGroup.invRev L₁) (FreeGroup.invRev L₂) ↔ FreeGroup.Red L₁ L₂
-- FreeGroup.Red.exact
@[to_additive]
theorem Red.exact : mk L₁ = mk L₂ ↔ Join Red L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeGroup.mk L₁ = FreeGroup.mk L₂ ↔ Relation.Join FreeGroup.Red L₁ L₂
-- FreeAddGroup.Red.exact
@[to_additive]
theorem Red.exact : mk L₁ = mk L₂ ↔ Join Red L₁ L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)}
Goal: FreeAddGroup.mk L₁ = FreeAddGroup.mk L₂ ↔ Relation.Join FreeAddGroup.Red L₁ L₂
-- FreeAddGroup.of_injective
@[to_additive "The canonical map from the type to the additive free group is an injection."]
theorem of_injective : Function.Injective (@of α) 
Arguments: {α : Type u}
Goal: Function.Injective FreeAddGroup.of
-- FreeGroup.of_injective
@[to_additive "The canonical map from the type to the additive free group is an injection."]
theorem of_injective : Function.Injective (@of α) 
Arguments: {α : Type u}
Goal: Function.Injective FreeGroup.of
-- FreeAddGroup.Red.Step.lift
@[to_additive]
theorem Red.Step.lift {f : α → β} (H : Red.Step L₁ L₂) : Lift.aux f L₁ = Lift.aux f L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} {β : Type v} [AddGroup β] {f : α → β} (H : FreeAddGroup.Red.Step L₁ L₂)
Goal: FreeAddGroup.Lift.aux f L₁ = FreeAddGroup.Lift.aux f L₂
-- FreeGroup.Red.Step.lift
@[to_additive]
theorem Red.Step.lift {f : α → β} (H : Red.Step L₁ L₂) : Lift.aux f L₁ = Lift.aux f L₂ 
Arguments: {α : Type u} {L₁ L₂ : List (α × Bool)} {β : Type v} [Group β] {f : α → β} (H : FreeGroup.Red.Step L₁ L₂)
Goal: FreeGroup.Lift.aux f L₁ = FreeGroup.Lift.aux f L₂
-- FreeGroup.lift_symm_apply
@[to_additive (attr := simps symm_apply)
  "If `β` is an additive group, then any function from `α` to `β` extends uniquely to an
  additive group homomorphism from the free additive group over `α` to `β`"]
def lift : (α → β) ≃ (FreeGroup α →* β) 
Arguments: {α : Type u} {β : Type v} [Group β] (g : FreeGroup α →* β)
Goal: ∀ (a : α), FreeGroup.lift.symm g a = (⇑g ∘ FreeGroup.of) a
-- FreeAddGroup.lift_symm_apply
@[to_additive (attr := simps symm_apply)
  "If `β` is an additive group, then any function from `α` to `β` extends uniquely to an
  additive group homomorphism from the free additive group over `α` to `β`"]
def lift : (α → β) ≃ (FreeGroup α →* β) 
Arguments: {α : Type u} {β : Type v} [AddGroup β] (g : FreeAddGroup α →+ β)
Goal: ∀ (a : α), FreeAddGroup.lift.symm g a = (⇑g ∘ FreeAddGroup.of) a
-- FreeAddGroup.lift.mk
@[to_additive (attr := simp)]
theorem lift.mk : lift f (mk L) = List.prod (L.map fun x => cond x.2 (f x.1) (f x.1)⁻¹) 
Arguments: {α : Type u} {L : List (α × Bool)} {β : Type v} [AddGroup β] {f : α → β}
Goal: (FreeAddGroup.lift f) (FreeAddGroup.mk L) = (List.map (fun x => bif x.2 then f x.1 else -f x.1) L).sum
-- FreeGroup.lift.mk
@[to_additive (attr := simp)]
theorem lift.mk : lift f (mk L) = List.prod (L.map fun x => cond x.2 (f x.1) (f x.1)⁻¹) 
Arguments: {α : Type u} {L : List (α × Bool)} {β : Type v} [Group β] {f : α → β}
Goal: (FreeGroup.lift f) (FreeGroup.mk L) = (List.map (fun x => bif x.2 then f x.1 else (f x.1)⁻¹) L).prod
-- FreeGroup.lift.of
@[to_additive (attr := simp)]
theorem lift.of {x} : lift f (of x) = f x 
Arguments: {α : Type u} {β : Type v} [Group β] {f : α → β} {x : α}
Goal: (FreeGroup.lift f) (FreeGroup.of x) = f x
-- FreeAddGroup.lift.of
@[to_additive (attr := simp)]
theorem lift.of {x} : lift f (of x) = f x 
Arguments: {α : Type u} {β : Type v} [AddGroup β] {f : α → β} {x : α}
Goal: (FreeAddGroup.lift f) (FreeAddGroup.of x) = f x
-- FreeAddGroup.lift.unique
@[to_additive]
theorem lift.unique (g : FreeGroup α →* β) (hg : ∀ x, g (FreeGroup.of x) = f x) {x} :
    g x = FreeGroup.lift f x 
Arguments: {α : Type u} {β : Type v} [AddGroup β] {f : α → β} (g : FreeAddGroup α →+ β) (hg : ∀ (x : α), g (FreeAddGroup.of x) = f x) {x : FreeAddGroup α}
Goal: g x = (FreeAddGroup.lift f) x
-- FreeGroup.lift.unique
@[to_additive]
theorem lift.unique (g : FreeGroup α →* β) (hg : ∀ x, g (FreeGroup.of x) = f x) {x} :
    g x = FreeGroup.lift f x 
Arguments: {α : Type u} {β : Type v} [Group β] {f : α → β} (g : FreeGroup α →* β) (hg : ∀ (x : α), g (FreeGroup.of x) = f x) {x : FreeGroup α}
Goal: g x = (FreeGroup.lift f) x
-- FreeGroup.ext_hom
@[to_additive (attr := ext) "Two homomorphisms out of a free additive group are equal if they are
  equal on generators. See note [partially-applied ext lemmas]."]
theorem ext_hom {G : Type*} [Group G] (f g : FreeGroup α →* G) (h : ∀ a, f (of a) = g (of a)) :
    f = g 
Arguments: {α : Type u} {G : Type u_1} [Group G] (f g : FreeGroup α →* G) (h : ∀ (a : α), f (FreeGroup.of a) = g (FreeGroup.of a))
Goal: f = g
-- FreeAddGroup.ext_hom
@[to_additive (attr := ext) "Two homomorphisms out of a free additive group are equal if they are
  equal on generators. See note [partially-applied ext lemmas]."]
theorem ext_hom {G : Type*} [Group G] (f g : FreeGroup α →* G) (h : ∀ a, f (of a) = g (of a)) :
    f = g 
Arguments: {α : Type u} {G : Type u_1} [AddGroup G] (f g : FreeAddGroup α →+ G) (h : ∀ (a : α), f (FreeAddGroup.of a) = g (FreeAddGroup.of a))
Goal: f = g
-- FreeGroup.lift_of_eq_id
@[to_additive]
theorem lift_of_eq_id (α) : lift of = MonoidHom.id (FreeGroup α) 
Arguments: (α : Type u_1)
Goal: FreeGroup.lift FreeGroup.of = MonoidHom.id (FreeGroup α)
-- FreeAddGroup.lift_of_eq_id
@[to_additive]
theorem lift_of_eq_id (α) : lift of = MonoidHom.id (FreeGroup α) 
Arguments: (α : Type u_1)
Goal: FreeAddGroup.lift FreeAddGroup.of = AddMonoidHom.id (FreeAddGroup α)
-- FreeGroup.lift.of_eq
@[to_additive]
theorem lift.of_eq (x : FreeGroup α) : lift FreeGroup.of x = x 
Arguments: {α : Type u} (x : FreeGroup α)
Goal: (FreeGroup.lift FreeGroup.of) x = x
-- FreeAddGroup.lift.of_eq
@[to_additive]
theorem lift.of_eq (x : FreeGroup α) : lift FreeGroup.of x = x 
Arguments: {α : Type u} (x : FreeAddGroup α)
Goal: (FreeAddGroup.lift FreeAddGroup.of) x = x
-- FreeGroup.lift.range_le
@[to_additive]
theorem lift.range_le {s : Subgroup β} (H : Set.range f ⊆ s) : (lift f).range ≤ s 
Arguments: {α : Type u} {β : Type v} [Group β] {f : α → β} {s : Subgroup β} (H : Set.range f ⊆ ↑s)
Goal: (FreeGroup.lift f).range ≤ s
-- FreeAddGroup.lift.range_le
@[to_additive]
theorem lift.range_le {s : Subgroup β} (H : Set.range f ⊆ s) : (lift f).range ≤ s 
Arguments: {α : Type u} {β : Type v} [AddGroup β] {f : α → β} {s : AddSubgroup β} (H : Set.range f ⊆ ↑s)
Goal: (FreeAddGroup.lift f).range ≤ s
-- FreeGroup.lift.range_eq_closure
@[to_additive]
theorem lift.range_eq_closure : (lift f).range = Subgroup.closure (Set.range f) 
Arguments: {α : Type u} {β : Type v} [Group β] {f : α → β}
Goal: (FreeGroup.lift f).range = Subgroup.closure (Set.range f)
-- FreeAddGroup.lift.range_eq_closure
@[to_additive]
theorem lift.range_eq_closure : (lift f).range = Subgroup.closure (Set.range f) 
Arguments: {α : Type u} {β : Type v} [AddGroup β] {f : α → β}
Goal: (FreeAddGroup.lift f).range = AddSubgroup.closure (Set.range f)
-- FreeGroup.closure_range_of
@[to_additive (attr := simp)]
theorem closure_range_of (α) :
    Subgroup.closure (Set.range (FreeGroup.of : α → FreeGroup α)) = ⊤ 
Arguments: (α : Type u_1)
Goal: Subgroup.closure (Set.range FreeGroup.of) = ⊤
-- FreeAddGroup.closure_range_of
@[to_additive (attr := simp)]
theorem closure_range_of (α) :
    Subgroup.closure (Set.range (FreeGroup.of : α → FreeGroup α)) = ⊤ 
Arguments: (α : Type u_1)
Goal: AddSubgroup.closure (Set.range FreeAddGroup.of) = ⊤
-- FreeGroup.map.mk
@[to_additive (attr := simp)]
theorem map.mk : map f (mk L) = mk (L.map fun x => (f x.1, x.2)) 
Arguments: {α : Type u} {L : List (α × Bool)} {β : Type v} {f : α → β}
Goal: (FreeGroup.map f) (FreeGroup.mk L) = FreeGroup.mk (List.map (fun x => (f x.1, x.2)) L)
-- FreeAddGroup.map.mk
@[to_additive (attr := simp)]
theorem map.mk : map f (mk L) = mk (L.map fun x => (f x.1, x.2)) 
Arguments: {α : Type u} {L : List (α × Bool)} {β : Type v} {f : α → β}
Goal: (FreeAddGroup.map f) (FreeAddGroup.mk L) = FreeAddGroup.mk (List.map (fun x => (f x.1, x.2)) L)
-- FreeGroup.map.id
@[to_additive (attr := simp)]
theorem map.id (x : FreeGroup α) : map id x = x 
Arguments: {α : Type u} (x : FreeGroup α)
Goal: (FreeGroup.map id) x = x
-- FreeAddGroup.map.id
@[to_additive (attr := simp)]
theorem map.id (x : FreeGroup α) : map id x = x 
Arguments: {α : Type u} (x : FreeAddGroup α)
Goal: (FreeAddGroup.map id) x = x
-- FreeGroup.map.id'
@[to_additive (attr := simp)]
theorem map.id' (x : FreeGroup α) : map (fun z => z) x = x 
Arguments: {α : Type u} (x : FreeGroup α)
Goal: (FreeGroup.map fun z => z) x = x
-- FreeAddGroup.map.id'
@[to_additive (attr := simp)]
theorem map.id' (x : FreeGroup α) : map (fun z => z) x = x 
Arguments: {α : Type u} (x : FreeAddGroup α)
Goal: (FreeAddGroup.map fun z => z) x = x
-- FreeAddGroup.map.comp
@[to_additive]
theorem map.comp {γ : Type w} (f : α → β) (g : β → γ) (x) :
    map g (map f x) = map (g ∘ f) x 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α → β) (g : β → γ) (x : FreeAddGroup α)
Goal: (FreeAddGroup.map g) ((FreeAddGroup.map f) x) = (FreeAddGroup.map (g ∘ f)) x
-- FreeGroup.map.comp
@[to_additive]
theorem map.comp {γ : Type w} (f : α → β) (g : β → γ) (x) :
    map g (map f x) = map (g ∘ f) x 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α → β) (g : β → γ) (x : FreeGroup α)
Goal: (FreeGroup.map g) ((FreeGroup.map f) x) = (FreeGroup.map (g ∘ f)) x
-- FreeAddGroup.map.of
@[to_additive (attr := simp)]
theorem map.of {x} : map f (of x) = of (f x) 
Arguments: {α : Type u} {β : Type v} {f : α → β} {x : α}
Goal: (FreeAddGroup.map f) (FreeAddGroup.of x) = FreeAddGroup.of (f x)
-- FreeGroup.map.of
@[to_additive (attr := simp)]
theorem map.of {x} : map f (of x) = of (f x) 
Arguments: {α : Type u} {β : Type v} {f : α → β} {x : α}
Goal: (FreeGroup.map f) (FreeGroup.of x) = FreeGroup.of (f x)
-- FreeAddGroup.map.unique
@[to_additive]
theorem map.unique (g : FreeGroup α →* FreeGroup β)
    (hg : ∀ x, g (FreeGroup.of x) = FreeGroup.of (f x)) :
    ∀ {x}, g x = map f x 
Arguments: {α : Type u} {β : Type v} {f : α → β} (g : FreeAddGroup α →+ FreeAddGroup β) (hg : ∀ (x : α), g (FreeAddGroup.of x) = FreeAddGroup.of (f x)) {x : FreeAddGroup α}
Goal: g x = (FreeAddGroup.map f) x
-- FreeGroup.map.unique
@[to_additive]
theorem map.unique (g : FreeGroup α →* FreeGroup β)
    (hg : ∀ x, g (FreeGroup.of x) = FreeGroup.of (f x)) :
    ∀ {x}, g x = map f x 
Arguments: {α : Type u} {β : Type v} {f : α → β} (g : FreeGroup α →* FreeGroup β) (hg : ∀ (x : α), g (FreeGroup.of x) = FreeGroup.of (f x)) {x : FreeGroup α}
Goal: g x = (FreeGroup.map f) x
-- FreeGroup.map_eq_lift
@[to_additive]
theorem map_eq_lift : map f x = lift (of ∘ f) x 
Arguments: {α : Type u} {β : Type v} {f : α → β} {x : FreeGroup α}
Goal: (FreeGroup.map f) x = (FreeGroup.lift (FreeGroup.of ∘ f)) x
-- FreeAddGroup.map_eq_lift
@[to_additive]
theorem map_eq_lift : map f x = lift (of ∘ f) x 
Arguments: {α : Type u} {β : Type v} {f : α → β} {x : FreeAddGroup α}
Goal: (FreeAddGroup.map f) x = (FreeAddGroup.lift (FreeAddGroup.of ∘ f)) x
-- FreeGroup.freeGroupCongr_apply
@[to_additive (attr := simps apply)
  "Equivalent types give rise to additively equivalent additive free groups."]
def freeGroupCongr {α β} (e : α ≃ β) : FreeGroup α ≃* FreeGroup β 
Arguments: {α : Type u_1} {β : Type u_2} (e : α ≃ β) (a : FreeGroup α)
Goal: (FreeGroup.freeGroupCongr e) a = (FreeGroup.map ⇑e) a
-- FreeAddGroup.freeAddGroupCongr_apply
@[to_additive (attr := simps apply)
  "Equivalent types give rise to additively equivalent additive free groups."]
def freeGroupCongr {α β} (e : α ≃ β) : FreeGroup α ≃* FreeGroup β 
Arguments: {α : Type u_1} {β : Type u_2} (e : α ≃ β) (a : FreeAddGroup α)
Goal: (FreeAddGroup.freeAddGroupCongr e) a = (FreeAddGroup.map ⇑e) a
-- FreeAddGroup.freeAddGroupCongr_refl
@[to_additive (attr := simp)]
theorem freeGroupCongr_refl : freeGroupCongr (Equiv.refl α) = MulEquiv.refl _ 
Arguments: {α : Type u}
Goal: FreeAddGroup.freeAddGroupCongr (Equiv.refl α) = AddEquiv.refl (FreeAddGroup α)
-- FreeGroup.freeGroupCongr_refl
@[to_additive (attr := simp)]
theorem freeGroupCongr_refl : freeGroupCongr (Equiv.refl α) = MulEquiv.refl _ 
Arguments: {α : Type u}
Goal: FreeGroup.freeGroupCongr (Equiv.refl α) = MulEquiv.refl (FreeGroup α)
-- FreeAddGroup.freeAddGroupCongr_symm
@[to_additive (attr := simp)]
theorem freeGroupCongr_symm {α β} (e : α ≃ β) : (freeGroupCongr e).symm = freeGroupCongr e.symm 
Arguments: {α : Type u_1} {β : Type u_2} (e : α ≃ β)
Goal: (FreeAddGroup.freeAddGroupCongr e).symm = FreeAddGroup.freeAddGroupCongr e.symm
-- FreeGroup.freeGroupCongr_symm
@[to_additive (attr := simp)]
theorem freeGroupCongr_symm {α β} (e : α ≃ β) : (freeGroupCongr e).symm = freeGroupCongr e.symm 
Arguments: {α : Type u_1} {β : Type u_2} (e : α ≃ β)
Goal: (FreeGroup.freeGroupCongr e).symm = FreeGroup.freeGroupCongr e.symm
-- FreeAddGroup.freeAddGroupCongr_trans
@[to_additive]
theorem freeGroupCongr_trans {α β γ} (e : α ≃ β) (f : β ≃ γ) :
    (freeGroupCongr e).trans (freeGroupCongr f) = freeGroupCongr (e.trans f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (f : β ≃ γ)
Goal: (FreeAddGroup.freeAddGroupCongr e).trans (FreeAddGroup.freeAddGroupCongr f) = FreeAddGroup.freeAddGroupCongr (e.trans f)
-- FreeGroup.freeGroupCongr_trans
@[to_additive]
theorem freeGroupCongr_trans {α β γ} (e : α ≃ β) (f : β ≃ γ) :
    (freeGroupCongr e).trans (freeGroupCongr f) = freeGroupCongr (e.trans f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (f : β ≃ γ)
Goal: (FreeGroup.freeGroupCongr e).trans (FreeGroup.freeGroupCongr f) = FreeGroup.freeGroupCongr (e.trans f)
-- FreeAddGroup.sum_mk
@[to_additive (attr := simp)]
theorem prod_mk : prod (mk L) = List.prod (L.map fun x => cond x.2 x.1 x.1⁻¹) 
Arguments: {α : Type u} {L : List (α × Bool)} [AddGroup α]
Goal: FreeAddGroup.sum (FreeAddGroup.mk L) = (List.map (fun x => bif x.2 then x.1 else -x.1) L).sum
-- FreeGroup.prod_mk
@[to_additive (attr := simp)]
theorem prod_mk : prod (mk L) = List.prod (L.map fun x => cond x.2 x.1 x.1⁻¹) 
Arguments: {α : Type u} {L : List (α × Bool)} [Group α]
Goal: FreeGroup.prod (FreeGroup.mk L) = (List.map (fun x => bif x.2 then x.1 else x.1⁻¹) L).prod
-- FreeGroup.prod.of
@[to_additive (attr := simp)]
theorem prod.of {x : α} : prod (of x) = x 
Arguments: {α : Type u} [Group α] {x : α}
Goal: FreeGroup.prod (FreeGroup.of x) = x
-- FreeAddGroup.sum.of
@[to_additive (attr := simp)]
theorem prod.of {x : α} : prod (of x) = x 
Arguments: {α : Type u} [AddGroup α] {x : α}
Goal: FreeAddGroup.sum (FreeAddGroup.of x) = x
-- FreeGroup.prod.unique
@[to_additive]
theorem prod.unique (g : FreeGroup α →* α) (hg : ∀ x, g (FreeGroup.of x) = x) {x} : g x = prod x 
Arguments: {α : Type u} [Group α] (g : FreeGroup α →* α) (hg : ∀ (x : α), g (FreeGroup.of x) = x) {x : FreeGroup α}
Goal: g x = FreeGroup.prod x
-- FreeAddGroup.sum.unique
@[to_additive]
theorem prod.unique (g : FreeGroup α →* α) (hg : ∀ x, g (FreeGroup.of x) = x) {x} : g x = prod x 
Arguments: {α : Type u} [AddGroup α] (g : FreeAddGroup α →+ α) (hg : ∀ (x : α), g (FreeAddGroup.of x) = x) {x : FreeAddGroup α}
Goal: g x = FreeAddGroup.sum x
-- FreeGroup.lift_eq_prod_map
@[to_additive]
theorem lift_eq_prod_map {β : Type v} [Group β] {f : α → β} {x} : lift f x = prod (map f x) 
Arguments: {α : Type u} {β : Type v} [Group β] {f : α → β} {x : FreeGroup α}
Goal: (FreeGroup.lift f) x = FreeGroup.prod ((FreeGroup.map f) x)
-- FreeAddGroup.lift_eq_sum_map
@[to_additive]
theorem lift_eq_prod_map {β : Type v} [Group β] {f : α → β} {x} : lift f x = prod (map f x) 
Arguments: {α : Type u} {β : Type v} [AddGroup β] {f : α → β} {x : FreeAddGroup α}
Goal: (FreeAddGroup.lift f) x = FreeAddGroup.sum ((FreeAddGroup.map f) x)
-- FreeGroup.sum_mk
@[simp]
theorem sum_mk : sum (mk L) = List.sum (L.map fun x => cond x.2 x.1 (-x.1)) 
Arguments: {α : Type u} {L : List (α × Bool)} [AddGroup α]
Goal: (FreeGroup.mk L).sum = (List.map (fun x => bif x.2 then x.1 else -x.1) L).sum
-- FreeGroup.sum.of
@[simp]
theorem sum.of {x : α} : sum (of x) = x 
Arguments: {α : Type u} [AddGroup α] {x : α}
Goal: (FreeGroup.of x).sum = x
-- FreeGroup.sum.map_mul
@[simp]
theorem sum.map_mul : sum (x * y) = sum x + sum y 
Arguments: {α : Type u} [AddGroup α] {x y : FreeGroup α}
Goal: (x * y).sum = x.sum + y.sum
-- FreeGroup.sum.map_one
@[simp]
theorem sum.map_one : sum (1 : FreeGroup α) = 0 
Arguments: {α : Type u} [AddGroup α]
Goal: FreeGroup.sum 1 = 0
-- FreeGroup.sum.map_inv
@[simp]
theorem sum.map_inv : sum x⁻¹ = -sum x 
Arguments: {α : Type u} [AddGroup α] {x : FreeGroup α}
Goal: x⁻¹.sum = -x.sum
-- FreeAddGroup.induction_on
@[to_additive (attr := elab_as_elim, induction_eliminator)]
protected theorem induction_on {C : FreeGroup α → Prop} (z : FreeGroup α) (C1 : C 1)
    (Cp : ∀ x, C <| pure x) (Ci : ∀ x, C (pure x) → C (pure x)⁻¹)
    (Cm : ∀ x y, C x → C y → C (x * y)) : C z 
Arguments: {α : Type u} {C : FreeAddGroup α → Prop} (z : FreeAddGroup α) (C1 : C 0) (Cp : ∀ (x : α), C (pure x)) (Ci : ∀ (x : α), C (pure x) → C (-pure x)) (Cm : ∀ (x y : FreeAddGroup α), C x → C y → C (x + y))
Goal: C z