A Mechanism for Reasoning over Defeasible Preferences in Arg2P ⋆ ⋆⋆ Giuseppe Pisano1[0000−0003−0230−8212] , Roberta Calegari1[0000−0003−3794−2942] , Andrea Omicini2[0000−0002−6655−3869] , and Giovanni Sartor1[0000−0003−2210−0398] 1 ALMA–AI Interdepartmental Center of Human Centered AI Dipartimento di Informatica – Scienza e Ingegneria (DISI) 2 Alma Mater Studiorum–Università di Bologna, Italy g.pisano@unibo.it, roberta.calegari@unibo.it, andrea.omicini@unibo.it, giovanni.sartor@unibo.it Abstract. This paper introduces argumentation over defeasible prefer- ences in Arg2P, an argumentation framework based on logic program- ming. A computational mechanism is first implemented in Arg2P accord- ing to Dung’s defeasible preference model, then generalised to enable arbitrary preference relations over arguments. Keywords: Argumentation · Defeasible preferences · Arg2P 1 Introduction This work focuses on argumentation with conditional preferences within the Arg2P (short for Arg-tuProlog) framework [10, 2]. The topic is already tackled from a theoretical perspective by various works – e.g., [11, 7, 8, 6] – but, to the best of our knowledge, a complete working implementation of this functional- ity does not exist, yet [1]. Dung et al. [6] cope with the problem of defeasible preferences while maintaining compatibility with the standard approach to the semantics of standard abstract argumentation [5]—thus providing the basis for the implementation. Accordingly, in this paper we discuss first of all an efficient implementation of the model presented in [6] along with some examples. Then, an improvement of the computational mechanism for dealing with de- feasible preferences is proposed in order to support a broader set of argument ordering relations—like the ones introduced in ASPIC+ weakest/last and eli- tist/democrat. The choice of ordering is very important in the construction of an argumentation framework, and it heavily depends on the application area. A higher number of supported orderings implies then a huge advantage in terms ⋆ G. Pisano, R. Calegari and G. Sartor have been supported by the H2020 ERC Project “CompuLaw” (G.A. 833647). A. Omicini has been supported by the H2020 Project “StairwAI” (G.A. 101017142). ⋆⋆ Copyright © 2021 for this paper by its authors. Use permitted under Creative Commons License Attribution 4.0 International (CC BY 4.0). of applicability of the tool. Since the original model [6] only supports a smaller set of orderings, and does not deal with aggregated preferences, the final goal of our generalisation is to overcome this limitation. The paper is structured as follows. Section 2 overviews background notions— i.e., the formal argumentation framework, the conditional preferences model, and the Arg2P language. Section 3 introduces the Arg2P implementation of the argumentation framework [6] along with some examples. Section 4 discusses the improvement of the previously implemented mechanisms enabling the use of the arguments orderings introduced in ASPIC+ [9]. Section 5 concludes the work. 2 Preliminary notions In the following we introduce the structured argumentation model adopted in Arg2P (Subsection 2.1)—an ASPIC+ -like argumentation system [5, 9]. Prefer- ences are introduced in Subsection 2.2 according to the model presented in [6]. Finally, the Arg2P language is discussed in Subsection 2.3. 2.1 Structured Argumentation Framework (AF) In this section we introduce the argumentation language, arguments and attack relations between them. As usual a literal is an atomic proposition or its negation. Notation 1 For any literal ϕ, its complement is denoted by ϕ̄. That is, if ϕ is a proposition p, then ϕ̄ = ¬p, while if ϕ is ¬p, then ϕ̄ is p. Literals are brought into relation through rules. Definition 1 (Rules). A strict rule r has the form: ρ : ϕ1 , ..., ϕn → ψ while a defeasible rule has the form: ρ : ϕ1 , ..., ϕn ⇒ ψ in both cases with 0 ≤ n, and where ρ is the unique identifier for r, denoted by N(r); each ϕ1 , . . . , ϕn , ψ is a literal; the set {ϕ1 , . . . , ϕn } is denoted by Antecedent(r) and ψ by Consequent(r). A strict rule is an expression indicating that if ϕ1 , . . . , ϕn hold, then without exception it holds that ψ. Strict rules are used for representing strict (sound) knowledge and are denoted with StrictRules. Defeasible rules – denoted with DefRules – are rules that can be defeated by contrary evidence. Pragmatically, a defeasible rule is used to represent defeasible knowledge, i.e., tentative infor- mation that may be used if nothing could be posed against it. For simplicity, we define axioms and non-axiom premises via strict and defeasible rules with empty Antecedent. A theory consists of a set of rules. Definition 2 (Theory). A defeasible theory is a tuple ⟨Rules⟩ where Rules ⊆ StrictRules ∪ DefRules. Arguments are built from strict and defeasible rules. Given the rules of a defea- sible theory, we can construct arguments by chaining them, as specified in the following definition, cf. [9]. Definition 3 (Argument). An argument A constructed from a defeasible theory ⟨Rules⟩ is a finite construct of the form: A : A1 , . . . , An →r ϕ or A : A1 , . . . , An ⇒r ϕ with 0 ≤ n, where – r is the top rule of A, denoted by TopRule(A); – A is the argument’s unique identifier; – A1 , . . . , An are A’s direct subarguments, denoted by DirectSub(A); – Sub(A) denotes the entire set of subarguments of A, i.e., Sub(A) = Sub(A1 )∪ . . . ∪ Sub(An ) ∪ {A}; – ϕ is the conclusion of the argument, denoted by Conc(A); – DefRules(A) is the set of defeasible rules exploited to build argument A – LastDefRules(A) is the set of the last defeasible rules exploited to build argu- ment A where  TopRule(A) if TopRule(A) is defeasible LastDefRules(A) = S An ∈DirectSub(A) LastDefRules(An ) otherwise Arguments can be in conflict, accordingly to two kinds of attack: rebuts and un- dercutting, defined as in [9]. We assume the postulates of consistency and closure for argument-based systems ensuring that strict rules cannot entail contradic- tory conclusions—i.e., we assume that 1) the set of strict rules is closed under transposition, and 2) the strict closure of the empty set is directly consistent [4]. Definition 4 (Attack). An argument A attacks an argument B at B ′ ∈ Sub(B) iff A undercuts or rebuts B (at B ′ ), where: (i) A undercuts B (at B ′ ) iff Conc(A) = ¬N(r) and B ′ s top rule r is defeasible; (ii) A rebuts B (at B ′ ) iff Conc(A) = ¬ϕ, Conc(B ′ ) = ϕ and B ′ ’s top rule r is defeasible. We say that an argument A directly rebuts (dbut) or directly undercuts (dcut) B if A rebuts or undercuts B at B itself. An argumentation graph can then be defined exploiting arguments and attacks. Definition 5 (Argumentation framework and graph). An argumenta- tion framework, aka also as abstract argumentation framework, constructed from a defeasible theory T is a tuple ⟨A, ⇝⟩, where A is the set of all arguments constructed from T , and ⇝ is the attack relation over A. The corresponding argumentation graph is the corresponding directed graph where: arcs are in- terpreted as attacks and nodes are arguments. The expression structured argumentation framework in the following spec- ifies that the internal construction of the arguments is provided in the framework (in particular as rules and their chaining). Notation 2 Given an argumentation graph G = ⟨A, ⇝⟩, we write AG , and ⇝G to denote the graph’s arguments and attacks respectively. We also write dbut⇝ and dcut⇝ to denote the set of direct rebuts and direct undercuts. 2.2 Preference-Based Argumentation Framework Dung et al. [6] introduce a conservative generalisation of structured argumen- tation frameworks aimed at dealing with arguments expressing preferences over rules. Based on that, in the following we define a preference-based argumentation framework. First, we define preference arguments and the corresponding set. Definition 6 (Preference Argument). A preference argument constructed from a defeasible theory T is an argument A such that Conc(A) has the form N (r1) ≺ N (r2) where r1 and r2 are in DefRules. Notation 3 (Preference Arguments Set) We denote the set of preference arguments in an argumentation framework with AP . Given the notion of preference arguments, we introduce the notion of Preference- Based AF (PAF) so as to reason over such arguments [6]. In short, a PAF is a transformation of a standard AF also accounting for preference arguments. This means to define how preference arguments interact with other arguments—i.e., how admissibility of one argument A ∈ AP impacts on others arguments, and more precisely, how the attack relation between these new arguments is defined. The key idea in [6] is to transform the AF direct attacks into arguments that can then be attacked and challenged by preference arguments. Then, conditional preferences attack these new arguments, thus challenging their effect. Converting attacks into arguments leads to the need of rebuilding the attacks set since new arguments have to be considered—namely, (a) attacks coming from attacks transformed into arguments, and (b) attacks involving preference arguments. Following this idea, in PAF the attack relation is built taking into account a) and b). With respect to a), existing AF direct attacks – i.e., dbut, dcut – are transformed into arguments and added to the argument set A. All the attacks belonging to the ⇝ set are transformed consistently. Notation 4 Let us denote with datt the set of all the attacks from transfor- mation “attacks into arguments”. Note that attacks in datt are attacks from old attacks transformed into arguments to either an original argument already exist- ing in AF or to an old attack also transformed into an argument. Example 1. For instance, let us consider an argumentation framework AF , with three arguments – A, B and B1 where Sub(B1 ) = {B} – and two attacks: one direct rebut from A to B, and one rebut attack from A to B1 . The transformation (point a)) only impacts the first attack (being a direct attack). A new argument AT T representing the attack from A to B is so added to the new argumentation framework (PAF), and consequently, also the corresponding attack from AT T to B. As concern the attack from A to B1 , it is not necessary to convert it into an argument – not being a direct attack – but it is enough to change the source of the B1 attack from A to AT T . The resulting argumentation framework PAF will be so composed of four arguments – namely A, B, B1 , AT T – and two attacks—one from AT T to B and one from AT T to B1 (see Fig. 1). Fig. 1. Standard argumentation graph (left) and transformed preference graph attack relation w.r.t. a) (right). With respect to b), new attacks are introduced, capturing the contrast between a preference argument and an attack argument—i.e., reifying the notion of a preference. The idea is that the preference for argument A over argument B is an attack against the view that B can successfully attack A: prevailed-over argu- ments cannot attack the prevailing ones. It follows that if a preference argument according to which A prevails over B is admissible, then the attack from B into A is rejected from the extension containing the preference argument. Notation 5 Let us denote with patt the set of all attacks from a single prefer- ence argument to an attack argument. Example 2. Let us consider the PAF from Example 1. Consider then a fourth argument P claiming the superiority of argument B over argument A—this is for the sake of simplicity since arguments actually express preferences over defeasible rules. With respect to b), this scenario would result in a new attack from P to AT T , where AT T is the argument representing the attack from A to B (Fig. 2). In fact, being B preferred to A, it would be impossible for the latter to attack the former. Fig. 2. Example 2 transformed preference graph attack relation w.r.t. a). Formally, a PAF is defined as (definition slightly modified w.r.t. the original one to match the general model introduced in Subsection 2.1): Definition 7 (Preference-Based AF). Given an argumentation framework T = ⟨A, ⇝⟩, a preference-based argumentation framework of T is an abstract argumentation framework F K = ⟨AT , ⇝T ⟩ where – AT = A ∪ dbut⇝ ∪ dcut⇝ , and – ⇝T = datt ∪ patt where: • datt ⊆ (dbut⇝ ∪ dcut⇝ ) × AT such that ((A, B), X) ∈ datt iff ∗ X ∈ A and B ∈ Sub(X), or ∗ X = (C, D) ∈ (dbut⇝ ∪ dcut⇝ ) and B ∈ Sub(C) • patt ⊆ A × dbut⇝ such that (X, (A, B)) ∈ patt iff ∃d ∈ LastDefRules(A) such that d < TopRule(B) ∈ Conc(X). The key point in the original work by [6] is the analysis of the relation used to identify the attacks in patt. This analysis is outside the scope of this paper being our analysis more focused on the computational properties of the AF to P AF transformation. Hence, for further details we point to the original work. Note that our definition of patt includes a specific use of preferences to determine (in) effective attacks, i.e., a rebutting attack fails if directed against a preferred rule in the attacked argument. 2.3 Arg2P syntax Arg2P [10] is a modular framework for structured argumentation based on logic programming [3]. In this section we briefly introduce the Arg2P language neces- sary for understanding the examples discussed in the paper. For a more detailed introduction of the tool please refer to [10]. In Arg2P, rules can be expressed by exploiting the operators =⇒ = {− > , =>} – where − > stands for strict implication while => for the defeasible one – with the notation: label : premise1 , . . . , premisen =⇒ conclusion. where label is the identifier (unique name) of a rule and premise1 , . . . , premisen are the premises that entail the conclusion. Accordingly, axioms/ defeasible axioms take the form: label : [] =⇒ conclusion. Premises and conclusions can take any form accepted in Prolog: i.e., all Prolog terms – e.g. atoms, variables, lists, compound terms – are allowed. The binary attack relation between arguments – which underpins rebutting attacks – can be reached via terms’ negation. Strong negation – negation as definite falsity – is encoded prepending the − operator to a term (i.e. −term). Undercut attacks can be expressed exploiting the notation: label2 : premise1 , . . . , premisen =⇒ undercut(label1 ) where label1 is the identifier of a defeasible rule in the the- ory. Preferences over rules can be expressed with the notation sup(r1, r2) where r1 and r2 are the rules unique identifiers. The Arg2P framework implements a graph-based mode providing as output the entire argumentation graph according to the specified semantics: the evaluation can be required via the buildLabelSets predicate. 3 Defeasible preferences mechanism in Arg2P The model presented in Subsection 2.2 is well-suited to be implemented in Arg2P: being it self-contained, it can be easily modularised and integrated with the ex- isting model. The transformation from AF to PAF fully generalises mechanisms and semantics used for standard argumentation frameworks, thus enabling the reuse of standard tools already implemented in the framework. Conceptually, we can handle the PAF model as a function F that, given an argumentation framework AF , returns a new argumentation framework BF . How we evaluate and handle framework BF w.r.t. AF is left unchanged. Accordingly, the imple- mentation of the model in Arg2P only requires the creation of a new optional module responsible for the framework’s transformation. Users can then deter- mine how to handle preferences, by combining the most suitable modules for the evaluation. The remainder of this section shows how function F is defined and implemented, according to the model in Subsection 2.2. 3.1 Transformation algorithm Listing 1.1. Transformation algorithm 1 ( PafArguments , PafAttacks ) B u i l d P a f A r g u m e n t a t i o n G r a p h ( Arguments , Attacks ): 2 % Filters attacks that are in no circumstances impacted by preference arguments 3 ( ValidAttacks , Inva lidAtt acks ) = f i l t e r S u p R e l a t e d A t t a c k s ( Attacks ) 4 % Transf ormati on point a ) converts the preference - related attacks into arguments , 5 % also transposing the connected attacks , datt set 6 ( NewArguments , NewAttacks ) = conver tAttac ks ( I nvalid Attack s ) 7 % Transf ormati on point b ) build the patt set 8 PrefAttacks = b u i l d P r e f A t t a c k s ( Arguments , NewArguments ) 9 % Returns the new arguments and attacks sets 10 PafArguments = append ( Arguments , NewArguments ) 11 PafAttacks = append ( ValidAttacks , NewAttacks , PrefAttacks ) 12 return ( PafArguments , PafAttacks ) Listing 1.13 shows the pseudo-code of the algorithm used in transforming AF to PAF—i.e., the encoding of the function F . First of all, attacks are split into two sets: non influent attacks for the pur- pose of transformation – i.e., attacks not affected by preferences, that can be translated as-is in the final framework ValidAttacks – and attacks that should be considered as invalid and thus transformed— InvalidAttacks (line 3 Listing 1.1). After that, the transformation of the framework begins. First, direct attacks are converted into arguments also adding the new derived attacks—point a) of the transformation (see Subsection 2.2) (line 6 Listing 1.1). Then, conforming to the transformation point b) (see Subsection 2.2) attacks from preference ar- guments to the newly created attack arguments are built, always in accordance to the preference attack relation—line 8 Listing 1.1. Note that w.r.t. the original algorithm, the filtering of the attacks (line 3 in Listing 1.1) is introduced in order to enhance the comprehensibility of the final graph and improve the computational performance. The set (dbut⇝ ∪ dcut⇝ ) is filtered to exclude from the transformation those attacks not referenced by an element in patt; then the transformation is applied only to the InvaildAttacks subset, while the remaing ValidAttacks are transposed as-is in the final graph. From a computational perspective, the graph is kept as small as possible and most faithful to the original, thus avoiding useless transformations. 3 Sources and technical details are available on the official project page http://arg2p.apice.unibo.it Proposition 1. The transformation algorithm in 1.1 is sound w.r.t. the model in Subsection 2.2 by [6]. Proof. The transformation algorithm is almost completely faithful to the original model, then assuring the soundness of its results w.r.t. the original. The only difference is in the filtering part, where we avoid transforming those attacks not influenced by any preference. It is easy to prove the introduced optimisation does not impact the general soundness of the transformation algorithm. It is already proved in [6] that a PAF, in absence of preference arguments, delivers the same results of a standard AF. As a consequence, if an attack does not interact with a preference argument, it is irrelevant if it has been transformed or not. Thus, the filtering of the irrelevant attacks does not impact the final outcome of the evaluation w.r.t. the not filtered graph. Example 3. Let us consider the Sherlock Holmes example proposed in [6]. A murder investigation involving three persons – namely p1, p2 and s – is consid- ered. It is known for sure that the murderer acted alone, s was physically unable to kill the victim, and p1 benefited from the murder. Listing 1.2. Example 3 rules in Arg2P r1 : inno ( p1 ) , inno ( s ) -> - inno ( p2 ). r2 : inno ( p2 ) , inno ( s ) -> - inno ( p1 ). r3 : inno ( p1 ) , inno ( p2 ) -> - inno ( s ). r4 : beneficiary ( p1 ) -> have_motive ( p1 ). r5 : beneficiary ( p2 ) -> have_motive ( p2 ). pi1 : have_motive ( p1 ) , - have_motive ( p2 ) -> sup ( d2 , d1 ). pi2 : - have_motive ( p1 ) , have_motive ( p2 ) -> sup ( d1 , d2 ). d : [] = > inno ( s ). d1 : [] = > inno ( p1 ). d2 : [] = > inno ( p2 ). d3 : [] = > - have_motive ( p1 ). d4 : [] = > - have_motive ( p2 ). f1 : [] -> inno ( s ). f2 : [] -> beneficiary ( p1 ). Listing 1.2 shows the Arg2P encoding of the case. Strict rules r1, r2, and r3 encodes the fact that only one of the suspects can be the murderer—i.e., if two of them are innocent, then the third is guilty. Strict rules r4 and r5 derive the motivation to murder from the possible benefits. Five unconditional defeasible rules work as assumptions: d, d1, and d2 encode the principle on which persons are innocent unless proven guilty; d4 and d5 assume that p1 and p2 have both no motive to kill. There are also two facts, f1 and f2, asserting the knowledge on s’ innocence (f1) and p1 ’s profit from the murder (f2). Finally, two additional strict rules – pi1 and pi2 – conclude a preference over rules. In particular, if p1 had a motivation to kill while p2 had not, then the assumption on p2 ’s innocence is stronger than p1 ’s one (pi1). Conversely, if p1 hadn’t a motive to kill while p2 had, then the favours are on p1 ’s innocence (pi2). Fig. 3 shows the evaluation results under the grounded semantic in a standard argumentation framework – i.e., with no defeasible preferences handling – while Fig. 4 shows the results with the transformation module enabled. As expected, without any preference on the rules the graph remains undecided—it is not possible to decide on arguments concluding inno(p1)(inno(p2)) and ¬inno(p1) A0 : f2 =⇒ beneficiary ( p1 ) A7 : A0 , r4 =⇒ have_motive ( p1 ) A1 : d1 =⇒ inno ( p1 ) A8 : A2 , A4 , r2 =⇒ - inno ( p1 ) A2 : d2 =⇒ inno ( p2 ) A9 : A2 , A3 , r2 =⇒ - inno ( p1 ) A3 : d =⇒ inno ( s ) A10 : A1 , A4 , r1 =⇒ - inno ( p2 ) A4 : f1 =⇒ inno ( s ) A11 : A1 , A3 , r1 =⇒ - inno ( p2 ) A5 : d3 =⇒ - have_motive ( p1 ) A12 : A1 , A2 , r3 =⇒ - inno ( s ) A6 : d4 =⇒ - have_motive ( p2 ) A13 : A7 , A6 , pi1 =⇒ sup ( d2 , d1 ) Fig. 3. Arguments from Listing 1.2 with conditional preference disabled. A0 : f2 =⇒ beneficiary ( p1 ) A8 : A13 , attack =⇒ attack ( A13 , A2 ) A1 : d1 =⇒ inno ( p1 ) A9 : A0 , r4 =⇒ have_motive ( p1 ) A2 : d2 =⇒ inno ( p2 ) A10 : A2 , A3 , r2 =⇒ - inno ( p1 ) A3 : d =⇒ inno ( s ) A11 : A2 , A4 , r2 =⇒ - inno ( p1 ) A4 : f1 =⇒ inno ( s ) A12 : A1 , A3 , r1 =⇒ - inno ( p2 ) A5 : d3 =⇒ - have_motive ( p1 ) A13 : A1 , A4 , r1 =⇒ - inno ( p2 ) A6 : d4 =⇒ - have_motive ( p2 ) A14 : A1 , A2 , r3 =⇒ - inno ( s ) A7 : A12 , attack =⇒ attack ( A12 , A2 ) A15 : A9 , A6 , pi1 =⇒ sup ( d2 , d1 ) Fig. 4. Arguments from Listing 1.2 with conditional preference enabled. (¬inno(p2)). Conversely, after enabling defeasible reasoning on preferences, it is possible to decide for p2 ’s innocence, thus condemning p1. The latter result is caused by argument A15 (Fig. 4). The claimed preference of d2 over d1 impacts only two direct rebuts: the one from A14 to A2 and the one from A13 to A2. Consequently, these are the only attacks transformed into arguments (A7 and A8 )—filtering of the transformation algorithm. The attacks coming from these two arguments are the same: they attack argument A2 and all its derived arguments (A10, A11 and A14 ). If we evaluate the graph, we have that the preference argument (A15 ) is undisputed. It follows the rejection of the two attack arguments A7 and A8 and the admissibility of argument A2 on p2 ’s innocence. The rest of the graph is computed accordingly. Example 4. We now consider an example of preference reasoning from [11] show- ing a case of multiple nested preferences. Listing 1.3 shows the Arg2P theory. A0 : r0 =⇒ a A1 : r3 =⇒ -a A2 : r4 =⇒ sup ( r0 , r3 ) A3 : r5 =⇒ sup ( r3 , r0 ) A4 : r6 =⇒ sup ( r5 , r4 ) A5 : A0 , attack =⇒ attack ( A0 , A1 ) A6 : A1 , attack =⇒ attack ( A1 , A0 ) A7 : A2 , attack =⇒ attack ( A2 , A3 ) A8 : A0 , r1 =⇒ b Fig. 5. Arguments from Listing 1.3 with conditional preference enabled. Listing 1.3. Example from [11] in Arg2P r0 : [] = > a . r1 : a => b. r3 : [] = > -a . r4 : [] = > sup ( r0 , r3 ). r5 : [] = > sup ( r3 , r0 ). r6 : [] = > sup ( r5 , r4 ). Two unconditional rules are stated – r0 and r1 – concluding the two conflicting literals a and ¬a. Then a defeasible rule (r1) claims b if a is proved, and three unconditional rules conclude a preference: r4 concluding the priority of r0 over r3, the priority of r3 over r0 (r5) and the priority of r5 over r4 (r6). Taking into account no preference, the evaluation under the grounded seman- tic is undecided: arguments for a and ¬a rebut each other and consequently also the one concluding b is undecided. Intuitively, r5 states the strength of the ¬a claim and r6 enforces this priority against the one in r4. Accordingly, we expect the argument for ¬a to be accepted thus rejecting the opponent arguments. Fig. 5 shows the PAF built on the theory and its evaluation under the grounded semantic. Argument A1 for ¬a is accepted—thus causing the rejec- tion of arguments A0 (a) and A8 (b). The accepted preferences are two: the one on r5 over r4, that is undisputed, and the one on r3 over r0. As a consequence, the attack from argument A2 to A3 (argument A7) and the one from A0 to A1 (argument A5) are both rejected. 4 Generalising the reasoning mechanism The main limitation of the model described in Subsection 2.2 is the impossibility of dealing with attacks coming from a set of preferences, a.k.a. group preference attacks: preference attacks are only allowed from a single preference to an attack. The issue is well known in the literature and already discussed in papers dealing with defeasible preferences, see for instance [8] where an extended argumentation framework handling group attacks is proposed. The problem was also tackled in the work by Modgil [7], where authors leverage a sort of super-arguments to join preferences. This approach was then refined in the logical model proposed in [8]. We believe that the super-argument approach could be an optimal solution to integrate group preference attacks in the Arg2P framework. The extension of the computational mechanism under this perspective requires just a minor mod- ification to the transformation algorithm (listing 1.1), maintains all the compu- tational properties of the standard implementation, and allows overcoming the limit of the model in Subsection 2.2. Hence, following the insights from [7], we propose a generalisation of the already-presented reasoning mechanism coping with the group preference attack problem and thus enabling the use of differ- ent arguments ordering relations. In a nutshell, we leverage artificial arguments joining sets of preferences. Attacks come no more directly from preferences but are issued from these artificial arguments. In the following, we examine in detail our approach with some examples. We cannot here address the corresponding extension of the formal model of Subsection 2.2, which we leave to future works. 4.1 The new algorithm In the model discussed in Subsection 2.2 attacks ∈ patt can be expressed in the form (X, (A, B)), where X is a preference argument and (A, B) is an attack transformed into an argument. In the mechanism generalisation X is no longer a preference argument but rather an artificial argument constructed from the involved preference arguments. In order to cope with such an extension, we first introduce the grouped preference set AGP defined as: Definition 8 (Grouped Preference Set). Given a set of preference argu- ments AP in an argumentation framework, the set of all the possible subsets of AP , i.e., AGP = 2AP is the grouped preference set.+ Based on grouped preference set, we define a further kind of argument comple- menting definition 3. Definition 9 (Joint preferences argument). Every argument set A ∈ AGP is called a joint preferences argument. The direct subarguments of a joint preferences argument A are all preference arguments X ∈ A . We also say that an argument A is preferred to an argument B according to the preferences in a joint preferences argument X ∈ AGP with the notation ≻X . Then, we modify definition 7 as follows: Definition 10 (Generic Preference-Based AF). Given an argumentation framework T = ⟨A, ⇝⟩, a generic preference-based argumentation frame- work (GPAF) of T is an abstract argumentation framework F K = ⟨AT , ⇝T ⟩ where – AT = A ∪ dbut⇝ ∪ dcut⇝ ∪ AGP , and – ⇝T = datt ∪ patt where: • datt ⊆ (dbut⇝ ∪ dcut⇝ ) × AT such that ((A, B), X) ∈ datt iff ∗ X ∈ A and B ∈ Sub(X), or ∗ X = (C, D) ∈ (dbut⇝ ∪ dcut⇝ ) and B ∈ Sub(C) • patt ⊆ AGP × dbut⇝ such that (X, (A, B)) ∈ patt iff B ≻X A. Intuitively, we add to the arguments all the existing preference aggregations in AGP . Then, attacks in patt are not determined by single arguments (elements of AP ) but by joint preferences arguments (elements of AGP ). If we consider once again Example 2, the corresponding GPAF would contain a new argument AP with P as direct subargument, and the preference attack would come from AP and not from P as in the standard PAF (Fig. 6). Fig. 6. PAF (left) and transformed GPAF (right). A0 : f2 =⇒ beneficiary ( p1 ) A9 : A0 , r4 =⇒ have_motive ( p1 ) A1 : d1 =⇒ inno ( p1 ) A10 : A16 , pref =⇒ m e r g e d P r e f e r e n c e A2 : d2 =⇒ inno ( p2 ) A11 : A2 , A3 , r2 =⇒ - inno ( p1 ) A3 : d =⇒ inno ( s ) A12 : A2 , A4 , r2 =⇒ - inno ( p1 ) A4 : f1 =⇒ inno ( s ) A13 : A1 , A3 , r1 =⇒ - inno ( p2 ) A5 : d3 =⇒ - have_motive ( p1 ) A14 : A1 , A4 , r1 =⇒ - inno ( p2 ) A6 : d4 =⇒ - have_motive ( p2 ) A15 : A1 , A2 , r3 =⇒ - inno ( s ) A7 : A13 , attack =⇒ attack ( A13 , A2 ) A16 : A9 , A6 , pi1 =⇒ sup ( d2 , d1 ) A8 : A14 , attack =⇒ attack ( A14 , A2 ) Fig. 7. Evaluation of Example 3 with the extended mechanism and the original PAF’s preference attack relation. Proposition 2. The generic Preference-Based AF is a conservative generalisa- tion of a PAF when maintaining the PAF preference-attack relation. Proof. Let us consider a PAF. For each A ∈ patt such that A = (X, (B, C)) a new argument {X} ∈ AGP is built, and the patt set is modified accordingly—i.e., (patt−A)∪{({X}, (B, C)}. We have to prove that the modified graph delivers the same results as the original one. Since {X} like any argument in AGP cannot be directly rebutted/undercut, (being artificially added to the argumentation framework) status of {X} in GPAF is the same as that of X in PAF, since X is the only direct subargument of {X}. It follows that the PAF evaluation remains unaltered w.r.t. the initial transformation. W.r.t. the algorithm presented in Subsection 3.1, the new transformation involves an improved filtering strategy – taking into account preferences’ com- bination – and an extended construction of preference attacks. Indeed, the con- struction of the preference attacks should return also the artificial arguments— containing also the attacks derived from their sub-arguments. Fig. 7 shows the evaluation of Example 3 with the generalised algorithm and the original PAF’s preference attack relation. As expected, the result is analogous to Fig. 4, the only difference is the preference attack origin. While in the original A0 : f2 =⇒ beneficiary ( p1 ) A8 : A0 , r4 =⇒ have_motive ( p1 ) A1 : d1 =⇒ inno ( p1 ) A9 : A15 , pref =⇒ m e r g e d P r e f e r e n c e A2 : d2 =⇒ inno ( p2 ) A10 : A2 , A4 , r2 =⇒ - inno ( p1 ) A3 : d =⇒ inno ( s ) A11 : A2 , A3 , r2 =⇒ - inno ( p1 ) A4 : f1 =⇒ inno ( s ) A12 : A1 , A4 , r1 =⇒ - inno ( p2 ) A5 : d3 =⇒ - have_motive ( p1 ) A13 : A1 , A3 , r1 =⇒ - inno ( p2 ) A6 : d4 =⇒ - have_motive ( p2 ) A14 : A1 , A2 , r3 =⇒ - inno ( s ) A7 : A12 , attack =⇒ attack ( A12 , A2 ) A15 : A10 , A6 , pi1 =⇒ sup ( d2 , d1 ) Fig. 8. Example 3 evaluation with the modified algorithm and the weakest democrat argument ordering. model A15 directly attacks arguments A7 and A8, in the generalised mechanism (Fig. 7) the artificial argument A10 is the source of the attack. From a technical perspective, the improved reasoning mechanism enables dif- ferent arguments orderings while evaluating the argumentation graph. The eval- uation under different orderings could no longer adhere to the assumptions in [6]. However, some application scenarios can consider the loosening of such assump- tions, therefore exploiting other types of ordering. For instance, let us consider the orderings introduced in [9]. The authors bear the idea that – abstracting from the specific properties – the choice of an argument ordering is deeply connected to the application scenario. For example, the weakest link principle – according to which all the defeasible steps an argument construction should be considered in the ordering – could be more suited to empirical reasoning scenarios. Let us consider the application of the weakest-link democratic ordering [9] to Example 3. In a nutshell, in the weakest democrat ordering, an argument A is preferred to an argument B if for every defeasible rule r used to build B, there is a preference of the form r1 ≻ r, with r1 an A’s rule. Fig. 8 shows the evaluation results. Using this ordering, preference on d2 over d1 is not enough to conclude p2 ’s innocence. In fact, while this preference is enough to conclude the superiority of argument A2 on A12, the same does not hold for argument A13, since it based also on the defeasible rule d. The example demonstrates the flexibility of the mechanisms presented in this section. Example 5. Let us now consider an example exploiting joint preference argu- ments containing a combination of preferences—Listing 1.4. The theory contains two unconditional rules – r0 and r2 – concluding the two literals a and ¬b. Then a defeasible rule (r1) claims b if a, and two unconditional rules conclude a pref- erence: r3 concluding the priority of r2 over r1, and r4 concluding the priority of r2 over r0. The GPAF evaluation with the weakest-link democratic ordering and grounded semantic is: accepted for ¬b (A1) and rejected for b (A5) (Fig. 9). Listing 1.4. Example 5 theory r0 : [] = > a . r1 : a => b. r2 : [] = > -b . r3 : [] = > sup ( r2 , r1 ). r4 : [] = > sup ( r2 , r0 ). A0 : r0 =⇒ a A1 : r2 =⇒ -b A2 : r4 =⇒ sup ( r2 , r0 ) A3 : r3 =⇒ sup ( r2 , r1 ) A4 : A5 , attack =⇒ attack ( A5 , A1 ) A5 : A0 , r1 =⇒ b A6 : A2 , A3 , pref =⇒ m e r g e d P r e f e r e n c e Fig. 9. Arguments from Listing 1.4 with conditional preferences enabled. A6 is the joint preference argument which combines the preferences expressed by r4 (A2) and r3 (A3). 5 Conclusions In this paper we show how the conditional preferences mechanism from [6] can be implemented in Arg2P, then improved in order to cope with arbitrary preference relations over arguments. The work can be expanded in various ways, starting from a full theoreti- cal foundation of the model. From a pure computational perspective, the work needs further analysis w.r.t. the themes of (i) computational complexity and (ii) termination—i.e., prove if the algorithms always guarantee a solution or graph configurations leading to undecidable state exist. While have no final result on complexity (i), it should be polynomial w.r.t. the number of input attacks for both the algorithms. Algorithms are based on two main operations: the transfor- mation of the attacks in arguments – linear w.r.t. the number of attacks – and the recognition of the new pref-attacks – requiring in the worst case the examination of all the preference arguments for every attack. So, in the worst case, the com- plexity should be O(2N ∗ P A), where N is the number of the input attacks and P A is the number of preference arguments. Termination (ii) is deeply connected with formal foundation of the model, hence it will be tackled after its comple- tion. Nonetheless, initial informal analysis suggests a transformed graph should be always be obtainable by the proposed algorithms. However, the soundness of solutions provided by the transformed argumentation graph must be proved, in particular w.r.t. corner configurations. In fact, PAF properties hold only when the defeasible theory respects some constraints [6]—a.k.a. as preference strat- ification, or p-stratification. Basically, it is required to ensure partial ordering over rules concluding a preference to avoid cycles in the inference chain—i.e., a preference should not influence the rules it derives from. We also intend to extend this work towards Arg2P’s query-based mode [10]. Intuitively, it would be enough to evaluate also preference arguments that con- tribute to the patt set while evaluating an attacking argument. Further and deeper investigations are required in order to prove its feasibility. References 1. Calegari, R., Contissa, G., Lagioia, F., Omicini, A., Sartor, G.: Defeasible systems in legal reasoning: A comparative assessment. In: Legal Knowledge and Information Systems. JURIX 2019: The Thirty-second Annual Conference, Frontiers in Arti- ficial Intelligence and Applications, vol. 322, pp. 169–174. IOS Press (11-13 Dec 2019). https://doi.org/10.3233/FAIA190320 2. Calegari, R., Contissa, G., Pisano, G., Sartor, G., Sartor, G.: Arg-tuProlog: a modular logic argumentation tool for PIL. In: Legal Knowledge and Informa- tion Systems. JURIX 2020: The Thirty-third Annual Conference. Frontiers in Artificial Intelligence and Applications, vol. 334, pp. 265–268 (9-11 Dec 2020). https://doi.org/10.3233/FAIA200880 3. Calegari, R., Omicini, A., Sartor, G.: Explainable and ethical AI: A perspective on argumentation and logic programming. In: AIxIA 2020 – Advances in Artificial Intelligence, Lecture Notes in Computer Science, vol. 12414, pp. 19–36. Springer Nature (2021). https://doi.org/10.1007/978-3-030-73065-9_2 4. Caminada, M., Amgoud, L.: On the evaluation of argumenta- tion formalisms. Artificial Intelligence 171(5-6), 286–310 (2007). https://doi.org/10.1016/j.artint.2007.02.003 5. Dung, P.M.: On the acceptability of arguments and its fundamental role in non- monotonic reasoning, logic programming and n-person games. Artificial Intelligence 77(2), 321–358 (1995). https://doi.org/10.1016/0004-3702(94)00041-X 6. Dung, P.M., Thang, P.M., Son, T.C.: On structured argumentation with conditional preferences. In: The Thirty-Third AAAI Conference on Ar- tificial Intelligence, AAAI 2019. pp. 2792–2800. AAAI Press (2019). https://doi.org/10.1609/aaai.v33i01.33012792 7. Modgil, S.: Reasoning about preferences in argumentation frameworks. Artificial Intelligence 173(9-10), 901–934 (2009). https://doi.org/10.1016/j.artint.2009.02.001 8. Modgil, S., Prakken, H.: Reasoning about preferences in structured extended ar- gumentation frameworks. In: Computational Models of Argument: Proceedings of COMMA 2010. Frontiers in Artificial Intelligence and Applications, vol. 216, pp. 347–358. IOS Press (2010). https://doi.org/10.3233/978-1-60750-619-5-347 9. Modgil, S., Prakken, H.: The ASPIC + framework for structured ar- gumentation: a tutorial. Argument Computation 5(1), 31–62 (2014). https://doi.org/10.1080/19462166.2013.869766 10. Pisano, G., Calegari, R., Omicini, A., Sartor, G.: Arg-tuProlog: A tuProlog-based argumentation framework. In: Calimeri, F., Perri, S., Zumpano, E. (eds.) CILC 2020 – Italian Conference on Computational Logic. CEUR-WS, vol. 2719, pp. 51– 66 (13-15 Oct 2020), http://ceur-ws.org/Vol-2710/paper4.pdf 11. Prakken, H., Sartor, G.: Argument-based extended logic programming with de- feasible priorities. Journal of Applied Non-Classical Logics 7(1), 25–75 (1997). https://doi.org/10.1080/11663081.1997.10510900