On Natural Language Generation of Formal Argumentation

by   Federico Cerutti, et al.

In this paper we provide a first analysis of the research questions that arise when dealing with the problem of communicating pieces of formal argumentation through natural language interfaces. It is a generally held opinion that formal models of argumentation naturally capture human argument, and some preliminary studies have focused on justifying this view. Unfortunately, the results are not only inconclusive, but seem to suggest that explaining formal argumentation to humans is a rather articulated task. Graphical models for expressing argumentation-based reasoning are appealing, but often humans require significant training to use these tools effectively. We claim that natural language interfaces to formal argumentation systems offer a real alternative, and may be the way forward for systems that capture human argument.



There are no comments yet.


page 1

page 2

page 3

page 4


Automatic Debate Evaluation with Argumentation Semantics and Natural Language Argument Graph Networks

The lack of annotated data on professional argumentation and complete ar...

Natural-Language Multi-Agent Simulations of Argumentative Opinion Dynamics

This paper develops a natural-language agent-based model of argumentatio...

Relations between assumption-based approaches in nonmonotonic logic and formal argumentation

In this paper we make a contribution to the unification of formal models...

A Two-Phase Approach Towards Identifying Argument Structure in Natural Language

We propose a new approach for extracting argument structure from natural...

Persuasive Natural Language Generation – A Literature Review

This literature review focuses on the use of Natural Language Generation...

Attentive Interaction Model: Modeling Changes in View in Argumentation

We present a neural architecture for modeling argumentative dialogue tha...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Our aim here is to explore the challenges that we need to face when thinking about natural language interfaces to formal argumentation. Dung [dung1995] states that formal argumentation “captures naturally the way humans argue to justify their solutions to many social problems.” This is one of the most common claims used to support research in formal argumentation. More recently there have been a number of empirical studies to investigate this claim [Rahwan2009, Cerutti2014f, RosenfeldKraus16, RosenfeldKraus16bis]. The results, however, have been far from conclusive.

The use of graphical models to represent arguments is the most common approach used in the formal argumentation community to capture argument structures. This has been successfully applied in a number of real world situations: Laronge [Laronge2012] (an American barrister and researcher), for example, describes how he used argumentation graphs during trials. Despite this, our claim is that to produce and to consume a graphical representation of a structure of arguments there is need for significant levels of training.

Instead of training users on another (graphical) language for representing argument structures, we can leverage our societal model, through which we are trained in reading and writing; that is, using natural language. We claim that natural language representations of formal argumentation are the way forward to develop formal models that capture human argumentation. In this paper we investigate one aspect of natural language interfaces to formal argumentation: moving from formal arguments to natural language text by exploiting Natural Language Generation (NLG) systems. We ground our investigation on an existing example (Section 2) from collaboration between the BBC and the Dundee argumentation group [Lawrence2012], namely an excerpt of the BBC Radio 4 Moral Maze programme from 22nd June 2012. In this way the reader can always relate to the original piece of text from where our investigation started. The excerpt has been already formalised into an argument network (i.e. a graph linking together different pieces of information together to display the web of arguments exchanged). In Figure 1 and in Section 3 we review all the necessary elements for our investigation: the notion of argumentation schemes; how to represent argument networks in the Argument Interchange Format (AIF); a (simple) approach to structured argumentation to build arguments and approximate arguments from an AIF argument network; Dung’s theory of argumentation; and basic elements of NLG.

In NLG one of the most difficult tasks is to determine the communicative goal; i.e. deciding what we would like to communicate. Therefore, Section 4 is entirely dedicated to investigating relevant communicative goals in the context of formal argumentation.

The result we wish to achieve in this paper is a blueprint that outlines the complex research questions and their dense interconnections that our community needs to address in order to identify models that naturally capture human argumentation.

2 Running Example

On 22nd June 2012, in the middle of the European debt crisis, the Moral Maze program on BBC Radio 4 addressed the topic of individual and national debt. Among others, Nick Dearden, director of the Jubilee Debt Campaign, and Claire Fox, from the Institute of Ideas, were ‘witnesses’ (contributors offering a specific point of view in the debate) during the program.

