Fast-MCS: A Scalable Open-Source Tool to Find Minimal Cut Sets

A network is represented as a graph consisting of nodes and edges. A cut set for a source-destination pair in a network is a set of elements that, when failed, cause the source-destination pair to lose connectivity. A Minimal Cut Set (MCS) is a cut set that cannot be further reduced while maintaining its status as a cut set. MCSs are crucial in identifying the critical elements in the network that have the most significant impact on failure. This work introduces Fast-MCS, an open-source, scalable tool for evaluating MCSs in large, complex networks. Additionally, we compare the computation time of Fast-MCS with the state-of-the-art.

💡 Research Summary

The paper addresses the problem of finding Minimal Cut Sets (MCS) in large‑scale networks modeled as graphs. An MCS is a smallest set of components whose failure disconnects a given source‑destination pair; it is a fundamental construct in reliability engineering, fault‑tree analysis, and resilience assessment. Because the problem is NP‑hard, naïve enumeration of all possible node combinations quickly becomes infeasible as the number of vertices grows. Existing approaches fall into two main families. The combinatorial method builds a binary incidence matrix of all simple paths and iteratively checks single‑node, two‑node, … combinations for the “all‑ones” property. While conceptually simple, its runtime grows as the sum of binomial coefficients (\sum_{i=1}^{|V|-2}\binom{|V|-2}{i}) and memory consumption explodes for realistic topologies. The Boole‑Shannon expansion technique represents the system’s success function (the disjunction of all Minimal Path Sets, MPS) as a Boolean expression, then recursively applies Shannon expansion on a pivot variable, complements the resulting sub‑expressions, and finally simplifies using Boolean absorption. Although more systematic, this method still suffers from massive intermediate expression growth and high memory demand.

Fast‑MCS is introduced as a scalable, open‑source alternative. Its workflow consists of three stages. First, all Minimal Path Sets (MPS) are extracted using a modified depth‑first search (DFS) that terminates a branch not only when the destination is reached or a node repeats, but also when a newly visited node could already be reached via a shorter path from any previously visited node. This pruning dramatically reduces the number of candidate paths. Second, each MPS is transformed into a set of interior nodes (source and destination are removed). The collection of these sets, denoted C, is the input to a binary decision‑tree construction. The algorithm counts the frequency of each node across all sets and selects the most frequent node x as a pivot. C is then split into two sub‑collections: C_with (sets containing x, with x removed from each) and C_without (sets not containing x). The split operation is performed recursively, creating a binary tree where each internal node stores the pivot element and pointers to its left (without) and right (with) children. This frequency‑based pivoting aggressively reduces the search space because a node that appears in many MPS simultaneously eliminates many combinations when taken as “present” or “absent”.

Third, the tree is evaluated bottom‑up. Leaf nodes return their own set collection via EvaluateSelf. Internal nodes combine the results of their left and right sub‑trees using a Combine routine that forms unions of sets from the two sides, adds the pivot element when appropriate, and applies an absorption filter: any set that is a superset of another is discarded, guaranteeing minimality. Multiplication of left/right results corresponds to the logical AND of the two Boolean branches, while union corresponds to OR. Because all operations are purely set‑theoretic, the algorithm avoids constructing large Boolean formulas, leading to far lower memory footprints.

Complexity analysis shows that each recursion level removes at least one frequently occurring element, so the depth of the tree is bounded by the number of distinct nodes, and the branching factor is limited to two. Empirically, this yields a logarithmic‑ish reduction of the combinatorial explosion compared with the naïve method. Moreover, the set‑based absorption step ensures that only truly minimal cut sets survive, eliminating redundant supersets without additional post‑processing.

The authors implemented Fast‑MCS in Python, released it under an open‑source license, and benchmarked it against the combinatorial approach (