Enumeration of Preferred Extensions in Almost Oriented Digraphs

07/01/2019
by   Serge Gaspers, et al.
0

In this paper, we present enumeration algorithms to list all preferred extensions of an argumentation framework. This task is equivalent to enumerating all maximal semikernels of a directed graph. For directed graphs on n vertices, all preferred extensions can be enumerated in O^*(3^n/3) time and there are directed graphs with Ω(3^n/3) preferred extensions. We give faster enumeration algorithms for directed graphs with at most 0.8004· n vertices occurring in 2-cycles. In particular, for oriented graphs (digraphs with no 2-cycles) one of our algorithms runs in time O(1.2321^n), and we show that there are oriented graphs with Ω(3^n/6) > Ω(1.2009^n) preferred extensions. A combination of three algorithms leads to the fastest enumeration times for various proportions of the number of vertices in 2-cycles. The most innovative one is a new 2-stage sampling algorithm, combined with a new parameterized enumeration algorithm, analyzed with a combination of the recent monotone local search technique (STOC 2016) and an extension thereof (ICALP 2017).

READ FULL TEXT VIEW PDF

Authors

page 1

page 2

page 3

page 4

02/11/2022

On the preferred extensions of argumentation frameworks: bijections with naive extensions

This paper deals with the problem of finding the preferred extensions of...
07/08/2002

On Concise Encodings of Preferred Extensions

Much work on argument systems has focussed on preferred extensions which...
05/21/2021

Finding All Bounded-Length Simple Cycles in a Directed Graph

A new efficient algorithm is presented for finding all simple cycles tha...
07/28/2021

On fractional version of oriented coloring

We introduce the fractional version of oriented coloring and initiate it...
11/11/2020

Counting Homomorphic Cycles in Degenerate Graphs

Since computing most variants of the subgraph counting problem in genera...
01/29/2021

r-indexing Wheeler graphs

Let G be a Wheeler graph and r be the number of runs in a Burrows-Wheele...
09/27/2020

A Weighted Quiver Kernel using Functor Homology

In this paper, we propose a new homological method to study weighted dir...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

In Dung’s theory of abstract argumentation [17], an argumentation framework (AF) is a digraph , where each vertex represents an argument, and an arc denotes that argument attacks argument . There are various semantics that express what properties a set of arguments should have for a rational agent to stand by that set of arguments. One of the most central semantics is the preferred semantics that was already proposed by Dung in his foundational paper [17]. Let be a subset of vertices (also called extension) of a digraph . The set is conflict-free if no arc has both endpoints in . A vertex is acceptable with respect to if for each arc there is an arc with . In other words, for each argument that attacks , there is an argument in that attacks . We say in this case that defends against . The set is admissible if it is conflict-free and each argument in is acceptable with respect to . The set is preferred if it is an inclusion-wise maximal admissible set.

While we will use the language of abstract argumentation, we remark that such vertex sets have also been studied in graph theory. Neumann-Lara [33] (see also [25]) defined the notion of semikernels. Maximal semikernels are equal to the preferred extensions in the directed graph where all arcs are reversed. The related notion of kernels [38]

has the same correspondence with stable extensions in abstract argumentation, and was introduced as an abstract solution concept in cooperative game theory, but has been extensively studied in the theory of directed graphs. In particular, various issues around the enumeration of kernels and semikernels have been considered in previous work

[2, 6, 24, 35].

Motivation A central problem in abstract argumentation is the enumeration of extensions prescribed by a given semantics. In part, this is because exploring what sets of arguments may go together is an inherent issue of AFs. The enumeration of preferred extensions is of particular interest, firstly for its own sake, but also in the study of other semantics as it forms the basis of several other semantics refining this set. A number of existing algorithms and implementations enumerate all preferred extensions of a digraph (see, e.g., [7, 8, 10, 11, 12, 13, 16, 30, 34, 36, 37]). The enumeration of preferred extensions is also a part of the biennial International Competition on Computational Models of Argumentation (ICCMA). Computational problems where the enumeration of extensions are used involve answering the questions: is a given argument in some / all preferred extensions and what is the number of preferred extensions containing a given argument / in total. Upper bounds on the number of extensions under various semantics have also been proposed as fundamental characteristics to compare various semantics in abstract argumentation [4, 18].

Dunne et al. [18], building on the work of Baumann and Strass [3], showed that the number of preferred extensions is (this result also holds for many other semantics [3, 18]). This bound is realized by a disjoint union of triangles, where every edge is replaced by an arc in both directions. The proof is based on the well-known Moon and Moser result [32] for upper bounding the number of maximal cliques in graphs.

