Attack vulnerability of power systems under an equal load redistribution model

Attack vulnerability of power systems under an equal load redistribution model

Talha Cihad Gulcu,    Vaggos Chatziafratis, Yingrui Zhang, and Osman Yağan This research was supported by the National Science Foundation through grant CCF #1422165 and a generous gift from Persistent Systems, Inc.Preliminary version of some of the material was presented at the Information Theory and Applications Workshop (ITA 2016), San Diego, CA [4].T. C. Gulcu is with TUBITAK Software Technologies Research Institute, 06100, Cukurambar, Ankara, Turkey. E-mail: tcgulcu@gmail.comV. Chatziafratis is with the Computer Science Department, Stanford University, Palo Alto, CA 94305. Email:vaggos@stanford.eduY. Zhang and O. Yağan are with the Department of Electrical and Computer Engineering, Carnegie Mellon University, Pittsburgh, PA 15213. E-mail:{yingruiz, oyagan}@andrew.cmu.edu
Abstract

This paper studies the vulnerability of flow networks against adversarial attacks. In particular, consider a power system (or, any system carrying a physical flow) consisting of transmission lines with initial loads and capacities , respectively; the capacity defines the maximum flow allowed on line . Under an equal load redistribution model, where load of failed lines is redistributed equally among all remaining lines, we study the optimization problem of finding the best lines to attack so as to minimize the number of alive lines at the steady-state (i.e., when cascades stop). This is done to reveal the worst-case attack vulnerability of the system as well as to reveal its most vulnerable lines. We derive optimal attack strategies in several special cases of load-capacity distributions that are practically relevant. We then consider a modified optimization problem where the adversary is also constrained by the total load (in addition to the number) of the initial attack set, and prove that this problem is NP-Hard. Finally, we develop heuristic algorithms for selecting the attack set for both the original and modified problems. Through extensive simulations, we show that these heuristics outperform benchmark algorithms under a wide range of settings.

Flow networks; cascading failures; vulnerability; optimal attack strategies

I Introduction

Networks that carry or transport physical commodities, e.g., electricity/water/gas distribution networks and road/public transportation networks, have been an integral part of our daily lives for decades. For example, our quality of life largely depends on the continuous availability of an electrical power supply. This dependence is expected to be further amplified in the near future due to the increasing market share of electric vehicles and increasing integration of major national infrastructures to the power grid; e.g., water, transport, communications, etc. All of these point to a future where the reliability of the flow networks will be paramount, with the central research question being how we can design these networks in a robust and reliable manner. In the rest of the paper, we focus our attention on power systems for concreteness, but most of the discussion applies generally to any transport system.

A major problem with existing power systems is the seemingly unexpected large scale failures. Although rare, the sheer size of such failures has proven to be very costly, at times affecting hundreds of millions of people [2, 21, 28]; e.g., the recent blackout in India [34]. Such events are often attributed to a small initial shock getting escalated due to intricate dependencies within a power system [3, 27, 11]. This phenomenon, also known as cascade of failures, has the potential of collapsing an entire power system as well as other infrastructures that depend on the power grid [8, 16, 29]. Thus, understanding the dynamics of failures in power systems and mitigating the potential risks are critical for the successful development and evolution of many critical infrastructures.

In this paper, we continue our study of the robustness of power systems under a simple model based on equal redistribution of flow upon the failure of a power line. Namely, we consider a power system with transmission lines with initial loads and capacities . If a line fails (for any reason), its load is assumed to be redistributed equally among all lines that are alive. Thus, the load carried by a line may exceed its initial value over time due to load redistribution. The capacity defines the maximum flow allowed on the line , meaning that if the load carried by exceeds this capacity at any time, the line will be tripped (i.e., disconnected) by means of automatic protective equipments so as to avoid costly damages to the system. Subsequently, the load that was carried by line before failure will be redistributed to remaining lines, which in turn may cause further failures, possibly leading to a cascade of failures.

The equal load redistribution model gets its appeal from its ability to capture the long-range [7, 19] nature of the Kirchhoff’s law, at least in the mean-field sense, as opposed to the topological models [5, 14, 26] where failed load is redistributed only locally among neighboring lines. For example, it was suggested by Pahwa et al. [19] that equal load redistribution is a reasonable assumption111The equal load redistribution model is also similar in spirit to the well-studied CASCADE model introduced in [8, 9]. There, upon failure of a line, a fixed amount of load is redistributed to all functional lines irrespective of the load being carried by the failed line or the number of remaining lines. especially under the DC power flow model; the DC model is known [17, 24] to approximate the AC model well in many cases. With these in mind, an important goal is to understand the robustness of systems under the equal load redistribution model described above against random and targeted attacks. The former case was studied by Yağan [29] under the assumptions that initial loads are independent and identically distributed with and that capacities are given by

where denotes the tolerance factor; in [29] all lines assumed to have the same tolerance factor. There, the robustness of the system against random attacks that target a -fraction of the lines was studied; system robustness was quantified by the final (i.e., steady-state) fraction of non-failed lines. Among other results, it was shown that the system robustness is maximized if all lines are given the same initial load, for a given fixed mean load .

Recently, Zhang and Yağan [36] extended the results in [29] to the more general case where lines can have varying tolerance parameters. Namely, they let

with denoting the free-space (or, redundancy) available at line . The tolerance factor, given by , may now vary from one line to another. Under the assumption that load-‘free space’ pairs are independent and identically distributed with , they studied the robustness against random attacks that target a -fraction of the lines. Their main result is that, with the mean values and are fixed, is uniformly maximized for all values if all nodes are given the same free space , regardless of how the loads are distributed. This leads to the counterintuitive conclusion that lines with higher initial load shall be assigned smaller tolerance factors to maximize robustness and raises the possibility that the widely used (both in academy and industry) setting of equal tolerance factor is not optimal for system robustness (as far as the metric is concerned).

With the case of random attacks being well-understood, we shift our attention in this paper to understanding the vulnerability of power systems under targeted attacks. As before, the main goal would be to derive design strategies (in the form of optimal load-‘free space’ distributions) that would lead to maximum robustness, this time against a knowledgeable adversary attacking a carefully selected set of lines. However, for this optimization problem to be well-defined one has to have a good understanding of the problem from an adversary’s perspective. With this in mind, this paper aims to develop good attack strategies that lead to maximal damage to the system for a given number of lines that can be attacked. The solution to the optimal attack problem will also help a system designer by i) revealing the worst-case attack vulnerability of the system which can help evaluate a given system design; and ii) revealing the most vulnerable lines in the system that will potentially be targeted by adversaries; this may then provide useful design guidelines for improving system robustness.

Formally, we consider the following optimization problem. Given lines with loads and free spaces , we seek to find the optimal set of lines that the adversary should attack in order to minimize the final number of alive lines. We provide optimal solutions via greedy algorithms in three special cases: i) when all lines have the same load; ii) when for each (as commonly used in the literature [5, 11, 13, 14, 26, 29]); and iii) when all lines have the same free space, i.e., when . The last case is of particular interest as it is known to lead to maximum robustness against random attacks. For general cases of load-‘free-space’ distribution , we develop heuristic attack algorithms and show via simulations that these outperform benchmark attack strategies. In particular, we show that attacking the lines with the largest Load Free-space () is in general a good strategy. Parametrized attack strategies targeting the lines with the largest are also considered where is in , and optimum choices for are provided in several cases.

