ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- RingEquiv.toSemilinearEquiv_apply
@[simps]
def _root_.RingEquiv.toSemilinearEquiv (f : R ≃+* S) :
    haveI := RingHomInvPair.of_ringEquiv f
    haveI := RingHomInvPair.symm (↑f : R →+* S) (f.symm : S →+* R)
    R ≃ₛₗ[(↑f : R →+* S)] S 
Arguments: {R : Type u_1} {S : Type u_7} [Semiring R] [Semiring S] (f : R ≃+* S) (a : R)
Goal: f.toSemilinearEquiv a = f a
-- RingEquiv.toSemilinearEquiv_symm_apply
@[simps]
def _root_.RingEquiv.toSemilinearEquiv (f : R ≃+* S) :
    haveI := RingHomInvPair.of_ringEquiv f
    haveI := RingHomInvPair.symm (↑f : R →+* S) (f.symm : S →+* R)
    R ≃ₛₗ[(↑f : R →+* S)] S 
Arguments: {R : Type u_1} {S : Type u_7} [Semiring R] [Semiring S] (f : R ≃+* S)
Goal: ∀ (a : S), f.toSemilinearEquiv.symm a = f.invFun a
-- LinearEquiv.coe_ofInvolutive
@[simp]
theorem coe_ofInvolutive {σ σ' : R →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ]
    {_ : Module R M} (f : M →ₛₗ[σ] M) (hf : Involutive f) : ⇑(ofInvolutive f hf) = f 
Arguments: {R : Type u_1} {M : Type u_8} [Semiring R] [AddCommMonoid M] {σ σ' : R →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ]
Goal: ∀ {x : Module R M} (f : M →ₛₗ[σ] M) (hf : Function.Involutive ⇑f), ⇑(LinearEquiv.ofInvolutive f hf) = ⇑f
-- MvPolynomial.expand_C
theorem expand_C (p : ℕ) (r : R) : expand p (C r : MvPolynomial σ R) = C r 
Arguments: {σ : Type u_1} {R : Type u_3} [CommSemiring R] (p : ℕ) (r : R)
Goal: (MvPolynomial.expand p) (MvPolynomial.C r) = MvPolynomial.C r
-- MvPolynomial.expand_X
@[simp]
theorem expand_X (p : ℕ) (i : σ) : expand p (X i : MvPolynomial σ R) = X i ^ p 
Arguments: {σ : Type u_1} {R : Type u_3} [CommSemiring R] (p : ℕ) (i : σ)
Goal: (MvPolynomial.expand p) (MvPolynomial.X i) = MvPolynomial.X i ^ p
-- MvPolynomial.expand_monomial
@[simp]
theorem expand_monomial (p : ℕ) (d : σ →₀ ℕ) (r : R) :
    expand p (monomial d r) = C r * ∏ i ∈ d.support, (X i ^ p) ^ d i 
Arguments: {σ : Type u_1} {R : Type u_3} [CommSemiring R] (p : ℕ) (d : σ →₀ ℕ) (r : R)
Goal: (MvPolynomial.expand p) ((MvPolynomial.monomial d) r) = MvPolynomial.C r * ∏ i ∈ d.support, (MvPolynomial.X i ^ p) ^ d i
-- MvPolynomial.expand_one_apply
theorem expand_one_apply (f : MvPolynomial σ R) : expand 1 f = f 
Arguments: {σ : Type u_1} {R : Type u_3} [CommSemiring R] (f : MvPolynomial σ R)
Goal: (MvPolynomial.expand 1) f = f
-- MvPolynomial.expand_one
@[simp]
theorem expand_one : expand 1 = AlgHom.id R (MvPolynomial σ R) 
Arguments: {σ : Type u_1} {R : Type u_3} [CommSemiring R]
Goal: MvPolynomial.expand 1 = AlgHom.id R (MvPolynomial σ R)
-- MvPolynomial.expand_comp_bind₁
theorem expand_comp_bind₁ (p : ℕ) (f : σ → MvPolynomial τ R) :
    (expand p).comp (bind₁ f) = bind₁ fun i ↦ expand p (f i) 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_3} [CommSemiring R] (p : ℕ) (f : σ → MvPolynomial τ R)
Goal: (MvPolynomial.expand p).comp (MvPolynomial.bind₁ f) = MvPolynomial.bind₁ fun i => (MvPolynomial.expand p) (f i)
-- MvPolynomial.expand_bind₁
theorem expand_bind₁ (p : ℕ) (f : σ → MvPolynomial τ R) (φ : MvPolynomial σ R) :
    expand p (bind₁ f φ) = bind₁ (fun i ↦ expand p (f i)) φ 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_3} [CommSemiring R] (p : ℕ) (f : σ → MvPolynomial τ R) (φ : MvPolynomial σ R)
