ULTIMA RATIO
Should Hamlet kill Claudius?
Michael Schroeder1 4, Daniela A. Plewe2, Andreas Raab3
;
Inst. for Knowledge-based Systems, Univ. of Hannover, Germany, [email protected]
Franz-Kunstler-Str. 2, 10969 Berlin, Germany, [email protected]
Dept. of Simulation and Graphics, Univ. of Magdeburg, Germany, [email protected]
1
2
3
1 Introduction
Ultima Ratio is a system for formal argumentation and
visualization. It allows one to specify an agent and the
world it is situated in as an extended logic program.
Using argumentation, it is possible to detect and remove conicts the agents are facing. The modeling language allows two forms of negation to express that a
proposition is explicitly false and is assumed false by
default, respectively, it allows for integrity constraints
to characterize contradictory situations, and the denition of revisable assumptions in order to remove the
inconsistencies. We use Shakespeare's Hamlet as a modelling example. Given the specication, Ultima Ratio
unfolds a process of argumentation in which arguments
and counter-arguments are exchanged to detect conicts and remove them. Two kinds of arguments are
distinguished, attacks to the conclusion of an argument
(rebut) and to the premises of an argument (undercut),
respectively. Besides the argumentation engine, Ultima
Ratio provides text, audio, and animated 3D output.
The visualization enables users to navigate through the
argumentation space and the argumentation process.
It is based on the visual metaphor of mobiles being
dynamically constructed as the argumentation process
evolves. The argumentation engine is accessible on the
internet http://www.kbs.uni-hannover.de/
~schroede/ultima simulator/ultima.html. Additionally,
Ultima Ratio will be exhibited at Ars Electronica 98.
2 Formalizing Human Argumentation
Argumentation semantics treats the evaluation of a
logic program as an argumentation process, where a
4 now
at BT Labs, MLB1 PP12, Ipswich IP5 3RE, UK,
goal holds if all arguments supporting cannot be
attacked anymore. Thus, logic programming is seen as a
discourse involving attacking and counter-attacking arguments. Logic programming can be described in terms
of two gures: Reductio ad absurdum- and groundattack [2] or equivalently rebut and undercut [3]. The
former classies an argument that leads to a contradiction under the current believes and arguments, and
the latter an argument that falsies the premise of
one of the current arguments. Argumentation semantics in extended logic programming has been dened in
[1, 3]. Our framework is based on [3] with a modication avoiding some unintuitive results [4].
Consider the excerpt of the third scene in the third
act of Shakespeare's Hamlet below:
G
G
1
Hamlet. [approaches the entry to the lobby]
Now might I do it pat, now a'is a-praying2 And now I'll do't, [he draws his sword] and
so a' goes to heaven,
3 And so am I revenged. That would be scanned:
4 A villain kills my father, and for that
5 I his sole son do this same villain send
6 To heaven...
7 Why, this is bait and salary, not revenge.
Hamlet is caught in a conict. On the one hand
he wants revenge for his father being murdered. On the
other he knows that having revenge by killing Claudius,
the murderer, is not possible since Claudius is praying
at that very moment and would go to heaven which
contradicts the goal of having revenge. The text can be
formalized as follows:
a praying(claudius)
b in heaven(X) kills(Y X) praying(X)
c took revenge on(X Y) kills(X Y)
d killed(claudius king)
e :took revenge on(X Y) in heaven(Y)
goal revenge(X Y) close(X Z)
f
killed(Y Z) not justied(killed(Y Z))
:
;
;
:
;
;
;
:
:
;
;
;
:
;
;
;
;
:
g close(hamlet king)
h ? goal revenge(X Y) not took revenge on(X Y)
i revisable(kills(hamlet claudius) false)
In line 1, Hamlet realizes that Claudius is praying.
This is represented as a fact (a). In line 2, Hamlet continues that Claudius would go to heaven if killed while
praying. Formally, this is an instantiation of the general
rule (b). In line 3, Hamlet states that killing Claudius
satises Hamlet's desire for revenge. Or more general
(c). In line 4, Hamlet starts another line of thinking by
mentioning the fact that Claudius killed Hamlet's father, the king (d). In line 7, Hamlet nds that he does
not have revenge if he sends Claudius to heaven (e).
Beside this direct translation of Hamlet's monologue to
logic, we have to add further facts and rules which are
mentioned throughout the scenes before or which are
given implicitly. First of all, we need a rule to express
when someone wants revenge (f). I.e. wants to take
revenge on if killed a person being close to ,
and the killing is not justied. Left implicitly in the
piece is the fact that Hamlet and his father are close to
each other (g). To specify conicting goals we use besides facts and rules integrity constraints. In this scene
we state formally that it is contradictory to want to
take revenge and not have it (h). Finally, we have to
specify the assumptions Hamlet is willing to change to
solve conicts. For this scene, Hamlet adopts the default assumption of not killing Claudius. I.e. (i) states
that Hamlet killing Claudius is assumed false initially,
but may be changed in the course of argumentation.
;
:
;
;
;
;
;
X
Y
Y
:
:
Z
Figure 1: Dynamic mobiles for Hamlet's conict.
X
3 Functionality
The core of the system is the argumentation engine
whose output is transformed for the text and audio output as well as the 3D animation. The user controls the
engine using an internet interface. The user selects
an agent's prole dening the agent's character,
the world, the agent is confronted with, and
one of two modes of reasoning to either detect a
conicting situation or to abduce alternative decisions to deal with the conicts and remove them.
4 Visualizing the Argumentation Process
For visualisation we consider four events: an argument
is proposed, accepted, being attacked, or defeated.
If an argument is being proposed, its visualization
reveals the uncertainty of its future. During its foundation by other arguments it gains visual stability. If it
is being accepted, its visual representation changes to
indicate that there has been an agreement about this
argument.
During the execution of the logic program, an argument can be attacked in two ways (undercut and rebut).
In our visualization we use dierent metaphors for each
of the attacks to communicate the formal dierence between both types visually. If an undercut occurs, the
defeated argument collapses in the scene which is interpreted as being built on a wrong premise. A rebut is a
direct attack on the conclusion of an argument, i.e. the
second argument neutralize the rst one.
Acknowledgment We'd like to thank Bela Bargeld and
Joachim Bottger for our discussions and for their support in implementing the visualization and Iara Mora and Gerd Wagner for
their comments. Thanks also to BT for generous support of the
project.
References
[1] P. M. Dung. An argumentation semantics for logic programming with explicit negation. In Proc. of the 10th International Conference on Logic Programming, pages 616{630.
MIT Press, 1993.
[2] P. M. Dung. On the acceptability of arguments and its fundamental role in nonmonotonic reasoning, logic programming
and n-person games. Articial Intelligence, 77(2):321{357,
1995.
[3] Henry Prakken and Giovanni Sartor. Argument-based extended logig programming with defeasible priorities. Journal
of Applied Non-Classical Logics, 1997. To Appear.
[4] Michael Schroeder, Iara Mora, and Jose Julio Alferes. Vivid
agents arguing about distributed extended logic programs. In
Proceedings of the Portuguese Conference on Articial Intelligence EPIA97. LNAI 1323, Springer{Verlag, 1997.