We also consider a variation of the problem with an additional constraint on the total load of the lines attacked; i.e., when the adversary is further constrained with for some . From a practical point of view, this might be the case if high-load carrying lines are protected better by the network owner and the cost of attacking them is proportional to their load. We show that this variation of the optimal attack problem is in fact NP-Hard, meaning that no polynomial-time algorithm can find the set that minimizes , unless . Our proof is based on a polynomial time reduction from the -Subset Sum problem, i.e., the problem that seeks to find whether a sequence of integers has a subset of size whose sum equals . For the modified optimization problem, we develop several heuristic algorithms and evaluate their performance in comparison with benchmarks through an extensive simulation study. In particular, we modify the previously developed heuristics with a switch that, when actuated during a sequential selection of lines to be attacked, changes the way algorithm makes the remaining selections; this idea is inspired from heuristics developed in [12] for the multi-dimensional - Knapsack problem. Among other things, we demonstrate via simulations that the max- algorithm with a switch performs well in a range of settings.

We believe that our results will shed some light on the vulnerability of power systems against powerful adversaries launching targeted attacks. In particular, we expect them to capture the qualitative properties of a power system well. This work may also have applications in other fields. In particular, the model considered here might be relevant for any flow network that is responsible for carrying (or, transporting) a physical quantity. A particularly interesting application is the study of traffic jams in roads [20], where the capacity of a line is regarded as the traffic flow capacity of a road.

The rest of the paper is organized as follows. We describe the system model in Section II. In Section III, we survey the results in [36] concerning robustness against random attacks. We start our discussion on optimal attack strategies in Section IV by demonstrating that certain greedy algorithms fail to give the optimal solution in general. In Section V we consider some special cases of interest where greedy algorithms are shown to find optimal attack sets. In Section VI we prove a hardness result showing that a variation of the optimal attack problem is NP-Hard. Finally, in Section VII, we develop heuristic algorithms for both the original and the modified optimization problems and present a detailed numerical study comparing the performance of our heuristics with benchmark algorithms such as max-, max-, max-, and random attacks.

The random variables (rvs) under consideration are defined on the probability space , where denotes the probability measure. We denote the expectation operator by . The indicator function of an event is denoted by . We write for the cardinality of a discrete set .

Ii System Model

We consider a power system with transmission lines with initial loads (i.e., power flows) . The capacity of a line defines the maximum power flow that it can sustain, and is given by

(1)

where denotes the free-space (or, redundancy) available to line . The capacity of a line is typically written [14, 26, 13, 5] as a factor of the line’s original load, i.e.,

with defining the tolerance parameter for line . Put differently, the free space is often given in terms of the initial load with . It is assumed that a line fails (i.e., outages) if its load exceeds its capacity at any given time. In that case, the load it was carrying before the failure is redistributed equally among all remaining lines.

The main question of interest is to characterize the robustness of this power system against i) random attacks that result initially with a failure of a (randomly selected) -fraction of the lines; and ii) targeted attacks that initially fail a specific set of lines. The initial set of failures lead to redistribution of power flows from the failed lines to alive ones (i.e., non-failed lines), so that the load on each alive line becomes equal to its initial load plus its equal share of the total load of the failed lines. This may lead to the failure of some additional lines due to the updated flow exceeding their capacity. This process may continue recursively, generating a cascade of failures, with each failure further increasing the load on the alive lines, and may eventually result with the collapse of the entire system.

Throughout, let denote the final fraction of alive lines when a -fraction of lines is randomly attacked. The robustness of the power system can be evaluated [29, 36] by the behavior of as the attack size increases, and particularly by the critical attack size at which drops to zero. In the case where a specific set of lines are attacked, we define as the final number of alive lines. The main goal of this paper is to seek optimal attack strategies, i.e., to find the set of lines that minimizes under certain constraints; e.g., the size being fixed.

The equal flow redistribution model is inspired by the democratic fiber bundle model [1, 6], where parallel fibers with random failure thresholds (i.e., capacities) drawn independently from share equally an applied total force of ; see also [20, 22]. This model has been recently adopted by Pahwa et al. [19] in the context of power systems with corresponding to the total load that power lines share equally. The formulation considered here, introduced in [29, 36], differs from the original democratic fiber-bundle model in that i) we do not assume that the total load of the system is fixed at ; and ii) we allow for power lines to carry different initial loads; see also [18]. In addition, [19] is concerned with failures in the power system that are triggered by increasing the total force (i.e., load) applied. Instead, our formulation allows analyzing the robustness of the system against external attacks or random line failures, which are known to be the source of system-wide blackouts in many interdependent systems [3, 32, 35].

Iii Relevant Work: Evaluating and Optimizing Robustness against Random Attacks

We now survey the results obtained by Zhang and Yağan [36, 29] on the robustness of power systems under equal load redistribution of loads. These works consider the problem from a defender’s perspective and provide means to characterize and optimize the robustness of the system, assuming that the adversary will launch a random attack to a certain fraction of lines. With the randomness involved in the attack model, as well as load-capacity values, [29, 36] rely on mean-field analysis to characterize the mean performance of the system in the asymptotic regime where approaches infinity.

Throughout this section, assume that the pairs are independently and identically distributed with for each . The corresponding probability density is given by . We assume that and with probability one, and that the marginal densities and are continuous on their support.

Iii-a Final system size as a function of the attack size

The main result in [36] characterizes the robustness of power systems under any distribution of initial load and free space , and any attack size .

Theorem 3.1 ([36])

Let and denote generic random variables following the same distribution with initial loads , and free space , respectively. Then, with denoting the smallest solution of

(2)

over , the final system size is given by

(3)

An intuitive explanation of this result is that , defined as the smallest solution of (2), gives the extra load each alive line has to carry (in addition to their initial load) at the steady-state; (3) is then understood easily since a line will still be alive at the steady-state if i) it is not targeted initially; and ii) it has enough free-space to handle the extra amount of load.

For a graphical solution of , one shall plot as a function of , and draw a horizontal line at on the same plot. The leftmost intersection of these two lines gives the operating point , from which we can compute . When there is no intersection, we set and understand that ; e.g., see Figure 1.

Fig. 1: We see the variation of final system size as a function of the (random) attack size when loads are drawn independently and uniformly from the range , and free spaces are given by . Red (lower) curve stands for , whereas blue (upper) curve represents . For , we observe an abrupt first-order transition of as it suddenly jumps to zero at , while decaying linearly as up until that point. A slightly different behavior is seen when in that exhibits a continuous divergence from the line before complete system failure, which again takes place through a discontinuous transition.

Theorem 3.1 enables computing as a function of , thereby helping understand the response of the system to attacks of varying magnitude. It also enables computing the critical attack size defined as the largest attack the system can sustain. More precisely, we define

so that for any attack with size , the system undergoes a complete breakdown leading to . The next result provides a closed form expression for the critical attack size.

Theorem 3.2 ([36])

The critical attack size is given by

(4)