What follows is an excerpt that has been analysed to identify the argument network in the dialogue and made available at http://aifdb.org/argview/1724 [Lawrence2012]. In this paper we focus on the sub-part of the argument network depicted in Figure 1 and we highlight in the text the elements that contribute to the generation of such an argument network.

Claire Fox I understand that. I suppose my concern is just this: I want the freedom to be able to write off debts but — I’m sure you recognise this — there is this sort of sense amongst a lot of young people, who just think, “I want that, so I’ll have that now. Thank you.” And so, if you want the moral hazard, instead of kind of just going on about the bankers, is there not a danger that if we just said we’d write off debt, that it actually isn’t very helpful for our side, for ordinary people, to actually have that? [T1] There’s no discipline there [T2]. In some ways you need that discipline, don’t you, to be a saver, to think, “I won’t get into debt?” [T3]

Nick Dearden In some ways I agree with you. If you want the economy to run smoothly, you have to incentivise certain types of behaviour. [T4] So, for example in South Korea, in terms of how South Korean grew, it did incentivise saving, at certain times, by certain economic policies [T5]. On the other hand, I think what people don’t realise, or only half realise, is the fact that we have actually written off massive amounts of debt [T6]. But it certainly isn’t the debts of the people who most need it in society [T7].

Figure 1: Argument network for the running example, as obtained from http://aifdb.org/argview/1724 (edited version)

3 Background

3.1 Argumentation Schemes

Argumentation schemes [waltonetal2008, Walton2009] are abstract reasoning patterns commonly used in everyday conversational argumentation, legal, scientific argumentation, etc. Schemes have been derived from empirical studies of human argument and debate. They can capture traditional deductive and inductive approaches as well as plausible reasoning. Each scheme has a set of critical questions that represents standard ways of critically probing into an argument to find aspects of it that are open to criticism.

For instance, in the dialogue reported in Section 2, part of Nick’s position can be mapped into an argument from example that has the following structure:

Premise: In this particular case, individual a has property F and also property G.
Conclusion: Therefore, generally, if x has property F, the it also has property G.

One of the critical questions here is: “Is the proposition claimed in the premise in fact true?”

3.2 Representing an Argument Network

The Argument Interchange Format (AIF) [CHESNEVAR2006, Rahwan2009] is the current proposal for a standard notation for argument structures. It is based on a graph that specifies two types of nodes: information nodes (or I-nodes) and scheme nodes (or S-nodes). These are represented by two disjoint sets, and , where information nodes represent claims, premises, data, etc., and scheme nodes capture the application of patterns of reasoning belonging to a set , . Reasoning patterns can be of three types: rule of inference ; criteria of preference ; and criteria of conflicts .

The relation expresses that a scheme node instantiates a particular scheme. Scheme nodes, moreover, can be one of three types: rule of inference application nodes ; preference application nodes ; or conflict application nodes , with , and .

Nodes are connected by edges whose semantics is implicitly defined by their use. For instance, an information node connected to a RA scheme node, with the arrow terminating in the latter, would suggest that the information node serves as a premise for an inference rule. Figure 1 shows an AIF representation of the arguments exchanged in the dialogue introduced in Section 2. Rectangular nodes represent information nodes, while rhombic ones represent scheme nodes: green for RA nodes, and red for CA nodes.

3.3 Deductive Argumentation

Using deductive argumentation means that each argument is defined using a logic, and in the following we adopt the simple, but elegant logic proposed by Besnard & Hunter [Besnard2014a]. Thus, we let be a logical language. If is an atom in , then is a positive literal in , and is a negative literal in . For a literal , the complement of the positive literal is (resp. if is not a positive literal, its complement is the positive literal ).

A simple rule is of the form where are literals. A simple logical knowledge base is a set of literals and a set of simple rules. Given a simple logic knowledge base, , the simple consequence relation is defined, such that if and only if there is a rule and either or . Now, given and a literal , is a simple argument if and only if and such that . is the support (or premises, assumptions) of the argument, and is the claim (or conclusion) of the argument. Given an argument , the function returns , and returns .

For simple arguments a and b we consider the following types of simple attack:

  • a is a simple undercut of b if there is a simple rule in and there is an such that is the complement of ;

  • a is a simple rebut of b if is the complement of .

