Limits and Possibilities of Forgetting in Abstract Argumentation

1 Introduction

The notion of forgetting has been extensively studied in the field of knowledge representation and reasoning for many major formalisms like classical logic [Lin and Reiter, 1994], logic programming [Gonc¸alves et al., 2016a; Eiter and Kern-Isberner, 2018] and more recently for abstract argumentation [Baumann et al., 2020]. Roughly speaking, forgetting is about getting rid of some variables, atoms or arguments while keeping as much as possible of the reasoning not concerned with the forgotten. The ability of forgetting is often exploited to make reasoning more efficient. In this paper we want to further elaborate the limits and possibilities of forgetting in abstract argumentation. The latter is a vibrant research area in AI [Simari and Rahwan, 2009; Baroni et al., 2018a] with Dung-style argumentation frameworks (AFs) and their associated semantics at the heart of this field [Dung, 1995] .

In order to obtain reasonable forgetting operators for abstract reasoning we may try to convey ideas from other formalisms. The area of logic programming with its plenty of approaches to forgetting is a good candidate (cf. [Gonc¸alves et al., 2016b] for an excellent overview). However, the following two examples show that forgetting in abstract argumentation cannot be reduced to forgetting in logic programming in a straightforward manner.

Example 1 (Limits of the Standard Translation). Consider the following AF F . We have stb(F) = {{b, d}}. Assume now that we want to forget the argument b. Hence, one reasonable forgetting result is thus an AF F ′ , s.t. stb(F ′ ) = {{d}}. Note that simply deleting b would yield an AF Fb, s.t. stb(Fb) = {{a, d}}. This means, such a syntactical removal would render the previously unaccepted argument a acceptable.

Let us consider instead the standard translation from AFs to LPs [Strass, 2013]. This yields the following equivalent logic program P.P ∶ a ←not b

Now we may apply the already defined forgetting operator fSP [Berthold et al., 2019b]. More precisely, forgetting b from P results in fSP (P, b) as given below.

Unfortunately, fSP (P, b) is a non-AF-like program. Therefore, it is generally not possible to simply reverse the standard translation. However, in case of fSP(P, b) we may find an equivalent LP P ′ which is indeed AF-like.

Retranslating P ′ to the realm of AFs results in F ′ . Note that stb(F ′ ) = {{d}} as desired.

Example 2 (Representational Limits). Consider now the slightly more involved AF F. We observe stb(F) = {{a, e, f }, {b, f, d}, {c, d, e}}.

Let us assume again that we want to forget the argument b. The favored forgetting result is thus the extension set D = {{a, e, f}, {f, d}, {c, d, e}}. Since D forms a ⊆-antichain there is an LP P realizing it [Eiter et al., 2013]. However, we will never find an equivalent AF-like LP P ′ since D does not satisfy so-called tightness [Dunne et al., 2015]. In particular, {f, d} ∪ {e} ∉ D but {e, f} ⊆ {a, e, f} and {d, e} ⊆ {c, d, e}.

The final example deals with forgetting multiple arguments. It reveals that this task cannot be simply reduced to forgetting single arguments.

Example 3 (Forgetting Sets vs. Arguments). Consider the following AF F. We have stb(F) = {{x, b, e}, {a, c, d}, {a, c, e}}. Assume that we want to forget a set of arguments, say {x, b}. One reasonable forgetting result is thus an AF F ′ , s.t. stb(F ′ ) = {{a, c, d}, {a, c, e}} = D.

One natural approach for forgetting multiple arguments is to iteratively apply an existing forgetting operator for single arguments. The following frameworks illustrate this procedure for the operator f firstly presented in [Baumann et al., 2020, Algorithm 1, Example 4].

The three examples above show that we need further investigation on how sets of arguments can be forgotten in case of AFs. As a consequence we provide a systematic and comprehensive analysis of forgetting desiderata and associated operations adapted to the intrinsics of abstract argumentation. We hereby draw a lot of inspiration from logic programming. We show the limits and shed light on the possibilities. In particular, we study the relations between desiderata, their individual as well as combined satisfiability and look for promising combinations. Moreover, we consider forgetting under stable semantics as it shows a quite different behavior regarding the fulfillment of combined desiderata. Finally, we conclude and discuss related work.

2 Background

2.1 Logic Programming

