Chris
April 21, 2015
150

# 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

3. 3
Parable of the Polygons (Vi Hart and Nicky Case)

4. 4
Causal Understanding

5. 5
Outline:

!
1. Background: forms of narrative play

2. Extended example: Shakespeare World

3. Ongoing work: playable speciﬁcations

6. 6
1. FORMS OF NARRATIVE PLAY

7. 7
branching stories

8. 8
branching stories
Twine (twinery.org)

9. 9

10. 10
Sam Kabo Ashwell: “Standard Patterns in Choice-Based
Games"

11. 11
Sam Kabo Ashwell: “Standard Patterns in Choice-Based
Games"

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!

13. 13
What’s the structure of a stateful story?

14. 14

15. 15
JRWRIR\HU
RSHQFDELQHW
JRWRGHQ
NH\ IR\HU
ZLQ
GHQ
Petri Net

16. 16
JRWRIR\HU
RSHQFDELQHW
JRWRGHQ
NH\ IR\HU
ZLQ
GHQ
permanent

states
Petri Net

17. 17
JRWRIR\HU
RSHQFDELQHW
JRWRGHQ
NH\ IR\HU
ZLQ
GHQ
Petri Net

18. 18
JRWRIR\HU
RSHQFDELQHW
JRWRGHQ
NH\ IR\HU
ZLQ
GHQ
Petri Net

19. 19
JRWRIR\HU
RSHQFDELQHW
JRWRGHQ
NH\ IR\HU
ZLQ
GHQ
Petri Net

20. 20
JRWRIR\HU
RSHQFDELQHW
JRWRGHQ
NH\ IR\HU
ZLQ
GHQ
choice between

actions
Petri Net

21. 21
JRWRIR\HU
RSHQFDELQHW
JRWRGHQ
NH\ IR\HU
ZLQ
GHQ
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

28. 28
another form of narrative play

29. 29
greet

insult

compliment

gossip

reject

...
social verbs: social state:
knowledge

sentiment

emotional state

personality

beliefs

goals

30. 30
aka

“character-driven”

“emergent”

“combinatorial”
COMPOSITIONAL NARRATIVE

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

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

35. 35
II. EXTENDED EXAMPLE:

SHAKESPEAREAN TRAGEDY

STORY WORLD

36. 36
at

has

anger

affection

depressed

World state:

37. 37
insult:
➡️

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.

43. 43
compliment:
➡️

44. 44
➡️
travel_toward:

45. 45
murder:
!
!
➡️

46. 46
loot:
➡️

47. 47

48. 48
initial state

49. 49

50. 50

51. Program Execution
51
A -o B
Δ, A → Δ, B
Δ = arbitrary context of resources A1, …, An

52. 52
6 6¶
6R6¶

U6R6¶

Q

/RJLF3URJUDP
LQLWLDOVWDWH
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

54. 54
x0 : p(romeo,juliet)
x1 : q
x2 : r
=

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

60. Nondeterminism
60
A -o B
Δ, B
A -o C
Δ, C
Δ, A

61. 61
A -o B C -o D

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

69. 69
program traces are!
causally-structured stories

70. 70
Outline:

!
1. Background: forms of narrative play

2. Extended example: Shakespeare World

3. Ongoing work: playable speciﬁcations

71. 71
3. ONGOING WORK:

PLAYABLE SPECIFICATIONS

72. 72
accessible tools for making

games

73. 73
PuzzleScript

74. 74

75. 75

76. 76
Horizontal [ > Player | No Obstacle ] ->
[ PlayerBodyH | PlayerHead1 ] sfx2

77. 77
Idea:

Replace nondeterminism in the system

with human interactor choice.

78. 78
move/up/red : move up * at L (player_head red)
!
move/up : move up * at L (player_head C) * next C C'
* adj L up L' * empty L' -o
-o at L player_body * at L' (player_head L’).
!
move/r : move right * at L (player_head C) * adj L right L'
* empty L'
-o at L player_body * at L' (player_head lime).
!
move/l : move left * at L (player_head C) * adj L left L'
* empty L'
-o at L player_body * at L' (player_head lime).
!
% gravity
gravity : at L (player_head C) * adj L down L' * empty L'
-o at L player_body * at L' (player_head C).

79. 79
move/up/red : move up * at L (player_head red)
!
move/up : move up * at L (player_head C) * next C C'
* adj L up L' * empty L' -o
-o at L player_body * at L' (player_head L’).
!
move/r : move right * at L (player_head C) * adj L right L'
* empty L'
-o at L player_body * at L' (player_head lime).
!
move/l : move left * at L (player_head C) * adj L left L'
* empty L'
-o at L player_body * at L' (player_head lime).
!
% gravity
gravity : at L (player_head C) * adj L down L' * empty L'
-o at L player_body * at L' (player_head C).

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

82. 82
ONGOING/FUTURE WORK

83. 83
language implementation
https://github.com/chrisamaphone/interactive-lp

84. 84
emergent systems have lots of corner cases

=>

bugs!

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))

88. 88
CONCLUSION

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
7KH6LPV
/LQHDU
/RJLF
3HWUL1HWV
&/)&HOI
SURJUDPPLQJ
ODQJXDJH
7KHVLV
VWDWHPHQW
5HVHDUFK
4XHVWLRQ
(YLGHQFHIRU
GHVLJQWRROSDUW
RIWKHVLV
VWDWHPHQW
UHDVRQLQJ
WRROV
EXJV
&HSWUH
VHQVLQJ
SUHGLFDWHV
3X]]OH6FULSW
(YLGHQFHIRU
SURWRW\SLQJDQG
DQDO\VLVSDUWRI
WKHVLVVWDWHPHQW
3DUW
3DUW
3DUW
&/)
WUDFHVSURRIV
3URRIVDV
VWRULHV
6KDNHVSHDUH
ZRUOG
/RJLF
3URJUDPPLQJ
&RQFXUUHQW
VWUXFWXUH
Thanks!

92. Extra Slides
92

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?