Utilizing ASP for Generating and Visualizing Argumentation Frameworks

0.38 MB·English

by  Günther Charwat

Utilizing ASP for Generating and Visualizing
Argumentation Frameworks
Gu¨ntherCharwat,JohannesPeterWallner,andStefanWoltran
ViennaUniversityofTechnology,InstituteofInformationSystems184/2,
Favoritenstraße9-11,1040Vienna,Austria
{gcharwat,wallner,woltran}@dbai.tuwien.ac.at
3
1
0
Abstract. Withintheareaofcomputationalmodelsofargumentation,theinstan-
2
tiation-basedapproachisgainingmoreandmoreattention,notatleastbecause

n meaningful input for Dung’s abstract frameworks is provided in that way. In a
a nutshell, the aim of instantiation-based argumentation is to form, from a given
J
knowledgebase,asetofargumentsandtoidentifytheconflictsbetweenthem.

8 Theresultingnetworkisthenevaluatedbymeansofextension-basedsemantics
onanabstractlevel,i.e.ontheresultinggraph.Whileseveralsystemsarenowa-
]
daysavailableforthelatterstep,theautomationoftheinstantiationprocessitself
I
A hasreceivedlessattention.Inthiswork,weprovideanovelapproachtoconstruct
. and visualize an argumentation framework from a given knowledge base. The
s
system we propose relies on Answer-Set Programming and follows a two-step
c
[ approach.Afirstprogramyieldsthelogic-basedargumentsasitsanswer-sets;a
secondprogramisthenusedtospecifytherelationsbetweenargumentsbasedon
1
theanswer-setsofthefirstprogram.Asitturnsout,thisapproachnotonlyallows
v
foraflexibleandextensibletoolforinstantiation-basedargumentation,butalso
8
providesanewmethodforanswer-setvisualizationingeneral.
8
3
1
1 Introduction
.
1
0
Instantiation-based argumentation [7] is a central paradigm in nonmonotonic reason-
3
1 ingsinceitgivesaformalhandletoseparatethelogicalandnon-classicalcontentsof
: reasoninginthepresenceofcontradictinginformation.Hereby,onestartswithaknowl-
v
i edgebaseandconstructsargumentsfromit.Argumentstypicallyconsistoftwoparts,
X
namelyasupport,whichisgroundedintheknowledgebaseandaclaimderivedfrom
r it.In[4]theprocessisdescribedwithanunderlyingpropositionalknowledgebaseus-
a
ingminimalsetsofconsistentsupportclassicallyentailingtheclaim.Inasecondstep,
conflicts between these arguments have to be identified. The obtained arguments and
therelationbetweenthemyieldaso-calledargumentationframework[9].Thissimple,
yetexpressiveformalismisbasicallyadirectedgraphwherebytheargumentsarerepre-
sentedviaverticesandtheconflictswithdirectededges.Argumentationframeworksare
thenevaluatedwithoneofthenumeroussemanticsforabstractargumentationavailable,
resultinginpotentiallymultipleacceptablesetsofarguments[3].
Hereweareonlyinterestedintheinstantiationpart,however,whichreceivedless
attention wrt. realized systems. Notable exceptions are the Carneades system, which
can construct arguments using heuristics [16] and the recent TOAST implementation
2 G.Charwatetal.
for the ASPIC+ framework [27]. The reason for the lack of implementations is po-
tentially twofold: First, due to the inherent high complexity of the problem; already
constructingasingleargumentishardforthesecondlevelofthepolynomialhierarchy
[23]. Secondly, standard instantiation schemes for propositional knowledge bases re-
sultininfiniteargumentationframeworksevenforfiniteknowledgebases[1].Thefirst
obstaclecallsforhighlyexpressivelanguages,makinganswer-setprogramming[6,21,
22] (ASP, for short) a well suited candidate. For the second obstacle, we restrict our-
selvesheretoargumentsthathavetheirclaimscomingfromanapriorispecifiedsetof
formulae.
Tosummarize,weaimhereforasystemwhichtakesasinputaknowledgebaseas
wellasasetofpotentialclaimsandproducestheinstantiatedargumentationframework,
suchthatthelattercanbeprocessedbyotherargumentationtools,e.g.ASPARTIX[11]
orCEGARTIX[10].Morespecifically,ourcontributionsareasfollows:
– We provide ASP programs1 to encode the construction of arguments as well as
the construction of the conflicts. For the second task, the answer-sets of the first
encodingareusedasinput.Thuswecanmakeuseofthehighsophisticationmodern
ASPsystemshavereached[15,20].Moreover,sincetheargumentconstructionand
conflictidentificationaredeclarativelydescribedviaASPcode,thesystemiseasily
adaptabletoothernotionsofargumentsorconflicts.
– We present a system that, on the one hand, takes care of passing the answer-sets
from one program to another. On the other hand, the system uses the answer-sets
ofthetwoprogramsforvisualizationinformofagraph.Inourcaseweobtainan
argumentation framework. Finally, this result can be exported and used by other
systemsforabstractargumentation.
As a by-product, we observed that this method is by no means restricted to the
argumentation domain. Ultimately, it allows for a user-driven graph representation of
the collection of answer-sets of a given input program, thus acting as a tool for ASP
visualization in general. The most interesting feature of the tool is that the concrete
specificationfortwoanswer-setsbeinginrelationisgivenbyanASPprogramitself.In
recentyears,ASPhasbenefitedfromtherisingnumberofdevelopmentandvisualiza-
tiontools,e.g.ASPViz[8],ASPIDE[14],Kara[19]andIDPDraw[29].Thesetoolsso
farhavefocusedonpresentationsofsingleanswer-setsofthegivenprogram.However,
incertainapplicationsitisnotonlythesingleanswer-setswhichareofinterest,butthe
relationbetweenthem.
WhilevisualizationisarathernewresearchbranchinASP,ithasgainedmoreat-
tentionintheargumentationcommunity,wherededicatedvisualizationtoolshavebeen
proposed already in the late 90s (e.g. [2,5,11,18,24–26,28], including Debategraph2
andRationale3).Manyofthesesupporttheargumentconstructionbyauserviadifferent
means,suchasautomatedreasoning,inputmasksanddatabasequerying.Comparedto
these systems, our approach combines the computational power of high-sophisticated
ASPsystemswithvisualizationaspects.Moreover,thankstothedeclarativenatureof
1http://dbai.tuwien.ac.at/proj/argumentation/vispartix/
2http://debategraph.org
3http://rationale.austhink.com/
UtilizingASPforGeneratingandVisualizingArgumentationFrameworks 3
theASPencodingsspecifyingtheinstantiationstep,webelievethatthestrengthofour
approachliesinitsflexibilityanditsexpandabilitytonewargumentationformalisms.
Thispaperisstructuredasfollows:WebrieflyintroduceargumentationandASPin
Section2.Then,inSection3,wepresentASPencodingsforconstructinganargumen-
tationframework.InSection4weoutlineanovelvisualizationtoolwhichisusedfor
representingrelationsbetweenanswer-sets.AfinaldiscussionisgiveninSection5.
2 Preliminaries
We provide the necessary background from argumentation theory and ASP for this
work.Inparticularwewillexplaintheargumentationprocessbasedonargumentation
frameworks[9]aswellasbrieflyrecalltheconceptsfordisjunctivelogicprograms.
2.1 Argumentation
Inthissectionweintroduceformalargumentation.Westartwiththeunderlyingprocess
[7], which we will utilize in our context. The general process consists of three steps.
First,givenaknowledgebase,argumentsandtheirrelationshipsareinstantiated.After
thisinstantiationtheargumentsaretreatedasabstractentities,withoutconsideringtheir
concrete content. Secondly conflicts are resolved using appropriate semantics on the
abstractinstantiationandfinallyconclusionsaredrawn.
In this work the knowledge base K is a (potentially inconsistent) set of proposi-
tionallogicformulae.Weconstructtheformulaewiththeusualconnectives¬,∨,∧,→,
thenegation,disjunction,conjunctionandimplication,respectively.Furthermoreentail-
mentandlogicalequivalenceofformulaeisdenotedby|=and≡,respectively.Wewrite
formulaewithlowercaseGreeklettersα,β,γ,....
Example1. Considerthefollowingsimpleandinconsistentexampleknowledgebase:
K={a,a→b,¬b}
Theinstantiationstepnowconstructsargumentsandrelationsamongthembasedon
theinformationavailableinK accordingto[4].Theabstractrepresentationweutilize
forthispurposeisthewidelystudiedargumentationframework[9].Anargumentation
framework(AF)isadirectedgraphF =(Args,Att),withthevertices(Args)beingab-
stractargumentsandthedirectededges(Att)denoteattacksbetweenthemtorepresent
conflicts.
The instantiation of an AF now consists of two parts, namely the argument con-
struction and the attack relation construction. An argument A = (S,C) consists of a
supportfortheargumentandaclaim.ThesupportisasubsetoftheknowledgebaseK
andtheclaimisasinglelogicalformula.Thesupportmustbeaconsistentandsubset
minimalsetofformulae,whichentailstheclaim.
Heretheargumentsarepairsofsupportandclaimtoprovideaformalbasisforar-
gumentconstruction.Whenpluggedintheargumentationframeworkweabstractfrom
this “inner” structure and collapse every pair of support and claim into one abstract
argument.Thisistheabstractionprocedureoftheoverallprocess.
4 G.Charwatetal.
Wenotethatargumentconstructionherediffersfromtheusualargumentdefinition
in the literature. In particular the claim can be taken only from a pre-defined set C.
Using a pre-defined set of claims, we can restrict ourselves to reasonable claims, e.g.
not involving tautologies. In this way we prohibit the construction of infinitely many
arguments thatcould otherwise result frominfinitely many syntactically differentfor-
mulae which are semantically equivalent. This restriction comes with a disadvantage
however,asthesetofpre-definedclaimsmustbechosenwithcare,sinceinconsistent
conclusionsmightbedrawnotherwise.Indeed,[17]identifyconditionsforrationaland
consistent end results, which require the existence of specific arguments, which must
beincludedinC.Ontheotherhand,thisrestrictionisinlinewiththeconceptofcores
ofargumentationframeworks[1],whichtrytopreservedesiredpropertieswhileusing
onlyasubsetofallpossiblearguments.
Example2. ContinuingExample1,letthesetofclaimsbeC = K∪{¬a,b,a∧¬b}.
Thenwecanconstructthefollowingarguments:
a =({a},a) a =({¬b,a→b},¬a)
1 4
a =({a→b},a→b) a =({¬b},¬b)
2 5
a =({a,a→b},b) a =({a,¬b},a∧¬b)
3 6
Fortheconstructionoftheattackrelationseveraloptionswerestudiedinliterature.
The basic idea for attacks between arguments underlying all of these options is that
some sort of inconsistency occurs between them. We take the attack definitions from
[17] and illustrate two types, defeat and directed defeat. An argument A = (S,C)
attacksanargumentA(cid:48) =(S(cid:48) ={φ(cid:48),...,φ(cid:48) },C(cid:48))usingdefeatifC |=¬(φ(cid:48)∧...∧φ(cid:48) ).
1 m 1 m
TheformerdirectlydefeatsthelatterifC |=¬φ(cid:48) foronei,1≤i≤m.
i
Example3. Continuing Example 2, the AF in Figure 1 illustrates the result using the
directdefeatontheargumentsbuiltfromKandtheclaimsC.Notethate.g.a anda
3 5
are not mutually attacking each other, since the claim of a does not entail a negated
5
supportformulaofa .
3
Fig.1.Argumentationframework
a
1
a
4
a a
3 6
a a
5 2
This completes the first step of the argumentation process, namely the AF con-
struction out of the knowledge base. For the conflict resolution a plethora of argu-
mentation framework semantics exist. A basic property for semantics is the conflict-
free property, which states that a set M of arguments in an AF F is conflict free if
there are no attacks between them in F. A set of arguments M is stable in an AF
UtilizingASPforGeneratingandVisualizingArgumentationFrameworks 5
F = (Args,Att) if it is conflict free and all arguments outside are attacked from M,
i.e.∀a∈(Args\M)∃b∈M with(b,a)∈Att.
Example4. If we take the argumentation framework from Example 3, then the stable
(cid:8) (cid:9)
semanticsselects {a ,a ,a },{a ,a ,a },{a ,a ,a } asacceptablesubsetsofar-
1 5 6 1 2 3 2 4 5
guments.
Thelaststepoftheargumentationprocessdealswithdrawingconclusionsfromthe
sets of acceptable arguments. One can look at the content of the abstract arguments
whichwereaccepted,e.g.onecanderivethedeductiveclosureofthiscontent.
In general every step of this process is intractable. Hence we need sophisticated
systemsfortacklingthesesteps,whichmakesASPasuitablechoiceforembeddingthe
processin.Amoredetailedcomputationalcomplexityanalysiscanbefoundin[23].
2.2 Answer-SetProgramming
Inthissectionwerecallthebasicsofdisjunctivelogicprogramsundertheanswer-sets
semantics[6,22].
WefixacountablesetU of(domain)elements,alsocalledconstants.Anatomisan
expression p(t ,...,t ), where p is a predicate of arity n ≥ 0 and each t is either a
1 n i
variableoranelementfromU.Anatomisgroundifitisfreeofvariables.B denotes
U
thesetofallgroundatomsoverU.
A(disjunctive)rulerisoftheform
a ∨ ··· ∨ a ←b ,...,b , notb ,..., notb
1 n 1 k k+1 m
with n ≥ 0, m ≥ k ≥ 0, n+m > 0, where a ,...,a ,b ,...,b are atoms, and
1 n 1 m
“not” stands for default negation. The head of r is the set H(r) = {a ,...,a } and
1 n
the body of r is B(r) = {b ,...,b , notb ,..., notb }. Furthermore, B+(r) =
1 k k+1 m
{b ,...,b }andB−(r)={b ,...,b }.Aruler isaconstraint ifn = 0.Aruler
1 k k+1 m
issafeifeachvariableinroccursinB+(r).Arulerisgroundifnovariableoccursin
r.Afactisagroundrulewithoutdisjunctionandemptybody.Aprogramisafiniteset
ofdisjunctiverules.
Foranyprogramπ,letU bethesetofallconstantsappearinginπ.Gr(π)isthe
π
set of rules rσ obtained by applying, to each rule r ∈ π, all possible substitutions σ
fromthevariablesinrtoelementsofU .AninterpretationI ⊆B satisfiesaground
π U
ruleriffH(r)∩I (cid:54)=∅wheneverB+(r)⊆I andB−(r)∩I =∅.I satisfiesaground
programπ,ifeachr ∈ π issatisfiedbyI.Anon-groundruler(resp.,aprogramπ)is
satisfiedbyaninterpretationI iffI satisfiesallgroundingsofr(resp.,Gr(π)).I ⊆B
U
isananswer-setofπiffitisasubset-minimalsetsatisfyingtheGelfond-Lifschitzreduct
πI ={H(r)←B+(r)|I∩B−(r)=∅,r ∈Gr(π)}.
3 Instantiation-basedArgumentation
InthissectionweprovideourASPencodingsfortheconstructionofargumentsfroma
knowledge-baseKandasetCofclaims.Asinput,eachformulainKandCisgivenby
theunarypredicatekb(·)andcl(·),respectively.
6 G.Charwatetal.
Example5. Theinput,asgiveninExample1and2,isspecifiedby:
{kb(a).kb(imp(a,b)).kb(neg(b)).
cl(a).cl(imp(a,b)).cl(neg(b)).cl(neg(a)).cl(b).cl(and(a,neg(b))).}
First,weintroducetheASPencodingsforcheckingwhetheracertainvariableas-
signmentisamodelforagivenformula(ornot).Modelcheckingplaysacrucialrole
forourinstantiation-basedapproach.Then,wepresentencodingsforthecomputation
of arguments. Finally, we provide ASP code for some types of attack relations. Note
thatanargumentationframeworkisobtainedbytwoseparateASPprogramcallswhere
thefirstonetakesasinputKandC andreturnsaseparateanswer-setforeachresulting
argument.Thesecondprogramreceivesasinputa“flattened”versionofallarguments
andcomputestheattacksbetweenargumentsbasedondifferentattacktypeencodings.
3.1 ModelChecking
Propositional formulae provide the basis for the construction of arguments and their
attack relations. In fact, we can express most of the defining properties of arguments
(suchasentailmentofthesupporttotheclaim)andattacksbymeansofpropositional
formulae.InthissectionweprovideanASPencodingthatallowsustocheckwhether
a formula α is true under a given interpretation I, i.e. I is a model for α. First, the
formula is split into sub-formulae until we obtain the contained atoms or constants.
Due to brevity, the following encodings only exemplify this for the connectives ∧, ¬
and→.Notethat∨,(cid:54)↔and↔aresupportedaswell.
πsubformula =(cid:8)subformula(F)←subformula(and(F, )); (1)
subformula(F)←subformula(and(,F)); (2)
subformula(F)←subformula(neg(F)); (3)
subformula(F)←subformula(imp(F, )); (4)
subformula(F)←subformula(imp(,F)).(cid:9) (5)
Theatomsandconstantsofαarethenobtainedviatheencodingπ .Considerrule
atom
(1)whichdenotesthataformulaisnotanatomincaseitisoftheformand(·,·)4.
πatom =(cid:8)noatom(F)←subformula(F;F1;F2),F :=and(F1,F2); (1)
noatom(F)←subformula(F;F1),F :=neg(F1); (2)
noatom(F)←subformula(F;F1;F2),F :=imp(F1,F2); (3)
atom(X)←subformula(X),notnoatom(X).(cid:9) (4)
Nowwecomputewhethertheinterpretationisamodelbyfirstevaluatingtheatoms
andconstants.Incaseanatomgetsassignedtrue(false)wederivethattheinterpreta-
tionforthissub-formulaisamodel(notamodel).Now,theconnectivesareevaluated
bottom-up based on the model information of the sub-formulae. In particular, this al-
lowstocheckwhetherI isamodelforouroriginalformulaα,ornot.
Theencodingπ exemplifiesthisapproachforsomeoftheconnectives.Inthe
ismodel
subsequentsectionswehavetoapplymodelcheckingseveraltimeswithinasingleASP
encoding.Inordertoavoidsideeffectsofdifferentchecks,weintroduceanadditional
4Notethatthesyntaxofourencodingsisspecifictothegroundergringo[15].
UtilizingASPforGeneratingandVisualizingArgumentationFrameworks 7
parameter,K,whichservesasakeyforidentifyingtheoriginoftheinterpretationthat
iscurrentlychecked.Suppose,forexample,thatwewanttochecksatisfiabilityoftwo
differentformulae.Astheformulaemayevaluatetotrueunderdifferentinterpretations
wehavetodistinguishbetweenthetruthassignments.
πismodel=(cid:8)ismodel(K,X)←atom(X),true(K,X); (1)
ismodel(K,F)←subformula(F;F1),F :=neg(F1),
(2)
nomodel(K,F1);
ismodel(K,F)←subformula(F),F :=and(F1,F2),
(3)
ismodel(K,F1;F2);
ismodel(K,F)←subformula(F),F :=imp(F1,F2),
(4)
ismodel(K,F1;F2).(cid:9)
Duetobrevityweomittheencodingπ here.Analogoustoπ itderives
nomodel ismodel
the predicate nomodel(K,F) whenever an atom gets assigned false or a sub-formula
isfalseunderthecurrentinterpretation.Thecompleteprogramforcheckingwhethera
formulaevaluatestotrueunderagivenvariableassignmentconsistsof
π =π ∪π ∪π ∪π
modelcheck subformula atom ismodel nomodel
Example6. Consider the formula a → b from K of Example 5, i.e. kb(imp(a,b)).
Inordertocheckwhetherthereexistsamodelwecanmakeuseofπ inthe
modelcheck
followingway:Initially,wehavetodefineanadditionalrulesubformula(X)←kb(X)
asπ onlyconsidersformulaegivenbythepredicatesubformula(·).Byadding
subformula
theprogramπ ∪π thefollowinganswer-setisreturned:
subformula atom
{kb(imp(a,b)).subformula(imp(a,b)).subformula(a).subformula(b).
noatom(imp(a,b)).atom(b).atom(a).}
Each atom now gets assigned true or false, representing an interpretation. We encode
thisbytheruletrue(k,X)∨false(k,X)←atom(X).Notethatthespecificationofa
key(inthiscasek)ismandatoryalthoughπ isnotappliedseveraltimesinthis
modelcheck
example.Byaddingandrunningπ ∪π fouranswer-setsarereturned.Each
ismodel nomodel
containsthepredicatesfromthepreviouslygivenanswer-setaswellasthetruthassign-
mentfortheatomsaandbandeitherismodel(k,imp(a,b))ornomodel(k,imp(a,b)).
Theanswer-setobtainedbyfalse(k,a)andtrue(k,b)contains(amongstothers)
{false(k,a).true(k,b).ismodel(k,b).nomodel(k,a).ismodel(k,imp(a,b)).}
denotingthatI(a)=false,I(b)=trueisamodelfora→b.
3.2 FormingArguments
WenowderivetheargumentsfromaknowledgebaseKandasetCofclaims.According
to[4],wehavetocheckwhetherthesupportentailstheclaimandifthesupportissubset
minimalaswellasconsistent.Inordertoobtainargumentswefirstguessexactlyone
claimandasubsetofformulaefromK.Thisguessisencodedasfollows:
πarg =(cid:8)1{sclaim(X):cl(X)}1; (1)
1{fs(X):kb(X)}.(cid:9) (2)
8 G.Charwatetal.
Theselectedclaimisdenotedbysclaim(·).Thepredicatefs(·)isderivediftherespec-
tiveformulafromKiscontainedinthesupportS ofanargumentA=(S,C).
Entailment: Inordertobeavalidargument,thesupportmustentailtheclaim,i.e.S |=
C musthold.AsS |=C,|=S →C mustholdaswell.Hence,¬(S →C)≡¬(¬S∨
C) ≡ S ∧¬C must be unsatisfiable. Unsatisfiability of the formula S ∧¬C can be
checkedbymakinguseofthesaturationtechnique[12]:Wefirstassigntrue(entail,x)
or false(entail,x) to each atom x in the formula using a disjunctive rule. This al-
lowsbothtrue(entail,x)andfalse(entail,x)tobecontainedintheresultinganswer-
set. Furthermore, all formulae in S and the negated claim C are conjunctively con-
nected. Hence, in case any of those formulae evaluates to false under a variable as-
signment (i.e. nomodel(entail,·) is derived) we know that ¬(S → C) is not satis-
fied which implies that S |= C evaluates to true under the given interpretation. In
this case we saturate, i.e. we derive true(entail,x) and false(entail,x) for any atom
x. On the other hand, if no formula in S and C derives entails claim the constraint
← notentails claim removes the answer-set. If this is the case, due to the definition
ofstablemodelsemanticsinanswer-setprogramming,noanswer-setisreturned.Only
incasethereexistsnomodelfor¬(S → C)allguessesaresaturatedandweobtaina
singleanswer-setrepresentingasupportS andclaimC whereS |=C holds.
Inthefollowingtheprogramπ isgiven.Notethatentail issimplyusedas
entailment
akeyforidentifyingthevariableassignmentandmodelcheck.
πentailment =(cid:8)true(entail,X)∨false(entail,X)←atom(X); (1)
entailsclaim←nomodel(entail,neg(X)),sclaim(X); (2)
entailsclaim←nomodel(entail,X),fs(X); (3)
←notentailsclaim; (4)
true(entail,X)←entailsclaim,atom(X); (5)
false(entail,X)←entailsclaim,atom(X).(cid:9) (6)
Subset minimality: The support S of an argument must be a subset minimal set of
formulae,i.e.theremustnotexistanS(cid:48) ⊂ S s.t.S(cid:48) |= C.Here,weapplytheconcept
ofaloop(seee.g.[13]).ForacandidatesupportS weconsiderallS(cid:48) ⊂S wherethere
existsexactlyoneformulaα∈S butα(cid:54)∈S(cid:48).IncaseanysuchS(cid:48)existswhereS(cid:48) |=C
we know that S is not a support for C. Due to monotonicity of classical logic this is
sufficient since if S(cid:48) (cid:54)|= C then also for all S(cid:48)(cid:48) ⊂ S(cid:48) it holds that S(cid:48)(cid:48) (cid:54)|= C. First, we
defineatotalorderingoverallformulaefs(·)inS:
π< =(cid:8)lt(X,Y)←fs(X),fs(Y),X<Y; (1)
nsucc(X,Z)←lt(X,Y),lt(Y,Z); (2)
succ(X,Y)←lt(X,Y),notnsucc(X,Y); (3)
ninf(Y)←lt(X,Y); (4)
inf(X)←fs(X),notninf(X); (5)
nsup(X)←lt(X,Y); (6)
sup(X)←fs(X),notnsup(X).(cid:9) (7)
ForanyS(cid:48)wenowassigntrue(m(K),x)orfalse(m(K),x)toallatomsx.m(K)
isusedaskeyforidentifyingthetruthassignment.K istheformulaαwhereα (cid:54)∈ S(cid:48).
UtilizingASPforGeneratingandVisualizingArgumentationFrameworks 9
The idea is now to “iterate” over the the ordering, beginning at the infimum inf(·).
Based on the ordering, we now consider every formula from the support: In case the
formulaissatisfiedorcorrespondstotheremovedformulaα(i.e.thekeyK)wederive
model upto(m(α),·). If we can derive hasmodel(m(α)) we know that the support
S(cid:48) = S \α is satisfiable and can therefore not be a valid support for our claim. On
theotherhand,ifanyS(cid:48) isavalidsupportwecannotderivehasmodel(m(α))andthe
answer-setisremovedbytheconstraint←nothasmodel(m(α)),fs(α).
πminimize=(cid:8)true(m(K),X)←notfalse(m(K),X),atom(X),fs(K); (1)
false(m(K),X)←nottrue(m(K),X),atom(X),fs(K); (2)
modelupto(m(K),X)←inf(X),ismodel(m(K),X),
(3)
fs(X),X(cid:54)=K;
modelupto(m(K),K)←inf(K),fs(K); (4)
modelupto(m(K),X)←succ(Z,X),ismodel(m(K),X),
(5)
fs(X),modelupto(m(K),Z),X(cid:54)=K;
modelupto(m(K),K)←succ(Z,K),modelupto(m(K),Z),
(6)
fs(K);
hasmodel(m(K))←sup(K),modelupto(m(K),X),
(7)
ismodel(m(K),neg(Z)),sclaim(Z);
←nothasmodel(m(K)),fs(K).(cid:9) (8)
Consistency: ThesupportSmustbeaconsistentsetofformulae.Inotherwords,there
existsamodelfortheconjunctionofallformulaeinS.Theprogramπ simply
consistent
consistsofaguesswhichassignstruthvaluestoallatomsandaconstraintthatremoves
anyunsatisfiablesupport.
πconsistent =(cid:8)1{true(consistent,X),false(consistent,X)}1←atom(X). (1)
←nomodel(consistent,X),fs(X).}.(cid:9) (2)
Thefollowingprogramthengivesallargumentsthatcanbecomputedfromaknowl-
edgebaseKandasetofclaimsC:
π =π ∪π ∪π ∪π ∪π ∪π
arguments modelcheck arg entailment < minimize consistent
Each answer-set obtained by π contains the predicate sclaim(·) and a set of
arguments
predicatesfs(·),representingclaimandsupport.
Example7. ConsidertheinputasgiveninExample5.Theprogramπ returns
arguments
thefollowinganswer-sets(werestrictourselvestotherelevantpredicates):
a : {fs(a).sclaim(a).}
1
a∗ : {fs(imp(a,b)).sclaim(imp(a,b)).}
2
a : {fs(a).fs(imp(a,b)).sclaim(b).}
3
a : {fs(neg(b)).fs(imp(a,b)).sclaim(neg(a)).}
4
a : {fs(neg(b)).sclaim(neg(b)).}
5
a : {fs(a).fs(neg(b)).sclaim(and(a,neg(b))).}
6
10 G.Charwatetal.
Note that due to the definition of program π and π several resulting
minimize consistent
answer-sets may represent the same derived argument: This is the case for a∗ where
2
actually three models are derived by the program π . They only differ in the
consistent
respectivetruthassignmentstrue(consistent,·)andfalse(consistent,·).Weeliminate
duplicatesinanadditionalpost-processingstepinordertoremoveredundantinforma-
tion.
3.3 IdentifyingConflictsbetweenArguments
We now want to compute attacks between arguments. Therefore we first specify en-
codings that are used by every attack type (such as defeat and direct defeat). We then
presentencodingsforthecomputationoftheseattacktypes.
Inordertoreasonoverallargumentswefirsthaveto“flatten”theanswer-setsob-
tainedbyπ .Wespecifythisbythepredicatesas(A,fs,·)andas(A,claim,·).
arguments
Aisanumerickeyidentifyingtheargument.
Example8. We illustrate this by the answer-sets a , a and a from Example 7. This
1 2 3
inputisgivenbythefollowingfacts:
{as(1,fs,a).as(1,sclaim,a).as(2,fs,imp(a,b)).as(2,sclaim,imp(a,b)).as(3,fs,a).
as(3,fs,imp(a,b)).as(3,sclaim,b).}
In order to identify conflicts between arguments we first guess two arguments.
selected1(·)andselected2(·)containthekeysoftheselectedarguments.
πatt =(cid:8)1{selected1(A):as(A, , )}1. (1)
1{selected2(A):as(A, , )}1.(cid:9) (2)
Furthermore,weconstructonesinglesupportformulaforeachargumentAbycon-
junction of all formulae in as(A,fs,·). As in the previous section we first define an
orderingoverallformulaethatarecontainedinthesupport.Theonlydifferenceisthat
weaddtheargument’skeyAtothepredicatesinf(A,·),sup(A,·)andsucc(A,·,·).Due
tobrevity,thecorrespondingprogramπ isomitted.Wecanthenconstructthesup-
<key
portformulabyiteratingovertheorderingandconnectingtheformulaebyconjunction.
Notethatthelastparameteroffs conj(A,·,·)issimplyusedasanidentifierforthecur-
rentpositionintheiteration.Whenthesupremumisreachedwederivesupport(A,·)
forAcontainingthesupportformula.
πsupport =(cid:8)fsconj(A,X,X)←inf(A,X),sup(A,X); (1)
fsconj(A,and(X,Y),Y)←inf(A,X),succ(A,X,Y); (2)
fsconj(A,and(O,N),N)←succ(A,C,N),fsconj(A,O,C); (3)
support(A,X)←fsconj(A,X,C),sup(A,C).(cid:9) (4)
For the computation of attacks we again apply the saturation technique. The pro-
gramπ isusedtosaturateallattackcomputations.First,wederiveallattacktype
attsat
keystfromthetruthassignmentstrue(t,·)andfalse(t,·)oftheappliedattacktypepro-
grams. Note that the corresponding assignments are defined separately in each attack
program. In case attack is derived for all truth assignments in some attack program