Syntax and Semantics A logic program P over a propositional signature U [Lifschitz et al., 1999] is a finite set of rules of the form a1 ∨ . . . ∨ ak ← b1, ..., bl, not c1, ...,not cm, notnotd1, ...,notnotdn. For such a rule r let H(r) = {a1, . . . ak}, B + (r) = {b1, . . . , bl}, B - (r) = {c1, . . . , cm} and B -- (r) = {d1, . . . , dn}. We define U(P) = ⋃r∈P H(r) ∪ B + (r) ∪ B - (r) ∪ B -- (r).

A set of atoms I ⊆ U is called an interpretation. The reduct of P w.r.t. I is given as P I = {H(r) ← B + (r) ∣ r ∈ P,B - (r) ∩ I = ∅,B -- (r) ⊆ I}. An interpretation I is an answer set of P if I ⊧ P, where ⊧ is the classical satisfaction relation, and for each interpretation I ′ we have: If I ′ ⊧ P I , then I ′ /⊂ I. The set of all answer sets of P is denoted by AS(P). Two programs P1,P2 are equivalent if AS(P1) = AS(P2) (P1 ≡ P2) and strongly equivalent, whenever AS(P1∪R) = AS(P2∪R) for any program R (P1 ≡s P2) [Lifschitz et al., 2001]. Given a set V ⊆ U, the V -exclusion of a set of answer setsM, denotedM∥V , is {X\V ∣ X ∈M}.

Forgetting: Desiderata and Operators Let P be the set of all logic programs over U. A forgetting operator is a (partial) function f ∶ P × 2U → P with (P,V ) ↦ f(P,V ). The program f(P,V ) is interpreted as the result of forgetting about V from P. Moreover, U(f(P,V )) ⊆ U(P) ∖ V is usually required. In the following we introduce some well-known properties for forgetting operators [Gonc¸alves et al., 2016a].

Strong persistence is presumably the best known one [Knorr and Alferes, 2014]. It requires that the result of forgetting f(P, V ) is strongly equivalent to the original program P , modulo the forgotten atoms.

(SP) f satisfies strong persistence if, for each program P and each set of atoms V , we have: AS(f(P, V ) ∪ R) = AS(P ∪R)∥V for all programs R with U(R) ⊆ U\V .

Strong invariance requires that rules not mentioning atoms to be forgotten can be added before or after forgetting.

(SI) f satisfies strong invariance if, for each programP and each set of atoms V , we have: f(P, V )∪R ≡s f(P∪R, V ) for all programs R with U(R) ⊆ U\V .

Consequence persistence and its two variations are weaker forms of strong persistence dealing with ordinary equivalence only.

• (CP) f satisfies consequence persistence if, for each P and each set of atoms V : AS(f(P, V )) = AS(P)∥V .
• (sC) f satisfies strengthened consequence if, for each P and each set of atoms V : AS(f(P, V )) ⊆ AS(P)∥V .
• (wC) f satisfies weakened consequence if, for each P and each set of atoms V : AS(f(P, V )) ⊇ AS(P)∥V .

2.2 Argumentation Theory

Syntax and Semantics Let U be an infinite background set. An argumentation framework (AF) [Dung, 1995] is a directed graph F = (A,R) with A ⊆ U representing arguments and R ⊆ A × A interpreted as attacks. If (a, b) ∈ R we say that a attacks b or a is an attacker of b. Moreover, a set E defends an argument a if any attacker of a is attacked by some argument of E. In this paper we consider finite AFs only and use the symbol F to denote the set of all finite AFs. Moreover, for a set E ⊆ A we use E + for {b ∣ (a, b) ∈ R, a ∈ E} and define E⊕ = E ∪ E+ . Given an AF F = (B,S), we use A(F) to refer to the set B and R(F) to refer to the relation S. For two AFs F and G, we define the expansion of F by G, in symbols F ⊔G, as expected: F ⊔G = (A(F)∪A(G),R(F)∪R(G)). Finally, the restriction of an AF F to a set of arguments C ⊆ U is defined as F ∣C = (A(F ) ∩ C, R(F ) ∩ (C × C)).

An extension-based semantics σ ∶ F → 22U is a function which assigns to any AF F a set of sets of arguments σ(F) ⊆ 2A(F) . Each set of arguments E ∈ σ(F) is considered to be acceptable with respect to F and is called a σ-extension. The most basic requirements of an extension are called conflict-freeness (cf ) and admissibility (ad). Other wellstudied semantics include stage (stg), stable (stb), semi-stable (ss), complete (co), preferred (pr), grounded (gr), ideal (il ) and eager (eg). The requirements of each semantics are summarized below. A recent overview of argumentation semantics can be found in [Baroni et al., 2018b]. Two AFs F and G are equivalent w.r.t. σ (F ≡σ G) if σ(F) = σ(G).

