Grossman-Larson Hopf algebras - Algebras

Skip to content
Back to top
View this page
Edit this page

# Grossman-Larson Hopf algebras

AUTHORS:

- Frédéric Chapoton (2017)

class sage.combinat.grossman_larson_algebras.GrossmanLarsonAlgebra(R, names=None)

  Bases: `CombinatorialFreeModule`

  The Grossman-Larson Hopf Algebra.

  The Grossman-Larson Hopf Algebras are Hopf algebras with a basis indexed by forests of decorated rooted trees. They are the universal enveloping algebras of free pre-Lie algebras, seen as Lie algebras.

  The Grossman-Larson 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

      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

  Python

      >>> from sage.all import *
      >>> G = algebras.GrossmanLarson(QQ, 'xy')
      >>> x, y = G.single_vertex_all()
      >>> ascii_art(x*y)
      B  + B
       #      #_
       |     / /
       x    x y
       |
       y

      >>> ascii_art(x*x*x)
      B  + B     + 3*B     + B
       #      #         #_      _#__
       |      |        / /     / / /
       x      x_      x x     x x x
       |     / /        |
       x    x x         x
       |
       x

  The Grossman-Larson algebra is associative:

  Sage

      sage: z = x * y
      sage: x * (y * z) == (x * y) * z
      True

  [Python]

      >>> from sage.all import *
      >>> z = x * y
      >>> x * (y * z) == (x * y) * z
      True

  It is not commutative:

  Sage

      sage: x * y == y * x
      False

  Python

      >>> from sage.all import *
      >>> 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

      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

  [Python]

      >>> from sage.all import *
      >>> G = algebras.GrossmanLarson(QQ, None)
      >>> x = G.single_vertex_all()[Integer(0)]
      >>> 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. When `None` is given, unlabelled rooted forests are used. When a single string is given, each letter is taken as a variable. See `sage.combinat.words.alphabet.build_alphabet()`.

  Warning

  Beware that the underlying combinatorial free module is based either on `RootedTrees` or on `LabelledRootedTrees`, with no restriction on the labellings. This means that all code calling the `basis()` method would not give meaningful results, since `basis()` returns many “chaff” elements that do not belong to the algebra.

  REFERENCES:

  - [Pana2002]

  - [GroLar1]

  antipode_on_basis(x)

    Return the antipode of a forest.

    EXAMPLES:

    Sage

        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[]]]

    Python

        >>> from sage.all import *
        >>> G = algebras.GrossmanLarson(QQ,Integer(2))
        >>> x, y = G.single_vertex_all()
        >>> G.antipode(x)  # indirect doctest
        -B[#[0[]]]

        >>> G.antipode(y*x)  # indirect doctest
        B[#[0[1[]]]] + B[#[0[], 1[]]]

  change_ring(R)

    Return the Grossman-Larson algebra in the same variables over \(R\).

    INPUT:

    - `R` – a ring

    EXAMPLES:

    Sage

        sage: A = algebras.GrossmanLarson(ZZ, 'fgh')
        sage: A.change_ring(QQ)
        Grossman-Larson Hopf algebra on 3 generators ['f', 'g', 'h']
        over Rational Field

    Python

        >>> from sage.all import *
        >>> A = algebras.GrossmanLarson(ZZ, 'fgh')
        >>> A.change_ring(QQ)
        Grossman-Larson Hopf algebra on 3 generators ['f', 'g', 'h']
        over Rational Field

  coproduct_on_basis(x)

    Return the coproduct of a forest.

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> G = algebras.GrossmanLarson(QQ,Integer(2))
        >>> x, y = G.single_vertex_all()
        >>> ascii_art(G.coproduct(x))  # indirect doctest
        1 # B  + B  # 1
             #    #
             |    |
             0    0

        >>> Delta_xy = G.coproduct(y*x)
        >>> 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

        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

    Python

        >>> from sage.all import *
        >>> A = algebras.GrossmanLarson(QQ, 'xy')
        >>> RT = A.basis().keys()
        >>> x = RT([RT([],'x')],'#')
        >>> A.counit_on_basis(x)
        0
        >>> A.counit_on_basis(RT([],'#'))
        1

  degree_on_basis(t)

    Return the degree of a rooted forest in the Grossman-Larson algebra.

    This is the total number of vertices of the forest.

    EXAMPLES:

    Sage

        sage: A = algebras.GrossmanLarson(QQ, '@')
        sage: RT = A.basis().keys()
        sage: A.degree_on_basis(RT([RT([])]))
        1

    Python

        >>> from sage.all import *
        >>> A = algebras.GrossmanLarson(QQ, '@')
        >>> RT = A.basis().keys()
        >>> A.degree_on_basis(RT([RT([])]))
        1

  one_basis()

    Return the empty rooted forest.

    EXAMPLES:

    Sage

        sage: A = algebras.GrossmanLarson(QQ, 'ab')
        sage: A.one_basis()
        #[]

        sage: A = algebras.GrossmanLarson(QQ, None)
        sage: A.one_basis()
        []

    Python

        >>> from sage.all import *
        >>> A = algebras.GrossmanLarson(QQ, 'ab')
        >>> A.one_basis()
        #[]

        >>> A = algebras.GrossmanLarson(QQ, None)
        >>> 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 side-by-side with components of \(x\) or be grafted on a vertex of \(x\).

    EXAMPLES:

    Sage

        sage: A = algebras.GrossmanLarson(QQ, None)
        sage: RT = A.basis().keys()
        sage: x = RT([RT([])])
        sage: A.product_on_basis(x, x)
        B[[[[]]]] + B[[[], []]]

    Python

        >>> from sage.all import *
        >>> A = algebras.GrossmanLarson(QQ, None)
        >>> RT = A.basis().keys()
        >>> x = RT([RT([])])
        >>> A.product_on_basis(x, x)
        B[[[[]]]] + B[[[], []]]

    Check that the product is the correct one:

    Sage

        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[]]]

    [Python]

        >>> from sage.all import *
        >>> A = algebras.GrossmanLarson(QQ, 'uv')
        >>> RT = A.basis().keys()
        >>> Tu = RT([RT([],'u')],'#')
        >>> Tv = RT([RT([],'v')],'#')
        >>> 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

    `single_vertex_all()`.

    INPUT:

    - `i` – nonnegative integer

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> F = algebras.GrossmanLarson(ZZ, 'xyz')
        >>> F.single_vertex(Integer(0))
        B[#[x[]]]

        >>> F.single_vertex(Integer(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 pre-Lie algebra.

    See also

    `single_vertex()`.

    EXAMPLES:

    Sage

        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[[[]]],)

    Python

        >>> from sage.all import *
        >>> A = algebras.GrossmanLarson(ZZ, 'fgh')
        >>> A.single_vertex_all()
        (B[#[f[]]], B[#[g[]]], B[#[h[]]])

        >>> A = algebras.GrossmanLarson(QQ, ['x1','x2'])
        >>> A.single_vertex_all()
        (B[#[x1[]]], B[#[x2[]]])

        >>> A = algebras.GrossmanLarson(ZZ, None)
        >>> A.single_vertex_all()
        (B[[[]]],)

  some_elements()

    Return some elements of the Grossman-Larson Hopf algebra.

    EXAMPLES:

    Sage

        sage: A = algebras.GrossmanLarson(QQ, None)
        sage: A.some_elements()
        [B[[[]]], B[[]] + B[[[[]]]] + B[[[], []]],
        4*B[[[[]]]] + 4*B[[[], []]]]

    Python

        >>> from sage.all import *
        >>> A = algebras.GrossmanLarson(QQ, None)
        >>> A.some_elements()
        [B[[[]]], B[[]] + B[[[[]]]] + B[[[], []]],
        4*B[[[[]]]] + 4*B[[[], []]]]

    With several generators:

    Sage

        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[]]]]

    [Python]

        >>> from sage.all import *
        >>> A = algebras.GrossmanLarson(QQ, 'xy')
        >>> 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

        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'}

    Python

        >>> from sage.all import *
        >>> R = algebras.GrossmanLarson(QQ, 'xy')
        >>> R.variable_names()
        {'x', 'y'}

        >>> R = algebras.GrossmanLarson(QQ, ['a','b'])
        >>> R.variable_names()
        {'a', 'b'}

        >>> R = algebras.GrossmanLarson(QQ, Integer(2))
        >>> R.variable_names()
        {0, 1}

        >>> R = algebras.GrossmanLarson(QQ, None)
        >>> R.variable_names()
        {'o'}