https://ojs.aaai.org/index.php/AAAI/article/view/6600/6454
Reasoning on Knowledge Graphs with Debate Dynamics
https://ojs.aaai.org › AAAI › article › view
by M Hildebrandt · 2020 · Cited by 34

The Thirty-Fourth AAAI Conference on Artificial Intelligence (AAAI-20)
Reasoning on Knowledge Graphs with Debate Dynamics
Marcel Hildebrandt,1,2,∗ Jorge Andres Quintero Serna,1,2,∗ Yunpu Ma,1,2
Martin Ringsquandl,1 Mitchell Joblin,1 Volker Tresp1,2
1Siemens Corporate Technology, 2Ludwig Maximilian University
first name.last name@siemens.com
Abstract
We propose a novel method for automatic reasoning on knowledge graphs based on debate dynamics. The main idea is to
frame the task of triple classification as a debate game between
two reinforcement learning agents which extract arguments
– paths in the knowledge graph – with the goal to promote
the fact being true (thesis) or the fact being false (antithesis),
respectively. Based on these arguments, a binary classifier,
called the judge, decides whether the fact is true or false. The
two agents can be considered as sparse, adversarial feature
generators that present interpretable evidence for either the
thesis or the antithesis. In contrast to other black-box methods, the arguments allow users to get an understanding of
the decision of the judge. Since the focus of this work is to
create an explainable method that maintains a competitive
predictive accuracy, we benchmark our method on the triple
classification and link prediction task. Thereby, we find that
our method outperforms several baselines on the benchmark
datasets FB15k-237, WN18RR, and Hetionet. We also conduct
a survey and find that the extracted arguments are informative
for users.
1 Introduction
A large variety of information about the real world can be
expressed in terms of entities and their relations. Knowledge
graphs (KGs) store facts about the world in terms of triples
(s, p, o), where s (subject) and o (object) correspond to nodes
in the graph and p (predicate) denotes the edge type connecting both. The nodes in the KG represent entities of the
real world and predicates describe relations between pairs of
entities.
KGs are useful for various artificial intelligence (AI) tasks
in different fields such as named entity disambiguation in
natural language processing (Han and Zhao 2010), visual relation detection (Baier, Ma, and Tresp 2017), or collaborative
filtering (Hildebrandt et al. 2019). Examples of large-size
KGs include Freebase (Bollacker et al. 2008) and YAGO
(Suchanek, Kasneci, and Weikum 2007). In particular, the
Google Knowledge Graph (Singhal 2012) is a well-known
example of a comprehensive KG with more than 18 billion
facts, used in search, question answering, and various NLP
∗These authors contributed equally to this work.
Copyright c 2020, Association for the Advancement of Artificial
Intelligence (www.aaai.org). All rights reserved.
tasks. One major issue, however, is that most real-world
KGs are incomplete (i.e., true facts are missing) or contain
false facts. Machine learning algorithms designed to address
this problem try to infer missing triples or detect false facts
based on observed connectivity patterns. Moreover, many
tasks such as question answering or collaborative filtering
can be formulated in terms of predicting new links in a KG
(e.g., (Lukovnikov et al. 2017), (Hildebrandt et al. 2018)).
Most machine learning approaches for reasoning on KGs
embed both entities and predicates into low dimensional vector spaces. A score for the plausibility of a triple can then
be computed based on these embeddings. Common to most
embedding-based methods is their black-box nature. This
lack of transparency constitutes a potential limitation when it
comes to deploying KGs in real world settings. Explainability in the machine learning community has recently gained
attention; in many countries laws that require explainable
algorithms have been put in place (Goodman and Flaxman
2017). Additionally, in contrast to one-way black-box configurations, comprehensible machine learning methods enable
the construction of systems where both machines and users
interact and influence each other.
Most explainable AI approaches can be roughly categorized into two groups: Post-hoc interpretability and integrated
transparency (Dosilovi ˇ c, Br ́ ciˇ c, and Hlupi ́ c 2018). While post- ́
hoc interpretability aims to explain the outcome of an already
trained black-box model (e.g., via layer-wise relevance propagation (Montavon et al. 2017)), integrated transparency-based
methods either employ internal explanation mechanisms or
are naturally explainable due to low model complexity (e.g.,
linear models). Since low complexity and prediction accuracy are often conflicting objectives, there is typically a trade
off between performance and explainability. The goal of this
work is to design a KG reasoning method with integrated
transparency that does not sacrifice performance while also
allowing a human-in-the-loop.
In this paper we introduce R2D2 (Reveal Relations using
Debate Dynamics), a novel method for triple classification
based on reinforcement learning. Inspired by the concept outlined in (Irving, Christiano, and Amodei 2018) to increase AI
safety via debates, we model the task of triple classification
as a debate between two agents, each presenting arguments
either in favor of the thesis (the triple is true) or the antithesis (the triple is false). Based on these arguments, a binary
4123
classifier, called the judge, decides whether the fact is true or
false. As opposed to most methods based on representation
learning, the arguments can be displayed to users such that
they can trace back the classification of the judge and potentially overrule the decision or request additional arguments.
Hence, the integrated transparency mechanism of R2D2 is
not based on low complexity components, but rather on the
automatic extraction of interpretable features. While deep
learning made manual feature engineering to great extends
redundant, this advantage came at the cost of producing results that are difficult to interpret. Our work is an attempt to
close the circle by employing deep learning techniques to
automatically select sparse, interpretable features. The major
contributions of this work are as follows.
• To the best of our knowledge, R2D2 constitutes the first
model based on debate dynamics for reasoning on KGs.
• We benchmark R2D2 with respect to triple classification
on the datasets FB15k-237 and WN18RR. Our findings
show that R2D2 outperforms all baseline methods with
respect to the accuracy, the PR AUC, and the ROC AUC,
while being more interpretable.
• To demonstrate that R2D2 can in principle be employed
for KG completion, we also evaluate its link prediction
performance on a subset of FB15k-237. To include a real
world task, we employ R2D2 on Hetionet for finding genedisease associations and new target diseases for drugs.
R2D2 either outperforms or keeps up with the performance
of all baseline methods on both datasets with respect to
standard measures such as the MRR, the mean rank, and
hits@k, for k = 3, 10.
• We conduct a survey where respondents take the role of
the judge classifying the truthfulness of statements solely
based on the extracted arguments. Based on a majority
vote, we find that nine out of ten statements are classified
correctly and that for each statement the classification of
the respondents agrees with the decision of R2D2’s judge.
These findings indicate that the arguments of R2D2 are
informative and the judge is aligned with human intuition.
This paper is organized as follows. We briefly review KGs and
the related literature in the next section. Section 3 describes
the methodology of R2D2. Section 4 details an experimental study on the benchmark datasets FB15k-237, WN18RR,
and Hetionet. In particular, we compare R2D2 with various
methods from the literature and describes the findings of our
survey. In Section 5 the quality of the arguments and future
works are discussed. We conclude in Section 6.
2 Background and Related Work
In this section we provide a brief introduction to KGs in
a formal setting and review the most relevant related work.
Let E denote the set of entities and consider the set of binary relations R. A knowledge graph KG ⊂ E ×ばつ R ×ばつ E is
a collection of facts stored as triples of the form (s, p, o) –
subject, predicate, and object. To indicate whether a triple is
true or false, we consider the binary characteristic function
φ : ×ばつE→{0, 1}. For all (s, p, o) ∈ KG we assume
Michael
Jordan
Washington
Wizzards
Chicago Bulls
National
Basketball
Association
(NBA)
Chicago
White Sox
Major
League
Baseball
(MLB)
male
Basketball
player USA
Space
Jam
Children’s
Movie
Query: (Michael Jordan, has profession, basketball player)
Agent 1: (Michael Jordan, plays for, Chicago Bulls)
∧ (Chicago Bulls, team of, NBA)
Agent 2: (Michael Jordan, plays role in,Space Jam)
∧ (Space Jam, has genre, Children’s Movie)
Agent 1: (Michael Jordan, plays for, Washington Wizzards)
∧ (Washington Wizzards, team of, NBA)
Agent 2: (Michael Jordan, plays for, Chicago White Sox)
∧(Chicago White Sox, team of, MLB)
Judge: Query is true.
plays
for
plays
for
team
of
team
of
plays
for
team
of
has
gender
plays
role in
nationality
has
has
genre produced
in
has
profession
Figure 1: The agents debate whether Michael Jordan is a
professional basketball player. While agent 1 extracts arguments from the KG supporting the thesis that the fact is true
(green), agent 2 argues that it is false (red). Based on the arguments the judge decides that Michael Jordan is a professional
basketball player.
φ(s, p, o)=1 (i.e., a KG is a collection of true facts). However, in case a triple is not contained in KG, it does not imply
that the corresponding fact is false but rather unknown (open
world assumption). Since most KGs that are currently in use
are incomplete in the sense that they do not contain all true
triples or they actually contain false facts, many canonical
machine learning tasks are related to KG reasoning. KG reasoning can be roughly categorized according to the following
two tasks: first, inference of missing triples (KG completion
or link prediction), and second, predicting the truth value of
triples (triple classification). While different formulations of
these tasks are typically found in the literature (e.g., the completion task may involve predicting either subject or object
entities as well as relations between a pair of entities), we
employ the following definitions throughout this work.
Definition 1 (Triple Classification and KG completion).
Given a triple (s, p, o) ∈ ×ばつE, triple classification
is concerned with predicting the truth value φ(s, p, o). KG
completion is the task to rank object entities o ∈ E by their
likelihood to form a true triple together with a given subjectpredicate-pair (s, p) ×ばつR. 1
Many machine learning methods for KGs can be trained
to operate in both settings. For example, a triple classifier of
the form f : ×ばつE → [0, 1] with f(s, p, o) ≈ φ(s, p, o),
1
Throughout this work, we assume the existence of inverse relations. That means for any relation p ∈ R there exists a relation
p−1 ∈ R such that (s, p, o) ∈ KG if and only if (o, p−1, s) ∈ KG.
Hence, the restriction to rank object entities does not lead to a loss
of generality.
4124
induces a completion method given by f(s, p, ·) : E → [0, 1],
where function values for different object entities can be
used to produce a ranking. While the architecture of R2D2
is designed for triple classification, we demonstrate that it
can in principle also work in the KG completion setting. The
performance on both tasks is reported in Section 4.
Representation learning is an effective and popular technique underlying many KG refinement methods. The basic
idea is to project both entities and relations into a low dimensional vector space. Then the likelihood of triples is
modelled as a functional on the embedding spaces. Popular
completion methods based on representation learning include
the translational embedding methods TransE (Bordes et al.
2013) and TransR (Lin et al. 2015) as well as the factorization approaches RESCAL (Nickel, Tresp, and Kriegel 2011),
DistMult (Yang et al. 2015), ComplEx (Trouillon et al. 2016),
and SimplE (Kazemi and Poole 2018). Path-based reasoning
methods follow a different philosophy. For instance, the PathRanking Algorithm (PRA) proposed in (Lao, Mitchell, and
Cohen 2011) uses for inference a combination of weighted
random walks through the graph. In (Xiong, Hoang, and
Wang 2017) the reinforcement learning based path searching approach called DeepPath was proposed, where an agent
picks relational paths between entity pairs. Recently, and
more related to our work, the multi-hop reasoning method
MINERVA was proposed in (Das et al. 2018). The basic idea
in that paper is to display the query subject and predicate
to the agents and let them perform a policy guided walk
to the correct object entity. The paths that MINERVA produces also lead to some degree of explainability. However,
we find that only actively mining arguments for the thesis and
the antithesis, thus exposing both sides of a debate, allows
users to make a well-informed decision. Mining evidence
for both positions can also be considered as adversarial feature generation, making the classifier (judge) robust towards
contradictory evidence or corrupted data.
3 Our Method
We formulate the task of triple classification in terms of a
debate between two opposing agents. Thereby, a query triple
corresponds to the statement around which the debate is centered. The agents proceed by mining paths on the KG that
serve as evidence for the thesis or the antithesis. More precisely, they traverse the graph sequentially and select the next
hop based on a policy that takes past transitions and the query
triple into account. The transitions are added to the current
path, extending the argument. All paths are processed by a
binary classifier called the judge that attempts to distinguish
between true and false triples based on the arguments provided by the agents. Figure 1 shows an exemplary debate.
The main steps of a debate can be summarized as follows:

1. A query triple around which the debate is centered is
   presented to both agents.
2. The two agents take turns extracting paths from the KG
   that serve as arguments for the thesis and the antithesis.
3. The judge processes the arguments along with the query
   triple and estimates the truth value of the query triple.
   While the parameters of the judge are fitted in a supervised
   fashion, both agents are trained to navigate through the graph
   using reinforcement learning. Based on the formal framework
   presented in (Das et al. 2018), the agents’ learning tasks are
   modelled via the fixed horizon decision processes outlined
   below.
   Equations (1) and (2) define a mapping from the space of histories to the space of distribution over all admissible actions,
   thus inducing a policy πθ(i) , where θ(i) denotes the set of all
   trainable parameters in Equations (1) and (2).
   Debate Dynamics In a first step, the query triple q =
   (sq, pq, oq) with truth value φ(q) ∈ {0, 1} is presented to
   both agents. Agent 1 argues that the fact is true, while agent
   2 argues that it is false. Similar to most formal debates, we
   consider a fixed number of rounds N ∈ N. In every round
   n = 1, 2,...,N, the agents start graph traversals with fixed
   length T ∈ N from the subject node of the query sq. The
   judge observes the paths of the agents and predicts the truth
   value of the triple. Agent 1 starts the game generating a sequence of length T consisting of states and actions according
   to Equations (1 - 3). Then agent 2 proceeds by producing a
   similar sequence starting from sq. Algorithm 1 contains a
   pseudocode of R2D2 at inference time.
   To ease the notation we have enumerated all actions consecutively and dropped the superscripts that indicate which
   agent performs the action. Then the sequence corresponding
   to the n-th argument of agent i is given by
   τ (i) n := �
   An ̃(i,T)+1, An ̃(i,T)+2,...,An ̃(i,T)+T

, (4)
where we used the reindexing n ̃(i, T) := (2(n−1)+i−1)T.
The sequence of all arguments is denoted by
τ :=
τ (1)
1 , τ (2)
1 , τ (1)
2 , τ (2)
2 ,...,τ (1)
N , τ (2)
N

. (5)
The Judge The role of the judge in R2D2 is twofold: First,
the judge is a binary classifier that tries to distinguish between
true and false facts. Second, the judge also evaluates the quality of the arguments extracted by the agents and assigns rewards to them. Thus, the judge also acts as a critic, teaching
the agents to produce meaningful arguments. The judge processes each argument together with the query individually by
a feed forward neural network f : R2(T +1)d → Rd, sums the
output for each argument up and processes the resulting sum
by a binary classifier. More concretely, after processing each
argument individually, the judge produces a representation
according to
y(i)
n = f
�τ (i)
n , qJ
� (6)
with
τ (i)
n := �
aJ
n ̃(i,T)+1, aJ
n ̃(i,T)+2,..., aJ
n ̃(i,T)+T
�
(7)
where aJ
t =

rJ
t , eJ
t
�
∈ R2d denotes the judge’s embedding
for the action At and qJ =