We study the enumeration of preferred extensions in digraphs with no, or relatively few, -cycles (i.e., bidirectional arcs). Our aim is to determine how much the presence of -cycles affects the number of preferred extensions of an AF. Mutually attacking arguments play a special role in abstract argumentation [29], but this conflict is often resolved rather easily if the strength of the two attacks can be evaluated [5], or the user’s preference between the two arguments can be elicited [31, 1]. These methods of resolving conflicts motivate the study of problems, and in particular enumeration problems, for AFs with no or few 2-cycles.

Our results We study enumeration algorithms and combinatorial upper bounds on the number of preferred extensions in oriented graphs, which are digraphs without 2-cycles, and generalizations of oriented graphs. Our main concern is the enumeration of all preferred extensions in time moderately exponential in the number of vertices , and we mainly focus on digraphs that are either oriented or have small resolution order. The resolution order of a digraph , denoted , is the number of vertices that belong to a 2-cycle in .

Our main result is an algorithm that, for any , enumerates all preferred extensions of a digraph on vertices in time

where , and is the positive root of . The notation hides factors that are polynomial in the input size. See Figure 1, which plots the base of the running time expressed as for varying from 0 to 1. For , this is best possible and follows from the work in [18, 31].

Figure 1: The graph depicts the base of the exponential running times of the three enumeration algorithms, according to . When , our branching algorithm for oriented graphs together with the Oriented Translation (dark green) gives the fastest algorithm. For , the algorithm based on previous work [18, 31] (orange) is fastest. In the middle range, the combination of the 2-phase monotone local search with the parameterized enumeration algorithm (blue) is fastest. Our lower bound on the largest number of preferred extensions is drawn with a dashed red line.

At the other end of the spectrum, i.e., for oriented graphs where , the upper bound is and is obtained via a carefully constructed branching algorithm and running time analysis. We also give a lower bound on the largest number of preferred extensions an oriented graph on vertices may have of . A construction, which we call the Oriented Translation, reducing an arbitrary digraph to an oriented graph with vertices, such that there is a bijection between their preferred extensions, allows us to generalize these upper and lower bounds to and , respectively.

Our main technical contribution is the third algorithm. It relies on a parameterized enumeration algorithm and extensions of the recent monotone local search framework [21]. The parameterized enumeration algorithm has as input a digraph , a set of arguments , and a non-negative integer , and it enumerates all maximal admissible extensions of within distance of . Its running time can be upper bounded by . This is optimal, since there are instances for which the solution consists of preferred extensions at distance at most from . Furthermore, under the Strong Exponential Time Hypothesis, the corresponding decision problem has no time solution for any . We use this parameterized enumeration algorithm in a new 2-phase monotone local search procedure, where we separately sample vertices from , the set of vertices in at least one 2-cycle, and and then apply the parameterized enumeration algorithm. The running time analysis is a new combination of the results in [21] for the first sampling phase and [27]

for the second sampling phase, combined with the parameterized subroutine. From a technical point of view, this is the most innovative part of this paper. (From a conceptual point of view, the most innovative contribution is probably the synergy between modern enumeration algorithmics and the theory of abstract argumentation.) This results in an algorithm enumerating all preferred extensions of a given digraph

in time .

Interpretation of results Figure 1 illustrates the running time of the various algorithms. We have improved algorithms and combinatorial upper bounds whenever . The result for shows that for oriented graphs, our new algorithm allows to handle instances with more arguments, compared with the previous best upper bound. (We have that .) The figure also shows that we have significantly narrowed the gap between the best known lower bound and the best known upper bound for oriented graphs, and digraphs with a fraction of vertices belonging to -cycles, for a wide range of .

Outline Sections 2 and 3 describe our monotone local search algorithm. Section 4 describes our branching algorithm for oriented graphs.

First we introduce the parameterized enumeration problem that will form the subroutine of our Monotone Local Search.

0.99 Maximal Admissible Subset Enumeration (MASE)

Input: Graph , set , integer
Parameter:
Output: Enumerate all maximal admissible sets such that .

There is a subtlety here with how we define maximal. We say is a maximal admissible subset of if there does not exist an admissible set such that . Notably is not necessarily a preferred extension (though is if ).

In Section 2, we present an algorithm for MASE, parameterized by and , the resolution order of the subgraph of induced by .

Theorem 1.

For an instance of MASE, let . Then MASE can be solved in time. Furthermore, there are at most maximal admissible subsets of within distance of . Hence, there are at most preferred extensions that are subsets of with size .