The operational usefulness of derives in part from its ability to quantify the system robustness by a single scalar, paving the way to designing the system with optimal robustness by means of maximizing ; see Section III-B below.

An interesting question here is whether decays to zero continuously (i.e., through a second-order transition), or discontinuously (i.e., through a first-order transition). The practical significance of this is that continuous transitions suggest a more stable and predictable system behavior with respect to attacks, whereas with discontinuous transitions, system behavior becomes more difficult to predict based on past data. In [36], it was shown that the total breakdown of the system will always be through a first-order (i.e., discontinuous) transition under random attacks. More precisely, it was shown that while by definition it holds that for any arbitrarily small. This shows that despite its simplicity, the equal flow redistribution model can capture real-world phenomena of unexpected large-scale system collapses; i.e., cases where seemingly identical attacks/failures leading to entirely different consequences. In addition, depending on system parameters, the first-order breakdown may have early indicators at smaller attack sizes such as a diverging failure rate leading to a non-linear decrease in . In other cases, the system abruptly transitions to a total collapse while perfectly resisting attacks until the critical point; see Figure 1 and [36, Fig. 2] for the rich transition behavior that can be observed under the equal load redistribution model.

Iii-B Achieving Optimal Robustness

An important question from a system designer’s perspective is concerned with deriving the universally optimum distribution of initial loads and free spaces when the mean values and , respectively, are fixed. The results obtained in [36] concerning this are presented next.

Theorem 3.3 ([36])

For any initial load-free space distribution, it holds that

(5)

where denotes the critical attack size when the free-space follows a Dirac-delta distribution, i.e., , for any .

In words, this result states that the critical attack size can never be larger than the ratio of mean free space to mean capacity. In addition, this optimal value can be achieved by assigning every line the same free-space, i.e., by setting , regardless of how loads are distributed.

Thus far, we have seen that the equal distribution of free space leads to the largest possible critical attack size, hereafter denoted . It is clear that the final system size after an attack of size is at most . With this in mind, the next result establishes the optimality of the Dirac-delta distribution of free-space in the sense of maximizing the robustness of power systems uniformly over all attack sizes.

Theorem 3.4 ([36])

With we have

Hence, the Dirac-delta distribution of free-space maximizes over the entire range .

These findings suggest that under the equal flow-redistribution model considered here, power systems with homogeneous distribution of redundant space are more robust against random attacks and failures, as compared to systems with heterogeneous distribution of redundancy. Interestingly, this suggests that the optimal robustness is achieved when the tolerance factor decreases with increasing load, leading to the counter-intuitive conclusion that the lines carrying the highest load should have the smallest tolerance factor to achieve maximum robustness; see [36] for a more detailed discussion on this matter.

Fig. 2: In this example we have (load, capacity) values given by where is arbitrarily small. The greedy maximum-load attack will need to attack containers to fail all. It will start attacking the leftmost container with load which will not lead to any further failures. Then, it will continue with the second one from the left, again unable to trigger a cascade, and continue until attacking all containers directly. The optimal solution can be seen to be by attacking the last container, which will trigger a cascading failure destroying the whole system. We can generalize this counterexample to the case with containers with the greedy algorithm’s output being while the optimal solution being .

Iv The optimal attack problem and insights

While existing results in [36, 29] shed some light on the robustness under the equal flow redistribution model, many real-world threats to power systems would be expected to come from powerful adversaries targeting specific parts of the grid to inflict maximum damage on the overall system. In order to understand the system’s robustness against such targeted attacks and to reveal its most vulnerable lines, we now consider the problem from an adversary’s perspective and seek effective strategies for attacking the system under given constraints. In particular, we consider a scenario where the adversary has full information about the system and aims to find the best set of of lines to attack so that it fails maximum number of lines as a result cascading failures. This optimization problem is formally introduced next.

Iv-a The Main Optimization Problem: ER-

The Equal Redistribution (ER) problem with attacks is the optimization problem, denoted ER-, that aims to find the set of lines such that attacking leads to the maximum number of total line failures (as a result of load redistribution and cascading failures), among all possible attack sets with size . Put differently, we seek to find with that minimizes . Throughout, we find it useful to consider the decision version of this optimization problem (referred to as the ER-- problem) formally defined as follows.

INPUT: pairs of non-negative numbers in the form indicating the load and the capacity of each line, and integers and such that . We assume so that no line fails initially at its own load.

OUTPUT: The answer to whether or not there is an attack set with size , such that at the end of the cascading failures the number of failed nodes is at least ; i.e., whether there exists with and .

Iv-B Heuristic Algorithms that Fail

Here we will present three intuitive greedy algorithms and give concrete examples demonstrating their poor performance for the optimization problem described above. In doing so, we will focus on the special case where meaning that the goal of the attack is to destroy the whole system, by attacking a minimum number of lines.

In what follows, we find it useful to describe the problem in a simpler way, where we have water containers with capacities , and initial water levels . As in the equal flow-redistribution model, when a container is "attacked" its content is redistributed equally to the remaining containers. Also, if the water level in a container exceeds its capacity, we assume that it has failed and redistribute its content, again equally, to the remaining containers. With this formulation, the goal of the attackers is to find the smallest number of containers to target so that all containers get overloaded and fail eventually.

An important observation is that the following intuitive algorithms can deviate significantly from the optimal solution.

Greedy max-load attack

This greedy strategy aims to maximize the load that will be redistributed in each attack round. Namely, it starts by attacking the container with the highest load, and proceeds similarly, waiting after every attack for a steady-state to be reached (meaning that all load redistribution and potential further failures end). The algorithm stops when all containers fail. This strategy is not optimal in general because it fails to recognize the opportunity to eliminate containers with very large capacities that will otherwise be difficult to fail by redistributing the load. The worst-case deviation from the optimal (in terms of the number of lines needed to be attacked for complete system failure) is ; e.g., see Figure 2.

Fig. 3: Consider containers where (load, capacity) values are given by for the first containers and for the last containers; here is arbitrarily small and . The greedy max-capacity attack will need to attack containers to fail the all containers; it will start attacking the first containers but cascading failures will not take place. On the other hand, the optimal solution is as it takes to attack only one of the containers with to trigger a cascading failure that will fail all.

Greedy max-capacity attack

This strategy is similar in spirit with the greedy max-load attack except that this time the container with the maximum capacity is attacked in each round. The idea here is that by taking out large containers, the remaining, supposedly small, containers will be destroyed due to load redistribution. This strategy is not in general optimal either, because there may be containers with large capacities but small (or, even almost zero) loads, rendering an attack to such containers very ineffective in terms of triggering failures by means of load redistribution. The worst-case deviation from the optimal is again as demonstrated in Figure 3.

Greedy max-free-space attack

It is clear from the previous two cases that the optimal attack strategy will be one that considers both the loads and capacities of the containers involved. The greedy approach that targets containers with largest free space (i.e., difference) falls into this category, and is based on the fact that containers with largest free space will fail the latest in the course of a cascading failure; e.g., see Section IV-C for a discussion of this fact. Therefore, it is sensible to eliminate those containers with a direct attack. On the other hand, containers with small free space are already on the verge of failing and therefore can be taken down by means of redistribution of loads. Although this greedy strategy is intuitive (and in fact optimal in some special cases), it fails to be the optimal solution in general. The main reason is that this approach does not take into account the loads of the containers directly. For example, a container may have a large free space but its load may be negligible compared to other containers, rendering a direct attack on this container ineffective. The worst-case deviation from the optimal is again as demonstrated in Figure 4.