Goal: (MvPolynomial.expand p) ((MvPolynomial.bind₁ f) φ) = (MvPolynomial.bind₁ fun i => (MvPolynomial.expand p) (f i)) φ
-- MvPolynomial.map_expand
@[simp]
theorem map_expand (f : R →+* S) (p : ℕ) (φ : MvPolynomial σ R) :
    map f (expand p φ) = expand p (map f φ) 
Arguments: {σ : Type u_1} {R : Type u_3} {S : Type u_4} [CommSemiring R] [CommSemiring S] (f : R →+* S) (p : ℕ) (φ : MvPolynomial σ R)
Goal: (MvPolynomial.map f) ((MvPolynomial.expand p) φ) = (MvPolynomial.expand p) ((MvPolynomial.map f) φ)
-- MvPolynomial.rename_expand
@[simp]
theorem rename_expand (f : σ → τ) (p : ℕ) (φ : MvPolynomial σ R) :
    rename f (expand p φ) = expand p (rename f φ) 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_3} [CommSemiring R] (f : σ → τ) (p : ℕ) (φ : MvPolynomial σ R)
Goal: (MvPolynomial.rename f) ((MvPolynomial.expand p) φ) = (MvPolynomial.expand p) ((MvPolynomial.rename f) φ)
-- MvPolynomial.rename_comp_expand
@[simp]
theorem rename_comp_expand (f : σ → τ) (p : ℕ) :
    (rename f).comp (expand p) =
      (expand p).comp (rename f : MvPolynomial σ R →ₐ[R] MvPolynomial τ R) 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_3} [CommSemiring R] (f : σ → τ) (p : ℕ)