Our algorithm is a standard parameterized branching algorithm. Compared to the enumeration of independent sets, the primary additional tool we have is a powerful simplification rule, (Undefendable), for vertices with in-degree . (Undefendable) also allows our base case to be any conflict-free set.

In Section 3, we extend our parameterized algorithm into a general enumeration algorithm through a novel 2-phase application of monotone local search. Since 2-cycles increase the run time of our MASE subroutine, we modify the classical Monotone Local Search to sample separately between a set of ”bad vertices” (ones contained in a 2-cycle) and ”good vertices” (ones not contained in any 2-cycle). This presents a speed up compared to a more direct application of the Monotone Local Search framework. We believe this may be useful for other problems.

Separately, Section 4 presents a branching algorithm for oriented graphs. Again, (Undefendable) plays a critical role. This time around, we allow our base case to be any induced DAG which further provides a simplification rule for vertices with out-degree 0. We tailor our branching rules to take full advantage of these two simplification rules. This is combined with a lot of careful case analysis and ad-hoc methods (including a graph classification theorem in Subsection H.7).

Each of our algorithms also provide a corresponding combinatorial upper bound on the number of preferred extensions. The various enumeration algorithms and bounds are collected in Section 5.

In the appendix we have a mix of background, further detail and extra results. Some extra results that may be of independent interest:

Appendix Section C describes the Oriented Translation, a parsimonious reduction from a general directed graph to an oriented graph.

Theorem 2.

There is a linear time algorithm that transforms any AF into an oriented AF with such that there is a bijection between the preferred extensions of and the preferred extensions of that can be applied in linear time.

The basic idea of the construction (see Appendix Section C) is carefully converting 2-cycles into 4-cycles by doubling up the vertices that are contained in at least one 2-cycle.

Our primary interest in Theorem 2 is as a tool for extending oriented graph algorithms to algorithms on general graphs, parameterized by resolution order. In Section 5 we apply this to our branching algorithm for oriented graphs.

Theorem 2 is also useful for deriving complexity results on oriented graphs by extending constructions for directed graphs. In Appendix Section F.2 we obtain the following result:

Theorem 3.

Unless P=NP, no algorithm enumerates the admissible or preferred extensions of an AF in output-polynomial time, even when the AF is an oriented graph.

In Appendix Section F we also show our algorithm for the decision variant of MASE is optimal, assuming the Strong Exponential Time Hypothesis, and that the enumeration bound in Theorem 1 is tight (i.e: there exist instances with maximal admissible subsets within distance ).

We briefly justify the choice of the measure we use for our MASE algorithm in Appendix Section G.

Notation An oriented graph is a digraph with no 2-cycles.

We will use the notation to denote the set of vertices adjacent to and to denote .

We will assume throughout that AFs have no self loops. We can safely make this assumption due to the Loopless Translation (Definition C.1) which, with a (small) constant overhead removes all self loops from an AF while preserving the admissible extensions.

2 Parameterized Enumeration Problems

Our algorithm for MASE will follow a standard template for parameterized branching algorithms. A summary of the necessary concepts can be found in Appendix Section A.

We will consider the measure where is the number of vertices we are allowed to remove and is the resolution order of . We will design a branching algorithm with run time which recurses into subinstances and collates their results to obtain the maximal admissible subsets of .

However, there is a technical difficulty in the collation step arising from the fact that a maximal admissible subset of may not be a maximal admissible subset of . This gives rise to the following subproblem:

0.99 Maximal Subset Collation

Input: Graph , pairs where for each , and is a set containing only maximal admissible subsets of
Output: A set containing all maximal elements of

The main result we need is:

Lemma 1.

Maximal Subset Collation can be solved in time.

An algorithm for Maximal Subset Collation is provided in Appendix Section D.

We are now ready to solve MASE.

2.1 An algorithm for Maximal Admissible Subset Enumeration

The overall structure of our algorithm is described in Algorithm 1.

The following table lists the branching rules in application order with the first row being the base case. The second column describes the instances each rule is applicable to. After applying simplification rules, our branching algorithm will always apply the first rule that is applicable to the input instance.

Case Requirement to apply Running Time
Base is conflict-free. Solves in time, returns set.
1 is oriented with maximum total degree .

Branching vector

, branching number .
2 There is a 2-cycle in . Branching vector , branching number .
3 has maximum total degree . Branching vector , branching number .
4 contains a vertex with total degree 3. Branching vector , branching number .

We note that these requirements are exhaustive, hence there will always be at least one applicable rule in any instance.

