Over the last decades, argumentation has become increasingly central as a frontier research within artificial intelligence (AI), especially around the notions of interpretability and explainability, which are more and more required within AI applications. In this paper we present the first prototype of Arg-tuProlog, a logic-based argumentation tool built on top of the tuProlog system. In particular, Arg-tuProlog enables defeasible reasoning and argumentation, and deals with priorities over rules. It also includes a formal method for dealing with burden of proof (burden of persuasion). Being lightweight and compliant to the requirements for micro-intelligence, Arg-tuProlog is perfectly suited for injecting argumentation into distributed pervasive systems.
In recent years we are witnessing a renewed interest in logical models for symbolic
automated reasoning—mostly related to their interpretability and explainability
features, more and more required by artificial intelligence (AI) technologies [
As intelligent systems need to communicate, reason, and act in accordance
with the law, computable models of legal argumentation are particularly
significant for the development of robust and law compliant intelligent systems [
Accordingly, this work presents the Arg-tuProlog tool—a lightweight
tuPrologbased implementation for structured argumentation [
The work is structured as follows. In Section 2, we provide a global overview of the framework discussing the formal foundations and the argumentation language for the operational use of the tool. Then, Section 3 discusses the architecture and the engine interface, whereas Section 4 presents the directives introduced by the Arg-tuProlog framework. Section 5 discusses a working example of the system. Finally, in Section 6 we overview similar systems already proposed in the literature. Section 7 provides for the final remarks. 2 2.1
Arg-tuProlog is a modular rule-based argumentation system to represent, reason, and argument upon conditional norms featuring obligations, prohibitions, and (strong or weak) permissions also according to burden of persuasion constraints.
The approach is based on common constructs in computational models of
argument that lay their root in Dung’s abstract argumentation [
Given an argumentation graph, the sets of arguments that are accepted or
rejected – that is, those arguments that will survive or not to possible attacks
– are computed using some semantics. For our purposes, we resort to labelling
semantics as reviewed in [
The language to encode knowledge in the argumentation framework is of primary concern. In fact, we aim at providing users with an interface as plain as possible in terms of interpretability and human readability.
Arg-tuProlog adopts an ASPIC+-like syntax – introduced in [
guage allows facts and rules to be encoded. Statements take the form ruleName : premise1 ; : : : ; premisen => conclusion: Unconditioned statement (facts) can be expressed with the notation: factName : [] => 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, with the addition of three further notations p(term) to indicate permission; o(term) to indicate obligation.
term, to indicate a strong negation, as opposed to the negation as failure implemented within the tuProlog engine.
The formalism includes permissions, prohibitions, and obligations; the
corresponding logic is captured by defeasible rule schemata, modelling basic deontic
inference [
In general, strong negations cannot be nested. The only exception to this rule is in the use of deontic operators, in particular to manage prohibitions—a lack of prohibition can be defined exploiting two strong negations: o( term).
Finally, inside premises, weak negation (negation as failure) can be expressed as (term). As above, this operator can not be nested. This notation is useful to express exceptions to the applicability of a rule or make assumption: it defines an undercut attack.
Superiority relation. Many non-monotonic reasoning and argumentation tools
– ABA+ [
Arg-tuProlog makes it possible to denote preferences by using the following notation: sup(ruleName1 ; ruleName2 ) This proposition states that the rule with identifier equal to ruleName1 is superior to the one with identifier ruleName2 . The superiority relation between ruleName1 and ruleName2 makes it possible to solve the conflict between arguments in favour of arguments built from ruleName1 . The preference relation over arguments can be defined in various ways based on the preference over rules. We adopt a simple last-link ordering, according to which an argument A is preferred over another argument B if and only if the top rule of A is superior to the rule top rule of B.
Burden of persuasion. The burden of persuasion, born in the legal field but then extended also to philosophy, allows a response on the acceptability of an argument to be obtained even in situations that would normally be uncertain. Generally speaking, the burden of persuasion specifies which party has to prove a statement to a specified degree (the standard of proof) on the penalty of losing on the issue. Whether this burden is met is determined in the final stage of a proceeding, after all evidences are provided. The burden of persuasion for a claim can be defined – under a logical perspective – as the task of ensuring that in the final stage of the proceeding there exists a justified argument for the claim. Generally speaking, we can say that if there is a burden of persuasion for a conclusion , then argument for will be rejected unless they strictly prevail against all counterarguments (that are not rejected on other grounds). As a consequence, the collision between arguments for and arguments for will be decided in favour of the latter, in the absence of a priority for the first.
In our model, the burden of persuasion may be captured in a second stage concerning argument labellings, only after the base labelling has been computed. It only concerns the arguments labelled UND. So, a burden of persuasion labelling addresses UND arguments, and assigns OUT and IN labels depending on the allocation of the burden of persuasion.
Formally, the burden of persuasion on a proposition can be expressed as follows:
bp(term1 ; : : : ; termn ): The structure of terms reflects the one seen for standard rules: compound terms, variables and strong negations are therefore allowed. 3
The Arg-tuProlog framework3 aims at providing a comprehensive and innovative tool for spreading intelligence and argumentation capabilities in nowadays challenging AI context. It tries to address the issues arising in the actual technological landscape of intelligent systems—with particular attention to the legal and explainability issues.
The interoperability and portability requirements of intelligent systems drive
us to the choice of tuProlog [
The main and distinguishing aspect of the Arg-tuProlog engine is represented by its design, which aims at providing two distinct ways of use: a) the graph-based mode providing as output the entire argumentation graph according to the specified semantics—i.e., the labellings of the entire set of facts and rules given as input; b) the query-based mode providing as output the evaluation of a single query given as input and according to a given semantics—i.e., enabling defeasible reasoning on arguments starting from certain premises.
While the former mode can be considered as the traditional approach of argumentation tools, the latter makes the Arg-tuProlog framework a fit choice for the aforementioned AI pervasive scenarios.
In the context of multi-agent systems (MAS), Arg-tuProlog enables agents to correctly deal with incomplete or missing knowledge, encouraging argumentation and dialogue among them in order to reach an agreement or influence a decision. In our vision, the agent intelligent behaviour is likely to be associated with the capability of debating about the current context, by reaching a consensus on what is happening around and what is needed, and by triggering and directing proper conversations to decide how to collectively act in order to reach the future desirable state of the affairs. Knowledge is shared and decentralised, and the ArgtuProlog engine provides both the agents and the environment abstraction of MAS with reasoning and argumentation capabilities, making it possible to reach a social consensus on what is better to do. For these reasons, it fits perfectly with the AI scenarios recalled in Section 1. 3 https://pika-lab.gitlab.io/argumentation/arg2p/ The framework leverages on the underlying tuProlog engine. All the required components exploit the tuProlog feature to allow external libraries to be included during the evaluation process. Consequently, the entire framework is a collection of tuProlog compatible libraries.
Fig. 1 shows the modules composing the system. It is designed in a fullymodular way. Every function inside the framework – e.g., graph building, or argument labelling – is sealed in the corresponding module. Modularity highly improves upgradability and flexibility – in terms of adding of new features or requirements modification – of the entire system. For example, one may consider the Grounded Labeller, responsible for computing the grounded labelling of the argumentation graph. In order to add a different labelling semantics, it would only require to create an ad-hoc module, without impacting the rest of the system. In the following, we describe each component in detail.
Engine interface. The Engine Interface module hides all the complexity of the framework. It exposes only the two usage predicates—namely, answerQuery/2 and buildLabelSets/0 transparently orchestrating the basic modules.
The predicate answerQuery(+Goal, -Yes, -No, -Und) requests the evaluation of the given Goal. The output corresponds to the set of facts matching the goal, distributed in the three sets—namely, IN, OUT, and UND. The IN set includes facts classified as acceptable, the OUT is for the rejected ones and the UND is for those of which it was not possible to classify due to lack of information. For instance, assume to query the system about doctors’ liability (for instance, in case of medical malpractice, according to the applicable law to which doctors are liable for the harm suffered by a patient if they were negligent in treating the patient) in a case where Dr. Murphy should be considered liable, while Dr. House not. The predicate usage would be answerQuery(liable(Doctor), Yes, No, Und), and the result would be composed by the three sets containing the solutions IN=[liable(drMurphy)], OUT=[liable(drHouse)] and UND=[].
The predicate buildLabelSets builds and prints (in the output interface) the argument and the statement labellings according to the provided theory based on the construction and evaluation of the arguments. All arguments and statements are therefore evaluated.
The user interface also provides two flags, which can be set in the application
as facts of the Prolog theory, for setting useful options in the resolution process.
Both flags deals with the management of the burden of persuasion. The first flag
is demonstration: if activated, the output prints the labelling resolution process
step by step, pointing out the specific part of the definition presented in [
The intuition behind incompleteness is the following: when we accept a
conclusion since the burden of persuasion is on , we may still remain uncertain
on the premises for that conclusion. For instance, we may accept that the
doctor was negligent since he failed to provide a convincing argument about why
he was not negligent, and still be uncertain whether the doctor did or did not
comply with the guidelines. The opposite approach is also possible: if we accept
an argument based on the burden of persuasion, we are also bound to accept all
of its sub-arguments. This approach leads to the concepts of a complete and a
grounded burden of persuasion labelling [
Language parser. The Language Parser module is aimed at converting the rules in the defined argumentation language (Section 2) into a correct Prolog theory. In fact, in this first prototype, Arg-tuProlog acts as a meta-interpreter. The meta-interpreter accepts theories in a well-defined argumentation language, translates them in Prolog – exploiting this module – and, finally, completes the computation providing the requested solutions.
Algorithmic modules. The rest of the modules are mainly linked to algorithmic responsibilities, in particular:
Graph Builder builds the argumentation graph Grounded Labeller, in charge of computing grounded labelling of the argumentation graph, according to the Dung’s notions of grounded semantics BP Labeller builds the second stage burden of persuasion labelling starting from the grounded labelling Statement Labeller carries out the statements labelling according to the two previous steps.
Details about these modules are provided in Section 4. In Section 3 we present the two user predicates provided by the Arg-tuProlog framework—namely, answerQuery =4 and buildLabelSets =0. Their semantics leverages on a common resolution process exploited to build the argumentation graph and evaluate the arguments. In particular, the resolution process can be split into three distinct steps: 1. the argumentation graph construction; 2. the arguments labelling according to the different labelling semantics—namely, grounded, burden of persuasion (BP), and BP complete; 3. the statements labelling according to the arguments labelling. The predicate buildLabelSets =0 performs all the three steps and provide the argumentation graph and its labelling as solutions. The predicate answerQuery =4, once built the argumentation graph and its labelling, searches for the specific solution (input Goal) in the labelling sets. In the following, further details of each step are discussed. 4.1
As in any logic-based argumentation framework, an argument is not a generic
entity: instead, it is a pair, whose first part is a coherent minimum set of formulas
sufficient to prove the formula contained in its second part. Relationships of
support – in the case an argument sustains the same conclusion of another one – or
attack – in the case an argument conclusion is in contrast with another argument
claim – connect the arguments between them. Construction of arguments, and
of their relationships, is ascribed to the predicate buildArgumentationGraph=1.
Formally, arguments have three properties (c.f. [
They are added to the theory in the form:
argument ([[RN1 ; : : : ; RNn ]; Top RN ; Conc]): Arguments are built searching all the distinct and coherent subsets of facts and rules sharing the same conclusion contained by the input theory. The support relationship between arguments is expressed as follows:
support (supporter _argument ; supported _argument ): Through the predicate support =2, it is possible to reconstruct the entire tree that led to the creation of an argument.
The attack relations between the arguments – rebut or undercut – are instead defined in the form: attack (attacker _argument ; attacked _argument ):
Once the argumentation framework is built, it can be evaluated, and labels can be associated with each argument according to a specified semantics. Labels are a way of expressing acceptance/rejection of the arguments.
In Arg-tuProlog, labelling is built in two stages. The first stage is aimed
at computing the equivalent of Dung’s grounded extension [
The second stage of labelling takes into account the possible burden of persuasion (BP) on propositions. First, the BP specifications are pre-processed by grounding the contained variables if present (taking into account only evaluable arguments). The new set of grounded BP terms is then added to the theory in the form:
rei edBp([[grounded _term1 ]; : : : ; [grounded _termn ]]):
Then, the argumentBPLabelling =2 predicate is called to perform the labelling
according to the semantics specified in [
The predicate statementLabelling =2 labels all the statements in a set of conclusions of an argument according to the label of the argument. Therefore, the conclusions of IN arguments are labelled as IN, and the same for OUT and UND. 5
To ground the discussion, and show the Arg-tuProlog framework effectiveness,
in the following we discuss a running example from [
Let us consider a case in civil law where the allocation of the burden of persuasion act as follows. We assume that a doctor is liable for the harm suffered by a patient. However, there is an exception: the doctor can avoid liability if he shows he was not negligent. We also assume that a doctor is considered to be not negligent if he followed the medical guidelines that govern the case. Finally, we assume that it is uncertain whether the doctor has followed the guidelines in the case at hand. Let us first model the case without taking the burden into account. Accordingly, let us suppose the following premises and rules:
f1 : ) :guidelines f3 : ) harm r1 : :guidelines ) negligent r3 : :negligent ) :liable f2 : ) guidelines r2 : guidelines ) :negligent r4 : harm ) liable with r3 r4 . The theory can be expressed in the Arg-tuProlog argumentation language as follows: f1 : [] => - guidelines . f2 : [] => guidelines . f3 : [] => harm . r1 : - guidelines => negligent . r2 : guidelines => - negligent . r3 : - negligent => - liable . r4 : harm => liable .
sup (r4 , r3 ).
According to the knowledge base, we can then build the following arguments:
Ar1;f1 : Af1 ) negligent
Br3;r2;f1 : Br2;f2 ) :liable
Cf3 : ) harm Cr4;f3 : Cf3 ) liable The argumentation graph and its grounded fIN; OUT; UNDg-labelling are depicted in Fig. 2a, in which all arguments are UND, except argument Cf3. The green nodes are the ones labelled as IN, the red ones as OUT, the grey as UND. Fig. 2b depicts the same situation but a difference operation mode of the Arg-tuProlog engine. In particular, the system is asked to prove the liable goal, and as show in the solution tab, liable has been labelled as UND, since in the current situation no reasoning about the doctor liability can be done.
The result is not satisfactory according to the law, since it does not take into account the applicable burdens of persuasion. The doctor should have lost the case – i.e., be declared liable – since he failed to discharge his burden of proving he was not negligent—namely, he didn’t satisfy his burden of persuasion for his non-negligence. The doctor’s failure results from the fact that it remains uncertain whether he followed the guidelines. In order to capture this aspect of the argument, we need to provide an indication for the burden of persuasion.
Now we assume – according to the Italian Law – to have bp(harm) and bp(:negligent), i.e., the doctor has to persuade the judge that he was not negligent, and the patient has to persuade the judge that he was harmed. We also assume it remains uncertain whether the doctor was diligent since it is uncertain whether he followed the guidelines, while the patient succeeded in proving harm (as the claim that there is harm was unchallenged). Then, since the doctor failed to meet his burden of proof, the doctor is considered to be liable.
The grounded BP-labelling is depicted in Fig. 3. In particular, Fig. 3a shows the argumentation graph, Fig. 3b the corresponding arguments labelling, and Fig. 3c the labelling resolution process step by step.
In contrast with the grounded fIN; OUT; UNDg-labelling where every argument is labelled UND, arguments Ar1;f1 and Cr4;f3 are now labelled IN, while Br2;f2 and (a) Grounded argumentation graph (b) Query-based mode Fig. 2: The Arg-tuProlog IDE with no burden of persuasion: grounded argumentation graph (a) and example of query-based mode usage (b).
Br3;r2;f1 are labelled OUT. It is still uncertain whether the doctor followed the guidelines (the corresponding arguments Af1 and Bf2 are UND).
A different result can be obtained by enabling the completion of the BPlabelling. Consequently, as depicted in Fig. 3d, argument Af1 for :guidelines is IN and argument Bf2 for guidelines is OUT. 6
Many argumentation tools have been proposed along the last decades and, in this work, we do not mean to give an exhaustive survey. In order to strengthen the motivation for this work, in the following we recall the related research panorama, highlighting differences and similarities. We restrict our scope to argumentation technologies only, that is, those coming with downloadable and usable tools—as in the case of Arg-tuProlog.
Three main approaches can be distinguished in the available tools: the area of
the rule-based abstract argumentation – where ASPIC+ [
The possibility of using open (non-ground) rules in knowledge, and of using different instances of the same predicates in different rules, could be a key ad(a) BP argumentation graph (b) BP argument labelling (c) BP labelling resolution process (d) BP-labelling graph completation vantage, especially when the same rule has to be applied to different instances within a single argument. This is usually not allowed in ABA-based tools, and we consider this a key feature in the design of Arg-tuProlog.
When a system has to deal with a high number of uncertain conflicts, the ability to rely not only on sceptical, but also on credulous reasoning, and in general on different semantics, may be important. Argumentation approaches have this ability natively while the one based on defeasible logic usually not, though also ambiguity propagation in defeasible logic can lead to similar results. The Arg-tuProlog prototype currently implements only the grounded semantics.
When a system has to address complex issues of legal reasoning, and full explainability is required, the ability to provide a picture of existing arguments and of the relations between them – with an an explanation on which arguments should or could be finally endorsed – may become a critical feature. This is a feature we could find in structured argumentation tools, like Arg-tuProlog, but not in defeasible logic tools.
A very similar approach to our work that deserves to be mentioned is
Argue tuProlog [
From a technological perspective, many improvements are required in order to make existing tools usable and effective in a distributed environment, as well as easily downloadable/deployable and well documented. Indeed, almost all the available systems can be classified as early prototypes, lacking in most cases of any support or documentation.
Finally, all the above reflections have to be combined with considerations about the effectiveness and ease in the use of the argumentation tools provided. 7
The work shows the effectiveness of Arg-tuProlog to: (i) deal with inconsistent information—thus enabling defeasible reasoning; (ii) integrate legal aspects—e.g. the possibility to explicit the burden of persuasion over terms; (iii) provide an easy and straightforward way to manipulate and interact with the engine.
One of the greatest strengths of the tool lies in its architecture: both modularity and complete integration with logic programming systems – being Prolog based – make it highly suitable for the target pervasive contexts of intelligent systems. In such contexts, in fact, it is preferable to be able to hook/unhook functions – i.e., libraries – according to the requirements. Moreover, the intrinsic integration with logic programming also makes it easier to respond to requirements such as interpretability, understandability and explainability. However, the prototype presented in this work is the starting point of the desiderata, various enhancements should be considered both in terms of research and efficiency. Efficiency issues. The main limit of the prototype is related to the query-based mode. In fact, to answer a single query – on a single statement – the argumentation graph on the whole theory has to be performed. As discussed in Section 6, different techniques have already been developed allowing for efficient single argument evaluation. We mean to exploit these algorithms in theArg-tuProlog framework. The second issue concerns the mechanism for building the argumentation graph. To derive the argumentation trees from facts and rules, an exhaustive search on the knowledge base is performed—i.e., the computational cost is roughly quadratic for the number of rules of the theory. Also, the labelling algorithm based on the burden of persuasion is extremely expensive—quadratic with respect to the number of arguments. Consequently, the most expensive operators should be implemented more efficiently—for example leveraging the tuProlog capabilities of integrating rules written directly in Java/Kotlin and, implementing an interpreter instead of the meta-interpreter proposed in the prototype. Research challenge and issues. From the point of view of the research, ArgtuProlog represents, in our vision, the fundamental brick for distributing symbolic intelligence in intelligent systems in compliance with the concept of microintelligence. The enabling of argumentation capabilities should give system actors properties like understandability and explainability – since the actors can argument over their decisions – but also normative enforcement—since actors can act in compliance with the law and violations can be timely observed. Under this perspective, many challenges open up. For example, an open point is how to manage the resolution of conflicts among agents. A single “arbitrator” to manage the whole argumentation process and force the other agents’ behaviour would certainly be impractical in distributed contexts, since it would soon become a bottleneck. One could perhaps think about “area arbitrator” responsible for a certain space and for a certain period of time – also considering the dynamism of knowledge and its change over time – but the best solution still has to be designed and tested. Furthermore, in modern pervasive contexts, symbolic techniques need to be suitably integrated with sub-symbolic algorithms in order to exploit synergies and benefits of each approach in a fruitful way. The high interoperability of Arg-tuProlog and its modular architecture make us think that it could be a useful technology for these purposes, yet many open points still deserve attention.