We present a rule specification language called Ceptre, intended to enable rapid prototyping for experimental game mechanics, especially in domains that depend on procedural generation and multi-agent simulation. Ceptre can be viewed as an explication of a new methodology for understanding games based on linear logic, a formal logic concerned with resource usage. We present a correspondence between gameplay and proof search in linear logic, building on prior work on generating narratives. In Ceptre, we introduce the ability to add interactivity selectively into a generative model, enabling inspection of intermediate states for debugging and exploration as well as a means of play. We claim that this methodology can support game designers and researchers in designing, anaylzing, and debugging the core systems of their work in generative, multi-agent gameplay. To support this claim, we provide two case studies implemented in Ceptre, one from interactive narrative and one from a strategy-like domain. Introduction Today, game designers and developers have a wealth of tools available for creating executable prototypes. Freelyavailable engines such as Twine, Unity, PuzzleScript, and Inform 7 provide carefully-crafted interfaces to creating different subdomains of games. On the other hand, to invent interesting, novel mechanics in any of these tools typically requires the use of ill-specified, general purpose languages: in Twine, manipulating state requires dipping into JavaScript; in Unity, specifying any interactive behavior requires learning a language such as C# or JavaScript; Inform 7 contains its own general-purpose imperative, functional, and logic programming languages; and PuzzleScript simply prevents the author from going outside the well-specified 2D tile grid mechanisms. The concept of operational logics (Mateas and WardripFruin 2009), the underlying substrate of meaningful statechange operations atop which mechanics are built, was recently proposed as a missing but critical component of game design and analysis. In most prototyping tools, there is a Copyright c © 2015, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved. fixed operational logic (e.g. tile grids and layers in PuzzleScript, or text command-based navigation of a space in Inform 7) atop which the designer may be inventive in terms of rules and appearance, but all rules must be formed out of entities that mean something in the given operational logic (or use a much more complex language to subvert that default logic). We lack good specification tools for inventing new operational logics, or combining elements from several. In particular, many novel systems of play arise from the investigation of interactive storytelling (Mateas and Stern 2003), multi-agent social interaction (McCoy et al. 2010), and procedurally generated behavior (Hartsook et al. 2011), and no existing tools make it especially straightforward for a novice developer to codify and reason about those systems. Ceptre is a proposal for an operational-logic-agnostic specification language that may form the basis of an accessible front-end tool. It is based on a tradition of logical frameworks (Harper, Honsell, and Plotkin 1993), which use logical formulas to represent the rules of a system (a specification). Then proof search may be used to simulate execution, answer queries, and perform analysis of the specification. In Ceptre, we specify games, generative systems, and narratives with similar payoff. Our logic of choice for representing games is linear logic (Girard 1987), unique among logics in its ability to model state change and actions without the need for a frame rule or other axiomatization of inertia for predicates that do not change in an action. Using linear logic to specify a space of play closely resembles planning approaches. Planning has been used extensively to study games, especially in the interactive storytelling domain (Mateas and Stern 2003; Porteous, Cavazza, and Charles 2010; Medler and Magerko 2006) but also as a general mechanic description language (Zook and Riedl 2014). In contrast to this work, we position Ceptre as unique among game description languages in its combination of (a) direct correspondence to a pre-existing logic and proof theory, providing a portable and robust foundation for reasoning about games, and (b) use as a native authoring language, rather than as a library or auxiliary tool. On the other hand, unlike prior executable description languages (e.g. (Dormans 2011; Osborn, Grow, and Mateas 2013)), we retain the planning-like ability to specify generalized rule schema that apply in a multi-agent setting, allowing for causal analysis of event sequences. These statements Proceedings, The Eleventh AAAI Conference on Artificial Intelligence and Interactive Digital Entertainment (AIIDE-15)

Ceptre: A Language for Modeling Generative Interactive Systems.

While higher-order pattern unification for the λΠ-calculus is decidable and unique unifiers exists, we face several challenges in practice: 1) the pattern fragment itself is too restrictive for many applications; this is typically addressed by solving sub-problems which satisfy the pattern restriction eagerly but delay solving sub-problems which are non-patterns until we have accumulated more information. This leads to a dynamic pattern unification algorithm. 2) Many systems implement λΠΣ calculus and hence the known pattern unification algorithms for λΠ are too restrictive.

In this paper, we present a constraint-based unification algorithm for λΠΣ-calculus which solves a richer class of patterns than currently possible; in particular it takes into account type isomorphisms to translate unification problems containing Σ-types into problems only involving Π-types. We prove correctness of our algorithm and discuss its application.

/pdf/higher-order-dynamic-pattern-unification-for-dependent-types-1hjha5gkoj.pdf

Higher-order dynamic pattern unification for dependent types and records