Goal: (MvPolynomial.rename f).comp (MvPolynomial.expand p) = (MvPolynomial.expand p).comp (MvPolynomial.rename f)
-- FreeMonoid.toList_symm
@[to_additive (attr := simp)]
theorem toList_symm : (@toList α).symm = ofList 
Arguments: {α : Type u_1}
Goal: FreeMonoid.toList.symm = FreeMonoid.ofList
-- FreeAddMonoid.toList_symm
@[to_additive (attr := simp)]
theorem toList_symm : (@toList α).symm = ofList 
Arguments: {α : Type u_1}
Goal: FreeAddMonoid.toList.symm = FreeAddMonoid.ofList
-- FreeMonoid.ofList_symm
@[to_additive (attr := simp)]
theorem ofList_symm : (@ofList α).symm = toList 
Arguments: {α : Type u_1}
Goal: FreeMonoid.ofList.symm = FreeMonoid.toList
-- FreeAddMonoid.ofList_symm
@[to_additive (attr := simp)]
theorem ofList_symm : (@ofList α).symm = toList 
Arguments: {α : Type u_1}
Goal: FreeAddMonoid.ofList.symm = FreeAddMonoid.toList
-- FreeAddMonoid.toList_ofList
@[to_additive (attr := simp)]
theorem toList_ofList (l : List α) : toList (ofList l) = l 
Arguments: {α : Type u_1} (l : List α)
Goal: FreeAddMonoid.toList (FreeAddMonoid.ofList l) = l
-- FreeMonoid.toList_ofList
@[to_additive (attr := simp)]
theorem toList_ofList (l : List α) : toList (ofList l) = l 
Arguments: {α : Type u_1} (l : List α)
Goal: FreeMonoid.toList (FreeMonoid.ofList l) = l
-- FreeAddMonoid.ofList_toList
@[to_additive (attr := simp)]
theorem ofList_toList (xs : FreeMonoid α) : ofList (toList xs) = xs 
Arguments: {α : Type u_1} (xs : FreeAddMonoid α)
Goal: FreeAddMonoid.ofList (FreeAddMonoid.toList xs) = xs
-- FreeMonoid.ofList_toList
@[to_additive (attr := simp)]
theorem ofList_toList (xs : FreeMonoid α) : ofList (toList xs) = xs 
Arguments: {α : Type u_1} (xs : FreeMonoid α)
Goal: FreeMonoid.ofList (FreeMonoid.toList xs) = xs
-- FreeMonoid.toList_comp_ofList
@[to_additive (attr := simp)]
theorem toList_comp_ofList : @toList α ∘ ofList = id 
Arguments: {α : Type u_1}
Goal: ⇑FreeMonoid.toList ∘ ⇑FreeMonoid.ofList = id
-- FreeAddMonoid.toList_comp_ofList
@[to_additive (attr := simp)]
theorem toList_comp_ofList : @toList α ∘ ofList = id 
Arguments: {α : Type u_1}
Goal: ⇑FreeAddMonoid.toList ∘ ⇑FreeAddMonoid.ofList = id
-- FreeAddMonoid.ofList_comp_toList
@[to_additive (attr := simp)]
theorem ofList_comp_toList : @ofList α ∘ toList = id 
Arguments: {α : Type u_1}
Goal: ⇑FreeAddMonoid.ofList ∘ ⇑FreeAddMonoid.toList = id
-- FreeMonoid.ofList_comp_toList
@[to_additive (attr := simp)]
theorem ofList_comp_toList : @ofList α ∘ toList = id 
Arguments: {α : Type u_1}
Goal: ⇑FreeMonoid.ofList ∘ ⇑FreeMonoid.toList = id
-- FreeAddMonoid.toList_zero
@[to_additive (attr := simp)]
theorem toList_one : toList (1 : FreeMonoid α) = [] 
Arguments: {α : Type u_1}
Goal: FreeAddMonoid.toList 0 = []
-- FreeMonoid.toList_one
@[to_additive (attr := simp)]
theorem toList_one : toList (1 : FreeMonoid α) = [] 
Arguments: {α : Type u_1}
Goal: FreeMonoid.toList 1 = []
-- FreeAddMonoid.ofList_nil
@[to_additive (attr := simp)]
theorem ofList_nil : ofList ([] : List α) = 1 
Arguments: {α : Type u_1}
Goal: FreeAddMonoid.ofList [] = 0
-- FreeMonoid.ofList_nil
@[to_additive (attr := simp)]
theorem ofList_nil : ofList ([] : List α) = 1 
Arguments: {α : Type u_1}
Goal: FreeMonoid.ofList [] = 1
-- FreeMonoid.toList_mul
@[to_additive (attr := simp)]
theorem toList_mul (xs ys : FreeMonoid α) : toList (xs * ys) = toList xs ++ toList ys 
Arguments: {α : Type u_1} (xs ys : FreeMonoid α)
Goal: FreeMonoid.toList (xs * ys) = FreeMonoid.toList xs ++ FreeMonoid.toList ys
-- FreeAddMonoid.toList_add
@[to_additive (attr := simp)]
theorem toList_mul (xs ys : FreeMonoid α) : toList (xs * ys) = toList xs ++ toList ys 
Arguments: {α : Type u_1} (xs ys : FreeAddMonoid α)
Goal: FreeAddMonoid.toList (xs + ys) = FreeAddMonoid.toList xs ++ FreeAddMonoid.toList ys
-- FreeMonoid.ofList_append
@[to_additive (attr := simp)]
theorem ofList_append (xs ys : List α) : ofList (xs ++ ys) = ofList xs * ofList ys 
Arguments: {α : Type u_1} (xs ys : List α)
Goal: FreeMonoid.ofList (xs ++ ys) = FreeMonoid.ofList xs * FreeMonoid.ofList ys
-- FreeAddMonoid.ofList_append
@[to_additive (attr := simp)]
theorem ofList_append (xs ys : List α) : ofList (xs ++ ys) = ofList xs * ofList ys 
Arguments: {α : Type u_1} (xs ys : List α)
Goal: FreeAddMonoid.ofList (xs ++ ys) = FreeAddMonoid.ofList xs + FreeAddMonoid.ofList ys
-- FreeAddMonoid.toList_sum
@[to_additive (attr := simp)]
theorem toList_prod (xs : List (FreeMonoid α)) : toList xs.prod = (xs.map toList).join 
Arguments: {α : Type u_1} (xs : List (FreeAddMonoid α))
Goal: FreeAddMonoid.toList xs.sum = (List.map (⇑FreeAddMonoid.toList) xs).join
-- FreeMonoid.toList_prod
@[to_additive (attr := simp)]
theorem toList_prod (xs : List (FreeMonoid α)) : toList xs.prod = (xs.map toList).join 
Arguments: {α : Type u_1} (xs : List (FreeMonoid α))
Goal: FreeMonoid.toList xs.prod = (List.map (⇑FreeMonoid.toList) xs).join
-- FreeMonoid.ofList_join
@[to_additive (attr := simp)]
theorem ofList_join (xs : List (List α)) : ofList xs.join = (xs.map ofList).prod 
Arguments: {α : Type u_1} (xs : List (List α))
Goal: FreeMonoid.ofList xs.join = (List.map (⇑FreeMonoid.ofList) xs).prod
-- FreeAddMonoid.ofList_join
@[to_additive (attr := simp)]
theorem ofList_join (xs : List (List α)) : ofList xs.join = (xs.map ofList).prod 
Arguments: {α : Type u_1} (xs : List (List α))
Goal: FreeAddMonoid.ofList xs.join = (List.map (⇑FreeAddMonoid.ofList) xs).sum
-- FreeMonoid.toList_of
@[to_additive (attr := simp)]
theorem toList_of (x : α) : toList (of x) = [x] 
Arguments: {α : Type u_1} (x : α)
Goal: FreeMonoid.toList (FreeMonoid.of x) = [x]
-- FreeAddMonoid.toList_of
@[to_additive (attr := simp)]
theorem toList_of (x : α) : toList (of x) = [x] 
Arguments: {α : Type u_1} (x : α)
Goal: FreeAddMonoid.toList (FreeAddMonoid.of x) = [x]
-- FreeAddMonoid.ofList_singleton
@[to_additive]
theorem ofList_singleton (x : α) : ofList [x] = of x 
Arguments: {α : Type u_1} (x : α)
Goal: FreeAddMonoid.ofList [x] = FreeAddMonoid.of x
-- FreeMonoid.ofList_singleton
@[to_additive]
theorem ofList_singleton (x : α) : ofList [x] = of x 
Arguments: {α : Type u_1} (x : α)
Goal: FreeMonoid.ofList [x] = FreeMonoid.of x
-- FreeMonoid.ofList_cons
@[to_additive (attr := simp)]
theorem ofList_cons (x : α) (xs : List α) : ofList (x :: xs) = of x * ofList xs 
Arguments: {α : Type u_1} (x : α) (xs : List α)
Goal: FreeMonoid.ofList (x :: xs) = FreeMonoid.of x * FreeMonoid.ofList xs
-- FreeAddMonoid.ofList_cons
@[to_additive (attr := simp)]
theorem ofList_cons (x : α) (xs : List α) : ofList (x :: xs) = of x * ofList xs 
Arguments: {α : Type u_1} (x : α) (xs : List α)
Goal: FreeAddMonoid.ofList (x :: xs) = FreeAddMonoid.of x + FreeAddMonoid.ofList xs
-- FreeAddMonoid.toList_of_add
@[to_additive]
theorem toList_of_mul (x : α) (xs : FreeMonoid α) : toList (of x * xs) = x :: toList xs 
Arguments: {α : Type u_1} (x : α) (xs : FreeAddMonoid α)
Goal: FreeAddMonoid.toList (FreeAddMonoid.of x + xs) = x :: FreeAddMonoid.toList xs
-- FreeMonoid.toList_of_mul
@[to_additive]
theorem toList_of_mul (x : α) (xs : FreeMonoid α) : toList (of x * xs) = x :: toList xs 
Arguments: {α : Type u_1} (x : α) (xs : FreeMonoid α)
Goal: FreeMonoid.toList (FreeMonoid.of x * xs) = x :: FreeMonoid.toList xs
-- FreeAddMonoid.of_injective
@[to_additive]
theorem of_injective : Function.Injective (@of α) 
Arguments: {α : Type u_1}
Goal: Function.Injective FreeAddMonoid.of
-- FreeMonoid.of_injective
@[to_additive]
theorem of_injective : Function.Injective (@of α) 
Arguments: {α : Type u_1}
Goal: Function.Injective FreeMonoid.of
-- FreeMonoid.recOn_one
@[to_additive (attr := simp)]
theorem recOn_one {C : FreeMonoid α → Sort*} (h0 : C 1) (ih : ∀ x xs, C xs → C (of x * xs)) :
    @recOn α C 1 h0 ih = h0 
