Knowl Inf Syst

DOI 10.1007/s10115-010-0371-3

REGULAR PAPER

Argument mining based on a structured database

and its usage in an intelligent tutoring environment

Safia Abbas · Hajime Sawamura

Received: 6 April 2009 / Revised: 23 September 2010 / Accepted: 29 November 2010

© Springer-Verlag London Limited 2011

Abstract Argumentation theory is a new research area that concerns mainly with reaching
a mutually acceptable conclusion using logical reasoning. Argumentation can be defined as
a proof of dynamic nature and is considered as an ill-defined domain that typically lacks
clear distinctions between “right” and “wrong” answers. Instead, there are often competing
reasonable answers. Recently, a number of argument mapping tools have been developed to
diagram, articulate, and comprehend different arguments. Despite the fact, these methods are
of complementary nature, and the efforts for integrating these tools are missing. The purpose
of this paper is threefold: (1) revealing a novel approach for argument representation using a
structured relational argument database “RADB”, which has been designed, developed, and
implemented in order to represent different argument analyses and diagrams, (2) presenting
a classifier agent that utilizes the RADB repository by using different mining techniques
in order to retrieve the most relevant arguments to the subject of search, and (3) proposing
an agent-based educational environment (ALES) that utilizes the RABD together with the
classifier agent to teach argument analysis.

Keywords Argumentation · Structure databases · Mining techniques ·

Intelligent tutoring environment

1 Introduction

Argumentation theory, or argumentation, embraces the arts and sciences of civil debate, dia-
log, conversation, and persuasion. It studies rules of inference, logic, and procedural rules in

S. Abbas (B)
Faculty of Computer and Information Sciences, Ain Shams University, Abbasia, Cairo, Egypt
e-mail: safia_abbas@[Link]

H. Sawamura
Institute of Natural Science and Technology, Niigata University,
8050, 2-cho, Ikarashi, Niigata 950-2181, Japan
e-mail: sawamura@[Link]

123
 S. Abbas, H. Sawamura

both artificial and real world settings. Argumentation is concerned primarily with reaching
conclusions through logical reasoning, that is, claims based on premises. We argue all the
time in our daily life through scientific communities, parliaments, courts, and online discus-
sion boards. That is, we would say “living is arguing in the age of globalization just as living
is eating in the days of plenty”. Humans’ knowledge and wisdom produced there usually
have the form of arguments that are built up from more primitive knowledge of the form of
facts and rules. Those repositories or treasuries of knowledge are now about to be organized,
by different tries, to argument data bases or corpora that can be retrieved, stored, and reused
online freely.
One of these attempts is the argument mapping tools (e.g., Compendium1 , Araucaria2 ,
Rationale3 , Carneades4 , etc.) that aims at improving our ability to articulate, comprehend,
and communicate reasoning. This can be achieved by supporting the production of diagrams
of reasoning and argumentation for especially complex arguments and debates. It is greatly
anticipated that it helps end users learn critical thinking methods as well as promoting critical
thinking in daily life [26,29]. Although much work has been done in this area, there are still
some concerns about formal computational argumentation frameworks [12,13]; formalizing
methods in which the internal statuses of arguments have to be decided semantically and/or
dialectically [14]. These concerns can briefly be summarized into the following three general
points: (1) Both areas for argumentation-conscious works lack means of arguments’ search
for an argument to be retrieved, classified, or summarized. Put it differently, such an idea of
an argument to be retrieved, summarized, or classified in order to gain useful information
that can be used from a large argument database is missing. (2) The existing frameworks
miss the interoperability among each other, such that instead of producing an appropriate
common file types that enable the user to access the same argument using different tools,
special types of files are generated such as AML files that are primarily committed to be used
by Araucaria DB only. (3) The context analysis, presented in the existing frameworks, does
not follow empirical regularities where anyone can analyze any document depending on his
own thoughts and beliefs not on a dedicated structure for different argument schemes.
In this paper, in order to overcome the mentioned obstacles, we present a novel approach
that sustains argument analysis, retrieval, and re-usage from a relational argument database
(RADB). The database is considered as a highly structured argument repository managed
by a classifier agent. This agent makes use of different mining techniques that are gathered
and used to: (1) summon and provide a myriad of arguments at the user’s fingertips and
(2) reveal more relevant results to user’s queries. The paper mainly concerns mining argu-
ments through an RADB that (1) summarizes the argument dataset, (2) supports the fast
interaction between the different mining techniques and the pre-existing arguments, and (3)
facilitates the interoperability among various agents/tools/humans. Finally, an agent-based
learning environment outline is illustrated, where the mining classifier agent and the RADB
are integrated to an intelligent tutoring system (ITS). Such integration should assist in (1)
deepening the understanding of argumentation, decision-making, and critical thinking, (2)
guiding the analysis process to refine the user’s underlying classification, and improving the
analysis and the student’s intellectual process.
The paper is organized as follows. Section 2 provides a background on the AIF ontology
[8] and the different theories of argumentation. Section 3 presents the needs and the aims of
1 [Link]
2 [Link]
3 [Link]
4 [Link]

123
Argument mining based on a structured database

the structured/relational argument database construction. The design and the implementation
of the RADB building blocks are described in Sect. 4. Section 5 illustrates the RADB acces-
sibility features by using examples for argument querying and manipulation. Section 6 states
different mining techniques and strategies in a certain classifier agent, which mines the
RADB repository, as a managing tool, to verify some goals. Section 7 outlines the usage of
the RADB together with the classifier agent in an agent-based learning environment named
“ALES”. In Sect. 8, we compare our work with the most relevant work performed in the
field, particularly from the motivational point of view. Finally, conclusions and future work
are presented in Sect. 9.

2 Background: AIF ontology and Walton theory of argumentation

Argumentation theory has provided several sets of forms such as deductive, inductive, and
presumptive patterns of reasoning [18]. The earliest accounts of argument schemes were
advanced and developed in several researches by different authors [18]. Each scheme set
unanimously presupposes a particular theory of argument, which in turn, implies a particular
perspective regarding the relation between logic and pragmatic aspects of argumentation,
and notions of plausibility and defeasibility. However, the most influential theories in argu-
mentation are those of Toulmin and Walton [27,31,32]. The latter, which is our main interest
in this paper, represents a new form of reasoning that depends on a fallacious argument,
where each argument is considered as a set of premises presented as reasons to accept or
reject the conclusion. It could be reformulated based on the AIF ontology [8] and be used
thereafter in a different context analysis. Next subsections illustrate the foundations of both
the AIF ontology and Walton theory of argumentation, then the reformulation of Walton
scheme based on the AIF ontology is clarified.

2.1 The argumentation interchange format ontology “AIF”

AIF is a core ontology which reveals a way that can be extended to capture a variety of
argumentation formalisms and schemes [8,25]. It assumes that every argument can be rep-
resented semantically in the form of nodes N connected together by binary directed edges
in a directed graph known as argument network [8]. The directed edges are denoted by the
edge edge edge
predicate −−−→: N × N such that n 1 −−−→ n 2 or (n 1 , n 2 ) ∈−−−→. The nodes can be classi-
fied as information nodes (I-nodes) that hold pieces of information or data, and scheme nodes
(S-nodes) that represent the applications of schemes. In other words, I-nodes contain the con-
tent as the declarative aspects of the domain of discourse such as claims, data, evidence, and
propositions. On the other hand, S-nodes are applications of schemes that can be considered
as patterns of reasoning or deductive patterns associated with argumentative statements. The
ontology deals with three different types of scheme nodes, namely rule of inference appli-
cation nodes (RA-nodes), preference application nodes (PA-nodes), and conflict application
nodes (CA-nodes) [8,25].
At any argumentation network, the node A supports the node B if and only if there is an
edge from A to B. There are two types of edges denoted as the scheme edge and the data
edge. The Scheme edge emanates from S-node to support the conclusion that can be either
an I-node or another S-node, whereas the data edge emanates from an I-node and necessarily
supports an S-node to supply data or information to the scheme application. Semantics of
support for node-to-node relation are shown below in Fig. 1.

123
 S. Abbas, H. Sawamura

Fig. 1 Different semantics of support for node-to-node relation in argumentation network

Fig. 2 Simple argument

representation

Definition 1 (Argument Network) An argument network  is a graph consisting of:

– a set ℵ of nodes where ℵ = ℵ I ∪ ℵ S s.t.
ℵ I : a set of information nodes (I-nodes) and ℵ S : a set of scheme nodes (S-nodes).
edge edge
– a binary relation −−−→: ℵ × ℵ representing edges among nodes such that  ∃(i,j) ∈−−−→
where both i and j ∈ ℵ I .
Any simple argument can be represented by linking a set of premises to a conclusion via a
particular scheme node [8,25].
Definition 2 (Simple Argument) A simple argument in network  is a tuple ≺ P,R,C
where:
– P ⊆ ℵ I is a set of nodes representing premises;
– R ∈ ℵ SR A is a scheme node representing a rule of inference application(RA-node); and
– C ∈ ℵ I is a node representing the conclusion.
Following is an example description of simple argument in propositional logic, depicting
graphically in Fig. 2. We will differentiate between S-node and I-node by drawing the former
in a slightly thick border.
Example 1 (Simple Argument) The tuple A1 =≺ { p, p → q}, MP1 , q is a simple argu-
ment in a propositional form, where p ∈ ℵ I , ( p → q) ∈ ℵ I are nodes describing the
premises, q ∈ ℵ I is a node describing the final conclusion and MP1 ⊆ ℵ SR A is a rule of
inference application node (RA-node).

2.2 Walton theory of argumentation

The Walton theory of argumentation depicts a new aspect in informal logic by using critical
questions to evaluate and analyze arguments dialogs. These critical questions help find the

123
Argument mining based on a structured database

gaps and problems in the argument and evaluate it as weak or strong [28,30]. This kind of
fallacious argumentation reasoning has become the tool of choice in numerous argumenta-
tion studies for evaluating arguments [31,32]. Thus, the theory formalized the most common
kinds of arguments in structures and taxonomies of schemes, where each scheme type has a
name, a conclusion, a set of premises, and a set of critical questions bound to it.
An example of Walton-style schemes is the “Argument From Correlation To Cause” which
infers a connection between two events from a premise describing a positive correlation
between them [11,28,30].

Example 2 (Argument From Correlation To Cause) In the argumentation scheme for this
type of argument, the variables A and B stand for propositions that describe an observed
events. This Scheme has one premise, a conclusion, and seven critical questions.
– Premise: There is a positive correlation between A and B.
– Conclusion: Therefore, A causes B.
Its basic critical questions consist of:
1. Is there a positive correlation between A and B?
2. Are there a significant number of instances of the positive correlation between A and B?
3. Is there good evidence that the causal relationship goes from A to B, and not just from
B to A?
4. Can it be ruled out that the correlation between A and B is accounted for by some third
factor that causes both A and B?
5. If there are intervening variables, can it be shown that the causal relationship between
A and B is indirect?
6. If the correlation fails to hold outside a certain range of causes, then can the limits of
this range be clearly indicated?
7. Can it be shown that the increase or change in B is not solely due to the way B is defined,
the way entities are classified as belonging to the class of Bs, or changing standards,
over time, of the way Bs are defined or classified?
On the one hand, the argument from correlation to cause is a weak argument if it fails to
account for one or more of these critical questions in a given case. On the other hand, this
argument has a small weight of presumption in its favor, which can be increased by further
investigations to give a satisfactory answer to these critical questions.

Another example of Walton-style schemes is the “Argument from Expert Opinion” [11]
that contains a set of premises, a conclusion, and a set of six basic critical questions. The
details of that scheme are shown in Example 3.
Example 3 The scheme “Argument from Expert Opinion” has two premises and a conclusion:
– Premise: Source E is an expert in the subject domain X containing proposition B.
– Premise: E asserts that proposition B in domain X is true.
– Conclusion: B may plausibly be taken to be true.
Its basic critical questions consist of:
1. Expertise Question: How credible is expert E as an expert source?
2. Field Question: Is E an expert in the field that the B is in?
3. Opinion Question: Does E’s assertions imply B?
4. Trustworthiness Question: Is E reliable as source?

123
 S. Abbas, H. Sawamura

Fig. 3 Argument network representation for Walton schemes. CA-node: conflict application nodes. RA-node:
rule of inference application nodes. C/R-node: either CA-node or RA-node

5. Consistency Question: Does B consistent with the assertions of other experts?

6. Backup Evidence Question: Are there any evidences sustain B?
As discussed by Prakken in [11,23], the critical questions in this argumentation scheme are
bipartite questions and are used to raise doubts about premises. The first, second, third, and
sixth questions refer to presumption required for the inference to go through. However, ques-
tions four and five are poles apart, these questions are basically dedicated for exceptions to
the general rule and can be considered as rebuttal knowledge.

2.3 Utilizing Walton schemes based on the AIF ontology

In this subsection, we describe how natural arguments can be analyzed using Walton the-
ory of argumentation based on the AIF ontology. Considering the AIF ontology for argu-
ment representation, if the cyclic problem (the same information node (I-node) refines more
than one scheme node (S-node)) is avoided, each scheme structure in Walton theory can
be semantically represented in the form of a directed tree “argument network”. From that,
any Walton-style scheme can be represented as a general skeleton as seen in Fig. 3, and any
discourse can be reanalyzed based on that formalization.
Next Example 4 shows the argument network of a context from Araucaria5 database that
has been reanalyzed using the above-proposed formulation for the expert opinion scheme
based on the AIF ontology.
Example 4 (Argument_831) “Werner G. Seifert, Chief Executive Officer, Deutsch B rse,
Germany, argued that divergences between stock prices and traditional measures of funda-
mental value such as price-to-earnings or price-to-book are not necessarily a market imper-
fection. The extremes of the Internet bubble, in which some popular stocks traded at prices
that implied unrealistic rates of growth maintained in perpetuity, are examples of what he
called “disproductive disconnects” produced by irrational investor behavior. However, he
cited examples of “productive disconnects” in which stocks have been richly or inexpen-
sively valued for other reasons such as presence or absence of political risk. The correctness
of these judgments can only be seen in hindsight. “Markets must be able to float up and down
to process information.”

5 [Link]

123
Argument mining based on a structured database

Fig. 4 Argument network representation for Argument_831 context. Final decision. Support node

approves the final decision. Conflict node rebuts the final decision

Figure 4 shows the analysis network of the argument_831 context, using Compendium as
graphical representation tool. Looking deeply to this argument network or directed tree, we
can see that:
– each I-node is connected in the analysis network to another I-node through a S-node,
which verify to AIF concepts.
– the I-nodes that fulfill questions two, six, and three of the used expert opinion scheme are
considered as support nodes for the final conclusion of the context. However, the I-node
that fulfills the Trustworthiness Question acts as rebuttal node that attack, contradict, or
weaken the final conclusion and connected to other I-node via a CA-Node that is the
conflict scheme node in the AIF ontology.
– the Backup Evidence question can be considered as a nested node, since it is supported
by more than one evidence(I-Node).

3 Why RADB?

In spite of the different argument repositories, such as Araucaria DB [26,29], that facilitate
the data preprocessing and contain different analyzed contexts, the problem of producing
appropriate common file types has not been solved yet. Instead, special types of files are
generated, such as AML [29] files that are primarily committed to be used by Araucaria only.
In addition, the context analysis, as in discourse DB6 , does not follow empirical regularities
where anyone can analyze any document based on his own thoughts and beliefs, not relying
on a dedicated structure of different argument schemes. Furthermore, the current approaches
that classify/categorize the usual textual data representation/documents tend to either divide
the problem space into subproblems creating a lexicon of useful features, that can help clas-
sify sentences into positive, negative, or neutral categories, or identify patterns as keywords
that indicate viewpoints. Such classification approach exhibits some limitations since it is not

6 [Link]

123
 S. Abbas, H. Sawamura