rJ
p , eJ
o
� ∈ R2d encodes the
query predicate and the query object. Note that the query
4126
Algorithm 1: R2D2 Inference
input :Triple query q = (sq, pq, oq)
output :Classification score tτ ∈ [0, 1] of the judge
along with the list of arguments τ
1 τ ← [ ] // Initialize the list of
arguments with an empty list
// Loop over the debate rounds
2 for n = 1 to N do
// Loop over the two agents
3 for i = 1 to 2 do
4 e
(i)
1 ← sq // Initialize the
position of the agent
5 τ (i) n ← [ ] // Initialize the
argument with an empty list
// Loop over the path
6 for t = 1 to T do
7 Sample a transition (r, e) from e
(i)
t
according to πθ(i)// See
Equations (1-3)
8 τ (i) n .append(r, e) // Extend the
argument
9 e
(i)
t+1 ← e // Update the position
of the agent
10 end
11 τ .append(τ (i) n ) // Extend the list of
all argument
12 end
13 end
14 Process τ via the judge and retrieve the classification
score tτ // See Equation (6-8)
15 return tτ and τ
subject is not revealed to the judge because we want the
judge to base its decisions solely on the agents’ actions rather
than on the embedding of the query subject. After processing
all arguments in τ , the debate is terminated and the judge
scores the query triple q with tτ ∈ (0, 1) according to
tτ = σ

wReLU 
W

2
i=1

N
n=1
y(i)
n
�� , (8)
where W ∈ Rd×ばつd and w ∈ Rd denote the trainable parameters of the classifier and σ(·) denotes the sigmoid activation
function. We also experimented with more complex architectures where the judge processes each argument in τ via a
recurrent neural network. However, we found that both the
classification performance and the quality of the arguments
suffered.
The objective function of the judge for a single query q is
given by the cross-entropy loss
Lq = φ(q) log tτ + (1 − φ(q)) (1 − log tτ ). (9)
Hence, during training, we aim to minimize the overall loss
given by
L = 1
|T |

q∈T
Lq , (10)
where T denotes the set of training triples. To prevent overfitting, an additional L2-penalization term with strength
λ ∈ R≥0 on the parameters of the judge is added to Equation
(10).
An overview of the overall architecture of R2D2 is depicted in Figure 2.
Rewards In order to generate feedback for the agents, the
judge also processes each argument τ (i) n individually and
produces a score according to
t
(i)
n = wReLU
Wf
�τ (i)
n , qJ
� , (11)
where both the neural network f as well as the linear weights
vector w correspond to the definitions given in the previous
paragraph. Thus, t
(i)
n corresponds to the classification logits
of q solely based on the n-th argument of agent i. Since
agent 1 argues for the thesis and agent 2 for the antithesis,
the rewards are given by
R(i)
n =
�
t
(i)
n if i = 1
−t
(i)
n otherwise. (12)
Intuitively speaking, this means that the agents receive high
rewards whenever they extract an argument that is considered
by judge as strong evidence for their position
Reward Maximization and Training Scheme We employ REINFORCE (Williams 1992) to maximize the expected cumulative reward of the agents given by
G(i) :=

N
n=1
R(i)
n . (13)
Thus, the agents’ maximization problems are given by
arg max
θ(i)
Eq∼KG+ Eτ (i)
1 ,τ (i)
2 ,...,τ (i)
N ∼πθ(i)
�
G(i)
�
�
�
�
q
�
, (14)
where KG+ is the set of training triples that contain in addition to observed triples in KG also unobserved triples.
The rationale is as follows: As KGs only contain true facts,
sampling queries from KG would create a dataset without
negative labels. Therefore it is common to create corrupted
triples that are constructed from correct triples (s, p, o) by
replacing the object with an entity o ̃ to create a false triple
(s, p, o ̃) ∈ KG / (see (Bordes et al. 2013)). Rather than creating
any kind of corrupt triples, we generate a set of plausible but
false triples. More concretely, for each (s, p, o) ∈ KG we generate one triple (s, p, o ̃) ∈ KG / with the constraint that o ̃ appears in the database as the object with respect to the relation
p. More formally, we denote the set of corrupted triples with
KGC := {(s, p, o ̃)|(s, p, o ̃) ∈ KG / , ∃s ̃ : ( ̃s, p, o ̃) ∈ KG} .
Then the set of training triples T is contained in KG+ :=
4127
Dataset Entities Relations Triples
FB15k-237 14,541 237 310,116
WN18RR 40,943 11 93,003
Hetionet 47,031 24 2,250,197
Table 1: Statistics of the datasets used in the experiments.
KG ∪ KGC . The underlying rationale for working with plausible but false facts is that we do not waste resources on
triples that break implicit type-constrains. Since this heuristic
only needs to be computed once and filters out triples that
could easily be discarded by a type-checker, we can focus on
the prediction of facts that present more of a challenge.
During training the first expectation in Equation (14) is
substituted with the empirical average over the training set.
The second expectation is approximated by the empirical
average over multiple rollouts. We also employ a moving
average baseline to reduce the variance. Further, we use entropy regularization with parameter β ∈ R≥0 to enforce
exploration.
In order to address the problem that the agents require a
trained judge to obtain meaningful reward signals, we freeze
the weights of the agents for the first episodes of the training.
The rationale is that training the judge does not necessarily
rely on the agents being perfectly aligned with their actual
goals. For example, even if the agents do not extract arguments that correspond to their position, they can still provide
useful features that the judge learns to exploit. After the initial training phase, where we only fit the parameters of the
judge, we employ an alternating training scheme where we
either train the judge or the agents.
4 Experiments
Datasets We measure the performance of R2D2 with respect to the triple classification and the KG completion task
on the benchmark datasets FB15k-237 (Toutanova et al. 2015)
and WN18RR (Dettmers et al. 2018). To test R2D2 on a
real world task we also consider Hetionet (Himmelstein and
Baranzini 2015), a large scale, heterogeneous graph encoding
information about chemical compounds, diseases, genes, and
molecular functions. We employ R2D2 for detecting genedisease associations and finding new target diseases for drugs,
two tasks of high practical relevance in the biomedical domain (see (Himmelstein and Baranzini 2015)). The statistics
of all datasets are given in Table 1.
Metrics and Evaluation Scheme As outlined in Section
2, triple classification aims to decide whether a query triple
(sq, pq, oq) is true or false. Hence, it is a binary classification task. For each method we set a threshold δ obtained by
maximizing the accuracies on the validation set. That means,
for a given query triple (sq, pq, oq), if its score (e.g., given
by Equation (8) for R2D2) is larger than δ, the triple will be
classified as true, otherwise as false. Since most KGs do not
contain facts that are labeled as false, we have generated a set
of negative triples: For each observed triple in the validation
and test set we create a false but plausible fact (see Section
3).2 We report the accuracy, the PR AUC, and ROC AUC
for all methods. Since R2D2 is a stochastic classifier, we can
produce multiple rollouts of the same query at inference time
and average the resulting classification scores to lower the
variance.
Even though the purpose of R2D2 is triple classification,
one can turn it into a KG completion method as follows:
We consider a range of object entities each producing a different classification score tτ given by Equation (8). Since
tτ can be interpreted as a measure for the plausibility of a
triple, we use the classification scores to produce a ranking. More concretely, we rank each correct triple in the
test set against all plausible but false triples (see Section
3). Since this procedure is computational expensive during training (one needs to run multiple debates per training
triple to produce a ranking), we select the following relations for training and testing purposes: For FB15k-237 we
follow (Socher et al. 2013) and consider the relations ‘profession’, ‘nationality’, ‘ethnicity’, and ‘religion’. Following
(Himmelstein and Baranzini 2015) and (Himmelstein et al.
2017), the relations ‘gene associated with disease’ and ‘compound treats disease’ are considered for Hetionet. We report
the mean rank of the correct entity, the mean reciprocal rank
(MRR), as well as Hits@k for k = 1, 3, 10 - the percentage
of test triples where the correct entity is ranked in the top k.
In order to find the most suitable set of hyperparameters
for all considered methods, we perform cross-validations.
Thereby the canonical splits of the datasets into a training,
validation, and test set are used. In particular, we ensured
that triples that are assigned to the validation or test set (and
their respective inverse relations) are not included in the
KG during training. The results on the test set of all methods are reported based on the hyperparameters that showed
the best performance (based on the highest accuracy for
triple classification and the the highest MRR for link prediction) on the validation set. We considered the following
hyperparameter ranges for R2D2: The number of latent dimensions d for the embeddings is chosen from the range
{32, 64, 128}. The number of LSTM layers for the agents
is chosen from {1, 2, 3}. The the number of layers in the
MLP for the judge is tuned in the range {1, 2, 3, 4, 5}. β was
chosen from {0.02, 0.05, 0.1}. The length of each argument
T was tuned in the range {1, 2, 3} and the number of debate rounds N was set to 3. Moreover, the L2-regularization
strength λ is set to 0.02. Furthermore, the number of rollouts
during training is given by 20 and 50 (triple classification)
or 100 (KG completion) at test time. The loss of the judge
and the rewards of the agents were optimized using Adam
with learning rate given 10−4. The best hyperparameter are
reported in Table 3.
All experiments were conducted on a machine with 48
CPU cores and 96 GB RAM. Training R2D2 on either dataset
takes at most 4 hour. Testing takes about 1-2 hours depending
on the dataset.
2
The datasets along with the code of R2D2 are available at
https://github.com/m-hildebrandt/R2D2.
4128
Dataset FB15k-237 WN18RR
Method Acc PR AUC ROC AUC Acc PR AUC ROC AUC
DistMult 0.739 0.78 0.803 0.804 0.901 0.872
ComplEx 0.738 0.789 0.796 0.802 0.887 0.860
TransE 0.673 0.727 0.736 0.69 0.794 0.732
TransR 0.612 0.655 0.651 0.721 0.724 0.792
SimplE 0.703 0.733 0.756 0.722 0.812 0.742
R2D2 0.751 0.86 0.848 0.726 0.821 0.808
R2D2+ 0.764 0.865 0.857 0.804 0.909 0.893
Table 2: The performance on the triple classification task.
Parameter FB15k-237 WN18RR FB15k-237 (subset) Hetionet
Embedding size (d) 64 64 64 32

stacked LSTM cells (agents) 2 1 2 2

layers MLP (judge) 1 1 3 2

rounds in a debate (N)3 3 3 3

