Much of the formal study of algorithmic concerns with respect to semantics for abstract argumentation frameworks has focused on the issue of computational complexity. In contrast matters regarding computability have been largely neglected. Recent trends in semantics have, however, started to concentrate not so much on the formulation of novel semantics but more on identifying common properties: for example, from basic ideas such as conflict-freeness through to quite sophisticated ideas such as serializability.
The aim of this paper is to look at the implications these more recent studies have for computability rather than computational complexity.
Computational complexity, the focus of most formal work on algorithmic matters as these affect traditional semantics within abstract argumentation frameworks, see e.g. Dvorak and Dunne [3], addresses questions of limits on efficient solution methods. In this focus there is, usually unstated, an assumption that some form of solution method, i.e. algorithm, actually is possible. A far more fundamental concern, however, is that of computability: whether a given problem is capable of algorithmic solutions at all. Recently there has been an increasing interest in treatments of semantics through analysis of generic principle. Such work has its origins in Baroni and Giacomin [1]. In this, the central interest is not so much what makes a novel semantics distinct (and arguably useful) from previously proposed forms but rather on identifying features that all reasonable semantics ought to have in common. This approach raises a very general question: suppose we have some effective mechanism by which a semantics can be described, what is it possible in this case to say about recognising such properties computationally? The aim of the current paper is first formally to define this problem and then to establish some basic computational properties.
In some respects considering, in the context of abstract argumentation frameworks, questions such as “Is it possible to solve this problem (by an algorithm)?” rather than “Is it possible to solve this problem efficiently?” may seem strange. There are, however, good reasons for doing so. We can first note the historical significance of such questions: computability (or, as it is also referred to, recursive function theory) predates the first programmable computers by several decades: the question “Can this be solved algorithmically?” has a much longer history than its counterpart “Can this be solved by an efficient algorithm?”. Even if one accepts its historical importance, the possibility of unsolvable questions arising in the specific instance of argumentation frameworks seems unlikely and examples almost surely highly contrived and artificial: defined not so much as having a “real context” but more simply to demonstrate a point. Argumentation frameworks are directed graphs and treated, in all but a small body of work, as finite structures; in practical settings this finite aspect is always present. So if we are only concerned with the computational features of single finite objects then unsolvability is not a consideration: given a finite graph, an interpretable question about that graph’s properties (e.g. from “How many edges?” through to “What is the longest simple path between two nodes?”) we can always answer the question by an algorithmic method (albeit sometimes a rather lengthy one).
In summary, if questions of effective (as opposed to efficient) methods are going to arise, these will not be at the level of individual frameworks. Argumentation, however, has moved on from the realm of issues which can be related to a purely finite framework context. From its initial proposal, we have the concept of argument semantics as subsets of finite sets satisfying particular criteria. Here, again, we are still in a finite environment: semantics are sets of subsets, some subsets will meet the criteria and others will fail to do so. The core question becomes whether a given set meets the criteria with respect to a given framework. If this, the verification problem is computable then general issues of algorithmic solution do not arise since every question can be resolved, at worst, by explicit enumeration and piecemeal review of every subset. It is, of course, conceivable that “semantics” may be formulated in which such “list and check” methods would fail since the verification problem is itself undecidable. Yet, while imaginable as a mathematical conceit, it is hard to think of any such “semantics” arising in practice. Frameworks do not yield unsolvable questions, (practical) semantics (properties of frameworks), also fail to yield such problems. It is when we move one level higher, as is demonstrated in the present paper, and look at properties of semantics that computability becomes a non-trivial issue. Properties of classes of semantics (from the “principle based” proposal of Baroni and Giacomin [1] onwards) have proven to be an important simplification in shifting interest from a justification of novel approaches through “other proposals can’t do this” to “this approach has all of the benefits of earlier ideas and it can do this”. The principle-based analysis offers a subtle but significant direction in which novel semantics are treated. It is in this move from frameworks to properties of frameworks to properties of properties of frameworks that non-computability arises. One might ask, being aware of this issue, why computability should matter: mathematicians, after all, continue their efforts despite the implications of Gödel’s work. To be aware of the possibility of non-computability may avoid efforts to automate that which provably cannot be automated: for example, we cannot develop an algorithm that given a description of a semantics will determine whether that semantics respects the conflict-freeness principle.
The shifting from frameworks and semantics to properties of semantics does, however, raise one issue: how do we represent a property e.g. conflict-freeness in computational terms. Frameworks are directed graphs and their semantics, according to the criteria used, simply subsets of their arguments. Now it is certainly possible to enumerate all frameworks and their corresponding, say conflict-free sets. In studying computational properties of principles we need to capture an infinite range of possibilities by a finite form. The mechanisms that are needed to do so are, ultimately, those that lead to questions such as “Does this semantics σ respect this principle π?” being incapable of algorithmic solution.
The consequences of viewing properties of semantics from a computational perspective go further than basic uncomputability. If we consider the classical undecidable computational problem, The Halting Problem of Turing [7], which considers if encodings of programs will come to a halt on a given input, although undecidable in the sense that no algorithm exists which is guaranteed always to give a correct response in a finite time, there is at least a “partial decision method”: one which will recognise all positive instances. This is simply to simulate the program on its given input and report accept should this simulation end. For the classification of semantics we do not even have such partial decision methods: there is no effective algorithm guaranteed to recognise all positive (or all negative) instances. In formal language while cases such as The Halting Problem are recursively enumerable (although not recursive) natural semantic properties such as conflict-freeness fail even to be recursively enumerable.
We give preliminary background in Section 2. We assume the reader has some acquaintance with the concept of Model of Computation as captured by, among others, Turing Machines, Post Machines etc. Excellent introductory background concerning these may be found in Hopcroft, Motwani and Ullman [4] with more advanced discussion in Hopcroft and Ullman [5].
In Section 3 we present one method of encoding an argument framework and collection of subsets of its argument as a finite length binary sequence. Results are given in Section 5 and Section 6 with conclusions in Section 7.
An argumentation framework (af) is a pair where is a finite set of entities, called arguments, and a binary relation on . For any we say that p attacks q if .
We use the shorthand for an arbitrary framework where the argument and attack set are implicit.
Let be an argumentation framework, and . We define as , as , as , and as . The set S is said to be conflict-free if . A set S is said to defend x iff . The characteristic function is defined as .
Let be an argumentation framework. A subset S of is said to be:
an admissible set if S is conflict-free and
a complete extension if S is conflict-free and
a grounded extension if S is the smallest (w.r.t. ⊆) complete extension
a preferred extension if S is a maximal (w.r.t. ⊆) complete extension
For σ an arbitrary semantics (e.g. conflict-free, preferred, complete) the notation describes
It will be helpful to use the shorthand with for the predicate which takes the value ⊤ whenever . It is well known (as shown in Dung’s original paper [2]) that for any af, ,
A number of general principles for argumentation semantics have been presented in Baroni and Giacomin [1]. Among these are
A semantics σ respects τ if
We also have (in addition to the concept “a semantics σ respects a semantics τ”) that of a semantics σ respecting a principle π. For example, σ respects reinstatement if
An alphabet, Σ is a finite set of symbols, denotes the set of all finite length sequences of symbols (words) from Σ (including ε the empty word). A language, L over Σ is a subset of . The complement of a language L, denoted , is the language . A language is recursively enumerable (r.e.) (also called partially decidable) if there is a program, M, taking as an input and which halts and accepts w whenever . A language is recursive (or decidable) if both L and are r.e.
Since we may encode Turing Machine programs, M, as words (see for example, Hopcroft and Ullman [5, pp. 181–2]) we can define the set of all r.e. languages by
For a given program, M taking inputs from , is the subset of on which M will halt and report accept.
We can introduce the concept of property of a language simply via the set of Turing machine programs that accept languages with the property. That is if Π is some property (e.g. empty, infinite, contains only odd length words, etc) then .
Encodings in binary and their consequences
A device which we make extensive use of can be summarised in the following terms: we have a set of objects, ; we wish, uniquely, to describe these as words over . Since we can order the words in (e.g. use standard lexicographic ordering and the convention ) we can use such an ordering precisely to define “the first object in ”, “the second object in ” and generally the k’th object in : go through the words in in order, the first such word that describes a valid encoding will define the “first” object. In general the k’th word discovered that defines a valid encoding will be the k’th object. We thus have total functions over and :
Notice that,
Such schemes allow us to treat properties of structures as functions over .
As a simple example, consider the set
So that,
We can write as and hence since 00100 is the first word (in lexicographic order) that encodes an element of . Similarly , i.e. the pair
Argument frameworks
Since the names of arguments are unimportant it is only needed to describe the number of these. If , then is described by the word (i.e. a sequence of n 1s). This is followed by 00 to indicate that the next section of the encoding describes . An attack is an ordered pair with , hence we can encode such as separating distinct attacks with the sequence 00 and using the sequence 000 to indicate the end.
For example the af,
would be coded as 111001011001101110011010011101000.
In order to ensure uniqueness attacks are described with increasing order of source and increasing order of target for attacks with the same source.
Frameworks and sets of subsets of arguments, with
Let denote the set of all objects with .
We have the scheme used for afs above. Noting that is a list of some set of subsets of . Following the 000 indicating the final attack in for an arbitrary set in with the convention that the indices are given in increasing order. We use to code it. Sets are presented in increasing order of size and increasing value of argument index (sets of the same size being ordered lexicographically using the indices of members, e.g. before , before etc.)
Distinct sets in are separated by 00 and the end of the list by 000. For example to describe the system we would have 0010011100110111000. With the example we would encode the system as
Note that the empty set in is expressed as 000 (end of attack list token) immediately followed by 00 (next set in token). We also note the distinction encoded as (that is end of code 000; content of empty set 00; end of code 000) and coded as .
For the pair we use to denote its (unique) encoding as a binary word.
Power set constructions
Define the power set iteration operation, for applied to a (finite) set, S, as
Hence are successively S itself, the set of all subsets of S, the set of all subsets of the set of all subsets of S, and so on (more tersely S, , ).
For any finite S andthere is a total computable mapping
First note that . Order the sets in by increasing size (and “lexicographically” for sets of the same size). Consider the binary encoding of any whole number, w, with . We can use the value (0 or 1) of the ith bit to describe the presence (1) or absence (0) of the ith set in when describing a member of . Thus the whole number 0 describes the empty set (binary encoding as a string of 0s) while the whole number describes the set containing all members of (binary encoding as a string of 1s).
It should be clear that given any S, and we form and from any S, and recover the corresponding member of . □
Now it is not hard to see that we can also think in terms of numerical properties via functions, . For example describes “the number of conflict-free sets in ”.
We develop this notion more precisely in the next section.
Languages, predicates, and argument semantics
We have described a language L as a set of words over a finite alphabet (often ).
We have predicates, p, whose domain we consider to be the Natural numbers, .
An argument semantics, σ, we treat as a set of pairs with an af and so that , or equivalently that holds.
Superficially these may seem to be three quite distinct formalisms. One of the gains of the encoding mechanisms described in the previous section is in demonstrating that all are equivalent: we can treat a language, L, as a predicate or argument semantics ; we can go in the opposite direction and formulate from a predicate, p, languages over single character alphabets, and argument semantics . Finally we may move from an argument semantics, σ, to languages or predicates . The fact that encoding schemes over some collection of objects, can be ordered is a key tool here.
The purpose of this section is to describe these translations and introduce the notational conventions used in Section 5.
Languages to predicates and semantics
Let be the usual lexicographic ordering (with )
Suppose . The predicate has
The argument semantics, is described by
Predicates to languages and semantics
Given the language, corresponding to it has
The argument semantics has
Semantics to languages and predicates
If σ is an argument semantics the language is
The predicate has
Summary
A semantics, σ, has an associated predicate so that .
A semantics, σ, is described by a predicate, for which .
A predicate has an associated semantics for which .
Predicates, (regardless of their source) are languages, , of finite length single character words so that .
Decidability in argumentation semantics
In looking at properties of semantics from a computational perspective we would like these to have some desirable features, One such is given by the concept of verifiability.
A semantics, σ, is verifiable if there is a program, M, that given as input behaves as follows:
M checks that its input is valid, i.e. describes an af and a subset S of , rejecting if this is not the case.
M checks and rejects if .
Let σ be a verifiable semantics. The languageis recursive.
Consider the program, that does the following on input .
checks with rejecting if this is not the case.
For each , verifies rejecting if any is found.
For each , verifies rejecting if any is found.
If all of the tests in (1)–(3) succeed then accepts.
The program will accept any with and reject any with hence is recursive. □
The notion of “semantic properties”, as promoted in the principle-based concepts of Baroni and Giacomin [1], becomes rather more complicated. Suppose we have some property, π. We wish to formulate the question “does a semantics σ respect property π?” in computational terms, i.e. as a language of finite words.
We have shown in the previous section that any argumentation semantics describes a predicate over and such predicates define languages of words from a single character alphabet. In computational terms, we can therefore focus on the computation of languages, . Each such language offers an (admittedly usually highly artificial) argumentation semantics; every argumentation semantics (in the sense we have defined these) describes such a language. In computational terms we would only be interested in verifiable semantics, that is to say those for which the associated single character language, has a Turing Machine program, which recognises
We can code these Turing machine programs in binary and order these codes. In summary, a semantics property, π, is
There is, of course, a well-known issue with this approach, as exemplified in the next result.
There are semantics, σ, for which the languageis not recursive.
Suppose the contrary and that for every σ we have a Turing machine program that on input halts and reports ⊤ whenever and halts and reports ⊥ with all other instances. Define the predicate as
Here is the k’th Turing machine as given by the standard lexicographic ordering of TM codes with single symbol input alphabets. The predicate defines a semantics, as described in Section 4.2. From the starting assumption, the language is recursive and so there is a TM, that halts and reports ⊤ on instances for which and which halts and reports ⊥ on all other instances. Since is a TM program with a single symbol input alphabet there is some such that is the t’th codeword. What, however, is the value ? It cannot be ⊤ since by definition if ; similarly it cannot be ⊥ since this would only happen should . It follows that is not recursive. □
The proof technique, “diagonalization”, of Theorem 2 is one of the classical tools used in the study of properties of infinite structures and dates back to the late 19th century.
One consequence is,
There are semantics, σ, for which the languageis not recursively enumerable.
Let σ be a semantics. Define its complementary semantics, through the behaviour . The language , i.e . It is a well-known result from computability that if a language, L is not recursive then its complement is not r.e. This suffices to prove the claim. □
We could deal with each of the various semantic principles that have been proposed on a case-by-case basis. We can, however, proceed in a much more general style.
Let σ be any semantics. A blocking set for σ is a specific for which there are choices and with but , , being the afs with attack sets respectively .
The augmentation of σ by a blocking set is the semantics, denoted , defined as
For example for we could choose ; for , .
Let σ be a semantics with a blocking set. Suppose that π is a semantics property that σ respects butdoes not respect (for example conflict-freeness is respected bybut not by). Furthermore assume thatis infinite (i.e. there are infinitely instancessuch that).is not recursively enumerable.
The proof uses a technique adapted from the proof of Rice’s Theorem for r.e. properties, see Hopcroft and Ullman [5, Theorem 8.7, pp. 191–2].
It is known that the language
is not r.e. (see Hopcroft and Ullman [5, Theorem 8.4, p. 184])
Suppose the contrary and that for some such property within the conditions stated, π say, there is some program, accepting : that is , given , halts and accepts all instances for which respects the property π.
Let σ have property π but be such that does not.
With these .
Suppose we have an instance of and consider the semantics defined as follows. Given with we run a “pre-compilation” stage using a program Q.
Q simulates M running with input w. If M halts and accepts w then Q starts with , the encoding of a program accepting the language .
Regardless of what happens in (1) (e.g. this step could be performed in parallel) Q will run with input .
Now the semantics described by Q will correspond to in the event that and to should . Thus given an instance of we can using Q construct the code of program, taking as its inputs .
Suppose now that the property defined by were r.e.,
Then we build a program to recognise by
Given use Q to compile the code whose inputs are of the form .
Run with input .
Then will accept only if the semantics it describes corresponds to that is so contradicting the fact that is not r.e. □
The languages describing the following properties for a semantics, σ, are not recursively enumerable.
Conflict-freeness.
Reinstatement.
Admissibility.
Strong admissibility, i.e.and.
Naivety, i.e.and is a maximal (w.r.t. ⊆) set in.
Abstention, i.eifwith,then there is somewith.
I-maximality, i.e..
From Theorem 3, it suffices to identify σ, and an augmentation of σ by a blocking set in such a way that σ has the property of interest but does not.
, .
, .
, .
, .
, .
, .
,
□
The case of “abstention” is of interest since, of the standard argumentation semantics, only the complete semantics has this property (conventionally unique status semantics such as the grounded only “satisfy” abstention in a rather vacuous sense).
The results above are a consequence of the languages concerned i.e. “property of a semantics σ”, failing to satisfy one of the three necessary and sufficient conditions prescribed by Rice’s Theorem for r.e. properties. Namely, let be
If is r.e. and is such that is infinite then every r.e. with is in , i.e. the code with is in .
If is r.e. and is such that is infinite then there is a finite which is in , i.e. the code with is in .
The set of finite languages, L, such that can be enumerated. That is to say, there is a program which will produce the output in which is a list of all of the members of the i’th finite language (ordering is unimportant) and in which every finite language (eventually) will appear.
The languages , and fail to satisfy (RE1) (the so-called “containment property”). It is, however, possible to show these satisfy (RE2).
Let σ be a semantics that satisfieswhere. Let τ be the semantics with corresponding languageIf π is a semantic property that σ respecting π implies τ respecting π thensatisfies (RE2), i.e. for every infinite language with the property there is a finite subset with the property.
If then the condition indicates that . The language is finite by virtue of its corresponding afs having only finitely many arguments. □
A positive result
Although many of the semantic properties of interest yield non r.e. languages and hence fail even to be partially decidable, we can conclude by presenting what is in some ways, a rather surprising positive result. This arises in the technically sophisticated concept of serializability from Thimm [6].
We first need the concept of initial sets, which Xu and Cayrol [8] introduced as the non-empty S in such that
Letting denote the initial sets of , Thimm [6] groups initial sets into three classes.
unattacked initial sets S: those with .
unchallenged initial sets S: those for which and for all .
challenged initial sets S: those with and for which some has
For :
are the unattacked initial sets of .
the unchallenged initial sets of .
the challenged initial sets of .
The reduct of with respect to is the af, with arguments and attacks .
Finally the concept of a semantics being serializable is presented in Thimm [6].
Let σ be a semantics, i.e. a mapping from any to sets of subsets of .
A state is a pair with .
A selector is a function satisfying for all .
A terminator is any Boolean function β mapping states to .
A transition takes and and returns the state .
We write if the state results after a finite number of applications of α. If the state is terminal in which case we write .
Choose as selector function
Let the termination function be if and only if : hence the termination condition is such that the process of “select (using ) – apply transition (form the reduct)” leads to a framework with no initial sets. Using these Thimm [6] has shown that the preferred semantics are serializable. Changing the termination condition from “ if and only if ” to “”, that is irrespective of further conditions on the state , establishes that the admissibility semantics are serializable. In fact all of the cases in Definition 3 are serializable as also stable semantics (S is admissible with ). In contrast, however, neither semi-stable (S is admissible with maximal) nor ideal (S is admissible with every argument of S in every preferred extension) are serializable.
It is clear that
is verifiable, as also the associated semantics arising from unattacked, unchallenged and challenged initial sets. Recall that a state is a pair mapped by a selector function α whose arguments come from , and to a new state. We thus have
is recursive.
Recall that instances are pairs of states . Furthermore selectors, α, may be viewed as 4-tuples of whole numbers with . From Lemma 1 we can move between sets of subsets of and whole numbers in this range. Finally we note that starting from the 4-tuple we can consider each 4-tuple in turn ending at . It is thus possible systematically to review every selector function.
We do not, of course, propose the following algorithm as a practical method: it is solely to demonstrate the claim of the Theorem.
Given proceed as follows
Set the current state to be
Choose the next selector .
If the subsets corresponding to are not from go back to (b).
If the subset corresponding to t is not a subset of the union of those given by u, v, w go back to (b)
Let . Update the current state to .
If return to (b).
Recursively call the procedure with input .
If the result of (f) is accept then report accept otherwise return to (b)
If all selectors considered then reject.
Notice that the reduct operation reduces the number of arguments while the second state argument increases. Thus the recursive step at (g) will eventually terminate. □
Although Theorem 5 establishes the decidability of whether a selector function exists that moves from one state to another it is a little bit unsatisfactory in one regard: it can be shown that the preferred semantics is serializable via the selector a choice which is clearly effective. A selector function discovered by the procedure of Theorem 5 only identifies a sequence of transitions relevant to one framework.
Conclusions
Our main aim in this paper has been to consider a different aspect of algorithmics and argumentation semantics: that of decidability rather than computational complexity. The issue of whether algorithmic processes exist is not one that arises in typical environments: these will involve finite systems and deal with questions concerning specific semantics. Such semantics are matters that concern properties of finite sets of subsets of arguments. When, however, we start to consider argumentation semantics in the principle based terms promoted by, among others, Baroni and Giacomin [1] we face a new set of problems. In principle, it is always possible to analyze new proposals on an ad hoc basis in determining which desirable properties such have. Were it possible, however, to demonstrate adherence to given principle algorithmically such ad hoc approaches become redundant: codify the semantics in a form open to computational processing, present the codified form to a suitable program for analysis. We have shown that the main obstacle to this process is not the first aspect (finite codification of a semantics) but the second. The scale of unsolvability going beyond merely non-recursive (as in classical examples such as the Halting Problem of Turing [7]): in these when an instance is positive then it will, eventually, be accepted. Instead for semantic properties we face non-recursive enumerability: neither positive nor negative instances are guaranteed eventually to be recognized. The interplay between computation and argument semantics as described in Section 4 provides an insight into how powerful the notion of argument semantics is. Whether there are significant gains from this viewpoint is the object of study in future work.
References
1.
P.Baroni and M.Giacomin, On principle-based evaluation of extension-based argumentation semantics, Artificial Intelligence171(10–15) (2007), 675–700.
2.
P.M.Dung, On the acceptability of arguments and its fundamental role in nonmonotonic reasoning, logic programming and n-person games, Artificial Intelligence77 (1995), 321–357. doi:10.1016/0004-3702(94)00041-X.
3.
W.Dvorak and P.E.Dunne, Computational problems in formal argumentation and their complexity, in: Handbook of Formal Argumentation, College Publications, 2018, pp. 631–687.
4.
J.E.Hopcroft, R.Motwani and J.D.Ullman, Introduction to Automata Theory, Languages, and Computation, Addison–Wesley, 2001.
5.
J.E.Hopcroft and J.D.Ullman, Introduction to Automata Theory, Languages, and Computation, Addison–Wesley, 1979.
A.M.Turing, On computable numbers, with an application to the Entscheidungsproblem, Proceedings of the London mathematical society2(1) (1937), 230–265. doi:10.1112/plms/s2-42.1.230.
8.
Y.Xu and C.Cayrol, Initial sets in abstract argumentation frameworks, Journal of Applied Non-Classical Logics28(2–3) (2018), 260–279. doi:10.1080/11663081.2018.1457252.