Chris
April 21, 2015
180

# Creating and Analyzing Playable Narratives with Linear Logic

Computational procedures afford us with a rich design space of narratives that can be explored and played in a variety of ways, and interactive narrative as a field has the potential to help humans understand complex systems of causality. But we need better tools for authoring and conceptualizing playable narratives, especially those that arise from multiple story agents acting interdependently.

I illustrate how linear logic, a general formalism with ties to
computational concurrency, can be used to encode a narrative space in such a way that we can a) run a proof search algorithm to generate different narratives, and b) analyze causal structure. I will then discuss ongoing work in developing a programming language based on linear logic, with the aim of supporting a broad range of idioms in interactive simulation and game design.

April 21, 2015

## Transcript

1. ### Creating and Analyzing! Playable Narratives! with Linear Logic Chris Martens

1 Graphics Lab, CMU April 21, 2015
2. ### Creating and Analyzing! Playable Narratives! with Linear Logic Chris Martens

2 Graphics Lab, CMU April 21, 2015

5. ### 5 Outline: ! 1. Background: forms of narrative play 2.

Extended example: Shakespeare World 3. Ongoing work: playable speciﬁcations

12. ### 12 branching stories with state foyer: (set:\$key = true) You

found a key! [[den]] ! den: (if: not \$key)[There is a cabinet here, but you can't open it.] (else: )[There's a cabinet here. [[open it]] ] [[foyer]] ! open it: yay cabinet!

Petri Net

20. ### 20 JRWRIR\HU RSHQFDELQHW JRWRGHQ NH\ IR\HU ZLQ GHQ choice between

actions Petri Net

22. ### 22 Linear Logic go_to_foyer : in_den -o in_foyer * !key.

go_to_den : in_foyer -o in_den. open_cabinet : in_den * key -o in_den * !cabinet_open.
23. ### 23 go_to_foyer : in_den -o in_foyer * !key. go_to_den :

in_foyer -o in_den. open_cabinet : in_den * key -o in_den * !cabinet_open. Linear Logic “atoms” or “(atomic) resources”
24. ### 24 go_to_foyer : in_den -o in_foyer * !key. go_to_den :

in_foyer -o in_den. open_cabinet : in_den * key -o in_den * !cabinet_open. Linear Logic “lolli:” linear implication
25. ### 25 go_to_foyer : in_den -o in_foyer * !key. go_to_den :

in_foyer -o in_den. open_cabinet : in_den * key -o in_den * !cabinet_open. Linear Logic antecedents and consequents
26. ### 26 go_to_foyer : in_den -o in_foyer * !key. go_to_den :

in_foyer -o in_den. open_cabinet : in_den * key -o in_den * !cabinet_open. Linear Logic “tensor:” resource conjunction
27. ### 27 go_to_foyer : in_den -o in_foyer * !key. go_to_den :

in_foyer -o in_den. open_cabinet : in_den * key -o in_den * !cabinet_open. Linear Logic “bang:” persistent resources

29. ### 29 greet insult compliment gossip reject ... social verbs: social

state: knowledge sentiment emotional state personality beliefs goals

31. ### 31 aka “character-driven” “emergent” “combinatorial” COMPOSITIONAL NARRATIVE One rule might

be applied several times, each in a different narrative state. ! Thus: rules must be parametric over narrative states!
32. ### 32 COMPOSITIONAL NARRATIVE Research question: How can we provide computational

support to authoring, understanding the structure of, and playing with compositional narratives?
33. ### 33 COMPOSITIONAL NARRATIVE Answer in progress: programming language(s) based on

linear logic. Research question: How can we provide computational support to authoring, understanding the structure of, and playing with compositional narratives?
34. ### 34 Outline: ! 1. Background: forms of narrative play 2.

Extended example: Shakespeare World 3. Ongoing work: playable speciﬁcations

36. ### 36 at <character> <location> has <character> <object> anger <character> <character>