Arguments: {α : Type u_1} {C : FreeMonoid α → Sort u_6} (h0 : C 1) (ih : (x : α) → (xs : FreeMonoid α) → C xs → C (FreeMonoid.of x * xs))
Goal: FreeMonoid.recOn 1 h0 ih = h0
-- FreeAddMonoid.recOn_zero
@[to_additive (attr := simp)]
theorem recOn_one {C : FreeMonoid α → Sort*} (h0 : C 1) (ih : ∀ x xs, C xs → C (of x * xs)) :
    @recOn α C 1 h0 ih = h0 
Arguments: {α : Type u_1} {C : FreeAddMonoid α → Sort u_6} (h0 : C 0) (ih : (x : α) → (xs : FreeAddMonoid α) → C xs → C (FreeAddMonoid.of x + xs))
Goal: FreeAddMonoid.recOn 0 h0 ih = h0
-- FreeMonoid.recOn_of_mul
@[to_additive (attr := simp)]
theorem recOn_of_mul {C : FreeMonoid α → Sort*} (x : α) (xs : FreeMonoid α) (h0 : C 1)
    (ih : ∀ x xs, C xs → C (of x * xs)) : @recOn α C (of x * xs) h0 ih = ih x xs (recOn xs h0 ih) 
Arguments: {α : Type u_1} {C : FreeMonoid α → Sort u_6} (x : α) (xs : FreeMonoid α) (h0 : C 1) (ih : (x : α) → (xs : FreeMonoid α) → C xs → C (FreeMonoid.of x * xs))
Goal: (FreeMonoid.of x * xs).recOn h0 ih = ih x xs (xs.recOn h0 ih)
-- FreeAddMonoid.recOn_of_add
@[to_additive (attr := simp)]
theorem recOn_of_mul {C : FreeMonoid α → Sort*} (x : α) (xs : FreeMonoid α) (h0 : C 1)
    (ih : ∀ x xs, C xs → C (of x * xs)) : @recOn α C (of x * xs) h0 ih = ih x xs (recOn xs h0 ih) 