just the presence of a keyword that matters, but also its context meaning [10,20]. In light of
this fact, the currently used textual data representation that considers any argument as a single
document would be intractable to be processed, mined, or manipulated. As a result, this lim-
its the knowledge extraction abilities that could be beneficial and valuable for different end
users. To overcome the mentioned shortcomings, a relational argument database “RADB”
that consists of common data base file types and uses analysis regularities is presented in this
paper as a solution for argument representation.
The RADB can be defined as a set of information reformulated and categorized into a set
of files (tables) that are general enough to be accessed, gathered (queried), and manipulated
in different manners. Therefore, the resulting “clumps” of this organized data is much easier
to be understood. The RADB enjoys a number of advantages in comparison with traditional
representation. It aims to summarize the high-scale argument dataset, such that all informa-
tion required are encoded in an appropriate form in order to (1) support the fast interaction
between the different mining techniques and the pre-existing arguments, (2) facilitate the
interoperability among various argument tools/agents/humans.
In a more abstract view, according to the AIF ontology [8,25] and Walton theory of argu-
mentation discussed in Sect. 2, any argument can semantically be represented in the form of
a directed tree [see Fig. 4] that can be structured as a well-established relational argument
database “RADB”. Not only Walton theory of argumentation is regarded to be an abstract
propositional form, but also a pattern instantiated in real dialogs. This property allows the
possibility of the relational database conversion. In addition, it provides a space to create a
new argumentation scheme; an important feature that will be explained later in Sect. 5.2.

4 The RADB main building blocks

This section describes the main structure of our repository the “RADB”, which in turn sum-
mons a number of arguments that were selected from the Araucaria database. The RADB
design and structure take into account that: (1) Araucaria DB contains general contexts that
do not belong to a specific domain, so the RADB structure is general enough to encapsulate
multiple domains, (2) the chosen contexts’ analyses do not follow any empirical regulari-
ties, so these arguments’ contexts are re-analyzed based on different schemes structures of
Walton theory of argumentation [11,31,32], preserving the constraints of the AIF ontology
[8] (such that no information node (I-node) refines another I-node), and were visualized using
Compendium as a mapping tool to reflect the analysis trees.
Accordingly, the RADB repository can semantically be represented as a forest of a numer-
ous directed trees [6,9], wherein each directed tree lays out a semantic representation for a
specific argument analysis based on specific scheme. This representation is illustrated in the
following Example 5 and Fig. 5.
Example 5 The following context from the Araucaria repository [26,29,33] was reanalyzed
based on the expert opinion scheme [11,31,32], and its directed tree is shown by means of
Compendium in Fig. 5.

Eight-month-old Kyle Mutch’s tragic death was not an accident and he suffered injuries
consistent with a punch or a kick, a court heard yesterday. The baby, whose stepfather
denies murder, was examined by pathologist Dr. James Grieve shortly after his death.
Dr. Grieve told the High Court at For far the youngest was covered in bruises and
had suffered a crushed intestine as well as severe internal bleeding. When asked by

123
Argument mining based on a structured database

Fig. 5 The analysis diagram of the context in Example 5 based on the expert opinion scheme (this is repre-
sented by the table form of the RADB in Fig. 9)

Advocate Depute Mark Stewart, prosecuting, if the bruises could have been caused by
an accident, he said “No. Not in a child that is not walking, not toddling and has not
been in a motor car.” Dr. Grieve said the injuries had happened “pretty quickly” and
would be “difficult for an infant to cope with”. The lecturer in forensic medicines at
Aberdeen University told the jury that the bruises could have been caused by a single
blow from a blunt instrument, like a closed hand. Death, not accident, court told

The main building blocks of the RADB are as follows: (a) the table of schemes
“Scheme_TBL”, which gathers the names and the indexes for different schemes notations,
(b) the schemes structure table “Scheme_Struct_TBL” that assembles the details of each
scheme stated in “Scheme_TBL”, and (c) the transaction table “Data_TBL”, which contains
the analyses of arguments based on scheme structures and preserves the constraints of the AIF
ontology [8]. The relation between those basic tables is shown in Fig. 6. Furthermore, next
subsections will describe in detail the various building blocks concerned with the “RADB”
through the use of screen shots from our implemented system.

4.1 The Scheme_TBL table

This table gathers different scheme kinds where schemes are formulated in the form of rows
and columns, as seen in Fig. 7. The rows act as records of data for different schemes with the
corresponding features instantiated in the columns. Each feature is either a text or a discrete
attribute. The Scheme_TBL has two features (I D, discrete) and (SC H _N ame, text). The I D
denotes the identification number of the SC H _N ame that stands for a unique scheme name.

123
 S. Abbas, H. Sawamura

Fig. 6 The relation between the basic tables in RADB

Fig. 7 The design and structure

of Scheme_TBL table

This I D plays an important role as a primary key for this table and as a foreign key in the
others (note that any I D attribute/feature mentioned later will stand for the same function).
To illustrate, the context in Example 5 was analyzed based on the ‘Expert Opinion Scheme’.
Therefore, the corresponding data for the (I D, SC H _N ame) features in the Scheme_TBL
table is the record (1,Expert Opinion) as represented in Fig. 7.

4.2 The Scheme_Struct_TBL table

The Scheme_Struct_TBL table contains the details of each scheme stated in the Scheme_
TBL, as shown in Fig. 8. The rows represent records for the different information associ-
ated with the different schemes, and the columns reveal the features of these records. The
features are defined as follows: (I D, discrete) as specified in Sect. 4.1, and (SC H _I d, dis-
crete) that acts as a foreign key of Scheme_T B L indicating the concerned scheme. The
context of the associated information is represented in (Content, text) and (T ype, discrete
∈ {P, C, CQ, CC}), such that P for premises, C for conclusion, CQ for critical question, and
CC for critical argumentation conclusion. For instance, part of the corresponding RADB for-
mulation of the expert opinion scheme, shown in Sect. 2, can be presented by the following
records:
– (I D, SC H _I D, T ype, Content) −→ (1,1, P, Source E is an expert in the subject domain
X containing proposition B).
– (I D, SC H _I D, T ype, Content) −→ (2,1,P, E asserts that proposition B in domain X
is true)
– (I D, SC H _I D, T ype, Content) −→ (3,1,C, B may plausibly be taken to be true).

123
Argument mining based on a structured database

Fig. 8 The design and structure of Scheme_Struct_TBL table

4.3 The Data_TBL table

The Data_TBL table, as seen in Fig. 9, contains all users’ transactions. The table gathers
all the analysis done by the different users for specific argument contexts. It consists of
(I D, discrete) attribute, defined as before, (Str u_I d, discrete) that serves as foreign key of
Scheme_Struct_TBL table referring to a specific part of the scheme details, (Content, text)
attribute contains a portion of the analyzed context that fulfills the referred fixed part of the
scheme details, and (T ype, discrete ∈ {−1, 0, 1}) attribute, which holds three values only,
1 for the supported node, −1 for rebuttal node, and 0 for undetermined value that denotes
neither support nor rebuttal nodes. One of these values would be given to the final conclusion
of the analysis. Since we consider any argument network as a kind of directed rooted trees,
(Child_O f , discrete) attribute points to the parent of each node, whereas the root node
has no parents (0 refers to no parent). (level, discrete) attribute refers to the level of each
node in the tree, such that the value 0 indicates the root node of the argument. Finally, the
(argumentation_no, text) attribute contains the identification name of the analyzed argu-
ment context. For instance, the final conclusion node represented in Fig. 5 can be populated
in the Data_TBL table as seen in Fig. 10.

5 Benefits of the RADB structure

The described design and structure of the various RADB components emphasize a good
foundation to gain valuable knowledge and extract useful information by (1) querying the
different argument component, (2) manipulating (add, update, and delete) both schemes and
arguments analyses in a flexible way, and (3) mining the different analyses transactions using
different mining techniques, which will be described in Sect. 6.

5.1 Some SQL queries examples

The following examples illustrate the flexibility of the design of the RADB as a reposi-
tory of structured arguments. They put forward different ways to query different argument

123
 S. Abbas, H. Sawamura

Fig. 9 The design and structure of Data_TBL table (this is a table for Fig. 5)

Fig. 10 The final conclusion node representation of Fig. 5 in the Data_TBL table

components in order to extract various information, which in turn, could usefully be used by
different end users.

Example 6 Starting with a simple example, if we want to retrieve all the details of the “expert
opinion” scheme, we simply run the following SQL query:

– SELECT * FROM Scheme_Struct_TBL INNER JOIN Scheme_TBL ON Scheme_

Struct_TBL.SC H _I d = Scheme_TBL.I D
WHERE Scheme_TBL.SC H _N ame LIKE ‘Expert Opinion’.

Then, the result is obtained as shown in Fig. 11.

Example 7 If we want to retrieve all the transactions that use the “Backup Evidence Ques-
tion” in their analysis, the following SQL queries are consecutively applied, and the clumps
from these queries are obtained as shown in Fig. 12.

123
Argument mining based on a structured database

