Free monoid over a given alphabet

Main definitions

• FreeMonoid α: free monoid over alphabet α; defined as a synonym for List α with multiplication given by (++).
• FreeMonoid.of: embedding α → FreeMonoid α sending each element x to [x];
• FreeMonoid.lift: natural equivalence between α → M and FreeMonoid α →* M
• FreeMonoid.map: embedding of α → β into FreeMonoid α →* FreeMonoid β given by List.map.

def FreeAddMonoid (α : Type u_6) : Type u_6

Free nonabelian additive monoid over a given alphabet

def FreeMonoid (α : Type u_6) : Type u_6

Free monoid over a given alphabet.

instance FreeAddMonoid.instDecidableEqFreeAddMonoid {α : Type u_1} [DecidableEq α] : DecidableEq (FreeAddMonoid α)

instance FreeMonoid.instDecidableEqFreeMonoid {α : Type u_1} [DecidableEq α] : DecidableEq (FreeMonoid α)

def FreeAddMonoid.toList {α : Type u_1} : FreeAddMonoid α ≃ List α

The identity equivalence between FreeAddMonoid α and List α.

def FreeMonoid.toList {α : Type u_1} : FreeMonoid α ≃ List α

The identity equivalence between FreeMonoid α and List α.

def FreeAddMonoid.ofList {α : Type u_1} : List α ≃ FreeAddMonoid α

The identity equivalence between List α and FreeAddMonoid α.

def FreeMonoid.ofList {α : Type u_1} : List α ≃ FreeMonoid α

The identity equivalence between List α and FreeMonoid α.

@[simp]

theorem FreeAddMonoid.toList_symm {α : Type u_1} : FreeAddMonoid.toList.symm = FreeAddMonoid.ofList

@[simp]

theorem FreeMonoid.toList_symm {α : Type u_1} : FreeMonoid.toList.symm = FreeMonoid.ofList

@[simp]

theorem FreeAddMonoid.ofList_symm {α : Type u_1} : FreeAddMonoid.ofList.symm = FreeAddMonoid.toList

@[simp]

theorem FreeMonoid.ofList_symm {α : Type u_1} : FreeMonoid.ofList.symm = FreeMonoid.toList

@[simp]

theorem FreeAddMonoid.toList_ofList {α : Type u_1} (l : List α) : ↑FreeAddMonoid.toList (↑FreeAddMonoid.ofList l) = l

@[simp]

theorem FreeMonoid.toList_ofList {α : Type u_1} (l : List α) : ↑FreeMonoid.toList (↑FreeMonoid.ofList l) = l

@[simp]

theorem FreeAddMonoid.ofList_toList {α : Type u_1} (xs : FreeAddMonoid α) : ↑FreeAddMonoid.ofList (↑FreeAddMonoid.toList xs) = xs

@[simp]

theorem FreeMonoid.ofList_toList {α : Type u_1} (xs : FreeMonoid α) : ↑FreeMonoid.ofList (↑FreeMonoid.toList xs) = xs

@[simp]

theorem FreeAddMonoid.toList_comp_ofList {α : Type u_1} : ↑FreeAddMonoid.toList ∘ ↑FreeAddMonoid.ofList = id

@[simp]

theorem FreeMonoid.toList_comp_ofList {α : Type u_1} : ↑FreeMonoid.toList ∘ ↑FreeMonoid.ofList = id

@[simp]

theorem FreeAddMonoid.ofList_comp_toList {α : Type u_1} : ↑FreeAddMonoid.ofList ∘ ↑FreeAddMonoid.toList = id

@[simp]

theorem FreeMonoid.ofList_comp_toList {α : Type u_1} : ↑FreeMonoid.ofList ∘ ↑FreeMonoid.toList = id

theorem FreeAddMonoid.instAddCancelMonoidFreeAddMonoid.proof_2 {α : Type u_1} : ∀ (x : FreeAddMonoid α), nsmulRec 0 x = nsmulRec 0 x

theorem FreeAddMonoid.instAddCancelMonoidFreeAddMonoid.proof_4 {α : Type u_1} : ∀ (x x_1 x_2 : FreeAddMonoid α), ↑FreeAddMonoid.toList x ++ ↑FreeAddMonoid.toList x_1 = ↑FreeAddMonoid.toList x_2 ++ ↑FreeAddMonoid.toList x_1 → ↑FreeAddMonoid.toList x = ↑FreeAddMonoid.toList x_2