affection <character> <character> depressed <character> dead <character> World state:

38. ### 38 do/insult : ! at Alice L * at Eliza

L   * anger Alice Eliza! -o ! at Alice L * at Eliza L   * anger Alice Eliza  * anger Eliza Alice   * depressed Eliza.!
39. ### 39 do/insult : ! \$at Alice L * \$at Eliza

L   * \$anger Alice Eliza! -o ! anger Eliza Alice   * depressed Eliza.! (notation: \$ for resources we want to keep)
40. ### 40 do/insult : ! \$at C L * \$at C’

L   * \$anger C C’! -o anger C’ C   * depressed C’.! for all C, C’, L
41. ### 41 do/insult : ! \$at C L * \$at C’

L   * \$anger C C’! -o anger C’ C   * depressed C’.! for all C, C’, L Logic Programming! (aka Relational Programming)
42. ### 42 Main idea of this section: Use linear logic programming

(computation = proof search) to generate narratives over a space speciﬁed by rules.

51. ### Program Execution 51 A -o B Δ, A → Δ,

B Δ = arbitrary context of resources A1, …, An
52. ### 52 6 6¶ 6R6¶  U6R6¶    Q

 /RJLF3URJUDP LQLWLDOVWDWH Program execution in CLF (Watkins et al. 2002) as realized by Celf (Schack-Nielsen & Schürmann 2008) quiescence
53. ### Program Execution 53 At the end we get: ! Δ

, the ﬁnal context ! a trace of rules applied (sequence of narrative actions, AKA story!) n

=
55. ### 55 rule : p(C,C’) * q -o s(C) x0 :

p(romeo,juliet) x1 : q x2 : r
56. ### 56 x3 : s(romeo) x2 : r x0 : p(romeo,juliet)

x1 : q x2 : r rule : p(C,C’) * q -o s(C)
57. ### 57 let x3 = rule x0 x1 … x0 :

p(romeo,juliet) x1 : q x2 : r x3 : s(romeo) x2 : r rule : p(C,C’) * q -o s(C)
58. ### 58 x3 : s(romeo) x2 : r let x3 =

rule x0 x1 … rule2 : r * s(C) -o t(C) * u
59. ### 59 let x3 = rule x0 x1 let [x4, x5]

= rule2 x2 x3 … x4 : t(romeo) x5 : u x3 : s(romeo) x2 : r rule2 : r * s(C) -o t(C) * u

Δ, C Δ, A

62. ### 62 A -o B C -o D Δ, B, C

Δ, A, D Δ, A, C
63. ### 63 A -o B C -o D Δ, B, C

Δ, A, D Δ, A, C Δ, B, D
64. ### 64 A -o B C -o D Δ, B, C

Δ, A, D Δ, A, C Δ, B, D r1 r2 r2 r1
65. ### 65 A -o B C -o D Δ, B, C

Δ, A, D Δ, A, C Δ, B, D r1 r2 r2 r1 let y1 = r1 x1 let y2 = r2 x2 in E let y2 = r2 x2 let y1 = r1 x1 in E
66. ### 66 Δ, B, C Δ, A, D Δ, A, C

Δ, B, D r1 r2 r2 r1 Concurrent Equality = let y1 = r1 x1 let y2 = r2 x2 in E let y2 = r2 x2 let y1 = r1 x1 in E
67. ### 67 y1:B y2:D r1 r2 let y2 = r2 x2

let y1 = r1 x1 in E let y1 = r1 x1 let y2 = r2 x2 in E x1:A x2:C
68. ### 68 @KEJOQHP PU>=HP¡ NKIAK¡ PKSJ¡ =JCAN @K?KILHEIAJP JQNOA¡ FQHEAP¡ 

