A New Node-Based Algorithm for Identifying the Complete Minimal Cut Set

Abstract

The binary-state network, which is fundamental to several modern systems, only operates in two states: operational or inoperable. Network reliability is crucial in its planning, design, and evaluation, with the minimal cut (MC) being a cornerstone for reliability algorithms. A recursive binary-addition-tree algorithm (BAT) excels in its capacity to promptly eliminate infeasible vectors. However, it relies on a depth-first search (DFS), a technique surpassed in efficiency by BAT. To the best of our knowledge, no exploration into a recursive MC-based BAT for MC identification has been undertaken thus far. Therefore, this manuscript introduces the recursive node-based BAT, devised such that the ith iteration of the jth vector mirrors its progenitor vector, barring its ith coordinate valued at one. This BAT method, paired with rules to eliminate infeasible vectors, demonstrates high efficiency in deriving MCs. This is evident in the time complexity analysis and tests on 20 benchmark binary-state networks. A thorough examination of the empirical findings highlights the distinctive features and benefits of the proposed approach. Specifically, the strategic reordering of node numbers, along with the isolated nodes concept, significantly reduces the occurrence of infeasible vectors. Simultaneously, the inclusion of edge nodes expedites the feasibility verification process for vectors. Ultimately, the proposed recursive node-based BAT algorithm framework ensures a more efficient process for generating vectors.

1. Introduction

Modern society is replete with diverse networks facilitating the conveyance of resources such as flow [1], gas [2], petrol [3], electricity [4,5], vehicular movement [6], signals [7], data [8], multimedia [9], and even social connections [10], all aiming to enhance the quality and efficiency of life. Network reliability, as delineated in the literature [11,12,13], is the likelihood of a network maintaining its intended functions and performance. Consequently, it has long been esteemed as a pivotal metric for gauging the efficacy and status of networks.

At the core of even the most intricate networks lies the foundational binary-state network, characterized by its components’ dichotomous states: operational or failed [14,15]. By expanding the state count beyond this binary construct, we derive multi-state flow networks (MFNs) that adhere to the flow conservation principle [16,17,18]. This spectrum further extends to deterioration/augmentation-effect MFNs (DMFNs/AMFNs) based on a quasi-flow conservation model [19] and multi-state information networks (MINs) that diverge from the conventional flow conservation paradigm [20].

Accommodating diverse flow types, including text, audio, and image data within cloud computing, we observe the evolution of MFNs, DMFNs/AMFNs, and MINs into multi-commodity MFNs [21] and MINs [22]. Moreover, multi-distribution networks, which permit components to possess multiple state distributions, further advance multi-commodity MFNs to multi-distribution multi-commodity MFNs [23]. Hence, enhancements in the foundational binary-state network prove beneficial across the entire spectrum of the aforementioned network models [14,15,16,17,18,19,20,21,22,23].

Computing the reliability for binary-state networks, both unconstrained and constrained by factors like cost, volume, weight, k-out-of-n criteria [18], transmission speed limits [6], memory capacity, signal quality [9], and failure rate [24], is an NP-Hard and #P-hard endeavor [11]. Given the myriad constraints and challenges intrinsic to real-world networks [11,12,13], issues of conditional network reliability assume greater significance than their unconstrained counterparts [25].

Algorithms addressing conditional binary-state network reliability predominantly concentrate on either minimal cuts (MCs) [26] or minimal paths (MPs) [1,2,3,4]. Both the MP and MC are arc subsets, as originally proposed in [6,11,12]. An MP offers a direct path between the source and sink nodes, contrasting with an MC, which, when removed, disrupts this connection [26]. No arcs in either MCs or MPs should be superfluous; if found, they would be categorized as mere cuts/paths rather than genuine MCs/MPs [11,12].

The identification and understanding of MCs play a crucial role in assessing network reliability and resilience. While both MPs and MCs are important subsets for network analysis, MCs offer insights into the minimal conditions under which a network remains connected, thereby providing essential information for network design and optimization. Moreover, the numbers of MPs and MCs are 2^|E| and 2^|V| in the worst case, where |V| is the number of nodes and |E| = O(|V|²) is the number of arcs [11,12]. Hence, analyzing MCs can often be more computationally tractable than examining MPs. Considering the significance and the computational advantages of focusing on MCs, this study narrows its scope to primarily address the challenges of efficiently finding all MCs.

Identifying all MCs or MPs is both NP-Hard and #P-hard [11]. Neither MC nor MP algorithms provide direct reliability computation and necessitate auxiliary techniques, such as inclusion–exclusion or sum-of-disjoint product [27]. Yet, determining network reliability through these methods, based on the identified MCs or MPs, remains NP-Hard and #P-hard [11]. Thus, refining MC algorithms is imperative.

Several MC algorithms have been proposed [26], with the node-centric MC algorithm [19] emerging as the most efficient. It identifies MCs based on nodes, not arcs, resulting in time complexities of O(2^|V|) versus O(2^|E|) [11]. However, it relies on depth-first search (DFS) [18,19,20,23], which is overshadowed in efficiency by Yeh’s binary-addition-tree algorithm (BAT) [28], an implicit enumeration approach that efficiently identifies potential solutions.

Yeh later enhanced BAT with a recursive method for finding all MPs [29], dramatically reducing the time complexity. The recursive BAT’s strength lies in its ability to instantly discard infeasible vectors [29], further preventing the generation of vectors from infeasible sources during the recursive process.

To our knowledge, a recursive MC-based BAT for MC identification remains uncharted territory. Thus, our study aims to unveil a recursive node-based algorithm rooted in the recursive BAT, streamlining the process by eliminating infeasible vectors and boosting reliability calculation efficiency for binary-state networks. Some concepts of the proposed recursive node-based algorithm, rooted in the recursive BAT, are based on the improvement of Yeh’s binary-addition-tree algorithm (BAT) [28], PLSA, a progeny of the layered-search algorithm (LSA) [30], and IET, which facilitates the calculation of binary-state network reliability [29]. Hence, there are indeed several similarities with the references used. The novelty and contributions of the proposed algorithm lie in overcoming the node-centric MC algorithm that identifies MCs based on nodes, not arcs, resulting in time complexities of O(2^|V|) versus O(2^|E|) and dependence on depth-first search (DFS), which is overshadowed in efficiency.

This paper’s structure is as follows: Section 2 defines the necessary acronyms and notations. Section 3 briefly revisits MCs, BAT, the path-based layered-search algorithm (PLSA), and inclusion–exclusion technology (IET). In Section 4, we delve into the renowned node-based MC algorithm within the BAT context. Section 5 underscores our algorithm’s innovations. Section 6 presents the proposed algorithm in detail, alongside pseudocode, time complexity analysis, and a walkthrough. Its efficacy is benchmarked against a well-established node-based MC algorithm using 20 binary-state networks. Finally, Section 7 wraps up the discourse, hinting at future prospects.

2. Acronyms, Notations, Nomenclature, and Assumptions

2.1. Notations

All required acronyms, notations, nomenclature, and assumptions are given in this section and at the end of this text.