theorem FreeAddMonoid.instAddCancelMonoidFreeAddMonoid.proof_3 {α : Type u_1} : ∀ (n : ℕ) (x : FreeAddMonoid α), nsmulRec (n + 1) x = nsmulRec (n + 1) x

instance FreeAddMonoid.instAddCancelMonoidFreeAddMonoid {α : Type u_1} : AddCancelMonoid (FreeAddMonoid α)

theorem FreeAddMonoid.instAddCancelMonoidFreeAddMonoid.proof_1 {α : Type u_1} : ∀ (x x_1 x_2 : FreeAddMonoid α), ↑FreeAddMonoid.toList x ++ ↑FreeAddMonoid.toList x_1 = ↑FreeAddMonoid.toList x ++ ↑FreeAddMonoid.toList x_2 → ↑FreeAddMonoid.toList x_1 = ↑FreeAddMonoid.toList x_2

instance FreeMonoid.instCancelMonoidFreeMonoid {α : Type u_1} : CancelMonoid (FreeMonoid α)

instance FreeAddMonoid.instInhabitedFreeAddMonoid {α : Type u_1} : Inhabited (FreeAddMonoid α)

instance FreeMonoid.instInhabitedFreeMonoid {α : Type u_1} : Inhabited (FreeMonoid α)

@[simp]

theorem FreeAddMonoid.toList_zero {α : Type u_1} : ↑FreeAddMonoid.toList 0 = []

@[simp]

theorem FreeMonoid.toList_one {α : Type u_1} : ↑FreeMonoid.toList 1 = []

@[simp]

theorem FreeAddMonoid.ofList_nil {α : Type u_1} : ↑FreeAddMonoid.ofList [] = 0

@[simp]

theorem FreeMonoid.ofList_nil {α : Type u_1} : ↑FreeMonoid.ofList [] = 1

@[simp]

theorem FreeAddMonoid.toList_add {α : Type u_1} (xs : FreeAddMonoid α) (ys : FreeAddMonoid α) : ↑FreeAddMonoid.toList (xs + ys) = ↑FreeAddMonoid.toList xs ++ ↑FreeAddMonoid.toList ys

@[simp]

theorem FreeMonoid.toList_mul {α : Type u_1} (xs : FreeMonoid α) (ys : FreeMonoid α) : ↑FreeMonoid.toList (xs * ys) = ↑FreeMonoid.toList xs ++ ↑FreeMonoid.toList ys

@[simp]

theorem FreeAddMonoid.ofList_append {α : Type u_1} (xs : List α) (ys : List α) : ↑FreeAddMonoid.ofList (xs ++ ys) = ↑FreeAddMonoid.ofList xs + ↑FreeAddMonoid.ofList ys

@[simp]

theorem FreeMonoid.ofList_append {α : Type u_1} (xs : List α) (ys : List α) : ↑FreeMonoid.ofList (xs ++ ys) = ↑FreeMonoid.ofList xs * ↑FreeMonoid.ofList ys

@[simp]

theorem FreeAddMonoid.toList_sum {α : Type u_1} (xs : List (FreeAddMonoid α)) : ↑FreeAddMonoid.toList (List.sum xs) = List.join (List.map (↑FreeAddMonoid.toList) xs)

@[simp]

theorem FreeMonoid.toList_prod {α : Type u_1} (xs : List (FreeMonoid α)) : ↑FreeMonoid.toList (List.prod xs) = List.join (List.map (↑FreeMonoid.toList) xs)

@[simp]

theorem FreeAddMonoid.ofList_join {α : Type u_1} (xs : List (List α)) : ↑FreeAddMonoid.ofList (List.join xs) = List.sum (List.map (↑FreeAddMonoid.ofList) xs)

@[simp]

theorem FreeMonoid.ofList_join {α : Type u_1} (xs : List (List α)) : ↑FreeMonoid.ofList (List.join xs) = List.prod (List.map (↑FreeMonoid.ofList) xs)

def FreeAddMonoid.of {α : Type u_1} (x : α) : FreeAddMonoid α

Embeds an element of α into FreeAddMonoid α as a singleton list.

def FreeMonoid.of {α : Type u_1} (x : α) : FreeMonoid α

Embeds an element of α into FreeMonoid α as a singleton list.

@[simp]

theorem FreeAddMonoid.toList_of {α : Type u_1} (x : α) : ↑FreeAddMonoid.toList (FreeAddMonoid.of x) = [x]