Returns all maximal admissible subsets such that
function MASE()
     if  then
         return      
     while (Undefendable) applies do
         Apply (Undefendable)      
     if Base Case applies then
         Solve the instance directly through the base case subroutine.
     else
         Let be the first branching rule that applies.
         Let be the subinstances obtained from applying .
         Let , for all .
         return      
Algorithm 1 Structure of MASE branching algorithm

We include the base case and short remarks on each of the branching cases. Full proofs of each case can be found in Appendix Section E.

The key ingredient for solving the base case and optimizing our branching cases is the following simplification rule. It is essentially a rephrasing of a well known result that has been applied before in the context of enumeration algorithms (e.g., [16][9]).

Simplification Rule 1 (Undefendable).

Suppose we are trying to enumerate all maximal admissible subextensions of .

Let be a vertex such that there exists a vertex , attacks and no vertex in attacks . Then there is no admissible subset of that contains so we can safely set .

Lemma 2.

(Undefendable) is sound.

Proof.

Vertex can never be defended from in any subextension of and hence is in no admissible subextension of . ∎

Instead of solving the base case directly we will instead solve the more general case where is a DAG. The increased generality will be needed in Section 4.

The base case, that is conflict-free, follows trivially (since is a DAG if is conflict-free).

2.2 MASE when is a DAG

The results in this section are all well-known and follow directly from (Undefendable).

Lemma 3.

If is a DAG, the rule (Undefendable) is not applicable if and only if is admissible.

Proof.

Clearly (Undefendable) is not applicable if and only if every is acceptable with respect to (recall this means that for all arcs , there is an arc with ). By the definition of admissibility, it remains to show that if (Undefendable) is not applicable, then is conflict-free. This follows from noting (Undefendable) is applicable to any vertex attacked by a maximal vertex in . Such a vertex exists in any weakly connected DAG with more than one vertex. Hence all weakly connected components of have size one. ∎

(Undefendable) takes polynomial time to apply. The resulting subset from applying (Undefendable) until it is not applicable is the unique maximal admissible subset of . It is admissible by Lemma 3. It is the unique maximal admissible subset as (Undefendable) only removes vertices that are in no admissible subsets of . Hence:

Lemma 4.

Suppose induces a DAG in . Then has exactly one maximal admissible subset and it can be found in polynomial time.

2.3 Remarks on branching cases

Full proofs can be found in Appendix Section E.

Case 1 follows from noting must be a family of cycles.

Let be the vertex in the 2-cycle with higher total degree. Case 2 follows from a 2-way branch, in one branch enumerating all maximal admissible subsets that include , in the other branch enumerating all that do not include .

Case 3 is another 2-way branch, except applied to any vertex with total degree at least 4.

Case 4 is probably the most instructive. It best showcases the power of (Undefendable). First we show a vertex exists with in-degree 1, out-degree 2. Then a 2-way branch is applied to the vertex attacking , using (Undefendable) to improve the branch where the vertex is excluded and is left with in-degree 0.

2.4 Running Time Analysis

The base case is solvable in polynomial time. Each of our branching rules has branching number . Hence, if we ignore the calls to Maximal Subset Collation, by the Combine Analysis Lemma (Lemma 6) our algorithm has running time .

Maximal Subset Collation is applied to each admissible subset encountered by the MASE algorithm (i.e: each leaf in the search tree) at most times, where is the maximum depth of the search tree. By Lemma 1 each application incurs a cost ( for our branching rules). Hence the overall cost incurred by the Maximal Subset Collation step is

where is the total number of admissible subsets encountered by the MASE algorithm (equivalently, the number of leaves in the search tree). By the Combine Analysis Lemma for Enumeration (Lemma 7), is . The maximum depth is which we may take to be . Hence Maximal Subset Collation incurs an overhead cost of .

As noted, our algorithm also satisfies the requirements for applying the Combine Analysis Lemma for Enumeration (Lemma 7). We summarize all the above results in the following theorem.

Theorem 4.

Let , where is the resolution order of . Then MASE can be solved in time. Furthermore, there are at most maximal admissible subsets of within distance of . Hence, there are at most preferred extensions that are subsets of with size .

3 Monotone Local Search

In this section, we apply Monotone Local Search to our algorithm for Maximal Admissible Subset Enumeration. A basic exposition of Monotone Local Search will be provided here, additional background can be found in Appendix Section B.

The framework normally applies to extension problems. However we can just as easily apply it to removal problems (formally by focusing on the complement of each set, we can turn any removal problem into an extension problem). Hence, we will freely use the framework with removal problems instead.