Fig. 11 The SQL query result in Example 6

Fig. 12 The SQL queries result in Example 7

1. id = “SELECT ID FROM Scheme_Struct_TBL WHERE Scheme_Struct_TBL.Content

LIKE ‘Backup Evidence Question%’ ”;
2. “SELECT * FROM Data_TBL WHERE Data_TBL.
Stru_ID=id”;

Example 8 Suppose we want to retrieve all the arguments that have the word “war” in
their analyses’ conclusion. First, the schemes’ structures are classified such that all dif-
ferent schemes’ conclusions are gathered in one set “CRS”. Secondly, the arguments’
transactions or analysis are categorized such that each item in the CRS set has a corre-
sponding set of transactions. Finally, the different sets of transactions are summarized such
that the selected items are the groups that contains “war” word in their context. These
steps can be expressed by the following two SQL queries, where the second query meets
both the second and the last steps. The resulted clumps from these queries are shown in
Fig. 13.
– CRS = “SELECT * FROM Scheme_Struct_TBL
WHERE Scheme_Struct_TBL.Type LIKE ‘C’ ”;
– For Each Item I ∈ CRS;
– “SELECT * FROM Data_TBL
WHERE Data_TBL.Stru_ID = [Link]
AND Data_TBL.Content LIKE “‘% war %’ ”;

123
 S. Abbas, H. Sawamura

Fig. 13 The transaction final result

Fig. 14 The adding scheme tab

5.2 Data manipulation

Argumentation can be defined as an intellectual process that depends on one’s thoughts and
beliefs and is affected by the surrounding environment and culture. It is known that cultural
aspects are well reflected in the style of mutual argument analysis, so appropriate schemes
are obligatory to suit the different cultural influences. In response to this, the developed
RADB repository enjoys the extensibility feature that permits adding, deleting, and updating
both the schemes and the arguments analyses. For example, new schemes, such as “Islamic
Inheritance scheme” that divides the inheritance between different heirs based on Islamic
regularities can simply be added using the form shown in Fig. 14. Within the same form,
different parts of the scheme, like premises, conclusion, and critical questions, can sequen-
tially be inserted into the RADB repository using the ODBC connection through the object
oriented (OOP) forms designed via Visual C++. The ODBC allows the free access to the
RADB tables, while the OOP forms act as a visualization tool that facilitates the database
manipulation and the end user interaction with the system. Accordingly, the already existed
schemes, laying in the RADB, can be deleted as well as updated through the forms shown
in Figs. 15 and 16. These manipulations consider the different arguments analyses as well,
where other different OOP forms are used. In other words, an argument analysis can be
added, updated, or even deleted through different forms [see Appendix B].

123
Argument mining based on a structured database

Fig. 15 The deleting scheme tab

Fig. 16 The updating scheme

tab

As example, to add a new scheme, the user should press the “ADD” tab. This will open
the adding new scheme form as seen in Fig. 14. The user can simply enter the name of the
new scheme in the “Scheme Name” text box and presses the “Save” button. In this case, the
“Scheme Name” text will be disabled, and both the “Context” text box along with the “Type”
frame will be enabled to allow the user to add the details of the new scheme. After then, the
user can write the conclusion context in the “Context” text box and selects the type of that
context from the “Type” frame, as seen in Fig. 15. The user is free to press the “Save” button
that will access the RADB through the ODBC connection to add the new scheme name in the
Scheme_ TBL and add the associated “conclusion” to the Scheme_Struct_TBL. Moreover, if
the user needs to update the existing scheme, he can choose the “UPDATE” tab. The form in
Fig. 15 will be displayed with the whole schemes names retrieved from the RADB and listed
in the “Scheme Name” combo box. After then, the user chooses the required scheme name
then presses “Update” button. The “Update” button will relocate the student to the Update
form as seen in Fig. 16 offering the chosen scheme details and giving the user the ability to
update any desired contents or details.

123
 S. Abbas, H. Sawamura

6 Mining analogous arguments

So far, we have described the retrieval methods of argument parts via some SQL statements to
highlight the flexibility of the structured arguments formulation. However, those described
methods retained some elementary tasks that are dedicated to arguments’ parts only. The
underlying RADB repository arguments can be more exploited for more general objectives.
Some of these objectives are to:
– give the end user the freedom to navigate into the existing arguments to search for specific
subjects,
– extricate information by classifying the RADB arguments and retrieving the most rele-
vant arguments to the subject of search,
– discover hidden patterns and correlations between different pre-existing arguments,
– analyze any argument context based on a set of crucial hints that direct the analysis
process.
To accomplish these objectives, different data mining techniques, which vary in functional-
ity, were integrated together with the RADB repository. For example, the AppriorTid tech-
nique [5], the Substructure mining technique, and the Rule Extraction mining technique [see
Sects. 6.1–6.2] are used to classify the pre-existing arguments in order to retrieve the most
relevant arguments and discover hidden correlation between the different argument parts.
Accordingly, a classifier agent that gathers and controls different mining techniques based
on the user’s specification has been developed as will be discussed in the subsections below.
The agent mines the RADB repository aiming to: (1) direct the search process toward hypoth-
eses that are more relevant to users’ queries; classifying the analogous arguments in different
ways based on user’s choice seeking for the most relevant arguments to the user’s subject of
search, (2) add flexibility to the retrieving process by providing different search techniques,
and (3) offer a myriad of arguments at the users’ fingertips.

6.1 AprioriTid mining classification

The AprioriTid algorithm [5,34] has been implemented and embedded into the classifier
agent as “Priority Search” as seen in Fig. 17. The Priority search aims to retrieve the most
relevant arguments to the user’s subject of search and queuing them based on the maximum
support number, such that the first queued argument is the one that has more itemsets [3]
related to the subject of search. Although the AprioriTid algorithm has originally been devised
to discover all significant association rules between the items in large database transactions,
the agent employs its mechanism in the priority search to generate different combinations
between different itemsets [5,3]. These combinations are then used to classify the retrieved
contexts and queued them in a descending order based on its support number. As a response
to the priority search purpose, an adapted version of the AprioriTid mining algorithm has
been developed and applied. This adapted version, as seen in Fig. 18, considers the single
itemset (1-itemset) size as well as the maximum support number usage, rather than k-itemset
for k ≥ 2 and the minimum support number “minsup” mechanism.
For more clarification, the priority search mines specific parts of the pre-existing argu-
ments based on the user’s search criteria. These search criteria enable the user to seek the
premises, conclusions, or the critical questions lying in the different arguments. For exam-
ple, suppose the user queries the RADB searching for all information related to “Iraq war”.
Simply, he can write “the destructive war in Iraq” as the search statement and can choose
the conclusion as the search criteria [see Fig. 19]. In this case, the classifier agent receives

123
Argument mining based on a structured database

Fig. 17 The main window of our system implemented in Visual C++

Fig. 18 An enhanced version of

AprioriTid

Fig. 19 The priority search result

the set of significant tokens {destructive, war, iraq} from the parser module (for more expla-
nation about parser functionality, see [3]). This set is considered as the single size item-
set (1-itemset) C1 = {w1 , w2 , w3 } that contains the most crucial set of words in the search
statement. Then, the agent uses the adapted version of the AprioriTid algorithm to gen-
erate the different super itemsets C2≤k≤3 that are the different combinations between dif-
ferent tokens. So, the generated super itemsets, as seen in Fig. 20, will be the 2-itemset
C2 = {w1 w2 , w1 w3 , w2 w3 }, and the 3-itemset C3 = {w1 w2 w3 }. Afterward, the different
conclusions in the different arguments trees will be mined seeking for the most relevant
set of arguments Ans = {d1 , d2 , . . . , dm } such that ∀di ∈ D∃Ck∈{1,2,..., j} ⊆ di . Finally, the
results will be queued in descending order and exposed in a list, where the user can choose the
argument name “Argument_314” from the list to expose the associated context and analysis
as in Fig. 26.

123
 S. Abbas, H. Sawamura

Fig. 20 The adapted AprioriTid

mechanism

6.2 Tree substructure mining

The substructure mining techniques utilize the tree structure lying in the RADB repository
and retrieve the most relevant arguments to the subject of search. This search mechanism is
considered substantial for the structured repository and offers two types of search techniques:
“General Search” and “Rule Extraction Search”.