@[simp]

theorem FreeMonoid.toList_of {α : Type u_1} (x : α) : ↑FreeMonoid.toList (FreeMonoid.of x) = [x]

theorem FreeAddMonoid.ofList_singleton {α : Type u_1} (x : α) : ↑FreeAddMonoid.ofList [x] = FreeAddMonoid.of x

theorem FreeMonoid.ofList_singleton {α : Type u_1} (x : α) : ↑FreeMonoid.ofList [x] = FreeMonoid.of x

@[simp]

theorem FreeAddMonoid.ofList_cons {α : Type u_1} (x : α) (xs : List α) : ↑FreeAddMonoid.ofList (x :: xs) = FreeAddMonoid.of x + ↑FreeAddMonoid.ofList xs

@[simp]

theorem FreeMonoid.ofList_cons {α : Type u_1} (x : α) (xs : List α) : ↑FreeMonoid.ofList (x :: xs) = FreeMonoid.of x * ↑FreeMonoid.ofList xs

theorem FreeAddMonoid.toList_of_add {α : Type u_1} (x : α) (xs : FreeAddMonoid α) : ↑FreeAddMonoid.toList (FreeAddMonoid.of x + xs) = x :: ↑FreeAddMonoid.toList xs

theorem FreeMonoid.toList_of_mul {α : Type u_1} (x : α) (xs : FreeMonoid α) : ↑FreeMonoid.toList (FreeMonoid.of x * xs) = x :: ↑FreeMonoid.toList xs

theorem FreeAddMonoid.of_injective {α : Type u_1} : Function.Injective FreeAddMonoid.of

theorem FreeMonoid.of_injective {α : Type u_1} : Function.Injective FreeMonoid.of

def FreeAddMonoid.recOn {α : Type u_1} {C : FreeAddMonoid α → Sort u_6} (xs : FreeAddMonoid α) (h0 : C 0) (ih : (x : α) → (xs : FreeAddMonoid α) → C xs → C (FreeAddMonoid.of x + xs)) : C xs

Recursor for FreeAddMonoid using 0 and FreeAddMonoid.of x + xs instead of [] and x :: xs.

def FreeMonoid.recOn {α : Type u_1} {C : FreeMonoid α → Sort u_6} (xs : FreeMonoid α) (h0 : C 1) (ih : (x : α) → (xs : FreeMonoid α) → C xs → C (FreeMonoid.of x * xs)) : C xs

Recursor for FreeMonoid using 1 and FreeMonoid.of x * xs instead of [] and x :: xs.

@[simp]

theorem FreeAddMonoid.recOn_zero {α : Type u_1} {C : FreeAddMonoid α → Sort u_6} (h0 : C 0) (ih : (x : α) → (xs : FreeAddMonoid α) → C xs → C (FreeAddMonoid.of x + xs)) : FreeAddMonoid.recOn 0 h0 ih = h0

@[simp]

theorem FreeMonoid.recOn_one {α : Type u_1} {C : FreeMonoid α → Sort u_6} (h0 : C 1) (ih : (x : α) → (xs : FreeMonoid α) → C xs → C (FreeMonoid.of x * xs)) : FreeMonoid.recOn 1 h0 ih = h0

@[simp]

theorem FreeAddMonoid.recOn_of_add {α : 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)) : FreeAddMonoid.recOn (FreeAddMonoid.of x + xs) h0 ih = ih x xs (FreeAddMonoid.recOn xs h0 ih)

@[simp]

theorem FreeMonoid.recOn_of_mul {α : 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)) : FreeMonoid.recOn (FreeMonoid.of x * xs) h0 ih = ih x xs (FreeMonoid.recOn xs h0 ih)

def FreeAddMonoid.casesOn {α : Type u_1} {C : FreeAddMonoid α → Sort u_6} (xs : FreeAddMonoid α) (h0 : C 0) (ih : (x : α) → (xs : FreeAddMonoid α) → C (FreeAddMonoid.of x + xs)) : C xs

A version of List.casesOn for FreeAddMonoid using 0 and FreeAddMonoid.of x + xs instead of [] and x :: xs.

def FreeMonoid.casesOn {α : Type u_1} {C : FreeMonoid α → Sort u_6} (xs : FreeMonoid α) (h0 : C 1) (ih : (x : α) → (xs : FreeMonoid α) → C (FreeMonoid.of x * xs)) : C xs