A logical framework and its implementation should serve as a flexible tool for specifying, simulating, and reasoning about formal systems. When the formal systems we are interested in exhibit state and concurrency, however, existing logical frameworks fall short of this goal. Logical frameworks based on a rewriting interpretation of substructural logics, ordered and linear logic in particular, can help. To this end, this dissertation introduces and demonstrates four methodologies for developing and using substructural logical frameworks for specifying and reasoning about stateful and concurrent systems. 
Structural focalization is a synthesis of ideas from Andreoli's focused sequent calculi and Watkins's hereditary substitution. We can use structural focalization to take a logic and define a restricted form of derivations, the focused derivations, that form the basis of a logical framework. We apply this methodology to define SLS, a logical framework for sbubstructural lbogical sbpecifications, as a fragment of ordered linear lax logic. 
Logical correspondence is a methodology for relating and inter-deriving different styles of programming language specification in SLS. The styles we connect range from very high-level specification styles like natural semantics, which do not fully specify the control structure of programs, to low-level specification styles like destination-passing, which provide detailed control over concurrency and control flow. We apply this methodology to systematically synthesize a low-level destination-passing semantics for a Mini-ML language extended with stateful and concurrent primitives. The specification is mostly high-level except for the relatively few rules that actually deal with concurrency. 
Linear logical approximation is a methodology for deriving program analyses by performing abstract analysis on the SLS encoding of the language's operational semantics. We demonstrate this methodology by deriving a control flow analysis and an alias analysis from suitable programming language specifications. 
Generative invariants are a powerful generalization of both context-free grammars and LF's regular worlds that allow us to express invariants of SLS specifications in SLS. We show that generative invariants can form the basis of progress-and-preservation-style reasoning about programming languages encoded in SLS.

Substructural logical specifications

In this paper, we explore the use of Linear Logic programming for story generation. We use the language Celf to represent narrative knowledge, and its own querying mechanism to generate story instances, through a number of proof terms. Each proof term obtained is used, through a resource-flow analysis, to build a directed graph where nodes are narrative actions and edges represent inferred causality relationships. Such graphs represent narrative plots structured by narrative causality. This approach is a candidate technique for narrative generation which unifies declarative representations and generation via query and deduction mechanisms.

/pdf/linear-logic-programming-for-narrative-generation-3sc70uejv6.pdf

Linear Logic Programming for Narrative Generation

Linear logic programming languages have been identified in prior work as viable for specifying stories and analyzing their causal structure. We investigate the use of such a language for specifying story worlds, or settings where generalized narrative actions have uniform effects (not specific to a particular set of characters or setting elements), which may create emergent behavior through feedback loops. We show a sizable example of a story world specified in the language Celf and discuss its interpretation as a story-generating program, a simulation, and an interactive narrative. Further, we show that the causal analysis tools available by virtue of using a proof-theoretic language for specification can assist the author in reasoning about the structure and consequences of emergent stories.

Generative Story Worlds as Linear Logic Programs

CLF (Concurrent LF) [CPWW02a] is a logical framework for specifying and implementing deductive and concurrent systems from areas, such as programming language theory, security protocol analysis, process algebras, and logics. Celf is an implementation of the CLF type theory that extends the LF type theory by linear types to support representation of state and a monad to support representation of concurrency. It relies on the judgments-as-types methodology for specification and the interpretation of CLF signatures as concurrent logic programs [LPPW05] for experimentation. Celf is written in Standard ML and compiles with MLton, MLKit, and SML/NJ. The source code and a collection of examples are available from http://www.twelf.org/~celf .

Celf --- A Logical Framework for Deductive and Concurrent Systems (System Description)

Logic programming languages, type inference algorithms, and automated theorem provers are all examples of systems that rely on unification. If the unification problem has to deal with logic variables at higher type (functional type), we speak of higher-order unification [4]. Higher-order unification is in general undecidable, but it can be turned decidable, if appropriately restricted to a fragment. For example, Miller’s pattern fragment characterizes a first-order fragment, for which unification is decidable [5]. As substructural type theories are becoming more prevalent, for example, in systems that need to represent consumable resources, higher-order unification algorithms need to deal with logic variables at linear or affine type. Linear and affine type theories, for example, refine intuitionistic type theory in the following way: Besides intuitionistic assumptions, which can be referred to an arbitrary number of times, linear and affine assumptions are treated as resources that must be referred to exactly once and at most once, respectively. As substructural type theories are mere refinements, one might erroneously suspect that the standard intuitionistic pattern unification algorithm can be applied to this setting directly. This, unfortunately, is not the case. Consider the following two linear unification problems, where we write, as usual, for linear application and juxtaposition for intuitionistic application.

Pattern Unification for the Lambda Calculus with Linear and Affine Types

Induction on Concurrent Terms

We define the pattern fragment for higher-order unification problems in linear and affine type theory and give a deterministic unification algorithm that computes most general unifiers.

Anders Schack-Nielsen

Papers

Celf --- A Logical Framework for Deductive and Concurrent Systems (System Description)

Pattern Unification for the Lambda Calculus with Linear and Affine Types

Induction on Concurrent Terms

Pattern Unification for the Lambda Calculus with Linear and Affine Types