For our application, the instance is the graph and the family we are looking to enumerate, , is the set of all preferred extensions of . We will apply Monotone Local Search using MASE as our subroutine.

For a MASE instance , let denote the set of all maximal admissible sets such that . Hence contains all preferred extensions that are subsets of within distance , but may also contain admissible extensions that are not preferred extensions.

Because of this, our Monotone Local Search will enumerate , however, it may also enumerate some non-maximal admissible extensions. Our result, Theorem 5, will account for this, however, for simplicity we will just speak of enumerating throughout this section.

A naive application of the Monotone Local Search framework with our algorithm for enumerating yields an time algorithm that enumerates all preferred extensions of . To improve this we need a basic understanding of how Monotone Local Search works.

3.1 Basic Overview of Monotone Local Search

We need the following definition from [21] (slightly modified to account for our preference for removal problems):

Definition 3.1 ([21]).

Let be a universe of size and let . A family is an -set-containing-family if for every set , there exists a such that .

For any fixed , a value will somehow be chosen. Then, a -set-containing-family is constructed. For each set in , its subsets from obtained by removing at most elements are then enumerated using an enumeration subroutine. This enumerates all elements of with size . Supposing the subroutine has run time (where is the parameter), this step of Monotone Local Search has run time .

Repeating this for all , Monotone Local Search has running time . With the right choices of , [21] shows the running time .

3.2 Improving our Monotone Local Search

We start with some notation. For any digraph , let be the set of vertices in in at least one 2-cycle and let . The key idea is we will sample vertices from and separately. The overall structure is described in Algorithm 2. Except for the separate sampling, it is identical to a standard application of Monotone Local Search.

First, we argue correctness, i.e: that every preferred extension is enumerated at least once. Fix a preferred extension, say , and suppose contains vertices in and vertices in . Then, by the definition of set-containing-families, there exists a such that and a such that . Now we note that to get:

Hence is enumerated in the call to as required.

Now we argue the runtime. For a fixed the calls to MASE have total run time for some choice of . Our overall running time is

We can split this into two terms to get a complexity of multiplied by .

Returns a set containing all preferred extensions of (and possibly some non-preferred extensions)
function ImprovedMLS()
     Let .
     for  to  do
         Let .
         Let be a -set-containing-family.
         for  to  do
              Let .
              Let be a -set-containing-family.
              for all pairs with  do
                  Let .                             return
Algorithm 2 Structure of Improved Monotone Local Search algorithm

We will now analyze the running time with the right choices of and . Theorem 7 summarizes the results we use to analyze the complexity.

The first of these two terms can be analyzed using the analysis in [21]. This term is the complexity one attains for Monotone Local Search with a subroutine. Hence the analysis in [21] gives a complexity of .

We need the extended analysis presented in [27] to analyze the second term. This term is the complexity one attains for Monotone Local Search with a subroutine (where is the parameter, the size of the underlying set and is the set we are extending). Hence the analysis in [27] gives a complexity of .

The papers we have cited also give a corresponding combinatorial upper bound on the number of preferred extensions. We summarize the above results as follows.

Theorem 5.

Let be a digraph. Let be the proportion of vertices in that are in at least one 2-cycle.

Then there exists a time algorithm that enumerates all preferred extensions of ; however it may also enumerate some non-maximal admissible extensions. Furthermore, there are at most preferred extensions in .

4 Improved Enumeration Algorithm for Oriented Graphs

Finally, we outline a branching algorithm with a finer analysis for oriented graphs. As with MASE, we will follow a standard template for branching algorithms. A summary of the necessary concepts can be found in Appendix Section A. Our algorithm creates a search tree with at most leaves where is the branching number for branching vector .

In Section 5 we will use the Oriented Translation (Theorem 2) to obtain a general enumeration algorithm parameterized by the number of vertices in at least one 2-cycle.

4.1 Overview

The overall structure of our algorithm is described in Algorithm 3.

The state of the algorithm consists of the subset and a queue of vertices ( for undecided and for deferred). is the set of vertices we have yet to make a decision on whether we should include them. is a queue of vertices which have no outgoing arcs to . These vertices will be handled in the base case. While branching we can essentially assume the vertices in do not exist.

We maintain the following invariants. We outline why they are invariant, it is straight-forward to verify that each case of our branching algorithm maintains these invariants.

  1. and are disjoint. This holds as vertices are only ever deleted from or moved between and , never copied.

  2. is a DAG where each vertex only attacks vertices that were added to before . This is crucial for the base case since a DAG has 1 maximal admissible subset. This holds as only vertices with out-degree in are ever moved to .

  3. There is no attack from any vertex in to any vertex in . This holds for the same reason as Invariant 2.