Argument/path length (T) 2 2 2 2
Entropy regularization (β) 0.02 0.02 0.1 0.1
Table 3: The best hyperparameters for R2D2 found via cross-validation.
Results
Triple Classification We compare the performance of
R2D2 on the triple classifications task against DistMult, ComplEx, TransE, TransR, and SimplE. The results are displayed
in Table 2. On FB15k-237, R2D2 outperforms all baselines
with respect to the accuracy, the PR AUC, and the ROC AUC.
However, on WN18RR the performance of R2D2 is dominated by the factorization methods ComplEx and DistMult
by a significant margin. We conjecture that this is due to the
sparsity in the dataset. As a remedy we employ pretrained
embeddings from TransE that are fixed during training.3 We
denote the resulting method with R2D2+ and find that it outperforms all other methods with respect to the PR AUC and
ROC AUC on WN18RR. We also test R2D2+ on FB15k-237
and find that it improves the results of R2D2 by only a small
margin. This is expected since FB15k-237 is not as sparse as
WN18RR.
KG completion Next to the baselines used for triple classification we also employ the path based link prediction method
MINERVA. Note that it is not possible to compute a fair mean
rank for MINERVA, since it does not produce a complete
ranking of all candidate objects. Table 4 displays the results
on the completion task for all methods under consideration
on FB15k-237 and Hetionet (subsets; see above). R2D2 outperforms all other methods on FB15k-237 with respect to
all metrics but Hits@10. However, the performance of MINERVA is almost on par. Moreover, R2D2 outperforms all
baselines on Hetionet with respect to the MRR, the mean
rank, Hits@3, and Hits@10. While MINERVA exhibits the
best performance with respect to Hits@1, R2D2 yields significantly better results with respect to all other metrics.
3
We choose TransE embeddings due to the simple functional
relations between entities. These can be easily exploited by R2D2.
Survey To asses whether the arguments are informative for
users in an objective setting, we conducted a survey where
respondents take the role of the judge making a classification
decision based on the agents’ arguments. More concretely, we
set up an online quiz consisting of ten rounds. Each round is
centered around a query (with masked subject) sampled from
the test set of FB15k-237 (KG completion). Along with the
query statement we present the users six arguments extracted
by the agents in randomized order. Based on these arguments
the respondents are supposed to judge whether the statement
is true or false. In addition, we asked the respondents to rate
their confidence in each round.
Based on 44 participants (109 invitations were sent) we
find that the overall accuracy of the respondents’ classifications was 81.8%. Moreover, based on a majority vote (i.e.,
classification based on the majority of respondents) nine out
of ten questions were classified correctly indicating that humans are approximately on par with the performance of the
automated judge. Further, the statement where the majority
of respondents was wrong corresponds to the only query
that was also misclassified by the judge. In this round the
participants were supposed to decide whether a person has
the religion Methodism. It is hard to answer this question
correctly because the person at hand is Margaret Thatcher
who had two different religions over her lifetime: Methodism
and the Church of England. The fact that the majority of
respondents and the judge agree in all rounds indicates that
the judge is aligned with human intuition and that the arguments are informative. Moreover, we found that when users
assigned a high confidence score to their decision (’rather
certain’ or ’absolutely certain’) the overall accuracy of their
classification was 89%. The accuracy dropped to 68.4% when
users assigned a low confidence score (’rather uncertain’ or
’absolutely uncertain’).
4129
Dataset FB15k-237 (subset) Hetionet (subset)
Metrics MRR Mean Rank Hits@1 Hits@3 Hits@10 MRR Mean Rank Hits@1 Hits@3 Hits@10
DistMult 0.502 8.607 0.363 0.572 0.779 0.134 31.190 0.054 0.121 0.291
ComplEx 0.521 7.477 0.383 0.587 0.806 0.148 31.439 0.061 0.141 0.325
TransE 0.473 10.2112 0.345 0.522 0.745 0.110 35.559 0.033 0.097 0.267
TransR 0.543 8.737 0.391 0.635 0.816 0.144 27.841 0.049 0.136 0.340
SimplE 0.429 11.760 0.275 0.506 0.736 0.177 31.965 0.091 0.174 0.354
MINERVA 0.580 – 0.448 0.657 0.857 0.174 – 0.097 0.18 0.364
R2D2 0.589 6.332 0.459 0.665 0.853 0.206 23.486 0.090 0.219 0.455
Table 4: The performance on the KG completion task.
Query: Richard Feynman nationality
−−−−−−−→ USA? Nelson Mandela hasP rof ession
−−−−−−−−−−→ Actor?
Agent 1: Richard Feynman livedInLocation
−−−−−−−−−−→ Queens Nelson Mandela hasF riend
−−−−−−−→ Naomi Campbell
∧ Queens locatedIn
−−−−−−→ USA Naomi Campbell hasDated
−−−−−−→ Leonardo DiCaprio
Agent 2: Richard Feynman hasEthnicity
−−−−−−−−−→ Russian people Nelson Mandela hasP rof ession
−−−−−−−−−−→ Lawyer
∧ Russian people geographicDistribution
−−−−−−−−−−−−−−−→ Republic of Tajikistan ∧ Lawyer specializationOf−1
−−−−−−−−−−−−−→ Barrister
Table 5: Two example debates generated by R2D2: While agent 1 argues that the query is true and agent 2 argues that it is false.
5 Discussion and Future Works
We examined the quality of the extracted paths manually and
typically found reasonable arguments, but quite often also
arguments that do not make intuitive sense. We conjecture
that one reason for that is that agents often have difficulties finding meaningful evidence if they are arguing for the
false position. Moreover, for many arguments, most of the
relevant information is already contained in the first step of
the agents and later transitions often contain seemingly irrelevant information. This phenomenon might be due to the
fact that the judge ignores later transitions and agents do not
receive meaningful rewards. Further, relevant information
about the neighborhood of entities can be encoded in the
embeddings of entities. While the judge has access to this
information through the training process, it remains hidden
to users. For example, when arguing that Nelson Mandela
was an actor (see Table 5), the argument of agent 1 requires
the user to know that Naomi Campbell and Leonardo DiCaprio are actors (which is encoded in FB15k-237). Then
this argument serves as evidence that Nelson Mandela was
also an actor since people tend to have friends that share their
profession (social homophily). However, without this context
information it is not intuitively clear why this is a reasonable
argument.
To examine the interplay between the agents and the judge,
we consider a setting where we train R2D2 with two agents,
but neglect the arguments of one agent during testing. This
should lead to a biased outcome in favor of the agent whose
arguments are considered by the judge. We test this setting
on FB15k-237 and find that when we consider only the arguments of agent 1, the number of positive predictions increases by 18.8%. In contrast, when we only consider agent 2,
the number positive predictions drops by 70.2%. This result
shows that the debate dynamics are functioning as intended
and that the agents learn to extract arguments that the judge
considers as evidence for their respective position.
While the results of the survey are encouraging, we plan to
develop variants of R2D2 that improve the quality of the arguments and conduct a large scale experimental study that also
includes other baselines in a controlled setting. Moreover,
we plan to discuss fairness and responsibility considerations.
In that regard, (Nickel et al. 2015) stress that when applying statistical methods to incomplete KGs the results are
likely to be affected by biases in the data generating process
and should be interpreted accordingly. Otherwise, blindly
following these predictions can strengthen the bias. While
the judge in our method also exploits skews in the data, the
arguments can help to identify these biases and potentially
exclude problematic arguments from the decision.
6 Conclusion
We proposed R2D2, a new approach for KG reasoning based
on a debate game between two opposing reinforcement learning agents. The agents search the KG for arguments that
convince a binary classifier (judge) of their position. Thereby,
they act as sparse, adversarial feature generators. Since the
judge bases its decision solely on mined arguments, R2D2 is
more interpretable than other baseline methods. Our experiments showed that R2D2 outperforms all baselines in the
triple classification setting with respect to all metrics on the
benchmark datasets WN18RR and FB15k-237. Moreover,
we demonstrated that R2D2 can in principle operate in the
KG completion setting. We found that R2D2 has competitive performance compared to all baselines on a subset of
FB15k-237 and Hetionet. Furthermore, the results of our survey indicate that the arguments are informative and that the
judge is aligned with human intuition.
References
Baier, S.; Ma, Y.; and Tresp, V. 2017. Improving visual
relationship detection using semantic modeling of scene descriptions. In International Semantic Web Conference, 53–68.
Springer.
Bollacker, K.; Evans, C.; Paritosh, P.; Sturge, T.; and Taylor,
J. 2008. Freebase: a collaboratively created graph database
4130
for structuring human knowledge. In Proceedings of the 2008
ACM SIGMOD international conference on Management of
data, 1247–1250. ACM.
Bordes, A.; Usunier, N.; Garcia-Duran, A.; Weston, J.; and
Yakhnenko, O. 2013. Translating embeddings for modeling
multi-relational data. In Advances in neural information
processing systems, 2787–2795.
Das, R.; Dhuliawala, S.; Zaheer, M.; Vilnis, L.; Durugkar, I.;
Krishnamurthy, A.; Smola, A.; and McCallum, A. 2018. Go
for a walk and arrive at the answer: Reasoning over paths in
knowledge bases using reinforcement learning. In International Conference on Learning Representations.
Dettmers, T.; Minervini, P.; Stenetorp, P.; and Riedel, S. 2018.
Convolutional 2d knowledge graph embeddings. In ThirtySecond AAAI Conference on Artificial Intelligence.
Dosilovi ˇ c, F. K.; Br ́ ciˇ c, M.; and Hlupi ́ c, N. 2018. Explain- ́
able artificial intelligence: A survey. In 2018 41st International convention on information and communication technology, electronics and microelectronics (MIPRO), 0210–0215.
IEEE.
Goodman, B., and Flaxman, S. 2017. European union regulations on algorithmic decision-making and a "right to explanation". AI Magazine 38(3):50–57.
Han, X., and Zhao, J. 2010. Structural semantic relatedness: a
knowledge-based method to named entity disambiguation. In
Proceedings of the 48th Annual Meeting of the ACL, 50–59.
ACL.
Hildebrandt, M.; Sunder, S. S.; Mogoreanu, S.; Thon, I.;
Tresp, V.; and Runkler, T. 2018. Configuration of industrial
automation solutions using multi-relational recommender
systems. In Joint European Conference on Machine Learning
and Knowledge Discovery in Databases, 271–287. Springer.
Hildebrandt, M.; Sunder, S. S.; Mogoreanu, S.; Joblin, M.;
Mehta, A.; Thon, I.; and Tresp, V. 2019. A recommender
system for complex real-world applications with nonlinear
dependencies and knowledge graph context. In European
Semantic Web Conference, 179–193. Springer.
Himmelstein, D. S., and Baranzini, S. E. 2015. Heterogeneous network edge prediction: a data integration approach
to prioritize disease-associated genes. PLoS computational
biology 11(7):e1004259.
Himmelstein, D. S.; Lizee, A.; Hessler, C.; Brueggeman, L.;
Chen, S. L.; Hadley, D.; Green, A.; Khankhanian, P.; and
Baranzini, S. E. 2017. Systematic integration of biomedical
knowledge prioritizes drugs for repurposing. Elife 6:e26726.
Hochreiter, S., and Schmidhuber, J. 1997. Long short-term
memory. Neural computation 9(8):1735–1780.
Irving, G.; Christiano, P.; and Amodei, D. 2018. Ai safety
via debate. arXiv preprint arXiv:1805.00899.
Kazemi, S. M., and Poole, D. 2018. Simple embedding for
link prediction in knowledge graphs. In Advances in Neural
Information Processing Systems, 4284–4295.
Lao, N.; Mitchell, T.; and Cohen, W. W. 2011. Random
walk inference and learning in a large scale knowledge base.
In Proceedings of the Conference on Empirical Methods in
Natural Language Processing, 529–539. ACL.
Lin, Y.; Liu, Z.; Sun, M.; Liu, Y.; and Zhu, X. 2015. Learning
entity and relation embeddings for knowledge graph completion. In Twenty-ninth AAAI conference on artificial intelligence.
Lukovnikov, D.; Fischer, A.; Lehmann, J.; and Auer, S. 2017.
Neural network-based question answering over knowledge
graphs on word and character level. In Proceedings of the
26th international conference on World Wide Web, 1211–
1220. International World Wide Web Conferences Steering
Committee.
Montavon, G.; Lapuschkin, S.; Binder, A.; Samek, W.; and
Muller, K.-R. 2017. Explaining nonlinear classification deci- ̈
sions with deep taylor decomposition. Pattern Recognition
65:211–222.
Nickel, M.; Murphy, K.; Tresp, V.; and Gabrilovich, E.
2015. A review of relational machine learning for knowledge
graphs. Proceedings of the IEEE 104(1):11–33.
Nickel, M.; Tresp, V.; and Kriegel, H.-P. 2011. A three-way
model for collective learning on multi-relational data. In
International Conference on Machine Learning, volume 11,
809–816.
Singhal, A. 2012. Introducing the knowledge graph: things,
not strings. [Online; accessed 28-March-2019].
Socher, R.; Chen, D.; Manning, C. D.; and Ng, A. 2013.
Reasoning with neural tensor networks for knowledge base
completion. In Advances in neural information processing
systems, 926–934.
Suchanek, F. M.; Kasneci, G.; and Weikum, G. 2007. Yago:
a core of semantic knowledge. In Proceedings of the 16th international conference on World Wide Web, 697–706. ACM.
Toutanova, K.; Chen, D.; Pantel, P.; Poon, H.; Choudhury,
P.; and Gamon, M. 2015. Representing text for joint embedding of text and knowledge bases. In Proceedings of the
2015 Conference on Empirical Methods in Natural Language
Processing, 1499–1509.
Trouillon, T.; Welbl, J.; Riedel, S.; Gaussier, E.; and
Bouchard, G. 2016. Complex embeddings for simple link prediction. In International Conference on Machine Learning,
volume 48, 2071–2080.
Williams, R. J. 1992. Simple statistical gradient-following
algorithms for connectionist reinforcement learning. Machine
learning 8(3-4):229–256.
Xiong, W.; Hoang, T.; and Wang, W. Y. 2017. Deeppath: A
reinforcement learning method for knowledge graph reasoning. In Proceedings of the 2017 Conference on Empirical
Methods in Natural Language Processing. ACL.
Yang, B.; Yih, W.-t.; He, X.; Gao, J.; and Deng, L. 2015.
Embedding entities and relations for learning and inference
in knowledge bases. In International Conference on Learning
Representations.
4131

https://www.sciencedirect.com/science/article/pii/S1570868313000748
A neural cognitive model of argumentation with application to legal inference and decision making
Author links open overlay panelArtur S. d'Avila Garcez a, Dov M. Gabbay b, Luis C. Lamb c

Formal models of argumentation have been investigated in several areas, from multi-agent systems and artificial intelligence (AI) to decision making, philosophy and law. In artificial intelligence, logic-based models have been the standard for the representation of argumentative reasoning. More recently, the standard logic-based models have been shown equivalent to standard connectionist models. This has created a new line of research where (i) neural networks can be used as a parallel computational model for argumentation and (ii) neural networks can be used to combine argumentation, quantitative reasoning and statistical learning. At the same time, non-standard logic models of argumentation started to emerge. In this paper, we propose a connectionist cognitive model of argumentation that accounts for both standard and non-standard forms of argumentation. The model is shown to be an adequate framework for dealing with standard and non-standard argumentation, including joint-attacks, argument support, ordered attacks, disjunctive attacks, meta-level attacks, self-defeating attacks, argument accrual and uncertainty. We show that the neural cognitive approach offers an adequate way of modelling all of these different aspects of argumentation. We have applied the framework to the modelling of a public prosecution charging decision as part of a real legal decision making case study containing many of the above aspects of argumentation. The results show that the model can be a useful tool in the analysis of legal decision making, including the analysis of what-if questions and the analysis of alternative conclusions. The approach opens up two new perspectives in the short-term: the use of neural networks for computing prevailing arguments efficiently through the propagation in parallel of neuronal activations, and the use of the same networks to evolve the structure of the argumentation network through learning (e.g. to learn the strength of arguments from data).

Previous article in issueNext article in issue
Keywords
ArgumentationNeural-symbolic reasoningLegal decision makingCognitive modelling

1. Introduction
   Formal models of argumentation have been investigated in several areas, from multi-agent systems and artificial intelligence (AI) to decision making, philosophy and law [4], [8], [12], [17], [30], [33]. In artificial intelligence, models of argumentation have been used for commonsense reasoning, modelling chains of defeasible arguments to reach a conclusion. Such models are mainly founded on logic-based approaches, which have been the standard for the representation of argumentative reasoning in AI [3].

Recent efforts to bridge the gap between logic-based models of argumentation and cognitive models of computation include [10], [11], [34]. In [10], [11], an equivalence is shown between value-based argumentation [2] and standard connectionist networks [22]. This has created a new line of research in argumentation where (i) neural networks can be used as a cognitive computational model for argumentation and (ii) neural networks can be used to combine argumentation, quantitative reasoning and statistical learning. In [34], behavioural data is used to conclude that in human reasoning, reinstatement does not yield a full recovery of the attacked argument; [1] implements the same idea mathematically through equations that resemble the predator–prey dynamics of species populations. Further work integrating logic and neural networks include [20] where clustering in fuzzy ART networks is used to compute prevailing arguments, and [25] which extends the work in [10] to deal with self-defeating arguments and provides a number of interesting examples. At the same time, some non-standard models of argumentation start to emerge, enriching current models with cognitive abilities; e.g. [15] discusses meta-level attacks, coalitions, disjunctive attacks and argument support, [37] provides an adequate semantics for joint attacks, among much else, [29] seeks to unravel the role of emotions in argumentation, [14], [23] propose to handle uncertainty in argumentation through the assignment of probabilities and weights to arguments, and [13], [26] offer a qualitative method for reasoning about uncertainty and preferences between arguments.

We argue that the adoption of a cognitive approach to argumentation can offer an adequate framework for dealing with both standard and non-standard argumentation models. In this paper, we show that a cognitive approach can model many different aspects of argumentation in a uniform way, in particular, modelling uncertainty in argumentative reasoning and the accrual of arguments. The approach opens up, through the use of a connectionist system, two new short-term perspectives: (i) the use of neural networks to compute prevailing arguments efficiently through the propagation in parallel of neuronal activation signals and (ii) the use of the same networks to evolve the structure of an argumentation network through learning (e.g. to learn the strength of arguments from data). We believe that this approach also opens a more long-term perspective for the research on argumentation: the use of connectionist models of computation to help investigate and evaluate cognitive models of argumentation. For example, ideas from connectionism about the modelling of attention and emotion could be investigated in the context of argumentation [29], [36].

Argumentation has also been proposed as a method for helping machine learning systems [27] where an expert's arguments, or the reasons for some of the learning examples, are used to guide the search for hypotheses. This is related to the body of work on abductive reasoning and combinations of abduction and inductive logic programming [24], [28]. It is said that the arguments constrain the combinatorial search among possible hypotheses, directing the search towards hypotheses that are more comprehensible in the light of an expert's background knowledge [27]. We subscribe to this idea. In fact, experimental results on the integration of learning with background knowledge using neural networks have been shown to outperform symbolic and purely-connectionist systems, especially in the presence of noisy data [9]. In this paper, differently from [27], however, learning from data can be used to inform a process of numerical argumentation, allowing different perspectives of human argumentation, including joint attacks, argument support, meta-argumentation and disjunctive attacks, to be modelled in the same framework, as detailed in what follows.

The remainder of the paper is organised as follows. First, we define the concepts of argumentation and neural cognitive models used throughout the paper. Then, we present an algorithm, generalised from [10], which translates standard and non-standard argumentation frameworks into standard connectionist networks. We show that the resulting neural model executes a sound parallel computation of the prevailing arguments according to a number of standard argumentation semantics, and also according to value-based argumentation models [2], abstract dialectical frameworks [5], and other forms of human argumentation. We illustrate the network computation through examples that include joint attacks, support, meta-argumentation and disjunctive attacks. Finally, we apply the framework to a real decision making situation in legal reasoning, which indicates that the network model can be a useful tool in the modelling of non-standard and numerical argumentation, and in the analysis of what-if questions that emerge in real situations. The paper concludes with a brief discussion and directions for future work.

2. Background
   In this section, we present the concepts of argumentation and neural networks used throughout the paper.

Definition 1

An argumentation framework has the form
, where α is a set of arguments, and
is a relation indicating which arguments attack which other arguments.

In order to record the values associated with arguments, in [2] Bench-Capon has extended Dung's argumentation framework [12] by adding to it a set of values and a function mapping arguments to values. This brings argumentation closer to a numerical, connectionist approach.

Definition 2

A value-based argumentation framework is a 5-tuple
, where α is a finite set of arguments, attacks is an irreflexive binary relation on α, V is a non-empty set of values, val is a function mapping elements in α to elements in V, and P is a set of possible audiences, where we may have as many audiences as there are orderings on V. For every
,
.

Bench-Capon also defines the notions of objective and subjective acceptability of arguments. The first are arguments acceptable no matter the choice of preferred values for every audience, whereas the second are acceptable to some audiences. Arguments which are neither objectively nor subjectively acceptable are called indefensible. A function v from attack to
gives the relative strength of an argument. Given
, if
then
is said to be stronger than
. Otherwise, if
then
is weaker than
.

We shall also relate the neural approach with abstract dialectical frameworks [5].

Definition 3

An abstract dialectical framework (ADF) is a tuple
where S is a set of nodes,
is a set of links,
is a set of total functions
, one for each node s.

Consider an example. A person is innocent (i), unless she is a murderer (m). A killer (k) is a murderer (m), unless she acted in self-defence (s). There must be evidence for self-defence, e.g. a witness (w) who is not known to be a liar (l). An ADF can model the above example by stating that s is in if w is in and l is out. Similarly, m is in if k is in and s is out. In other words, like neural networks, ADFs include the concept of support. If k and w are in and l is out then s will be in; s then defeats m regardless of k so that i prevails. Every argumentation framework has an associated ADF. Also, normal logic programs have associated ADFs [5]. Since every logic program also has an associated neural network [9], this fact will be used later to show the required correspondences.

