A Linear Algorithm for Computing Independence Polynomials of Trees

1 Introduction

1.1 Definitions

Throughout this paper $G = (V, E)$ is a simple (i.e., a finite, connected, undirected, loopless and without multiple edges) graph with vertex set $V = V (G)$ of cardinality $| V (G) | = n (G)$ and edge set $E = E (G)$ of cardinality $| E (G) | = m (G)$ .

A set $S \in V (G)$ is independent if no two vertices in $S$ are adjacent. An independent set of maximum cardinality, named a maximum independent set, and its size is called the independence number and denoted $α (G)$ . An independence polynomial of graph $G$ defined by Gutman and Harary in 1983 [1]:

I (G; x) = α (G) \sum k = 0 s_{k} x^{k} = s_{0} + s_{1} x + s_{2} x^{2} + . . . + s_{α (G)} x^{α (G)}

(1)

where $s_{k}$ denotes the number of independent sets of cardinality $k$ in the graph $G$ . $s_{0} = 1$ is the number of independent sets with minimal cardinality in $G$ (i.e empty set) [6].

A tree decomposition of a general graph $G (V, E)$ is a tree $T$ of ”bags”, where if edge $(u, v) \in E (G)$ then $u$ and $v$ are together in same ”bag”, and $\forall u \in V (G)$ the “bags” containing $u$ are connected in $T$ . The width of a tree decomposition equal to one less than the maximum bag size and the treewidth of $G (V, E)$ equal to least width of all tree decompositions for $G$ .

1.2 Computing the independence polynomial

To compute the independence polynomials $I (G; x)$ , as shown in Levit and Mandrescu survey [2] one can use the following recursive formula:

I (G; x) = I (G - v; x) + x \cdot I (G - N [v]; x)

(2)

where N[v] is the neighborhood of the vertex v including v itself.

To compute the independence polynomials of union of graphs the formula is [7, 2]:

I (G_{1} \cup G_{2}; x) = I (G_{1}; x) \cdot I (G_{2}; x)

(3)

1.3 Problem

Some facts on similar problems:

Computing the Maximum Independent Set of a general graph is an NP-Complete problem.
Computing the Independence Polynomial of a general graph is also an NP-Complete problem. The degree of the independence polynomial is equivalent to the Maximum Independent Set.
There are families of graphs with a closed-form expression for their independence polynomial [8], but from what is known, trees are not one of them.
Some families of graphs have a polynomial algorithm to compute their $α (G)$ . Does it give us hope for a polynomial algorithm to compute their independence polynomials?

According to Bodlaender [4], many practical problems rely heavily on graphs with bounded treewidth. Tittmann [5] offers a way for the construction of an algorithm that computes the independence polynomial of a graph with bounded treewidth in polynomial time based on a specific partition.
Based on Tittmann, who described in acronyms how an algorithm for graphs with a bounded treewidth should look, we accurately investigated an actual algorithm for trees.

Yosef, Mizrachi, and K. developed an efficient approach for computing the independence polynomials of trees with $n$ vertices [3]. This approach is based on an extensive database containing the independence polynomials of all the trees with up to $n - 1$ vertices, and the induction step computing the independence polynomials of all the trees with $n$ vertices based on their $n - 1$ counterparts. Although this approach works well with small-sized trees, big trees may require an enormous database to compute their independence polynomials.

2 Main idea of algorithm

The new algorithm is not based on a database nor requires one. Instead, it used the dynamic programming technique.

The independence polynomial $I (G; x)$ represented in the algorithm as a list with $α (G) + 1$ cells in the following format:

[s_{k = α (G)}, s_{k = α (G) - 1}, . . ., s_{k = 1}, s_{k = 0}]

Graph	$I (G; x)$	Stored as
$P_{1}$	$x + 1$	$[1, 1]$
$P_{2}$	$2 x + 1$	$[2, 1]$
$P_{3}$	$x^{2} + 3 x + 1$	$[1, 3, 1]$

Table 1: Path graphs with 1,2 and 3 vertices and their representation in the algorithm.

From the computing process, the independence polynomial formula, as described in (2), says that every vertex can be calculated just after its children and grandchildren are calculated. Post-order-traversal validates that the children and grandchildren vertices will be computed before the father vertex.