Definition 1. Let F = (A,R) be an AF and E ⊆ A.

1. E ∈ cf (F) iff for no a, b ∈ E, (a, b) ∈ R,
2. E ∈ad(F) iff E ∈cf (F) and E defends all its elements,
3. E ∈ co(F) iff E ∈ ad(F) and for any a ∈ A defended by E, a ∈ E,
4. E ∈ stg(F) iff E ∈cf (F) and for no I ∈cf (F),E ⊕ ⊂I ⊕,
5. E ∈stb(F) iff E ∈cf (F) and E⊕ = A,
6. E ∈ss(F) iff E ∈ad(F) and for no I ∈ad(F),E ⊕ ⊂I ⊕,
7. E ∈pr(F) iff E ∈co(F) and for no I ∈co(F), E ⊂I,
8. E ∈gr(F) iff E ∈co(F) and for any I ∈co(F), E ⊆I,
9. E ∈ il(F) iff E ∈ co(F), E ⊆ ⋂pr(F) and there is no I ∈co(F) satisfying I ⊆⋂pr(F) s.t. E ⊂ I,

Existence, Reasoning and Expressibility A semantics σ is universally defined, if σ(F) ≠ ∅ for any F ∈ F. If even ∣σ(F)∣ = 1 we say that σ is uniquely defined. Apart from stable semantics all considered semantics are universally defined. The grounded, ideal and eager semantics are uniquely defined (cf. [Baumann and Spanring, 2015] for an overview).

With respect to the acceptability of arguments, we consider the two main reasoning modes. Given a semantics σ, an AF F , and an argument a ∈ A(F), we say that a is credulously accepted w.r.t. σ if a ∈ ⋃σ(F) and that a is skeptically accepted w.r.t. σ if σ(F) ≠ ∅ and a ∈ ⋂σ(F).

We say that a set of sets E ⊆ 2U is realizable w.r.t. σ if there is an AF F s.t. σ(F) = E. Realizability under stable semantics is given if and only if i) E forms a ⊆-antichain 1 and ii) E is tight [Dunne et al., 2015]. Tightness is fulfilled if for all E ∈ E and a ∈ ⋃E we have: if E ∪{a} ∉ E then there exists an e ∈ E, s.t. (a, e) ∉ {(b, c) ∣ ∃E′ ∈ E ∶ {b, c} ⊆ E′ }. See Example 2 for an illustration. Moreover, we will frequently use that stage, semi-stable as well as preferred semantics satisfy I-maximality too (cf. [Baumann, 2018] for an overview).

1 Within the argumentation community this property is usually referred to as I-maximality [Baroni and Giacomin, 2007].

3 Desiderata for Forgetting

Given an AF F and a set of arguments X ⊆ U, we use fσ(F,X) to denote the result of forgetting the arguments X in F under semantics σ. This means, we consider a function fσ ∶ F × 2U → F mapping a pair (F,X) to an AF fσ(F,X). If clear from context or irrelevant we will omit σ.

In the following we collect and define a large number of desiderata for forgetting in abstract argumentation. Some of them have been already considered in [Baumann et al., 2020] for the case of single arguments. We generalize them to sets of arguments as done in the LP case. Moreover we introduce further important conditions firstly considered in the realm of LPs [Gonc¸alves et al., 2016a]. We will see that there are many dependencies that are not clear at first glance. Note that desiderata e1 as well as e2 could be alternatively renamed as eCP and eSP (see Section 2 for more details.) However, we decided to keep in line with the notation chosen in [Baumann et al., 2020].

Desiderata 1. Given an AF F and a set of arguments X ⊆ U. For a forgetting operator f we define:

(no further extensions are added)

(delete X even from any future extension)

(subsets of X-adjusted extension)

(supersets of X-adjusted extension)

The next four desiderata are concerned with skeptical and credulous reasoning.

Desiderata 2. Given an AF F and a set of arguments X ⊆ U. For a forgetting operator f we define:

Arguably the presented reasoning desiderata either describe too strictly or too loosely what is skeptically or credulously accepted. For r1 and r2 to be satisfied, it suffices to syntactically remove X. In contrast, to satisfy r3 or r4 the resulting AF must entail a precise set of arguments. As a compromise between them, we suggest the following desiderata, that bridge semantic and syntatic requirements.

Desiderata 3. Given two AFs F and H as well as a set of arguments X ⊆ U. For a forgetting operator f we define:

• m1. ⋂σ(f(F,X)) ⊆ A(F) ∖X

(skept. acceptance is among unforgotten old arguments) m2. ⋃σ(f(F,X)) ⊆ A(F) ∖X (cred. acceptance is among unforgotten old arguments) m3. ⋂σ(f(F,X) ⊔H) ⊆ (A(H) ∪A(F)) ∖X for all AFs H with A(H) ⊆ U ∖ X (forgotten arguments are never skept. accepted) m4. ⋃σ(f(F,X) ⊔H) ⊆ (A(H) ∪A(F)) ∖X for all AFs H with A(H) ⊆ U ∖ X

(forgotten arguments are never cred. accepted)

Condition m1 (resp. m2) requires that, if there are new arguments added while forgetting, they be irrelevant to skeptical (resp. credulous) reasoning. In other words, that these arguments are purely administrative. Then m3 (resp. m4) require new arguments to be irrelevant, even under the addition of new information.

The following three conditions are purely syntactical ones. Desideratum s1 makes explicit what is often implicitly assumed for forgetting operators in other formalisms. Condition s3 presents the most straightforward way of forgetting a set of arguments. Such an syntactical approach was firstly considered in [Bisquert et al., 2011].

Desiderata 4. Given an AF F and a set of arguments X ⊆ U. For a forgetting operator f we define:

s1. A(f(F,X)) ∩X = ∅ (no arguments fromX) s2. A(f(F,X)) = A(F) ∖X (precise set of arguments) s3. f(F,X) = F∣A(F)∖X (rigid AF)

The following vacuity desiderata provide conditions under which a given framework does not require any changes.

Desiderata 5. Given an AF F and a set of arguments X ⊆ U. For a forgetting operator f we define:

v1. If ⋂σ(F) ∩X = ∅, then F = f(F,X). (skept. vacuity) v2. If ⋃σ(F) ∩X = ∅, then F = f(F,X). (cred. vacuity) v3. If A(F) ∩X = ∅, then F = f(F,X). (argument vacuity)

When deriving a forgetting result it would be advantageous to be able to confine the construction in some way. For comparison, some forgetting operators in LP have been shown to be able to disregard rules that do not mention the atoms to be forgotten, i.e. they satisfy the discussed property (SI). Similarly, when forgetting arguments from an AF we could require that arguments that do not stand in (close) contact to the arguments to be forgotten can be left unchanged.

Desiderata 6. Given an AF F and a set of arguments X ⊆ U. For a forgetting operator f we define:

• l0. f(F,X) ⊔ H ≡ f(F ⊔ H,X) for all AFs H with
• A(H) ⊆ U ∖ X (f and ⊔ are compatible) l1. f(F,X)⊔H ≡ f(F ⊔H,X) for all AFs H with A(H) ⊆ U ∖ (X ∪ {a ∣ ∃x ∈ X, s.t. (a, x) ∈ R or (x, a) ∈ R}) (less tolerant refinement of compatibility)

We proceed with an analysis of their dependencies.

Proposition 1. For σ ∈ {stg, stb, ss, pr , gr , il , eg} and conditions c and c′ in the diagram below, a path from c to c′ indicates that any function fσ satisfying c under σ also satisfies c′ under σ. Moreover, only these relations hold.

Apart from the relationships concerning single conditions there are more complex implications. In the realm logic programming it was already shown that (SP) is necessary and sufficient for (SI) and (CP) [Gonc¸alves et al., 2016a]. Beside other interesting relations we state the analogous result for abstract argumentation in Item 5 of the following proposition. Please note that the proof is astonishingly simple.

Proposition 2. For any semantics σ ∈ {stg, stb}:

1. s2, l0 and e3⊆ imply e2,
2. s2, l0 and e3⊇ imply e2.

Moreover, for any τ ∈ {stg, stb, ss, pr , gr , il , eg} we have:

1. e3⊆ and e3⊇ if and only if e1, 4. esC and ewC if and only if e1,
2. e1 and l0 if and only if e2.

4 Satisfiability and Unsatisfiability

In this section we consider the satisfiability of single conditions as well as whole sets of desiderata. Most of the results underline the intrinsic limits of forgetting in abstract argumentation as they prove unsatisfiability.

4.1 Individual Desiderata

We start with a positive result regarding individual satisfiablity. In fact, 19 conditions are satisfiable under any considered semantics if considered in isolation.