A version of List.cases_on for FreeMonoid using 1 and FreeMonoid.of x * xs instead of [] and x :: xs.

@[simp]

theorem FreeAddMonoid.casesOn_zero {α : Type u_1} {C : FreeAddMonoid α → Sort u_6} (h0 : C 0) (ih : (x : α) → (xs : FreeAddMonoid α) → C (FreeAddMonoid.of x + xs)) : FreeAddMonoid.casesOn 0 h0 ih = h0

@[simp]

theorem FreeMonoid.casesOn_one {α : Type u_1} {C : FreeMonoid α → Sort u_6} (h0 : C 1) (ih : (x : α) → (xs : FreeMonoid α) → C (FreeMonoid.of x * xs)) : FreeMonoid.casesOn 1 h0 ih = h0

@[simp]

theorem FreeAddMonoid.casesOn_of_add {α : Type u_1} {C : FreeAddMonoid α → Sort u_6} (x : α) (xs : FreeAddMonoid α) (h0 : C 0) (ih : (x : α) → (xs : FreeAddMonoid α) → C (FreeAddMonoid.of x + xs)) : FreeAddMonoid.casesOn (FreeAddMonoid.of x + xs) h0 ih = ih x xs

@[simp]

theorem FreeMonoid.casesOn_of_mul {α : Type u_1} {C : FreeMonoid α → Sort u_6} (x : α) (xs : FreeMonoid α) (h0 : C 1) (ih : (x : α) → (xs : FreeMonoid α) → C (FreeMonoid.of x * xs)) : FreeMonoid.casesOn (FreeMonoid.of x * xs) h0 ih = ih x xs

theorem FreeAddMonoid.hom_eq {α : Type u_1} {M : Type u_4} [AddMonoid M] ⦃f : FreeAddMonoid α →+ M⦄ ⦃g : FreeAddMonoid α →+ M⦄ (h : ∀ (x : α), ↑f (FreeAddMonoid.of x) = ↑g (FreeAddMonoid.of x)) : f = g

theorem FreeMonoid.hom_eq {α : Type u_1} {M : Type u_4} [Monoid M] ⦃f : FreeMonoid α →* M⦄ ⦃g : FreeMonoid α →* M⦄ (h : ∀ (x : α), ↑f (FreeMonoid.of x) = ↑g (FreeMonoid.of x)) : f = g

def FreeAddMonoid.sumAux {M : Type u_6} [AddMonoid M] : List M → M

A variant of List.sum that has [x].sum = x true definitionally. The purpose is to make FreeAddMonoid.lift_eval_of true by rfl.

abbrev FreeAddMonoid.sumAux.match_1 {M : Type u_1} (motive : List M → Sort u_2) : (x : List M) → (Unit → motive []) → ((x : M) → (xs : List M) → motive (x :: xs)) → motive x

def FreeMonoid.prodAux {M : Type u_6} [Monoid M] : List M → M

A variant of List.prod that has [x].prod = x true definitionally. The purpose is to make FreeMonoid.lift_eval_of true by rfl.

abbrev FreeAddMonoid.sumAux_eq.match_1 {M : Type u_1} (motive : List M → Prop) : (x : List M) → (Unit → motive []) → ((head : M) → (xs : List M) → motive (head :: xs)) → motive x

theorem FreeAddMonoid.sumAux_eq {M : Type u_4} [AddMonoid M] (l : List M) : FreeAddMonoid.sumAux l = List.sum l

theorem FreeMonoid.prodAux_eq {M : Type u_4} [Monoid M] (l : List M) : FreeMonoid.prodAux l = List.prod l

theorem FreeAddMonoid.lift.proof_4 {α : Type u_2} {M : Type u_1} [AddMonoid M] (f : FreeAddMonoid α →+ M) : (fun f => { toZeroHom := { toFun := fun l => FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList l)), map_zero' := (_ : (fun l => FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList l))) 0 = (fun l => FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList l))) 0) }, map_add' := (_ : ∀ (x x_1 : FreeAddMonoid α), FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList x ++ ↑FreeAddMonoid.toList x_1)) = FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList x)) + FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList x_1))) }) ((fun f x => ↑f (FreeAddMonoid.of x)) f) = f