Following Black & Hunter [Black2012], an approximate argument is a pair . If , then is also valid; if , then is also consistent; if , and there is no such that , then is also minimal; if , and , then is also expansive (i.e. it is valid and consistent, but it may have unnecessary premises).

Building on top of Figure 1 and transforming each node into a simple rule, a simple knowledge base for our running example is:

Therefore, the following are the simple arguments that can be built from :

with d rebutting b, and d undercutting c.

However, there are many more approximate arguments. For instance, is an approximate argument in favour of [T1] taking into consideration all the inferences that might help concluding it. Conversely, is the minimal (invalid) approximate argument in favour of [T1].

3.4 Abstract Argumentation

An argumentation framework [dung1995] consists of a set of arguments and a binary attack relation between them.

Definition 1

An argumentation framework () is a pair where is a set of arguments and . We say that b attacks a iff , also denoted as . The set of attackers of an argument a will be denoted as , the set of arguments attacked by a will be denoted as . We also extend these notations to sets of arguments, i.e. given , iff s.t. ; iff s.t. ; iff s.t. ; and .

Each argumentation framework, therefore, has an associated directed graph where the vertices are the arguments, and the edges are the attacks.

The basic properties of conflict–freeness, acceptability, and admissibility of a set of arguments are fundamental for the definition of argumentation semantics.

Definition 2

Given an :

  • a set is a conflict–free set of if s.t. ;

  • an argument is acceptable with respect to a set of if s.t. , s.t. ;

  • a set is an admissible set of if is a conflict–free set of and every element of is acceptable with respect to , i.e. .

An argumentation semantics prescribes for any a set of extensions, denoted as , namely a set of sets of arguments satisfying the conditions dictated by . For instance, here is the definition of preferred (denoted as ) semantics.

Definition 3

Given an , a set is a preferred extension of , i.e. , iff is a maximal (w.r.t. set inclusion) admissible set of .

Given a semantics , an argument a is said to be credulously accepted w.r.t. if a belongs to at least one -extension. a is skeptically accepted w.r.t. if a belongs to all the -extensions.

It can be noted that each complete extension implicitly defines a three-valued labelling function on the set of arguments: an argument a is labelled iff ; is labelled iff s.t. ; and is labelled if neither of the above conditions holds. In the light of this correspondence, argumentation semantics can be equivalently defined in terms of labellings rather than of extensions [Caminada2006, KER2011].

We can now introduce the concept of the issues of an argumentation framework whose status is enough to determine the status of all the arguments in the framework [gabbay2009b, Booth2012, Booth2014].

Definition 4

Given an and the set of all complete labellings of , for any , iff , ; or , ().

The set of arguments in the equivalent class is the set of issues of :

Continuing with our running example, Figure 2 depicts the argumentation framework from Section 3.3 applying deductive argumentation on the argument network of Figure 1: .




Figure 2: The for Figure 1 interpreted using deductive argumentation.

There are two preferred extensions: . Moreover, , and if , (and viceversa).

3.5 Natural Language Generation

A Natural Language Generation (NLG) system requires [Reiter2000]:

  • A knowledge source to be used;

  • A communicative goal to be achieved;

  • A user model; and

  • A discourse history.

In general, the knowledge source is the information about the domain, while the communicative goal describes the purpose of the text to be generated. The user model is a characterisation of the intended audience, and the discourse history is a model of what has been said so far.

X[2,l] X[3,l] X[2,l] Module & Content task & Structure task
Document planning & Content determination & Document structuring
Microplanning & Lexicalisation
Referring expression generation & Aggregation
Realisation & Linguistic realisation & Structure realisation

Table 1: Modules and tasks of a NLG system, adapted from [Reiter2000, Figure 3.1].

An NLG system divides processing into a pipeline [Reiter2000] composed of the three stages described in Table 1. First it determines the content and structure of a document (document planning); then it looks at syntactic structures and choices of words that needs to be used to communicate the content chosen in the document planning (microplanning). Finally, it maps the output of the microplanner into text (realisation).

Each stage includes tasks that can be primary concerned with either content or structure. Document planning requires content determination — deciding what information should be communicated in the output document — and document structuring — how to order the information to be conveyed.