Proposition 3. Desideratum d ∈ {e3⊇ , e3⊆ , esC, r1, r2, r3, r4, s1, s2, s3,m1,m2,m3,m4, v1, v2, v3, l0, l1} is satisfiable under any semantics σ ∈ {stg , stb, ss , pr , gr , il , eg}.

The following proposition shows a dividing line between uniquely and universally defined semantics. The I-maximality of the latter family prevent the satisfiability of e1 and ewC. We mention that the corresponding forgetting property (CP) in the realm of LPs is satisfiable.

Proposition 4. Desiderata e1 and ewC are satisfiable under any τ ∈ {gr , il , eg}, but not under σ ∈ {stb, stg, ss, pr}.

The following two propositions are mainly due to already shown results in [Baumann et al., 2020].

Proposition 5. Desiderata e4 is satisfiable under stable semantics, but not under any τ ∈ {stg, ss, pr , gr , il , eg}.

Proposition 6. Desiderata e2 is unsatisfiable under any semantics σ ∈ {stg , stb, ss , pr , gr , il , eg}.

4.2 Combined Desiderata

In the following we consider whole sets of conditions.

Proposition 7. We have the following satisfiability results:

1. {s2, l0, e3⊆ } as well as {s2, l0, e3⊇ } are unsatisfiable for any semantics µ ∈ {stg, stb}.
2. Moreover, {e3⊆ , e3⊇ } and {esC, ewC} are unsatisfiable for any semantics σ ∈ {stg, stb, ss, pr}, but satisfiable for each τ ∈ {gr , il , eg}.

The next result underline the exceptional potential of stable semantics regarding forgetting.

Proposition 8. {l0, esC} as well as {l1, esC} are satisfiable under stable semantics but not under σ ∈ {gr , stg, ss, pr}.

4.3 Testing the Limits: Promising Combinations

The strongest syntactical desideratum s3 is incompatible with all semantical ones and can only be trivially combined with r1 and r2. In this context, trivial means, that one condition already implies the other (cf. Proposition 1). Stable semantics is able to collapse for certain AFs. This unique property is nicely reflected in Table 1 via exceptional behaviour regarding fulfilling combined desiderata.

Proposition 9. Table 1 summarizes the compatibility under semantics σ ∈ {stg , stb, ss , pr , gr , il , eg}. A "✓"/"×" in cell (l,c) indicates whether or not the conditions in line l and column c are simultaneously satisfiable under σ. The symbol "τ" restricts the satisfiability to the semantics gr , il and eg, the symbol "stb" to stable semantics and the symbol "¬stb" to all semantics but stable respectively. The combinations in a dark background are trivial.

5 Forgetting under Stable Semantics

Let us reflect on the proposed extension-based conditions as listed in Desiderata 1. At first we observe that e1 and e4 represent two opposing philosophies about the concept of forgetting. Desideratum e1 requires that any former extension has to survive in an adjusted fashion, namely new extensions are obtained from initial ones via deleting the arguments which has to be forgotten (σ(f(F,X)) = {E ∖X ∣ E ∈ σ(F)}). In contrast, Condition e4 requires to delete any extension carrying arguments which has to be forgotten (σ(f(F,X)) = σ(F) ∖ {E ∣ E ∈ σ(F),E ∩X ≠ ∅}). Both interpretations of forgetting are independent as shown in Proposition 1. Any other considered extension-based condition is either a relaxation of e1, or a lifting of this interpretation to the level of strong equivalence. In the following we will consider these two main desiderata in more detail. We restrict ourselves to stable semantics and leave the consideration of other semantics for future work.

Forgetting via e4 Quite recently, an e4-operator f for forgetting single arguments was presented [Baumann et al., 2020, Algorithm 1]. In Example 3 of the introductory part we have seen that applying this operator f iteratively does not necessarily produce a desirable outcome. Moreover, this procedure is sensitive to the order of forgetting. How to adapt the existing procedures for multiple arguments?

It turned out that the main idea can be directly conveyed to the task of forgetting a whole set of arguments X. More precisely, in a first step we simply restrict the initial framework F to A(F)∖X, i.e. we consider F∣A(F)∖X. In doing so we get that any former extension containing arguments from X is not stable anymore but any other survives. Now, in a second step, we eliminate any unwanted extensions via the addition of selfattacking arguments. This yields the following Algorithm 1.

Example 4 (Example 3 cont.). Consider again AF F . Let X = {x, b}. Applying Algorithm 1 immediately yields f ∗ (F , X) = F ∣A(F)∖X as stb(F ∣A(F)∖X) = {{a, c, d}, {a, c, e}}.