Fig. 4: In this example we have containers with (load, capacity) values for the first containers and for the last container, where is arbitrarily small and satisfies . The greedy max free-space () attack will output since it will start attacking the leftmost containers and no cascading failures will take place. The optimal solution is obviously by attacking the last container.

Iv-C Observations towards Designing a Smart Algorithm

We now present some observations that will be useful in designing a smart attack algorithm.

The order of attack does not matter

In the equal redistribution model, the order with which we launch an attack does not affect the final set of failed containers. This is because the load of the attacked nodes will be distributed to all of the remaining nodes so at the end an amount of will end up in the remaining containers (leading to new failures or not) irrespective of the order we chose to attack the containers in . We remark that an attack strategy can still be designed in a greedy fashion, where the set is determined one member at a time, waiting for cascades to stop after each attack.

Order of failures during the cascading process

Assume that containers are sorted by increasing free space, . Given that any failed load is redistributed equally among the remaining containers, it is clear that this ordering will remain the same throughout the course of cascading failures; the containers that are attacked directly at the beginning are excluded from this argument. Therefore, in the process of recursive load redistribution, containers will fail (due to their free space diminishing to (below) zero) in this exact same order: the one with smallest free space will fail first, and so on and so forth.

V Optimal Attack Strategies under Special Cases

We now present three special cases of the ER- problem and provide optimal attack strategies for each of them.

Same Loads

An interesting situation arises when initial loads are the same for all containers while capacities differ. This reflects situations in which all lines in the power system are given the same initial load, but have different capacities owing to the physical constraints or material used. We show that a greedy algorithm finds the optimal solution in this special case. The ER--Same Loads Problem is defined formally as follows.

INPUT: A non-negative rational number for the common load and a list of non-negative numbers indicating the capacity of each line. The integer represents the number of attacks we can launch.

OUTPUT: The set of lines to be attacked that minimizes under the constraint .

The next result, proved in Supplementary Material, shows that the max--greedy algorithm finds the optimal solution.

Theorem 5.5

The --Greedy Algorithm is optimal for the ER--Same Loads Problem.

Same Free Spaces

Sometimes it might be the case that the containers have arbitrary load and capacity but they have a fixed free space. In [36], this was in fact shown to be the optimal design that gives maximum robustness against random attacks. We refer to the corresponding problem as the ER--Same Free Spaces, formally defined as follows.

INPUT: A list of non-negative rational numbers indicating the load of each container and a positive rational number indicating the common free space.

OUTPUT: Find the minimum number of containers needed to be attacked in order to destroy the whole system.

We changed the output from having a fixed number of lines to be attacked to inflict the maximum damage, to the case where we aim to destroy the whole system with the minimum number of attacks. This is because in the case where every container has the same free space, there are no intermediate cascading failures. After an attack, the system will either fail completely, or no single line will fail other than those attacked directly. We show in Supplementary Material that the --Greedy algorithm that targets lines with the largest loads leads to the optimal solution for this problem.

Theorem 5.6

The --Greedy Algorithm is optimal for the ER--Same Free Spaces Problem.

Capacities Proportional to Loads

In many cases, the capacities and the loads of power lines are related in a particular way. Namely, the capacity of a line is often set to be proportional to its load. For example with denoting the tolerance factor, we have for each line . In this variation, we will also show that there is a greedy algorithm achieving the optimal solution. The ER-- Problem is defined formally as follows.

INPUT: A list of non-negative numbers indicating the load of each container and a positive number such that container capacities are set to for each .

OUTPUT: The set of lines to be attacked that minimizes under the constraint .

In this setting, load, free-space, and capacity of the lines will be ordered in the same way, and as we show in the Supplementary Material, --Greedy algorithms that target lines with the largest load and free-space and capacity give the optimal solution to this problem.

Theorem 5.7

The --Greedy Algorithms are optimal for the ER-- Problem.

Vi A modified optimal attack problem with total load constraints

In this Section, we will prove that a variation of the decision problem ER-- is NP-Complete. In particular, we consider the ER--- problem, defined formally as follows.

INPUT: pairs of non-negative numbers in the form indicating the load and the capacity of each line, integers and such that , and a positive number . We also assume for each .

OUTPUT: The answer to whether or not there is an attack set with size , and total sum of loads , such that at the end of the cascading failures the number of failed nodes is at least ; i.e., whether there exists with , , and .

It is clear that the objective is two-fold here and that there is an inherent trade-off: by attacking lines with larger initial loads we can shed more load on other lines and have a better chance to trigger a cascade of failures that would destroy the whole system. However, the problem enforces a constraint on the total load of the attacked containers as well. This knapsack-like trade-off is what makes the problem NP-complete as we now show. Our proof is based on the reduction of the ER--- problem from the -Subset Sum variant defined as follows: Given a set of integers and a target sum , is there any subset of size whose sum is ?

Theorem 6.8

The ER--- Problem is NP-Complete.


Proof.  First, we show that ER--- Problem is in NP: The certificate is a list of the containers we choose to attack. We can check in polynomial time (e.g., see the ER-Attack Projection algorithm in [4]) whether at least lines in the system fail or not. Since we have a certificate that can be checked in polynomial time, ER--- is in NP!

Given an instance of the -Subset Sum problem we will create an instance of the ER--- problem: Given a set of integers , the -Subset Sum problem asks whether there exists members of the set whose some equals . If , we can check if and respond accordingly. From now on, we suppose and create an equivalent version of the ER--- problem in the following manner. Let lines have loads and consider the ER--- problem; i.e., we seek to find a set of lines such that and that attacking leads to failure of at least lines in the system. We also set where the free space is for each . This last constraint ensures two things. First, as discussed in Section V, when all lines have the same free space then attacking lines can only have two consequences: either only those lines that are attacked fail, or all lines fail. In either case, there is no cascade of failures and the system reaches a steady-state immediately. Thus, with equal free space among all lines, the ER--- problem with is equivalent to ER--- problem. Secondly, under the enforced assumptions it is clear that a complete system failure will take place if and only if the total load failed by the initial attack is larger than the sum of the free spaces of those that are not in the attack set ; i.e., if and only if

Here, the first equality follows from the facts that and for each . Recalling further the constraint that , this leads to . Therefore, the created instance of the ER--- problem indeed seeks to find a subset of such that and , rendering it equivalent to the -Subset Sum instance that we have started with. For the reverse direction, assume that the ER--- problem has a solution with lines . Then the loads of these lines constitute a solution to the -Subset-Sum problem.

The above reduction can be constructed in polynomial time (more precisely, in linear time), so if there was a polynomial algorithm that could solve the ER---, then the -Subset Sum would be in P, which is wrong unless P=NP. Thus, we conclude that the ER--- Problem is NP-complete.  