.
is a DAG where each only attacks vertices added to before .
There is no attack from any vertex in to any vertex in .
Returns all maximal admissible subsets of .
function OrientedEnumeration()
     if  then
         return      
     while Any simplification rule applies do
         Apply said simplification rule      
     if Base Case applies then
         Solve the instance directly through the base case subroutine.
     else
         Let be the first branching rule that applies.
         Let be the subinstances obtained from applying .
         Let , for all .
         return      
Algorithm 3 Structure of Oriented maximal admissible enumeration algorithm

Our measure is . For any instance, our algorithm creates a search tree with at most leaves. Hence, calling will return all preferred extensions of by traversing a search tree with at most leaves.

4.2 Extra Notation

We will say a vertex has degree if it has in-degree , a vertex has degree if it has out-degree and a vertex has degree if it has in-degree and out-degree .

4.3 Simplification Rules

Both of these are applicable in polynomial time and decrease .

Simplification Rule 2 (Out-degree 0).

Let be a vertex in with out-degree . Move from to the end of the queue .

Simplification Rule 3 (In-degree 0).

Let be any vertex in with in-degree . Then by Invariant 3, has in-degree in . Applying Simplification Rule (Undefendable) we can set . After that, has out-degree 0 in and hence we move from to .

Our new instance has:

  • .

  • .

Due to these rules, henceforth we may assume each vertex in has in-degree , out-degree and (total) degree .

4.4 Branching Rules

Our algorithm will apply the first rule applicable to the instance:

Case Requirement to apply Worst case branching number
Base . Solves in , returns 1 set.
1 with total degree . Branching vector , branching number .
2 with degree . Branching vector , branching number .
3 with in-degree out-degree. Branching vector , branching number .
4 has a weakly connected component where every vertex has degree . Branching vector , branching number .
5 has a weakly connected component where every vertex has degree . Branching vector , branching number .
6 There is a weakly connected component in where every vertex has in-degree out-degree. Branching vector , branching number .

We note the base case and cases 3 and 6 cover all possible inputs. Hence there will always be at least one applicable rule.

Our primary strategy is the following branching rule applied to a specifically chosen .

4.5 2-way branch on whether to include

We will often pick a specific vertex and do a 2-way branch, in one branch enumerating all maximal admissible subsets that include , in the other branch enumerating all that do not include .

  • In the branch where we decide to include we can not include any of ’s neighbors. Hence we create a new instance where .

    Now is isolated in so by Simplification Rule 0 we may move from to . Hence in our new instance we finally have:

    • .

    • .

    and hence .

    As a technical note, not every subset enumerated in this branch contains , however, every maximal admissible subset that contains will be enumerated in this branch.

  • In the other branch we decide to exclude . Hence our new instance has:

    • .

    • .

    and hence .

Hence branching on whether we should include leads to a branching rule with branching vector .

Definition 4.1 (2-way branch on whether to include ).

The phrase 2-way branch on whether to include will be used as shorthand for the above branching rule.

4.6 Remarks on cases

Full proofs can be found in Appendix Section H.

In the base case, by Invariant 2, is a DAG. The base case then follows trivially from Lemma 4.

Case 1 follows from a 2-way branch on whether to include (Definition 4.1), where is any vertex with total degree at least 7.

Case 2 is a good example of the strategy of picking a specific to apply a 2-way branch on. We will pick a that allows us to apply our simplification rules in the branch where is excluded. However, the choice of will depend on some case analysis.

Case 3 is similar to Case 2, a specific is chosen on which we apply a 2-way branch.

Case 4 is done through a graph classification theorem(Theorem 10).

Case 5 is just a 4-way branch on any vertex and its in-neighbors.

For Case 6, we first show there is a vertex with degree attacking a vertex with degree , say . Then we apply a 3-way branch on and its in-neighbors.

4.7 Summary of results

In our base case we enumerate 1 extension in polynomial time.

Otherwise, we apply a branching rule with branching number .

As in MASE, the Maximal Subset Collation subroutine (Algorithm 4) does not incur additional overhead as the search tree’s depth is bounded by (see Subsection 2.4 for the argument which we can apply verbatim).

Applying the Combine Analysis Lemma(Lemma 6) and Combine Analysis Lemma for Enumeration (Lemma 7) we obtain:

Theorem 6.

Let be an oriented graph. Then there is an algorithm that enumerates all preferred extensions of with running time where is the unique positive root of , .

