Abstract
A secure set S in a graph is defined as a set of vertices such that for any the majority of vertices in the neighborhood of X belongs to S. It is known that deciding whether a set S is secure in a graph is -complete. However, it is still open how this result contributes to the actual complexity of deciding whether for a given graph G and integer k, a non-empty secure set for G of size at most k exists. In this work, we pinpoint the complexity of this problem by showing that it is -complete. Furthermore, the problem has so far not been subject to a parameterized complexity analysis that considers structural parameters. In the present work, we prove that the problem is -hard when parameterized by treewidth. This is surprising since the problem is known to be FPT when parameterized by solution size and “subset problems” that satisfy this property usually tend to be FPT for bounded treewidth as well. Finally, we give an upper bound by showing membership in , and we provide a positive result in the form of an FPT algorithm for checking whether a given set is secure on graphs of bounded treewidth.
Keywords: Secure set, Complexity analysis, Parameterized complexity, Treewidth, Parameterized algorithms
Introduction
The objective of many problems that can be modeled as graphs is finding a group of vertices that together satisfy some property. In this respect, one of the concepts that has been quite extensively studied [31] is the notion of a defensive alliance [20], which is a set of vertices such that for each element v at least half of its neighbors are also in the alliance. The name “defensive alliance” stems from the intuition that the neighbors of such an element v that are also in the alliance can help out in case v is attacked by its other neighbors. Notions like this can be applied to finding groups of nations, companies or individuals that depend on each other, but also to more abstract situations like finding groups of websites that form communities [18].
In this work, we are looking at a natural generalization of defensive alliances called secure sets, which have been introduced by Brigham et al. [11]. While defensive alliances make sure that each element of an alliance can defend itself against attacks from its neighbors, they do not account for attacks on multiple vertices at the same time. To this end, we can employ a stronger concept: A secure set of a graph G is a subset S of the vertices of G such that for each , the number of vertices in is not less than the number of vertices in . Here N[X] denotes the closed neighborhood of X in G, i.e., X together with all vertices adjacent to X. The Secure Set problem can now be stated as follows: Given a graph G and an integer k, does there exists a secure set S of G such that ?
It is known that deciding whether a given set S is secure in a graph is -complete [21], so it would not be surprising if finding (non-trivial) secure sets is also a very hard problem. Unfortunately, the exact complexity of this problem has so far remained unresolved. This is an unsatisfactory state of affairs because it leaves the possibility open that existing approaches for solving the problem (e.g., [1]) are suboptimal in that they employ unnecessarily powerful programming techniques. Hence we require a precise complexity-theoretic classification of the problem.
Due to its high complexity, it makes sense to look at the parameterized complexity [13, 16, 19, 26] of the problem and to study if Secure Set becomes tractable under the assumption that certain parameters of the problem instances are small. For some parameters, this may be a reasonable assumption in practice. For instance, it has been shown that Secure Set can be solved in linear time if the solution size is bounded by a constant [17]. If we are only interested in small secure sets, the resulting algorithm is therefore a good choice.
However, we often cannot make the assumption that the solutions are small. In such cases, it is a common strategy to consider structural parameters instead, which measure in a certain way how complex the graph underlying a problem instance is. One of the most studied structural parameters is treewidth [5, 7, 27], which indicates how close a graph is to being a tree. Treewidth is an attractive parameter because many hard problems become tractable on instances of bounded treewidth, and in several practical applications it has been observed that the considered problem instances exhibit small treewidth [5, 24, 30]. In [22] it has been shown that a certain variant of Secure Set becomes easy on trees, but the complexity of Secure Set parameterized by treewidth is listed as an open problem in that work and has so far remained unresolved.
The first main contribution of our paper is to show that Secure Set is -complete. Unlike the existing -hardness proof [21], which uses a (quite involved) reduction from Dominating Set, we base our proof on a reduction from a problem in the area of logic. To be specific, we first show that the canonical -complete problem can be reduced to a variant of Secure Set, where vertices can be forced to be in or out of every solution, and pairs of vertices can be specified to indicate that every solution must contain exactly one element of each such pair. In order to prove the desired complexity result, we then successively reduce this variant to the standard Secure Set problem. At the same time, we show -completeness for the exact variants of these problems, where we are interested in secure sets exactly of a certain size.
Membership in the class is rather obvious; in fact, [1] presents a polynomial-time reduction to Answer Set Programming [10] and thus shows this result implicitly. Together with our corresponding hardness result, it follows that Secure Set is -complete, and it turns out that all the problem variants we consider in this paper are -complete.
We thus complete the picture of the precise complexity of the Secure Set problem, and we also provide completeness results for variants of the problem that have already been proposed [22] but for which no complexity analysis has been performed so far. Our results underline that Secure Set is among the few rather natural problems in graph theory that are complete for the second layer of the polynomial hierarchy (like, e.g., Clique Coloring [25] or 2-Coloring Extension [28]). Moreover, -hardness of Secure Set indicates that an efficient reduction to the Sat problem is not possible (unless the polynomial hierarchy collapses).
The second main contribution of our paper is a parameterized complexity analysis of Secure Set with treewidth as the parameter. We show that this problem is hard for the class , which rules out a fixed-parameter tractable algorithm under commonly held complexity-theoretic assumptions. This result is rather surprising for two reasons: First, the problem is tractable on trees [22] and often problems that become easy on trees turn out to be fixed-parameter tractable when parameterized by treewidth.1 Second, this makes Secure Set one of the very few “subset problems” that are fixed-parameter tractable w.r.t. solution size but not w.r.t. treewidth. Problems with this kind of behavior are rather rare, as observed by Dom et al. [15].
Beside this parameterized hardness result, we also give an upper bound by showing that Secure Set is in the class , which means that it can be solved in polynomial time on instances of bounded treewidth. We do so by providing an algorithm where the degree of the polynomial depends on the treewidth.
Finally, we present a positive result for the -complete problem of checking whether a given set of vertices is secure in a graph: We provide an algorithm that solves the problem in linear time for graphs of bounded treewidth.
This paper is organized as follows: We first provide the necessary background in Sect. 2. Then we analyze the complexity of Secure Set in Sect. 3, where we show that this problem, along with several variants, is -complete. In Sect. 4, we consider the parameterized complexity of Secure Set where treewidth is our parameter of interest. Section 5 concludes the paper with a discussion.
The present work extends a conference paper [4], which did not contain any results about the parameterized complexity of the considered problems. Beside the new results in Sect. 4, we also slightly modified some of the reductions that prove -hardness so that they preserve bounded treewidth, which allows us to reuse them for our parameterized hardness proofs. We also added a reduction (which eliminates necessary vertices), which made one of the reductions (from the exact variant of the problem to the non-exact variant) from the previous paper redundant.
Background
All graphs are undirected and simple unless stated otherwise. We denote the set of vertices and edges of a graph G by V(G) and E(G), respectively. We denote an undirected edge between vertices u and v as (u, v) or equivalently (v, u). It will be clear from the context whether an edge (u, v) is directed or undirected. Given a graph G, the open neighborhood of a vertex , denoted by , is the set of all vertices adjacent to v, and is called the closed neighborhood of v. Let . We abuse notation by writing and to denote and , respectively. If it is clear from the context which graph is meant, we write and instead of and , respectively.
Definition 1
Given a graph G, a set is secure in G if for each it holds that .
We often write “S is secure” instead of “S is secure in G” if it is clear from the context which graph is meant. By definition, the empty set is secure in any graph. Thus, in the following decision problems we ask for secure sets of size at least 1. The following is our main problem:
Figure 1 shows a graph together with a minimum non-empty secure set . Observe that for any the condition is satisfied.
Fig. 1.