An important implication of the above result is that the optimization version of the ER--- problem, which seeks to find the set of lines that minimizes under the constraints and , is NP-Hard. This means that under these constraints, the adversary can not launch an optimal attack in polynomial time unless P=NP.

Vii Heuristic algorithms and their performance

Although, it is not known whether the original optimization problem of finding the best lines to attack to minimize final system size is NP-Hard or not, the discussion in the preceding section indicates that the optimal attack problem is likely to be computationally challenging; in particular, we know that the problem is NP-Hard if we are further constrained by the total load of those we can attack. This prompts us to develop heuristic algorithms, for both the original and the modified optimization problems, that work in polynomial time and have competitive performance under arbitrary load-capacity distributions. The performance of these heuristics will then be compared with some benchmark heuristics such as max-, max-, max-, and random attacks.

In the interest of brevity and concreteness, the discussion is restricted here to non-greedy algorithms that choose the attack set without ever running the attack projection algorithm. In other words, the algorithms are not allowed to run the cascading failures initiated by a subset of , and then continue making the remaining selections from the lines that survived the cascade. Of course, all heuristics considered here including the benchmarks can be modified to operate in a greedy fashion. One might also be tempted to use a greedy algorithm where, at each round, the line to be attacked is chosen in an optimal way; i.e., the line whose failure leads to smallest number of surviving lines is chosen from among all lines that are still alive. However, for the problem at hand, one can realize that unless is relatively large, the final system size equals regardless of the set of attacked lines. For example, with , this will be the case whenever

meaning that if , the greedy heuristic will have to deal with ties when making its choices for the next line to be attacked until it makes choices. Since resolving the ties by randomization for such a large number of selections is likely to lead to poor performance, one needs heuristic rules to resolve the ties. Even then, our preliminary simulation study indicated that the greedy versions of the heuristics considered here perform only slightly better than their non-greedy counterparts, and the comparison among the greedy heuristics provided no additional insight to what was already observed from non-greedy algorithms; hence the decision to consider only non-greedy attack strategies here.

Vii-a Heuristics for the original optimization problem

We first consider the original case where there is no constraint on the total load of the lines that can be attacked; i.e., we consider the ER- problem. Let be the set of lines to be attacked such that . It is clear from the previous discussions that a good attack should aim to

(6)
(7)

In words, the attack should aim to find the lines with the largest free space while making the total load of the failed lines as large as possible. Thus, the attack should intuitively look for lines with large initial load and large free-space. Of course, most difficult situations arise when the load and free-space values of the lines are in reverse order; e.g., the highest load carrying line has the smallest free-space, etc. as in Figure 2.

Our main idea towards handling the trade-off described above is based on its similarities with the well-studied 0-1 Knapsack problem. In the 0-1 Knapsack problem, we are given a set of items, , each with a weight and a value , and the goal is to choose items such that their total value is maximized while the total weight is bounded by ; i.e.,

(8)
(9)

The 0-1 Knapsack problem is known to be NP-Hard, but polynomial-time heuristics can still give close-to-optimal solutions. For example, a competitive heuristic is to order the items based on their "value per weight", i.e., , and choose items according to this order, starting with the one with the highest , until the total weight capacity is reached. In fact, with a small modification to handle corner cases, this heuristic is known to yield at least of the optimum value.

The optimal attack problem we consider, i.e., the ER- problem, has some similarities with but is not equivalent to the 0-1 Knapsack problem. In particular, one can construct an analogy between the constraints of the 0-1 Knapsack problem and the ER- problem by assigning all item weights as and the total weight limit to be . However, the objectives (6)-(7) of the ER- problem are much more complex than the objective (8) of the Knapsack problem. Nevertheless, the two problems have some similarity in that their main difficulties lie in the trade-offs involved. In the Knapsack problem the trade-off is between the value and the weight of the item and it is desirable to pick items with high value and low weight, while in the ER-, the trade-off lies between the possibly conflicting objectives of choosing lines with high load and high free-space. Inspired with the efficient heuristic for the Knapsack problem that is based on selecting items with the largest ratio (i.e., items with the biggest bang for the buck), our first heuristic for the ER- problem is based choosing lines with the highest load times free-space, i.e., with the highest .

Maximum LoadFree Space Attack

In this algorithm, the load free space product, is computed for each line . After sorting the lines based on this product, the lines to be attacked is chosen as the ones having the highest load-free space product. As mentioned above, this is inspired by the 2-approximation heuristic for the Knapsack problem that orders items according to when the goal is to choose items with high and low . In the ER- problem, we wish to choose lines with high and high , or equivalently, with high and low . Thus, constructing an analogy between value and load , and weight (or, cost) and , our heuristic chooses lines with the maximum

The performance of this heuristic is demonstrated via several numerical examples in the next subsection along with a comparison with some benchmark heuristics.

Aside from its connection to a powerful heuristic in a relevant problem, the maximum heuristic has several advantages. First of all, this heuristic becomes equivalent to the optimal attack strategy in the three special cases considered in Section V; e.g., when all lines have the same load, it chooses ones with highest free-space (and hence capacity), or when all lines have the same free-space, it chooses lines with maximum , etc. Secondly, considering the product is an effective way to favor lines with high load and free-space, while heavily penalizing load or free-space values close to zero; note that benchmark heuristics including the highest-capacity attack () fail to penalize small or values. In the optimal attack problem, this makes perfect sense given that a line with almost no load should never be attacked even if it has very high free-space since its failure will likely not affect any other line. Similarly, it may not be a good idea to directly attack a line with almost no free-space even if it has very high load, since the line will likely fail due to load redistribution regardless of which other lines are attacked.

Maximum attack

While maximum attack is intuitive and will be seen to be powerful in many cases, we observe that its performance can be further improved by a small modification. To this end, we propose a second heuristic as a modified version of the max- attack that allows adjusting the relative importance of load and free-space values of the lines. In particular, with in , we consider a heuristic that chooses lines with the maximum . An added benefit of this heuristic is that it contains several heuristics as special cases. In particular, the maximum algorithm described above is obviously a special case of this algorithm, corresponding to the case . Also, by setting , this heuristic reduces to the max- attack, while setting (or, large enough) makes it equal to the max- attack.

Vii-B Numerical Comparison with Benchmark Heuristics

We now compare the heuristics we developed against some benchmark heuristic algorithms via numerical experiments. The benchmark heuristics we will consider are given below:

Random attack

This is the most primitive attack strategy and considered here only for comparison purposes. The attack picks lines to be attacked uniformly at random from amongst all lines.

Highest-, highest-, highest- attacks

These three attacks are based on sorting lines with respect to their initial load , free-space , or capacity , respectively and attacking the top lines with the highest value of the corresponding metric.

We fix the number of lines at for all experiments. First, we consider the case where each line is independently given an initial load from a uniform distribution, , where we set and . The free-space allocated to each line is generated independently from its load, again from a uniform distribution, with , . The capacity of a line is given by the sum . The independence of and leads to some lines having high load but small free-space, or vice versa, rendering the optimal attack problem non-trivial; e.g., with these choices, the realized load-capacity values will almost surely not fall into one of the special cases presented in Section V where an optimal solution is available.