theorem FreeAddMonoid.lift.proof_2 {α : Type u_1} {M : Type u_2} [AddMonoid M] (f : α → M) : ∀ (x x_1 : FreeAddMonoid α), FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList x ++ ↑FreeAddMonoid.toList x_1)) = FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList x)) + FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList x_1))

theorem FreeAddMonoid.lift.proof_1 {α : Type u_2} {M : Type u_1} [AddMonoid M] (f : α → M) : (fun l => FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList l))) 0 = (fun l => FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList l))) 0

theorem FreeAddMonoid.lift.proof_3 {α : Type u_1} {M : Type u_2} [AddMonoid M] (f : α → M) : (fun f x => ↑f (FreeAddMonoid.of x)) ((fun f => { toZeroHom := { toFun := fun l => FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList l)), map_zero' := (_ : (fun l => FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList l))) 0 = (fun l => FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList l))) 0) }, map_add' := (_ : ∀ (x x_1 : FreeAddMonoid α), FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList x ++ ↑FreeAddMonoid.toList x_1)) = FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList x)) + FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList x_1))) }) f) = (fun f x => ↑f (FreeAddMonoid.of x)) ((fun f => { toZeroHom := { toFun := fun l => FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList l)), map_zero' := (_ : (fun l => FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList l))) 0 = (fun l => FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList l))) 0) }, map_add' := (_ : ∀ (x x_1 : FreeAddMonoid α), FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList x ++ ↑FreeAddMonoid.toList x_1)) = FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList x)) + FreeAddMonoid.sumAux (List.map f (↑FreeAddMonoid.toList x_1))) }) f)

def FreeAddMonoid.lift {α : Type u_1} {M : Type u_4} [AddMonoid M] : (α → M) ≃ (FreeAddMonoid α →+ M)

Equivalence between maps α → A and additive monoid homomorphisms FreeAddMonoid α →+ A.

def FreeMonoid.lift {α : Type u_1} {M : Type u_4} [Monoid M] : (α → M) ≃ (FreeMonoid α →* M)

Equivalence between maps α → M and monoid homomorphisms FreeMonoid α →* M.

@[simp]

theorem FreeAddMonoid.lift_ofList {α : Type u_1} {M : Type u_4} [AddMonoid M] (f : α → M) (l : List α) : ↑(↑FreeAddMonoid.lift f) (↑FreeAddMonoid.ofList l) = List.sum (List.map f l)

@[simp]

theorem FreeMonoid.lift_ofList {α : Type u_1} {M : Type u_4} [Monoid M] (f : α → M) (l : List α) : ↑(↑FreeMonoid.lift f) (↑FreeMonoid.ofList l) = List.prod (List.map f l)

@[simp]

theorem FreeAddMonoid.lift_symm_apply {α : Type u_1} {M : Type u_4} [AddMonoid M] (f : FreeAddMonoid α →+ M) : ↑FreeAddMonoid.lift.symm f = ↑f ∘ FreeAddMonoid.of

@[simp]

theorem FreeMonoid.lift_symm_apply {α : Type u_1} {M : Type u_4} [Monoid M] (f : FreeMonoid α →* M) : ↑FreeMonoid.lift.symm f = ↑f ∘ FreeMonoid.of

theorem FreeAddMonoid.lift_apply {α : Type u_1} {M : Type u_4} [AddMonoid M] (f : α → M) (l : FreeAddMonoid α) : ↑(↑FreeAddMonoid.lift f) l = List.sum (List.map f (↑FreeAddMonoid.toList l))

theorem FreeMonoid.lift_apply {α : Type u_1} {M : Type u_4} [Monoid M] (f : α → M) (l : FreeMonoid α) : ↑(↑FreeMonoid.lift f) l = List.prod (List.map f (↑FreeMonoid.toList l))

theorem FreeAddMonoid.lift_comp_of {α : Type u_1} {M : Type u_4} [AddMonoid M] (f : α → M) : ↑(↑FreeAddMonoid.lift f) ∘ FreeAddMonoid.of = f

theorem FreeMonoid.lift_comp_of {α : Type u_1} {M : Type u_4} [Monoid M] (f : α → M) : ↑(↑FreeMonoid.lift f) ∘ FreeMonoid.of = f

@[simp]

theorem FreeAddMonoid.lift_eval_of {α : Type u_1} {M : Type u_4} [AddMonoid M] (f : α → M) (x : α) : ↑(↑FreeAddMonoid.lift f) (FreeAddMonoid.of x) = f x

@[simp]