A graph with a minimum non-empty secure set indicated by circled vertices
Note that the well-known Defensive Alliance problem is a special case of Secure Set where only those subsets X of S are considered that have size 1. For example, in Fig. 1, the set is a defensive alliance as holds for each , but is not a secure set, since for it holds that .
We now define three variants of the Secure Set problem that we require in our proofs. generalizes the Secure Set problem by designating some “forbidden” vertices that may never be in any solution. This variant can be formalized as follows:
is a further generalization that, in addition, allows “necessary” vertices to be specified that must occur in every solution.
Finally, we introduce the generalization . Here we may state pairs of “complementary” vertices where each solution must contain exactly one element of every such pair.
For our results on structural parameters, we need a way to represent the structure of a instance by a graph that augments G with the information in C:
Definition 2
Let I be a instance, let G be the graph in I and let C the set of complementary vertex pairs in I. By the primal graph of I we mean the graph with and .
While the Secure Set problem asks for secure sets of size at most k, we also consider the Exact Secure Set problem that concerns secure sets of size exactly k. Note that a secure set may become insecure by adding or removing elements, so this is a non-trivial problem variant. Analogously, we also define exact versions of the three generalizations of Secure Set presented above.
When the task is not to find secure sets but to verify whether a given set is secure, the following problem is of interest:
This problem is known to be -complete [21].
In this paper’s figures, we often indicate necessary vertices by means of a triangular node shape, and forbidden vertices by means of either a square node shape or a superscript square in the node name. If two vertices are complementary, we often express this in the figures by putting a sign between them. For example, in Fig. 2, the vertices b and c are complementary and occur in no solution together; also the vertices b and e are complementary. Note, however, that by putting a sign between two vertices we do not mean to express that there is an edge between them. For instance, there is no edge between b and c, but there is an edge between b and e, which is explicitly drawn. The vertex a and the “anonymous” vertex adjacent to c are necessary and occur in every solution; and the “anonymous” vertex adjacent to e are forbidden and occur in no solution. In this figure, the unique minimum non-empty secure set satisfying the conditions of forbidden, necessary and complementary vertices consists of a, b and the “anonymous” necessary vertex adjacent to c.
Fig. 2.