Under this setup, we compute the final system size as a function of the number of lines attacked, where the set of attacked lines are selected according to the heuristics considered. The results are given in Figure 5 where each data point is obtained by averaging over 100 independent runs. We already see in this simple setting that our attack strategy of targeting lines with the highest outperforms all other benchmarks (except a small interval of attack size where max- attack seems to give the highest damage). In particular, we see that the highest attack is able to fail the whole system by targeting , , , and fewer lines as compared to max-, max-, max-, and random attacks, respectively.

Fig. 5: The performance comparison of different heuristic algorithms for , ,

Next, we check if this performance can be further improved by attacking lines with highest for some . To this end, we repeat the previous experiment as varies from zero to ten. The results are demonstrated in Figure 6 and as expected show that with or , we obtain the same performance with max- and max- attack, respectively. More interestingly, we see that the case is indeed not the best one can do. For example, we see that when , the max- attack can fail the whole system by attacking 75 fewer lines the case for . To demonstrate this better, we plot in the inset of Figure 6 the minimum number lines needed to be attacked to fail all lines. To compute this, we again run 100 independent experiments and pick the minimum attack size for which all 100 experiments led to entire system failure.

Fig. 6: The performance comparison of maximum algorithms for various values for , , Inset: The minimum number of lines needed to be attacked to fail all lines for the maximum attack.

The performance of heuristic algorithms are known to vary significantly under different parameter settings, and our case is not expected to constitute an exception. To that end, we have tested the performance of the max- attack with , for a wide range of possibilities for the distribution of and . In all cases we considered, we were able to identify a value for which the max- attack was at least as good as all benchmark attacks (random, highest--attacks) showing its versatile performance.

As already mentioned, the most challenging cases arise when the load and free-space values are in reverse order. To that end, we close this section by demonstrating the performance of the max- attack in such cases. In particular, we start by generating and independently according to some distribution. Then, the load values (resp. free-space values) are sorted and re-arranged in increasing (resp. decreasing) order, leading to highest-load carrying line having the smallest free-space, and so on. To make the problem more challenging and interesting, we also consider Pareto distribution. Namely, a random variable is said to follow Pareto distribution, written with and , if its probability density is given by

To ensure that is finite, one must set , while the variance of is finite only if .

The results for the case where and values are reverse ordered are depicted in Figure 7. Here, we show a small number of representative results that correspond to different behaviors for brevity. As before, all results correspond to the minimum attack size that led to an entire system collapse in all 100 experiments. The curves represent the results for the max- attack as varies from zero to two. In each plot, we add the corresponding results for the max- attack (shown by a filled square) and random attack (shown by a filled circle) as well; for convenience, the -axis values for these symbols are chosen such that they stay on the corresponding curve showing the results for max- attack. We note that the max- attack is already demonstrated by the case while gives a good indication of the performance of the max- attack, so these plots provide a comparison of the max- attack with all the benchmarks considered here.

Fig. 7: Minimum number of lines needed to be attacked to fail all lines in the system is shown when load and free-space values are generated independently (from the distributions given at the figure legend) and then sorted in reverse orders; e.g., to ensure , while . Curves stand for the results obtained under the max- attack as a function of . Corresponding results for the max- attack are shown by filled square symbols, and those for the random attack by filled circles.

The main observations from Figure 7 are as follows. We see that in all cases there is a particular value for which the max- attack performs the best among all benchmarks; it is only the case of where we see that the best performance of max- attack is attained when , or meaning that max- attack matches the performance of the max- attack. Also, we see that the value that leads to the best performance can be equal to, smaller than, or larger than one in different scenarios showing the importance of trying different values of to get the best performance. Finally, while benchmark attacks (including the random attack) occasionally give results close to the best max- attack, we see examples for each benchmark where its performance is significantly worse than the best max- attack; these cases are summarized in Table I.

Distribution of Minimum # of lines to attack to fail all
and random max- max- max- best
71 71
491
1411
541
from the
UK National Grid 1441
TABLE I: Performance comparison of benchmark attacks with the best result of the max- attack. The first four rows are obtained from Figure 7, while the last row is obtained from simulations with UK National Grid data (see Section VIII for details). Values significantly worse (in the sense of needing to attack many more lines to fail all) than the best- attack are made bold.

Vii-C Heuristic attacks for the modified optimization problem

We now consider the modified optimization problem ER--- where the attack set is further constrained by , in addition to . As shown in Theorem 6.8, in this case finding the attack set that minimizes the final system size is NP-Hard, prompting us to develop heuristic strategies. With the additional constraint on the total load of the lines that we can attack, the trade-offs involved become more complicated and heuristics developed in the previous section may not be well-suited for the ER--- problem. Ultimately, our strategy should be to choose an attack set that has (or, very close to ) lines with total load equal (or, very close) to , and that have the highest free space among all lines. This is because at the first stage of the cascades, any line that was not directly attacked will fail only if

Thus, to facilitate failures it is desirable to make and as large as possible, while as small as possible.

Given the multiple constraints involved, this problems shows similarity with the 2-dimensional 0-1 Knapsack problem [12, 23, 25]: Consider a collection of items, where each item is given a value , has weight , and volume . The objective is then to maximize subject to and where ; i.e., we want to choose items with the maximum total value while the total weight is limited by and total volume is limited by . As can be inferred from the discussion above, an important difference of the ER--- problem is that while it is desirable to choose lines with high (could be thought to be analogous to the “value” of the item) under given constraints, it is perhaps equally important to attain or be very close to the limits on both total load and total number of lines attacked.

Fig. 8: The performance comparison of different heuristic algorithms for , , , when the attack is constrained to lines such that their total load satisfies a) ; b) ; c) ; d) .

With these in mind, our heuristics for the ER--- problem are based on incorporating a switch to the previously developed heuristics that is actuated to ensure that the attack set attains or gets close to both constraints on its cardinality and the total load. This idea is inspired from the greedy-like heuristic developed for the multi-dimensional Knapsack problem in [12]. This algorithm initially starts choosing items based on a given set of rules until one or more of the constrained resources become scarce, and then switches to a different set of rules that favor items that use very little of the scarce resource. Here, we propose to use a heuristic that chooses the lines to be attacked one at a time according to the previously developed max- strategy. After each selection, we check whether the switch needs to be activated. Namely, with denoting the set of lines selected so far, we check

  • Is it still feasible to select all remaining lines from the smallest load carrying lines available? Namely, with the remaining lines’ loads sorted in ascending order , we check if

    If the answer is YES, we continue with the second condition for the switch, while if the answer is NO, the switch is activated and algorithm is finished by appending with lines with the smallest load-carrying lines available; i.e., with . Alternatively, one can release the latest added member of and append it with lines ; we found no major performance difference between these two approaches.

  • Next, check whether it is feasible to select all remaining lines from the largest load carrying lines available. Namely, with the remaining lines’ loads sorted in ascending order , we check if

    If the answer is NO, we continue the algorithm with the next selection, while if the answer is YES, the switch is activated and algorithm is finished by appending with lines with the largest load-carrying lines available; i.e., with .