Arguments: {α : Type u_1} {C : FreeAddMonoid α → Sort u_6} (x : α) (xs : FreeAddMonoid α) (h0 : C 0) (ih : (x : α) → (xs : FreeAddMonoid α) → C xs → C (FreeAddMonoid.of x + xs))
Goal: (FreeAddMonoid.of x + xs).recOn h0 ih = ih x xs (xs.recOn h0 ih)
-- FreeMonoid.casesOn_one
@[to_additive (attr := simp)]
theorem casesOn_one {C : FreeMonoid α → Sort*} (h0 : C 1) (ih : ∀ x xs, C (of x * xs)) :
    @casesOn α C 1 h0 ih = h0 
Arguments: {α : Type u_1} {C : FreeMonoid α → Sort u_6} (h0 : C 1) (ih : (x : α) → (xs : FreeMonoid α) → C (FreeMonoid.of x * xs))
Goal: FreeMonoid.casesOn 1 h0 ih = h0
-- FreeAddMonoid.casesOn_zero
@[to_additive (attr := simp)]
theorem casesOn_one {C : FreeMonoid α → Sort*} (h0 : C 1) (ih : ∀ x xs, C (of x * xs)) :
    @casesOn α C 1 h0 ih = h0 
Arguments: {α : Type u_1} {C : FreeAddMonoid α → Sort u_6} (h0 : C 0) (ih : (x : α) → (xs : FreeAddMonoid α) → C (FreeAddMonoid.of x + xs))
Goal: FreeAddMonoid.casesOn 0 h0 ih = h0
-- FreeAddMonoid.casesOn_of_add
@[to_additive (attr := simp)]
theorem casesOn_of_mul {C : FreeMonoid α → Sort*} (x : α) (xs : FreeMonoid α) (h0 : C 1)
    (ih : ∀ x xs, C (of x * xs)) : @casesOn α C (of x * xs) h0 ih = ih x xs 
Arguments: {α : Type u_1} {C : FreeAddMonoid α → Sort u_6} (x : α) (xs : FreeAddMonoid α) (h0 : C 0) (ih : (x : α) → (xs : FreeAddMonoid α) → C (FreeAddMonoid.of x + xs))
Goal: (FreeAddMonoid.of x + xs).casesOn h0 ih = ih x xs
-- FreeMonoid.casesOn_of_mul
@[to_additive (attr := simp)]
theorem casesOn_of_mul {C : FreeMonoid α → Sort*} (x : α) (xs : FreeMonoid α) (h0 : C 1)
    (ih : ∀ x xs, C (of x * xs)) : @casesOn α C (of x * xs) h0 ih = ih x xs 