Other established definitions of argumentation semantics will be considered as well [6], [7], [12]. In all the definitions that follow, an argumentation framework is a pair
, as above. First, let us define a function
, such that
is defended by α}, where
. The function F computes the arguments accepted in the sense of [12] or defended by a set of arguments, in the sense of [7]. In this way, we can define conflict-free sets of arguments. A set of arguments is conflict-free if and only if (iff, for short) it does not contain any arguments A and B such that A defeats B. Let Args be a conflict-free set of arguments. Args is said to be a complete extension iff
.

In another useful argumentation semantics, the grounded semantics, only one extension is yielded by making use of the function F and defining the grounded extension as the minimal fixed point of F [31]. A grounded extension is conflict-free [7]. In the preferred semantics [12], a more credulous approach is used, which maximizes the number of accepted arguments. In order to define preferred semantics, Dung introduces the notion of admissible sets of arguments. A set of arguments is admissible iff it is conflict-free and
. The set Args is a preferred extension iff Args is maximal w.r.t. set inclusion. In the stable semantics of argumentation [18], a set of arguments is called stable iff it defeats each argument that does not belong to this set. In semi-stable semantics, a set of arguments Args is semi-stable iff Args is a complete extension of which
is maximal and defines a set of arguments which are defeated by an argument in Args.

In order to illustrate the different argumentation semantics, we borrow an example from [7]. Consider the abstract argumentation framework depicted as a directed graph in Fig. 1, where each node is an argument and an arrow from argument X to argument Y denotes an attack from X on Y. This framework has grounded extension {E, F}; complete extensions {E, F}, {B, C, E, F} and {A, E, F}; preferred extensions {B, C, E, F} and {A, E, F}; stable extension {B, C, E, F}; and semi-stable extension {B, C, E, F}. As pointed out in [7], semi-stable and stable extensions will coincide whenever the framework has at least one stable extension.

Download : Download full-size image
Fig. 1. An abstract argumentation framework with arguments A, B, C, D, E, and F; D is a self-defeating argument.

Finally, we shall also consider meta-argumentation [15]. In a meta-argumentation network, let argument a attack b in the usual way. It is possible to define an argument c as an attack on a's attack. This makes the framework more fine-grained in that c's attack does not propagate throughout the network, but is targeted at one specific attack in the network. Meta-argumentation can be reduced to argumentation frameworks with the addition of a node denoting
and a careful re-organization of the network [15].

We shall use a standard definition of neural networks, as follows. A neural network is a directed graph with the following structure: a unit (or neuron) in the graph is characterised, at time t, by its input vector
, its input potential
, its activation state
, and its output
. The units of the network are interconnected via a set of directed and weighted connections such that if there is a connection from unit i to unit j then
denotes the weight of this connection. The input potential of neuron i at time t (
) is obtained by computing a weighted sum for neuron i such that
. The activation state
of neuron i at time t is then given by the neuron's activation function
such that
. Typically,
is either a linear function, a non-linear step function, or a sigmoid function such as
. In this paper, we use
as activation function and inputs values in the range [
]. In addition,
(an extra weight with input always fixed at 1) is known as the bias of neuron i. We say that neuron i is active at time t if
. Finally, the neuron's output value
is given by its output function
. Usually,
is the identity function so that
.

3. Neural cognitive argumentation frameworks
   We start by considering the relationship between argumentation and neural networks informally. If we represent an argument by a neuron then a connection from neuron i to neuron j can indicate that argument i either attacks or supports argument j, the weight of the connection corresponding to the strength of the attack or support. Since real numbers are used as weights in a neural network, we associate negative weights with attacks, positive weights with support, and zero weight with the lack of an attack or support.

Definition 4

We say that an argument prevails at time t when the activation state of its associated neuron is greater than a predefined value
at time t,
. We say that an argument is defeated at time t when the neuron's activation is smaller than
. Otherwise, i.e. for activations in the interval [
], we say that it is unknown whether an argument prevails or not.

There are different ways in which an argument may support other arguments. For example, an argument i may support argument j by attacking an argument k that attacks j, or argument i may support j directly, e.g. by strengthening the value of j, or even i and j may get together to attack k. Generally, an argument i supports an argument j if the coordination of i and j reduces the likelihood of j being defeated [39]. A general neural network structure capable of accounting for the above combinations of attack and support and the necessary computations of prevailing arguments would be a recurrent network having an input layer, a single hidden layer, and an output layer with feedback from the output to the input layer [9]. At time
, input values are provided to the network. Neuronal activation is then propagated in parallel from the input to the hidden layer at time
, and to the output of the network at time
. At time
, the output values can be fed back to the input of the network, and this process can be repeated until a stable state is obtained, when input and output values will be the same for each pair of neurons with feedback. Arguments for which the associated neuron is activated at the stable state are said to prevail.

Consider the neural network of Fig. 2(b), which implements the argumentation network of Fig. 2(a). Arguments A, B and C are encoded in the network's input and output layers. In this example, arguments do not get together to attack another argument so that each input neuron is connected directly to a hidden neuron and the weights from the input to the hidden layer simply serve to send the input information forward. Support and attack information is encoded by the weights leading from the hidden to the output layer of the network. Support for A is encoded by the positive weight going from neuron
to output neuron A. Similarly, support for B (resp. C) is encoded by the weight going from
(resp.
) to B (resp. C). A's attack on B is represented by the dashed arrow going from
to B, which should have negative weight, as specified in the algorithm below. Similarly, B's attack on C is represented by the dashed arrow going from
to C, with a negative weight.

Download : Download full-size image
Fig. 2. (a) Illustration of an argumentation network in which argument A attacks argument B, which in turn attacks argument C, and (b) its neural implementation, where solid lines receive positive weights and dashed lines, which represent the attacks, receive negative weights.

If the absolute value of the weight going from
to B (call it
) is larger than the value of the weight from
to B (call it
) then A defeats B. This produces {
} as prevailing arguments and is identical to the usual (non-value based) interpretation of argumentation frameworks [12]. The prevailing arguments are computed by the network as follows: suppose that A, B and C are all present at time
, denoted by input vector [
]. Hidden neurons
,
and
all become activated;
activates A, and blocks the activation of B from
(because
). At the same time, C is blocked by
(by default, we assume that attacks are stronger than support, i.e. the weight from
to C is greater in absolute value than the weight from
to C, unless stated otherwise). Thus, at time
, only output neuron A is activated (i.e. only the output of neuron A is greater than
). This is then represented as a new input vector [
] at time
. Given this new input, A continues to prevail, B is defeated as before, but C is reinstated because B now fails to defeat it, since B is not present in the input anymore. Thus, at time
, output neurons A and C become activated. At time
, a new input [
] is produced. Finally, with [
] given as input, output neurons A and C become activated again, producing a stable state in the network. Recall that network outputs are real values in the range (
). To compute a stable state, each output value in the range (
) is mapped to 1, output values in the range (
) are mapped to −1, and values in the range [
] are mapped to 0. After this is done, the network's new input vector can be compared with its previous input. In this example, the input vector at time
will be identical to the input vector at time
, that is [
] is a stable state. The network's stable activations indicate the prevailing arguments {
}. This result also coincides with the standard ADF interpretation of support (Definition 3). In the case of VAF (Definition 2), if B is preferred over A, all that needs changing in the network is the value of
or
so that
, denoting that the attack from A on B should not be strong sufficiently to defeat B [10]. In this case, input [
] produces new input [
], which is a stable state, given the neural network's new set of weights. This new network, therefore, computes prevailing arguments {
}, as expected in the case of the VAF under consideration.

As another example, consider the network of Fig. 3(b). Here, a cycle exists in the argumentation network. This may create an infinite loop in the computation of the stable state of the associated neural network; e.g. if the network were to be started on input vector [
], it would oscillate between that state and state [
] indefinitely, with the arguments all being attacked in parallel and defeated in a single pass through the network, and then reinstated in the next pass through the network. In order to handle this as intended by the usual argumentation semantics, whenever the neural network reaches a state [
], the computation stops. In this case, the neural network computes the grounded extension of the argumentation network, as discussed in more detail later. Summarising, our policy is that the network computation stops when either a stable state is obtained or when [
] is reached. We call [
] a terminal state. Notice that by following a value-based approach, and changing the weights according to some preference relation, one might eliminate the loop [10]. For example, if as before, B is preferred over A then the attack from A on B will not be successful, with input [
] producing stable state [
]. When the weights are different, the neural network is less likely to enter into an infinite loop (see [10] for a discussion on how weight learning given new information following a value-based approach can be useful at resolving loops).

Download : Download full-size image
Fig. 3. (a) An example of a cyclic argumentation network and (b) its neural implementation whose parallel computation produces, in a single pass through the network, a terminal state [−1,−1,−1] with no prevailing argument, following a grounded argumentation semantics.

The algorithm below generalises the algorithm first introduced in [10], which was made for VAF only. It translates argumentation frameworks into single-hidden layer neural networks that behave as exemplified, and can be used to compute prevailing arguments in parallel. It does so by defining the structure and set of weights of a neural network as a function of
, using activation function
and inputs in {
}. Each argument has a strength given by positive weight
. Certain arguments may attack other arguments with negative weight
, and certain arguments may support other arguments with positive weight
. The weights are such that activations in the interval [
] are guaranteed not to occur for now (we shall consider uncertainty in the next section). The neural network produces outputs in the intervals (
), which is mapped to false and denotes that an argument is defeated, and (
), which is mapped to true, denoting that an argument prevails.

By default, Algorithm 1 implements Dung's argumentation frameworks. If an argument
attacks an argument
, and
is itself not attacked, then neuron
should block neuron
. However, if
is deemed weaker than
, and no other argument attacks
, then neuron
should not block neuron
. To achieve this, and account for a number of other, alternative semantics and modes of argumentation in a neural network [16], the constraints on
and
can be modified, as will become clearer in Section 4. Also, in Algorithm 1, a single supporting argument is deemed sufficient to defeat any attack; the other alternatives, leading to different constraints on
and
, will be considered in Section 4. A novelty of the algorithm is that arguments may have strengths
, which may vary from one attack to another. Before we consider the extensions of Algorithm 1, however, let us make the ideas developed so far more precise.

Download : Download full-size image
Algorithm 1. General neural argumentation algorithm.

Definition 5

Let
. Let
denote the activation of neuron α at time t. We say that a neural network
computes an argumentation framework
if whenever
and
then
, and whenever
for every
such that
then
(reinstatement).

Proposition 6

For each argumentation framework
there exists a single-hidden layer neural network
such that
computes
.

Proof

First, we show that if
in the input layer of
then
in the output layer of
whenever there are no attacks on
. In the worst case, the input potential of hidden neuron
is
, and the output of
is
. We want
. Again in the worst case, the input potential of output neuron
will be
, and we need
. As a result,
needs to be satisfied. When there is an attack on
, the activation of output neuron
needs to be smaller than
if hidden neuron
is active. In the worst case,
has activation
,
has activation 1, and any other attacking neuron has activation −1. Hence,
has to be satisfied, where n is the number of attacks. Dually, when there are no attacks on
, the following inequality has to be satisfied:
, which gives
and the constraint on
, as shown in Algorithm 1, step 4. When at least one argument
supports argument
, the following inequality has to be satisfied (again, in the worst case analysis):
. Dually, in the worst case,
has to be satisfied, which gives
and the constraint on
, as shown in Algorithm 1, step 5. This completes the proof. □しろいしかく

Proposition 7

For each ADF
there exists a single-hidden layer neural network
such that
computes
.

Proof

The standard ADF interpretation is that
when
attacks
. This interpretation has been covered in the proof of Proposition 6. In weighted ADFs, however, one can distinguish different combinations of attack and support [5], in particular, a supporting link can be stronger than an attacking link so that the attacked argument prevails. Since neural networks with as few as a single hidden layer are universal approximators, it follows that in the neural argumentation approach, any Boolean combination of attacks and support can be computed. In the specific case of support, we need to show that if
supports
then if
then
. As before, we associate inputs in the interval
to in and inputs in the interval
to out. In the worst case, we need
. Thus,
, as guaranteed by the algorithm. This completes the proof. Notice that, in practice, we convert inputs in the interval
to 1, and inputs in the interval
to −1, which relaxes further the above constraint on
. □しろいしかく

We can also show that the neural-network approach is very general by proving that it computes the many different argumentation semantics, as defined earlier [6], [12]. Before that is done, however, we should note that an argument that is not attacked by any other argument cannot be reinstated in the neural network (an argument that is attacked but not defeated will be reinstated as usual). For example, argument E in Fig. 1 will be in if its input value is 1, and will be out if its input value is −1. It will continue to be out over time if it is out initially, and will be in otherwise. Argument B, on the other hand, will be reinstated whenever argument A is not present, and vice-versa.

Lemma 8

For each argumentation framework
there exists a single-hidden-layer recurrent neural network
such that the complete extensions of
are stable states of
.

Proof

Recall that a set of arguments Args is said to be a complete extension of
iff
. From Proposition 6, one pass through
computes
. Recurrently connected,
iterates
until a stable state is reached, which is a fixed point of F, that is
. □しろいしかく

Corollary 9

For each argumentation framework
there exists a recurrent neural network
such that the grounded, preferred, stable and semi-stable extensions of
are stable states of
.

As an example, consider again the argumentation framework of Fig. 1. Starting from
, without a terminal state, the associated neural network can converge to the following stable states: {B, C, E, F} and {A, E, F}, corresponding to its preferred extensions. With a terminal state, the network will converge to either {E, F}, {B, C, E, F} or {A, E, F}, corresponding to its complete extensions.

Finally, consider the argumentation network of Fig. 4, for which no stable state exists. With the use of a terminal state, the corresponding neural network will implement a semi-stable semantics, providing the empty set as the only extension. Without a terminal state, the neural network will loop (until it is either halted or its weights are changed), implementing a stable semantics.

Download : Download full-size image
Fig. 4. Semantic circularity for which no stable state exists.

The neural networks of Fig. 2, Fig. 3 should be seen as computational models rather than abstract argumentation frameworks. As discussed, the networks can be used in the parallel computation of prevailing arguments: given input vector [
] at the start, the networks should always converge to a stable state corresponding to a set of prevailing arguments, according to a (value-based, preferred, etc.) argumentation semantics.

Definition 10

We say that neural network
computes an (extension-based semantics of) argumentation framework
if every stable state of
is an extension of
.

Proposition 11

If
computes
and
admits a single extension then starting from input vector
,
always finds a stable state corresponding to the prevailing arguments of
.

Proof

The arguments in
can be viewed as logic programming clauses of the form
. Starting from [
],
will treat each
as a fact unless
is attacked and defeated by another argument
, which corresponds to adding a clause
to the program (where ¬ stands for negation by failure). If
admits a single extension then the corresponding program will have a single model. The stable models of any logic program can be computed by a single-hidden layer neural network; with a single model, the network is known to always settle down in a stable state corresponding to this model, as proved in [9]. Such a result can be applied directly here to complete the proof. □しろいしかく