The two conditions of the switch described above ensure that while the initial selections are made in line with the original objectives of picking lines with high load and high free-space, care is also given so as to be able to pick (or, ) lines whose total load is close to the limit . Of course, any algorithm including the benchmarks can be modified using the switch idea to better accommodate total load constraints. In particular, when the total load limit is extremely stringent, it would be tempting to pick lines with small load so as to not exhaust the total load limit quickly, while aiming to choose lines with high free-space. This prompts us to consider the max- heuristic as well, including its modification with the switch idea described above. To keep the discussion brief we do not present results for the max- attack (with or without switch) and consider only the case where ; this is in part due to the fact that when the switch is added, the performance of the max- attack becomes much less sensitive to variations in over small ranges.

Fig. 9: The performance comparison of different heuristic algorithms for , , with and sorted in reverse order, , when the attack is constrained to lines such that their total load satisfies a) ; b) ; c) ; d) . Each data point is obtained by averaging over 100 independent runs.

We now present numerical results to evaluate the performance of the heuristic attacks developed here and compare them against benchmark algorithms; as before, we will use max- and random attacks as benchmarks. Different from the experiments conducted in Section VII-A, here we have to vary not only the maximum number of lines that can be attacked, but also the limit on the total load of the attacked lines. In particular, we would expect the performance of the algorithms to depend heavily on . To this end, we find it meaningful to let vary with and to set it in reference to the mean total load of randomly selected lines; i.e., we set

(10)

for some constant . This choice enables us to tune to different levels and check performance in cases where (i) the total load is extremely limited (i.e., ); ii) total load limit is such that heuristics that do not take load into account (such as max- or random attacks) will likely be able to select (close to) lines with total load very close to (i.e., ); or iii) total load limit is not stringent at all (i.e., ) and the problem is similar to the unconstrained load case.

In the first set of experiments, we set and generate load-free space values independently from the distributions and . For brevity we consider four values of given at (10): , , , . The results are presented in Figure 8 from which a number of interesting observations can be made. When , i.e., when total load is extremely constrained, we see that all heuristics without a switch perform poorly and are not able to fail the whole system even until . This can be attributed to their inability to attack the maximum allowed number of lines as they quickly exhaust the total load limit. On the other hand, we see that both max--with-switch and max--with-switch attacks perform much better, and despite the stringent limit on the total load are able to fail the system by attacking about 50% more lines than required in the case where the total load is unlimited. When is increased to , we see that the performance of the benchmarks improve but still are significantly worse than the two heuristics that use the switch; in this case we also see that the max--with-switch attack slightly outperforms max--with-switch.

With , we see that algorithms that ignore the loads such as max- and random attacks perform as well as they do in the unconstrained case; this is expected by virtue of the law of large numbers. In particular, when , we would expect max- to perform well since it picks the most robust lines in the system and is likely to reach the limits and simultaneously given that is independent from . Figure 8 confirms this intuition where we also see that both heuristics with switch match the performance of the max- attack. Finally, with , we get close to the unconstrained load case, and as expected see that the performance of the max- algorithm becomes the best. What is interesting here is that the max--attack-with-switch is able to match this performance, showing its versatile performance across very different cases considered here. Overall, these experiments demonstrate that incorporating the switch significantly improves the performance and the max--attack performs well across different ranges of the total load limit.

As in Section VII-A, it is of interest to check the performance of these algorithms in difficult cases where load and free-space values are sorted in reverse orders. To this end, we consider one of the settings used in Figure 7, and generate load and free-space independently from and , and then sort them in reverse orders so that the line with maximum load gets the smallest free-space and so on and so forth. In this setting, max- and max- heuristics become equivalent. Also, since large values are around 150 while is limited to , the lines with maximum- will be those with large (and small due to reverse ordering). As seen in Figure 9, this leads to three benchmarks (max-) performing almost equally in this setting.

We see from Figure 9 that the max--attack-with-switch once again performs well. It leads to the best performance among all heuristics considered for , , and (equal with max-), while coming second for after max-; this is expected since without a stringent limit on total load, the problem gets closer to the unconstrained case where a switch is not needed. Also, in this case we see that the performance of the max- attack (along with max- and max- attacks) is rather unaffected by the load constraint. We attribute this to the fact that since load and free-space are reverse ordered, targeting max- lines is equal to targeting min- lines and even when the total load limit is not likely to be exhausted easily; i.e., the algorithm is able to choose lines without exceeding the total load limit. We think this is also the reason why the switch is not helping (and, actually hurting) the max- algorithm in this case.

Viii Simulations with UK National Grid Data

In this section, we provide simulation results illustrating how the attack strategies covered here performs when the load and free space distribution are based on real data. We have used National Grid Electricity Ten Year Statement 2016 Model of Great Britain [15] to generate load-free space pairs. To be more precise, the load distribution is chosen from the winter peak power flow diagram presented in [15, Appendix C]. For the free-space distribution, the transmission line ratings given in [15, Appendix B] has been used. As in the case of previous examples, the number of lines is taken as .

In Figure 10, we show the performance of the heuristic algorithms for the unconstrained case, i.e., for the ER- problem. The results are very similar to those obtained under synthetic load-free space distributions and demonstrate that heuristics developed here perform well under real-world distributions as well. In particular, we see that the proposed max- heuristic performs better than all benchmarks considered, and its performance can further be improved by the max- attack. For the UK National Grid data, our results indicated that the best performance is obtained when ; see also the last row in Table I.

Fig. 10: The performance comparison of different heuristic algorithms when follow the UK National Grid data [15].

Next, we consider the ER--- problem where the total load of the attack set is bounded by . As in Figures 8 and 9, we set according to (10) for several values, and compare the performance of our attack strategies with benchmarks; this time the load-free space distribution is set according to the aforementioned UK National Grid data. The results are depicted in Figure 11. Once again we see that the max- attack with switch leads to the best overall performance among all heuristics considered; it leads to the best performance when (tied with max- with switch), , and , while coming as second for after max-. This shows that the heuristic attacks proposed here have versatile performance also under distributions observed in real-world power systems.

Fig. 11: The performance comparison of different heuristic algorithms when pairs are distributed according to the UK National Grid data [15]. The attack is constrained to lines such that their total load satisfies a) ; b) ; c) ; d) .

Ix Conclusion

In this paper, we consider a flow-redistribution based model to understand cascading failures in load-carrying networks, e.g., electrical power systems, transportation systems, etc. We focus on assessing the vulnerability of such systems against adversarial attacks. In particular, in a system with lines with initial loads and capacities , we study the constrained optimization problem of finding initial lines to be attacked to minimize the final number of alive lines in the system. We give optimal greedy algorithms in several special cases, and prove that a variation of the problem (with a bound on the total load of the initial attack set) is NP-Hard. Several heuristics are developed and their performance is compared with benchmark attacks under various settings. Overall, it is seen that the system is most vulnerable against attacks that target lines with maximum load free-space product .

There are many interesting directions to consider for future work. First, the complexity of the optimal -attack problem (without a bound on the total load) is not known. Also, with the results of this paper revealing good attack strategies, one might now seek optimal design strategies (e.g., in the form of load-capacity distributions) that lead to maximum robustness against such attacks. It would also be interesting to consider new cascading failure models for flow networks that combine local and global redistribution approaches; e.g., a portion of the failed load is redistributed in the local neighborhood according to network topology while the rest is redistributed globally. For this last problem, we provide preliminary simulation results in Supplementary Material. They suggest that the mean-field (i.e., equal) redistribution model captures the qualitative behavior of system robustness well. Finally, it might be interesting to study information cascades in social networks [27, 30, 31, 33] using the models considered here; the optimal attack problem studied here will then amount to influence maximization problem [10].