|●|:	Number of elements in set ●
V:	Set of nodes V = {1, 2, …, n}
E:	Set of arcs E = {a1, a2, …, am}
ak:	kth arc in E
G(V, E):	A graph with V, E, source node 1, and sink node n; for example, Figure 1 is a graph with V = {1, 2, …, 7}, E = {a1, a2, …, a12}, source node 1, and sink node 7.
Db:	State distribution lists the probability for each working arc; e.g., Db = {Pr(a1) = Pr(a3) = Pr(a5) = Pr(a7) = Pr(a9) = Pr(a11) = 0.96, Pr(a2) = Pr(a4) = Pr(a6) = Pr(a8) = Pr(a10) = Pr(a12) = 0.91} in Figure 1.
G(V, E, Db):	Binary-state network with G(V, E) and Db. For example, Figure 1 with Db = {Pr(a1) = Pr(a3) = Pr(a5) = Pr(a7) = Pr(a9) = Pr(a11) = 0.96, Pr(a2) = Pr(a4) = Pr(a6) = Pr(a8) = Pr(a10) = Pr(a12) = 0.91} is a binary-state network.
X:	X = (X(1), X(2), …, X(|V|)) is a |V|-tuple node-based vector obtained from BAT such that its kth coordinate X(k) is represented whether node k is in the subnetwork with node 1 after the related cut. Note that X(1) = 1 and X(|V|) = 0 for all X. For example, X22 = (1, 1, 0, 1, 0, 1, 0) is the 22nd vector obtained from the BAT and denotes nodes 2, 4, and 6 are in the subnetwork with node 1 as shown in Figure 2.
S(X):	Node subset S(X) = {v ∊ V|X(v) = 1} ∪ {1}. For example, S(X22) = {1, 2, 4, 6} (see Figure 2) if X22 = (1, 1, 0, 1, 0, 1, 0) in Figure 1.
T(X):	Node subset T(X) = {v ∊ V|X(v) = 0} ∪ {n} = V − S(X). For example, T(X22) = {3, 5, 7} if X22 = (1, 1, 0, 1, 0, 1, 0) in Figure 1.
C(X):	Arc subset C(X) = ⌀ and {a ∊ E|for all a with one endpoint in S(X) and another one in T(X)} if X is infeasible or feasible, respectively. For example, C(X22) = ⌀ and C(X24) = {a5, a8, a10, a12} because X22 = (1, 1, 0, 1, 0, 1, 0) is infeasible, as shown in Figure 2, and X24 = (1, 1, 1, 1, 0, 1, 1) is feasible (Figure 3).
V(k):	Node subset V(k) = {j ∊ V|for all undirected arc a ∊ E from node k to node j ∊ V}. For example, V(2) = {1, 3, 4, 5} in Figure 1.
Pr(●):	Probability to have ● successfully, i.e., $\mathrm{Pr}\left(X\right)={\displaystyle {\prod }_{X(a)=1}\mathrm{Pr}(a)}$

2.2. Assumptions

• Every individual node, denoted as v, is characterized by impeccable reliability. Furthermore, there exists at least one uncomplicated path that connects nodes 1 and n through node v.
• Every arc either operates effectively or is characterized by a failure. The probability of its occurrence operates independently, determined by a distribution grounded in empirical observations, data analysis, or rigorous testing.
• The system refrains from incorporating any loops or parallel arcs.

3. Overview of the MC, BAT, PLSA, and IET

Before delving into the proposed algorithm designed for the identification of MCs and the computation of the binary-state network reliability problem using MCs as a reference, it is pivotal to elucidate the foundational concepts underpinning the algorithm. These encompass the MC, BAT, PLSA, and IET.

3.1. MC and MC-Based Algorithms

An MC, or minimal cut, is a distinct type of cut that, upon removal, bifurcates the network into two separate subnetwork nodes. This ensures that nodes 1 and n are not located within the same subnetwork. The distinction between a generic cut and an MC lies in the redundancy of arcs. Specifically, no arc within an MC is redundant; thus, the removal of any single arc from an MC would prevent it from functioning as a cut. To illustrate, consider Figure 4, which presents a comprehensive MC set, C, composed of: C₁ = {a₁, a₂}, C₂ = {a₁, a₃, a₅}, C₃ = {a₂, a₃, a₄}, and C₄ = {a₄, a₅}. In contrast, the arc subset C* = {a₁, a₂, a₃} is merely a cut and not an MC. This is attributed to the arc a₃ being extraneous and thus removable from C*.

The quest for minimal cuts (MCs) has spawned a multitude of methods, given the critical role MCs play in addressing binary-state network reliability challenges.

Typically, the quantity of arcs is quadratic in relation to the number of nodes, rendering the node–MC algorithm more adept at efficiency when identifying all MCs compared to its arc-based counterparts. The intricacies of the BAT-integrated node–MC algorithm are detailed in Section 4.

3.2. BAT

Yeh [28] was the pioneer in developing the arc-based binary array technique (BAT), which operates based on two fundamental rules to generate every conceivable binary-state vector:

Rule 1:	The coordinate, denoted as X(i), exhibiting the inaugural zero value undergoes a transformation to one, while X(j) is set to zero for every j < i.
Rule 2:	In instances where X(i) = 1 for every i, the process is terminated, signifying the identification of all vectors.

The aforementioned BAT rules are delineated in a more structured manner via the following pseudocode, as derived from Algorithm 1 [31]:

Algorithm 1: Arc-based BAT [31]
Input:	|E|.
Output:	All |E|-tuple binary-state vectors.
STEP 0.	Assign the values: i = 1 and X = 0.
STEP 1.	When X(ai) is 0, set both X(ai) and i to 1, then proceed to STEP 1.
STEP 2.	Halt if i = |E|.
STEP 3.	Increase i by 1, update X to 0, and return to STEP 1.

The BAT operates on a “you-only-look-once” (YOLO) principle. This characteristic ensures that only the vector X undergoes iterative updates within the concise arc-based BAT pseudocode, obviating the need for its preservation. Evidently, with merely four lines and a singular X, the BAT exemplifies simplicity in coding. Moreover, its efficiency in execution, frugality with memory usage, and adaptability make it an ideal choice. Consequently, BAT has found widespread applicability in diverse domains.

3.3. Layers and PLSA

Network reliability can be conceptualized as the probability that a network remains successfully connected under predefined conditions. Consequently, within the realm of network reliability challenges, there is an imperative to validate the connectivity of the resultant state vectors, independent of whether they are derived from MC- or MP-based algorithms. In pursuit of an efficient connectivity verification, the PLSA was initially introduced in [28].

Tracing its lineage, the PLSA is a progeny of the layered-search algorithm (LSA) [30]. LSA is distinctive for its formation of numerous non-overlapping node subsets: L₁, L₂, …, L_l, where L_i is the ith node subset including all nodes in the ith layer. These subsets, referred to as layers in the LSA, are generated sequentially, ensuring each node in L_i shares an arc with a node in L_i+1 but not with L_i+j for j = 1, 2, …, (l − i). Taking node s as the solitary constituent of L₁, the presence of node t in any layer distinct from L₁ infers a connection between nodes 1 and n. The pseudocode for the PLSA is delineated Algorithm 2:

Algorithm 2: PLSA [29]
Input:	G(V, E) and vector X.
Output:	Whether nodes 1 and n is connected in G(X).
STEP 0.	Assign the values: i = 2 and L1 = {1}.
STEP 1.	Let Li = { v ∊ V|v ∉ (L1 ∪ L2 ∪ … ∪ Li−1) and u ∊ Li−1 are two endpoints of a ∊ E }.
STEP 2.	Halt and X is disconnected if Li = ⌀.
STEP 3.	Halt and X is connected if n ∊ ⌀.
STEP 4.	Increase i by one and return to STEP 1.

The time complexity associated with the PLSA stands at O(|V|). This efficiency arises from the fact that each node is incorporated into a layer at most once. Consequently, the PLSA stands out both for its simplicity and its computational efficiency. To illustrate, referring to Figure 1, the procedure elucidating the determination of connectivity for S(X₂₂) can be found depicted in Figure 2, where X₂₂ = (1, 1, 0, 1, 0, 1, 0). The process from the proposed PLSA for Figure 2 is shown in