As exemplified earlier, it should be possible to extend Proposition 11 to certain very general classes of argumentation networks that admit multiple extensions. Due to the numerical nature of the networks, they are unlikely to oscillate unless integer weights with the same absolute values are used. For example, we have seen that, starting from [
], the network of Fig. 3 converges to a terminal state. Otherwise, it loops. As argued in [10], a network that loops should be seen as an opportunity for learning, whereby what-if questions can be considered and the network's weights can be changed slightly. Similarly, when a network reaches a terminal state, this should trigger a search for new evidence about the relative strength of the arguments. For example, consider the case where arguments A and B attack each other in a cycle. The corresponding neural network has two stable states, namely [
] and [
], corresponding to the two stable extensions of the argumentation network. Starting from [
], the neural network produces output [
], which is a terminal state. At this point, the computation stops. However, a loop exists in the network computation, since input [
] would produce output [
]. A terminal state does not provide much information by itself (a terminal state could be seen as producing maximum uncertainty). However, if the reaching of a terminal state is seen as a trigger for a search for more evidence, perhaps this search could shed new light on the relative strengths of arguments A and B, defining a preference for either argument by changing the weights of the network. If a neural network is such that the weights do not have the same absolute values then it is unlikely that arguments will cancel each other, as seen above, so that the network loops. Breaking such a symmetry in the set of weights by changing their values slightly is the norm of network learning, and could be seen as an alternative to the use of terminal states and a solution to the problem of having loops in the computation of such neural networks [10].

4. Neural cognitive nonclassical argumentation
   It is natural for a neural network to combine the weights representing multiple support or multiple attacks in order to compute the activation state of a neuron/argument. This is interesting in relation to the question of the accrual of arguments [38]. So far, our standard interpretation has been that any attack suffices to defeat an argument, unless a value-based function says otherwise. Another interpretation, however, is that arguments may get together to attack an argument (that is, only the conjunction of the arguments enables the attack; this is called a joint-attack [1]). Fig. 5(a) shows two arguments A and C attacking argument B. When either
   or
   for the standard interpretation, the attacks can be implemented by Algorithm 1 above. However, when arguments are allowed to accrue and either
   or
   , a decision has to be made as to whether or not A and C together can defeat B [10]. The same is true for support. Fig. 5(b) shows an argument A supporting argument B as done in ADFs. It may be that without A's support, B would be defeated, say, by an attack from another argument C, but B is not defeated with A's support. Finally, Fig. 5(c) shows a situation where, only if A and B prevail, can they attack C. Hidden neuron
   implements, in the usual way, a logical-AND. This is the situation where arguments A and B "get together" to attack C.

Download : Download full-size image
Fig. 5. Alternative modes of attack and support: (a) multiple attacks, (b) support, and (c) joint-attacks.

Let us consider Fig. 5(a) in more detail. Let
denote the weight from hidden neuron
to output neuron B. As said, the natural computation of a neural network will combine the weights into the input potential of B. Suppose that
and
. In this situation, neither A nor C defeat B, but, together, A and C may defeat B as an unintended consequence of the combination of the weights. To avoid this problem, we use the following convention: when arguments create a joint attack on another argument, the set-up of Fig. 5(c) is used. If n arguments are joined through hidden neuron
, then the bias
of
should satisfy the following inequality, which implements the intended logical-AND.

Let us now consider in more detail the situation where an argument receives multiple support (Fig. 5(b)). This situation is similar to that considered earlier, that is, whether some attack is strong enough to defeat all of the support received by B or whether the support for A overrides the attack, making it unsuccessful. The first case is straightforward and can be implemented by making:
where k is the number of supporting arguments, each with weight
.

The second case, in a more general set-up, takes a linearly ordered set
such that argument
prevails if it is not attacked, but
is defeated when attacked by
. However,
prevails again if it is supported by another argument
, but is defeated again if attacked by
, and so on. We need to assign values to weights
, as follows:
where
and ε is a small positive number such that
(typically
).

A further possibility would be to allow certain combinations of support to prevail and certain others to be defeated. This is, in fact, a likely outcome if a learning algorithm is to be applied, with the network's weights changing as a result of learning from data. Any combination of attack and support can be encoded in a neural network, as follows. The linear ordering above can be extended to multisets in the usual way, so that each
,
, denotes a set of arguments. The value of
will then correspond to the sum of the weights either attacking or supporting
, each weight being equal to
, where k is the cardinality of the set of arguments in question. Since we would like the combination of k arguments, and not of
or fewer arguments, to have the above effect, the following inequality should be satisfied:

The dual of the conjunctive attacks exemplified above are the disjunctive attacks shown in Fig. 6(a). In the figure, the activation of hidden neuron ∨ should attack either argument B or C according to some probability distribution. We say that neuron ∨ behaves stochastically. Having a standard hidden neuron in Fig. 6(a) would denote that A attacks both B and C. With a stochastic hidden neuron, either B or C is attacked with a probability. This offers a way of implementing the idea of a disjunctive attack, i.e. one that attacks either argument, but it does not matter which argument. If, for example, the probability of attacking argument B should be 50%, a random number is generated in the interval
and, if this number is greater than 0.5 then argument B is attacked; otherwise, argument C is attacked.

Download : Download full-size image
Fig. 6. Disjunctive attacks (a), self-defeating attacks (b), and attacks on attacks (c).

Let
denote the arguments (neurons) attacked stochastically through hidden neuron
. From the point of view of the network computation, for each
, we select a neuron
,
, at a time (at each round, a single
is chosen to receive activation from
). A stable state denoting a set
of potential prevailing arguments is then obtained in the usual way (with the same
being selected if the network recurs through
). We take
as our final set of prevailing arguments (i.e. following a skeptical semantics).

In addition to disjunctive attacks, the recent literature on argumentation has discussed extensively the modelling of self-defeating arguments as well as the concept of meta-argumentation [15], [25], [26]. Fig. 6(b) exemplifies the implementation of a self-defeating argument in a neural network. In the figure, argument A attacks argument B, but A is self-defeating, that is, the weight of the connection to output neuron A is negative. Hence, B prevails, as expected. Fig. 6(c) exemplifies a meta-level attack, i.e. an attack not on an argument, but on another attack. In Fig. 6(c), argument A does not attack argument B, but it attacks B's attack on C. As a result, C prevails. In this setting, it is possible for B to succeed in attacking another argument, say D, through a different hidden neuron. Notice the similarity between Fig. 6(c) and Fig. 5(c). Not surprisingly, the semantics of meta-level attacks can be characterised in terms of joint-attacks, by adding the meta-level attack itself as a node in the argumentation network [15].

Definition 12

Let
denote an attack from argument a on argument b. Suppose that argument c attacks this attack; we write it as
. A meta-argumentation network is an argumentation network extended with such attacks on attacks.

Lemma 13

(See [15].) Let
be a meta-argumentation network where
.
can be reduced to an argumentation network containing an extra node
such that
and
jointly attack
, and
attacks
.

Proposition 14

For any meta-argumentation network
there exists a neural network
such that
computes
.

Proof

We are concerned with the situation
without recursion. In the reduced network, node i attacks node jk, and nodes jk and j jointly attack node k. In the neural network (with the same structure as in Fig. 6(c)), we have
attacking k (recall that we have defined joint-attacks as conjunctions). If i is in then jk is out and k is in; if i is out then k is out iff j is in. In the neural network, the hidden neuron representing jk will be activated, attacking and defeating k iff
(or out) and
(or in), which clearly produces the same intended outcome. □しろいしかく

5. Case study: Public prosecution charging decision
   In this section, we apply the neural cognitive argumentation framework to the modelling of a public prosecution charging decision, which was part of a real legal case. The modelling of the charging decision includes many of the argumentation aspects addressed by our proposed framework, notably uncertainty, joint-attacks, argument support and ADF-style reasoning. The results show that the neural model can be a useful tool in the analysis of legal decision making, including the analysis of what-if questions, as detailed below.

The following is an extract from a charging decision statement made 29 May 2012 by Alison Levitt, Queen's Counsel, Principal Legal Advisor to the Director of Public Prosecutions in relation to allegations that a police officer passed confidential information to a journalist about Operation Weeting, a police investigation into allegations of phone hacking by newspapers in the United Kingdom.

In what follows, we will represent the main aspects of the arguments discussed in the charging decision statement as a neural cognitive model, and analyse the possible model set-ups and computations, and their alternative conclusions in relation to the actual outcomes of this legal case study. We are interested in exemplifying the use of the proposed model in practice, and analysing its usefulness as a tool for modelling the different aspects of argumentation, including the analysis of what-if questions, as detailed below.

"On 2 April 2012 the Crown Prosecution Service received a file of evidence from the Metropolitan Police Service requesting charging advice in relation to two suspects. The first is a serving Metropolitan Police Officer in the Operation Weeting team whose name is not in the public domain. He is currently suspended. The second suspect is Amelia Hill, a journalist who writes for The Guardian newspaper.

The allegation is that the police officer passed confidential information about phone hacking cases to the journalist.

All the evidence has now carefully been considered and I have decided that neither the police officer nor the journalist should face a prosecution. The following paragraphs explain the reasons for my decision.

The suspects have been considered separately, as different considerations arise in relation to each of them.

Between 4 April 2011 and 18 August 2011, Ms. Hill wrote ten articles which were published in The Guardian. I am satisfied that there is sufficient evidence to establish that these articles contained confidential information derived from Operation Weeting, including the names of those who had been arrested. I am also satisfied that there is sufficient evidence to establish that the police officer disclosed that information to Ms Hill.

I have concluded that there is insufficient evidence against either suspect to provide a realistic prospect of conviction for the common law offence of misconduct in a public office or conspiracy to commit misconduct in a public office.

In this case, there is no evidence that the police officer was paid any money for the information he provided.

Moreover, the information disclosed by the police officer, although confidential, was not highly sensitive. It did not expose anyone to a risk of injury or death. It did not compromise the investigation. And the information in question would probably have made it into the public domain by some other means, albeit at some later stage.

In those circumstances, I have concluded that there is no realistic prospect of a conviction in the police officer's case because his alleged conduct is not capable of reaching the high threshold necessary to make out the criminal offence of misconduct in public office. It follows that there is equally no realistic prospect of a conviction against Ms. Hill for aiding and abetting the police officer's conduct.

However, the information disclosed was personal data within the meaning of the Data Protection Act 1998 and I am satisfied that there is arguably sufficient evidence to charge both the police officer and Ms. Hill with offences under section 55 of that Act, even when the available defences are taken into account.

I have therefore gone on to consider whether a prosecution is required in the public interest. There are finely balanced arguments tending both in favour of and against prosecution.

Journalists and those who interact with them have no special status under the law and thus the public interest factors have to be considered on a case by case basis in the same way as any other. However, in cases affecting the media, the DPP's Interim Guidelines require prosecutors to consider whether the public interest served by the conduct in question outweighs the overall criminality alleged.

So far as Ms Hill is concerned, the public interest served by her alleged conduct was that she was working with other journalists on a series of articles which, taken together, were capable of disclosing the commission of criminal offences, were intended to hold others to account, including the Metropolitan Police Service and the Crown Prosecution Service, and were capable of raising and contributing to an important matter of public debate, namely the nature and extent of the influence of the media. The alleged overall criminality is the breach of the Data Protection Act, but, as already noted, any damage caused by Ms. Hill's alleged disclosure was minimal. In the circumstances, I have decided that in her case, the public interest outweighs the overall criminality alleged.

Different considerations apply to the police officer. As a serving police officer, any claim that there is a public interest in his alleged conduct carries considerably less weight than that of Ms Hill. However, there are other important factors tending against prosecution, including as already noted, the fact that no payment was sought or received, and that the disclosure did not compromise the investigation. Moreover, disclosing the identity of those who are arrested is not, of itself, a criminal offence. It is only unlawful in this case because the disclosure also breached the Data Protection Act.

In the circumstances, I have decided that a criminal prosecution is not needed against either Ms. Hill or the police officer.

However, in light of my conclusion that there is sufficient evidence to provide a realistic prospect of convicting the police officer for an offence under the Data Protection Act, I have written to the Metropolitan Police Service and to the IPCC recommending that they consider bringing disciplinary proceedings against him." Alison Levitt QC

Let us start by considering the arguments for and against prosecuting the journalist (pj) and the police officer (pp).

Arguments for prosecution:
A:
The articles contained confidential information;

B:
The police officer disclosed the information;

C:
A prosecution is required in the public interest.

Arguments against prosecution:
D:
There is no evidence that the police officer was paid any money;

E:
Information disclosed by the police officer, although confidential, was not highly sensitive;

F:
It did not expose anyone to a risk of injury or death;

G:
It did not compromise the investigation;

H:
It would probably have made it into the public domain by some other means;

I:
The public interest outweighs the overall criminality alleged;

J:
Together, the articles would expose the commission of criminal offences;

K:
Together, the articles would hold others to account;

L:
The articles contributed to an important matter of public debate, namely the nature and extent of the influence of the media.

Let us also analyse more closely the arguments relating to whether a prosecution is required in the public interest. The assumption is that both the journalist and the police officer have violated the Data Protection Act.

Arguments for bringing charges under the Data Protection Act:
M:
The information disclosed was personal data;

Arguments against bringing charges under the Data Protection Act:
N:
Disclosing the identity of those who are arrested is not, of itself, a criminal offence;

O:
It is only unlawful in this case because the disclosure also breached the Data Protection Act.

Remark 15

Notice how argument O was used rhetorically as part of an argument against bringing charges under the Data Protection Act. Argument O is, in fact, simply stating that the disclosure was unlawful because it breached the Data Protection Act. Consider also how the sentence below is used as part of the argumentation: "The alleged overall criminality is the breach of the Data Protection Act, but, as already noted, any damage caused by Ms. Hill's alleged disclosure was minimal". Our model will help quantify such damage and will require a definition of minimal, as will become clear. Similarly, the following sentences provide clues as to the weights to be assigned to the neural network, in relation to the police officer: "Any claim that there is a public interest in his alleged conduct carries considerably less weight" and "There is a high threshold to make out the criminal offence of misconduct in public office". We shall return to these once we have created the network model.

The QC's conclusion can be summarized as follows:
(a)
It was decided that a criminal prosecution is not needed;

(b)
It was decided that in the case of the journalist, the public interest outweighs the overall criminality alleged;

(c)
There is sufficient evidence to provide a realistic prospect of convicting the police officer for an offence under the Data Protection Act;

(d)
A recommendation was made to the police to consider bringing disciplinary proceedings against the police officer.

Our model's conclusion: Our model is concerned with making explicit the following relations (items 1 to 4 below).

On the issue of the police officer's misconduct:

1. Do the weights of the arguments exceed the high threshold for the offence of misconduct?

Arguments A, B and C should support the prosecution of the police officer (pp). Argument C should do so with a low weight (w) since the prosecution would be for misconduct in public office. Arguments D, F, G and H attack pp collectively (argument D with a high weight (W) for obvious reasons, and argument H with a low weight due to its speculative nature). Argument E attacks argument B. These are all the relevant arguments in relation to pp, as shown in Fig. 7, where dashed lines indicate attacks. As a result, neuron B fails to activate, and the weight of the arguments that collectively attack neuron pp should overcome the weight of the arguments that support pp. Hence, neuron pp should fail to activate. We discuss neuron/argument pj next.

Download : Download full-size image
Fig. 7. Neural implementation of legal case: prosecution decision.

2. If the police officer should not be prosecuted for misconduct then the journalist should not be prosecuted for aiding his conduct.

Item 2 above can be modelled in Fig. 7 using ADFs simply by stating that if argument pp is out (represented by a negative weight from input neuron pp to the hidden layer) then argument ¬pj should be in; hence, the journalist should not be prosecuted (in the neural network, if input neuron pp is not activated then output neuron ¬pj will be activated; see dashed line representing a negative weight from input neuron pp in Fig. 7). This separation between arguments pj and ¬pj allows one to ignore how arguments would influence neuron pj during the modelling of neuron ¬pj, and is referred to explicit negation in logic programming [19]. Thus, in case neuron pp fails to activate, which is the case here, neuron ¬pj will be activated. This completes the prosecution's analysis on the basis on misconduct.

On the issue of the violation of the Data Protection Act:

3. Do the weights of the arguments show that the public interest outweighs the violation of the Data Protection Act?

It is clear that arguments J, K and L support argument I, while argument M attacks I. In addition, argument N attacks M, and O attacks N, as shown in Fig. 8. The conclusion is that indeed argument I should prevail.

