A360571 Triangle read by rows: T(n,k) is the k-th Lie-Betti number of the path graph on n-vertices, n >= 1, 0 <= k <= 2*n - 1.

1, 1, 1, 2, 2, 1, 1, 3, 6, 6, 3, 1, 1, 4, 11, 16, 16, 11, 4, 1, 1, 5, 17, 33, 48, 48, 33, 17, 5, 1, 1, 6, 24, 58, 107, 140, 140, 107, 58, 24, 6, 1, 1, 7, 32, 92, 203, 329, 424, 424, 329, 203, 92, 32, 7, 1, 1, 8, 41, 136, 347, 668, 1039, 1280, 1280, 1039, 668, 347, 136, 41, 8, 1

Offset

1,4

Links

Table of n, a(n) for n=1..72.

Marco Aldi and Samuel Bevins, L_oo-algebras and hypergraphs, arXiv:2212.13608 [math.CO], 2022. See page 9.

Meera Mainkar, Graphs and two step nilpotent Lie algebras, arXiv:1310.3414 [math.DG], 2013. See page 1.

Eric Weisstein's World of Mathematics, Path Graph.

Example

Triangle begins:
      k=0  1  2   3   4    5    6    7     8     9   10   11   12  13 14 15
  n=1:  1  1
  n=2:  1  2  2   1
  n=3:  1  3  6   6   3    1
  n=4:  1  4 11  16  16   11    4    1
  n=5:  1  5 17  33  48   48   33   17     5     1
  n=6:  1  6 24  58 107  140  140  107    58    24    6    1
  n=7:  1  7 32  92 203  329  424  424   329   203   92   32    7   1
  n=8:  1  8 41 136 347  668 1039 1280  1280  1039  668  347  136  41  8  1

Prog

(SageMath)
from sage.algebras.lie_algebras.lie_algebra import LieAlgebra
def LieAlgebraFromGraph(G, Module = QQ):
    ''' Takes a graph and a module (optional) as an input.'''
    d = {}
    for edge in G.edges(): # this defines the relations among the generators of the Lie algebra
        key = ("x" + str(edge[0]), "x" + str(edge[1])) #[x_i, x_j]
        value = {"x_" + str(edge[0]) + "_" + str(edge[1]): 1} #x_{i, j}
        d[key] = value #appending to the dictionary d
    C = LieAlgebras(Module).WithBasis().Graded() #defines the category that we need to work with.
    C = C.FiniteDimensional().Stratified().Nilpotent() #specifies that the algebras we want should be finite, stratified, and nilpotent
    L = LieAlgebra(Module, d, nilpotent=True, category=C)
    def sort_generators_by_grading(lie_algebra, grading_operator): #this sorts the generators by their grading. In this case, V1 are vertices and V2
        generators = lie_algebra.gens()
        grading = [grading_operator(g) for g in generators] #using the grading operator to split the elements into their respective vector spaces
        sorted_generators = [g for _, g in sorted(zip(grading, generators))]
        grouped_generators = {}
        for g in sorted_generators:
            if grading_operator(g) in grouped_generators:
                grouped_generators[grading_operator(g)].append(g)
            else:
                grouped_generators[grading_operator(g)] = [g]
        return grouped_generators
    grading_operator = lambda g: g.degree() #defining the grading operator
    grouped_generators = sort_generators_by_grading(L, grading_operator) #evaluating the function to pull the generators apart
    V1 = grouped_generators[1] #elements from vertices
    V2 = grouped_generators[2] #elements from edges
    return L #, V1, V2 #returns the Lie algebra and the two vector spaces
def betti_numbers(lie_algebra): #this function will calculate the Lie theoretic Betti numbers and return them as a list
    dims = []
    H = lie_algebra.cohomology()
    for n in range(lie_algebra.dimension() + 1):
        dims.append(H[n].dimension())
    return dims
def A360571_row(n):
    if n == 1: return [1, 1]
    return betti_numbers(LieAlgebraFromGraph(graphs.PathGraph(n)))
for n in range(1, 7): print(A360571_row(n))

Crossrefs

Cf. A360572 (cycle graph), A088459 (star graph), A360625 (complete graph), A360938 (ladder graph), A360937 (wheel graph).

Cf. A063782 appears to be half the row sum.

Sequence in context: A010048 A055870 A360208 * A088459 A300699 A007799

Adjacent sequences: A360568 A360569 A360570 * A360572 A360573 A360574

Keyword

nonn,tabf

Author

Samuel J. Bevins, Feb 12 2023

Status

approved