• General Search: As shown in Fig. 17, it uses the breadth first search technique [21,35]
in order to encounter all nodes in the argument trees and retrieve the most relevant group.
For example, suppose the user writes “the destructive war in Iraq” as a search statement.
The revealed contexts, as shown in Fig. 21, will be ordered based on the nodes’ cardi-
nality (which means that the first queued argument is the one that contains more nodes
related to the subject of search).
With respect to Fig. 22, the breadth first search seeks each tree in our RADB forest,
preserving the ancestor-descendant relation [9,35] by searching first the root Fig. 22a,
then the children in the same level as in Fig. 22b and so on as in Fig. 22c. Finally, if the
user picks one of the resulted search arguments, the associated context and analysis are
depicted as shown in Fig. 26.
• Rule Extraction Mining: It is a search technique in which argument trees are encoun-
tered to discover all hidden patterns “embedded subtrees [9,35]” that coincide with
the relation between some objects. These objects express a set of the most significant
tokens of the user’s subject of search. More precisely, suppose the user wants to report
some information about the relation between the “USA war” and the “weapons of mass
destruction”. At the beginning, the user’s search statements are reduced to the most sig-
nificant set of tokens by the parser [1–3]. Then, the different argument trees, pre-existing
in the RADB repository, are mined in order to fetch these different tokens. Figure 24a
shows the analysis of an argument tree, where some enclosed nodes coincide with the
user’s search statements, while Fig. 24b shows the revealed embedded subtree.
Finally, each resulted subtree is expressed in the form of a rule as shown in Fig. 23,
where “+” indicates that this node is a support to the final conclusion and its type is 1.

123
Argument mining based on a structured database

Fig. 21 The general search

representation form

Fig. 22 The breadth first search

Fig. 23 The representation form of Rule Extraction search result

Similarly, “−” is a rebuttal node to the final conclusion, and its type is −1 as specified
in Sect. 4.3.

7 Use and benefit of RADB and argument mining agent in ITS

The RADB structure formulation and the mining classifier agent can be incorporated into an
intelligent tutoring system (ITS) to construct an agent-based learning environment, which
aims to teach argument analysis and construction. This section describes an architecture of
a proposed argument learning environment (ALES) as depicted in Fig. 25. The environment

123
 S. Abbas, H. Sawamura

Fig. 24 The Rule Extraction search

utilizes the RADB and the classifier agent in order to (1) guide the analysis process to refine
the user’s underlying classification, (2) deepen the user’s understanding of debating, decision-
making, and critical thinking. It consists of four main models: domain model, pedagogical
model, student model, and the GUI model. The domain model utilizes the represented struc-
tured argument repository “RADB” (already discussed in Sect. 4) and enjoys the extendability
feature as described in Sect. 5.2. The pedagogical model has three components (parser, clas-
sifier agent, teaching model) that co-operate together in order to achieve the required aims.
The student model keeps track of the student performance and assists the pedagogical model
in offering individualized teaching. Visual C++ was used to implement the graphical user
interface “GUI” of the proposed environment. It provided a stable encoding application and
satisfiable interface. Not only does ALES teach argument analysis, but also assesses the stu-
dent and guides him through personalized feedback [4]. Since the RADB design and structure
have been discussed in Sect. 4, the next subsections will describe the pedagogical and student
models.

7.1 Pedagogical model

The pedagogical model is responsible for reasoning about the student behavior
k according to
the student model. It aims to: (1) retrieve the most relevant results “ i=1 Si ” to both the
subject of search and the student’s background, (2) present the corresponding context and
analysis “Di ” of the selected result Si , and (3) guide the student analysis, during the assess-
ing phase. The pedagogical model as seen in Fig. 25 consists of three main components: the
parser, the classifier agent, and the teaching model.
– The importance of the parser lies in reducing the set of tokens into a set of significant
keywords, which in turn (1) improves the results of the classifier where combinations of
unnecessary words vanish and (2) reduces the number of iterations done by the classifier
agent. For more details and discussion, see [1–3].

– The classifier agent classifies the retrieved contexts depending on the student’s specifi-
cation, using general classification or rule extraction or priority based on specific search
criteria such as premises (with/against) or conclusions. For more details about different
retrieving techniques and the importance of the classifier agent, see Sect. 6.

– The teaching model monitors the student actions, guides the learning process, and pro-
vides the appropriate feedback. The model starts its role when the classifier agent sends

123
Argument mining based on a structured database

Fig. 25 ALES architecture

the document Di selected by the student. The teaching model checks, according to the
current student model, whether the student is in the learning or the assessing phase. If
the student is in the learning phase, the document is presented associated with the cor-
responding analysis as the shown in Fig. 26. On the other hand, if the student is in the
assessment phase, the student is able to do his own analysis, and the teaching model will
guide him during analysis by providing personalized feedback whenever required. The
feedback aims to guide the student and refine his analysis and intellectual skills. Two
kinds of feedback are provided by the teaching model; partial argument negotiation and
total negotiation.

• Case of partial argument negotiation: In this case, the student starts analyzing
the argument context in the form of a tree in which the root holds the final conclu-
sion of the issue of discussion. The teaching pedagogy used in this case provides
partial hints at each node of the analysis tree. They are results of comparing the
student’s current node analysis to the original one in the argument database. These
hints are provided before allowing the student to proceed further in the analysis
process; they aim to minimize the analysis error ratio, as much as possible, for the
current analyzed node. Generally, the teaching model guides with the student via

123
 S. Abbas, H. Sawamura

Fig. 26 The chosen context and the associated analysis

the partial hints at each node till the error of the current node is minimized to a spe-
cific ratio. After then, the student is able to move to the next analysis step (i.e., node).

• Case of total argument negotiation: The total argument negotiation is similar to

the partial argument negotiation. However, the teaching pedagogy is different in that
it provides hints only at the end of the analysis process. In other words, after the
student builds the full analysis tree for the selected context, the system interprets and
evaluates the student’s analysis comparable to the pre-existing one and remarks the
errors.

7.2 Student model

The student model stores details about student’s current problem-solving state and long-
term knowledge progress, that is essential for future student’s performance evaluations. The
model considers personal information, pre-test evaluation, and performance history. Personal
information contains personal data as name, ID, password, . . . , etc. The pre-test evaluation
permanently assesses the student’s argument analysis skills and follows the student progress
through learning process. Finally, the performance history implicitly reflects how much the
student has done and how well. A virtual example that shows the student–system interaction
is shown in the “Appendix A”.

7.3 An illustrative example

This is a simple example that shows a part of the complete run and explains the corresponding
symbols in ALES architecture Fig. 25. The system interactions are written in normal font.
The student’s actions are in bold. Our illustrations to some actions will be in capital letters.

123
Argument mining based on a structured database

THE SYSTEM ASKS THE USER TO LOG IN OR REGISTER IF IT IS HIS FIRST TIME.

System please sign in or register as a new user.

User safia.
User******.

System Hello safia, do you have background about argumentation?

THE USER SHOULD CHOOSE AN ANSWER FROM AN EXISTED LIST. SUP-

POSE THE USER HAVE NO IDEA ABOUT ARGUMENTATION OR ARGUMENT
ANALYSIS.

User No.

IN THIS CASE, THE SYSTEM GIVES THE USER A BRIEF INTRODUCTION ABOUT
THE SYSTEM AND HOW HE/SHE CAN INTERACT WITH IT IN ORDER TO GAIN
KNOWLEDGE ABOUT ARGUMENTATION.

System Ok. Let’s see how you can use the different screens. You can navigate in our
system searching for specific issue using different criteria through the search tab, then from
the exposed arguments list you can pick any argument. This allows you to see the original
context and the associated expert analysis. Next you can use the assessing tab for quiz argu-
ments, you are asked to analyze it based on your selected scheme. This stage can provides
you with two kinds of feedback “node/whole”, this feedback will help and guide you during
your analysis procedure.
System Are you ready to start now?
USER Yes.

THE MAIN FORM WILL APPEAR TO THE USER AS SHOWN IN Fig. 17.

SUPPOSE THE USER WANTS TO SEARCH ABOUT ALL ARGUMENTS OR REPORTS

RELATED TO “IRAQ WAR”

User press the search tab

User selects the General search tab. n=5
User writes in the search text “the destructive war in iraq” [ S = i=1 Wi ].
User presses search button.

THE PEDAGOGICAL MODEL PASSES THE “S” STATEMENT TO THE “Parser”. THE
“Parser” DIVIDES THE STATEMENT
 j=3 “S” AN REDUCE IT TO THE SET OF THE