?=LDKQOA¡ @KPN=RAH NKIAK¡ PKSJ¡  ?=LDKQOA¡ HEGAO =P =JCAN =JCAN HEGAO HEGAO HEGAO HEGAO HEGAO @K?KILHEIAJP FQHEAP¡ NKIAK¡ =P =P =P =P =P =P =P =P =P =P

70. ### 70 Outline: ! 1. Background: forms of narrative play 2.

Extended example: Shakespeare World 3. Ongoing work: playable speciﬁcations

76. ### 76 Horizontal [ > Player | No Obstacle ] ->

[ PlayerBodyH | PlayerHead1 ] sfx2

choice.

80. ### 80 CEPTRE 3 additions to the core language: ! sensing

predicates acting predicates stages
81. ### 81 targeted applications: ! 1. game design: easily combine rules

from many domains; invent new mechanics and game logics ! 2. distributed algorithms & systems: easily prototype and experiment with local rules and their global behavior

85. ### 85 Reasoning Tools ! 1. Statistical analysis of sets of

traces 2. Invariant, precondition, and postcondition checking for stages (static or dynamic) 3. Exhaustive analysis (model checking) for certain fragments of the language?
86. ### 86 Reasoning Tools ! 1. Statistical analysis of sets of

traces 2. Invariant, precondition, and postcondition checking for stages (static or dynamic) 3. Exhaustive analysis (model checking) for certain fragments of the language?
87. ### 87 Invariant Checking Example: “Whenever the player can reach a

locked door, she can also reach its key.” ! for all doors D, reachable(player,D) => reachable(player, key(D))

89. ### 89 Method: Linear logic programming + proof theory ! Results:

1. Structured narrative generation 2. Playable narratives and game sketches
90. ### 90 Takeaway: ! Programming languages based on logic can bring

rules, narrative, and code into closer alignment, which aids prototyping, testing, and reasoning of compositional simulations.
91. ### 91 Questions? 7ZLQH %UDQFKLQJ VWRU\ JUDSKV 6WDWHIXO 6WRULHV (PHUJHQW VWRU\WHOOLQJ

7KHDWULFV 3URP :HHN 7KH6LPV /LQHDU /RJLF 3HWUL1HWV &/)&HOI SURJUDPPLQJ ODQJXDJH 7KHVLV VWDWHPHQW 5HVHDUFK 4XHVWLRQ (YLGHQFHIRU GHVLJQWRROSDUW RIWKHVLV VWDWHPHQW UHDVRQLQJ WRROV EXJV &HSWUH VHQVLQJ SUHGLFDWHV 3X]]OH6FULSW (YLGHQFHIRU SURWRW\SLQJDQG DQDO\VLVSDUWRI WKHVLVVWDWHPHQW 3DUW 3DUW 3DUW &/) WUDFHVSURRIV 3URRIVDV VWRULHV 6KDNHVSHDUH ZRUOG /RJLF 3URJUDPPLQJ &RQFXUUHQW VWUXFWXUH Thanks!

93. ### 93 Open Q: ! What is the narrative structure of,

say, a classic arcade game or single-player RPG? ! Is this structure useful to a designer?
94. ### 94 Hypothesis: ! Concurrent structure of play traces will not

be all that interesting (modulo independently-acting NPCs) ! …but Petri Net structure of the rules might be: feedback loops, “orphan verbs,” resource accumulation properties, other design features (& bugs)
95. ### 95 Proof search: ! To run a query \Delta |-

B ! Seed \Delta_0 = \Delta Run to quiescence to get \Delta’ Check whether \Delta’ contains everything in B (and nothing more)
96. ### 96 So for instance I could codify endings in Shakespeare

world like: ! married A B * dead C -o ending ! then do a query for ! init -o ending ! (in fact this is what I did since Celf doesn’t support traces for goalless queries!)
97. ### 97 Tamara Participatory theatre in which participants may follow any

character when they exit a scene ! Many concurrent + reconverging scenes — concurrent structure! ! CLF as dramaturgy tool?