theorem FreeMonoid.lift_eval_of {α : Type u_1} {M : Type u_4} [Monoid M] (f : α → M) (x : α) : ↑(↑FreeMonoid.lift f) (FreeMonoid.of x) = f x

@[simp]

theorem FreeAddMonoid.lift_restrict {α : Type u_1} {M : Type u_4} [AddMonoid M] (f : FreeAddMonoid α →+ M) : ↑FreeAddMonoid.lift (↑f ∘ FreeAddMonoid.of) = f

@[simp]

theorem FreeMonoid.lift_restrict {α : Type u_1} {M : Type u_4} [Monoid M] (f : FreeMonoid α →* M) : ↑FreeMonoid.lift (↑f ∘ FreeMonoid.of) = f

theorem FreeAddMonoid.comp_lift {α : Type u_1} {M : Type u_4} [AddMonoid M] {N : Type u_5} [AddMonoid N] (g : M →+ N) (f : α → M) : AddMonoidHom.comp g (↑FreeAddMonoid.lift f) = ↑FreeAddMonoid.lift (↑g ∘ f)

theorem FreeMonoid.comp_lift {α : Type u_1} {M : Type u_4} [Monoid M] {N : Type u_5} [Monoid N] (g : M →* N) (f : α → M) : MonoidHom.comp g (↑FreeMonoid.lift f) = ↑FreeMonoid.lift (↑g ∘ f)

theorem FreeAddMonoid.hom_map_lift {α : Type u_1} {M : Type u_4} [AddMonoid M] {N : Type u_5} [AddMonoid N] (g : M →+ N) (f : α → M) (x : FreeAddMonoid α) : ↑g (↑(↑FreeAddMonoid.lift f) x) = ↑(↑FreeAddMonoid.lift (↑g ∘ f)) x

theorem FreeMonoid.hom_map_lift {α : Type u_1} {M : Type u_4} [Monoid M] {N : Type u_5} [Monoid N] (g : M →* N) (f : α → M) (x : FreeMonoid α) : ↑g (↑(↑FreeMonoid.lift f) x) = ↑(↑FreeMonoid.lift (↑g ∘ f)) x

def FreeAddMonoid.mkAddAction {α : Type u_1} {β : Type u_2} (f : α → β → β) : AddAction (FreeAddMonoid α) β

Define an additive action of FreeAddMonoid α on β.

theorem FreeAddMonoid.mkAddAction.proof_1 {α : Type u_2} {β : Type u_1} (f : α → β → β) : ∀ (x : β), 0 +ᵥ x = 0 +ᵥ x

theorem FreeAddMonoid.mkAddAction.proof_2 {α : Type u_1} {β : Type u_2} (f : α → β → β) : ∀ (x x_1 : FreeAddMonoid α) (x_2 : β), List.foldr f x_2 (↑FreeAddMonoid.toList x ++ ↑FreeAddMonoid.toList x_1) = List.foldr f (List.foldr f x_2 (↑FreeAddMonoid.toList x_1)) (↑FreeAddMonoid.toList x)

def FreeMonoid.mkMulAction {α : Type u_1} {β : Type u_2} (f : α → β → β) : MulAction (FreeMonoid α) β

Define a multiplicative action of FreeMonoid α on β.

theorem FreeAddMonoid.vadd_def {α : Type u_1} {β : Type u_2} (f : α → β → β) (l : FreeAddMonoid α) (b : β) : l +ᵥ b = List.foldr f b (↑FreeAddMonoid.toList l)

theorem FreeMonoid.smul_def {α : Type u_1} {β : Type u_2} (f : α → β → β) (l : FreeMonoid α) (b : β) : l • b = List.foldr f b (↑FreeMonoid.toList l)

theorem FreeAddMonoid.ofList_vadd {α : Type u_1} {β : Type u_2} (f : α → β → β) (l : List α) (b : β) : ↑FreeAddMonoid.ofList l +ᵥ b = List.foldr f b l

theorem FreeMonoid.ofList_smul {α : Type u_1} {β : Type u_2} (f : α → β → β) (l : List α) (b : β) : ↑FreeMonoid.ofList l • b = List.foldr f b l

@[simp]

theorem FreeAddMonoid.of_vadd {α : Type u_1} {β : Type u_2} (f : α → β → β) (x : α) (y : β) : FreeAddMonoid.of x +ᵥ y = f x y

@[simp]

