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 conflicts 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 definition of revisable assumptions in order to remove the inconsistencies. We use Shakespeare's Hamlet as a modelling example. Given the specification, Ultima Ratio unfolds a process of argumentation in which arguments and counter-arguments are exchanged to detect conflicts 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 mobilés being dynamically constructed as the argumentation process evolves. The argumentation engine is accessible on the internet .
 
 

2 Formalizing Human Argumentation

Argumentation semantics treats the evaluation of a logic program as an argumentation process, where a goal G holds if all arguments supporting G 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 figures: Reductio ad absurdum- and groundattack [2] or equivalently rebut and undercut [3]. The former classifies an argument that leads to a contradiction under the current believes and arguments, and the latter an argument that falsifies the premise of one of the current arguments. Argumentation semantics in extended logic programming has been defined in [1, 3]. Our framework is based on [3] with a modification avoiding some unintuitive results [4]. Consider the excerpt of the third scene in the third act of Shakespeare's Hamlet below: 

1. Hamlet. [approaches the entry to the lobby]
   Now might I do it pat, now a'is a-praying-
2. 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 conflict. 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:

1. praying(claudius):
2. in_heaven(X) <- kills(Y; X);praying(X):
3. took_ revenge_on(X; Y) <- kills(X; Y):
4. killed(claudius; king):
5. -took_revenge_on(X; Y) <- in_heaven(Y):
6. goal_revenge(X; Y) <- close(X; Z);
   killed(Y; Z); not justified(killed(Y; Z)):
7. close(hamlet; king):
8. goal_revenge(X; Y); not_took_revenge on(X; Y):
9. <- 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 satisfies 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 finds 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. X wants to take revenge on Y if Y killed a person Z being close to X, and the killing is not justified. Left implicitly in the piece is the fact that Hamlet and his father are close to each other (g). To specify conflicting 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 conflicts. 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.

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 profile defining the agent's character,
• the world, the agent is confronted with, and
• one of two modes of reasoning to either detect a conflicting situation or to abduce alternative decisions to deal with the conflicts and remove them.

4 Visualizing the Argumentation Process

For visualization 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 different metaphors for each of the attacks to communicate the formal difference 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 first one.

Acknowledgment We'd like to thank Bela Bargel and Joachim Böttger for our discussions and for their support in implementing the visualization and Iara Móra 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. Artificial Intelligence, 77(2):321-357,1995.
[3] Henry Prakken and Giovanni Sartor. Argument-based extended logic programming with defeasible priorities. Journal of Applied Non-Classical Logics, 1997.
[4] Michael Schroeder, Iara Móra, and José Julio Alferes. Vivid agents arguing about distributed extended logic programs. In Proceedings of the Portuguese Conference on Artificial Intelligence EPIA97. LNAI 1323, Springer-Verlag, 1997.