Arguments: {α : Type u_1} {C : FreeMonoid α → Sort u_6} (x : α) (xs : FreeMonoid α) (h0 : C 1) (ih : (x : α) → (xs : FreeMonoid α) → C (FreeMonoid.of x * xs))
Goal: (FreeMonoid.of x * xs).casesOn h0 ih = ih x xs
-- FreeAddMonoid.hom_eq
@[to_additive (attr := ext)]
theorem hom_eq ⦃f g : FreeMonoid α →* M⦄ (h : ∀ x, f (of x) = g (of x)) : f = g 
Arguments: {α : Type u_1} {M : Type u_4} [AddMonoid M] ⦃f g : FreeAddMonoid α →+ M⦄ (h : ∀ (x : α), f (FreeAddMonoid.of x) = g (FreeAddMonoid.of x))
Goal: f = g
-- FreeMonoid.hom_eq
@[to_additive (attr := ext)]
theorem hom_eq ⦃f g : FreeMonoid α →* M⦄ (h : ∀ x, f (of x) = g (of x)) : f = g 
Arguments: {α : Type u_1} {M : Type u_4} [Monoid M] ⦃f g : FreeMonoid α →* M⦄ (h : ∀ (x : α), f (FreeMonoid.of x) = g (FreeMonoid.of x))
Goal: f = g
-- FreeAddMonoid.sumAux_eq
@[to_additive]
lemma prodAux_eq : ∀ l : List M, FreeMonoid.prodAux l = l.prod
  
Arguments: {M : Type u_4} [AddMonoid M] (l : List M)
Goal: FreeAddMonoid.sumAux l = l.sum
-- FreeMonoid.prodAux_eq
@[to_additive]
lemma prodAux_eq : ∀ l : List M, FreeMonoid.prodAux l = l.prod
  