MOST SIGNIFICANT WORDS i=1 Wi = {destructive, war, iraq}. THIS SET IN TURN
WILL BE PASSED TO THE CLASSIFIER AGENT. THE CLASSIFIER
k=2 AGENT WILL
RETRIEVE THE DIFFERENT RELATED ARGUMENTS “ i=1 Si ”, BASED ON SUB-
STRUCTURE MING TECHNIQUES THAT HAVE BEEN DESCRIBED IN SECT. 6.2,
AND LIST THEM TO THE USER AS SEEN IN THE NEXT STEP.

System the search results are the following list [argument_214, argument_810] as in
Fig. 21.

123
 S. Abbas, H. Sawamura

User picks up argument_214 “Si ” from the retrieved list to see the main context and
the associated analysis.
System accesses to the “RADB” and presents the associated context and analysis “Di ” as
in Fig. 26.

DURING STUDENT NAVIGATION, THE STUDENT MODEL RECORDS EACH

ACCESSED ARGUMENT. AFTER THE USER FINISHES NAVIGATING, HE CAN move
TO THE ASSESSING TAB IN ORDER TO START THE LEARNING BY ASSESS-
ING PHASE, WHICH PROVIDES THE ABILITY TO ANALYZE SPECIFIC CONTEXT
GUIDED BY FEEDBACK (Fig. 27) [see “Appendix A” for the the complete run].

8 Related work

Although a number of argument mark-up languages tools have been proposed to facilitate data
preprocessing, using diagrams for argument representation, the integration between them is
missing. This barrier limits the ability of the same user to access the same argument using
different tools. The argument-markup language (AML, XML-based language) behind the
Araucaria, compendium, and reasonable systems [24,26,29,33] are examples of these trials.
Indeed, Araucaria system provides many retrieving criteria; however, irrelevant results may
be obtained when using more than one word in the search statement. For more clarification,
twenty contexts were selected from the Araucaria DB to act as RADB data entry. These
selected contexts were re-analyzed based on Walton schemes and stored in our RADB. The
contexts’ content revolves around various themes including religions, crimes, Philosophy,
and politics, where three of these contexts {arg1 , arg2 , arg3 } analyze the political issue for the
Iraq war. In order to verify and compare the retrieval methods in both systems, three search
statements related to “Iraq war” were used. These statements have been selected especially
because they did not appear explicitly in the set of arguments {arg1 , arg2 , arg3 }, instead their
words appeared separately in the contexts.

• S1 = “the destructive war in Iraq”,

• S2 = “Iraq war”,
• S3 = “Iraq”.

As shown in Table 1, the retrieved results varied in Araucaria DB from those of the
described classifier agent. The agent identified the three contexts relevant to the search state-
ments and showed them ordered by priority [see Sect. 6.1], whereas Arcauria DB could not
retrieve the pertinent arguments except for S3 .
Moreover, the user analyzes any document depending on his beliefs and understanding,
and not based on a dedicated structure of different schemes or previous analysis. This kind of
analysis encompasses an intractable knowledge that undermines the mining process. These
mining processes and the artificial intelligence influence together are needed to guide the

Table 1 The retrieved results

Araucaria DB ALES
using different statements
S1 None {arg1 , arg2 , arg3 }
S2 None {arg1 , arg2 , arg3 }
S3 {arg1 , arg2 , arg3 } {arg1 , arg2 , arg3 }

123
Argument mining based on a structured database

user’s understanding via the relation between scientific theories and evidences and to refine
his argument analysis ability.
Regarding the AI and education fields, many instructional systems have been developed
to hone student’s argumentation skills, for example SCHOLAR and WHY [35] systems.
However, these systems were mainly designed to engage the students in a Socratic dialog,
which faces significant problems to develop a Socratic tutor [21] such as, knowledge repre-
sentations, especially in the complex domains like legal reasoning, control or preprocessing,
and manipulate the natural language. Later, as a response to these difficulties, a number of
case-based models [19] and mining weblogs [10,22] have been proposed to tackle the mining
and the artificial influence problem. The mining weblogs are considered as a classification
problem for the legal or informal reasoning considering law. Though, it mines the textual data
that is intractable to be processed. On the other hand, the case-based argumentation systems,
such as the CATO [19] and LARGO [16,17], use the case-based reasoning method in order
to reify the argument structure through using tools for analyzing, retrieving, and comparing
cases in terms of factors.
Comparing CATO to our proposed application, both of them provide examples of specific
issues to be studied by different students, as well as evaluate the student’s arguments compa-
rable to the pre-existing one. With respect to the search for arguments, both systems support
the student’s search for the existing database and retrieve the most relevant argument. How-
ever, CATO limits the student’s search by a boolean combination of factors. On the one hand,
in the full-text retrieval search, one can retrieve documents, by matching phrases, which is
not relevant to the search subject. On the other hand, ALES provides different search criteria
to tackle this problem, as seen in Sect. 7, utilizing the provided search engine in order to:
summon and provide a myriad of arguments at the student’s fingertips, retrieve the most
relevant results to the subject of search, and organize the retrieved result such that the most
relevant is the first rowed. Furthermore, LARGO is an intelligent tutoring system that guides
the students during their graphical analysis representation to the legal court cases by provid-
ing feedback based on the pre-existing knowledge. It can also trace and evaluate the student’s
performance. However, it is basically dedicated to whom have a legal background, since it
considers the legal reasoning field only and designed especially to help law students learn
legal argumentation skill.
Finally, Rahwan presents the ArgDf system [8,25], through which users can create, manip-
ulate, and query arguments using different argumentation schemes. Comparing ArgDf sys-
tem to our approach, both of them sustain creating new arguments based on existing argu-
ment schemes. In addition, the ArgDf system guides the user during the creation process
based on the scheme structure only, and the user relies on his efforts and his background
to analyze the argument. However, in our approach, the user is not only guided by the
scheme structure but also by crucial hints devolved through mining techniques. Accordingly,
the creation process is restricted by comparing the contrasting reconstruction of the user’s
analysis and the pre-existing one. Such restriction helps in refining the user’s underlying
classification.
In the ArgDf system, searching existing arguments is revealed by specifying text in the
premises or the conclusion, as well as the type of relationship between them. After then,
the user is allowed to filter arguments based on a specific scheme. In our approach, searching
the existing arguments is not only done by specifying text in the premises or the conclu-
sion but also by providing different strategies based on different mining techniques in order
to: refine the learning environment by adding more flexible interoperability, guarantee the
retrieval of the most convenient hypotheses relevant to the subject of search, and facilitate
the search process by providing a different search criteria.

123
 S. Abbas, H. Sawamura

9 Conclusion and future work

In this paper, we described a novel approach to building a highly structured argument

repository (RADB) in order to (1) summon and provide a myriad of arguments at the
user’s fingertips and (2) facilitate the interoperability among various agents/tools/humans.
The novelty of our approach is the proposed structured knowledge base, which is used
to answer users’ queries related to the domain entities. So far, arguments have been
described in the form of diagrams encoded by the argument-markup language (AML, XML-
based language). On the other hand, this representation limits the argument interoperabil-
ity between different argument mapping tools. Moreover, our structure knowledge base
“RADB” enjoys the extendable property so that it enables the addition of new schemes
proper to different cultures and beliefs if they are formulated in the form of Walton theory
of argumentation.
Furthermore, the paper has introduced a classifier agent as a managing tool that uses dif-
ferent mining techniques to enrich the argument analysis, retrieval, and re-usage processes.
The main purposes of this agent are the following: (1) retrieving the most relevant results
to the subject of search and (2) supporting the fast interaction between the different mining
techniques and the existing arguments. Our attempt enjoys certain advantages when com-
pared to others, especially with respect to the search of pre-existing arguments. The results
obtained are very promising, where highly relevant and convenient arguments are obtained,
especially when the search statement is in this form “the destructive war in Iraq” or “ USA
war and the mass of destructive weapons”.
Finally, we proposed an agent-based educational environment (ALES), which utilizes both
the RABD and the classifier agent together, aiming to (1) guide the analysis process to refine
the user’s underlying classification and (2) deepen the users’ understanding of negotiation,
decision-making, and critical thinking. ALES considers two phases, the learning and assess-
ment phases, and has four main components: domain model, pedagogical model, student
model, and the GUI model. These components co-operate together in order to verify the
stated targets. In the future, we intend to (1) continue in the learning environment implemen-
tation, (2) use the frequent tree mining techniques [9,15] to search for the frequent patterns in
different arguments in order to identify an artificial student model, and (3) integrate an NLP
software to the classifier agent in order to aid in a new search criteria annotated as polarity
classification that provides flexibility to user’s queries [7].

