3.1.1 Depth First Search

DFS, or depth-first search algorithm, is recognized for providing the steps to explore all the graph nodes without repeating any of them. Figure 4 shows the path DFS(G,v) in depth with the origin node A. The idea is:

Fig. 4 DFS route (A, B, E, F, C, G, I, J, H, D) 

3.1.2 Hamiltonian Path

The first step of our method for counting independent sets in a graph involves the construction of a Hamiltonian path (Hc) over the input graph G. During this traversal, Hc visits each vertex of the graph exactly once, identifying each edge of the graph as a tree edge or a frond edge.

Although finding a Hamiltonian cycle in any graph is a classic NP-Complete problem, in this case, the constraints are relaxed by considering paths instead of cycles, which avoids returning to the same starting point.

This relaxation is most evident when examining graph topologies such as meshes, where the searching for an Hc becomes a linear time complexity problem. An example is the case of regular meshes, where Hc can follow a route through rows, alternating directions in odd and even rows.

3.1.3 Fibonacci Calculation in Graphs

Counting the number of independent sets i(G) in a graph G involves traversing the Hamiltonian path Hc of G [⁴]. During this traversal, the first pair of values starts with (αi, βi)=(1, 1). For the following identified edges, one of two rules applies. The Fibonacci recurrence rule:

If we consider that vi belongs to the path Pn, and vi+1 is the next vertex that will visit an edge of the tree (vi, vi+1), then the following recurrence equation is applied to compute the charge (αvi+1, βvi+1) as a function of the charge (αvi, βvi):

We call the previous pair of recurrences the Fibonacci rule recurrence because when they are applied to a path Pn−th, we obtain the knowledge identity i(Pn)=αvi+1+βvi+1=Fn+Fn+1=Fn+2, where Fn is the n-th Fibonacci number:

Let us illustrate our proposal with an example; in Figure 5, we show how to compute the M−S index of the graph. The Hamiltonian path used to traverse G is A−B−C−D−E. A primary thread Lp is opened, and the recurrence function (1) is applied at the beginning of the computation of i(G5):Lp:(1, 1)→(2, 1)→(3, 2)→(5, 3)→(8, 5). Note that temporary charges (αvi,βvi) can be stored in the vertex vi and marked as visited. For any pair of vertices (v, w)∈S, where S is an independent set and v, w are adjacent, and if edge (v, w) is identified as a frond edge, in this case (E, B) is the frond edge, a secondary thread Ls parallel to Lp is opened; that is, Ls:(0, 1)→(1, 0)→(1, 1)→(2, 1) when the walk visits vertex v and w have already been visited, then the subtraction rule (2) is applied, which allows the computation of the charge of vertex v based on a charge of vertex u; and for each frond edge that is encountered. Section 3.2.5 explains this in detail. Therefore:

S⊆V(G) is an independent set. If Δx, y∈S, {x, y}∉E. i(G)=S/S.

Fig. 5 Graph G with 5 vertices 

Continuing with our systematic approach, the binary tree in Figure 6 presents all possible combinations formed with the five vertices of graph G, considering that none of its vertices is adjacent to another [¹]. The negative symbol indicates that the vertex cannot be part of the combination.

Fig. 6 Binary tree of independent sets. Eliminate vertices B and E, which are frond edges 

At the end of the construction of the binary tree, we can see that there are 12 independent sets (and we eliminate vertices B and E, which form the frond edge). Moreover, applying the Fibonacci sequence count from Table 1, we confirm that the results, which are of significant importance, coincide.

3.2.1 Linear Chain Graph

Let G=(V, E) with Δ(G)=2 being G a chain graph with n nodes, therefore |V|=n and |E|=m=n−1.

Let us order the nodes in G as V={v1,v2,…,vn} in such a way that it is fulfilled E={c1,…,cn−1}={{v1,v2},{v2,v3},…,{vn−2,vn−1},{vn−1,vn}}, i.e. |v(ci)∩v(ci+1)|=1, i=1,…,n−2. Gi, i={1,…,n} being Gi the induced subgraph of G.

The basic technique for counting the number of independent sets i(Gi) on Gi of G is an incremental strategy [¹², ¹¹] that is based on associating a pair of values (αi,βi) to each node vi∈V, i={1,…,n}.

The path starts at one of the ends of the node v1 or the node vn, visiting its adjacent node linearly. The first pair of values starts with (αi,βi)=(1,1).

The recurrence relation considers that the value is known (αi,βi) associated with the induced subgraph Gi of G such that i(Gi)=(αi,βi).

The new pair of values (αi+1,βi+1) is constructed based on (αi,βi) applying the recurrence it generates to the Fibonacci numbers αi+1=αi+βi, βi+1=αi.