To examine all tree graphs, we divided them into three cases:

$| V | = 1$ :
- $I (G - v; x) = [1]$ because $G - v$ has no vertices in $G - v$ , there is one independent set of cardinality zero (i.e., empty set).
- $I (G - N [v]; x) = [1]$ from the same reason above. so:
$I (G; x) = [1] + [1, 0] \cdot [1] = [1, 1]$
$| V | = 2$ :
- $I (G - v; x) = [1, 1]$ because when vertex $v$ removed, the graph stay with only one vertex, and this sub-graph matches the previous case.
- $I (G - N [v]; x) = [1]$ because $G - N [v]$ has no vertices in $G - v$ , there is one independent set of cardinality zero (i.e., empty set). so:
$I (G; x) = [1, 1] + [1, 0] \cdot [1] = [2, 1]$
$| V | > 2$ :
1. Start with traveling on the tree in post-order traversal. When reaching a leaf node, like case 1, it can calculate by A:
  - $I (G - v; x) = [1]$
  - $x \cdot I (G - N [v]; x) = [1, 0]$
  $I (G; x) = [1, 1]$
2. For an inner vertex that all its children were calculated, when vertex v is removed, the number of connected components can rise, and in such case, computation of sub-graphs union, as described in (3), is needed.
  So in purpose to calculate $I (T; x)$ , compute next parameters:
  - $I (T - v; x) = Π_{u \in c h i l d r e n [v]} I (T; x)$
  - $I (T - N [v]; x)$ parameter said that we remove the vertex v with its neighbors so we can use $I (T - v; x)$ parameter of the children:
    
    $I (T - N [v]; x) = Π_{u \in c h i l d r e n [v]} I (T - u; x)$

Finally use formula 2 to calculate $I (T; x)$ .

3 Main Algorithm

The algorithm in FIP (find independence polynomial) function starts at selected root node of a tree and goes as far as it can down a given branch in FIPR (find independence polynomial recursion) function, then backtracks until it finds an unexplored path, and then explores it. The algorithm does this until the entire graph has been explored.

Input: Tree T as adjacency list

Output: A list IP that represents the independence polynomial of T

// Two base cases:

1 if $| V | == 1$ then

2 return [1,1]

3if $| V | == 2$ then

4 return [2,1]

// Select a root vertex that not a leaf:

r o o t \leftarrow f i n d I n n e r V e r t e x ()

// Call the recursive function:

6 FIPR(T, root)

// Return the independence polynomial of

T

return $I_{o} f_{T} (r o o t)$

Algorithm 1 FIP(T)

Input: Tree T as adjacency list, root vertex

Output: Three lists: I(T; x), I(T-v; x), I(T-N[v]; x)

// Stop condition:

1 if root is a leaf then

2 I_of_T_minus_v(root)

\leftarrow

[1]

3 I_of_T_minus_Nv(root)

\leftarrow

[1]

4 I_of_T(root)

\leftarrow

[1, 1]

6 else

// Explore undiscovered vertices that are root-neighbors:

7 foreach vertex u in N[root] that never explored do

// Save the hierarchy:

8 vertex_children(root).append(u)

// Call again recursively with u:

9 FIPR(T, u)

l e f t \leftarrow [1]

// Neutral organ to multiply

r i g h t \leftarrow [1, 0]

// Initialize as x

// Calculate the union of sub-graphs

10 foreach u in vertex_Children do

l e f t \leftarrow l e f t * I_o f_T (u)

// polynomial multiplication

r i g h t \leftarrow r i g h t * I_o f_T_m i n u s_v (u)

// Set all lists in

r o o t

index

13 I_of_T_minus_v(root)

\leftarrow l e f t

14 I_of_T_minus_Nv(root)

\leftarrow r i g h t

I_of_T(root)

\leftarrow l e f t + r i g h t

// polynomial Addition

Algorithm 2 FIPR(T, root)

4 Proof of correctness

Lemma 4.1.

FIPR(T, root) is called exactly once for each vertex in the graph

Proof.

