To practice working above sentence level I have tried encoding a fable (The Ant and the Dove) in the right format. Not too tricky after a bit of thought: you need to first rephrase the sentences as a set of simple propositions using the primitives, and then translation is not too hard. Also, replace the picture producers (ie noun groups) by a set of entities that can be easily referred to by id value throughout.

Here is the original fable:

The Ant and the Dove

AN ANT went to the bank of a river to quench its thirst, and being carried away by the rush of the stream, was on the point of drowning. A Dove sitting on a tree overhanging the water plucked a leaf and let it fall into the stream close to her. The Ant climbed onto it and floated in safety to the bank. Shortly afterwards a birdcatcher came and stood under the tree, and laid his lime-twigs for the Dove, which sat in the branches. The Ant, perceiving his design, stung him in the foot. In pain the birdcatcher threw down the twigs, and the noise made the Dove take wing.

One good turn deserves another

And, after some (minor) simplification, this is the fable in conceptual dependency format – a list of Lisp/Scheme expressions with the semantic primitives and their arguments:

((pp (class being)
     (label "ant")
     (id 0)
     (features animal)
     (type "ant"))
 (pp (class location) (label "river bank") (id 1))
 (pp (class location) (label "river") (id 2))
 (pp (class being)
     (label "dove")
     (id 3)
     (features animal can-fly)
     (type "dove"))
 (pp (class object)
     (label "leaf")
     (id 4)
     (features plant)
     (type "leaf"))
 (pp (class being)
     (label "bird catcher")
     (id 5)
     (features human)
     (type "human"))
 (pp (class location) (label "tree") (id 6))
 (pp (class object)
     (label "trap")
     (id 7)
     (type "trap"))
 (pp (class object)
     (label "water")
     (features liquid edible)
     (id 9))
 (thirsty (actor (pp (id 0))))
 (plan (actor (pp (id 0)))
       (object
         (ingest (actor (pp (id 0))) (object (pp (id 9))))))
 (ptrans
   (actor (pp (id 0)))
   (object (pp (id 0)))
   (to (pp (id 1))))
 (ptrans
   (actor gravity)
   (object (pp (id 0)))
   (from (pp (id 1)))
   (to (pp (id 2))))
 (loc (actor (pp (id 0))) (val (pp (id 2))))
 (loc (actor (pp (id 3))) (val (pp (id 6))))
 (loc (actor (pp (id 6)))
      (val (above (pp (id 2)))))
 (loc (actor (pp (id 4))) (val (pp (id 6))))
 (grasp (actor (pp (id 3))) (object (pp (id 4))))
 (grasp (actor (pp (id 3)))
        (object (pp (id 4)))
        (mode (tf)))
 (ptrans
   (actor gravity)
   (object (pp (id 4)))
   (from (pp (id 6)))
   (to (pp (id 2))))
 (loc (actor (pp (id 4))) (val (pp (id 2))))
 (ptrans
   (actor (pp (id 0)))
   (object (pp (id 0)))
   (from (pp (id 2)))
   (to (pp (id 4))))
 (ptrans
   (object (pp (id 4)))
   (from (pp (id 2)))
   (to (pp (id 1))))
 (ptrans
   (actor (pp (id 0)))
   (object (pp (id 0)))
   (from (pp (id 4)))
   (to (pp (id 1))))
 (like (actor (pp (id 0))) (to (pp (id 3))))
 (loc (actor (pp (id 5))) (val (pp (id 1))))
 (loc (actor (pp (id 3))) (val (pp (id 6))))
 (plan (actor (pp (id 5)))
       (object
         (grasp (actor (pp (id 5))) (object (pp (id 3))))))
 (grasp (actor (pp (id 5))) (object (pp (id 7))))
 (mtrans
   (actor (pp (id 0)))
   (object (pp (id 5)))
   (from eye)
   (to memory))
 (mloc (actor (pp (id 0)))
       (object
         (plan (actor (pp (id 5)))
               (object
                 (grasp (actor (pp (id 5))) (object (pp (id 3))))))))
 (like (actor (pp (id 0)))
       (to (pp (id 5)))
       (mode (neg)))
 (propel (actor (pp (id 0))) (to (pp (id 5))))
 (health (actor (pp (id 5))) (val 3))
 (grasp (actor (pp (id 5)))
        (object (pp (id 7)))
        (mode (tf)))
 (mtrans
   (actor (pp (id 3)))
   (object
     (grasp (actor (pp (id 5)))
            (object (pp (id 7)))
            (mode (tf))))
   (from ear)
   (to memory))
 (mloc (actor (pp (id 3)))
       (object
         (plan (actor (pp (id 5)))
               (object
                 (grasp (actor (pp (id 5))) (object (pp (id 3))))))))
 (ptrans
   (actor (pp (id 3)))
   (object (pp (id 3)))
   (from (pp (id 6)))))