Microplanning requires (1) lexicalisation — deciding what syntactic constructions our NLG system should use; (2) referring expression generation — how to relate with entities; and (3) aggregation — how to map the structures created by the document planning onto linguistic structures such as sentences and paragraphs.

Document planning and microplanning are the most strategic and complex modules in this pipeline. They focus on identifying the communicative goal and how it relates to the user model, thus producing the blueprint of the document that will be generated.

It is the responsibility of the document planning module, in particular of the document structuring task, to consider the rhetorical relations (or discourse relations) that hold between messages or groups of messages. For instance, Rhetorical Structure Theory (RST) [Mann1988] stresses the idea that the coherency of a text depends on the relationships between pairs of text spans (an uninterrupted linear interval of text) a nucleus and a satellite. In [Mann1988] a variety of relationships are provided, but for the purpose of this work, we focus on:


The nucleus contains a claim, while the satellite(s) contain(s) evidence supporting such a claim.


The nucleus contains a claim, while the satellite(s) contain(s) justification for such a claim.


Nucleus and satellite are in contrast.

Finally, once the more strategical tasks are performed, there is need for linguistic realisation — from abstract representations of sentences to actual text — and structure realisation — converting abstract structures such as paragraphs and sections into the mark-up symbols chosen for the document. The realisation module is the most algorithmic in this pipeline, and there are already several implementations for supporting it, for instance SimpleNLG [gatt2009simplenlg].

In the next section we highlight the cases of document planning and microplanning we believe are most interesting from an argumentation perspective.

4 Generating Natural Language Interfaces to Formal Argumentation

Let us now return to our running example to illustrate four relevant communicative goals. For the moment we are not making any assumptions about the user model, and we will assume no pre-existing discourse history. Therefore, given that the knowledge source is fixed, we envisage the following four communicative goals, each of which raises interesting and challenging questions:

  1. Presenting a single argument or an approximate argument;

  2. Presenting an entire argument network;

  3. Explaining the acceptability status of a single argument or an approximate argument; and

  4. Explaining the extensions, given some semantics.

In the following, we discuss elements of content determination for each of these goals; i.e. deciding what messages should be included in the document to be generated. Examples will be provided based on our running example. In parts, the generated texts will sound a little awkward because we deliberately chose not to modify the content of the arguments. We will elaborate on this in Section 5.

4.1 Presenting a Simple or an Approximate Argument

Simple and approximate arguments are composed of premises and a claim. There are two main strategies traditionally adopted to represent such a construct:

  • forward writing, from premises to claim;

  • backward writing,111Often also named assert-justify. from claim to premises.

Let us consider the argument . In the case of forward writing, we can write something like:

If you want the economy to run smoothly, you have to incentivise certain type of behaviour. [T4] In some ways you need that discipline, don’t you, to be a saver, to think, “I won’t get into debt”?. [T3]

An explicit signal such as Therefore can be used to highlight the Justify relation:

If you want the economy to run smoothly, you have to incentivise certain type of behaviour. [T4]
Therefore In some ways you need that discipline, don’t you, to be a saver, to think, “I won’t get into debt”?. [T3]

Similarly in the case of backward writing, we may write:

In some ways you need that discipline, don’t you, to be a saver, to think, “I won’t get into debt”?. [T3]
Indeed If you want the economy to run smoothly, you have to incentivise certain type of behaviour. [T4]

More interesting is the case of considering an approximate argument. Assuming that the communicative goal here is not to confuse the reader, it is probably reasonable not to include irrelevant elements in the presentation. Relevance theory may be seen as an attempt to analyse an essential feature of most human communication: the expression and recognition of intentions

[Grice1989, Sperber2005].

For instance, the First or Cognitive Principle of Relevance proposed by Sperber and Wilson [Sperber1995, Sperber2005] states: Human cognition tends to be geared to the maximisation of relevance. Therefore, it would be evidence of poor judgment to expand the argument by considering irrelevant elements. Unfortunately, defining the concept of relevance in formal argumentation is a non-trivial task [VanEemerenF2014, Paglieri2014]. To take a reasonable starting point, let us adapt the definition of relevant evidence from the Rule 401 of the Federal Rules of Evidence222https://www.law.cornell.edu/rules/fre/rule_401 (on 13/05/2017) to our context. Therefore, an approximate argument is relevant for an argument if:

  1. Its premises have any tendency to make the argument’s conclusion more or less probable than it would be without them; and

  2. It provides additional information that might advance the debate.