Arguments: {M : Type u_4} [Monoid M] (l : List M)
Goal: FreeMonoid.prodAux l = l.prod
-- FreeMonoid.lift_ofList
@[to_additive (attr := simp)]
theorem lift_ofList (f : α → M) (l : List α) : lift f (ofList l) = (l.map f).prod 
Arguments: {α : Type u_1} {M : Type u_4} [Monoid M] (f : α → M) (l : List α)
Goal: (FreeMonoid.lift f) (FreeMonoid.ofList l) = (List.map f l).prod
-- FreeAddMonoid.lift_ofList
@[to_additive (attr := simp)]
theorem lift_ofList (f : α → M) (l : List α) : lift f (ofList l) = (l.map f).prod 
Arguments: {α : Type u_1} {M : Type u_4} [AddMonoid M] (f : α → M) (l : List α)
Goal: (FreeAddMonoid.lift f) (FreeAddMonoid.ofList l) = (List.map f l).sum
-- FreeAddMonoid.lift_symm_apply
@[to_additive (attr := simp)]
theorem lift_symm_apply (f : FreeMonoid α →* M) : lift.symm f = f ∘ of 
Arguments: {α : Type u_1} {M : Type u_4} [AddMonoid M] (f : FreeAddMonoid α →+ M)
Goal: FreeAddMonoid.lift.symm f = ⇑f ∘ FreeAddMonoid.of
-- FreeMonoid.lift_symm_apply
@[to_additive (attr := simp)]
theorem lift_symm_apply (f : FreeMonoid α →* M) : lift.symm f = f ∘ of 
Arguments: {α : Type u_1} {M : Type u_4} [Monoid M] (f : FreeMonoid α →* M)
Goal: FreeMonoid.lift.symm f = ⇑f ∘ FreeMonoid.of
-- FreeMonoid.lift_apply
@[to_additive]
theorem lift_apply (f : α → M) (l : FreeMonoid α) : lift f l = ((toList l).map f).prod 
Arguments: {α : Type u_1} {M : Type u_4} [Monoid M] (f : α → M) (l : FreeMonoid α)
Goal: (FreeMonoid.lift f) l = (List.map f (FreeMonoid.toList l)).prod
-- FreeAddMonoid.lift_apply
@[to_additive]
theorem lift_apply (f : α → M) (l : FreeMonoid α) : lift f l = ((toList l).map f).prod 
Arguments: {α : Type u_1} {M : Type u_4} [AddMonoid M] (f : α → M) (l : FreeAddMonoid α)
Goal: (FreeAddMonoid.lift f) l = (List.map f (FreeAddMonoid.toList l)).sum
-- FreeMonoid.lift_comp_of
@[to_additive]
theorem lift_comp_of (f : α → M) : lift f ∘ of = f 
Arguments: {α : Type u_1} {M : Type u_4} [Monoid M] (f : α → M)
Goal: ⇑(FreeMonoid.lift f) ∘ FreeMonoid.of = f
-- FreeAddMonoid.lift_comp_of
@[to_additive]
theorem lift_comp_of (f : α → M) : lift f ∘ of = f 
Arguments: {α : Type u_1} {M : Type u_4} [AddMonoid M] (f : α → M)
Goal: ⇑(FreeAddMonoid.lift f) ∘ FreeAddMonoid.of = f
-- FreeAddMonoid.lift_eval_of
@[to_additive (attr := simp)]
theorem lift_eval_of (f : α → M) (x : α) : lift f (of x) = f x 
Arguments: {α : Type u_1} {M : Type u_4} [AddMonoid M] (f : α → M) (x : α)
Goal: (FreeAddMonoid.lift f) (FreeAddMonoid.of x) = f x
-- FreeMonoid.lift_eval_of
@[to_additive (attr := simp)]
theorem lift_eval_of (f : α → M) (x : α) : lift f (of x) = f x 
Arguments: {α : Type u_1} {M : Type u_4} [Monoid M] (f : α → M) (x : α)
Goal: (FreeMonoid.lift f) (FreeMonoid.of x) = f x
-- FreeAddMonoid.lift_restrict
@[to_additive (attr := simp)]
theorem lift_restrict (f : FreeMonoid α →* M) : lift (f ∘ of) = f 
Arguments: {α : Type u_1} {M : Type u_4} [AddMonoid M] (f : FreeAddMonoid α →+ M)
Goal: FreeAddMonoid.lift (⇑f ∘ FreeAddMonoid.of) = f
-- FreeMonoid.lift_restrict
@[to_additive (attr := simp)]
theorem lift_restrict (f : FreeMonoid α →* M) : lift (f ∘ of) = f 
Arguments: {α : Type u_1} {M : Type u_4} [Monoid M] (f : FreeMonoid α →* M)
Goal: FreeMonoid.lift (⇑f ∘ FreeMonoid.of) = f
-- FreeAddMonoid.comp_lift
@[to_additive]
theorem comp_lift (g : M →* N) (f : α → M) : g.comp (lift f) = lift (g ∘ f) 
Arguments: {α : Type u_1} {M : Type u_4} [AddMonoid M] {N : Type u_5} [AddMonoid N] (g : M →+ N) (f : α → M)
Goal: g.comp (FreeAddMonoid.lift f) = FreeAddMonoid.lift (⇑g ∘ f)
-- FreeMonoid.comp_lift
@[to_additive]
theorem comp_lift (g : M →* N) (f : α → M) : g.comp (lift f) = lift (g ∘ f) 
Arguments: {α : Type u_1} {M : Type u_4} [Monoid M] {N : Type u_5} [Monoid N] (g : M →* N) (f : α → M)
Goal: g.comp (FreeMonoid.lift f) = FreeMonoid.lift (⇑g ∘ f)
-- FreeMonoid.hom_map_lift
@[to_additive]
theorem hom_map_lift (g : M →* N) (f : α → M) (x : FreeMonoid α) : g (lift f x) = lift (g ∘ f) x 
Arguments: {α : Type u_1} {M : Type u_4} [Monoid M] {N : Type u_5} [Monoid N] (g : M →* N) (f : α → M) (x : FreeMonoid α)
Goal: g ((FreeMonoid.lift f) x) = (FreeMonoid.lift (⇑g ∘ f)) x
-- FreeAddMonoid.hom_map_lift
@[to_additive]
theorem hom_map_lift (g : M →* N) (f : α → M) (x : FreeMonoid α) : g (lift f x) = lift (g ∘ f) x 
Arguments: {α : Type u_1} {M : Type u_4} [AddMonoid M] {N : Type u_5} [AddMonoid N] (g : M →+ N) (f : α → M) (x : FreeAddMonoid α)
Goal: g ((FreeAddMonoid.lift f) x) = (FreeAddMonoid.lift (⇑g ∘ f)) x
-- FreeAddMonoid.vadd_def
@[to_additive]
theorem smul_def (f : α → β → β) (l : FreeMonoid α) (b : β) :
    haveI := mkMulAction f
    l • b = l.toList.foldr f b 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β → β) (l : FreeAddMonoid α) (b : β)