The most common primitive is ptrans, which is a physical transfer, either moving or going, depending on whether the actor and the object are the same thing. Then, loc describes the location of something, and mloc is about thinking.

So, what do we do with this? The first step is to put this back into (English) prose. This is done with a program based on an old module called mumble. It takes as input a list of CD structures (as above) and puts out English sentences. Depending on the primitive and certain features of the actor and object, an appropriate verb and sentence structure is chosen. After some minor tweaking we get the following output:

The ant is thirsty. The ant plans to drink water. The ant goes to the river bank. The ant falls from the river bank into the river. The ant is in the river. The dove is in a tree. A tree is in the river. A leaf is in a tree. The dove picks up a leaf. The dove lets go of a leaf. A leaf falls from a tree into the river. A leaf is in the river. The ant goes to a leaf. A leaf goes to the river bank. The ant goes to the river bank. The ant likes the dove. The bird catcher is on the river bank. The dove is in a tree. The bird catcher plans to pick up the dove. The bird catcher picks up a trap. The ant sees the bird catcher. The ant thinks that the bird catcher plans to pick up the dove. The ant does not like the bird catcher. The ant strikes the bird catcher. The bird catcher is somewhat ill. The bird catcher lets go of a trap. The dove hears that the bird catcher lets go of a trap. The dove thinks that the bird catcher plans to pick up the dove. The dove leaves from a tree.

END

There are several ways to make this more ’natural’ and less computery. At first we need to look at definite/indefinite: we always say the ant, and the dove, as if there was only one. Ideally we would want an ant and a dove, at least until they have been mentioned once. After that we switch to the definite article to refer back to the particular animal. And pronouns would be good.

Still lots of scope for improvement!

Names are another rabbit hole, so for now I use a prefab list that I created using some on-line name generators. I have a list of more names than I need, and just pick some randomly off there. Name generation is a sideshow for later.

And, November is finished now. I don’t actually have much to show, but have done a lot of reading and thinking about what I want to do. I will quietly continue chipping away at it, and perhaps will have something working by NaNoGenMo next year. So, more like NaNoGenYear!

The central element of my project is a ‘world simulator’, in which the characters act out their desires, follow their goals, and interact in (hopefully) interesting ways, which I will then harvest to generate a story from. The core of the simulator is a planner: you feed in the characters’ goals, and they will then find a way of doing what they need to do in order to achieve them. The planning algorithm I’m using is called Goal Oriented Action Planning (GOAP), basically a back-ward chaining algorithm: Starting from the goal, you work backwards to see which actions get you to your goal. Each action has a post-condition (which would be matched to the goal), and a pre-condition (which becomes the new goal). You select an action whose post-condition matches some of the character’s goal conditions, and then see how you get there. Each action also has a cost associated with it, which allows you to choose a more efficient path in case there are several options.

I have today managed to implement a very basic version of that in Scheme. I’m using atomic conditions, but eventually will have more complicated expressions, but it is a first step. For several toy scenarioes the planner does indeed find suitable solutions, which are paths through a network of states. Adjusting this to the final world representation should not be too much of an issue.

I have resigned myself to not finishing this system by the end of the month. But I’ve made a start, and will try to get this continued throughout the year, so that I have a novel ready by NaNoGenMo 2018… On the positive side, my Scheme programming is getting better, and I have loads of ideas about what to implement over the coming year.

I think back with sentimental feelings to the days of being a student – no job, no family, but lots of spare time to work on interesting stuff like this. I think that is the real benefit of a university education: the freedom to research pet projects!

In order to make it worthwhile, I will develop the world simulator in a modular way, so that more complexity can always be added in later on. New plans or goals, new actions, or whatever else is required to make it more realistic. I might end up with a version of the Sims… but with a narrative text interface, rather than a graphical one. Let’s see how far I get.

When rendering this as a story, it might be worth looking at state changes, and possibly to add changes to emotional states as annotations to any activities that are going on, so that we can generate text like A did some action, and it filled B with anger. or A was overjoyed to see B again. – obviously, it is always better to describe emotional states indirectly where possible, but that seems to hard for now.

Given how little time I can devote to the project, I think I will have to scale it down a bit if I want to have anything ready by the end of the month. I might always try to continue working on it afterwards for the more ambitious ‘stretch goals’.