Given this (loose) definition of relevance, we could argue that the approximate argument is relevant for b. Similarly as before, there are different possibilities to write such a chain of inferences. In addition, it raises questions related to microplanning: perhaps, we desire to merge together different pieces such as in the following example using backward writing style.

In some ways you need that discipline, don’t you, to be a saver, to think, “I won’t get into debt”?. [T3]
Indeed If you want the economy to run smoothly, you have to incentivise certain type of behaviour. [T4] , e.g. in South Korea, in terms of how South Korean grew, it did incentivise saving, at certain times, by certain economic policies [T5]

[T4] and [T5] are merged by a comma and e.g.. In this way, we highlight the Evidence relation and identify the connection as an argument from example instead of forming two independent sentences, which is an aspect traditionally related to microplanning.

Finally, if we have knowledge that an inference rule  an argumentation scheme, then we can also map the elements of an argument into such a scheme. For instance, argument b

is classified as an argument by established rule, that is represented by the following scheme:

l l X[1,l] Major Premise: & & If carrying out types of actions including the state of affairs A is the established rule for x, then (unless the case is an exception), x must carry out A.
Minor Premise: & & Carrying out types of actions including state of affairs A is the established rule for a.
Conclusion: & & Therefore a must carry out A.

It is interesting to note that the minor premise is left implicit in the formalisation of our example, and it might be an element that should be highlighted to the user. How to report an implicit premise may depend on the communicative goal. For example, if the system is intended for users to improve and make their arguments more explicit we may generate the text:

In some ways you need that discipline, don’t you, to be a saver, to think, “I won’t get into debt”?. [T3] Indeed If you want the economy to run smoothly, you have to incentivise certain type of behaviour. [T4]
although we have no evidence that this is the established rule.

In this case, the fact that there is a lack of the minor premise is added to the generated text. On the other hand, if the system is intended to report an analysis of a conversation, we need to take into account that the premise is implicit as it may be already known by the participants. Hence, the system could assume that the premise holds, and generate an explicit sentence and we assume that this is the established rule. Further research is, however, needed in understanding how to generate text in case of unstated premises (e.g., in case of enthymemes[waltonetal2008, Black2012]). With similar considerations, we could also include critical questions that have either already been answered, or that, if answered, could strengthen the argument.

4.2 Presenting an Argument Network

One of the strengths of formal argumentation is its ability to handle conflicts. In the previous section we focused on how to represent a single argument. However, even in our small running example, we can note that (1) there are more than one argument; and (2) there are conflicts among them (Figures 1 and 2).

The simplest strategy for representing an argument network is just to enumerate all the arguments and to list the conflicts among them, eventually linking that with critical questions if the information is available (e.g. This counterargument answers the critical question that states …).




Figure 3: The for the argument network of Figure 1 interpreted using deductive argumentation in a bipolar-inspired framework, where the squared arrows represents generic dependencies based on inferences.

However, we argue that there is a better approach, motivated by the need to satisfy Grice’s maxim of relation and relevance [Grice1975]; i.e. that in a conversation one needs to be relevant and say things that are pertinent to the discussion. Let us consider Figure 3 that depicts the argumentation framework (cf. Fig. 2) annotated with a second, bipolar-inspired [amgoudetal2008],333By bipolar-inspired we intend that such a relation does not represent conflicts. At the same time, however, we are not in the position to argue that it would be a relationship of support. binary relation between arguments. Such a relation is grounded in the original argument network, Figure 1.

Once such an annotated graph is obtained, a line of reasoning annotated together (e.g.  in Figure 3) could be merged together in order to provide a single approximate argument. Once all the lines of reasoning annotated together are identified and merged, then we need a strategy to order their presentation; e.g. ordering by length of each line of reasoning versus ordering by the number of attacks received. We also need appropriate signals for antithesis relations need to be used. For instance:

if you want the moral hazard, instead of kind of just going on about the bankers, is there not a danger that if we just said we’d write off debt, that it actually isn’t very helpful for our side, for ordinary people, to actually have that? [T1] Indeed There’s no discipline there [T2] and In some ways you need that discipline, don’t you, to be a saver, to think, “I won’t get into debt”?. [T3] Indeed If you want the economy to run smoothly, you have to incentivise certain type of behaviour. [T4] , e.g. in South Korea, in terms of how South Korean grew, it did incentivise saving, at certain times, by certain economic policies [T5] However, people don’t realise, or only half realise, is the fact that we have actually written off massive amounts of debt [T6] and But it certainly isn’t the debts of the people who most need it in society [T7].

4.3 Explaining the Acceptability Status of a Single Argument or an Approximate Argument

Two of the traditional decision problems in abstract argumentation [dw:2009] are checking whether an argument is credulously or skeptically accepted (or not). An interested user might select one of the arguments (or one of the propositions in the argument network) and ask whether or not it is credulously or skeptically accepted.






Figure 4: Dispute tree to prove that c is credulously accepted w.r.t. preferred semantics in the for the argument network of Figure 1 interpreted using deductive argumentation.

To answer such a query, we can exploit research in proof theory and argument games [Modgil2009]. For instance, to prove that c (in Figure 2) is credulously accepted according to preferred semantics, we can (1) compute the extensions; and (2) compute the dispute tree [Modgil2009] needed to prove it. The dispute tree is depicted in Figure 4 which suggests that only the argument network comprising c, d, and b needs to be considered.

4.4 Explaining Extensions

Explaining multiple extensions is analogous to present different argumentation (sub-)networks that are linked together by attacks. Therefore, the solution for this communication goal builds upon the procedures envisaged in Sections 4.2 and 4.3.

It is worth mentioning that a possible way to identify the attack connections between those extensions is to consider a set of arguments belonging to a set of issues such that for the chosen semantics.444Assuming that the semantics can be related to the notion of a complete labelling (Def. 4). Those arguments could nicely provide foci of attention: for instance, . Therefore, the text presented in Section 4.2 could be adapted in a straightforward manner to communicate the existence of two preferred extensions that gravitate around the issue .

5 Conclusion

In this paper have we provided a blueprint for a complex set of research questions that arise when considering how to generate natural language representations of formal argumentation structures.

First of all, as already noted at the beginning of Section 4, we assume neither a model of the user, nor pre-existing contexts that need to be referenced in the piece of text generated. These elements will need to be addressed in future research.

Moreover some pieces of generated text sound quite awkward. To address such an issue, each piece of information inserted in an argument network should represent a single text-agnostic normal form proposition. In this way, we could compose them in a way in a meaningful way. This is clearly a constraint that might be unnatural if an untrained user tries to generate an argument network, and this raises an interesting research question concerning how to enable untrained users to formalise their lines of reasoning.

It is worth noting that the research questions highlighted in this paper have been grounded on a piece of argumentation formalised from a discussion between humans. We claim neither that our list is exhaustive nor that it is applicable to all possible argument networks. For instance, providing a natural language interface to an argument network built by an expert might lead to different, unforeseen, communicative goals. For instance, related research enabling the scrutiny of autonomous systems by allowing agents to generate plans through argument and dialogue [Tintarev2013] had the specific communication goal of justifying the purpose of each step within a plan.

Moreover we support the effort of extending AIF to include additional information: for instance, the AIFdb [Lawrence2012] project extends the AIF model to include schemes: of rephrasing; of locution describing communicative intentions which speakers use to introduce propositional contents; and of interaction or protocol describing relations between locutions. Dealing with those pieces of information raise further research questions. Indeed, as we saw in Section 3.3, arguments a, b, and c form a conflict-free set, and in Section 4 we often considered them altogether in an approximate argument. However, while argument c was put forward by Claire Fox in the original dialogue (Section 2), arguments a and b belong to Nick Dearden. The question here is how to include the sources of those arguments in the generated natural language text. In the use of argumentation to support reasoning and intelligence analysis [Toniolo2015], sources are also important, but this is only one aspect of the provenance of an argument that could, in general, be considered.

Finally, we will investigate the potential of applying NLG to existing systems using formal argumentation in real-world applications, such as CISpaces [Toniolo2015] — a system for collaborative intelligence analysis — and ArgMed [Hunter2012, Williams2015] — a system for reasoning about the results of clinical trials.