March 6, 2008

EP 7.3: Brutus

by Noah Wardrip-Fruin · , 6:28 am

Given its name, it is probably no surprise that Selmer Bringsjord and David Ferrucci’s Brutus system specializes in stories of betrayal. Here is the beginning of one:

Dave Striver loved the university. He loved its ivy-covered clocktowers, its ancient and sturdy brick, and its sun-splashed verdant greens and eager youth. He also loved the fact that the university is free of the stark unforgiving trials of the business world — only this isn’t a fact: academia has its own tests, and some are as merciless as any in the marketplace. A prime example is the dissertation defense: to earn the PhD, to become a doctor, one must pass an oral examination on one’s dissertation. This was a test Professort Edward Hart enjoyed giving. (Bringsjord and Ferrucci, 2000, 199–200)

The story continues for roughly another half page. Hart is a member of Striver’s dissertation committee, and when they meet in Hart’s book-lined office he promises to sign Striver’s dissertation at the defense. The story says that Hart’s “eyes were bright and trustful, and his bearing paternal.” But at the defense Hart actually refuses to sign, and Striver fails. The story ends with an unexpected twist: we see Hart sitting in his office, “saddened by Dave’s failure,” and trying to think how he could help him. We realize that Hart has lied to himself about his betrayal.

Such examples demonstrate that, in terms of audience experience — both of language and structural coherence — Brutus’s output goes far beyond any of the story generation systems I have considered thus far. And, in contrast with Minstrel, the creators of Brutus haven’t presented its stories as the result of an accurate simulation of human creativity. Instead, they have argued at length that such simulation is impossible, devoting much of their book Artificial Intelligence and Literary Creativity (2000) to this issue. From Bringsjord and Ferrucci’s point of view, the challenge of story generation is to develop a system through clever engineering, rather than through emulation of the mechanisms of human creativity. As they put it, “we cheerfully operate under the belief that human (literary) creativity is beyond computation — and yet strive to craft the appearance of creativity from suitably configured computation” (149, original emphasis). And their faith in the power of this approach is great. In particular, they talk of the Brutus architecture eventually producing “an artificial storyteller able to compete against inspired authors” (152) or even able to “find employment at the expense of a human writer” (xxiv). This certainly sounds like a very successful “appearance of creativity.”

Such statements have also proven a successful formulation for producing press coverage of Brutus. Journalists have written many stories that position Brutus as a potential competitor to human authors. The New York Times, for example, has published more than one story about Bringsjord and Ferrucci’s work from this angle (e.g., Mirapaul, 1999; Akst, 2004). No other story generator of the era attracted this level of public attention. In a particularly fitting confluence, one of the Times stories is actually about a literal competition between Brutus and a group of human authors. This competition, held on a website run by Dan Hurley, asked web visitors to judge five stories: four newly-written stories by human authors and one product of the Brutus1 implementation of the Brutus architecture. As the Times explains:

Visitors to the site can vote on which story they think was created by a computer. Hurley and his staff picked the four human-penned pieces after reviewing online entries from 390 contributors, who had a month to labor over their prose. Bringsjord said Brutus.1 spit out its story in seconds. (Mirapaul, 1999)

Another Times story reports the outcome of the competition: “only 25 percent of the 2,000 voters picked out the computer-generated story” (Sommers, 1999). It’s an impressive result, but the simple existence of the competition, especially given its coverage in the U.S.’s paper of record, is even more telling. There is the impression — created by a combination of the literary quality of Brutus’s output, the rhetorical stance of Brutus’s designers, and the press coverage generated — that a major milestone has been passed. The key to this advance, we’re told, is that the creators of Brutus have put their finger on something essential that storytelling systems need. As Bringsjord and Ferrucci put it, “a good artificial storyteller must be in command of the immemorial themes that drive both belletristic and formulaic fiction. . . . such themes must be cast in terms that an AI can digest and process; that is, these themes must be, for want of a better word, mathematized” (81, original emphasis).

Mathematized betrayal

Bringsjord and Ferrucci see a need for “mathematizing” literary themes because they approach story generation from the neat AI perspective. As they write: “we approach story generation through logic; in more specific terms, this means that we conceive of story generation as theorem proving” (42). To my knowledge, Bringsjord and Ferrucci are the first to create a major story generation system that employs the tools of theorem-proving AI. Specifically, Brutus is built using a logic-programming system called FLEX, which is based on the programming language Prolog.

The first step in Brutus’s story generation procedure is to instantiate a theme. As mentioned earlier, the literary theme that is the focus of the Brutus system is betrayal. In order to help readers understand the system, Bringsjord and Ferrucci provide some “actual FLEX code” that is the mathematized expression of betrayal they have authored (table 7.2). This specifies two characters, the Betrayor and Betrayed. The Betrayed has some goal that the Betrayor promises to support, and the Betrayed believes the promise. But it is a lie, because the Betrayor actually has an evil plan to thwart the Betrayed’s goal.6