Goal: l +ᵥ b = List.foldr f b (FreeAddMonoid.toList l)
-- FreeMonoid.smul_def
@[to_additive]
theorem smul_def (f : α → β → β) (l : FreeMonoid α) (b : β) :
    haveI := mkMulAction f
    l • b = l.toList.foldr f b 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β → β) (l : FreeMonoid α) (b : β)
Goal: l • b = List.foldr f b (FreeMonoid.toList l)
-- FreeMonoid.ofList_smul
@[to_additive]
theorem ofList_smul (f : α → β → β) (l : List α) (b : β) :
    haveI := mkMulAction f
    ofList l • b = l.foldr f b 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β → β) (l : List α) (b : β)
Goal: FreeMonoid.ofList l • b = List.foldr f b l
-- FreeAddMonoid.ofList_vadd
@[to_additive]
theorem ofList_smul (f : α → β → β) (l : List α) (b : β) :
    haveI := mkMulAction f
    ofList l • b = l.foldr f b 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β → β) (l : List α) (b : β)
Goal: FreeAddMonoid.ofList l +ᵥ b = List.foldr f b l
-- FreeMonoid.of_smul
@[to_additive (attr := simp)]
theorem of_smul (f : α → β → β) (x : α) (y : β) :
    (haveI := mkMulAction f
    of x • y) = f x y 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β → β) (x : α) (y : β)
Goal: FreeMonoid.of x • y = f x y
-- FreeAddMonoid.of_vadd
@[to_additive (attr := simp)]
theorem of_smul (f : α → β → β) (x : α) (y : β) :
    (haveI := mkMulAction f
    of x • y) = f x y 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β → β) (x : α) (y : β)
Goal: FreeAddMonoid.of x +ᵥ y = f x y
-- FreeAddMonoid.map_of
@[to_additive (attr := simp)]
theorem map_of (f : α → β) (x : α) : map f (of x) = of (f x) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (x : α)
Goal: (FreeAddMonoid.map f) (FreeAddMonoid.of x) = FreeAddMonoid.of (f x)
-- FreeMonoid.map_of
@[to_additive (attr := simp)]
theorem map_of (f : α → β) (x : α) : map f (of x) = of (f x) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (x : α)
Goal: (FreeMonoid.map f) (FreeMonoid.of x) = FreeMonoid.of (f x)
-- FreeMonoid.toList_map
@[to_additive]
theorem toList_map (f : α → β) (xs : FreeMonoid α) : toList (map f xs) = xs.toList.map f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (xs : FreeMonoid α)
Goal: FreeMonoid.toList ((FreeMonoid.map f) xs) = List.map f (FreeMonoid.toList xs)
-- FreeAddMonoid.toList_map
@[to_additive]
theorem toList_map (f : α → β) (xs : FreeMonoid α) : toList (map f xs) = xs.toList.map f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (xs : FreeAddMonoid α)
Goal: FreeAddMonoid.toList ((FreeAddMonoid.map f) xs) = List.map f (FreeAddMonoid.toList xs)
-- FreeMonoid.ofList_map
@[to_additive]
theorem ofList_map (f : α → β) (xs : List α) : ofList (xs.map f) = map f (ofList xs) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (xs : List α)
Goal: FreeMonoid.ofList (List.map f xs) = (FreeMonoid.map f) (FreeMonoid.ofList xs)
-- FreeAddMonoid.ofList_map
@[to_additive]
theorem ofList_map (f : α → β) (xs : List α) : ofList (xs.map f) = map f (ofList xs) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (xs : List α)
Goal: FreeAddMonoid.ofList (List.map f xs) = (FreeAddMonoid.map f) (FreeAddMonoid.ofList xs)
-- FreeAddMonoid.lift_of_comp_eq_map
@[to_additive]
theorem lift_of_comp_eq_map (f : α → β) : (lift fun x ↦ of (f x)) = map f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β)
Goal: (FreeAddMonoid.lift fun x => FreeAddMonoid.of (f x)) = FreeAddMonoid.map f
-- FreeMonoid.lift_of_comp_eq_map
@[to_additive]
theorem lift_of_comp_eq_map (f : α → β) : (lift fun x ↦ of (f x)) = map f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β)
Goal: (FreeMonoid.lift fun x => FreeMonoid.of (f x)) = FreeMonoid.map f