Illustration of forbidden, necessary and complementary vertices
The following terminology will be helpful: We often use the terms attackers and defenders of a subset X of a secure set candidate S. By these we mean the sets and , respectively. To show that a subset X of a secure set candidate S is not a witness to S being insecure, we sometimes employ the notion of a defense of X w.r.t. S, which assigns to each attacker a dedicated defender: If we are able to find an injective mapping , then obviously , and we call a defense of X w.r.t. S. Given such a defense , we say that a defender d repels an attack on X by an attacker a whenever . Consequentially, when we say that a set of defenders D can repel attacks on X from a set of attackers A, we mean that there is a defense that assigns to each element of A a dedicated defender in D.
To warm up, we make some easy observations that we will use in our proofs. First, for every set R consisting of a majority of neighbors of a vertex v, whenever v is in a secure set, also some element of R must be in it:
Observation 1
Let S be a secure set in a graph, let and let . If , then S contains an element of R.
Proof
Suppose that and S contains no element of R. Since all elements of R attack v, . Hence , and we obtain the contradiction .
Next, if one half of the neighbors of an element v of a secure set attacks v, then the other half of the neighbors must be in the secure set:
Observation 2
Let S be a secure set in a graph, let and let N(v) be partitioned into two equal-sized sets A, D. If , then .
Proof
Since N(v) is partitioned into A and D such that , we get . If some element of D is not in S, then and . By , we get . From we now obtain the contradiction .
In particular, if half of the neighbors of v are forbidden, then v can only be in a given secure set if all non-forbidden neighbors are also in the secure set.
Finally, we recapitulate some background from complexity theory. The class is the class of problems that are solvable in polynomial time by a nondeterministic Turing machine that has access to an oracle. The canonical problem complete for this class is , which asks, given a formula , where is a propositional 3-DNF formula, whether there is a truth assignment to the variables such that for all truth assignments to the variables evaluates to true.
In parameterized complexity theory [13, 16, 19, 26], we study problems that consist not only of an input and a question, but also of some parameter of the input that is represented as an integer. A problem is in the class (“fixed-parameter tractable”) if it can be solved in time , where n is the input size, k is the parameter, f is a computable function that only depends on k, and c is a constant that does not depend on k or n. We call such an algorithm an FPT algorithm, and we call it fixed-parameter linear if . Similarly, a problem is in the class (“slice-wise polynomial”) if it can be solved in time , where f and g are computable functions. Note that here the degree of the polynomial may depend on k, so such algorithms are generally slower than FPT algorithms. For the class it holds that , and it is commonly believed that the inclusions are proper, i.e., -hard problems do not admit FPT algorithms. -hardness of a problem can be shown using parameterized reductions, which are reductions that run in FPT time and produce an equivalent instance whose parameter is bounded by a function of the original parameter.
For problems whose input can be represented as a graph, one important parameter is treewidth, which is a structural parameter that, roughly speaking, measures the “tree-likeness” of a graph. It is defined by means of tree decompositions, originally introduced in [27]. The intuition behind tree decompositions is to obtain a tree from a (potentially cyclic) graph by subsuming multiple vertices under one node and thereby isolating the parts responsible for cyclicity.
Definition 3
A tree decomposition of a graph G is a pair where T is a (rooted) tree and assigns to each node of T a set of vertices of G (called the node’s bag), such that the following conditions are met:
For every vertex , there is a node such that .
For every edge , there is a node such that .
For every , the subtree of T induced by is connected.
We call the width of . The treewidth of a graph is the minimum width over all its tree decompositions.
In general, constructing an optimal tree decomposition (i.e., a tree decomposition with minimum width) is intractable [2]. However, the problem is solvable in linear time on graphs of bounded treewidth (specifically in time , where w is the treewidth) [6] and there are also heuristics that offer good performance in practice [8, 14].
In this paper we will consider so-called nice tree decompositions:
Definition 4
A tree decomposition is nice if each node is of one of the following types:
Leaf node: The node t has no child nodes.
Introduce node: The node t has exactly one child node such that consists of exactly one element.
Forget node: The node t has exactly one child node such that consists of exactly one element.
Join node: The node t has exactly two child nodes and with .
Additionally, the bags of the root and the leaves of T are empty.
A tree decomposition of width w for a graph with n vertices can be transformed into a nice one of width w with nodes in fixed-parameter linear time [23].
For any tree decomposition and an element v of some bag in , we use the notation to denote the unique “topmost node” whose bag contains v (i.e., does not have a parent whose bag contains v). Figure 3 depicts a graph and a nice tree decomposition, where we also illustrate the notation.
Fig. 3.
A graph G and a nice tree decomposition of G rooted at the leftmost node
When we speak of the treewidth of an instance of Secure Set, , , Exact Secure Set, or , we mean the treewidth of the graph in the instance. For an instance of or , we mean the treewidth of the primal graph.
Complexity of the Secure Set Problem
This section is devoted to proving the following theorem:
Theorem 1
The following problems are all -complete: Secure Set, Exact Secure Set, , , , , and .
We prove this by providing a chain of polynomial reductions from to the problems under consideration.
Hardness of Secure Set with Forbidden, Necessary and Complementary Vertices
Lemma 1
and are -hard.
Proof
We reduce from to . This also proves -hardness for the exact variant because our reduction makes sure that all solutions of the instance have the same size. We are given a quantified Boolean formula , where is in 3-DNF and contains terms. We assume that no term contains both a variable and its complement (since such a term can never be satisfied) and that each term contains at least one universally quantified variable (since is trivially true otherwise).
We construct an instance of in the following. For an illustration, see Fig. 4. We define a graph G by choosing the union of the following sets as V(G):
Next we define the set of edges. In the following, whenever we sloppily speak of a literal in the context of the graph G, we mean the vertex corresponding to that literal (i.e., some , , or ), and we proceed similarly for terms. Furthermore, when we are dealing with a (vertex corresponding to a) literal l, then shall denote the (vertex corresponding to the) complement of l. For any term , let and denote the set of existentially and universally quantified literals, respectively, in .
Finally, we define
and .
Fig. 4.
Graph corresponding to the formula . To avoid clutter, we omit labels for the vertices from , , , , and , and we draw some edges in a dashed style
The following observations are crucial: Elements of are only adjacent to vertices from (which are forbidden) and . For any i, each element of is adjacent to iff it is adjacent to . Furthermore, for any i, j, if or is adjacent to , then setting the variable to or , respectively, falsifies the term . Finally, for any i, j, if or is adjacent to , then setting the variable to or , respectively, falsifies the term .
The intuition is that the complementary pairs guess a truth assignment to the existentially quantified variables. We now need to check if such a truth assignment has the property that the formula is true for all extensions of this assignment to the universally quantified variables. Trying out all these extensions amounts to going through all subsets of a solution candidate and comparing the numbers of attackers and defenders.
To illustrate, let S be a solution candidate (i.e., a set of vertices) and suppose S satisfies the conditions on forbidden, necessary and complementary vertices. We denote the truth assignment to encoded in S by . Moreover, let R be a subset of S containing either or for each universally quantified variable . We denote the extension of to encoded in R by . For any term that is falsified already by , the vertex attacks all vertices and . At the same time, for any term that is not falsified by , the vertex attacks or if setting the variable to or , respectively, falsifies . Hence, the number of attacks from vertices of the form or on R is exactly the number of terms that are falsified by . With the help of the vertices in , we can afford up to falsified terms, but if we falsify all terms, then R is a witness that S is not secure.
The instance can be constructed in time polynomial in the size of . We claim that is true iff is a positive instance of .
“Only if” direction If is true, then there is an assignment I to such that, for all assignments extending I to , some term in is satisfied. We define a set
We observe that , , , and that for any it holds that iff . By construction, whenever some element of is in S, then all its neighbors in are in S; and whenever some is in S, then some neighbor of in is in S.
We claim that S is a secure set in G. Let R be an arbitrary subset of S. We show that R has at least as many defenders as attackers by constructing a defense, which assigns to each attacker of R a dedicated defender in . We distinguish cases regarding the origins of the attacks on R.
We repel each attacker using . Since attacks R, R must contain some element of that is adjacent to and thus also to , so .
Each attacker from is adjacent to some . We repel that attacker using , which is adjacent to . Note that it cannot be the case that is attacked by more than one vertex in because has exactly two neighbors from that set and would not be in S if neither of these neighbors was in S.
If attacks R, then it attacks at least one element of , which is adjacent to some element of that is also in S. We repel using any such element of .
Any attack from some on R must be on . Since , is not consumed for repelling an attack on , so we repel with .
If some attacks R (by attacking ), we repel with .
Analogously, we repel each attacker with .
If, for some i with , the vertices for attack R, then we distinguish the following cases: If is in R, then the adjacent vertices for are in the neighborhood of R, too. We then repel each with for , and we repel with . Otherwise, is in R, and we proceed symmetrically using and as dedicated defenders.
- In order to account for attacks from on R, we distinguish two cases.
- If, for some i with , both and are in R, then, in the step before, we have repelled each with the respective or , but all are still free. These vertices can repel all attacks from , as there are at most such attacks.
- Otherwise we show that there are at most attacks from , and they can be repelled using . Consider the (partial) assignment J that assigns the same values to the variables as the assignment I above, and, for any variable , sets to or if R contains the vertex or , respectively. By assumption we know that our assignment to is such that for all assignments to some term in is true. In particular, it must therefore hold that J falsifies no existentially quantified literal in . Then, by construction of S, the vertex is not in S. We also know that J falsifies no universally quantified literal in . But then the vertices from adjacent to the vertex are not in R due to our construction of J, so does not attack any vertex in R. From this it follows that there are at most attacks from on R. We can repel all these attacks using the vertices .
This allows us to conclude . Therefore S is secure.
“If” direction Suppose S is a secure set in G satisfying the conditions regarding forbidden, necessary and complementary vertices. First observe that because the complementary vertex pairs make sure that S contains exactly half of .
If S contains some , then by Observation 2. If S contains some , then must be adjacent to some element of that is also in S by Observation 1.
We construct an interpretation I on the variables that sets exactly those to true where the corresponding vertex is in S, and we claim that for each extension of I to the universally quantified variables there is a satisfied term in . To see this, suppose to the contrary that some assignment J to all variables extends I but falsifies all terms in . Then we define a set R consisting of all vertices such that , all vertices such that , and all vertices in that are adjacent to these vertices or . We show that this contradicts S being secure: Clearly, R is a subset of S and has defenders due to itself, defenders due to , and defenders due to . This amounts to . On the other hand, there are attacks on R from . This is because for any term in one of the following cases applies:
The term is falsified already by I. Then and thus . The vertex , however, is adjacent to every element of , so it attacks R.
The term is not falsified by I but by J. Then , and contains some literal l with and , so is in R and attacked by .
In addition to these attackers, R has attackers in , as well as attackers in . As , we obtain in total
This contradicts S being secure, so for each extension of I to the universally quantified vertices, is true; hence is true.
Hardness of Secure Set with Forbidden and Necessary Vertices
Next we present a transformation that eliminates complementary vertex pairs by turning a instance into an equivalent instance. Along with , we define a function , for each instance I, such that the solutions of I are in a one-to-one correspondence with those of in such a way that any two solutions of I have the same size iff the corresponding solutions of have the same size. We use these functions to obtain a polynomial-time reduction from to as well as from to .
Before we formally define our reduction, we briefly describe the underlying intuition. The gadget in Fig. 5 is added for every complementary pair (a, b). It is constructed in such a way that every solution must either contain all of or none of them, and the same holds for . By making the vertex necessary, every solution must contain one of these two sets. At the same time, the bound on the solution size makes sure that we cannot afford to take both sets for any complementary pair.
Fig. 5.
Gadget for a pair of complementary vertices (a, b) in the reduction from to . The vertices a and b may have additional neighbors from the original graph
Definition 5
We define a function , which assigns a instance to each instance . For this, we use n to denote and first define a function . For each , we introduce new vertices , and as well as, for any , sets of new vertices , , and . We use the notation to denote the set of edges . Now we define the instance , where , , and is the graph defined by
We illustrate our construction in Fig. 5.
Lemma 2
Let be a instance, let A be the set of solutions of I and let B be the set of solutions of . There is a bijection such that holds for every .
Proof
We use the same auxiliary notation as in Definition 5 and we define g as . For every , we thus obtain , and we first show that indeed .
Let and let denote g(S). Obviously satisfies and . To see that is secure in , let be an arbitrary subset of . Since S is secure in G and , there is a defense . We now construct a defense . For any attacker v of in , we distinguish three cases.
If v is some for some and , we set . This element is in since v is only adjacent to or neighbors of it.
If v is or for some , its only neighbor in can be and we set .
Otherwise v is in (by our construction of ). Since the codomain of is a subset of the codomain of , we may set .
Since is injective, each attack on in can be repelled by . Hence is secure in .
Clearly g is injective. It remains to show that g is surjective. Let be a solution of . First we make the following observations for each and each :
If some is in , then by Observation 2.
If some is in , then for the same reason.
If , then . To see this, suppose . Let consist of those pairs such that and , and let consist of those pairs such that and . Now let . By the previous observations, . The defenders of are the element x, the elements of and perhaps some elements of , which consists of at most vertices. The attackers of are the elements of , the elements of and perhaps some elements of . Thus, if is nonempty, then the set has more attackers than defenders in . However, is secure, so must be empty, which implies .
If , then by Observation 1.
So for each and , contains either all or none of .
For every , contains or , since , whose neighbors are and . It follows that even if contains only one of each . If, for some , contained both a and b, we could derive a contradiction to because then . So contains either a or b for any .
We construct and observe that , , , and for each . It remains to show that S is secure in G. Let X be an arbitrary subset of S. We construct and observe that each we put into entails additional defenders and additional attackers of in compared to X in G; so . Clearly is a subset of , so as is secure in . We conclude . Hence S is secure in G.
As is clearly computable in polynomial time, the following result follows:
Corollary 1
is -hard.
The instances of are identical to the instances of the exact variant, so is also applicable to the exact case. In fact it turns out that this gives us also a reduction from to .
Corollary 2
is -hard.
Proof
Let I and be our and instances, respectively, and let k and denote their respective solution sizes. By Lemma 2, there is a bijection g between the solutions of I and the solutions of such that, for every solution S of I, g(S) has elements, and for every solution of , has k elements since is invertible.
Hardness of Secure Set with Forbidden Vertices
Now we present a transformation that eliminates necessary vertices. Our transformation not only operates on a problem instance, but also requires an ordering of the necessary vertices. For now, we can consider this as an arbitrary ordering. It will become more important in Sect. 4.1, where we reuse this transformation for showing -hardness w.r.t. treewidth.
Before formally defining the transformation , we refer to Fig. 6, which shows the result for a simple example graph with only two vertices a and b, of which b is necessary. The basic idea is that the vertex w must be in every solution S because any vertex that is in S also eventually forces w to be in S. Once , the construction to the right of w makes sure that .
Fig. 6.
Result of the transformation applied to an example graph with two adjacent vertices a and b, where b is necessary. Every solution in the depicted graph contains b, w and
Definition 6
We define a function , which assigns a instance to each pair , where is a instance and is an ordering of the elements of . For this, let denote . We use n to denote , and we first define a function . We use W to denote the set of new vertices . The intention is for each and to be forbidden, for w and each to be in every secure set, and for to be in a secure set iff v is in it at the same time. We write to denote ; for each , we use to denote the set of new vertices , and we use shorthand notation and . The intention is for each to be forbidden and for each to be in a secure set iff v is in it at the same time. We use the notation to denote the set of edges . If , let ; otherwise let P be the set consisting of all pairs (u, v) such that v is the direct successor of u according to , as well as the pair (u, w), where u is the greatest element according to . Now we define , where , , and is the graph defined by
We illustrate our construction in Figs. 7 and 8.
Fig. 7.
Illustration of the gadget that makes sure w and are in every secure set. The vertex a is a non-necessary, non-forbidden vertex from the instance and may have other neighbors from this instance. The vertex w has two neighbors (as depicted here) for each non-necessary, non-forbidden vertex from the instance, and additionally the neighbors depicted in Fig. 8
Fig. 8.
Illustration of the gadget that makes sure every secure set contains all necessary vertices as it must contain w. Here we assume there are the two necessary vertices x and y, and we use the ordering
We now prove that yields a correct reduction for any ordering .
Lemma 3
Let be a instance, let be an ordering of , let A be the set of solutions of I and let B be the set of solutions of . There is a bijection such that holds for every .
Proof
We use the same auxiliary notation as in Definition 6 and we define g as . For every , we thus obtain , and we first show that indeed .
Let and let denote g(S). Obviously satisfies . To see that is secure in , let be an arbitrary subset of . Since S is secure in G and , there is a defense . We now construct a defense . For any attacker a of in , we distinguish the following cases:
If a is some for some , then a can only attack either or a neighbor of , all of which are in , and we set .
Similarly, if a is for some , then we set .
If a is for some , then a attacks and we set .
If a is for some , then it attacks w or , which is not used for repelling any attack because cannot attack , so we set .
Otherwise a is in (by our construction of ). Since the codomain of is a subset of the codomain of , we may set .
Since is injective, each attack on in can be repelled by . Hence is secure in .
Clearly g is injective. It remains to show that g is surjective. Let be a solution of . We first show that :
If contains some , then contains an element of by Observation 1.
If contains an element of for some , then by Observation 2.
If for some , then for the same reason.
Furthermore, if contains an element of for some , then also for every for the same reason.
If for some , then by Observation 2.
If for some , then because at least or w must be in and the former implies as we have seen.
The previous observations show that any vertex being in implies . Since is nonempty, it follows that . We now show that contains an element of . Suppose the contrary, let , let and consider . The defenders of consist of exactly elements, whereas there are exactly attackers. With and in mind, we arrive at the contradiction .
The previous observations show that for every it holds that . Finally, we show that . Suppose, for the sake of contradiction, that there is some such that . We have seen that the latter can only be the case if . Observe that is a subset of that is attacked by , but the defenders are a proper subset of . This contradicts being secure in .
Let . By the previous observations, it is easy to see that . It remains to show that S is secure in G. Let X be an arbitrary subset of S. We construct and observe that the number of additional defenders of in compared to X in G is equal to the number of additional attackers; formally . Clearly , so as is secure in . Consequently . Hence S is secure in G.
Given an ordering , clearly is computable in polynomial time. We can thus easily obtain a reduction from to by first computing an arbitrary ordering of the necessary vertices in polynomial time. This also gives us a hardness result for the exact case, analogous to Corollary 2.
Corollary 3
and are -hard.
Hardness of Secure Set
We now introduce a transformation that eliminates forbidden vertices. The basic idea is that we ensure that a forbidden vertex f is never part of a solution by adding so many neighbors to f that we could only defend f by exceeding the bound on the solution size.
Definition 7
We define a function , which assigns a Secure Set instance to each instance . For each , we introduce new vertices . Now we define , where is the graph defined by
Lemma 4
Every instance I has the same solutions as the Secure Set instance .
Proof
Let and . Each secure set S in G is also secure in because the subgraph of G induced by is equal to the subgraph of induced by . Now let be a solution of . For every , neither f nor are in because each of these vertices has at least 2k neighbors, and cannot contain any because . Hence is also secure in G as the subgraphs induced by the respective neighborhoods are again equal.
This immediately yields the following result.
Corollary 4
Secure Set and Exact Secure Set are -hard.
Complexity of Secure Set Parameterized by Treewidth
In this section we study the parameterized complexity of the Secure Set problem when treewidth is the parameter.
We first show that all variants of Secure Set considered in this paper are -hard for this parameter by reusing some reductions from Sect. 3 and proving that they preserve bounded treewidth. Under the widely held assumption that , this rules out fixed-parameter tractable algorithms for these problems.
Second, we show that the -complete Secure Set Verification problem is solvable in linear time on instances whose treewidth is bounded by a constant. We do this by providing a fixed-parameter linear algorithm that performs dynamic programming on a tree decomposition of the input graph. Although bounded treewidth most likely does not lead to fixed-parameter tractability of the problem of finding secure sets, this proves that it does for the problem of verifying whether a given set is secure.
Third, we show that all the variants of the Secure Set problem considered in this paper are solvable in polynomial time on instances whose treewidth is bounded by a constant. We again do this by providing a polynomial-time dynamic programming algorithm, but this time the degree of the polynomial depends on the treewidth.
Hardness of Secure Set Parameterized by Treewidth
In this subsection, we prove the following theorem:
Theorem 2
The following problems are all -hard when parameterized by treewidth: Secure Set, Exact Secure Set, , , , , , and .
To prove this, we reduce from the following problem [3], which is known to be -hard [29] parameterized by the treewidth of the graph:
Lemma 5
and , both parameterized by the treewidth of the primal graph, are -hard.
Proof
Let an instance of Minimum Maximum Outdegree be given by a graph G, an edge weighting in unary and a positive integer r. From this we construct an instance of both and . An example is given in Fig. 9. For each , we define the set of new vertices , and for each , we define the sets of new vertices and . We now define the graph with
We also define the set of complementary vertex pairs . Finally, we define the set of necessary vertices and . We use I to denote , which is an instance of and also of . Obviously I is a positive instance of iff it is a positive instance of because the necessary and complementary vertices make sure that every solution of the instance I has exactly k elements. Hence we only consider .
Fig. 9.
Result of our transformation on a sample Minimum Maximum Outdegree instance with and two vertices a, b that are connected by an edge of weight 3. Complementary vertex pairs are shown via dashed lines. Necessary vertices have a symbol next to their name
The intention is that for each orientation of G we have a solution candidate S in I such that an edge orientation from u to v entails and , and the other orientation entails and . For each outgoing edge of v in the orientation of G, there are as many attackers of v in I as the weight of that edge. Together with , v can repel up to r such attacks. The other neighbors of v that are in S cannot help v since they are in turn attacked by their neighbors.
Clearly I can be computed in polynomial time. We now show that the treewidth of the primal graph of I depends only on the treewidth of G. We do so by modifying an optimal tree decomposition of G as follows:
For each , we take an arbitrary node whose bag B contains both u and v and add to its children a chain of nodes such that the bag of is .
For each , we take an arbitrary node whose bag B contains v and add to its children a chain of nodes such that the bag of is .
It is easy to verify that the result is a valid tree decomposition of the primal graph of I and its width is at most the treewidth of G plus four.
We claim that (G, w, r) is a positive instance of Minimum Maximum Outdegree iff I is a positive instance of .
“Only if” direction Let D be the directed graph given by an orientation of the edges of G such that for each vertex the sum of weights of outgoing edges is at most r. The set is secure in G: Let X be an arbitrary subset of S. Every attacker must be some element . If , then we can use to repel the attack from . Otherwise , so we can use either u or one of the elements of to repel the attack from . These are sufficiently many defenders: For every vertex , at most r neighbors attack v as otherwise the sum of weights of outgoing edges of v in D would be greater than r. Finally, it is easy to verify that , , and exactly one element of each pair of complementary vertices is in S.
“If” direction Let S be a solution of I. For every , either or due to the complementary vertex pairs. We define a directed graph D by and . Suppose there is a vertex v in D whose sum of weights of outgoing edges is greater than r. We construct , which is a subset of S. Now v has more than r attacking neighbors, but all defenders except v and must already defend themselves against their attacking neighbor. This contradicts S being secure.
Now we reduce from to to show -hardness of the latter problem. We reuse the function from Definition 5 and show that this gives us a reduction that preserves bounded treewidth.
Lemma 6
, parameterized by the treewidth of the graph, is -hard.
Proof
Let I be a instance whose primal graph we denote by G. We obtain an equivalent instance , whose graph we denote by . This reduction is correct, as shown in Lemma 2. It remains to show that the treewidth of is bounded by a function of the treewidth of G. Let be an optimal nice tree decomposition of G. We build a tree decomposition of by modifying a copy of in the following way: For every pair (a, b) of complementary vertices, we pick an arbitrary node t in whose bag B contains both a and b, and we add a chain of nodes between t and its parent such that, for , the bag of is , the bag of is , and the bag of is . It is easy to verify that is a valid tree decomposition of . Furthermore, the width of is at most the width of plus 15.
Just like before, we get an analogous result for the exact variant. It can be proved in the same way as Corollary 2.
Corollary 5
, parameterized by the treewidth of the graph, is -hard.
We next show -hardness of by reducing from using the function from Definition 6. This function maps a instance, together with an ordering of the necessary vertices, to an equivalent instance. We show that by choosing appropriately, this gives us a reduction that preserves bounded treewidth.
Lemma 7
, parameterized by the treewidth of the graph, is -hard.
Proof
Let be a instance and let be an optimal nice tree decomposition of G. We can compute such a tree decomposition in FPT time [6]. Let be the ordering of the elements of that is obtained in linear time by doing a post-order traversal of and sequentially recording the elements that occur for the last time in the current bag. We obtain the instance , whose graph we denote by . This reduction is correct, as shown in Lemma 3, and computable in FPT time. It remains to show that the treewidth of is bounded by a function of the treewidth of G. To this end, we use to build a tree decomposition of . We initially set and modify it by the following steps:
We insert w into every bag.
For every , we add v, and into the bag of every node between (and including) and . Note that the bag of contains both u and v. After this step, we have increased the bag size of each node by at most five.
For each , we use to denote the bag of and replace by a chain of nodes , where is the topmost node and the bag of is . After this step, note that, for each , the bag of the new node contains , , and .
For each , we add , , and to the bag of , which already contains w, , .
It is easy to verify that is a valid tree decomposition of . Furthermore, the width of is at most the width of plus twelve.
We again get an analogous result for the exact variant.
Corollary 6
, parameterized by the treewidth of the graph, is -hard.
Finally, we show -hardness of Secure Set by reducing from while preserving bounded treewidth.
Lemma 8
Secure Set, parameterized by the treewidth of the graph, is -hard.
Proof
Let be a instance, let denote the graph of and let be an optimal nice tree decomposition of G. We build a tree decomposition of by modifying a copy of in the following way: For every , we pick an arbitrary node t in whose bag B contains f, and we add a chain of nodes between t and its parent such that, for , the bag of is . It is easy to verify that is a valid tree decomposition of . Furthermore, the width of is at most the width of plus two.
We again get an analogous result for the exact variant.
Corollary 7
Exact Secure Set, parameterized by the treewidth of the input graph, is -hard.
A Fixed-Parameter Tractable Algorithm for Secure Set Verification
While we have seen in Sect. 4.1 that Secure Set parameterized by treewidth is most likely not FPT, we now present a positive result: The -complete [21] Secure Set Verification problem, which consists of checking whether a given set is secure in a graph G, is FPT parameterized by the treewidth of G. We show this by giving a fixed-parameter linear algorithm that follows the principle of dynamic programming on a tree decomposition of G. The core idea is the following: For each node t of and each , we store an integer , which indicates that X can be extended to a set using “forgotten” vertices from further down in in such a way that the difference between defenders and attackers of is and is the “worst” subset of that can be obtained in this way. To compute these values, we traverse from the bottom up and use recurrence relations to compute the values for the current node t of based on the values we have computed for the children of t. If we then look at the values we have computed at the root of , we can decide if there is a subset of that is “bad enough” to witness that is not secure.
Dynamic programming algorithms like this are quite common for showing membership w.r.t. treewidth and some examples can be found in [13, 26]. Proving their correctness is a usually rather tedious structural induction argument along the tree decomposition: At every node t of , we have to prove that the recurrence relations indeed characterize the value they are supposed to represent. Examples of such proofs can be found in [13].
We now formally define the values that we will compute at each tree decomposition node. Let G be a graph with a nice tree decomposition and let be the candidate for which we want to check if it is secure. For each node t of and each set of vertices A, we define . For any , we call the score of w.r.t. at t (or just the score of if and t are clear from the context) and denote it by . Furthermore, we call the local score of w.r.t. at t and denote it by . Finally, for each , we define the value
When r is the root of , both and hold, so is secure if and only if is nonnegative.
We now describe how to compute all such values in a bottom-up manner by distinguishing the node type of t, and we prove the correctness of our computation by structural induction along the way. In this correctness proof, we use additional terminology: We say that a set is an extension of X w.r.t. at t if it is one of those sets considered in the definition of that has minimum score; formally , and . We may omit or t if they are clear from the context.
Leaf node. If t is a leaf node, then its bag is empty and obviously holds.
-
Introduce node. Let t be an introduce node with child , let v be the unique element of , let and let . We prove that the following equation holds:
First consider the case where . Let be an extension of X at t, so . From and we infer . Moreover, the set is one of the candidates considered for an extension of in the definition of , so we obtain . In total, this gives us . Conversely, let be an extension of at , so . We distinguish two cases.- If , then from and we infer . Since and , it holds that . Hence the set is one of the candidates considered for an extension of X in the definition of and we obtain .
- Otherwise . In this case , and . Hence the set is considered in the definition of and we get . Since v is adjacent to an element of X, we infer .
Next consider the case where . Clearly . Let be an extension of X at t, so . From and we now infer . Similar to before, by definition of we obtain . In total, this gives us . Conversely, let be an extension of at , so . Since and , is considered in the definition of and we get . Since v is adjacent to an element of X, we infer . We obtain , so indeed .
Finally consider the remaining case where and, in particular, holds as well as . Using elementary set theory with and in mind, we can prove that is equal to . Hence a set is considered in the definition of iff it is considered in the definition of . For every such that , observe that , since v is not adjacent to any element of X and if it were adjacent to some element of , then would not be a valid tree decomposition. This proves that every such has the same score at t and . Hence .
-
Forget node. Let t be a forget node with child , let v be the unique element of and let . We prove that the following equation holds:
Clearly and all scores at forget nodes are identical to those in the respective child node. The case where is trivial as then , i.e., the domains of and are equal, and the sets considered in the definitions of and are the same. Hence we consider the case where .Let be an extension of X at t, so . If , then , so we obtain by definition of . On the other hand, if , then , so we obtain . As one of these two inequalities applies, we get .
Conversely, every extension of X at is considered in the definition of , so . Moreover, every extension of at is also considered in the definition of , so . If we combine these two inequalities, we get . Hence .
-
Join node. Let t be a join node with children such that , and let . We prove that the following equation holds:
Let be an extension of X at t, so . The set satisfies , so . Symmetrically, for it holds that .There is no element of that is adjacent to an element of , otherwise would not be a valid tree decomposition. Hence , and symmetrically . This entails and .
Since is the union of and , and these latter two sets have as their intersection, we can apply the inclusion-exclusion principle to obtain . In a similar way, we get . We can establish by putting these equations together. The inequalities we have derived before now allow us to conclude .
Now let and be extensions of X at and at , respectively. We have that and . The set is clearly considered in the definition of , so . Following the same reasoning as before, we obtain . This gives us . Hence .
Using these recurrence relations, we can traverse the tree decomposition in a bottom-up way and compute at each node t of the value for each . Hence for each node of we compute at most values, where w is the width of . By choosing the right data structure for adjacency tests [13, Exercise 7.16], each value can be computed in time . Since has many nodes and can be computed in fixed-parameter linear time [6], (in fact in time as observed by [9]), we thus get an algorithm with fixed-parameter linear running time for checking whether a given set is secure.
Theorem 3
Given a graph G, a tree decomposition of G of weight w and a set , we can decide in time whether is secure in G.
Our algorithm can easily be adjusted to find a witness if is not secure, i.e., to print a subset of that has more attackers than defenders. After has been computed for each t, this can be done via a final top-down traversal by a standard technique in dynamic programming on tree decompositions [26]: Alongside each value , we store the “origin” of this value and recursively combine the origins of , where r is the root of .
In our definition of the Secure Set Verification problem, we were only concerned with checking whether a set is secure, but we did not mention the additional constructs that we consider in this paper, like complementary vertex pairs or necessary or forbidden vertices. However, these additions pose no difficulty at all because we can just check the respective conditions in linear time.
A Polynomial Algorithm for Secure Set on Bounded Treewidth
We now present an algorithm for finding secure sets, not just verifying whether a given set is secure. Our algorithm works by dynamic programming on a tree decomposition of the input and extends the algorithm from Sect. 4.2. For graphs of bounded treewidth, the algorithm presented in this section runs in polynomial time. However, in contrast to the algorithm in Sect. 4.2, it is not an FPT algorithm since the degree of the polynomial depends on the treewidth. This is to be expected since the problem of finding secure sets of a certain size is -hard when parameterized by treewidth, as we have shown in Lemma 8. Our algorithm provides an upper bound for the complexity of this problem, namely membership in the class .
Let G be a graph with a nice tree decomposition , and let t be a node of . In Sect. 4.2, we were given one particular secure set candidate that we wanted to check, so we only computed one value for each , namely the lowest score of any whose intersection with is X. Here, in contrast, we cannot restrict ourselves to only one secure set candidate, and multiple candidates may have the same intersection with . We therefore compute multiple objects for each subset of , since two subsets of that have the same intersection with may have to be distinguished due to their subsets having different scores.
Let . By we denote the set of functions from to an integer. Let and let k be an integer. We say that a set is (S, t, c, k)-characterized if , and, for each , it holds that , where is the function defined in Sect. 4.2. For each , we now define the set
When r is the root of , there is a secure set of size k in G if and only if there is an element such that . To see this, first suppose there is a secure set of size k in G. Then there is a function such that is -characterized, so and , which means that is the lowest score of any subset of . Since is secure in G, this number is nonnegative. For the other direction, let such that . Then there is a -characterized set , obviously of size k. Since , the lowest score of any subset of is nonnegative, which proves that is secure in G.
We now describe how to compute all such values in a bottom-up manner.
Leaf node. If t is a leaf node, its bag is empty and obviously holds, where c maps to 0.
-
Introduce node. Let t be an introduce node with child and let v be the unique element of . For each and each function , we define a function . Its intended purpose is to obtain a version of c that applies to t instead of . If , we need to increase scores where v can serve as an additional defender, and otherwise we need to decrease scores where v can serve as an additional attacker. We now make this formal. Let , , and .
For each and each function there is a unique function such that , and we denote by .The following statements can be proved by arguments similar to those in Sect. 4.2: Let , and such that is -characterized. The set is -characterized and is -characterized. Hence and . Conversely, let , and such that is (S, t, c, k)-characterized, and let and . The set is -characterized. Hence .
From these observations, the following equation follows for every : -
Forget node. Let t be a forget node with child and let v be the unique element of . For each and each function , we define a function , and for each and each function , we define a function . Each of these functions maps every subset of S to an integer.
Next we define functions and that map each element of to a set of elements of and , respectively:
The following statements can be proved by arguments similar to those in Sect. 4.2: Let , and such that is -characterized. If , then is -characterized and ; otherwise is -characterized and . Conversely, let , and such that is (S, t, c, k)-characterized. If , then there is some such that is -characterized and ; otherwise there is some such that is -characterized and .From these observations, the following equation follows for every : -
Join node. Let t be a join node with children such that . For each , and each , we define a function , which maps each subset of S to an integer.
Next we define a function that maps each element of to a subset of :
The following statements can be proved by arguments similar to those in Sect. 4.2: Let , , , and such that is -characterized and is -characterized, and let and . The set is (S, t, c, k)-characterized and . Conversely, let , and such that is (S, t, c, k)-characterized. There is some as well as integers such that , the set is -characterized and is -characterized. Hence and .From these observations, the following equation follows for every :
We can now traverse the tree decomposition in a bottom-up way and at each node t of compute the set for each . Let n denote the number of vertices of G and w denote the width of . Every element of is a pair (c, k), where c is a function that maps each subset of S to an integer between and n, there are at most subsets of S, and k is an integer between 0 and n. Hence there are at most elements of . Each individual element of can be computed in time . Finally, there are at most possible values for S and many nodes in . We thus get an algorithm that takes as input an integer k together with a graph G whose treewidth we denote by w, and determines in time whether G admits a secure set of size k, where f and g are functions that only depend on w.
This algorithm for Exact Secure Set obviously also gives us an algorithm for Secure Set by checking all solution sizes from 1 to k. Finally, we can easily extend it to accommodate complementary vertex pairs as well as necessary and forbidden vertices. Hence we get the following membership result:
Theorem 4
Secure Set, Exact Secure Set, , , , , and can be solved in polynomial time if the treewidth of the input is bounded by a constant.
By keeping track of the origins of our computed values during our bottom-up traversal of the tree decomposition, we can easily adapt the algorithm to find solutions if they exist.
Conclusion
In this work, we have solved a complexity problem in graph theory that, to the best of our knowledge, has remained open since the introduction of secure sets [11] in 2007. We have shown that the problem of deciding whether, for a given graph G and integer k, G possesses a non-empty secure set of size at most k is -complete. We moreover obtained -completeness for seven further variants of this problem.
In the second part of this paper, we analyzed the complexity of the Secure Set problem parameterized by the treewidth of the input graph. In particular, we showed that bounded treewidth does not make the problem fixed-parameter tractable unless . Nevertheless, we provided a polynomial-time algorithm for finding secure sets on graphs of bounded treewidth and thus showed membership in the class . As a positive result, we could show that the -complete problem of verifying whether a given set is secure can be solved in fixed-parameter linear time when parameterized by treewidth.
There are several interesting directions for future research. One open question is which additional restrictions beside bounded treewidth need to be imposed on Secure Set instances to achieve fixed-parameter tractability. On the other hand, the Secure Set Verification problem may remain FPT for parameters that are less restrictive than treewidth. We showed -hardness and -membership of Secure Set, so a tight bound is still lacking, albeit perhaps more of theoretical interest due to the fact that problems at a certain level of the weft hierarchy generally do not admit faster algorithms than problems at higher levels. To classify a problem as FPT w.r.t. treewidth, a common approach is to express it in monadic second-order logic (MSO) and then invoke Courcelle’s Theorem [12], which immediately proves that the problem is FPT. We showed that Secure Set Verification is FPT, but it is not clear if it can be expressed in MSO. If it cannot, then our FPT result could hint at possible extensions of MSO whose model-checking problem is still FPT. Similarly, we believe that MSO can be extended in such a way that Secure Set can be expressed and that a variant of Courcelle’s Theorem for showing membership in instead of holds. Finally, some of our results seem to be transferable to (variants of) the Defensive Alliance problem, so it would be interesting to investigate if some of our reductions and algorithms can help in the study of such related problems.
Acknowledgements
Open access funding provided by Austrian Science Fund (FWF). This work was supported by the Austrian Science Fund (FWF) projects P25607 and Y698. The authors would like to thank the anonymous referees for their helpful feedback.
Footnotes
To be precise, [22] shows that a slight variant of Secure Set is tractable on trees, since Secure Set on trees is trivial. Our results, however, also imply -hardness for this particular variant.
References
- 1.Abseher, M., Bliem, B., Charwat, G., Dusberger, F., Woltran, S.: Computing secure sets in graphs using answer set programming. J. Log. Comput. (2015, accepted)
- 2.Arnborg S, Corneil DG, Proskurowski A. Complexity of finding embeddings in a k-tree. SIAM J. Algebr. Discrete Methods. 1987;8(2):277–284. doi: 10.1137/0608024. [DOI] [Google Scholar]
- 3.Asahiro Y, Miyano E, Ono H. Graph classes and the complexity of the graph orientation minimizing the maximum weighted outdegree. Discrete Appl. Math. 2011;159(7):498–508. doi: 10.1016/j.dam.2010.11.003. [DOI] [Google Scholar]
- 4.Bliem, B., Woltran, S.: Complexity of secure sets. In: Mayr, E.W. (ed.) Revised Papers of the 41st International Workshop on Graph-Theoretic Concepts in Computer Science (WG 2015), June 17–19, 2015, Garching, Germany. Lecture Notes in Computer Science, vol. 9224, pp. 64–77. Springer (2016)
- 5.Bodlaender HL. A tourist guide through treewidth. Acta Cybern. 1993;11(1–2):1–21. [Google Scholar]
- 6.Bodlaender HL. A linear-time algorithm for finding tree-decompositions of small treewidth. SIAM J. Comput. 1996;25(6):1305–1317. doi: 10.1137/S0097539793251219. [DOI] [Google Scholar]
- 7.Bodlaender, H.L.: Discovering treewidth. In: Vojtás, P., Bieliková, M., Charron-Bost, B., Sýkora, O. (eds.) Proceedings of the 31st Conference on Current Trends in Theory and Practice of Computer Science (SOFSEM 2005), January 22–28, 2005, Liptovský Ján, Slovakia. Lecture Notes in Computer Science, vol. 3381, pp. 1–16. Springer (2005)
- 8.Bodlaender HL, Koster AMCA. Treewidth computations I. Upper bounds. Inf. Comput. 2010;208(3):259–275. doi: 10.1016/j.ic.2009.03.008. [DOI] [Google Scholar]
- 9.Bojańczyk, M., Pilipczuk, M.: Optimizing tree decompositions in MSO. In: Vollmer, H., Vallée, B. (eds.) Proceedings of the 34th Symposium on Theoretical Aspects of Computer Science (STACS 2017), March 8–11, 2017, Hannover, Germany. LIPIcs – Leibniz International Proceedings in Informatics, vol. 66, pp. 15:1–15:13. Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2017)
- 10.Brewka G, Eiter T, Truszczyński M. Answer set programming at a glance. Commun. ACM. 2011;54(12):92–103. doi: 10.1145/2043174.2043195. [DOI] [Google Scholar]
- 11.Brigham RC, Dutton RD, Hedetniemi ST. Security in graphs. Discrete Appl. Math. 2007;155(13):1708–1714. doi: 10.1016/j.dam.2007.03.009. [DOI] [Google Scholar]
- 12.Courcelle B. The monadic second-order logic of graphs I: recognizable sets of finite graphs. Inf. Comput. 1990;85(1):12–75. doi: 10.1016/0890-5401(90)90043-H. [DOI] [Google Scholar]
- 13.Cygan M, Fomin FV, Kowalik Ł, Lokshtanov D, Marx D, Pilipczuk M, Pilipczuk M, Saurabh S. Parameterized Algorithms. Cham: Springer; 2015. [Google Scholar]
- 14.Dermaku, A., Ganzow, T., Gottlob, G., McMahan, B.J., Musliu, N., Samer, M.: Heuristic methods for hypertree decomposition. In: Gelbukh, A.F., Morales, E.F. (eds.) Proceedings of the 7th Mexican International Conference on Artificial Intelligence (MICAI 2008), October 27–31, 2008, Atizapán de Zaragoza, Mexico. Lecture Notes in Computer Science, vol. 5317, pp. 1–11. Springer (2008)
- 15.Dom, M., Lokshtanov, D., Saurabh, S., Villanger, Y.: Capacitated domination and covering: a parameterized perspective. In: Proceedings of the 3rd International Workshop on Parameterized and Exact Computation (IWPEC 2008), May 14–16, 2008, Victoria, Canada. Lecture Notes in Computer Science, vol. 5018, pp. 78–90. Springer (2008)
- 16.Downey RG, Fellows MR. Parameterized Complexity. Monographs in Computer Science. New York: Springer; 1999. [Google Scholar]
- 17.Enciso RI, Dutton RD. Parameterized complexity of secure sets. Congr. Numer. 2008;189:161–168. [Google Scholar]
- 18.Lawrence S, Giles CL, Coetzee F. Self-organization and identification of web communities. IEEE Comput. 2002;35(3):66–71. doi: 10.1109/2.989932. [DOI] [Google Scholar]
- 19.Flum J, Grohe M. Parameterized Complexity Theory. Texts in Theoretical Computer Science. New York: Springer; 2006. [Google Scholar]
- 20.Haynes, T.W., Hedetniemi, S.T., Henning, M.A.: Global defensive alliances in graphs. Electron. J. Comb. 10 (2003)
- 21.Ho, Y.Y.: Global Secure Sets of Trees and Grid-Like Graphs. PhD thesis, University of Central Florida, Orlando, FL, USA (2011)
- 22.Ho YY, Dutton RD. Rooted secure sets of trees. AKCE Int. J. Graphs Comb. 2009;6(3):373–392. [Google Scholar]
- 23.Kloks, T.: Treewidth: Computations and Approximations, vol. 842. Lecture Notes in Computer Science. Springer, New York, NY, USA (1994)
- 24.Kornai A, Tuza Z. Narrowness, pathwidth, and their application in natural language processing. Discrete Appl. Math. 1992;36(1):87–92. doi: 10.1016/0166-218X(92)90208-R. [DOI] [Google Scholar]
- 25.Marx D. Complexity of clique coloring and related problems. Theor. Comput. Sci. 2011;412(29):3487–3500. doi: 10.1016/j.tcs.2011.02.038. [DOI] [Google Scholar]
- 26.Niedermeier R. Invitation to Fixed-Parameter Algorithms. Oxford Lecture Series in Mathematics and its Applications. Oxford: Oxford University Press; 2006. [Google Scholar]
- 27.Robertson N, Seymour PD. Graph minors. III. Planar tree-width. J. Comb. Theory Ser. B. 1984;36(1):49–64. doi: 10.1016/0095-8956(84)90013-3. [DOI] [Google Scholar]
- 28.Szeider S. Generalizations of matched CNF formulas. Ann. Math. Artif. Intell. 2005;43(1):223–238. doi: 10.1007/s10472-005-0432-6. [DOI] [Google Scholar]
- 29.Szeider, S.: Not so easy problems for tree decomposable graphs. CoRR, arXiv:1107.1177 (2011)
- 30.Thorup M. All structured programs have small tree-width and good register allocation. Inf. Comput. 1998;142(2):159–181. doi: 10.1006/inco.1997.2697. [DOI] [Google Scholar]
- 31.Yero, I.G., Rodríguez-Velázquez, J.A.: Defensive alliances in graphs: a survey. CoRR, arXiv:1308.2096 (2013)