Furthermore, has at most preferred extensions.

5 Bounds on number of preferred extensions

In this section, we collect our results bounding the number of preferred extensions.

5.1 Bounds on general directed graphs

A tight upper bound is [19]. This bound is easily attainable since preferred extensions coincide with maximal independent sets(MIS) in graphs where every edge is in a 2-cycle.

We can also enumerate them in . We note each MIS has a single maximal admissible subset. We then take a branching algorithm for MIS[26], allowing us to apply the Maximal Subset Collation subroutine (Algorithm 4) to remove the non preferred extensions without additional overhead. Hence, all preferred extensions can be enumerated in .

5.2 Parameterizing by Resolution Order

We will give bounds based on , the proportion of vertices that are in at least one 2-cycle.

5.2.1 Lower Bound

An undirected 3-cycle has 3 preferred extensions. Hence, applying the Oriented Translation to it, we obtain an oriented structure with 6 vertices and 3 preferred extensions.

Our construction for lower bounding will be to include as many undirected 3-cycles as possible and then include as many oriented translations of 3-cycles as possible. We can include undirected 3-cycles and oriented translations, obtaining an AF with preferred extensions.

5.2.2 Upper Bound

There are 3 different upper bounds that are all optimal in a different range. See also Figure 1.

  • where is the unique positive root of . This bound is obtained from using the Oriented Translation along with Theorem 6. This is best for up to around 0.6684.

  • , the bound from our 2-phase Monotone Local Search. This is best for a small range where .

  • . This is best for .

6 Conclusion

We again note that the concept of an admissible (resp. preferred) extension has also been studied as a semikernel[33] (resp. maximal semikernel) in graph theory. Hence our result may be interpreted as a combinatorial upper bound on the number of maximal semikernels, parameterized by the proportion of vertices in at least one 2-cycle.

Acknowledgment

We thank Oliver Fisher for fruitful discussions and collaboration on preliminary results in the early stages of this work.

Appendix A Background on Analysis of Branching Algorithms

This section provides the required background for the analysis of branching algorithms used in this paper. All results here can be found in standard textbooks. We mostly follow Fomin & Kratsch [23]:

For the analysis of branching algorithms, we use Measure & Conquer [22] with relatively simple measures. A measure is a function assigning a non-negative number to each instance . For each instance, either the instance is directly solvable in polynomial time or our algorithm will apply a polynomial time branching rule to generate multiple sub-instances with smaller measure that are then recursed on.

The following notation (which is used in standard textbooks on exact exponential algorithms [23] and parameterized algorithms [14]) will simplify the discussion of these algorithms.

Definition A.1 (Branching Vector [23]).

Let be a measure. Let be a branching rule that for any input instance, say , branches into instances with measures such that for all , . Then we call the branching vector of branching rule .

The following lemma from [23] forms the basis for the analysis of our branching algorithms.

Lemma 5 ([23]).

Let be a branching rule with branching vector . Then the running time of the branching algorithm using only branching rule is where is the unique positive real root of:

We call the branching number of the branching vector .

In [23], it is further noted that if an algorithm has multiple branching rules, then its running times is where . We will actually need the following simple extension, which has been simplified from [26] and restated to use our notation.

Lemma 6 (Combine Analysis Lemma [26]).

Let be an algorithm for a problem which for each instance, say , either directly solves the instance in time or after polynomial time, applies one of branching rules , the -th of which has branching number . Then has running time where .

For our enumeration bounds we will need the following variant of the above lemma.

First, we define the search tree of a branching algorithm to be the tree formed by the recursive calls, with the leaves being cases that can be solved directly. Generally, and in all our applications, for enumeration algorithms the number of leaves is an upper bound on the number of objects being enumerated (equality may not hold as the same object may appear as a leaf multiple times).

Lemma 7 (Combine Analysis Lemma for Enumeration).

Let be an algorithm for a problem which for each instance, say , either directly solves the instance with a branching algorithm that generates at most leaves or applies one of branching rules , the -th of which has branching number . Then the search tree for applying to has at most leaves where .

Appendix B Background on Monotone Local Search

Monotone Local Search [21] is a technique to design exponential-time algorithms for subset problems based on single-exponential parameterized algorithms. We give an exposition of the corresponding enumeration algorithms from [21], and the extension in [27].

An implicit set system is a function that takes as input a string and outputs a set system , where is a universe and is a collection of subsets of . The string is referred to as an instance and we denote by the size of the universe and by the size of the instance. We assume that . An implicit set system is polynomial time computable if: (a) there exists a polynomial time algorithm that given produces , and (b) there exists a polynomial time algorithm that given , and a subset of determines whether .