Table 2 shows the counting of independent sets obtained by applying the Fibonacci sequence in the chain graph shown in Figure 7. Therefore, (αi,βi)=(Fi+1,Fi) then i(Gi)=αi+βi=Fi+1+Fi=Fi+2, i={0,…,n}, i.e., for n=6, i(G)=i(G6)=F7+F6=F8=21.

Fig. 7 Linear chain 

3.2.2 Simple Cycle of a Graph

Figure 8 shows a graph containing a simple cycle. Counting independent sets starts a main thread (Lp); the value pair starts with (αi,βi)=(1,1), and the secondary thread (Ls) starts the sequence recurrence with (αi,βi)=(0,1), where i=1,…,m.

Fig. 8 Simple cycle 

The last pair is (αm,βm)=(0,βm) so that the series ((α1,β1)=(0,1)→(α2,β2)=(1,0)→(α3,β3)=(1,1)…→(αm,βm)→(0,βm)) gives us the value of |S∈i(G′):v1∈S∧vm∈S|. The above series corresponds to the following series considering the Fibonacci numbers:

F0=0 and F1=1, (F0,F1)→(F1,F0)→(F2,F1)→…→(Fm−1,Fm−2). (αm,βm)=(0,βm); i(Gc)=((αm,βm)−(0,βαm)).

For computing the closing of the cycle [²], we apply rule (2); the last pair (αm,βm) of the secondary thread (Ls) is (αm,βm)=(0,βm), where {vm,v0}∈E(G) represents the backward edge that closes the cycle of G and is subtracted from the last pair of the primary thread (Lp).

Therefore, ((αm,βm)−(0,βm))=((α6,β6)−(0,β6))=(13, 8)−(0, 3)=(13, 5), we obtain that i(Gc)=13+5, i. e., 18 is the total number of independent sets. This count is shown in detail in Table 3, where we can see the counting of independent sets of G.

3.2.3 Cycle and Linear Chain of a Graph

Figure 9 shows a graph with nine nodes, where the nodes A, B, C, D, E, F, and A form a cycle. The exact process is followed to count the independent sets in a cycle for a simple cycle graph, previously studied in Section 3.2.2; the computation is shown in detail in Table 4.

Fig. 9 Simple cycle and linear chain 

When node F closes the cycle, the inverse edge rule (2) is applied, obtaining as a result the pair (13, 5)→ and continuing with the computing of the linear sequence applying the Fibonacci rule (1) on the nodes G, H, I until finishing the path of the graph. The total number of independent sets i(G) equals the sum of the last pair (49, 31)=49+31, i. e., 80 independent sets.

3.2.4 Hexagons Connected by Edges

Figure 10 shows the case of a graph with two cycles connected by a bridge edge. Here, the same process is performed for the simple cycles, and once a back edge is found, the first cycle is closed, equation (2) is applied, and we continue to compute the independent sets according to the Fibonacci rule. Tables 5 and 6 show that the calculations of the total of the independent sets i(G) that it is equal to the sum of the last pair (209, 90)=209+90=299 independent sets.

Fig. 10 Two hexagons joined by an edge 

3.2.5 Hexagons Connected by Vertices

Algorithms have been developed for counting independent sets in flat grid structures that facilitate counting, applying the traversal by rows and columns or vice versa [³]. Our algorithmic proposal processes the frond edges in two phases. Let v, w be a frond edge of a graph G.

In the first phase, when a walk (Lp) main thread visits the first vertex v of the front edge, the number of active threads and computing threads (Ls) must be duplicated. Assume (αv,βv)i is the charge associated with the active thread Li when visiting vertex v. A new thread Lvwi is created, which is subordinate to the master thread Li, and with an associated initial pair (0, βv)vw.

Therefore, the label vwi of Lvwi is also a pointer to its master thread Li. The second phase in the frond edge processing (v,w) is when the walk visits vertex w, and v has already been labeled as a visited vertex. Thus, control is maintained at vertex w. Suppose (αw,βw)i is the charge of vertex w on the master thread Li.

Meanwhile, (αvw,βvw)vw is the charge of w on the subordinate thread Lvwi. Then, the subtraction rule of equation (2) updates the charge of w in Li. After the application of this rule, the subordinate thread Lvwi is closed. In this way, any thread where the particle vw appears must be closed, which decreases the number of active threads.

To compute the number of independent sets of a grid is possible by taking the Hamiltonian path Hc as a guide, although the time complexity is of exponential order over the maximum number of frond edges in any row of the grid, given the number of cycles that are kept open during the Hc path. The Fibonacci and subtraction rules are sufficient to process one row of tiles from a hexagonal grid, as shown in Figures 11, 12 and Table 7.

Fig. 11 Three hexagons connected by vertices 

Fig. 12 Grid of three hexagons connected by vertices