In this paper we sketch a new approach to the development of dialogue games that builds upon the knowledge gained from several decades of dialogue game research across a variety of communities and which leverages the capabilities of the Dialogue Game Description Language as a means to describe the constituent parts of dialogue games. Our ultimate aim is to produce a method for rapidly describing and implementing games that conform to the designer's needs by declaring what is required and then automatically constructing the game from components, called 'fragments', that are distilled from existing dialogue games.
Dialogue games are generally designed to fulfil a specific purpose, for example, modelling
a specific type of dialogue such as the deliberation dialogue game of McBurney et al [ 6], or
investigating specific contexts of argumentation or dialogue as illustrated in the sequence of
elaborations of game rules for prohibiting the fallacy of Petitio Principii as found in the dialogue
of papers between Woods & Walton [19, 20, 21] on the one hand and of Mackenzie [
© 2021 Copyright for this paper by its authors. Use permitted under Creative Commons License Attribution 4.0 International (CC BY 4.0).
pertain to a broad range of dialogical contexts of interaction. A standard way to design and
develop dialogue games has involved the selection of an appropriate set of locutions, often from
an existing and well understood game, then specialising those locutions to the new context. DC
[
A related approach is the Lightweight Coordination Calculus (LCC) due to Robertson [10]. Whilst this approach shares some of our ideals in generating flexible and (semi-)automated communication protocols, it is a low level approach that is well suited to software agent coordination, but omits the focus on norm-oriented human communication that characterises much of dialogue game research, favouring an agent centred role that attempts to bridge between computational process communication and multi-agent institutions. A second early relevant approach was the efort to do run-time negotiation of the semantics of agent communication protocols [9]. This made an important contribution to the concept of protocol as a constructed object within a shared space as well as the idea that communication protocol is fungible. Finally a more recent approach to designing and implementing dialogue games can be seen in ProtOCL [23] which exploits the unified modelling language (UML) and the Object Constraint Language (OCL), technologies that are more commonly used to design and implement Object Oriented software systems. In ProtOCL, dialogue games are specified using a series of annotated diagrams which describe facets of the desired dialogue system. Code, in the form of a Java Object hierarchy is generated and incorporated into a wider software system. Both the LCC and the negotiating semantics approaches will likely form a basis for further work that exploits our proposed fragment library, especially in extending the system towards automated use by agents, however for the moment we are focusing upon dialogue game development as an essentially human-centric design activity akin to the ProtOCL approach.
This approach to dialogue description exploits the functionality of the Dialogue Game
Description Language (DGDL) [17]. In this section we give a high level overview of the DGDL before
focusing upon game descriptions expressed in the DGDL before finally investigating how such
descriptions can be taken apart to form “dialogue fragments”.
3.1. DGDL
The DGDL is a domain specific language for describing the rules of dialogues games in a format
that can be executed on a dialogue management run-time (such as DGEP [
We’ll not reproduce the entire grammar here, for reasons of space, but a minimal valid game description for a game named ‘Simple’ from [13] is illustrated in figure 1. In Simple there are two players, labelled ‘Player1’ and ‘Player2’, who each possess a public artefact store that is Simple{ {turns,magnitude:single,ordering:strict} {players,min:2,max:2} {player,id:Player1} {player,id:Player2} {store,id:CStore,owner:Player1,structure:set,visibility:public} {store,id:CStore,owner:Player2,structure:set,visibility:public} {Assert,{p},‘‘I assert that’’,{store(add, {p}, CStore, Speaker)}} } structured as a set of artefacts. Each turn the players may make a single move with a strictly alternating turn structure. There is a single move available to the players, the assert move, which enters the asserted statement into the artefact store of the speaker. Most dialogue games are more complex than this. Whilst the specification of players and turns is generally similar, most games define a rich set of interactions for the players to make, rather than the single ‘Assert’ move in the example, and a diverse set of efects, in terms of game artefacts, to apply once those moves have been made. Note however that there is a conceptual and practical diference between the DGDL grammar and a DGDL description. The grammar defines an abstract space of possible games whilst a DGDL description defines a single, specific, concrete game that exists within that space. It is the interval between abstract grammar and concrete game rule that we seek to exploit in this work.
Rather than an entire game description we desire fragments of a game that encapsulate an entire design concept from the source game and which are suitable for reconstructing into entirely new games. This introduces a notion of portability of rules between DGDL described games. If a given game implements a particular set of rules, which would be useful to include in another game, in order to make the same behaviour available in that other game, then fragments are one element of a means to achieve this. A basic fragment is a valid DGDL expression, starting from any valid left-hand-side (LHS) grammar rule, rather than merely the start rule, and completing it through to it’s terminal values. Whereas a ‘DGDL game description’ describes an entire game, a fragment describes only a part of a game. So all fragments are syntactically valid sub-expressions of the DGDL grammar. Because such basic fragments are particular to specific games, in order to make them more flexible, elements of a fragment can be replaced with their equivalents from the DGDL grammar originating from the same LHS starting point to yield a semi-instantiated ‘template fragment’. So, for example, where a fragment might refer, in it’s concrete instance, to a specific efect, e.g. “{store(add, {p}, CStore, Speaker)}” this could be replaced with the “RuleBody” grammar declaration to indicate that all other aspects of the fragment should remain the same but that diferent rule bodies could be applied, for example, a diferent artefact store efect. The idea is to provide an intermediate step between the two extremes of the highly abstract and incomplete grammar level rules and the completely concrete game description expressions. These intermediate states are our abstract fragments One or more fragments may be collected together to define a dialogical behaviour context. We desire to be able to take a declaration such as “prohibit circular reasoning” and then to generate games which fulfil this criterion on the basis of existing DGDL fragments. Note that this will be extremely dificult to completely achieve automatically and without error but provides a route towards more flexible, on the fly, dialogue protocol generation that accounts directly for the discoveries and achievements in dialogue game research over past decades. Fragments from multiple diferent dialogue games can be brought together to form a single library. The intuition is that games which have been decomposed into fragments can subsequently be recombined to form new games based upon the desired characteristics of the new game. A fragment library will comprise a database of fragments from existing dialogue games together with an interface for assembling fragments into new games.
Assuming a library of game fragments, suitably represented as templates for further
specialisation in specific generated games, let’s now consider the process of developing a new game from a
more declarative perspective. The goal is to be able to describe what we want our dialogue game
to do in terms of the characteristics of the resulting game. We propose that much of this process
would be performed in a specialised game development UI whose input was a description of the
desired game and whose output is a valid and fully-formed DGDL document. A variety of user
interfaces could be envisaged from a GUI that enables the user to describe their needs using
standard GUI widgets (selections, drop-downs, text inputs, and whatnot). Various forms of
text-based UI could also be envisaged, including a traditional application programming interface
(API) or, fittingly, a conversational interface, perhaps in the spirit of the recently announced
GitHub co-pilot tool. A starting place is to define a minimal, archetypal set of locutions that
conform to each supported dialogue type and which scafold the construction of the remainder
of the game. We name such a set of locutions the base game for dialogue type n. The base game
is a starting place, and the addition of rules to it leads to a specific derived game. If more than
one dialogue type is selected then there are two further organisational models that can account
for how the games work together. The first uses a Walton style shift model to move between
dialogue instances, and the second uses a compound model in which the locutions for each
dialogue type are amalgamated into a single whole. There are benefits to each approach and
both are supported by the DGDL. Once a base game has been selected, the user is instructed to
select desirable properties for their game. For example, prohibiting, prescribing, or permitting
specific behaviours. Each supported property will correspond to either an existing fragment, or
else will require a new rule to be defined (in which case the new rule becomes a fragment in
the library for subsequent reuse. At this point a DGDL description can be generated. In order
to determine whether the resulting game is sound automated testing of the game is performed
applying a mixture of desiderata/properties measurement, Drosophila/scenario based testing,
and a form of arguing agent competition [16]. After testing, the game can be imported to a
DGDL run-time such as the Dialogue Game Execution Platform (DGEP) [
Here, we motivate our proposed Dialogue Fragment Library by showing how an existing
dialogue game can be broken down into fragments of certain dialogue types. Our intention with
this example is to demonstrate that 1) a domain-specific dialogue game consists of more general
sets of locutions and rules; and 2) the game itself could have originally been constructed from
such fragments. For the sake of space, we will not provide the DGDL fragments themselves, but
will instead leave their specifications implicit. We use the goal-setting dialogue game ( GSDG)
specified in [ 11]. Goal-setting is a common technique used in behaviour change, where one
or more coaches (experts) engage with a patient to help them towards an achievable goal (e.g.
a number of daily exercise minutes) [
The basic structure of GSDG is a simple asymmetric persuasion game between only the lead coach and the patient. If we were to generalise this persuasion game, with 1 (“player 1”) taking the place of lead coach and 2 taking the place of the patient, we have the following structure (where the steps are followed in sequence, unless stated): SR2 SR3 SR4 SR5 SR6 SR7 SR8 1. 1: where 2 can either outright accept a proposal from 1, or demand justification. If a justification is forthcoming, 2 is obliged to accept the original proposal. We henceforth refer to this simple protocol as
(Simple Persuasion Dialogue).
A key principle of goal-setting is that the patient must take ownership of the goal so they are
motivated to achieve it [
and a new dialogue with ′′ as the new topic.
is available as an alternative to following a are then available. 1 using a move efectively triggers • A game based on • Following a move from 1, 2 can begin an • If the does not lead to termination, proceed to step 2 (efectively starting a new - albeit without the initial move)
The final aspect of GSDG is another coach being able to challenge the lead coach’s proposed goal. This challenge difers slightly from that available to the patient (via an move) in that the ℎ move is available to the other coach if and only if the patient themselves expresses uncertainty (via an move). This is intended to model the behaviour observed in [11] where a second coach can challenge ’s proposed goal as a way of helping the patient reflect on whether they wish to propose an alternative. Adding third-party challenging is relatively trivial insofar as its use does not mandate any new locution types, but it does have an impact on the overall structure of possible dialogues. Following a ℎ move, 1 is permitted to immediately revise the challenged goal, efectively triggering a new dialogue with the revised goal as the topic: 1. 1: 2. 2: 3. P3: 4. 1: 5. 2: 6. 1: () () → step 3 or 4 () → terminates Challenge(g) (, ) → step 5 Revise(g, g′) (if 3 moved ℎ (, ′) → step 6 () → terminates ( ′, ′′) → step 2 ( ′) → terminates
- with an additional participant 3 move from 2, 3 can perform a ℎ move, after which 1 can , and the dialogue continues per the existing rules of -
The aim of this worked example has been to show that an existing domain-specific dialogue game, GSDG can be deconstructed into fragments consisting of more general dialogical interactions and that, in principle, the game could have been constructed from those fragments in the first place. Underpinning GSDG are three distinct elements: a simple persuasion game ( ), a simple negotiation exchange ( ), and third-party challenging. Individually, none of these are intrinsically linked to goal-setting; it is in combining them we arrive at a dialogue game that models the theoretical behaviour of goal-setting.
We’ve sketched out how the DGDL can form the central scafold for a declarative approach to game development that builds upon and exploits much previous work. Key questions remain regarding the degree to which we’ve explored the possible space of dialogue games, how well the DGDL supports complete exploration of that space, and how many rules and behaviours have been encoded into DGDL expressions. It remains unclear to what degree existing rules can be recombined automatically, but we are committed to the idea that we should be learning from, and building upon, the lessons from existing dialogues games. It’s also unclear to what degree automated testing of new games can be sound and exhaustive. However, for the first time, it appears that the key pieces to enable an advance in dialogue game design, construction, testing, and deployment are in place, potentially enabling wider exploitation of this approach to dialogue research within the wider conversational AI agenda,. [6] P. McBurney, D. Hitchcock, and S. Parsons. The eightfold way of deliberation dialogue.
International Journal of Intelligent Systems, pages 95–132, 2007. [7] P. McBurney, S. Parsons, and M. Wooldridge. Desiderata for agent argumentation protocols.
Proceedings of the First AAMAS, pages 402–409, 2002. [8] A. Ravenscroft. Promoting thinking and conceptual change with digital dialogue games.
Computer Assisted Learning, 23(6):453–465, 2007. [9] C. Reed, T. Norman, and N. Jennings. Negotiating the semantics of agent communication languages. Computational Intelligence, 18(2):229–252, 2002. [10] D. Robertson. Lightweight coordination calculus for agent systems: Retrospective and prospective. In Declarative Agent Languages and Technologies IX. DALT 2011., volume 7169 of Lecture Notes in Computer Science. Springer, Berlin, Heidelberg, 2012. [11] Mark Snaith, Dominic de Franco, Tessa Beinema, Harm op den Akker, and Alison Pease.
A dialogue game for multi-party goal-seting in health coaching. In Proceedings of the 7th International Conference on Computational Models of Argument (COMMA 2018), pages 337–344, Warsaw, Poland, 2018. [12] D. N. Walton and E. C. W. Krabbe. Commitment in Dialogue. SUNY series in Logic and
Language. State University of New York Press, 1995. [13] S. Wells. Supporting argumentation schemes in argumentative dialogue games. Studies in
Logic, Grammar and Rhetoric (SLGR), 36(1):171–191, 2014. [14] S. Wells. The open argumentation platform (OAPL). In Proceedings of Computational Models of Argument. (COMMA 2020), Frontiers in Artifical Intelligence, pages 465–476. IOS Press, 2020. [15] S. Wells and C. Reed. A drosophila for computational dialectics. In Proceedings of the Fourth International Joint Conference on Autonomous Agents & Multi Agent Systems (AAMAS 2005), 2005. [16] S. Wells and C. Reed. Towards an arguing agents competition: Architectural considerations.
In Proceedings of the 8th International Workshop on Computational Models of Natural Argument (CMNA8), 2008. [17] S. Wells and C. Reed. A domain specific language for describing diverse systems of dialogue.
Journal of Applied Logic, 10(4):309–329, 2012. [18] N. Wirth. What can we do about the unnecessary diversity of notation for syntactic definitions? Communications of the ACM, 20(11):822–823, 1977. [19] J. Woods and D. N. Walton. Petito principii. Synthese, 31:107–128, 1977. [20] J. Woods and D. N. Walton. Arresting circles in formal dialogues. Journal Of Philosophical
Logic, 7:73–90, 1978. [21] J. Woods and D. N. Walton. Question-begging and cumulativeness in dialectical games.
Nous, 16:585–605, 1982. [22] T. Yuan. Human Computer Debate, A Computational Dialectics Approach. PhD thesis, Leeds
Metropolitan University, 2004. [23] T. Yuan and S. Wells. Protocl: Specifying dialogue games using uml and ocl. In F. Grasso, N. Green, and C. Reed, editors, Thirteenth International Workshop on Computational Models of Natural Argument (CMNA13), pages 74–85, 2013.