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

Author

Samuel J. Bevins, Feb 12 2023

Keywords

• nonn
• tabf

Examples

			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
		

Links

• 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.

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.

Programs

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))