Appendix A: System-user interaction

This appendix shows an example of a complete run. The system interactions are written in
normal font. The student’s actions are in bold. Our illustrations to some actions will be in
capital letters.

THE SYSTEM ASKS THE USER TO LOG IN OR REGISTER IF IT IS HIS FIRST TIME.

System please sign in or register as a new user.

User safia.
User******.

System Hello safia, do you have background about argumentation?

THE USER SHOULD CHOOSE AN ANSWER FROM AN EXISTED LIST. SUPPOSE

123
Argument mining based on a structured database

Fig. 27 The virtual example scenario

123
 S. Abbas, H. Sawamura

THE USER HAVE NO IDEA ABOUT ARGUMENTATION OR ARGUMENT

ANALYSIS.

User No.
IN THIS CASE, THE SYSTEM GIVES THE USER A BRIEF INTRODUCTION ABOUT
THE SYSTEM AND HOW HE CAN INTERACT WITH IT IN ORDER TO GAIN KNOWL-
EDGE ABOUT ARGUMENTATION.

System Ok. Let’s see how you can use the different screens. You can navigate in our
system searching for specific issue using different criteria through the search tab, then from
the exposed arguments list you can pick any argument. This allows you to see the original
context and the associated expert analysis. Next, you can use the assessing tab for quiz argu-
ments, you are asked to analyze it based on your selected scheme. This stage can provide you
with two kinds of feedback “node/whole”, and this feedback will help and guide you during
your analysis procedure.
System Are you ready to start now?
USER Yes.

THE MAIN FORM WILL APPEAR TO THE USER AS SHOWN IN Fig. 17.

SUPPOSE THE USER WANTS TO SEARCH ABOUT ALL ARGUMENTS OR REPORTS

RELATED TO “IRAQ WAR”

User press the search tab

User selects the General search tab.
User writes in the search text “the destructive war in iraq”.
User presses search button.

THE SYSTEM RETRIEVES THE DIFFERENT RELATED ARGUMENTS BASED ON

SUBSTRUCTURE MING TECHNIQUES.

System the search results are the following list [ argument_214, argument_810 ] as in
Fig. 21.
User picks up argument_214 from the retrieved list to see the main context and the
associated analysis.
System presents the associated context and analysis as in Fig. 26.

DURING STUDENT NAVIGATION, THE STUDENT MODEL RECORDS EACH

ACCESSED ARGUMENT. AFTER THE USER FINISHES NAVIGATING, HE CAN move
TO THE ASSESSING TAB IN ORDER TO START THE LEARNING BY ASSESS-
ING PHASE, WHICH PROVIDES THE ABILITY TO ANALYZE SPECIFIC CONTEXT
GUIDED BY FEEDBACK.

User press the assessing tab.

System please select a specific scheme to be used in your analysis.
User “expert opinion scheme”.
System select the kind of feedback “either node “partially” or whole “totally”.

123
Argument mining based on a structured database

User node feedback.

THE WHOLE ARGUMENTS, THAT USE THE “EXPERT OPINION SCHEME” IN ITS
ANALYSIS, WILL BE LISTED SUCH THAT THE PRIORITY IS TO THE CONTEXTS
THAT HAVE NOT BEEN ACCESSED YET BY THE USER DURING NAVIGATIONS.

System [argument_602, argument_1, argument_214].

User picks up one of the listed arguments, argument_602 as example.

THE SYSTEM PRESENTS THE TRANSCRIPT OF THE CHOSEN argument_602 ASSO-

CIATED WITH AN EMPTY TREE SKELETON AND ASKS THE STUDENT TO START
HIS OWN [Link] TRANSCRIPT IS SHOWN AS IN EXAMPLE 5
SINCE THE USER CHOOSE THE NODE FEEDBACK THE SYSTEM WILL SUPPLY
ADVICE AT EACH NODE COMPARING THE USER ANALYSIS WITH THE PRE-
EXISTING ONE, AND WILL NOT GO STEP FURTHER UNLESS THE USER ADJUST
THE CURRENT NODE ANALYSIS BY RATIO WITH THE EXPERT ANALYSIS FOR
THE SAME NODE.
User starts to fill his first node waiting the system advices. Suppose the student writes
“final decision is the death was not accident”.

System divides the user node statement in the set of significant tokens final, decision,
death, accident, then compares this tokens with the expert analysis for the same node, and
then calculates and records the error ratios for that node.

System shows out the following message “your analysis is partially correct try to use
the words { Kyle Mutch, tragic, suffered, punch}, in your node analysis, rather than the
words {final,decision,…} that have been used in the current analysis”.

User he will reanalyze the current node adding the context that contains the advised
keywords.

System compares again the current context node with the pre-existing analysis and nego-
tiate again, guiding the user, till he reaches to the correct analysis for this node.

User fill the other nodes.

System negotiates based on the pre-existing expert analysis guiding the user during his
analyses.

AFTER THE USER FINISHES HIS ANALYSIS TO THE WHOLE CONTEXT, FILL-
ING THE SUITABLE ANALYSIS FOR EACH NODE, THE SYSTEM WILL RECORD
THE FIRST ANALYSIS RATIO FOR EACH NODE, THEN CALCULATE AND RECORD
THE WHOLE ARGUMENT ANALYSIS RATIO FOR THAT ARGUMENT. THEN FOR
EACH ASSESSMENT THE SYSTEM WILL RECORD THE CORRECTNESS RATIO
TILL IT COMES TO BE MORE THAN OR EQUAL TO 90% IDENTICAL TO THE PRE-
EXISTING ANALYSIS. THEN THE SYSTEM WILL ASK THE USER TO GO TO THE
EVALUATION PHASE.

123
 S. Abbas, H. Sawamura

System wow, you achieving well, it is better to accept the challenge and go to the evaluation
phase.
User OK, and then press the tab evaluation.

System loads a context to be analyzed by the user; however, the system shows a con-
text that has not been accessed before by the user.

User starts to analyze without any help till press check analysis.
System compares each node of the userć6s analysis with the expert analysis, deduces a
report for the wrong nodes, and records this analysis for future progress report.

Appendix B: An example of the database population

This appendix illustrates the database population procedure. The database populating pro-
cess is only authorized for the teachers since this system is designed to be used in classroom
environments as an adaptive learning platform that teaches argument analysis and traces the
students’ progress history in order to improve the students’ critical thinking.
The system interactions are written in normal font. The teacher’s actions are in bold. My
illustration(s) to some actions will be in capital letters.

Teacher press the Insert in the Data tab from the main form as shown in Fig. 17.
System open the data insert form, as seen in Fig. 30.
Teacher press the “Load File” button.
System open the file dialog window, as seen in Fig. 28, giving the teacher the ability to
insert any new argument’s context to the system to be analyzed in the form of document/text
file type.
Teacher select “argument_831” to be analyzed.

THE CONTEXT AND THE ANALYSIS OF THE “argument_831” IS ALREADY REPRE-

SENTED IN EXAMPLE 4 SECT. 2.3. THIS CONTEXT IS CHOSE IN THAT APPENDIX
TO REPRESENT THE NESTED DATABASE POPULATING IN THE BACKUP EVI-
DENCE QUESTION’S ANSWER.

Fig. 28 The data entry form

123
Argument mining based on a structured database

Teacher select “Expert Opinion Scheme” from the “Select Scheme” combo box.
System retrieve and show the structure of the selected scheme in the “Corresponding Con-
text Analysis” tree, as shown in Fig. 29
Teacher start the analysis by selecting the “premise” node by either copy and past
from the left context box of the argument’s context or directly by editing in the node.
Since this node is supports the final conclusion, the teacher will mark the check box
beside that node.

THE TEACHER WILL CONTINUE THE ANALYSIS TILL REACHES THE “Back up
Evidence” node WHERE NESTED NODES ARE NEEDED.

Teacher select the “Back up Evidence” node.

Teacher press “Add Node” button.

Fig. 29 The data entry form containing the argument context and the utilized scheme structure

