GrossmanLarson Hopf Algebras¶
AUTHORS:
 Frédéric Chapoton (2017)

class
sage.combinat.grossman_larson_algebras.
GrossmanLarsonAlgebra
(R, names=None)¶ Bases:
sage.combinat.free_module.CombinatorialFreeModule
The GrossmanLarson Hopf Algebra.
The GrossmanLarson Hopf Algebras are Hopf algebras with a basis indexed by forests of decorated rooted trees. They are the universal enveloping algebras of free preLie algebras, seen as Lie algebras.
The GrossmanLarson Hopf algebra on a given set \(E\) has an explicit description using rooted forests. The underlying vector space has a basis indexed by finite rooted forests endowed with a map from their vertices to \(E\) (called the “labeling”). In this basis, the product of two (decorated) rooted forests \(S * T\) is a sum over all maps from the set of roots of \(T\) to the union of a singleton \(\{\#\}\) and the set of vertices of \(S\). Given such a map, one defines a new forest as follows. Starting from the disjoint union of all rooted trees of \(S\) and \(T\), one adds an edge from every root of \(T\) to its image when this image is not the fake vertex labelled
#
. The coproduct sends a rooted forest \(T\) to the sum of all tensors \(T_1 \otimes T_2\) obtained by splitting the connected components of \(T\) into two subsets and letting \(T_1\) be the forest formed by the first subset and \(T_2\) the forest formed by the second. This yields a connected graded Hopf algebra (the degree of a forest is its number of vertices).See [Pana2002] (Section 2) and [GroLar1]. (Note that both references use rooted trees rather than rooted forests, so think of each rooted forest grafted onto a new root. Also, the product is reversed, so they are defining the opposite algebra structure.)
Warning
For technical reasons, instead of using forests as labels for the basis, we use rooted trees. Their root vertex should be considered as a fake vertex. This fake root vertex is labelled
'#'
when labels are present.EXAMPLES:
sage: G = algebras.GrossmanLarson(QQ, 'xy') sage: x, y = G.single_vertex_all() sage: ascii_art(x*y) B + B # #_  / / x x y  y sage: ascii_art(x*x*x) B + B + 3*B + B # # #_ _#__   / / / / / x x_ x x x x x  / /  x x x x  x
The GrossmanLarson algebra is associative:
sage: z = x * y sage: x * (y * z) == (x * y) * z True
It is not commutative:
sage: x * y == y * x False
When
None
is given as input, unlabelled forests are used instead; this corresponds to a \(1\)element set \(E\):sage: G = algebras.GrossmanLarson(QQ, None) sage: x = G.single_vertex_all()[0] sage: ascii_art(x*x) B + B o o_  / / o o o  o
Note
Variables names can be
None
, a list of strings, a string or an integer. WhenNone
is given, unlabelled rooted forests are used. When a single string is given, each letter is taken as a variable. Seesage.combinat.words.alphabet.build_alphabet()
.Warning
Beware that the underlying combinatorial free module is based either on
RootedTrees
or onLabelledRootedTrees
, with no restriction on the labellings. This means that all code calling thebasis()
method would not give meaningful results, sincebasis()
returns many “chaff” elements that do not belong to the algebra.REFERENCES:

an_element
()¶ Return an element of
self
.EXAMPLES:
sage: A = algebras.GrossmanLarson(QQ, 'xy') sage: A.an_element() B[#[x[]]] + 2*B[#[x[x[]]]] + 2*B[#[x[], x[]]]

antipode_on_basis
(x)¶ Return the antipode of a forest.
EXAMPLES:
sage: G = algebras.GrossmanLarson(QQ,2) sage: x, y = G.single_vertex_all() sage: G.antipode(x) # indirect doctest B[#[0[]]] sage: G.antipode(y*x) # indirect doctest B[#[0[1[]]]] + B[#[0[], 1[]]]

change_ring
(R)¶ Return the GrossmanLarson algebra in the same variables over \(R\).
INPUT:
 \(R\) – a ring
EXAMPLES:
sage: A = algebras.GrossmanLarson(ZZ, 'fgh') sage: A.change_ring(QQ) GrossmanLarson Hopf algebra on 3 generators ['f', 'g', 'h'] over Rational Field

coproduct_on_basis
(x)¶ Return the coproduct of a forest.
EXAMPLES:
sage: G = algebras.GrossmanLarson(QQ,2) sage: x, y = G.single_vertex_all() sage: ascii_art(G.coproduct(x)) # indirect doctest 1 # B + B # 1 # #   0 0 sage: Delta_xy = G.coproduct(y*x) sage: ascii_art(Delta_xy) # random indirect doctest 1 # B + 1 # B + B # B + B # 1 + B # B + B # 1 #_ # # # #_ # # # / /    / /    0 1 1 0 1 0 1 1 0 1   0 0

counit_on_basis
(x)¶ Return the counit on a basis element.
This is zero unless the forest \(x\) is empty.
EXAMPLES:
sage: A = algebras.GrossmanLarson(QQ, 'xy') sage: RT = A.basis().keys() sage: x = RT([RT([],'x')],'#') sage: A.counit_on_basis(x) 0 sage: A.counit_on_basis(RT([],'#')) 1

degree_on_basis
(t)¶ Return the degree of a rooted forest in the GrossmanLarson algebra.
This is the total number of vertices of the forest.
EXAMPLES:
sage: A = algebras.GrossmanLarson(QQ, '@') sage: RT = A.basis().keys() sage: A.degree_on_basis(RT([RT([])])) 1

one_basis
()¶ Return the empty rooted forest.
EXAMPLES:
sage: A = algebras.GrossmanLarson(QQ, 'ab') sage: A.one_basis() #[] sage: A = algebras.GrossmanLarson(QQ, None) sage: A.one_basis() []

product_on_basis
(x, y)¶ Return the product of two forests \(x\) and \(y\).
This is the sum over all possible ways for the components of the forest \(y\) to either fall sidebyside with components of \(x\) or be grafted on a vertex of \(x\).
EXAMPLES:
sage: A = algebras.GrossmanLarson(QQ, None) sage: RT = A.basis().keys() sage: x = RT([RT([])]) sage: A.product_on_basis(x, x) B[[[[]]]] + B[[[], []]]
Check that the product is the correct one:
sage: A = algebras.GrossmanLarson(QQ, 'uv') sage: RT = A.basis().keys() sage: Tu = RT([RT([],'u')],'#') sage: Tv = RT([RT([],'v')],'#') sage: A.product_on_basis(Tu, Tv) B[#[u[v[]]]] + B[#[u[], v[]]]

single_vertex
(i)¶ Return the
i
th rooted forest with one vertex.This is the rooted forest with just one vertex, labelled by the
i
th element of the label list.See also
INPUT:
i
– a nonnegative integer
EXAMPLES:
sage: F = algebras.GrossmanLarson(ZZ, 'xyz') sage: F.single_vertex(0) B[#[x[]]] sage: F.single_vertex(4) Traceback (most recent call last): ... IndexError: argument i (= 4) must be between 0 and 2

single_vertex_all
()¶ Return the rooted forests with one vertex in
self
.They freely generate the Lie algebra of primitive elements as a preLie algebra.
See also
EXAMPLES:
sage: A = algebras.GrossmanLarson(ZZ, 'fgh') sage: A.single_vertex_all() (B[#[f[]]], B[#[g[]]], B[#[h[]]]) sage: A = algebras.GrossmanLarson(QQ, ['x1','x2']) sage: A.single_vertex_all() (B[#[x1[]]], B[#[x2[]]]) sage: A = algebras.GrossmanLarson(ZZ, None) sage: A.single_vertex_all() (B[[[]]],)

some_elements
()¶ Return some elements of the GrossmanLarson Hopf algebra.
EXAMPLES:
sage: A = algebras.GrossmanLarson(QQ, None) sage: A.some_elements() [B[[[]]], B[[]] + B[[[[]]]] + B[[[], []]], 4*B[[[[]]]] + 4*B[[[], []]]]
With several generators:
sage: A = algebras.GrossmanLarson(QQ, 'xy') sage: A.some_elements() [B[#[x[]]], B[#[]] + B[#[x[x[]]]] + B[#[x[], x[]]], B[#[x[x[]]]] + 3*B[#[x[y[]]]] + B[#[x[], x[]]] + 3*B[#[x[], y[]]]]

variable_names
()¶ Return the names of the variables.
This returns the set \(E\) (as a family).
EXAMPLES:
sage: R = algebras.GrossmanLarson(QQ, 'xy') sage: R.variable_names() {'x', 'y'} sage: R = algebras.GrossmanLarson(QQ, ['a','b']) sage: R.variable_names() {'a', 'b'} sage: R = algebras.GrossmanLarson(QQ, 2) sage: R.variable_names() {0, 1} sage: R = algebras.GrossmanLarson(QQ, None) sage: R.variable_names() {'o'}
