Dispute resolution is an essential part of argumentation. Although there have been particular advances in computational argumentation with machine learning, we assume that explicit and deterministic techniques for dispute resolution still have significant potential. There are semantic approaches to argument representation, such as the Argument Interchange Format that supports a certain level of interoperability, but according to our knowledge, dispute resolution techniques based on semantics are not yet studied. In this research, we consider single mixed disputes through abstract argumentation frameworks and propose a method for representing such disputes in OWL DL that allows resolving them with reasoning. Additionally, we develop an algorithm for generating the OWL DL representation having argument sets and attack relations as input. The algorithm is validated with a proof of concept implementation, and the OWL DL representation - with an example of correct dispute resolution performed by reasoning over the generated ontology.
An argument is a piece of reasoning implying a transition from premises to a conclusion that expresses the opinion to be defended. Argumentation can be considered from diferent angles, among them are persuasion, proof, decision-making, information-seeking, dispute resolution, etc. Argumentation is a multidisciplinary research field that spans across diverse areas such as logic, philosophy, language, rhetoric, law, psychology, and computer science. Argumentation plays an essential role in artificial intelligence study, due to its ability to conjugate user-related cognitive models with computational models for automated reasoning. Neighboring areas inside the artificial intelligence domain include machine learning, natural language processing, discourse analysis, computational linguistics, information extraction, and knowledge representation. Computational argumentation has recently become a hot topic due to recent advances in machine learning methods that promise to enable applications of artificial intelligence to social, economic sciences, and policymaking.
Although there are particular advances in argumentation mining [
Disputes are divided into single and multiple ones according to the number of propositions
that constitute the parties’ points of view, and into unmixed and mixed ones, depending on
the parties’ intentions to defend their point of view or criticize other opinions, or do both,
respectively [
The contributions of the present work are the following: 1) a method for representing argumentation with OWL DL1 that is based on abstract argumentation frameworks and supports dispute resolution with reasoning, and 2) an algorithm for generating the OWL representation having argument sets and attack relations as input. The algorithm is validated with a proof of concept implementation, and the OWL DL representation – with an example of the correct dispute resolution performed by reasoning over the generated ontology.
A method for the formal representation of an argument is called an argumentation framework.
There are several argumentation frameworks. In [
Considering the computational aspect, currently, the most widely used argument
representation is the Argument Interchange Format (AIF) [
A project [
2https://www.w3.org/RDF/ format. The system implements the identification of argumentative indicators and automated evaluation of the persuasiveness of the arguments.
Another argument representation format, Argdown3 is a Markdown4-inspired argument mark-up language, implemented as a context-free grammar and parser. It allows representing dialogical argumentation and generating argument maps but does not provide any dispute resolution procedures.
The legal domain is closely related to the argumentation theory. The Legal Knowledge
Interchange Format (LKIF) [
In [
Our dispute resolution algorithm is based on Dung’s abstract argumentation framework,
described in [
Definition 1.
An argumentation framework is a pair
=< , >, where is a set of arguments and ⊆ × .
We say that an argument attacks an argument (or is attacked by ) if (, ) holds. Similarly, we say that a set of arguments attacks (or is attacked by ) if is attacked by an argument in . The binary abstract relation (, ) between arguments and symbolizes how the criticism of argument rejects argument ; and how a further critical development in the dialog (, ) rejects argument by counterattacking it and thereby returns argument as defended.
Unlike the entailment relation, the attack relation is not reflexive, symmetric, or transitive. This transferred the formal logical representation of argumentation from the microlevel of the internal structure of the argument to the macrolevel of the structure of argumentation in the
4https://daringfireball.net/projects/markdown/syntax dispute and made it possible to overcome the restrictions of the classical argumentation analysis on modeling criticism.
Another feature of this argumentation framework is the usage of procedural semantics instead of classical logic frameworks. For a set of arguments, procedural semantics allows to define subsets with specific properties, including consistency and completeness, where required. Thus, Dung defines a conflict-free set of arguments.
Definition 2. A set of arguments is said to be conflict-free if there are no arguments and in such that attacks .
The notion of acceptability allows determining dispute outcomes.
Definition 3. An argument ∈ is acceptable with respect to a set of arguments if for each argument ∈ : if attacks then is attacked by .
Finally, an admissible set of arguments is a set of acceptable arguments.
Definition 4. A conflict-free set of arguments is admissible if each argument in is acceptable with respect to .
For a resolution of the single unmixed dispute, it is suficient that there is a nonempty admissible subset of arguments, that is, there is at least one acceptable argument. Thus, the dispute resolution problem can be considered as a classification of arguments into admissible sets.
Example 1. Let us consider the original example of argumentation from Dung’s paper [
• I: But your government is a terrorist government.
This argument is formalized as two argumentation sets = {1, 2} and = {}, and attack pairs {(1, ), (, 1), (2, )}. Both sets are conflict-free, but the argument is not acceptable w.r.t. , as it is attacked by 2, but no argument from attacks 2. Thus, there is a non-empty admissible subset only for .
Our OWL DL implementation of Dung’s framework is designed in a way that provides the automatic classification of arguments into admissible sets with reasoning. We illustrate the implementation with listings in the Manchester syntax.
The formalization of the basic elements of the framework is straightforward. Each argument set is represented as an owl:Class.
Class: <onto.owl#A>
SubClassOf: owl:Thing
Each argument is considered to be an owl:NamedIndividual. The belonging of an argument to the argument set is represented with the rdf:type relation. The text of the argument is stored in rdfs:label.
To represent the attacks relation, the owl:ObjectProperty ’attacks’ is defined (for clearness, here and further we write custom OWL entities in apostrophes). Also, the property ’isAttackedBy’ is defined as owl:inverseOf ’attacks’. It is required for defining admissible sets of arguments.
ObjectProperty: <onto.owl#attacks>
InverseOf: <onto.owl#isAttackedBy>
In order to provide reasoning under Open World Assumption (OWA), we have to “close” each individual argument with respect to the list of arguments it attacks. We do this by asserting that the argument belongs to an unnamed class that has the relation ’attacks’ to the set of arguments it attacks, constructed with owl:oneOf operator under owl:allValuesFrom restriction. If the argument attacks no argument, we assert that it attacks only owl:Nothing.
For the same reason, we also close each individual argument regarding the relation ’isAttackedBy’.
Listing 6: Example of closing an argument regarding the ’isAttackedBy’ relation To define a conflict-free set in a manner that supports reasoning under the OWA, we can not use the owl:complementOf operator. Thus, for each argument set we form a union of all other argument sets with owl:unionOf. Then its conflict-free subset is defined as a class that has the relation ’attacks’ only (owl:allValuesFrom) to the union of other argument sets. Class: <onto.owl#AConflictFree>
EquivalentTo: <onto.owl#A> and (<onto.owl#attacks> only (<onto.owl#I>)) SubClassOf: <onto.owl#A>
For each conflict-free set, an admissible subset is defined as a class that has the relation ’isAttackedBy’ only (owl:allValuesFrom) to the arguments that have the relation ’isAttackedBy’ to some (owl:someValuesFrom) arguments from the initial conflict-free set. Thus, if an argument is attacked by no arguments, it also belongs to the admissible set.
Class: <onto.owl#AAdmissible>
EquivalentTo: <onto.owl#AConflictFree> and (<onto.owl#isAttackedBy> only (<onto.owl#isAttackedBy> some <onto.owl#
AConflictFree>)) SubClassOf: <onto.owl#AConflictFree>
Example 2. Let us implement the argument from the Example 1 in OWL DL. The resulting class hierarchy visualized with Protege interface is presented in Fig. 1. The full declarations of the arguments 1, and 2 are presented in Listings 9, 10 and 11 respectively.
Individual: <onto.owl#i1>
Annotations: rdfs:label "My government cannot negotiate with your government because your government doesn’t even recognize my government"^^xsd:string
Listing 10: Declaration of Individual: <onto.owl#i2>
Annotations:
rdfs:label "But your government is a terrorist government"^^xsd:string Types: <onto.owl#I>, <onto.owl#attacks> only ({<onto.owl#a>}), <onto.owl#isAttackedBy> only owl:Nothing Facts: <onto.owl#attacks> <onto.owl#a>
Listing 11: Declaration of 2
The algorithm is intended to generate the described OWL DL representations of arguments using the list of argument sets and attack pairs as input. For better readability, the algorithm is divided into three steps.
Algorithm 1 declares basic entities including argument sets, arguments, ’attacks’ and ’isAttackedBy’ relations, and infers ’isAttackedBy’ statements with reasoning. Not considering reasoning, the algorithm has linear complexity, as it only runs once through both lists of arguments in argument sets and of attack pairs.
Algorithm 1 Basic entities generation Require: Argument sets, attack pairs
Create ontology for argument set in argument sets do
Create an owl:Class for argument ∈ do
Create an owl:NamedIndividual of rdf:type end for end for Create owl:ObjectProperty ’attacks’ Create owl:ObjectProperty ’isAttackedBy’ Assert ’isAttackedBy’ owl:inverseOf ’attacks’ for (1, 2) in attack pairs do
Find the instance 1 in for 1 Find the instance 2 in for 2
Assert 1 ’attacks’ 2 end for Run reasoner
Algorithm 2 closes arguments regarding ’attacks’ and ’isAttackedBy’ relation to support the reasoning under OWA. This algorithm also has linear complexity regarding the number of arguments.
Algorithm 3 declares conflict-free and admissible subsets of arguments for each input argument set and classifies arguments into them with reasoning. As declaring a conflict-free set for the argument set requires constructing a list of other argument sets, this algorithm has quadratic complexity regarding the number of argument sets.
Thus, the algorithm generates an ontology that contains an empty admissible subset for each argument set. These admissible subsets are then populated by classifying arguments with reasoning.
Input Data For proof of concept, the input data, i.e. argument sets and attack pairs, are represented in JSON format. Its structure includes two high-level keys: argument_sets and Algorithm 2 Closing world Require: Ontology for argument instance in do
Get the set of the arguments attacks if is empty then
Assert rdf:type (’attacks’ owl:AllValuesFrom owl:Nothing) else
Assert rdf:type ’attacks’ owl:AllValuesFrom owl:OneOf()) end if Get the set of the arguments is attacked by if is empty then
Assert rdf:type (’isAttackedB’ owl:AllValuesFrom owl:Nothing) else
Assert rdf:type (’isAttackedBy’ owl:AllValuesFrom owl:OneOf()) end if end for Algorithm 3 Inferring solution Require: Argument sets, ontology for argument set in argument sets do
Find the class for in Create its subclass Create an empty set for argument set in argument sets do if is not then
Find the class for in
Add to end if end for
Assert owl:equivalentClass (owl:intersectionOf (, ’attacks’ owl:allValuesFrom owl:unionOf()))
Create subclass of
Assert owl:equivalentClass (owl:intersectionOf ( , ’isAttackedBy’ owl:allValuesFrom (’isAttackedBy’ owl:someValuesFrom ))) end for
Run reasoner attack_pairs. The key argument_sets has a dictionary, where each item represents an argument set. The argument set item has a label and a dictionary of arguments that belong to it. Each argument item in the latter dictionary has a label and a text. The key attack_pairs has a list of two-element lists of argument labels that represent attack pairs. Formatted input data for Example 1 are provided in Listing 12. { "argument_sets": { "I": { "i1": "My government cannot negotiate with your government because your government doesn’t even recognize my government", "i2": "But your government is a terrorist government" }, "A": {
"a": "Your government doesn’t recognize my government either" }
Prototype The algorithm was implemented with Python language using Owlready2 library5
for working with OWL and the Pellet reasoner [
Results The most intransparent parts of the algorithm are running reasoner for 1) inferring ’isAttackedBy’ assertions, and 2) classifying arguments into conflict-free and admissible sets. We provide the logs of these runs, conducted in Windows 10 OS with Intel Core i7-11850H CPU and 16GB RAM. The first run took 0.72 s. and as a result, 6 individual assertions were inferred, see Listing 13. The second run classified 3 individuals for 0.75 s., see Listing 14. * Owlready2 * Pellet took 0.7212517261505127 seconds * Owlready2 * Pellet output: http://www.w3.org/2002/07/owl#Thing onto.owl#A - (onto.owl#a) onto.owl#I - (onto.owl#i1, onto.owl#i2) PROPINST: onto.owl#i1 onto.owl#attacks onto.owl#a PROPINST: onto.owl#i1 onto.owl#isAttackedBy onto.owl#a PROPINST: onto.owl#a onto.owl#attacks onto.owl#i1 PROPINST: onto.owl#a onto.owl#isAttackedBy onto.owl#i1
PROPINST: onto.owl#a onto.owl#isAttackedBy onto.owl#i2 PROPINST: onto.owl#i2 onto.owl#attacks onto.owl#a
Listing 13: Inferring ’isAttackedBy’ relation * Owlready2 * Pellet took 0.75439453125 seconds * Owlready2 * Pellet output: http://www.w3.org/2002/07/owl#Thing onto.owl#A onto.owl#AConflictFree - (onto.owl#a)
onto.owl#AAdmissible onto.owl#I onto.owl#IConflictFree onto.owl#IAdmissible - (onto.owl#i1, onto.owl#i2)
In result, the arguments 1 and 2 were correctly classified as acceptable, and assigned to the class , i.e. the admissible subclass of the argument set . And the argument was correctly assigned only to the class , i.e. the conflict-free subset of the argument set .
In this research, we reviewed existing solutions related to semantic argument representation and concluded that among them, there is no approach that would provide a dispute resolution technique. Based on Dung’s abstract argumentation frameworks, we proposed a method for OWL DL representation of single mixed disputes designed in a manner that allows their resolution with reasoning. Moreover, we proposed an algorithm for the generation of the OWL DL representations having argument sets and attack pairs as input. The algorithm has quadratic complexity and is validated with a proof of concept implementation. The proposed representation is validated with an example of the correct dispute resolution over the generated ontology. Future work will address extending the present approach for implementing complete, preferred and stable extensions of argument sets, and developing approaches for the computational resolution of other types of disputes. The latter may require considering other argumentation frameworks. We also plan to automate the input data preparation with text annotation, NLP techniques and machine learning.
This work was co-funded by the European Research Council for the project ScienceGRAPH (Grant agreement ID: 819536) and NFDI4DataScience funded by the German Research Foundation (DFG project number 460234259). The support from the Russian Science Foundation, project No. 20-18-00158, realised at St. Petersburg State University, is kindly recognized.