References

  • [1] J. V. Andersen, D. Sornette, and K.-t. Leung. Tricritical behavior in rupture induced by disorder. Phys. Rev. Lett., 78:2140–2143, Mar 1997.
  • [2] G. Andersson, P. Donalek, R. Farmer, N. Hatziargyriou, I. Kamwa, et al. Causes of the 2003 major grid blackouts in north america and europe, and recommended means to improve system dynamic performance. Power Systems, IEEE Transactions on, 20(4):1922–1928, 2005.
  • [3] S. V. Buldyrev, R. Parshani, G. Paul, H. E. Stanley, and S. Havlin. Catastrophic cascade of failures in interdependent networks. Nature, 464:1025–1028, 2010.
  • [4] E. Chatziafratis, Y. Zhang, and O. Yağan. On the robustness of power systems: optimal load-capacity distributions and hardness of attacking. In Information Theory and Applications Workshop (ITA), 2016.
  • [5] P. Crucitti, V. Latora, and M. Marchiori. Model for cascading failures in complex networks. Phys. Rev. E, 69:045104, Apr 2004.
  • [6] H. Daniels. The statistical theory of the strength of bundles of threads. i. Proceedings of the Royal Society of London. Series A. Mathematical and Physical Sciences, 183(995):405–435, 1945.
  • [7] L. Daqing, J. Yinan, K. Rui, and S. Havlin. Spatial correlation analysis of cascading failures: congestions and blackouts. Sci. Reps., 4, 2014.
  • [8] I. Dobson, B. A. Carreras, V. E. Lynch, and D. E. Newman. Complex systems analysis of series of blackouts: Cascading failure, critical points, and self-organization. Chaos, 17(2):026103, 2007.
  • [9] I. Dobson, J. Chen, J. Thorp, B. A. Carreras, and D. E. Newman. Examining criticality of blackouts in power system models with cascading events. In Proceedings of the 35th Annual Hawaii International Conference on System Sciences, 2002.
  • [10] D. Kempe, J. Kleinberg, and É. Tardos. Maximizing the spread of influence through a social network. In Proc. of ACM SIGKDD Conference, pages 137–146, 2003.
  • [11] R. Kinney, P. Crucitti, R. Albert, and V. Latora. Modeling cascading failures in the north american power grid. The European Physical Journal B, 46(1):101–107, 2005.
  • [12] R. Loulou and E. Michaelides. New greedy-like heuristics for the multidimensional 0-1 knapsack problem. Operations Research, 27(6):1101–1114, 1979.
  • [13] B. Mirzasoleiman, M. Babaei, M. Jalili, and M. Safari. Cascaded failures in weighted networks. Physical Review E, 84(4):046114, 2011.
  • [14] A. E. Motter and Y.-C. Lai. Cascade-based attacks on complex networks. Phys. Rev. E, 66:065102, Dec 2002.
  • [15] NationalGrid. http://www2.nationalgrid.com/uk/industry-information/ future-of-energy/electricity-ten-year-statement/. Technical report, 2016.
  • [16] T. D. O’Rourke. Critical infrastructure, interdependencies, and resilience. BRIDGE-WASHINGTON-NATIONAL ACADEMY OF ENGINEERING-, 37(1):22, 2007.
  • [17] T. J. Overbye, X. Cheng, and Y. Sun. A comparison of the ac and dc power flow models for lmp calculations. In Proceedings, 37th Hawaii International Conference on System Sciences, 2004.
  • [18] O. Ozel, B. Sinopoli, and O. Yağan. Robustness of flow networks against cascading failures under partial load redistribution. arXiv:1802.07664.
  • [19] S. Pahwa, C. Scoglio, and A. Scala. Abruptness of cascade failures in power grids. Scientific reports, 4, 2014.
  • [20] S. Pradhan and B. K. Chakrabarti. Failure properties of fiber bundle models. Int’l. Journal of Modern Physics B, 17(29):5565–5581, 2003.
  • [21] M. Rosas-Casals and R. Solé. Analysis of major failures in european power grid. International Journal of Electrical Power & Energy Systems, 33(3):805–808, 2011.
  • [22] C. Roy, S. Kundu, and S. Manna. Fiber bundle model with highly disordered breaking thresholds. Physical Review E, 91(3):032103, 2015.
  • [23] S. Senju and Y. Toyoda. An approach to linear programming with 0-1 variables. Management Science, pages B196–B207, 1968.
  • [24] B. Stott, J. Jardim, and O. Alsac. Dc power flow revisited. Power Systems, IEEE Transactions on, 24(3):1290–1300, Aug 2009.
  • [25] Y. Toyoda. A simplified algorithm for obtaining approximate solutions to zero-one programming problems. Management Science, 21(12):1417–1427, 1975.
  • [26] W.-X. Wang and G. Chen. Universal robustness characteristic of weighted networks against cascading failure. Phys. Rev. E, 77, 2008.
  • [27] D. J. Watts. A simple model of global cascades on random networks. Proceedings of the National Academy of Sciences, 99:5766–5771, 2002.
  • [28] Y. Yang, T. Nishikawa, and A. Motter. Small vulnerable sets determine large network cascades in power grids. Science, 358(6365), 2017.
  • [29] O. Yağan. Robustness of power systems under a democratic-fiber-bundle-like model. Phys. Rev. E, 91:062811, Jun 2015.
  • [30] O. Yağan and V. Gligor. Analysis of complex contagions in random multiplex networks. Physical Review E, 86(3):036103, 2012.
  • [31] O. Yağan, D. Qian, J. Zhang, and D. Cochran. Information diffusion in overlaying social-physical networks. In Proc. of the 46th Annual Conference on Information Sciences and Systems (CISS), pages 1–6, March 2012.
  • [32] O. Yağan, D. Qian, J. Zhang, and D. Cochran. Optimal allocation of interconnecting links in cyber-physical systems: Interdependence, cascading failures, and robustness. IEEE Transactions on Parallel and Distributed Systems, 23(9):1708–1720, Sept 2012.
  • [33] O. Yağan, D. Qian, J. Zhang, and D. Cochran. Conjoining speeds up information diffusion in overlaying social-physical networks. IEEE Journal on Selected Areas in Communications, 31(6):1038–1048, 2013.
  • [34] G. Zhang, Z. Li, B. Zhang, and W. A. Halang. Understanding the cascading failures in indian power grids with complex networks theory. Physica A, 392(15):3273–3280, 2013.
  • [35] Y. Zhang, A. Arenas, and O. Yağan. Cascading failures in interdependent systems under a flow redistribution model. Phys. Rev. E, 97:022307, Feb 2018.
  • [36] Y. Zhang and O. Yağan. Optimizing the robustness of electrical power systems against cascading failures. Scientific reports, 6:27625, 2016.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
267872
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description