Fig. 30 The data entry form containing both part of the analysis and nested nodes data

123
 S. Abbas, H. Sawamura

Table 2 The database populating for one of the “Back Up Evidence” nested nodes from Example 4

ID Struc_Id Content Type Child_Of Level argumentation_no

60 10 “The correctness of these 1 59 4 argument_831

judgments can only be…”
61 11 “RA-Node” 1 60 5 argument_831
62 10 “Dis productive disconnects” 1 61 6 argument_831

System add child node for the “Back up Evidence” node, as seen in Fig. 30.

IF THE TEACHER WANTS TO DELETE ANY NODE IN THE WHOLE ANALYSIS

TREE, HE CAN USE THE “Delete Node” BUTTON SHOWN IN Fig. 30.

Teacher continue the analysis by filling the remaining nodes. After then, he finishes
the analysis by pressing the “Save Whole Analysis” button.
System access the “RADB” and save the whole analysis in the transaction table
“Data_TBL”.

BASED ON THE COMPLETED ANALYSIS FOR “argument_831” SHOWED IN FIG. 4,

TABLE 2 SHOWS HOW THE LEAF NODE FOR THE “Back Up Evidence” NODE IS
GOING TO BE POPULATED IN THE DATABASE.

References

1. Abbas S, Sawamura H (2008) Argument mining using highly structured argument repertoire. In: The first
international conference on educational data mining (EDM), Montreal, Qubec, Canada, pp 202–2010
2. Abbas S, Sawamura H (2008) A first step towards argument mining and its use in arguing agents and
its. In: 12th international conference on knowledge-based and intelligent information and engineering
systems (KES), Zagreb, Croatia, Springer, pp 149–157
3. Abbas S, Sawamura H (2008) Towards argument mining using relational argument database. In: The sec-
ond international workshop on Juris-informatics (JURISIN), Asahikawa Convention Bureau, Hokkaido,
Japan, pp 22–31
4. Abbas S, Sawamura H (2009) Mining impact on argument learning environment and arguing agents.
In: The third international workshop on Juris-Informatics (JURISIN 2009), JSAI, Tokyo, Japan, pp 3–14
5. Agrawal R, Srikant R (1994) Fast algorithms for mining rules. In: the 20th VLDB conference Santiago,
Chile
6. Baloian N, Motelet O, Pino A (2008) Taking advantage of metadata semantics: the case of learning-
object-based lesson graphs. Knowl Inf Syst J 20:323–348
7. Cao B, Badia A (2009) Exploiting maximal redundancy to optimize sql queries. Knowl Inf Syst J
20:187–220
8. Chesnevar C, McGinnis J, Modgil S, Rahwan I (2006) Towards an argument interchange format. In: The
knowledge engineering review. Cambridge University Press
9. Chi Y, Muntz R (2001) Frequent subtree mining—an overview. Fundamenta Informaticae.
pp 1001–1038
10. Conrad J, Schilder F (2007) Opinion mining in legal blogs. In: ICAILć607 palo alto, California, USA,
pp 231–236, June 4–8
11. Godden M, Walton D (2006) Argument from expert opinion as legal evidence: critical questions and
admissibility criteria of expert testimony in the American legal system. Juris R 19:261–286
12. Gordan F, Walton D (2006) The carneades argumentation framework: using presumptions and excep-
tions to model critical questions. In: 6th computational models of natural argument workshop (CMNA),
European conference on artificial intelligence (ECAI), Italy, pp 5–13

123
Argument mining based on a structured database

13. Gordan F, Walton D (2006) The carneades argumentation framwork. In: Computational models of argu-
ment (COMMA06), IOS press, vol 144, pp 195–207
14. Katzav J, Reed C, Rowe G (2003) Argument research corpus. In: Huget M-P (ed) Communication in
multiagent systems, Lecture notes in computer science, vol 2650, Springer, Berlin, pp 269–283
15. Lin X, Zhou A, Luo H, Fan J, Bertino E (2008) A distributed approach to enabling privacy-preserving
model-based classifier training. Knowl Inf Syst J. pp 157–185
16. Lynch C, Ashley K (2009) Toward assessing law students’ argument diagrams. In: The 12th interna-
tional conference on artificial intelligence and law, Association for Computing Machinery, New York,
pp 222–223
17. Lynch C, Ashley K, Pinkwart N, Aleven V (2007) Learning by diagramming supreme court oral argu-
ments. In: The 11th international conference of artificial intelligence and law, ACM Press, pp 271–275
18. Macagno F, Walton D (2006) Argumentative reasoning patterns. In: Proceeding of 6th CMNA (Compu-
tational models of natural argument) workshop, ECAI (European conference on aetificial intelligence),
Rivadel Garda, Italy, Trento, Italy, University of Trento. pp 48–51
19. McBurney P, Parsons S (2003) Dialogue game protocols. In: Practical applications in language corpora
20. Moens M, Boiy E, Palau R, Reed C (2007) Automatic detection of arguments in legal texts. In: ICAIL07
Palo Alto, California USA, pp 225–230, June 4–8
21. Nijssen S, Kok JN (2004) A quickstart in frequent structure mining can make a difference. In: Tenth ACM
SIGKDD international conference on knowledge discovery and data mining, USA, pp 647–652
22. Prakken H, Vreeswijk G (2002) Logical systems for defeasible argumentation. In: Gabbay D,
Guenther F (eds) Handbook of philosophical logic. Kluwer, NY, pp 219–318
23. Prakken H, Reed C, Walton D (2005) Dialogues about the burden of proof. In: Proceedings of the 10th
international conference on artificial intelligence and law (ICAIL), ACM Press, New York NY, USA
24. Rahwan I, Sakeer P (2006) Representing and querying arguments on semantic web. In: Dunne PE,
Bench-Capon TJM (eds) Computational models of argument. IOS Press, Amsterdam
25. Rahwan I, Zablith F, Reed C (2007) The foundation for a world wide argument web. In: Artificial intel-
ligence conference (AAAI). published in the Artificial Intelligence Journal, April 04
26. Reed C, Rowe G (2004) Araucaria: software for argument analysis, diagramming and representation. Int
J Artif Intell Tools 13:983
27. Reed C, Rowe G (2005) Translating toulmin diagrams: theory neutrality in argument representation.
Argumentation J 19:267–286
28. Reed C, Walton D, Macagno F (2008) Argumentation schemes. Cambridge University Press, Cambridge
29. Rowe G, Reed C, Katzav J (2003) Araucaria: making up argument. In: European conference on computing
and philosophy
30. Walton D (1996) Argumentation schemes for presumptive reasoning. In: Lawrence Erlbaum, vol 13,
p 236
31. Walton D (2006) Argument from appearance: a new argumentation scheme. Logique et Analyse 195:
319–340
32. Walton D, Hansen H (2006) Fundamentals of critical argumentation. Cambridge University Press,
Cambridge
33. Walton D, Rowe G, Macagno F, Reed C (2006) Araucaria as a tool for diagramming arguments in
teaching and studying philosophy. Teach Philos 29:111–124
34. Wang K, Zeng X, Pei J, Li J (2008) Pads: a simple yet effective pattern-aware dynamic search method
for fast maximal frequent pattern mining. Knowl Inf Syst J 20:375–391
35. Zaki M (2005) Efficiently mining frequent trees in a forest: algorithms and applications. IEEE Trans
Knowl Data Eng 17:1021–1035

123
 S. Abbas, H. Sawamura

Author Biographies

Safia Abbas works as a lecturer in the Department of Computer

Sciences, Faculty of Computer and Information Sciences, University
of Ain Shams, Cairo, Egypt. She received the Ph.D. from the Gradu-
ate School of Science and Technology, Niigata University, Japan.

Hajime Sawamura is a Professor of Computer Science at Niigata

University, Japan. He received the B.E., M.E. and Doctor of Engi-
neering degrees from Hokkaido University in the area of logic-based
artificial intelligence and software science. During 1980–1996, he was
with Institute for Social Information Science, Fujitsu Laboratories Ltd.,
where he was a senior research fellow of computational logic group.
During 1990–1991 and in 2000, he was a visiting fellow of Australian
National University, and in 2002–2003 a visiting fellow of philosophy
department, Victoria University of Wellington, New Zealand. A strong
theme of his recent research is mathematical argumentation that is a
true and realistic logic, and its application to agent-oriented computing.

123