Download : Download full-size image
Fig. 8. Neural implementation of legal case: decision based on data protection act.

4. Different weights apply to the journalist and the police officer.

Argument M supports the argument that the journalist should be prosecuted for violation of the Data Protection Act (let us call this
). It also supports the argument for prosecuting the police officer for a violation of the Data Protection Act (call it
). The attacks from argument I on
and
should have different weights: a high (negative) weight W for
and a low (negative) weight (w) for
. Our model's conclusion, therefore, is that
should not prevail (i.e. the journalist should not be prosecuted), but differently from the QC's conclusion, if the value of the weight ω connecting argument M to
should be greater than the absolute value of w then argument
should prevail, i.e. the police officer would be prosecuted for violating the Data Protection Act. The actual values of weights ω and w may be a matter for debate, but perhaps the QC's arguments should have focused more on providing a justification for such values.

The above modelling exercise with the use of a neural cognitive model, may also help in the separation of concerns and systematic questioning of some of the assumptions made. For example, in this case study, some questions that emerge include: should different weights really apply to the journalist and the police officer, assuming they had to work as a team in the public interest? Aside from possible issues of remit, why should prosecution not be recommended straight away for the violation of the data protection act, and disciplinary proceedings should be evoked and recommended instead? We believe that our model should help prompt the user to ask such questions, organise the relationships among the different arguments under consideration, and investigate the impact of different weight assignments to the network model. For example, what if the weights W and w are assigned the same value? What if the weights ω and w are assigned the same absolute value? The user would then be able to run the model and consider the possible outcomes by analysing the different sets of prevailing arguments obtained as stable states of the neural network.

6. Conclusion and future work
   We have presented a neural cognitive model of argumentation that is capable of capturing a range of argumentation semantics and situations including joint-attacks, argument support, ordered attacks, disjunctive attacks, meta-level attacks and self-defeating attacks. All these different modes of argumentation can be modelled, learned and computed by means of a connectionist representation. In its most general form, arguments are weighted according to their strength, can support or attack other arguments directly, but can also combine conjunctively or disjunctively, sequentially or in parallel, at object- or meta-level, as exemplified throughout the paper. We have shown that all these different modes of argumentation can be represented and computed in a natural way by a connectionist network. This also indicates that the connectionist approach can offer an adequate tool for argument computation.

When dealing with uncertainty and meta-level preferences, in [14], the question of where the weights would come from is raised. In [2], voting by an audience is evoked as a solution that depends on meta-level considerations, as in [26]. With the framework proposed in this paper, the question gains a new dimension in that, as with any neural network, the weights can be learned from examples (i.e. instances from previous cases). As future work, we plan to explore the framework's learning capacity as part of a larger case study.

Uncertainty is intrinsic in human argumentation, yet most logic-based models of argumentation do not deal with uncertainty explicitly. Argumentation can be seen as a method for reducing one's uncertainty with the prevailing arguments being precisely those that are less-uncertain. In line with [21], [23], [35], the neural cognitive model introduced here lends itself well to this idea due to the use of weights and activation intervals as part of a neural network. However, we believe that the neural cognitive approach may also be advantageous from a purely computational perspective due to the networks' ability to adapt through learning and to compute prevailing arguments in parallel. All of the above is important given the objective of developing models of human argumentation. Future work includes, in addition to the evaluation of the framework's learning capacities, further experimentation on legal reasoning, a comparison of the framework's knowledge representation and learning capacity, e.g. in contrast with [23], [32], and the evaluation of the framework's parallel computation gains. A graphical interface is being developed to facilitate the interactive drawing and running of the networks as shown in the figures above, with all the features introduced here. We believe that such an interface can be useful as a tool for modelling, running and the elaboration of argumentation frameworks in a range of application areas.

https://aclanthology.org/N16-1007.pdf

Neural Network-Based Abstract Generation for Opinions and Arguments
Wang Ling
Google DeepMind
London, N1 0AE
Proceedings of NAACL-HLT 2016, pages 47–57,
San Diego, California, June 12-17, 2016.
c 2016

We study the problem of generating abstractive summaries for opinionated text. We propose an attention-based neural network model
that is able to absorb information from multiple text units to construct informative, concise,
and fluent summaries. An importance-based
sampling method is designed to allow the encoder to integrate information from an important subset of input. Automatic evaluation indicates that our system outperforms state-ofthe-art abstractive and extractive summarization systems on two newly collected datasets
of movie reviews and arguments. Our system
summaries are also rated as more informative
and grammatical in human evaluation.

https://www.sciencedirect.com/science/article/pii/S1570868313000748?via%3Dihub

Journal of Applied Logic

Volume 12, Issue 2, June 2014, Pages 109-127
Journal of Applied Logic
A neural cognitive model of argumentation with application to legal inference and decision making
Author links open overlay panelArtur S. d'Avila Garcez a, Dov M. Gabbay b, Luis C. Lamb c
https://doi.org/10.1016/j.jal.201308004

Abstract
Formal models of argumentation have been investigated in several areas, from multi-agent systems and artificial intelligence (AI) to decision making, philosophy and law. In artificial intelligence, logic-based models have been the standard for the representation of argumentative reasoning. More recently, the standard logic-based models have been shown equivalent to standard connectionist models. This has created a new line of research where (i) neural networks can be used as a parallel computational model for argumentation and (ii) neural networks can be used to combine argumentation, quantitative reasoning and statistical learning. At the same time, non-standard logic models of argumentation started to emerge. In this paper, we propose a connectionist cognitive model of argumentation that accounts for both standard and non-standard forms of argumentation. The model is shown to be an adequate framework for dealing with standard and non-standard argumentation, including joint-attacks, argument support, ordered attacks, disjunctive attacks, meta-level attacks, self-defeating attacks, argument accrual and uncertainty. We show that the neural cognitive approach offers an adequate way of modelling all of these different aspects of argumentation. We have applied the framework to the modelling of a public prosecution charging decision as part of a real legal decision making case study containing many of the above aspects of argumentation. The results show that the model can be a useful tool in the analysis of legal decision making, including the analysis of what-if questions and the analysis of alternative conclusions. The approach opens up two new perspectives in the short-term: the use of neural networks for computing prevailing arguments efficiently through the propagation in parallel of neuronal activations, and the use of the same networks to evolve the structure of the argumentation network through learning (e.g. to learn the strength of arguments from data).

Previous article in issueNext article in issue
Keywords
ArgumentationNeural-symbolic reasoningLegal decision makingCognitive modelling

1. Introduction
   Formal models of argumentation have been investigated in several areas, from multi-agent systems and artificial intelligence (AI) to decision making, philosophy and law [4], [8], [12], [17], [30], [33]. In artificial intelligence, models of argumentation have been used for commonsense reasoning, modelling chains of defeasible arguments to reach a conclusion. Such models are mainly founded on logic-based approaches, which have been the standard for the representation of argumentative reasoning in AI [3].

Recent efforts to bridge the gap between logic-based models of argumentation and cognitive models of computation include [10], [11], [34]. In [10], [11], an equivalence is shown between value-based argumentation [2] and standard connectionist networks [22]. This has created a new line of research in argumentation where (i) neural networks can be used as a cognitive computational model for argumentation and (ii) neural networks can be used to combine argumentation, quantitative reasoning and statistical learning. In [34], behavioural data is used to conclude that in human reasoning, reinstatement does not yield a full recovery of the attacked argument; [1] implements the same idea mathematically through equations that resemble the predator–prey dynamics of species populations. Further work integrating logic and neural networks include [20] where clustering in fuzzy ART networks is used to compute prevailing arguments, and [25] which extends the work in [10] to deal with self-defeating arguments and provides a number of interesting examples. At the same time, some non-standard models of argumentation start to emerge, enriching current models with cognitive abilities; e.g. [15] discusses meta-level attacks, coalitions, disjunctive attacks and argument support, [37] provides an adequate semantics for joint attacks, among much else, [29] seeks to unravel the role of emotions in argumentation, [14], [23] propose to handle uncertainty in argumentation through the assignment of probabilities and weights to arguments, and [13], [26] offer a qualitative method for reasoning about uncertainty and preferences between arguments.

We argue that the adoption of a cognitive approach to argumentation can offer an adequate framework for dealing with both standard and non-standard argumentation models. In this paper, we show that a cognitive approach can model many different aspects of argumentation in a uniform way, in particular, modelling uncertainty in argumentative reasoning and the accrual of arguments. The approach opens up, through the use of a connectionist system, two new short-term perspectives: (i) the use of neural networks to compute prevailing arguments efficiently through the propagation in parallel of neuronal activation signals and (ii) the use of the same networks to evolve the structure of an argumentation network through learning (e.g. to learn the strength of arguments from data). We believe that this approach also opens a more long-term perspective for the research on argumentation: the use of connectionist models of computation to help investigate and evaluate cognitive models of argumentation. For example, ideas from connectionism about the modelling of attention and emotion could be investigated in the context of argumentation [29], [36].

Argumentation has also been proposed as a method for helping machine learning systems [27] where an expert's arguments, or the reasons for some of the learning examples, are used to guide the search for hypotheses. This is related to the body of work on abductive reasoning and combinations of abduction and inductive logic programming [24], [28]. It is said that the arguments constrain the combinatorial search among possible hypotheses, directing the search towards hypotheses that are more comprehensible in the light of an expert's background knowledge [27]. We subscribe to this idea. In fact, experimental results on the integration of learning with background knowledge using neural networks have been shown to outperform symbolic and purely-connectionist systems, especially in the presence of noisy data [9]. In this paper, differently from [27], however, learning from data can be used to inform a process of numerical argumentation, allowing different perspectives of human argumentation, including joint attacks, argument support, meta-argumentation and disjunctive attacks, to be modelled in the same framework, as detailed in what follows.

The remainder of the paper is organised as follows. First, we define the concepts of argumentation and neural cognitive models used throughout the paper. Then, we present an algorithm, generalised from [10], which translates standard and non-standard argumentation frameworks into standard connectionist networks. We show that the resulting neural model executes a sound parallel computation of the prevailing arguments according to a number of standard argumentation semantics, and also according to value-based argumentation models [2], abstract dialectical frameworks [5], and other forms of human argumentation. We illustrate the network computation through examples that include joint attacks, support, meta-argumentation and disjunctive attacks. Finally, we apply the framework to a real decision making situation in legal reasoning, which indicates that the network model can be a useful tool in the modelling of non-standard and numerical argumentation, and in the analysis of what-if questions that emerge in real situations. The paper concludes with a brief discussion and directions for future work.

2. Background
   In this section, we present the concepts of argumentation and neural networks used throughout the paper.

Definition 1

An argumentation framework has the form
, where α is a set of arguments, and
is a relation indicating which arguments attack which other arguments.

In order to record the values associated with arguments, in [2] Bench-Capon has extended Dung's argumentation framework [12] by adding to it a set of values and a function mapping arguments to values. This brings argumentation closer to a numerical, connectionist approach.

Definition 2

A value-based argumentation framework is a 5-tuple
, where α is a finite set of arguments, attacks is an irreflexive binary relation on α, V is a non-empty set of values, val is a function mapping elements in α to elements in V, and P is a set of possible audiences, where we may have as many audiences as there are orderings on V. For every
,
.

Bench-Capon also defines the notions of objective and subjective acceptability of arguments. The first are arguments acceptable no matter the choice of preferred values for every audience, whereas the second are acceptable to some audiences. Arguments which are neither objectively nor subjectively acceptable are called indefensible. A function v from attack to
gives the relative strength of an argument. Given
, if
then
is said to be stronger than
. Otherwise, if
then
is weaker than
.

We shall also relate the neural approach with abstract dialectical frameworks [5].

Definition 3

An abstract dialectical framework (ADF) is a tuple
where S is a set of nodes,
is a set of links,
is a set of total functions
, one for each node s.

Consider an example. A person is innocent (i), unless she is a murderer (m). A killer (k) is a murderer (m), unless she acted in self-defence (s). There must be evidence for self-defence, e.g. a witness (w) who is not known to be a liar (l). An ADF can model the above example by stating that s is in if w is in and l is out. Similarly, m is in if k is in and s is out. In other words, like neural networks, ADFs include the concept of support. If k and w are in and l is out then s will be in; s then defeats m regardless of k so that i prevails. Every argumentation framework has an associated ADF. Also, normal logic programs have associated ADFs [5]. Since every logic program also has an associated neural network [9], this fact will be used later to show the required correspondences.

Other established definitions of argumentation semantics will be considered as well [6], [7], [12]. In all the definitions that follow, an argumentation framework is a pair
, as above. First, let us define a function
, such that
is defended by α}, where
. The function F computes the arguments accepted in the sense of [12] or defended by a set of arguments, in the sense of [7]. In this way, we can define conflict-free sets of arguments. A set of arguments is conflict-free if and only if (iff, for short) it does not contain any arguments A and B such that A defeats B. Let Args be a conflict-free set of arguments. Args is said to be a complete extension iff
.

In another useful argumentation semantics, the grounded semantics, only one extension is yielded by making use of the function F and defining the grounded extension as the minimal fixed point of F [31]. A grounded extension is conflict-free [7]. In the preferred semantics [12], a more credulous approach is used, which maximizes the number of accepted arguments. In order to define preferred semantics, Dung introduces the notion of admissible sets of arguments. A set of arguments is admissible iff it is conflict-free and
. The set Args is a preferred extension iff Args is maximal w.r.t. set inclusion. In the stable semantics of argumentation [18], a set of arguments is called stable iff it defeats each argument that does not belong to this set. In semi-stable semantics, a set of arguments Args is semi-stable iff Args is a complete extension of which
is maximal and defines a set of arguments which are defeated by an argument in Args.

In order to illustrate the different argumentation semantics, we borrow an example from [7]. Consider the abstract argumentation framework depicted as a directed graph in Fig. 1, where each node is an argument and an arrow from argument X to argument Y denotes an attack from X on Y. This framework has grounded extension {E, F}; complete extensions {E, F}, {B, C, E, F} and {A, E, F}; preferred extensions {B, C, E, F} and {A, E, F}; stable extension {B, C, E, F}; and semi-stable extension {B, C, E, F}. As pointed out in [7], semi-stable and stable extensions will coincide whenever the framework has at least one stable extension.

Download : Download full-size image
Fig. 1. An abstract argumentation framework with arguments A, B, C, D, E, and F; D is a self-defeating argument.

Finally, we shall also consider meta-argumentation [15]. In a meta-argumentation network, let argument a attack b in the usual way. It is possible to define an argument c as an attack on a's attack. This makes the framework more fine-grained in that c's attack does not propagate throughout the network, but is targeted at one specific attack in the network. Meta-argumentation can be reduced to argumentation frameworks with the addition of a node denoting
and a careful re-organization of the network [15].

We shall use a standard definition of neural networks, as follows. A neural network is a directed graph with the following structure: a unit (or neuron) in the graph is characterised, at time t, by its input vector
, its input potential
, its activation state
, and its output
. The units of the network are interconnected via a set of directed and weighted connections such that if there is a connection from unit i to unit j then
denotes the weight of this connection. The input potential of neuron i at time t (
) is obtained by computing a weighted sum for neuron i such that
. The activation state
of neuron i at time t is then given by the neuron's activation function
such that
. Typically,
is either a linear function, a non-linear step function, or a sigmoid function such as
. In this paper, we use
as activation function and inputs values in the range [
]. In addition,
(an extra weight with input always fixed at 1) is known as the bias of neuron i. We say that neuron i is active at time t if
. Finally, the neuron's output value
is given by its output function
. Usually,
is the identity function so that
.

3. Neural cognitive argumentation frameworks
   We start by considering the relationship between argumentation and neural networks informally. If we represent an argument by a neuron then a connection from neuron i to neuron j can indicate that argument i either attacks or supports argument j, the weight of the connection corresponding to the strength of the attack or support. Since real numbers are used as weights in a neural network, we associate negative weights with attacks, positive weights with support, and zero weight with the lack of an attack or support.