Algorithm 1: Construct G = f ∗

1 (F , X) Input :AF F; arguments X ⊆ U Output :AF G satisfying {s1,e4,v3,m4} 1 Function compute G(F,X) 2 if X ∩ A(F ) = ∅ then G ← F ; 3 else 4 G0 ← F ∣A(F )∖X ; 5 A = A(G0); R←R(G0); 6 foreach Ei ∈ stb(G0) ∖ stb(F) do 7 Let ai be a fresh argument s.t. ai /∈ A(F)∪A; 8 A ← A ∪ {ai}; R ← R ∪ {(ai, ai)} 9 foreach y ∈ ⋃A(G0) ∖ Ei do 10 R ← R ∪ {(y, ai)}; 11 G ← (A, R); 12 return G;

The attentive reader may have already noticed that f ∗ (F,X) = f(f(F, b), x). This means, forgetting x and b simultaneously yields the more compact outcome if applying the former operator f iteratively (f(f(F, b),x) vs. f(f(F,x), b)). A detailed comparison between iteratively applying f and the one-shot f ∗ will be part of future work.

Now lets turn to the question of whether e4 can be satisfied when removing arguments is impossible, unintended or just undesired for some reason. This means, only expanding the initial framework F is allowed. The following Algorithm 2 gives an affirmative answer. The simple idea is to manipulate as follows: For any argument x ∈ X we add a self-attacking argument ax which is attacked by any attacker of x. In doing so, any former extension E not containing x remains stable, but former ones E′ with x ∈ E′ does not survive as they do not attack ax (confer Appendix). It is important to note that the presented algorithm relies on syntactic information only as it does note require the computation of any extension.

Example 5 (Example 1 cont.). Consider again AF F . We have stb(F) = {{b, d}}. Let X = {b}. Note that Desideratum e4 forces a collaps of stable extensions.

Algorithm 2: Construct G = f ∗ 2 (F, X) Input :AF F; arguments X ⊆ U Output :AF G satisfying {e4,v3,m4} 1 Function compute G(F,X) 2 if X ∩ A(F ) = ∅ then G ← F ; 3 else 4 G0 ← F ; 5 A = A(G0); R←R(G0); 6 foreach x ∈ X do 7 Let ax be a fresh argument s.t. ax /∈ A; 8 A ← A ∪ {ax}; R ← R ∪ {(ax, ax)} 9 foreach b ∈ A ∶ (b, x) ∈ R do 10 R ← R ∪ {(b, ax)}; 11 G ← (A, R); 12 return G;

Forgetting via e1 The main reason for the impossibility to find an operator satisfying e1 under stable semantics is an intrinsic one, namely realizability. More precisely, there are certain instances (F,X) which would enforce a forgetting result F ′ violating the ⊆-antichain property or tightness (see Example 2). Consequently, one reasonable strategy is to look for forgetting operators satisfying e1 whenever possible, and if not, try to satisfy a certain relaxation of it. Natural candidates would be e3⊆ , e3⊇ or esC. A similar procedure was suggested and also implemented for strong persistence in the realm of logic programming [Gonc¸alves et al., 2017].

The choice of how to relax e1 depends on the application in mind. Each relaxation has its particular advantages and drawbacks. Moreover, as we have seen in Figure 1 there are no dependencies between them. Further research on this subject is left for future work.

6 Discussion and Conclusion

The paper sheds more light on forgetting in abstract argumentation. One main motivation was to convey desiderata from recent studies of forgetting in LP [Knorr and Alferes, 2014; Gonc¸alves et al., 2016a; Berthold et al., 2019a; Berthold, 2022]. We redefined several principles and provided a comprehensive study regarding satisfiability and relations. We further demonstrated that already existing operators from LP cannot be unconditionally applied to abstract argumentation. The two main reasons are non-AF-like forgetting results and the essential differences regarding expressibility. Finally, we presented two specific forgetting operators, one excluding the arguments to be forgotten, and the other one using expansions only.

A relevant work in this context is [Rienstra et al., 2020] dealing with so-called robustness principles. The paper studies the question to which extent old labellings persist/new labellings arise if a certain structural change of a given AF is performed. Such results are highly relevant for the theory of forgetting as they can be used to show the satisfiability/unsatisfiability of desidered properties. The consideration of such results will be fruitful for the development of concrete forgetting operators.

Acknowledgements

This work was supported by the German Federal Ministry of Education and Research (BMBF, 1IS18026A) by funding the competence center for Big Data and AI "ScaDS.AI" Dresden/Leipzig.