Let be real valued constants and be an implicit set system. Then is ()-uniform if for every instance , set , and integer , the cardinality of the collection

is at most . If there is an algorithm that given any instance , set , and integer , enumerates all elements of in time , then is said to be efficiently ()-uniform. In this case, the algorithm from [27] enumerates in time.

Theorem 7.

Let and be a polynomial time computable implicit set system.

If is -uniform, then for every instance .

If is efficiently -uniform, then there is an algorithm that, given as input, enumerates in time .

The original paper on Monotone Local Search [21] proved the theorem for .

Appendix C Oriented Translation

In this section we present the construction we use to transform directed graphs into oriented graphs (see Theorem 2) while preserving the preferred extensions.

This will be useful for lifting complexity results from directed graphs to oriented graphs. It is also used for automatically converting oriented graph algorithms into algorithms for general graphs parameterized by resolution order.

To remove special cases, we first present a translation that eliminates self loops from an AF. The only purpose of self loops is to prevent vertices from being included in admissible sets. Hence, we can replace self loops with attacks from an undefendable vertex.

Loopless Translation

Definition C.1 (Loopless Translation).

Let be an arbitrary AF. The loopless translation of is the graph where:

  • .

An example translation of can be found in Figure 2.

Figure 2: Loopless Translation of
Lemma 8.

The admissible extensions of are exactly the admissible extensions of the Loopless Translation of .

Proof.

The odd cycle among

ensures none of are in any admissible extension of . Hence can not be attacked in any admissible extension of . Hence, no vertex with a self loop in is in any admissible extension of .

Now it is straight forward to check is an admissible extension of if and only if it is an admissible extension of . ∎

We summarize the result as follows.

Lemma 9.

Let be an AF. Then there is a linear time algorithm that transforms into an AF , with , that has no self loops.

Furthermore there is an inclusion preserving bijection between the admissible extensions of and the admissible extensions of that can be applied in linear time.

This is why we assume in all other results that graphs have no self loops.

Simple Oriented Translation

For pedagogical purposes we first present an oriented translation that doubles the number of vertices. The full oriented translation algorithm follows from noting that only vertices in a 2-cycle need to be duplicated.

Our strategy is to replace each 2-cycle with a 4-cycle. However, a bit more care is necessary to ensure a bijection between preferred extensions in both graphs.

Definition C.2 (Simple Oriented Translation).

Let be an arbitrary AF. First apply the Loopless Translation (Definition C.1) to . Arbitrarily order the vertices in with a total order . For simplicity, relabel such that with . Let be the set of edges in that are in a 2-cycle. Then the simple oriented translation of is the graph where:

  • is the union of the following sets:

    • 4-cycle edges: .

    • Unidirectional edges: .

An example translation of can be found in Figure 3.

Figure 3: Simple Oriented Translation of

We need to show that has a few nice properties. First:

Lemma 10.

is oriented.

Proof.

This is clear from a case analysis on the edges of . ∎

Next, we want to show this translation nicely preserves preferred extensions. We first need a lemma controlling the structure of preferred extensions in .

Lemma 11.

Let be a preferred extension of . For any , if or are in , then both and are in .

Proof.

First we note so if is conflict-free with respect to , then is conflict-free with respect to .

We then note that every vertex attacking either also attacks or is attacked by . Hence if is acceptable with respect to , then so is .

Therefore if is admissible, then so is with respect to . Hence, by maximality, . This clearly also applies if . ∎

Now the main result:

Lemma 12.

Let be an AF. Let be the oriented AF obtained from applying the simple oriented translation on . Let be the following function from subsets of to subsets of :

Then is a bijection between the preferred extensions of and the preferred extensions of .

Proof.

It is clear that attacks both and . Hence is a bijection between the preferred extensions of and the preferred extensions of where . However Lemma 11 states that every preferred extension of satisfies this property. ∎

Full Oriented Translation

We have shown that the simple oriented translation does biject preferred extensions. We now optimize the translation which is necessary for our parameterized results.

Namely, if is not in any 2-cycles, then it is easy to see that and have the exact same in-neighbors and out-neighbors in . Hence, and are essentially identical and merging and into a single vertex still preserves all the above lemmas. Formally, an explicit construction of the oriented translation is:

Definition C.3 (Oriented Translation).

Let be an arbitrary AF. First apply the Loopless Translation (Definition C.1) to . Arbitrarily order the vertices in with a total order . For simplicity, relabel such that