Definition 4

We say that an argument prevails at time t when the activation state of its associated neuron is greater than a predefined value
at time t,
. We say that an argument is defeated at time t when the neuron's activation is smaller than
. Otherwise, i.e. for activations in the interval [
], we say that it is unknown whether an argument prevails or not.

There are different ways in which an argument may support other arguments. For example, an argument i may support argument j by attacking an argument k that attacks j, or argument i may support j directly, e.g. by strengthening the value of j, or even i and j may get together to attack k. Generally, an argument i supports an argument j if the coordination of i and j reduces the likelihood of j being defeated [39]. A general neural network structure capable of accounting for the above combinations of attack and support and the necessary computations of prevailing arguments would be a recurrent network having an input layer, a single hidden layer, and an output layer with feedback from the output to the input layer [9]. At time
, input values are provided to the network. Neuronal activation is then propagated in parallel from the input to the hidden layer at time
, and to the output of the network at time
. At time
, the output values can be fed back to the input of the network, and this process can be repeated until a stable state is obtained, when input and output values will be the same for each pair of neurons with feedback. Arguments for which the associated neuron is activated at the stable state are said to prevail.

Consider the neural network of Fig. 2(b), which implements the argumentation network of Fig. 2(a). Arguments A, B and C are encoded in the network's input and output layers. In this example, arguments do not get together to attack another argument so that each input neuron is connected directly to a hidden neuron and the weights from the input to the hidden layer simply serve to send the input information forward. Support and attack information is encoded by the weights leading from the hidden to the output layer of the network. Support for A is encoded by the positive weight going from neuron
to output neuron A. Similarly, support for B (resp. C) is encoded by the weight going from
(resp.
) to B (resp. C). A's attack on B is represented by the dashed arrow going from
to B, which should have negative weight, as specified in the algorithm below. Similarly, B's attack on C is represented by the dashed arrow going from
to C, with a negative weight.

Download : Download full-size image
Fig. 2. (a) Illustration of an argumentation network in which argument A attacks argument B, which in turn attacks argument C, and (b) its neural implementation, where solid lines receive positive weights and dashed lines, which represent the attacks, receive negative weights.

If the absolute value of the weight going from
to B (call it
) is larger than the value of the weight from
to B (call it
) then A defeats B. This produces {
} as prevailing arguments and is identical to the usual (non-value based) interpretation of argumentation frameworks [12]. The prevailing arguments are computed by the network as follows: suppose that A, B and C are all present at time
, denoted by input vector [
]. Hidden neurons
,
and
all become activated;
activates A, and blocks the activation of B from
(because
). At the same time, C is blocked by
(by default, we assume that attacks are stronger than support, i.e. the weight from
to C is greater in absolute value than the weight from
to C, unless stated otherwise). Thus, at time
, only output neuron A is activated (i.e. only the output of neuron A is greater than
). This is then represented as a new input vector [
] at time
. Given this new input, A continues to prevail, B is defeated as before, but C is reinstated because B now fails to defeat it, since B is not present in the input anymore. Thus, at time
, output neurons A and C become activated. At time
, a new input [
] is produced. Finally, with [
] given as input, output neurons A and C become activated again, producing a stable state in the network. Recall that network outputs are real values in the range (
). To compute a stable state, each output value in the range (
) is mapped to 1, output values in the range (
) are mapped to −1, and values in the range [
] are mapped to 0. After this is done, the network's new input vector can be compared with its previous input. In this example, the input vector at time
will be identical to the input vector at time
, that is [
] is a stable state. The network's stable activations indicate the prevailing arguments {
}. This result also coincides with the standard ADF interpretation of support (Definition 3). In the case of VAF (Definition 2), if B is preferred over A, all that needs changing in the network is the value of
or
so that
, denoting that the attack from A on B should not be strong sufficiently to defeat B [10]. In this case, input [
] produces new input [
], which is a stable state, given the neural network's new set of weights. This new network, therefore, computes prevailing arguments {
}, as expected in the case of the VAF under consideration.

As another example, consider the network of Fig. 3(b). Here, a cycle exists in the argumentation network. This may create an infinite loop in the computation of the stable state of the associated neural network; e.g. if the network were to be started on input vector [
], it would oscillate between that state and state [
] indefinitely, with the arguments all being attacked in parallel and defeated in a single pass through the network, and then reinstated in the next pass through the network. In order to handle this as intended by the usual argumentation semantics, whenever the neural network reaches a state [
], the computation stops. In this case, the neural network computes the grounded extension of the argumentation network, as discussed in more detail later. Summarising, our policy is that the network computation stops when either a stable state is obtained or when [
] is reached. We call [
] a terminal state. Notice that by following a value-based approach, and changing the weights according to some preference relation, one might eliminate the loop [10]. For example, if as before, B is preferred over A then the attack from A on B will not be successful, with input [
] producing stable state [
]. When the weights are different, the neural network is less likely to enter into an infinite loop (see [10] for a discussion on how weight learning given new information following a value-based approach can be useful at resolving loops).

Download : Download full-size image
Fig. 3. (a) An example of a cyclic argumentation network and (b) its neural implementation whose parallel computation produces, in a single pass through the network, a terminal state [−1,−1,−1] with no prevailing argument, following a grounded argumentation semantics.

The algorithm below generalises the algorithm first introduced in [10], which was made for VAF only. It translates argumentation frameworks into single-hidden layer neural networks that behave as exemplified, and can be used to compute prevailing arguments in parallel. It does so by defining the structure and set of weights of a neural network as a function of
, using activation function
and inputs in {
}. Each argument has a strength given by positive weight
. Certain arguments may attack other arguments with negative weight
, and certain arguments may support other arguments with positive weight
. The weights are such that activations in the interval [
] are guaranteed not to occur for now (we shall consider uncertainty in the next section). The neural network produces outputs in the intervals (
), which is mapped to false and denotes that an argument is defeated, and (
), which is mapped to true, denoting that an argument prevails.

By default, Algorithm 1 implements Dung's argumentation frameworks. If an argument
attacks an argument
, and
is itself not attacked, then neuron
should block neuron
. However, if
is deemed weaker than
, and no other argument attacks
, then neuron
should not block neuron
. To achieve this, and account for a number of other, alternative semantics and modes of argumentation in a neural network [16], the constraints on
and
can be modified, as will become clearer in Section 4. Also, in Algorithm 1, a single supporting argument is deemed sufficient to defeat any attack; the other alternatives, leading to different constraints on
and
, will be considered in Section 4. A novelty of the algorithm is that arguments may have strengths
, which may vary from one attack to another. Before we consider the extensions of Algorithm 1, however, let us make the ideas developed so far more precise.

Download : Download full-size image
Algorithm 1. General neural argumentation algorithm.

Definition 5

Let
. Let
denote the activation of neuron α at time t. We say that a neural network
computes an argumentation framework
if whenever
and
then
, and whenever
for every
such that
then
(reinstatement).

Proposition 6

For each argumentation framework
there exists a single-hidden layer neural network
such that
computes
.

Proof

First, we show that if
in the input layer of
then
in the output layer of
whenever there are no attacks on
. In the worst case, the input potential of hidden neuron
is
, and the output of
is
. We want
. Again in the worst case, the input potential of output neuron
will be
, and we need
. As a result,
needs to be satisfied. When there is an attack on
, the activation of output neuron
needs to be smaller than
if hidden neuron
is active. In the worst case,
has activation
,
has activation 1, and any other attacking neuron has activation −1. Hence,
has to be satisfied, where n is the number of attacks. Dually, when there are no attacks on
, the following inequality has to be satisfied:
, which gives
and the constraint on
, as shown in Algorithm 1, step 4. When at least one argument
supports argument
, the following inequality has to be satisfied (again, in the worst case analysis):
. Dually, in the worst case,
has to be satisfied, which gives
and the constraint on
, as shown in Algorithm 1, step 5. This completes the proof. □しろいしかく

Proposition 7

For each ADF
there exists a single-hidden layer neural network
such that
computes
.

Proof

The standard ADF interpretation is that
when
attacks
. This interpretation has been covered in the proof of Proposition 6. In weighted ADFs, however, one can distinguish different combinations of attack and support [5], in particular, a supporting link can be stronger than an attacking link so that the attacked argument prevails. Since neural networks with as few as a single hidden layer are universal approximators, it follows that in the neural argumentation approach, any Boolean combination of attacks and support can be computed. In the specific case of support, we need to show that if
supports
then if
then
. As before, we associate inputs in the interval
to in and inputs in the interval
to out. In the worst case, we need
. Thus,
, as guaranteed by the algorithm. This completes the proof. Notice that, in practice, we convert inputs in the interval
to 1, and inputs in the interval
to −1, which relaxes further the above constraint on
. □しろいしかく

We can also show that the neural-network approach is very general by proving that it computes the many different argumentation semantics, as defined earlier [6], [12]. Before that is done, however, we should note that an argument that is not attacked by any other argument cannot be reinstated in the neural network (an argument that is attacked but not defeated will be reinstated as usual). For example, argument E in Fig. 1 will be in if its input value is 1, and will be out if its input value is −1. It will continue to be out over time if it is out initially, and will be in otherwise. Argument B, on the other hand, will be reinstated whenever argument A is not present, and vice-versa.

Lemma 8

For each argumentation framework
there exists a single-hidden-layer recurrent neural network
such that the complete extensions of
are stable states of
.

Proof

Recall that a set of arguments Args is said to be a complete extension of
iff
. From Proposition 6, one pass through
computes
. Recurrently connected,
iterates
until a stable state is reached, which is a fixed point of F, that is
. □しろいしかく

Corollary 9

For each argumentation framework
there exists a recurrent neural network
such that the grounded, preferred, stable and semi-stable extensions of
are stable states of
.

As an example, consider again the argumentation framework of Fig. 1. Starting from
, without a terminal state, the associated neural network can converge to the following stable states: {B, C, E, F} and {A, E, F}, corresponding to its preferred extensions. With a terminal state, the network will converge to either {E, F}, {B, C, E, F} or {A, E, F}, corresponding to its complete extensions.

Finally, consider the argumentation network of Fig. 4, for which no stable state exists. With the use of a terminal state, the corresponding neural network will implement a semi-stable semantics, providing the empty set as the only extension. Without a terminal state, the neural network will loop (until it is either halted or its weights are changed), implementing a stable semantics.

Download : Download full-size image
Fig. 4. Semantic circularity for which no stable state exists.

The neural networks of Fig. 2, Fig. 3 should be seen as computational models rather than abstract argumentation frameworks. As discussed, the networks can be used in the parallel computation of prevailing arguments: given input vector [
] at the start, the networks should always converge to a stable state corresponding to a set of prevailing arguments, according to a (value-based, preferred, etc.) argumentation semantics.

Definition 10

We say that neural network
computes an (extension-based semantics of) argumentation framework
if every stable state of
is an extension of
.

Proposition 11

If
computes
and
admits a single extension then starting from input vector
,
always finds a stable state corresponding to the prevailing arguments of
.

Proof

The arguments in
can be viewed as logic programming clauses of the form
. Starting from [
],
will treat each
as a fact unless
is attacked and defeated by another argument
, which corresponds to adding a clause
to the program (where ¬ stands for negation by failure). If
admits a single extension then the corresponding program will have a single model. The stable models of any logic program can be computed by a single-hidden layer neural network; with a single model, the network is known to always settle down in a stable state corresponding to this model, as proved in [9]. Such a result can be applied directly here to complete the proof. □しろいしかく

As exemplified earlier, it should be possible to extend Proposition 11 to certain very general classes of argumentation networks that admit multiple extensions. Due to the numerical nature of the networks, they are unlikely to oscillate unless integer weights with the same absolute values are used. For example, we have seen that, starting from [
], the network of Fig. 3 converges to a terminal state. Otherwise, it loops. As argued in [10], a network that loops should be seen as an opportunity for learning, whereby what-if questions can be considered and the network's weights can be changed slightly. Similarly, when a network reaches a terminal state, this should trigger a search for new evidence about the relative strength of the arguments. For example, consider the case where arguments A and B attack each other in a cycle. The corresponding neural network has two stable states, namely [
] and [
], corresponding to the two stable extensions of the argumentation network. Starting from [
], the neural network produces output [
], which is a terminal state. At this point, the computation stops. However, a loop exists in the network computation, since input [
] would produce output [
]. A terminal state does not provide much information by itself (a terminal state could be seen as producing maximum uncertainty). However, if the reaching of a terminal state is seen as a trigger for a search for more evidence, perhaps this search could shed new light on the relative strengths of arguments A and B, defining a preference for either argument by changing the weights of the network. If a neural network is such that the weights do not have the same absolute values then it is unlikely that arguments will cancel each other, as seen above, so that the network loops. Breaking such a symmetry in the set of weights by changing their values slightly is the norm of network learning, and could be seen as an alternative to the use of terminal states and a solution to the problem of having loops in the computation of such neural networks [10].

4. Neural cognitive nonclassical argumentation
   It is natural for a neural network to combine the weights representing multiple support or multiple attacks in order to compute the activation state of a neuron/argument. This is interesting in relation to the question of the accrual of arguments [38]. So far, our standard interpretation has been that any attack suffices to defeat an argument, unless a value-based function says otherwise. Another interpretation, however, is that arguments may get together to attack an argument (that is, only the conjunction of the arguments enables the attack; this is called a joint-attack [1]). Fig. 5(a) shows two arguments A and C attacking argument B. When either
   or
   for the standard interpretation, the attacks can be implemented by Algorithm 1 above. However, when arguments are allowed to accrue and either
   or
   , a decision has to be made as to whether or not A and C together can defeat B [10]. The same is true for support. Fig. 5(b) shows an argument A supporting argument B as done in ADFs. It may be that without A's support, B would be defeated, say, by an attack from another argument C, but B is not defeated with A's support. Finally, Fig. 5(c) shows a situation where, only if A and B prevail, can they attack C. Hidden neuron
   implements, in the usual way, a logical-AND. This is the situation where arguments A and B "get together" to attack C.

Download : Download full-size image
Fig. 5. Alternative modes of attack and support: (a) multiple attacks, (b) support, and (c) joint-attacks.

Let us consider Fig. 5(a) in more detail. Let
denote the weight from hidden neuron
to output neuron B. As said, the natural computation of a neural network will combine the weights into the input potential of B. Suppose that
and
. In this situation, neither A nor C defeat B, but, together, A and C may defeat B as an unintended consequence of the combination of the weights. To avoid this problem, we use the following convention: when arguments create a joint attack on another argument, the set-up of Fig. 5(c) is used. If n arguments are joined through hidden neuron
, then the bias
of
should satisfy the following inequality, which implements the intended logical-AND.

Let us now consider in more detail the situation where an argument receives multiple support (Fig. 5(b)). This situation is similar to that considered earlier, that is, whether some attack is strong enough to defeat all of the support received by B or whether the support for A overrides the attack, making it unsuccessful. The first case is straightforward and can be implemented by making:
where k is the number of supporting arguments, each with weight
.

The second case, in a more general set-up, takes a linearly ordered set
such that argument
prevails if it is not attacked, but
is defeated when attacked by
. However,
prevails again if it is supported by another argument
, but is defeated again if attacked by
, and so on. We need to assign values to weights
, as follows:
where
and ε is a small positive number such that
(typically
).

A further possibility would be to allow certain combinations of support to prevail and certain others to be defeated. This is, in fact, a likely outcome if a learning algorithm is to be applied, with the network's weights changing as a result of learning from data. Any combination of attack and support can be encoded in a neural network, as follows. The linear ordering above can be extended to multisets in the usual way, so that each
,
, denotes a set of arguments. The value of
will then correspond to the sum of the weights either attacking or supporting
, each weight being equal to
, where k is the cardinality of the set of arguments in question. Since we would like the combination of k arguments, and not of
or fewer arguments, to have the above effect, the following inequality should be satisfied:

The dual of the conjunctive attacks exemplified above are the disjunctive attacks shown in Fig. 6(a). In the figure, the activation of hidden neuron ∨ should attack either argument B or C according to some probability distribution. We say that neuron ∨ behaves stochastically. Having a standard hidden neuron in Fig. 6(a) would denote that A attacks both B and C. With a stochastic hidden neuron, either B or C is attacked with a probability. This offers a way of implementing the idea of a disjunctive attack, i.e. one that attacks either argument, but it does not matter which argument. If, for example, the probability of attacking argument B should be 50%, a random number is generated in the interval
and, if this number is greater than 0.5 then argument B is attacked; otherwise, argument C is attacked.

Download : Download full-size image
Fig. 6. Disjunctive attacks (a), self-defeating attacks (b), and attacks on attacks (c).

Let
denote the arguments (neurons) attacked stochastically through hidden neuron
. From the point of view of the network computation, for each
, we select a neuron
,
, at a time (at each round, a single
is chosen to receive activation from
). A stable state denoting a set
of potential prevailing arguments is then obtained in the usual way (with the same
being selected if the network recurs through
). We take
as our final set of prevailing arguments (i.e. following a skeptical semantics).

In addition to disjunctive attacks, the recent literature on argumentation has discussed extensively the modelling of self-defeating arguments as well as the concept of meta-argumentation [15], [25], [26]. Fig. 6(b) exemplifies the implementation of a self-defeating argument in a neural network. In the figure, argument A attacks argument B, but A is self-defeating, that is, the weight of the connection to output neuron A is negative. Hence, B prevails, as expected. Fig. 6(c) exemplifies a meta-level attack, i.e. an attack not on an argument, but on another attack. In Fig. 6(c), argument A does not attack argument B, but it attacks B's attack on C. As a result, C prevails. In this setting, it is possible for B to succeed in attacking another argument, say D, through a different hidden neuron. Notice the similarity between Fig. 6(c) and Fig. 5(c). Not surprisingly, the semantics of meta-level attacks can be characterised in terms of joint-attacks, by adding the meta-level attack itself as a node in the argumentation network [15].

Definition 12

Let
denote an attack from argument a on argument b. Suppose that argument c attacks this attack; we write it as
. A meta-argumentation network is an argumentation network extended with such attacks on attacks.

Lemma 13

(See [15].) Let
be a meta-argumentation network where
.
can be reduced to an argumentation network containing an extra node
such that
and
jointly attack
, and
attacks
.

Proposition 14

For any meta-argumentation network
there exists a neural network
such that
computes
.

Proof

We are concerned with the situation
without recursion. In the reduced network, node i attacks node jk, and nodes jk and j jointly attack node k. In the neural network (with the same structure as in Fig. 6(c)), we have
attacking k (recall that we have defined joint-attacks as conjunctions). If i is in then jk is out and k is in; if i is out then k is out iff j is in. In the neural network, the hidden neuron representing jk will be activated, attacking and defeating k iff
(or out) and
(or in), which clearly produces the same intended outcome. □しろいしかく

5. Case study: Public prosecution charging decision
   In this section, we apply the neural cognitive argumentation framework to the modelling of a public prosecution charging decision, which was part of a real legal case. The modelling of the charging decision includes many of the argumentation aspects addressed by our proposed framework, notably uncertainty, joint-attacks, argument support and ADF-style reasoning. The results show that the neural model can be a useful tool in the analysis of legal decision making, including the analysis of what-if questions, as detailed below.

The following is an extract from a charging decision statement made 29 May 2012 by Alison Levitt, Queen's Counsel, Principal Legal Advisor to the Director of Public Prosecutions in relation to allegations that a police officer passed confidential information to a journalist about Operation Weeting, a police investigation into allegations of phone hacking by newspapers in the United Kingdom.

In what follows, we will represent the main aspects of the arguments discussed in the charging decision statement as a neural cognitive model, and analyse the possible model set-ups and computations, and their alternative conclusions in relation to the actual outcomes of this legal case study. We are interested in exemplifying the use of the proposed model in practice, and analysing its usefulness as a tool for modelling the different aspects of argumentation, including the analysis of what-if questions, as detailed below.

"On 2 April 2012 the Crown Prosecution Service received a file of evidence from the Metropolitan Police Service requesting charging advice in relation to two suspects. The first is a serving Metropolitan Police Officer in the Operation Weeting team whose name is not in the public domain. He is currently suspended. The second suspect is Amelia Hill, a journalist who writes for The Guardian newspaper.

The allegation is that the police officer passed confidential information about phone hacking cases to the journalist.

All the evidence has now carefully been considered and I have decided that neither the police officer nor the journalist should face a prosecution. The following paragraphs explain the reasons for my decision.

The suspects have been considered separately, as different considerations arise in relation to each of them.

Between 4 April 2011 and 18 August 2011, Ms. Hill wrote ten articles which were published in The Guardian. I am satisfied that there is sufficient evidence to establish that these articles contained confidential information derived from Operation Weeting, including the names of those who had been arrested. I am also satisfied that there is sufficient evidence to establish that the police officer disclosed that information to Ms Hill.

I have concluded that there is insufficient evidence against either suspect to provide a realistic prospect of conviction for the common law offence of misconduct in a public office or conspiracy to commit misconduct in a public office.

In this case, there is no evidence that the police officer was paid any money for the information he provided.

Moreover, the information disclosed by the police officer, although confidential, was not highly sensitive. It did not expose anyone to a risk of injury or death. It did not compromise the investigation. And the information in question would probably have made it into the public domain by some other means, albeit at some later stage.

In those circumstances, I have concluded that there is no realistic prospect of a conviction in the police officer's case because his alleged conduct is not capable of reaching the high threshold necessary to make out the criminal offence of misconduct in public office. It follows that there is equally no realistic prospect of a conviction against Ms. Hill for aiding and abetting the police officer's conduct.

However, the information disclosed was personal data within the meaning of the Data Protection Act 1998 and I am satisfied that there is arguably sufficient evidence to charge both the police officer and Ms. Hill with offences under section 55 of that Act, even when the available defences are taken into account.

I have therefore gone on to consider whether a prosecution is required in the public interest. There are finely balanced arguments tending both in favour of and against prosecution.

Journalists and those who interact with them have no special status under the law and thus the public interest factors have to be considered on a case by case basis in the same way as any other. However, in cases affecting the media, the DPP's Interim Guidelines require prosecutors to consider whether the public interest served by the conduct in question outweighs the overall criminality alleged.

So far as Ms Hill is concerned, the public interest served by her alleged conduct was that she was working with other journalists on a series of articles which, taken together, were capable of disclosing the commission of criminal offences, were intended to hold others to account, including the Metropolitan Police Service and the Crown Prosecution Service, and were capable of raising and contributing to an important matter of public debate, namely the nature and extent of the influence of the media. The alleged overall criminality is the breach of the Data Protection Act, but, as already noted, any damage caused by Ms. Hill's alleged disclosure was minimal. In the circumstances, I have decided that in her case, the public interest outweighs the overall criminality alleged.

Different considerations apply to the police officer. As a serving police officer, any claim that there is a public interest in his alleged conduct carries considerably less weight than that of Ms Hill. However, there are other important factors tending against prosecution, including as already noted, the fact that no payment was sought or received, and that the disclosure did not compromise the investigation. Moreover, disclosing the identity of those who are arrested is not, of itself, a criminal offence. It is only unlawful in this case because the disclosure also breached the Data Protection Act.

In the circumstances, I have decided that a criminal prosecution is not needed against either Ms. Hill or the police officer.

However, in light of my conclusion that there is sufficient evidence to provide a realistic prospect of convicting the police officer for an offence under the Data Protection Act, I have written to the Metropolitan Police Service and to the IPCC recommending that they consider bringing disciplinary proceedings against him." Alison Levitt QC

Let us start by considering the arguments for and against prosecuting the journalist (pj) and the police officer (pp).

Arguments for prosecution:
A:
The articles contained confidential information;

B:
The police officer disclosed the information;

C:
A prosecution is required in the public interest.

Arguments against prosecution:
D:
There is no evidence that the police officer was paid any money;

E:
Information disclosed by the police officer, although confidential, was not highly sensitive;

F:
It did not expose anyone to a risk of injury or death;

G:
It did not compromise the investigation;

H:
It would probably have made it into the public domain by some other means;

I:
The public interest outweighs the overall criminality alleged;

J:
Together, the articles would expose the commission of criminal offences;

K:
Together, the articles would hold others to account;

L:
The articles contributed to an important matter of public debate, namely the nature and extent of the influence of the media.

Let us also analyse more closely the arguments relating to whether a prosecution is required in the public interest. The assumption is that both the journalist and the police officer have violated the Data Protection Act.

Arguments for bringing charges under the Data Protection Act:
M:
The information disclosed was personal data;

Arguments against bringing charges under the Data Protection Act:
N:
Disclosing the identity of those who are arrested is not, of itself, a criminal offence;

O:
It is only unlawful in this case because the disclosure also breached the Data Protection Act.

Remark 15

Notice how argument O was used rhetorically as part of an argument against bringing charges under the Data Protection Act. Argument O is, in fact, simply stating that the disclosure was unlawful because it breached the Data Protection Act. Consider also how the sentence below is used as part of the argumentation: "The alleged overall criminality is the breach of the Data Protection Act, but, as already noted, any damage caused by Ms. Hill's alleged disclosure was minimal". Our model will help quantify such damage and will require a definition of minimal, as will become clear. Similarly, the following sentences provide clues as to the weights to be assigned to the neural network, in relation to the police officer: "Any claim that there is a public interest in his alleged conduct carries considerably less weight" and "There is a high threshold to make out the criminal offence of misconduct in public office". We shall return to these once we have created the network model.

The QC's conclusion can be summarized as follows:
(a)
It was decided that a criminal prosecution is not needed;

(b)
It was decided that in the case of the journalist, the public interest outweighs the overall criminality alleged;

(c)
There is sufficient evidence to provide a realistic prospect of convicting the police officer for an offence under the Data Protection Act;

(d)
A recommendation was made to the police to consider bringing disciplinary proceedings against the police officer.

Our model's conclusion: Our model is concerned with making explicit the following relations (items 1 to 4 below).

On the issue of the police officer's misconduct:

1. Do the weights of the arguments exceed the high threshold for the offence of misconduct?

Arguments A, B and C should support the prosecution of the police officer (pp). Argument C should do so with a low weight (w) since the prosecution would be for misconduct in public office. Arguments D, F, G and H attack pp collectively (argument D with a high weight (W) for obvious reasons, and argument H with a low weight due to its speculative nature). Argument E attacks argument B. These are all the relevant arguments in relation to pp, as shown in Fig. 7, where dashed lines indicate attacks. As a result, neuron B fails to activate, and the weight of the arguments that collectively attack neuron pp should overcome the weight of the arguments that support pp. Hence, neuron pp should fail to activate. We discuss neuron/argument pj next.

Download : Download full-size image
Fig. 7. Neural implementation of legal case: prosecution decision.

2. If the police officer should not be prosecuted for misconduct then the journalist should not be prosecuted for aiding his conduct.

Item 2 above can be modelled in Fig. 7 using ADFs simply by stating that if argument pp is out (represented by a negative weight from input neuron pp to the hidden layer) then argument ¬pj should be in; hence, the journalist should not be prosecuted (in the neural network, if input neuron pp is not activated then output neuron ¬pj will be activated; see dashed line representing a negative weight from input neuron pp in Fig. 7). This separation between arguments pj and ¬pj allows one to ignore how arguments would influence neuron pj during the modelling of neuron ¬pj, and is referred to explicit negation in logic programming [19]. Thus, in case neuron pp fails to activate, which is the case here, neuron ¬pj will be activated. This completes the prosecution's analysis on the basis on misconduct.

On the issue of the violation of the Data Protection Act:

3. Do the weights of the arguments show that the public interest outweighs the violation of the Data Protection Act?

It is clear that arguments J, K and L support argument I, while argument M attacks I. In addition, argument N attacks M, and O attacks N, as shown in Fig. 8. The conclusion is that indeed argument I should prevail.

Download : Download full-size image
Fig. 8. Neural implementation of legal case: decision based on data protection act.

4. Different weights apply to the journalist and the police officer.

Argument M supports the argument that the journalist should be prosecuted for violation of the Data Protection Act (let us call this
). It also supports the argument for prosecuting the police officer for a violation of the Data Protection Act (call it
). The attacks from argument I on
and
should have different weights: a high (negative) weight W for
and a low (negative) weight (w) for
. Our model's conclusion, therefore, is that
should not prevail (i.e. the journalist should not be prosecuted), but differently from the QC's conclusion, if the value of the weight ω connecting argument M to
should be greater than the absolute value of w then argument
should prevail, i.e. the police officer would be prosecuted for violating the Data Protection Act. The actual values of weights ω and w may be a matter for debate, but perhaps the QC's arguments should have focused more on providing a justification for such values.

The above modelling exercise with the use of a neural cognitive model, may also help in the separation of concerns and systematic questioning of some of the assumptions made. For example, in this case study, some questions that emerge include: should different weights really apply to the journalist and the police officer, assuming they had to work as a team in the public interest? Aside from possible issues of remit, why should prosecution not be recommended straight away for the violation of the data protection act, and disciplinary proceedings should be evoked and recommended instead? We believe that our model should help prompt the user to ask such questions, organise the relationships among the different arguments under consideration, and investigate the impact of different weight assignments to the network model. For example, what if the weights W and w are assigned the same value? What if the weights ω and w are assigned the same absolute value? The user would then be able to run the model and consider the possible outcomes by analysing the different sets of prevailing arguments obtained as stable states of the neural network.

6. Conclusion and future work
   We have presented a neural cognitive model of argumentation that is capable of capturing a range of argumentation semantics and situations including joint-attacks, argument support, ordered attacks, disjunctive attacks, meta-level attacks and self-defeating attacks. All these different modes of argumentation can be modelled, learned and computed by means of a connectionist representation. In its most general form, arguments are weighted according to their strength, can support or attack other arguments directly, but can also combine conjunctively or disjunctively, sequentially or in parallel, at object- or meta-level, as exemplified throughout the paper. We have shown that all these different modes of argumentation can be represented and computed in a natural way by a connectionist network. This also indicates that the connectionist approach can offer an adequate tool for argument computation.

When dealing with uncertainty and meta-level preferences, in [14], the question of where the weights would come from is raised. In [2], voting by an audience is evoked as a solution that depends on meta-level considerations, as in [26]. With the framework proposed in this paper, the question gains a new dimension in that, as with any neural network, the weights can be learned from examples (i.e. instances from previous cases). As future work, we plan to explore the framework's learning capacity as part of a larger case study.

Uncertainty is intrinsic in human argumentation, yet most logic-based models of argumentation do not deal with uncertainty explicitly. Argumentation can be seen as a method for reducing one's uncertainty with the prevailing arguments being precisely those that are less-uncertain. In line with [21], [23], [35], the neural cognitive model introduced here lends itself well to this idea due to the use of weights and activation intervals as part of a neural network. However, we believe that the neural cognitive approach may also be advantageous from a purely computational perspective due to the networks' ability to adapt through learning and to compute prevailing arguments in parallel. All of the above is important given the objective of developing models of human argumentation. Future work includes, in addition to the evaluation of the framework's learning capacities, further experimentation on legal reasoning, a comparison of the framework's knowledge representation and learning capacity, e.g. in contrast with [23], [32], and the evaluation of the framework's parallel computation gains. A graphical interface is being developed to facilitate the interactive drawing and running of the networks as shown in the figures above, with all the features introduced here. We believe that such an interface can be useful as a tool for modelling, running and the elaboration of argumentation frameworks in a range of application areas.