theorem FreeMonoid.of_smul {α : Type u_1} {β : Type u_2} (f : α → β → β) (x : α) (y : β) : FreeMonoid.of x • y = f x y

theorem FreeAddMonoid.map.proof_2 {α : Type u_1} {β : Type u_2} (f : α → β) : ∀ (x x_1 : FreeAddMonoid α), List.map f (↑FreeAddMonoid.toList x ++ ↑FreeAddMonoid.toList x_1) = List.map f (↑FreeAddMonoid.toList x) ++ List.map f (↑FreeAddMonoid.toList x_1)

theorem FreeAddMonoid.map.proof_1 {α : Type u_2} {β : Type u_1} (f : α → β) : (fun l => ↑FreeAddMonoid.ofList (List.map f (↑FreeAddMonoid.toList l))) 0 = (fun l => ↑FreeAddMonoid.ofList (List.map f (↑FreeAddMonoid.toList l))) 0

def FreeAddMonoid.map {α : Type u_1} {β : Type u_2} (f : α → β) : FreeAddMonoid α →+ FreeAddMonoid β

The unique additive monoid homomorphism FreeAddMonoid α →+ FreeAddMonoid β that sends each of x to of (f x).

def FreeMonoid.map {α : Type u_1} {β : Type u_2} (f : α → β) : FreeMonoid α →* FreeMonoid β

The unique monoid homomorphism FreeMonoid α →* FreeMonoid β that sends each of x to of (f x).

@[simp]

theorem FreeAddMonoid.map_of {α : Type u_1} {β : Type u_2} (f : α → β) (x : α) : ↑(FreeAddMonoid.map f) (FreeAddMonoid.of x) = FreeAddMonoid.of (f x)

@[simp]

theorem FreeMonoid.map_of {α : Type u_1} {β : Type u_2} (f : α → β) (x : α) : ↑(FreeMonoid.map f) (FreeMonoid.of x) = FreeMonoid.of (f x)

theorem FreeAddMonoid.toList_map {α : Type u_1} {β : Type u_2} (f : α → β) (xs : FreeAddMonoid α) : ↑FreeAddMonoid.toList (↑(FreeAddMonoid.map f) xs) = List.map f (↑FreeAddMonoid.toList xs)

theorem FreeMonoid.toList_map {α : Type u_1} {β : Type u_2} (f : α → β) (xs : FreeMonoid α) : ↑FreeMonoid.toList (↑(FreeMonoid.map f) xs) = List.map f (↑FreeMonoid.toList xs)

theorem FreeAddMonoid.ofList_map {α : Type u_1} {β : Type u_2} (f : α → β) (xs : List α) : ↑FreeAddMonoid.ofList (List.map f xs) = ↑(FreeAddMonoid.map f) (↑FreeAddMonoid.ofList xs)

theorem FreeMonoid.ofList_map {α : Type u_1} {β : Type u_2} (f : α → β) (xs : List α) : ↑FreeMonoid.ofList (List.map f xs) = ↑(FreeMonoid.map f) (↑FreeMonoid.ofList xs)

theorem FreeAddMonoid.lift_of_comp_eq_map {α : Type u_1} {β : Type u_2} (f : α → β) : (↑FreeAddMonoid.lift fun x => FreeAddMonoid.of (f x)) = FreeAddMonoid.map f

theorem FreeMonoid.lift_of_comp_eq_map {α : Type u_1} {β : Type u_2} (f : α → β) : (↑FreeMonoid.lift fun x => FreeMonoid.of (f x)) = FreeMonoid.map f

theorem FreeAddMonoid.map_comp {α : Type u_1} {β : Type u_2} {γ : Type u_3} (g : β → γ) (f : α → β) : FreeAddMonoid.map (g ∘ f) = AddMonoidHom.comp (FreeAddMonoid.map g) (FreeAddMonoid.map f)

theorem FreeMonoid.map_comp {α : Type u_1} {β : Type u_2} {γ : Type u_3} (g : β → γ) (f : α → β) : FreeMonoid.map (g ∘ f) = MonoidHom.comp (FreeMonoid.map g) (FreeMonoid.map f)

@[simp]

theorem FreeAddMonoid.map_id {α : Type u_1} : FreeAddMonoid.map id = AddMonoidHom.id (FreeAddMonoid α)

@[simp]

theorem FreeMonoid.map_id {α : Type u_1} : FreeMonoid.map id = MonoidHom.id (FreeMonoid α)