Table 1. Process from the proposed PLSA for Figure 2.

i	Li	Li+1
1	{1}	{2}
2	{2}	{4}
3	{4}	{6}
4	{6}

.

3.4. IET

Owing to its lucidity and pivotal functionality, the IET algorithm is frequently employed in network reliability computations, especially when all MCs are identified. The IET facilitates the calculation of binary-state network reliability, drawing from the subsequent equation delineated in [29]:

$$\begin{array}{l}Pr({\displaystyle \underset{i=1}{\overset{p}{\cup }}\mathrm{supp}(P_i}))\\ ={\displaystyle \sum _{k=1}^p{(-1)}^{k+1}\mathrm{Pr}({\displaystyle \underset{P_i\in I_k}{\cap }\mathrm{supp}(P_i}))}\end{array}$$

(1)

where I_k is the set of k different MPs, supp(P_k) = {X|X ≥ X_k}, X_k is the k-th 1-MP, i.e., X_k(a_i) = $\left\{\begin{array}{ll}1& \mathrm{if} a_i\in P_k\\ 0& \mathrm{otherwise}\end{array}\right.$, supp(P_k) ∩ supp(P_l) = {X|X ≥ Max(X_k, X_l) = $\left\{\begin{array}{ll}1\hfill & \mathrm{if} a_i\in P_k\cup P_l\hfill \\ 0\hfill & \mathrm{otherwise}\hfill \end{array}\right.\}$ = supp(P_k ∪ P_l).

Each constituent term situated on the right-hand side of Equation (1) represents an intersection within MC subsets and is thus designated as an IET term. The probability, as articulated by Equation (1) and framed within the context of MCs, is computed in the ensuing manner:

R^#(G) = [Pr(C₁) + Pr(C₂) + Pr(C₃) + Pr(C₄)] − [Pr(C₁ ∩ C₂) + Pr(C₁ ∩ C₃) + Pr(C₁ ∩ C₄) + Pr(C₂ ∩ C₃) + Pr(C₂ ∩ C₄) + Pr(C₃ ∩ C₄)] + [Pr(C₁ ∩ C₂ ∩ C₃) + Pr(C₁ ∩ C₂ ∩ C₄) + Pr(C₁ ∩ C₃ ∩ C₄) + Pr(C₂ ∩ C₃ ∩ C₄) ] − Pr(C₁ ∩ C₂ ∩ C₃ ∩ C₄).
= Pr({a₁, a₂}) + Pr({a₁, a₃, a₅}) + Pr({a₂, a₃, a₄}) + Pr({a₄, a₅}) − [Pr({a₁, a₂, a₃, a₅}) + Pr({a₁, a₂, a₃, a₄}) + Pr(({a₁, a₂, a₄, a₅}) + Pr({a₁, a₂, a₃, a₄, a₅}) + Pr({a₁, a₃, a₄, a₅}) + Pr({a₂, a₃, a₄, a₅})] + [Pr({a₁, a₂, a₃, a₄, a₅}) + Pr({a₁, a₂, a₃, a₄, a₅}) + Pr({a₁, a₂, a₃, a₄, a₅}) + Pr({a₁, a₂, a₃, a₄, a₅})] − Pr({a₁, a₂, a₃, a₄, a₅}).

(2)

4. BAT-BASED NODE-BASED MC

In this section, we present a modification of the widely recognized node-based MC algorithm, tailored specifically for BAT integration. This adaptation seamlessly amalgamates the principles of MC, the MC algorithm, the PLSA, and the BAT.

4.1. Pseudocode

The node-based MC algorithm was originally implemented based on DFS. From the experiments, BAT was found to be more efficient than DFS. A BAT-based node-based MC algorithm is first proposed, and its pseudocode is Algorithm 3:

Algorithm 3: Proposed BAT-Based Node-Based MC Algorithm [29,30,31]
Input:	G(V, E), source node 1 and sink node n.
Output:	All MCs.
STEP 0.	Assign the values: X = 0, i = 1 and Ω = {{a ∊ E|a is adjacent to node 1}}.
STEP 1.	Reassign the values of X(i) and i to be 1 if X(i) = 0, and then proceed to STEP 4.
STEP 2.	Stop the process if u = |V|.
STEP 3.	Assign X(i) to 0, increment i by 1, and then proceed to STEP 1.
STEP 4.	If both G(S(X)) and G(T(X)) are connected subgraphs without isolated nodes, then let Ω = Ω ∪ {C(X)} because C(X) is an MC. Proceed to STEP 1.

The pseudocode described primarily integrates the node-based MC algorithm within the foundational framework of BAT. Nonetheless, two salient distinctions emerge:

• The vector X transitions from being an arc-based |E|-tuple in Algorithm 1 to a node-based |V|-tuple.
• An additional STEP 4 is incorporated to identify the MC subsequent to acquiring a new iteration of X.

In terms of time complexity, the above-proposed BAT’s requirement to ascertain all |V|-tuple binary-state vectors stands at O(|V|2^|V|). Implementing the PLSA in STEP 4 carries a time complexity of O(|V|) for each vector processed. Consequently, the time complexity of the proposed BAT-centric node-based MC algorithm culminates at O(|V|²2^|V|) when tasked with discovering all the MCs within binary-state networks.

4.2. Step-by-Step Example

We employ the binary-state network depicted in Figure 1 as an illustrative example to elucidate the sequential procedure inherent to the proposed BAT-centric node-based MC algorithm, aimed at methodically uncovering all MCs. The steps are detailed as follows:

STEP 0.	Assign the values: X = 0, i =1 and Ω = {{a1, a2}}.
STEP 1.	Given that X(1) = 0, set it to 1, assign i as 1, and proceed to STEP 4.
STEP 4.	Given that both G(S(X)) and G(T(X)) are connected, where S(X) = {1, 2} and T(X) = {3, 4, 5, 6, 7}, C(X) is defined as an MC with C(X) = {a2, a3, a4, a5}. Consequently, let Ω be updated to Ω = Ω ∪ {C(X)}, resulting in Ω = {{a1, a2}, {a2, a3, a4, a5}}. Now, proceed to STEP 1.
	:
	:
STEP 1.	In X = (1, 1, 0, 0, 0, 0, 0), since X(3) = 0, we update X(3) to 1 and set i to 1. Consequently, X becomes (1, 1, 1, 0, 0, 0, 0). Now, proceed to STEP 4.
STEP 4.	Given that G(S(X)) is disconnected, C(X) does not qualify as an MC. Proceed to STEP 1, noting that S(X) = {1, 2, 3}.
	:
	:
STEP 2.	Because i = |V| = 7, halt.

The entire procedure, along with its corresponding outcomes, are comprehensively cataloged in

Table 2. All X_i and MCs obtained from the proposed node-based BAT.

i	Xi	S(Xi)	T(Xi)	C(X)	U(Xi)
1	(1, 0, 0, 0, 0, 0, 0)	{1}	{2, 3, 4, 5, 6, 7}	{a1, a2}	{2, 3}
2	(1, 1, 0, 0, 0, 0, 0)	{1, 2}	{3, 4, 5, 6, 7}	{a2, a3, a4, a5}	{3, 4, 5}
3	(1, 0, 1, 0, 0, 0, 0)	{1, 3}	{2, 4, 5, 6, 7}	{a1, a3, a6, a7}	{2, 4, 6}
4	(1, 1, 1, 0, 0, 0, 0)	{1, 2, 3}	{4, 5, 6, 7}	{a4, a5, a6, a7}	{4, 5, 6}
5	(1, 0, 0, 1, 0, 0, 0)	{1, 4}
6	(1, 1, 0, 1, 0, 0, 0)	{1, 2, 4}	{3, 5, 6, 7}	{a2, a3, a5, a6, a8, a9}	{3, 5, 6}
7	(1, 0, 1, 1, 0, 0, 0)	{1, 3, 4}	{2, 5, 6, 7}	{a1, a3, a4, a7, a8, a9}	{2, 5, 6}
8	(1, 1, 1, 1, 0, 0, 0)	{1, 2, 3, 4}	{5, 6, 7}	{a5, a7, a8, a9}	{5, 6}
9	(1, 0, 0, 0, 1, 0, 0)	{1, 5}
10	(1, 1, 0, 0, 1, 0, 0)	{1, 2, 5}	{3, 4, 6, 7}	{a2, a3, a4, a8, a10, a11}	{3, 4, 6, 7}
11	(1, 0, 1, 0, 1, 0, 0)	{1, 3, 5}
12	(1, 1, 1, 0, 1, 0, 0)	{1, 2, 3, 5}	{4, 6, 7}	{a4, a6, a7, a8, a10, a11}	{4, 6, 7}
13	(1, 0, 0, 1, 1, 0, 0)	{1, 4, 5}
14	(1, 1, 0, 1, 1, 0, 0)	{1, 2, 4, 5}	{3, 6, 7}	{a2, a3, a6, a9, a10, a11}	{3, 6, 7}
15	(1, 0, 1, 1, 1, 0, 0)	{1, 3, 4, 5}
16	(1, 1, 1, 1, 1, 0, 0)	{1, 2, 3, 4, 5}	{6, 7}	{a7, a9, a10, a11}	{6, 7}
17	(1, 0, 0, 0, 0, 1, 0)	{1, 6}
18	(1, 1, 0, 0, 0, 1, 0)	{1, 2, 6}
19	(1, 0, 1, 0, 0, 1, 0)	{1, 3, 6}	{2, 4, 5, 7}	{a1, a3, a6, a9, a10, a12}	{2, 4, 5, 7}
20	(1, 1, 1, 0, 0, 1, 0)	{1, 2, 3, 6}	{4, 5, 7}	{a4, a6, a7, a8, a10, a11}	{4, 5, 7}
21	(1, 0, 0, 1, 0, 1, 0)	{1, 4, 6}
22	(1, 1, 0, 1, 0, 1, 0)	{1, 2, 4, 6}
23	(1, 0, 1, 1, 0, 1, 0)	{1, 3, 4, 6}	{2, 5, 7}	{a4, a5, a6, a9, a12}	{2, 5, 7}
24	(1, 1, 1, 1, 0, 1, 0)	{1, 2, 3, 4, 6}	{5, 7}	{a5, a8, a10, a12}	{5, 7}
25	(1, 0, 0, 0, 1, 1, 0)	{1, 5, 6}
26	(1, 1, 0, 0, 1, 1, 0)	{1, 2, 5, 6}
27	(1, 0, 1, 0, 1, 1, 0)	{1, 3, 5, 6}
28	(1, 1, 1, 0, 1, 1, 0)	{1, 2, 3, 5, 6}
29	(1, 0, 0, 1, 1, 1, 0)	{1, 4, 5, 6}
30	(1, 1, 0, 1, 1, 1, 0)	{1, 2, 4, 5, 6}
31	(1, 0, 1, 1, 1, 1, 0)	{1, 3, 4, 5, 6}
32	(1, 1, 1, 1, 1, 1, 0)	{1, 2, 3, 4, 5, 6}	{7}	{a11, a12}

. Within this table, a vector X is deemed feasible if the values associated with S(X), T(X), C(X), and U(X) = T(X) ∩ {all nodes adjacent to arcs in C(X)} are enumerated.

5. Proposed Novel Concepts

A paramount distinction between the algorithm proposed herein and the one delineated in Section 4 lies in the recursive approach employed to authenticate the connectivity across all extracted vectors. The nuances of this methodology are expounded upon in the subsequent discourse of this section.

5.1. Renumber Nodes Based on the PLSA

Let vector X(v) = 0 for all v ≥ u. Vector X* is called the son of X if X^*(v) = $\left\{\begin{array}{ll}1\hfill & v=u\hfill \\ X\left(v\right)\hfill & \mathrm{otherwise}\hfill \end{array}\right.$, and X^# is an offspring of X if X << X^# and X^#(v) = X(v) for all v < u. For example, let X₆ = (1, 1, 0, 1, 0, 0, 0). X₁₄ = (1, 1, 0, 1, 1, 0, 0) is the son of X₆ and X₁₄ = (1, 1, 0, 1, 1, 0, 0) and X₂₂ = (1, 1, 0, 1, 0, 1, 0) and X₃₀ = (1, 1, 0, 1, 1, 1, 0) are the offspring of X₆.

As detailed in Table 2, the vector X₅ = (1, 0, 0, 1, 0, 0, 0) is characterized as infeasible. Correspondingly, all its progeny vectors—namely X₁₃ = (1, 0, 0, 1, 1, 0, 0), X₂₁ = (1, 0, 0, 1, 0, 1, 0), and X₂₉ = (1, 0, 0, 1, 0, 1, 0)—which share identical values for the first four coordinates with X₅, are also adjudged infeasible.

Notably, this observed pattern does not universally hold. For instance, considering the same network with the positions of nodes 2 and 5 interchanged, as depicted in Figure 5, X₅ = (1, 0, 0, 1, 0, 0, 0) remains infeasible. Yet, one of its derivations, X₁₃ = (1, 0, 0, 1, 1, 0, 0), now emerges as feasible, diverging from the scenario in Figure 1.

Consider an infeasible vector X, with coordinates X(i) = 0 for i = k + 1, k + 2, …, n − 2. If both G(S(X)) and G(T(X)) remain disconnected even after updating the coordinates to X(i) = 1 for i = k + 1, k + 2, …, n − 2, it implies that all progeny of X are inherently infeasible. Consequently, we introduce a novel method, grounded on the PLSA, to resequence the nodes. The objective is to ascertain a configuration where, given an infeasible vector, all its derivations are likewise infeasible. This strategy enables the algorithm to bypass associated infeasible derivations once the infeasibility of a parent vector is established, thus reducing the count of the vectors evaluated for feasibility.

Table 3. Example of Algorithm 4.

i	1	2	3	4
L(i)	{1}	{2, 3}	{4, 5, 6}	{7}
v	1	2	3	4	5	6	7
λ(v)	1	2	2	3	3	3	4

delineates the layers, L(i), obtained from executing STEP 1 for each i and the layer value, λ(v), associated with each node v based on the structure in Figure 1.

Algorithm 4: PLSA-based Renumber Nodes [29]
Input:	G(V, E), source node 1 and sink node n.
Output:	All MCs.
STEP 0.	Implement Algorithm 2 to find L1, L2, …, Ll and λ(v) for all nodes v ∊ V.
STEP 1.	Renumber nodes such that nodes i < j if nodes i and j are in LƖ and Lφ, respectively, with Ɩ ≤ φ.
STEP 2.	Renumber nodes in each layer such that nodes i < j if nodes λ(i) > λ(i).

5.2. Recursive Concept

The recursive BAT methodology is designed to systematically produce and evaluate every conceivable binary-state vector for a specified system. This technique is predominantly employed in addressing network reliability challenges, with a specific focus on connectivity characterized by minimal paths (MPs) and minimal cuts (MCs).

In [29], the recursive BAT methodology was first presented to utilize the inclusion-exclusion principle in determining network reliability following the identification of MPs. This manuscript further refines the algorithm to seamlessly incorporate edge nodes, thereby improving the process of evaluating the feasibility of vectors stemming from previously established feasible vectors.

In the proposed recursive BAT [29], there are (|V| − 2) iterations for the problem discussed here without needing to check the states of nodes 1 and n. The ith iteration has 2^(Ɩ−1) vectors, where Ɩ = n_j−1 is the number of vectors in the (i − 1)th iteration for i = 2, 3, …, (|V| − 2) and the first iteration has 2 vectors. Each vector, say X, in the ith iteration with X(j) = 0 for j = (i + 1), (i + 2), …, (|V| − 2). Hence, without the loss of generality and for convenience, X generated in the ith iteration is written in i-tuple because X(j) = 0 for all j > i.

Let X_j be the jth vector generated, X_i,j be the jth vector in the ith iterative for j = 1, 2, …, 2^(Ɩ−1), Ɩ = n_j−1, i = 1, 2, …, (|V| − 2), X₁ = X_1,1 = (0), and X₂ = X_1,2 = (1). The following important equation is the core of recursive BAT to obtain all vectors:

$$X_i{,}_j(k)=\left\{\begin{array}{ll}{X}_j\left(k\right)\hfill & k=1,2,\dots ,(i-1)\hfill \\ 1\hfill & \mathrm{otherwise}\hfill \end{array}\right..$$

(3)

Also,

S(X_i,j) = S(X_j) ∪ {(i + 2)},

(4)

U(X_i,j) = [U(X_j) − {(i+2)}] ∪ [V(i+2) − S(X_j)].

(5)

Thus, the recursive BAT can have one vector in O(1) [29], which is much faster than O(n) in the traditional BAT [28].

The application of the recursive method for Algorithm 3, visualized in Figure 1.

Table 4. Results in the first iterative for vectors 1 and 2.

j	Xj = X1,j	S(Xj)	U(Xj)	C(Xj)
1	(0)	{1}	{2, 3}	{a1, a2}
2	(1)	{1, 2}	{3, 4, 5}	{a2, a3, a4, a5}

,

Table 5. Results in the second iterative for vectors 3 and 4, based on vectors 1 and 2, respectively.

J	Xi = X1,j	S(Xi)	U(Xi)	i	j	Xi = X2,j	S(Xi)	U(Xi)	C(Xi)
1	(0)	{1}	{2, 3}	3	1	(0, 1)	{1, 3}	{2, 4, 6}	{a1, a3, a6, a7}
2	(1)	{1, 2}	{3, 4, 5}	4	2	(1, 1)	{1, 2, 3}	{4, 5, 6}	{a4, a5, a6, a7}

,

Table 6. Results in the third iterative for vectors 5–8, based on that of 1–4, respectively.

i	Xi	S(Xi)	U(Xi)	i	Xi	S(Xi)	U(Xi)	C(Xi)
1	(0)	{1}	{2, 3}	5	(0, 0, 1)	{1, 4}D
2	(1)	{1, 2}	{3, 4, 5}	6	(1, 0, 1)	{1, 2, 4}	{4, 5, 6}	{a2, a3, a5, a6, a8, a9}
3	(0, 1)	{1, 3}	{2, 4, 6}	7	(0, 1, 1)	{1, 3, 4}	{2, 5, 6}	{a1, a3, a4, a7, a8, a9}
4	(1, 1)	{1, 2, 3}	{4, 5, 6}	8	(1, 1, 1)	{1, 2, 3, 4}	{5, 6}	{a5, a7, a8, a9}

,

Table 7. Results in the fourth iterative for vectors 9–16, based on that of 1–8, respectively.

I	Xi	S(Xi)	U(Xi)	i	Xi	S(Xi)	U(Xi)	C(Xi)
1	(0)	{1}	{2, 3}	9	(0, 0, 0, 1)	{1, 5}D
2	(1)	{1, 2}	{3, 4, 5}	10	(1, 0, 0, 1)	{1, 2, 5}	{3, 4, 6, 7}	{a2, a3, a4, a8, a10, a11}
3	(0, 1)	{1, 3}	{2, 4, 6}	11	(0, 1, 0, 1)	{1, 3, 5}D
4	(1, 1)	{1, 2, 3}	{4, 5, 6}	12	(1, 1, 0, 1)	{1, 2, 3, 5}	{4, 6, 7}	{a4, a6, a7, a8, a10, a11}
5	(0, 0, 1)	{1, 4}D		13	(0, 0, 1, 1)	{1, 4, 5}D
6	(1, 0, 1)	{1, 2, 4}	{4, 5, 6}	14	(1, 0, 1, 1)	{1, 2, 4, 5}	{3, 6, 7}	{a2, a3, a6, a9, a10, a11}
7	(0, 1, 1)	{1, 3, 4}	{2, 5, 6}	15	(0, 1, 1, 1)	{1, 3, 4, 5}D
8	(1, 1, 1)	{1, 2, 3, 4}	{5, 6}	16	(1, 1, 1, 1)	{1, 2, 3, 4, 5}	{6, 7}	{a7, a9, a10, a11}

and

Table 8. Results in the last iterative for vectors 17–32, based on that of 1–16, respectively.

i	Xi	S(Xi)	U(Xi)	i	Xi	S(Xi)	C(Xi)
1	(0)	{1}	{2, 3}	17	(0, 0, 0, 0, 1)	{1, 6}D
2	(1)	{1, 2}	{3, 4, 5}	18	(1, 0, 0, 0, 1)	{1, 2, 6}D
3	(0, 1)	{1, 3}	{2, 4, 6}	19	(0, 1, 0, 0, 1)	{1, 3, 6}	{a1, a3, a6, a9, a10, a12}
4	(1, 1)	{1, 2, 3}	{4, 5, 6}	20	(1, 1, 0, 0, 1)	{1, 2, 3, 6}	{a4, a6, a7, a8, a10, a11}
5	(0, 0, 1)	{1, 4}D		21	(0, 0, 1, 0, 1)	{1, 4, 6}D
6	(1, 0, 1)	{1, 2, 4}	{4, 5, 6}	22	(1, 0, 1, 0, 1)	{1, 2, 4, 6}D
7	(0, 1, 1)	{1, 3, 4}	{2, 5, 6}	23	(0, 1, 1, 0, 1)	{1, 3, 4, 6}	{a4, a5, a6, a9, a12}
8	(1, 1, 1)	{1, 2, 3, 4}	{5, 6}	24	(1, 1, 1, 0, 1)	{1, 2, 3, 4, 6}	{a5, a8, a10, a12}
9	(0, 0, 0, 1)	{1, 5}D		25	(0, 0, 0, 1, 1)	{1, 5, 6}D
10	(1, 0, 0, 1)	{1, 2, 5}	{3, 4, 6, 7}	26	(1, 0, 0, 1, 1)	{1, 2, 5, 6}D
11	(0, 1, 0, 1)	{1, 3, 5}D		27	(0, 1, 0, 1, 1)	{1, 3, 5, 6}D
12	(1, 1, 0, 1)	{1, 2, 3, 5}	{4, 6, 7}	28	(1, 1, 0, 1, 1)	{1, 2, 3, 5, 6}D
13	(0, 0, 1, 1)	{1, 4, 5}D		29	(0, 0, 1, 1, 1)	{1, 4, 5, 6}D
14	(1, 0, 1, 1)	{1, 2, 4, 5}	{3, 6, 7}	30	(1, 0, 1, 1, 1)	{1, 2, 4, 5, 6}D
15	(0, 1, 1, 1)	{1, 3, 4, 5}D		31	(0, 1, 1, 1, 1)	{1, 3, 4, 5, 6}D
16	(1, 1, 1, 1)	{1, 2, 3, 4, 5}	{6, 7}	32	(1, 1, 1, 1, 1)	{1, 2, 3, 4, 5, 6}	{a11, a12}

showcase the resultant vectors. Specifically, both the inaugural and second iterations yield two vectors each, delineated in Table 4 and Table 5, respectively.

It is imperative to acknowledge that within these tables both X_i,j and X_j are arrayed within a congruent row. Distinctive differences between these vectors are emphasized in bold for clarity and ease of reference.

5.3. Edge Nodes for Feasible Vectors

The functions O(|S(X)|) and O(|T(X)|) are employed to assess the connectivity of G(S(X)) and G(T(X)), respectively. Their purpose is to ascertain if C(X) qualifies as an MC for any novel vector X. Given X as a feasible binary vector of dimension (n − 2)-tuple, a novel concept named the edge node subset, denoted as U(X), has been introduced. Specifically, node t is classified as an edge node if and only if e_s,t is an element of E, with nodes s and t positioned in S(X) and T(X), respectively. Consequently, an edge node can be interpreted as a node residing at the periphery of MC C(X).

To elucidate with a tangible instance derived from Figure 1: X₂₃ with a value of (1, 0, 1, 1, 0, 1, 0), U(X₂₃) is represented by the set {2, 5}. Similarly, X₂₄ with a value of (1, 1, 1, 1, 0, 1, 1), U(X₂₄) is defined by the set {5}. It is pertinent to note that the corresponding MCs are C(X₂₃) = {a₄, a₅, a₆, a₉, a₁₂} and C(X₂₄) = {a₅, a₈, a₁₀, a₁₂}.

Given a feasible vector X, it follows that t is an element of U(X) and τ belongs to the set difference [T(X) − U(X)]. Additionally, the components X(t) and X(τ) are both set to 0. To evaluate the feasibility of X^* grounded on its antecedent vector X, we can distinguish two cases:

$$\mathbf{CASE} \mathbf{1}\mathbf{.} X*(v)=\left\{\begin{array}{ll}1\hfill & v=\tau \hfill \\ X\left(v\right)\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(6)

If there is no path linking any node within S(X) to any node in the set [T(X) − U(X)], it can be concluded that X* is infeasible. As an illustration from Figure 1, the vector X₂ = (1, 1, 0, 0, 0, 0, 0) is feasible. Given that node 6 belongs to the set [T(X₁) − U(X₁)], the vector (1, 1, 0, 0, 0, 1, 0) is deemed infeasible.

By recognizing the edge nodes, the aforementioned rule can be executed in O(1) time to ascertain whether both S(X) and T(X) form connected subgraphs. This is considerably more efficient than the O(n) time complexity characteristic of Algorithm 3, which is premised on the PLSA.

$$\mathbf{CASE} \mathbf{2}\mathbf{.} X*(v)=\left\{\begin{array}{ll}1\hfill & v=t\hfill \\ X\left(v\right)\hfill & \mathrm{otherwise}\hfill \end{array}\right..$$

(7)

If the graph G(U(X) − {t}) exhibits connectivity, both S(X*) and T(X*) are also connected. This implies that C(X^*) is indeed an MC, given the precondition that both S(X) and T(X) are connected.

Conversely, if G(U(X) − {t}) is disconnected, C(X*) cannot be classified as an MC. Employing the PLSA, verifying the connectivity of G(U(X) − {t}) requires O(|U(X) − {t}|) << O(|T(X)|) time complexity. Notably, O(|U(X) − {t}|) is much smaller than O(|T(X)|). Therefore, the aforementioned approach presents a more efficient alternative to directly employing the PLSA for ascertaining the connectivity of T(X).

In summary, by considering the aforementioned two scenarios, the introduction of edge nodes significantly bolsters the efficiency of the PLSA.

5.4. Isolated Nodes

Edge nodes serve as a valuable metric to ascertain the feasibility or infeasibility of a vector. To further enhance our understanding and analytical capabilities, not just for a singular vector but also its derivatives, the new concept of “isolated nodes” has been introduced.

An isolated node, within the context of G(X), is defined in the following manner: Node v is deemed an isolated node if it satisfies one of two conditions:

• v is an element of S(X), but in G(S(X)) it fails to establish a path to node 1.
• Conversely, v belongs to T(X), but within G(T(X)) it is unable to connect to node n.

A pivotal observation here is that the existence of at least one isolated node in X is indicative of a disconnection either in G(S(X)) or G(T(X)). This provides a direct means to infer the connectivity status of the subsets S(X) and T(X) based on the presence or absence of isolated nodes.

In the representation provided by Figure 6, nodes with a dark shading fall within S(X), whereas those colored white are members of T(X). Nodes represented with a dashed outline are identified as isolated nodes. Within the subfigures of Figure 6:

-

In Figure 6a, node 4 is identified as the outside isolated node.

-

In Figure 6b, node 3 is depicted as the inside isolated node.

-

Lastly, in Figure 6c, node 2 is portrayed as the future isolated node.

These distinctions among the isolated nodes, visually differentiated in the figure, allow for a deeper understanding of the positional relevance and behavior of nodes within the context of S(X) and T(X).

Nodes have been sequenced based on the layering derived from the PLSA, as elaborated in Section 5.1. Within the framework of vector X, as illustrated in Figure 3, it is infeasible to establish a pathway from either node 1 or node n to any isolated node v. In essence, the presence of an isolated node within X in G(X) dictates that X is infeasible. The positioning of node v can be categorized as inside, outside, or future.

Furthermore, there is an inherent inability to append any nodes to S(X) in such a manner that such node is no longer isolated. As a consequence, both X and all its derivatives (offspring) are deemed infeasible. Notably, when X is externally isolated, its predecessor, denoted by X₁ = (1, 0, 0, 0, 0, 0, 0), cannot be expanded to produce any new derivatives, such as (1, 0, 0, 0, 1, 0, 0) or (1, 0, 0, 0, 0, 1, 0). It is crucial to highlight that both C(X₁) and X₃ are retained because C(X₁) qualifies as a genuine MC and X₃ = (1, 0, 1, 0, 0, 0, 0) had been previously generated prior to the instantiation of X₅ = (1, 0, 0, 1, 0, 0, 0).

5.5. Fathom Vectors Based on Isolated Nodes

Given a feasible vector X, assume X_i is a derivative of X such that X_i(u) = $\left\{\begin{array}{ll}1\hfill & \mathrm{if} u=v_i\hfill \\ X(u)\hfill & \mathrm{otherwise}\hfill \end{array}\right.$ and X(v_i) = 0, where λ(v) < λ(v₁). Based on the insights provided in Section 5.3 and Section 5.4, the following rules can be established:

• Infeasibility of X₁: Vector X₁ is infeasible if node v₁ is not an element of U(X).
• Inside Isolated Node Condition: X₂ and its derivatives are infeasible if X₂(v₂) = 1 for every v in U(X) and X(u) = 0, where λ(u) < λ(v₂). In this scenario, u is termed as an inside isolated node.
• Outside Isolated Node Condition: X₂ and its derivatives are deemed infeasible if X₂(v) = 0 for all v in the λ(v)th layer and λ(u) < λ(v₂). Here, u is categorized as an outside isolated node. As an added nuance, the parent of X can be excluded from the recursive list.
• Future Isolated Node Condition: X₂ and its derivatives are infeasible if X₂(v₂) = 1, X(u) = 0, both u and v₂ are elements of U(X), u < v₂, and U(X) is not connected. In this situation, u is defined as a future isolated node.
• Feasibility of X₂: X₂ is feasible if v₂ is an element of U(X) and one of the subsequent conditions holds true:

  (1)

  v₂ is an independent node.

  (2)

  v₂ is a dependent node and X(u) = 1 for all nodes u that depended on v₂.

These rules provide a structured approach to deduce the feasibility or infeasibility of vectors, thereby enabling a systematic understanding of the network structure. This recursive nature leads to several computational advantages:

• Efficiency in Connectivity Verification: The rules preclude the need for redundant connectivity checks for both X and all its derivatives X*, significantly reducing the computational overhead.
• Optimized Vector Generation: By establishing conditions for the infeasibility of vectors, the rules effectively minimize the unnecessary generation of vectors in the BAT, leading to a faster algorithm runtime.
• Systematic Fathoming: By incorporating these rules into the proposed algorithm, we ensure that the process will efficiently dismiss or validate not just individual vectors but entire sets of related vectors. This ensures a comprehensive, yet efficient, exploration of the solution space.

In summary, integrating these structured rules into the algorithm amplifies its efficiency, making it adept at swiftly navigating through the complexities of network structures.

6. Proposed Algorithm

In this section, we elucidate the proposed algorithm through its pseudocode, illustrate its application via a representative example, and subject it to empirical evaluation through performance testing.

6.1. Pseudocode

The following Algorithm 5 presents the pseudocode for the node-based recursive BAT algorithm we have proposed.

Algorithm 5: Proposed Node-based Recursive BAT [31]
Input:	G(V, E), source node 1 and sink node n.
Output:	All MCs.
STEP 0.	Determine V(v) and λ(v) for all v ∊ V utilizing the PLSA. Initializing the values: set i to 2, j to 1, both N and N* to 2, X1 to (0), X2 to (1), S(X1) to {1}, S(X2) to {1, 2}, U(X1) to V(1), U(X2) to the difference between V(2) and {1}, and Ω to the set containing C(X1) and C(X2).
STEP 1.	Let X(v) = $\left\{\begin{array}{ll}1\hfill & \mathrm{if} v=i\hfill \\ X_j(v)=0\hfill & \mathrm{otherwise}\hfill \end{array}\right.$ and S(X) = S(Xj) ∪ {(i+1)} based on Equations (3) and (4).
STEP 2.	If G(X) contains an isolated node denoted as u, then X and its offspring are deemed infeasible. Proceed to STEP 3. If not, advance to STEP 4.
STEP 3.	Eliminate Xj and proceed to STEP 4 if u is an outside isolated node.
STEP 4.	If node (i + 1) = 3 ∊ U(Xj), let U(X) = U(Xj) ∪ V((i + 1)) − S(X), Ω = Ω ∪ {C(X)}, N = N + 1 = 3, and XN = X.
STEP 5.	Increase j by 1 and proceed to STEP 1 if j < N*.
STEP 6.	If i < (|V| − 2), let i = i + 1, j = 1, N* = N, and go to STEP 1. Otherwise, terminate the process and Ω constitutes a complete MC set.

The ensuing pseudocode delineates the node-based recursive BAT algorithm.

STEP 0: Leverage the PLSA to compute V(v) and λ(v) for every v ∊ V. STEP 1: Building on the conceptual framework presented in the iterative BAT from [25]; this step endeavors to identify all vectors. Notably, the representation of X transitions from being an arc-based |E|-tuple vector to a node-based (|V| − 2)-tuple vector. STEPs 2-4: The connectivity of S(X) is validated, relying on the layer number and the properties introduced in Section 5.1.

The primary computational demand for the proposed algorithm stems from the identification of all feasible vectors. This possesses a time complexity of O(2^k), drawing from the iterative BAT’s mechanism to pinpoint all k-tuple binary-state vectors. Evaluating the feasibility of the identified vector necessitates O(|V| − 2), as seen in STEPs 2–4. Therefore, the overall time complexity for the algorithm, especially when discerning all MCs in binary-state networks, is O((|V| − 2)2^(|V|-2)), which simplifies to O((|V| − 2)2^α|V|), where α = (|V| − 2)/|V| ∊ [0, 1), i.e., Algorithm 5 outperforms Algorithm 3 and other existing related algorithms in terms of efficiency.

6.2. Step-by-Step Example

Enumerating all minimal cuts (MCs) and determining the exact binary-state network reliability in terms of MCs within binary-state networks are acknowledged to be NP-hard and #P-hard challenges, as highlighted by reference [11]. Consequently, as the scale of the network increases, the computational burden escalates exponentially.

A seminal benchmark for binary-state networks is portrayed in Figure 1, which is recurrently referenced in literature [8,9,10,11,12,13,14,15]. Its moderate scale renders it particularly apt to elucidate the stages of the proposed algorithm.

STEP 0.	Determine V(v) and λ(v) for all v ∊ V as shown in Table 4 and Table 5; let i = 2, j = 1, (|V| − 2) = 5, X1 = (0), S(X1) = {1}, U(X1) = V(1), X2 = (1), S(X2) = {1, 2}, U(X2) = V(2) − {1} = {3, 4, 5}, N = N* = 2, and Ω = {C(X1), C(X2)} = {{a1, a2}, {a2, a3, a4, a5}}.
STEP 1.	Let X(v) = $\left\{\begin{array}{ll}1\hfill & \mathrm{if} v=i\hfill \\ X_j(v)=0\hfill & \mathrm{otherwise}\hfill \end{array}\right.$, i.e., X = (0, 1), and S(X) = S(Xj) ∪ {(i + 1)} = {1, 3}.
STEP 2.	Because G(X) has no isolated nodes, proceed to STEP 4.
STEP 4.	Because node (i + 1) = 3 ∊ U(Xj), X is feasible and let U(X) = U(Xj) ∪ V((i + 1)) − S(X) = {2, 3} ∪ {1, 2, 4, 6} − {1, 3} = {2, 4, 6}, Ω = Ω ∪ {C(X)} = {{a1, a2}, {a2, a3, a4, a5}, {a1, a3, a6, a7}}, N = N + 1 = 3, and XN = X.
STEP 5.	Because j = 1 < N* = 2, let j = j + 1 = 2, and go to STEP 1.
STEP 1.	Let X(v) = $\left\{\begin{array}{ll}1\hfill & \mathrm{if} v=2\hfill \\ X_2(v)=0\hfill & \mathrm{otherwise}\hfill \end{array}\right.$, i.e., X = (1, 1), and S(X) = S(X2) ∪ {(2 + 1)} = {1, 2, 3}.
STEP 2.	Because there are no isolated nodes in G(X), go to STEP 4.
STEP 4.	Because node (i + 1) = 3 ∊ U(Xj), let U(X) = U(X2) ∪ V(3) − S(X) = {4, 5, 6}, Ω = Ω ∪ {C(X)} = { {a1, a2}, {a2, a3, a4, a5}, {a1, a3, a6, a7}, {a4, a5, a6, a7} }, N = N + 1 = 4, and XN = X4 = X.
STEP 5.	Because j = N* = 2, go to STEP 6.
STEP 6.	Because i = 2 < (|V| − 2) = 5, let i = i + 1 = 3, j = 1, N* = N = 4, and go to STEP 1.
STEP 1.	Let X(v) = $\left\{\begin{array}{ll}1\hfill & \mathrm{if} v=i\hfill \\ X_j(v)=0\hfill & \mathrm{otherwise}\hfill \end{array}\right.$, i.e., X = (0, 0, 1), and S(X) = S(Xj) ∪ {(i + 1)} = {1, 4}.
STEP 2.	Because node 4 is isolated, X and its offspring are all infeasible and go to STEP 3.
STEP 3.	Because node 4 is isolated outside, remove X1 and go to STEP 5.
STEP 5.	Because j = 1 < N* = 4, let j = j + 1 = 2 and go to STEP 1.
	:
	Assume that i = 5, j = 12, N* = 10, and N = 4.
STEP 1.	Let X(v) = $\left\{\begin{array}{ll}1\hfill & \mathrm{if} v=i\hfill \\ X_j(v)=0\hfill & \mathrm{otherwise}\hfill \end{array}\right.$, i.e., X = (1, 1, 1, 1, 1), and S(X) = S(Xj) ∪ {(i + 1)} = {1, 2, 3, 4, 5, 6}.
STEP 2.	Because there are no isolated nodes in G(X), go to STEP 4.
STEP 4.	Because node (i + 1) = 6 ∊ U(Xj) is connected, let U(X) = U(X2) ∪ V(3) − S(X) = {7}, Ω = Ω ∪ {C(X)}, N = N + 1 = 5, XN = X, and go to STEP 5.
STEP 5.	Because j = N* = 12, go to STEP 6.
STEP 6.	Because i = (|V| − 2) = 5, halt and all MCs are found in Ω = {{a1, a2}, {a2, a3, a4, a5}, {a1, a3, a6, a7}, {a4, a5, a6, a7}, {a2, a3, a5, a6, a8, a9}, {a1, a3, a4, a7, a8, a9}, {a5, a7, a8, a9}, {a2, a3, a4, a8, a10, a11}, {a4, a6, a7, a8, a10, a11}, {a2, a3, a6, a9, a10, a11}, {a7, a9, a10, a11}, {a1, a3, a6, a9, a10, a12}, {a4, a6, a7, a8, a10, a11}, {a4, a5, a6, a9, a12}, {a5, a8, a10, a12}, {a11, a12}}.

Following the implementation of the node-based recursive BAT algorithm, comprehensive results are presented in Table 4 and Table 5. These tables offer insights into the algorithm’s performance, especially in context with the benchmark binary-state network from Figure 1. It is essential to review these outcomes to grasp the algorithm’s proficiency in identifying MCs.

6.3. Computation Experiments

To authenticate the proficiency and efficacy of our algorithm, we subjected it to rigorous testing on well-established benchmark networks. Accordingly, we selected 20 quintessential binary-state benchmark networks, showcased in Figure 7(1–20) [11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29], to serve as our experimental subjects. It is imperative to mention that the node numbering sequence has been rearranged in accordance with the guidelines laid out in Section 5.1. For instance, the representations in Figure 7(13) and Figure 7(18) were remodeled as Figure 7(21) and Figure 7(22), respectively.

Note that the order of node numbers is renumbered based on Section 5.1, e.g., Figure 7(13) and Figure 7(18) are redrawn to Figure 7(21) and Figure 7(22), respectively.

To critically assess the proposed algorithm’s performance, we benchmarked it against the leading node-based algorithm, adapted for BAT as elucidated in Section 4. To ensure an equitable evaluation, both algorithms were implemented using DEV C⁺⁺ 5.11, operating on a 64-bit Windows 10 environment powered by an Intel Core i7-6650U processor clocked at 2.20 GHz to 2.21 GHz coupled with 32 GB of RAM. Additionally, for all tested networks, we set Pr(a) to 0.9 for every arc a.

The comparative results are tabulated in

Table 9. Comparison of results.

Fig.	n	m	c	TNBA	TRBAT
1	4	5	4	0	0
2	6	8	9	0	0
3	5	8	8	0	0
4	6	9	9	0	0
5	9	12	28	0	0
6	7	14	25	0	0
7	11	21	133	0	0
8	9	13	24	0	0
9	8	12	19	0	0
10	9	14	25	0	0
11	7	12	20	0	0
12	8	13	29	0	0
14	21	26	528	0.041	0.018
15	9	14	25	0	0
16	10	21	104	0	0
17	18	27	1249	0.159	0.022
19	20	30	7376	0.436	0.093
20	16	24	105	0.001	0.001
21	16	30	644	0.083	0.012
22	13	22	214	0.003	0.001

. Superior performance metrics, whether from our proposed method or the reference node-based MC algorithm, are highlighted in bold. In this context, “T_NBA” signifies the quantity of vectors and the associated computation time needed by the renowned node-based algorithm, whereas “T_RBAT” represents the equivalent metrics for our proposed methodology. As illustrated in Table 9, the number of derived MCs experiences an exponential increase concerning the number of nodes, “n”. This trend is consistent with the inherent characteristics of NP-hard and #P-hard challenges. Notably, both the T_NBA and T_RBAT are zero for “m” values less than 21. Consequently, these two algorithms prove to be efficient in solving small-scale problems. However, for “m” values greater than 21, the proposed algorithm outperforms the other one in terms of the T_NBA and T_RBAT values. These results demonstrate that the proposed algorithm is more suitable for larger problems.

As depicted in Table 9, the count of derived MCs exhibits an exponential surge relative to the number of nodes, n. This trend aligns with the inherent attributes of NP-hard and #P-hard challenges.

For more diminutive datasets, specifically those represented in Figure 7(1–12), both algorithms showcase comparable efficiencies, completing computations within 0.001 s.

A comprehensive analysis of the data from

Table 10. Comparison of the proposed algorithm and the one proposed in [19].

	The Proposed Algorithm	The Algorithm Proposed in [19]
Generation	O(1)	O(n)
Feasibility Verification	O(1)	O(n)
Fathom Offspring	Yes	No

further underscores the salient features and advantages of our approach. Specifically, the strategic reordering of node numbers, coupled with the isolated nodes concept, drastically diminishes the prevalence of infeasible vectors. Concurrently, the integration of edge nodes accelerates the feasibility verification process for vectors. Finally, the recursive algorithm framework ensures a more efficient vector generation process.

The empirical results delineated above align seamlessly with the comparative analysis of time complexities drawn between our proposed algorithm and the prominent MC algorithm. This congruence not only reaffirms the theoretical underpinnings but also accentuates the superiority of our algorithm over the MC methodology previously documented in [29].

7. Conclusions

Network reliability stands as a pivotal metric encapsulating the operational probability of contemporary networks. It is noteworthy that the reliability evaluations bearing real-world constraints, termed conditional network reliability, offer more pragmatic insights than their unconditional counterparts. Central to the computation of conditional network reliability is the necessity to delineate MCs and MPs.

Addressing this exigency, the present work pivots on the enhancement of the canonical binary addition tree (BAT) through the introduction of a recursive paradigm. Our innovation lies in crafting a recursive node-based BAT tailored explicitly for elucidating MCs in conditional network reliability scenarios.

Our proposed methodology distinguishes itself on multiple fronts:

• It pioneers a recursive approach within the realm of BAT algorithms aimed at MC extraction.
• The algorithm melds the agility of recursive BAT—enabling O(1) vector generation—with a strategic node renumbering scheme. This amalgamation aids in the early identification and pruning of infeasible vectors and their progeny, courtesy of the isolated node concept.
• The novel introduction of “edge nodes” further trims the computational overheads associated with feasibility verification of vectors.

Subjecting our algorithm to rigorous empirical scrutiny, we benchmarked it against the gold-standard node-based MC algorithm across 20 binary-state networks. The corroboration from both time complexity analyses and practical experiments unequivocally underscored the superiority of our recursive node-based BAT.

Paving the way forward, our ambitions extend towards stress-testing the proposed algorithm against more sizable benchmark networks. An intriguing avenue of future exploration also encompasses the algorithm’s extrapolation towards identifying d-MCs in multistate flow network (MFN) contexts.

Furthermore, to show the efficiency of the proposed method, we plan to compare it with more algorithms in the future. Additionally, further studies are planned to investigate how our model improves 4G/5G communications.