Clearly FIPR(T, root) is called for a vertex u only if it not discovered. The moment it’s called, FIPR(T, root) cannot be called vertex v again. Furthermore, because T is connected component, and FIPR(T, root) uses post order travesal in the implementation, it’s ensures that it will be called for every vertex in T. ∎

Lemma 4.2.

The body of the foreach loop that explore undiscovered vertices that are root-neighbors (lines 6-8) is executed exactly once for each edge (v,u) in the graph.

Proof.

FIPR(T, root) is called exactly once for each vertex root (Claim 1). And the body of the loop is executed once for all the unseen edges that connect to root. ∎

Corollary 4.1.

The algorithm can start from every vertex root such that
$d e g (v) \geq 2$ and get the same runtime.

Proof.

The order of walking on the tree is in post order travels. In this way, it go through each edge exactly twice so that is no matter which vertex v $(d e g (v) \geq 2)$ it start from, the running time will remain the same. ∎

Therefore, the running time of the FIPR(T, root) algorithm is $O (n + m)$ , and the tested graphs are trees, so it summarise to $O (n)$ .

5 Conclusion

In this article we have presented a linear algorithm that uses dynamic programming to find an independence polynomial of trees. The algorithm uses a post-order-travel over the graph. when it reaches the leaves it calculates them, and in the backtracking, when all children were calculated, there comes the father turn to compute.

References

[1] Gutman I. and Harary F., Generalizations of the matching polynomial, Utilitas Mathematica, Vol. 24, 97-106, 1983.
[2] Levit V. E. and Mandrescu E., The independence polynomial of a graph - a survey Proceedings of the 1st International Conference on Algebraic Informatics, 231-252, 2005.
[3] Yosef R., Mizrachi M., Kadrawi O. On unimodality of independence polynomials of trees, https://arxiv.org/pdf/2101.06744v3.pdf, 2021.
[4] Hans L. B., A linear time algorithm for finding tree-decompositions of small treewidth, SIAM,
https://epubs.siam.org/doi/pdf/10.1137/S0097539793251219, 1996.
[5] Tittmann P. Graph polynomials: The Ethernal Book, 2021.
[6] Levit V. E. and Mandrescu E., On Unimodality of Independence Polynomials of some Well-Covered Trees, Discrete Mathematics and Theoretical Computer Science, Vol. 4, 237-256, 2003.
[7] Hoede C. and Li X., Clique polynomials and independent set polynomials of graphs, Discrete Mathematics, Vol. 125, 219-228, 1994.
[8] Ferrin G. M., Independence polynomials ,University of South Carolina, Master’s thesis, 2014.
https://scholarcommons.sc.edu/cgi/viewcontent.cgi?article=3632 $&$ context=etd

A Linear Algorithm for Computing Independence Polynomials of Trees

Authors

On Unimodality of Independence Polynomials of Trees

Enumerating Minimal Separators in Ranked Order

Transversals of Longest Cycles in Partial k-Trees and Chordal Graphs

Harary polynomials

Massively Parallel Dynamic Programming on Trees

On Huang and Wong's Algorithm for Generalized Binary Split Trees

Table Based Detection of Degenerate Predicates in Free Space Construction

1 Introduction

1.1 Definitions

1.2 Computing the independence polynomial

1.3 Problem

2 Main idea of algorithm

3 Main Algorithm

4 Proof of correctness

Lemma 4.1.

Proof.

Lemma 4.2.

Proof.

Corollary 4.1.

Proof.

5 Conclusion

References

A Linear Algorithm for Computing Independence Polynomials of Trees

Authors

Related Research

On Unimodality of Independence Polynomials of Trees

Enumerating Minimal Separators in Ranked Order

Transversals of Longest Cycles in Partial k-Trees and Chordal Graphs

Harary polynomials

Massively Parallel Dynamic Programming on Trees

On Huang and Wong's Algorithm for Generalized Binary Split Trees

Table Based Detection of Degenerate Predicates in Free Space Construction

This week in AI

1 Introduction

1.1 Definitions

1.2 Computing the independence polynomial

1.3 Problem

2 Main idea of algorithm

3 Main Algorithm

4 Proof of correctness

Lemma 4.1.

Proof.

Lemma 4.2.

Proof.

Corollary 4.1.

Proof.

5 Conclusion

References