On the to-do list now is the representation of world knowledge, both the objective ’truth’ and the characters’ individual views of it. Then the world simulator/planner, and then a few basic aims. At that point I should have a simple TaleSpin working, which I can extend with more details. I would then add more aims and actions to it as I go along, and start work on the routine to generate the story from the world log, and finally the verbalisation, which will be a slightly more sophisticated clone of Mumble.

That would also make it easy to implement some of Propp’s functions: the interdiction would mean that the hero is told one of his aims is not allowed. And the interdiction-violation would mean that the hero ignores that, and keep it as an aim. Alternatively, a friend’s aim could be disallowed, and the hero would try to achieve the aim for the friend, such as acquire an object and give it to the friend.

The next step then is to annotate the narrative functions with actions and aims; for example, absentation could be an atrans of a friend to a location as an action, and the same for the hero as an aim, as the hero wants to be with their friend. There might be some conflicting aim (such as staying at home, protecting the family), but the resolution might be that the friend starts feeling sad when away from their home environment, leading to the aim of coming back home, which then achieves the hero’s aim as well.

I also need to start thinking about the World Simulator, the engine that does all the heavy lifting of producing the story content. The original idea is to take TaleSpin, but that might be a bit too simplistic. After all, it’s only really been used for short stories about Joe Bear and Irving Bird. In addition I need timestamping to keep track of where the various characters are and what they are doing, and a more sophisticated logging facility, as the simulator log will be fed into the story renderer at the end. I also need to work with multiple characters at once, so the whole setup needs to be a bit more capable than the original.

To turn the basic plot into a story, I need to turn the Proppian functions into actions. So I’m thinking of a way of annotating them with what essentially happens in each function. This can be a conceptual dependency-style structure, but possibly also using some higher level commands than just the basic primitives that Schank et al used in their work. These would later be expanded into such primitives to be fed into the language generator at the end.

I’ve also compiled an initial list of aims, which will drive what the characters will be doing. These are for example

• go to location
• go to person
• acquire object
• deliver object
• acquire information
• defeat person
• destroy object

So the Propp function departure maps onto giving the hero the aim go to location. What that location is, remains to be seen. It could be the location where a person or object can be found. Whereas reconnaissance gives the villain the aim acquire information. There will be different ways to achieve these aims, which will involve sub-aims, and hopefully enough variation to generate plenty of different stories.

Thinking about characters, I’ve been looking at emotions. Emotions will determine how characters react, though I have as yet no clue how that would work. I’ve come across a scheme by Robert Plutchik, which uses eight basic emotions, where two are paired as counterparts:

• Trust - Disgust
• Fear - Anger
• Sadness - Joy
• Surprise - Anticipation

There would be a scale (-10 to +10 or so), so an emotion item would be a list of four numbers. A character will have a basic emotional state, but would also have emotion items describing the relationship with other characters. The states are variable, so if character A is angry, and meets character B, towards whome they feel joy, then they might become less angry. Obviously a very simplistic way to model something as complicated as human emotions, but the perfect is the enemy of the good. Especially if you only have one month!

My approach will consist of various stages, and at the top level I am planning to generate a broad and abstract sequence of events that will be fleshed out in subsequent stages. I have chosen the framework of Vladimir Propp, who analysed Russian folk tales and came up with a list of 31 narrative functions, which can be grouped into four distinct sections. I’m generating a list of sections, where each section can have up to four functions, and then I pick the appropriate number of functions randomly from the list of functions for each section.

There are some constraints, so you cannot have a return unless you also had a departure beforehand. I have implemented a very simple routine which churns out sequences that fulfil their constraints. Quite primitive at the moment, but perhaps a starting point.

Some example outputs (for their meaning see the Wikipedia link above) are:

• (complicity trickery departure departure villany first-donor-func hero-reaction wedding pursuit)
  This is a bit weird, as there are two departures (but they could be different people), and after the wedding there is a pursuit, so the hero is chased away by a villain after he got married and rewarded/promoted. Strange, but perhaps leading to an interesting story!

• (interdiction trickery interdiction trickery departure departure departure first-donor-func struggle struggle transfiguration difficult-task)
  Here the hero gets a warning/command twice, and each time a villain attempts some deception. This time, three people leave (I think that needs to be cut down to single occurrence only!) and a lot of fighting is happening.

Thing is, I can imagine writing a story around those functions. The challenge is to see if the computer can do that, too. Still early days. The main concern with this whole thing is that the generated novel will either be trivial and boring, or non-sensical and incoherent. Probably even both. I am under no illusions that the final result will be worthwhile reading; but I will only find out at the end!