relation betrayal_p
if Evil is some goal whose plan is an EvilPlan

and whose agent is a Betrayor
and Saying is included in the EvilPlan
and Saying is some say
and Thwarting is included in the EvilPlan
and Thwarting is some thwart
and Betrayeds_Goal is the prevented_goal of Thwarting
and Betrayors_Lie is some support of the Betrayeds_Goal
and Betrayed is some person

whose goal is the Betrayeds_Goal
and whose beliefs include the Betrayors_Lie

____________________________________
Table 7.2: Brutus’s Ideal Representation of Betrayal, quoted from page 173 of Artificial Intelligence and Literary Creativity (2000)

However, this is not the FLEX code used by Brutus1 — the version of Brutus that Bringsjord and Ferrucci have actually authored. Instead, they tell us, “In Brutus1, thematic instantiation captures the essential characteristics of betrayal by building the following frame” (190). This frame is shown in table 7.3. Notice that it specifies less about the relationship and character internals (it does not specify that the Betrayed believes the Betrayer’s lie, that the lie is regarding support of the Betrayed’s goal, or that the Betrayer has an evil plan) and more about the events (not only a lie, but also a location, and also an evil action).

frame betrayal is a concept
default betrayer is a person and
default betrayed is a person and
default betrayers_goal is a goal and
default betrayeds_goal is a goal and
default betrayers_lie is a statement and
default betrayers_location is a place and
default betrayers_evil_action is a action.

____________________________________
Table 7.3: Brutus1’s Implemented Representation of Betrayal, quoted from page 190 of Bringsjord and Ferrucci (2000)

Both of these theme instantiations, despite their differences, may remind one of Minstrel’s planning advice themes. After all, PATs are also hand-authored specifications of structures of relationship and event, which are meant to capture the immemorial themes that drive literature. But, as I will describe, in the end the formal theme definitions of Brutus and Minstrel end up playing quite different roles in the two systems.

Creating a story

In order to tell a story about betrayal, Brutus needs to fill the roles of Betrayer and Betrayed. One might imagine the two characters being created on the fly, using some method akin to those of Universe or Tale-Spin — but constrained to ensure that each character will be appropriate for their role. Or, alternately, one might imagine a situation in which the system begins with a set of automatically-generated characters. The system might then begin storytelling by choosing a character from this set with a goal that can be thwarted. It might then make that character the Betrayed, and then either create or assign a character to be the Betrayer.

But neither of these is what happens. Instead, the system searches its “domain knowledge-base” — its collection of authored data — to see if two characters exist that already meet the criteria for the relationship of betrayal. That is to say, it looks for a character who already has what it takes to be the Betrayer (a goal, and a lie, and an evil action), and who takes part in appropriate events for betrayal, and where those events also include a character who has what it takes to be the Betrayed.

The only way for the characters to get into the knowledge base is for them to be hand-created by authors. This means that someone must write the FLEX code to represent a character who meets the criteria for being the Betrayer and to represent another who meets the criteria for being the Betrayed. However, Bringsjord and Ferrucci assure readers this sort of thing will change in a future version of the system:

In Brutus1, thematic instantiation requires that the domain knowledge-base include many of the specific objects required to instantiate the theme. In future versions of Brutus the process of thematic instantiation will use general domain concepts as a basis for generating specific objects so that less domain knowledge is required as input into the story generation process. (191)

How this will happen is not specified.

Generating a plot

Once Brutus has instantiated a theme and found the appropriate characters in memory, the next stage is to develop the specifics of the plot. Bringsjord and Ferrucci characterize the plot development process as taking place through “simulation” — but it is a very different form of simulation than, say, that which animates Minstrel’s model of authorial creativity.

Bringsjord and Ferrucci tell us that the simulation begins with the fact that each character has a goal and a plan. They write, “Once a character is set in motion, the character attempts to achieve its goal by executing the actions associated with the goal’s plan” (177). So, for example, here is Hart’s evil plan:

instance evilGoal is a goal
agent is hart and
plan is {lie101, refuse_to_sign101} and
success is status of strivers_defense is failed.

(178)

Each action, such as “refuse_to_sign101,” has preconditions. These prevent it from being executed except in the right circumstances. We can assume, for example, that “refuse_to_sign101” only will execute when the aforementioned “strivers_defense” is the event taking place at that moment of the simulation. Here is the representation for that event:

instance strivers_defense is a thesis_defense
thesis is strivers_thesis and
where is university_of_rome and
examined is striver and
committee is {hart,meter,rogers,walken} and
status is scheduled.

(175)

In some ways this is similar to the Universe model of authoring, in which hand-coded plot fragments are strung together by the system’s processes. But Universe chooses which plot fragment to use next based on a continually-shifting set of characters and goals. Depending on the circumstances, different characters can play different roles in the same plot fragment. On the other hand, for Brutus — or at least Brutus1 — the specific characters are already encoded into each event. Also, each character must already have encoded into their plan the actions that they will take when a particular event is active. And, as one learns on page 176 of Bringsjord and Ferrucci’s book, even these actions are not generic, but each exist in a version hand-authored for the appropriate character.

Given this, while the Brutus model of plot development can be characterized as a simulation, it’s not a simulation that could lead to unpredictable outcomes. Rather, producing any plot requires hand-creating the specific characters, the specific plans, and the specific instances of events that will allow the theorem prover to produce a match on its logical pattern. The plot mechanisms that are at work in Brutus, then, suffer from the opposite problem of those produced by Minstrel. Rather than out of control variation, they seem to produce no variation at all. For a story generation system, this form of theorem proving is a very odd choice for the dominant operational logic.

Structuring a story

Once the story’s events have been activated, and then added to memory, these events must be structured for their presentation to an audience. For this purpose Brutus uses a “story grammar” — a type of description of story structure first developed in the analysis of stories, rather than their generation.7 While Bringsjord and Ferrucci don’t provide the grammar they authored for the story quoted at the outset of this section, they do provide this “simplified” fragment:

1. Story → Setting + Goals_and_plans + Betrayers_evil_action + betrayed’s_state

2. Goals_and_plans → Betrayed’s_goal + Betrayers_promise + Betrayers_goal

3. Setting → setting_description(betrayal_location,pov,betrayed)

4. Betrayed’s_goal → personal_goal_sentence(betrayed)

5. Betrayers_goal → personal_goal_sentence(betrayer)

6. Betrayers_promise → promise_description(betrayer,betrayed)

7. Betrayers_evil_action → narrate_action(betrayers_evil_action)

(196)

It may not be immediately obvious how to read such a grammar. The rules are relatively simple. Each line defines something (on the left side of the arrow) that can be “rewritten” as something else (on the right side). If something is uppercase, then it is a “non-terminal” — there is another rule for rewriting it. If something is lowercase, a “terminal,” then it will be sent to the Brutus natural language generation grammars (which will be discussed later in this chapter). The items in parenthesis at the end of some terminals are arguments passed to the NLG grammars.

This grammar is remarkably concrete. Most story grammars operate at a much higher level of abstraction. For example, a common terminal for many story grammars is a generic “event” — rather than a “personal_goal_sentence.” And many story grammars contain items that may be repeated, or which are optional — whereas each item in this grammar appears exactly once. This greater concreteness addresses one of the commonly-voiced concerns about story grammars: that, while a fine tool for analysis, they don’t provide the necessary structure for generating well-formed stories. On the other hand, this grammar is so tightly structured that it is nearly a sentence-level outline.

Here is a story generated from this grammar:

Dave loves the university of Rome. He loves the studious youth, ivy-covered clocktowers and its sturdy brick. Dave wanted to graduate. Prof. Hart told Dave, “I will sign your thesis at your defense.” Prof. Hart actually intends to thwart Dave’s plans to graduate. After Dave completed his defense and the chairman of Dave’s committee asked Prof. Hart to sign Dave’s thesis, Prof. Hart refused to sign. Dave was crushed. (197)

Notice that the first two sentence of this story have a very similar structure to the first two of the story quoted at the beginning of this section: “Dave Striver loved the university. He loved its ivy-covered clocktowers, its ancient and sturdy brick, and its sun-splashed verdant greens and eager youth.” In both cases, they were generated by the terminal of the third item in the grammar above: “setting_description” — but operating with slightly different elements. Later in this chapter I will discuss the specifics of how Brutus generates literary texts for its audience, the area in which it implements some of its most interesting ideas for digital media authoring.

Brutus and creativity

A close look at what authors create for a Brutus story, as begun above, undermines some of the very rhetoric that has produced interest in the Brutus project. This is especially true of the rhetoric around its “appearance of creativity.” A good summary of this rhetoric comes in Bringsjord and Ferrucci’s sixth chapter:

The main goal behind the development of Brutus is to produce real, working systems which, by virtue of their internal logical structure (which implements the architecture) and implementation specifics, allow for generated stories to be sufficiently distant from initial, internal knowledge representations (called, again, creative distance) and to vary independently along different dimensions (called wide variability). (161)

As earlier chapters discuss, systems such as Tale-Spin and Minstrel — at some level — threaten to spin out of control. The unpredictable interactions between their components mean that their authors can be quite surprised by the outcomes (and not always pleasantly, as “mis-spun” stories attest). Bringsjord and Ferrucci usefully give a name to the gap in predictability that arises from these highly variable component interactions: “creative distance.” We might not choose to call this gap creativity, but it is a gap that certainly exists for these systems.

On the other hand, it is also apparent that Brutus — or at least Brutus1 — has almost no gap, almost none of this unpredictability, and almost none of the distance from “initial, internal knowledge representations” that Bringsjord and Ferrucci discuss. Let me clarify this. Bringsjord and Ferrucci write:

If we look “under the hood” of a program and find it trivial for a human to transform the program’s initial data to the program’s output, we are less likely to consider the program creative. If however, we, as humans, would find it challenging to map the program’s initial data to a creative artifact (like a well-written and interesting story), then we are more likely to consider the program creative. We call the perceived difference between a program’s initial data and its output creative distance. (161)

It is not clear what level and type of human difficulty would be required to make a program appear “creative.” One may wonder, for example, if all statistical techniques (as soon as they operate on non-trivial amount of data) by definition appear creative — given that it would be nearly impossible for a human to carry out the calculations involved. But, regardless, in the case of Brutus it is clear that even a cursory view of its model of authoring (such as that performed above) easily allows a person to see what characters will take what actions during what story events — as well as what sentences in what order will be used to communicate the story.

With all this so explicitly specified, what possible space could there be for “creative distance” in Brutus? Bringsjord and Ferrucci don’t answer this directly, instead focusing on the criterion of variability. They write: “Significant storytelling and literary variability can be achieved by altering, adding, or selecting different story, paragraph, or LAGs. Content variability can, of course, be achieved by creating or modifying thematic relations, behavioral rules, and domain knowledge” (197). In other words, one or more elements of an explicitly encoded Brutus story could be replaced with other, equally explicitly encoded elements — and, unsurprisingly, this would generate a different (though far from unpredictable) result.

The author of Brutus’s stories

If one accepts Brutus as research into the creation of reusable story components, which can be interestingly combined with elements at other levels of abstraction, I can actually see much of value in it — though this requires disposing entirely with the rhetoric of “creativity.” However, taking this perspective brings up another issue. In descriptions of Brutus one particular level of component is privileged: the mathematized description of literary themes. But thinking back over the different components presented for the Brutus1 story outlined in Bringsjord and Ferrucci’s book, it becomes apparent that this is the one unnecessary component. It is not used in creating characters, relationships, events, or language. All the elements of the story are defined independently of the formal account of betrayal. It is used only to match elements already in the knowledge base, which could be found by any number of other procedures (e.g., choosing a character at random, who will already be specified in all the events for his story, which in turn will already specify the other characters involved). In other words, in Brutus the system’s encoded knowledge about the structure of literary themes makes no contribution to “creative distance.” Instead, this distance is entirely created — to whatever extent it exists — by the shape of the pieces into which Bringsjord and Ferrucci decided to cut the story for which the formalized account would produce the logical match.

This, in turn, might make us uncomfortable with reports, such as that from The New York Times, that “Bringsjord said Brutus.1 spit out its story in seconds.” In fact, Bringsjord and Ferrucci spent much longer than a few seconds authoring exactly the elements, and the versions of those elements, and the order of those elements, that would make up the story “Brutus1” produced.

Frankly, presenting the Brutus1 system as a story author simply seems unwarranted, having examined its operations. With this in mind, the Brutus project takes on the rough shape of a literary hoax — though I suspect the system’s authors are among those who were taken in by the illusion. In this regard it is a memorable example of the misconceptions to which even the technically knowledgeable can fall prey without an approach for critical reading of computational systems.

It is my hope that a version of “software studies” (by this name, or another) can become pervasive enough that, in the future, those writing for The New York Times will be less easily fooled. This is especially important for software systems with broader social impact, but I believe the relevant phenomena are particularly legible in examples such as Brutus — which are leant readability by our familiarity with storytelling and ability to perform common-sense evaluations of claims related to it.

In the Brutus illusion we may also see the lingering impact of traditional views of AI. Even though Bringsjord and Ferrucci no longer claim that their system simulates human creative behavior, they still can’t escape trying to create the impression that the system is the creative actor — that its stories are artworks, and the system is the author of these stories. Of course, this is not a necessary perspective. One could view the Brutus1 system as an artwork, and its stories as particular surface outputs from the artwork, and Bringsjord and Ferrucci as the authors of the artwork. This view of system authoring would doubtless produce less press attention, but this is often the case with accurate reports of software systems, and it would not make this perspective more difficult to hold. More substantially, this would require a different conceptual approach to AI — such as that which produced the Terminal Time project.

Notes

6Note that, given the story example above, it must be possible for the Betrayer to be consciously unaware of this evil plan, even after executing it.

7As described in the previous chapter’s section on Minstrel, the genealogy of story grammars is usually traced back to Vladimir Propp’s Morphology of the Folktale.