Combining Narratives

Extended Abstract

Keywords: Representation formalisms,

Representations of Time, Action, Events.

John McCarthy and Tom Costello

Computer Science Department Stanford University Stanford, CA 94305

            email: {jmc,costello}@cs.Stanford.EDU

Abstract

A theory is elaboration tolerant to the extent that new information can be incorporated with only simple changes. The simplest change is conjoining new information, and only conjunctive changes are considered in this paper. In general adding information to a theory should often change, rather than just enlarge, its consequences, and this requires that some of the reasoning be non-monotonic.

Our theories are narratives—accounts of sets of events, not necessarily given as sequences. A narrative is elaboration tolerant if new events, or more detail about existing events, can be added by just adding more sentences.

We propose a new version of the situation calculus which allows information to be added easily. In particular, events concurrent with already described events can be introduced without modifying the existing descriptions, and more detail of events can be added.

1 Objectives of Situation Calculus

The logical approach to AI ([McC59] and [McC89]) is to make a computer program that represents what it knows about the world in general, what it knows about the situation it is in, and also its goals all as sentences in some mathematical logical language. The program, then infers logically what action is appropriate for achieving its goal and does it. Since 1980 it has been widely known that non-monotonic inference must be included. The actions our program can perform include some that generate sentences by other means than logical inference, e.g. by observation of the world or by the use of special purpose non-logical problem solvers.

Situation calculus is an aspect of the logic approach to AI. A situation is a snapshot of the world at some instant. Situations are rich objects in that it is not possible to completely describe a situation, only to say some things about it. From facts about situations and general laws about the effects of actions and other events, it is possible to infer something about future situations. Situation calculus was first discussed in [McC63], but [MH69a] was the first widely read paper about it.

In this formalization of action in situation calculus, there are at least three kinds of problem—narrative, planning and prediction. Of these, narrative seems to be the simplest for humans. A narrative is an account of what happened. We treat it by giving some situations and some events and some facts about them and their relations. Situations in a narrative are partially ordered in time. The real situations are totally ordered^{1}, but the narrative may not include full information about this ordering. Thus the temporal relations between situations need only be described to the extent needed to describe their interactions. Situations occurring entirely in different places give the most obvious examples, but even actions by the same person in the same place may not interact as far as the inferences we draw. If we state that the traveler on certain flight reads a book and also drinks a Coca-cola, we humans don’t need to know any temporal relations between the two events unless they interact.

In situation calculus as it was originally envisaged (and has been used,) events (mainly actions) in a situation produce next situations, e.g. s′ = Result(e, s). The original theory did not envisage more than one event occurring in a situation, and it did not envisage intermediate situations in which events occur. However, rarely did people write axioms that forbade^{2} these possibilities; it’s just that no-one took advantage of them.

Our present formalism doesn’t really change the basic formalism of the situation calculus much; it just takes advantage of the fact that the original formalism allows treating concurrent events even though concurrent events were not originally supposed to be treatable in that formalism. Gelfond, Lifschitz and Rabinov [GLR91a, GLR91b] treat concurrent events in a different way from what we propose here.

1Hypothetical situations need not be totally ordered, the situation where Oswald missed Kennedy is neither in the past nor the future.

2Reiter [Rei93] did write such axioms.

In a narrative, it is not necessary that what is said to hold in a situation be a logical consequence (even non-monotonically) of what was said to hold about a previous situation and known common sense facts about the effects of events. In the first place, in stories new facts about situations are often added, e.g. “When Benjamin Franklin arrived in London it was raining”. In the second place, we can have an event like tossing a coin in which neither outcome has even a non-monotonic preference. ^{3}

In interpreting the following formalizations, we regard situations as rich objects and events as poor. In fact, we are inclined to take a deterministic view within any single narrative. In principle, every event that occurs in a situation and every fact about following situations is an inevitable consequence of the facts about the situation. Thus it is a fact about a situation that a coin is tossed and that it comes up tails. However, such facts are only occasionally consequences of the facts about the situation that we are aware of in the narrative.

2 Elaboration Tolerant Reasoning

A formalization of a phenomenon is elaboration tolerant to the extent that it permits elaborations of the description without requiring completely redoing the basis of the formalization. In particular, it would be unfortunate to have to change the predicate symbols. Ideally the elaboration is achieved by adding sentences, rather than by changing sentences. Often when we add sentences we need to use some form of nonmonotonic reasoning. This is because we often want to add information that we would previously have assumed was false. Unless we use non-monotonicity we would get inconsistency. In this paper we concentrate on the easier case when there is no need for non-monotonicity.

Natural language descriptions of phenomena seem to be more elaboration tolerant than any existing formalizations. Here are the two major kinds of elaboration tolerance that we examine in this paper.

Non-interacting Events Allowing the addition of a description of a second phenomenon that doesn’t interact with the first. In this case the conclusions that can be drawn about the combined narrative are just the conjunction of the conclusions about the component narratives. To infer the obvious consequences of events we need to assume that some other events do not occur. In this paper, a major novelty is that we do not assume that no other events occur. We only state that there are no events that would cause an event in our narrative to fail. Thus a narrative about stacking blocks will state that the only block moving actions^{4} are those mentioned. A block stacking narrative will not say that no traveling events occur. Nor will a narrative about traveling makes claims about what block stacking events happen. This allows non-interacting narratives to be consistently conjoined.

3Nevertheless, some narratives are anomalous. If we record that Junior flew to Moscow, and, in the next situation mentioned, assert that he is in Peking, a reader will feel that something has been left out.

We want to introduce a concept of a proper narrative, this is a narrative without anomalies.

The fluents holding in a new situation should be reasonable outcomes of the events that have been reported, except for those fluents which are newly asserted, e.g. that it was raining in London when Franklin arrived.

Previous proposals could not conjoin two narratives, as they either assumed that the events that happened were picked out by the result function, or they assumed that the only events that occurred were those mentioned.

Detail of Events We can add details of an event. On the airplane from Glasgow to London, Junior read a book and drank a gin and tonic. If we make the assumption that other relevant events do not happen, we can elaborate by adding new relevant event. We will the assume that just this new set of events are the events that happen. This can be achieved by the minimization of relevant occurrences. However the notion of relevant must be formalized very carefully, as is apparent when we elaborate a particular event as a sequence of smaller events. “How did he buy the Kleenex? He took it off the shelf, put it on the counter, paid the clerk and took it home.” A narrative that just mentions buying the Kleenex should not allow non-monotonic reasoning that excludes this particular elaboration. Moreover, if we elaborate in this way, we don’t want to exclude subsequent elaboration of component events, e.g. elaborating paying the clerk into offering a bill, taking the change, etc. Our formalism allows details of an event to be added by conjoining extra sentences.

3 Modifying the Situation Calculus

Formalisms such as the situation calculus of McCarthy and Hayes [MH69a], and the event calculus of Kowalski [KS94, KS97] have been used to represent and reason about a changing world c.f [Sha97]. Neither of these formalisms is exactly what is needed to represent the kind of narratives we wish to consider.

The situation calculus in its most limited version does not allow us to represent what events occur explicitly—rather every sequence of events is assumed to occur. We can specify that a particular sequence of events occurs by introducing a predicate, actual true of just the sequence of situation that occur^{5}. This is not ideal, as it forces us to decide what events happened earlier, before we name the events that happen later.

4More precisely, no other actions that would move the blocks mentioned in the narrative occur.

Other blocks might be stacked in Baghdad, if our narrative is about New York. Perhaps a theory of context, that would interpret a statement about all blocks in our narrative, as a statement about all the blocks in New York could be used here.

For this reason we use a modified situation calculus, adding a new predicate Occurs(e, s), that states what events occur. Thus, rather than the function Result(e, s) serving two purposes, stating that e occurred at s, and designating the resulting situation, we split these two functions. We keep Result(e, s), but it now only denotes the result of doing e in s when e Occurs at s. If e does not occur, then the value of this function is an arbitrary situation^{6}. This adds an event calculus style of presentation to the underlying situation calculus formalism. In particular, it allows us to specify a sequence of events, without making any claims as to what other events may have happened in the meantime.

Our Ontology of situations In the full paper we discuss our ontology of situations, and consider some ramifications of our decisions.

4 Specifying the Effects of Events

In the situation calculus it is usual to specify the effects of actions by writing effect axioms, like^{7},

∀s.Holds(Loaded, s) → Holds(Dead, Result(Shoot, s)).

If we move to a formalism that allows other events to occur between s and Result(e, s), then this way of specifying change needs to be adjusted. It is possible that something might occur in the time between s and Result(Shoot, s) that causes the event to have a different result. For this reason it seems natural to allow the preconditions, those things that hold on the left hand side, to mention properties of all times between s and Result(Shoot, s).

In previous versions of the situation calculus the preconditions for an event were always modeled as a set of fluents, namely those fluents that had to hold at s, for the event to have an effect at Result(a, s). If we allow other things to happen during an event, we cannot just specify the preconditions that must hold at the beginning of the event.

Consider a plane journey from Glasgow to London. It is necessary that the plane be in working order for the entire flight. It is also necessary to be in Glasgow at the beginning of the flight, but clearly, there is no need for this precondition to persist for the entire flight. It is necessary to have a ticket, until the airline steward takes it from you. Thus this is an example of a precondition, “having a ticket” that must hold neither just at the moment the event starts, nor for the entire duration.

5Pinto and Reiter [PR93, PR95] actually do this.

6We could choose instead to make Result a partial function, but this introduces the difficulties of partial functions.

7As is customary in Logical A.I. we write Holds(Dead, s) without saying who is dead. We can suppose the events occur in a context and lifting rules exist to make this Dead(V ictim) in an outer context. The outer context may contain further preconditions, like that shooter is not missing.

Before we consider how to represent preconditions, we recall how we represented all possible preconditions earlier. If we wish to introduce a predicate that can parameterize all effect axioms in the old-fashioned situation calculus can write ^{8},

∀a, f, g.Changes(a, f, g) =^{def} ∀s.Holds(g, s) → ¬(Holds(f , s) ≡ Holds(f , Result(a, s))

following [Cos97]. g is a predicate on fluents that encodes the preconditions. Parameterizing all effect axioms allows us to minimize effect axioms easily.

However, as we want to have preconditions that can extend over the duration of the event, we need more than one set of fluents. For this reason we allow as preconditions, two sets of fluents. The first set need only hold at the start of an event, while the others must persist for the entire event.

It might seem that this does not model preconditions that need hold for only part of the duration of the event. However, we can model these by using other defined fluents. Thus we can write that “It is necessary to have a ticket, until the airline steward takes it from you.” using a new fluent F_{1} defined by

∀s.Holds(F_{1} , s) ≡ Holds(Has(Ticket), s) ∨ Holds(Takenby(Steward, Ticket), s).

This fluent should hold for the entire duration of the flight. HoldsD(f , s, e) is a shorthand for ∀s′.s ≤ s′ < Result(e, s) → Holds(f , s′).

We can write “It is necessary that the plane be in working order for the entire flight.” using the fluent W orkingOrder,

∀s, l, l′.HoldsD(WorkingOrder, s, Fly(l, l′)) ∧ HoldsD(F_{1} , s, Fly(l, l′))) → Holds(at(l′), s)

We can add “ It is necessary to be in Glasgow at the beginning of the flight.”

∀s, l, l′.Holds(at(l), s) ∧ HoldsD(WorkingOrder, s, Fly(l, l′))∧ HoldsD(F_{1} , s, Fly(l, l′))) → Holds(at(l′), s)

Now that our preconditions are represented as two sets^{9} , rather than one, we redefine Changes as follows:

∀e, f, g, G.Changes(e, f, G, g) =^{def} ∀s.∀f_{1}.(g(f_{1}) → Holds(f_{1} , s))∧

(∀f_{1}.G(f_{1}) → HoldsD(f_{1} , s, e)) → ¬(Holds(f , s) ≡ Holds(f , Result(e, s)))

8We will slightly abuse notation and write Holds(g, s) for (∀f′.g(f′) → Holds(f′, s)), when g is a predicate on fluents.

9Here we assume that we have a fluent function ¬, such that ∀s, f.Holds(f , s) ≡ ¬Holds(¬f , s).

In the absence of the fluent function ¬, we would need four sets, two for positive fluents and two for negative fluents.

We find it useful to introduce the predicate Succeeds(e, f, s) defined as,

∀G, g.Changes(e, f, G, g) → (Holds(g, s) ∧ HoldsD(G, s, e)). (1)

Frame Axioms

We usually would write a frame axiom for a fluent, say On(A, T op(B)), block A is on the top of block B, and an action, in this case Shoot as,

∀s.Holds(On(A, B), s) ≡ Holds(On(A, B), Result(Shoot, s)).

However, since Result no longer encodes what events occurred, we need to say something like, “if no event that could change the fluent On(A, B) occurred in the interval between s and s′ and On(A, B) held at s then On(A, B) will hold at s′. It is notable that this needs the notion of Changes that we introduced above. Thus we write,

\begin{matrix}Frame Axiom : \\ ∀s, s′, f, g, G.(s ≤ s′ ∧ ∀s′′, a.s ≤ Result(a, s′′) ≤ s′ → \\ ¬(Occurs(a, s′′) ∧ Changes(a, f , G, g) ∧ Succeeds(a, s′′))) → \\ (Holds(f , s′) ≡ Holds(f , s′)) \end{matrix} (2)

This will generate all of our frame axioms if we minimize Changes, varying Succeeds and Holds, and allowing the domain to vary as in [Cos96]. We do not consider using non-monotonic reasoning to minimize Changes here, as we wish to stress other issues. Thus we explicitly axiomatize the result of the minimization, much in the same way as Reiter[Rei91] uses an explanation closure axiom and an explicit statement of what events can change what fluents.

What events occur? Before we consider combining narratives, we address a problem that arises in our new formalism, that was not present in the earlier versions of the situation calculus.

Even frame axioms like this are not enough to allow us to carry out the simple reasoning we could carry out in previous versions of the situation calculus. We also need to know that certain events do not occur.

Consider the following example of moving a block. We have the action that moves a block, but to move a block successfully it must be clear. For instance if someone else puts another block on top of the block we are moving to, then our action will fail.

Thus our only effect axiom is the following one, which states moving block a onto block c succeeds, if a and c are clear for the entire duration, and a is not equal to c.

∀s, a, b, c, e.a ≠ c ∧ e = Move(a, Top(c)) ∧ HoldsD(Clear(Top(a)), s, e)∧

Holds(On(a, Top(b)), s) ∧ HoldsD(Clear(Top(c)), s, e) → Holds(On(a, c), Result(e, s)) ∧ ¬Holds(On(a, b), Result(e, s))

For this example we need some other facts about the world, these are given in an Appendix to the full paper. We are also told that the only block that is not on the table is A, which is on B, and that the action of moving A to the top of C occurred at the situation S0.

∀a, l.Holds(On(a, l), S0 ) ≡ (a = A ∧ l = Top(B)) ∨ (a ≠ A ∧ l = Table), Occurs(Move(A, Top(C )), S0 ),

We can now write our frame axiom, which in this case is, expanding the definition of changes,

∀s, s′, a, c, e.((∀s′′, a′.e = Move(a, Top(a′)) ∧ s ≤ Result(e, s′′) < s′ →
¬(Occurs(e, s′′) ∧ a′ ≠ c ∧ Succeeds(e, On(a, Top(a′)), s′′))) ∧ s ≤ s′

→ (Holds(On(a, c), s) ≡ Holds(On(a, c), s′))

This states that a block a is on a block c in a situation s if and only a is on c in s′, so long as there is no event e, of moving moving a to T op(a′), which occurs, and is successful.

We wish to prove that Holds(On(A, C ), Result(Move(A, Top(C )), S0 )), however, we can only prove the weaker,

∀e.e = Move(A, Top(C )) ∧ HoldsD(Clear(A), s, e) ∧ HoldsD(Clear(C ), s, e) → Holds(On(A, C ), Result(e, S0 ))

Thus, we need to prove that A and C remain clear during the move action in order to show that the action is successful. To show that they remain clear we need to use our frame axiom. But, all we can prove is that the A block remains clear if there is no successful move action Move(b_{1} , Top(A)) that occurs, and whose result is before Result(Move(A, C ), S0 ). As we allow situations before S0, we can imagine that there was a move in progress that placed a block on C just after S0.

Thus we explicitly state that no action that might put something on A or C occurred in the interval, save of course the action of putting A on the top of C.

∀s, b_{1}, e.e = Move(b_{1} , Top(A)) ∧ ¬(Occurs(e, s))∧ S0 ≤ Result(e, s) < Result(Move(A, Top(C )), S0 )

∀s, b_{1}, e.e = Move(b_{1} , Top(C )) ∧ ¬(Occurs(e, s)) ∧ b_{1} ≠ A∧ S0 ≤ Result(e, s) < Result(Move(A, Top(C )), S0 )

We can now prove that Holds(On(A, C ), Result(Move(A, Top(C )), S0 )), as the above principal allows us to prove that A and C are clear for the entire interval.

We cannot prove that C remains on the Table however, as there may be events that put C on top of other blocks. These events will not make C unclear, so they do not block the action of putting A on C. To prove that C remain on the table we would need,

∀s, x.¬(Occurs(Move(C , x), s))∧ S0 ≤ Result(Move(C , x), s) ≤ Result(Move(A, C ), S0 ).

It is notable that there was no need to state that no other actions occurred. It sufficed to say that no other events occurred that might cause a precondition of an event in our narrative to fail. The notion that we need only state that certain events did not occur becomes very important if we wish to axiomatize domains in a way that will later allow them to be conjoined. In fact, the motivating property for developing this new axiomatization was to allow separate axiomatizations, that do not interfere with each other, to be conjoined. This is not possible in the old-style situation calculus, as we explicitly list the sequence of actions that occurs. It is also not possible if we state that the only events that occur are those mentioned, as is sometimes done in narrative reasoning.

The reasoning that we did was not significantly more difficult than the usual reasoning in the situation calculus. We needed to check a few more conditions, namely that blocks remained clear, but strategies, such as goal regression continue to be effective.

Events with multiple effects In the full paper we discuss how to represent events with multiple effects at possibly different times.

We now consider narratives in two domains. One concerns stacking blocks, the other a plane journey. We show that we can axiomatize these two narratives separately, but in such a way that their conjunction is consistent.

5 Glasgow, London, Moscow and New York

The object of this section is to give narratives illustrating the treatment of concurrent events in two cases. The first is when two sub-narratives do not interact, and the second is when they do. The first sub-narrative is ordinary block stacking (as discussed in many situation calculus papers), and we suppose the stacking to be done by a person called Daddy in New York.

In the second sub-narrative, the actor is named Junior, and he wants to fly from Glasgow to Moscow via London. The story is taken from earlier web-published but widely circulated manuscripts [McC92] discussing how circumscription could be used to treat an unexpected obstacle to a plan, and [McC95] how narratives should be represented.

These two sub-narratives do not interact, and thus give an example of our first goal, a treatment of non-interacting narratives that can be conjoined consistently.

Because we want to treat interacting events, we make life more complicated for Junior. If he loses his ticket, he must wire Daddy in New York for money. Daddy, who normally indulges Junior, has to interrupt his block stacking and sell a block in order to get the money to send Junior. In this part of the narrative we have an example of adding details to an event. We state the event of Daddy getting money occurs, we also give a sequence of events, Daddy stacking blocks until block3 is clear, then selling block 3 and receiving money. The sequence realizes the single event of getting money. We show that both statements are consistent with each other, and the explanation can be consistently conjoined onto the narrative that mentions only the first event.

The following uses the axiomatizations of flying and blocks-world in the Appendix of the full paper. In the text we only give those axioms that are particular to the story.

In the full paper we give axiomatizations of both the narratives where Junior loses his ticket, and contacts Daddy who sends him money, that Daddy raises by selling a block (In New York, blocks are made of Gold). Naturally Daddy has to clear the block before selling it, so the narratives interact in a non-trivial way. Narrative 1

In this narrative Junior doesn’t lose his tickets, T_{1} and T_{2} and gets to Moscow without asking for help. Daddy stacks blocks in New York. There is no interaction, and nothing is said about the time relations between the two sub-narratives.

\begin{matrix}Holds(At(Junior, Glasgow), S0 ) Occurs(Fly(Glasgow, London, T_{1} ), S0 ) \\ dest(T_{1}) = London ∧ source(T_{1}) = Glasgow ∧ Holds(Has(Junior, T_{1} ), S0 ) \\ dest(T_{2}) = Moscow ∧ source(T_{2}) = London ∧ Holds(Has(Junior, T_{2} ), S0 ) \\ Result(Fly(Glasgow, London, T_{1} ), S0 ) < S1 \end{matrix} (3)

We should be able to infer:

Holds(At(Junior, London), S1 )

To infer this we need to know that,

∀s′, e, g, G.S0 ≤ s′ < Result(Does(J , Fly(London, Moscow, T_{1} )), Has(J , T_{1} ), S0 ) → ¬(Occurs(e, s′) ∧ Changes(e, Has(J , T_{1} ), g, G) ∧ Succeeds(e, Has(J , T_{1} ), s′))

That is, no event occurs that would cause Junior to lose his ticket before he has to give it to the air-hostess. We actually state the following stronger fact, that no events that would cause Junior to no longer have a ticket occur, save of course flying from Glasgow.

\begin{matrix}∀s′, e, g, G.(e ≠ F ly(London, Glasgow, T_{1}) ∨ s′ ≠ S0) ∧ S0 ≤ s′ < S1 → \\ ¬(Occurs(e, s′) ∧ Changes(e, Has(J , T_{1} ), g, G)) \end{matrix} (4)

When Junior is in London, inertia gets us that Junior still has the ticket to Moscow. As for the ticket to London, we would infer that he does not have it as we brought up the fact that a ticket is used up when one takes the flight the ticket is for. That is certainly a part of the knowledge of anyone who travels using tickets. Thus someone who had traveled by bus would infer it about airplane travel. Indeed it could be inferred from more general principles about commerce, e.g. that a seller doesn’t want to allow the buyer to get an arbitrary number of what he has a paid for one of. However, anyone who travels has the more specific information and doesn’t need to infer it from general principles about commerce. Indeed he may never have formulated any general principles about commerce.

\begin{matrix}Occurs(Fly(London, Moscow, T_{2} ), S1 ) \\ Result(Fly(London, Moscow, T_{2} ), S1 ) < S2 \end{matrix} (5)

We wish to infer,

Holds(At(Junior, Moscow), S2 )

Again we need to know that no bad events occur, that is Junior doesn’t lose any tickets.

\begin{matrix}∀s′, e, g, G.(e ≠ F ly(London, Moscow, T_{2}) ∨ s′ ≠ S1)∧ \\ S1 ≤ s′ < S2 → ¬(Occurs(e, s′) ∧ Changes(e, Has(J , T_{2} ), g, G)) \end{matrix} (6)

We call these sentences Nar1J, that is the sentences from 3 to 6. Now we begin Daddy’s life as a block stacker. We have holds no relation between the situations S0 and S0′ and know nothing of their temporal relations. If we asserted S0 < S0′ < S1, then we could conclude that Junior still had the tickets in S0′. Also asserting S0′ = S0 would do no harm to the conclusions drawn about either sub-narrative.

\begin{matrix}Holds(At(Daddy, NY ), S0′) \\ Holds(Has(Daddy, A_{1} ), S0′) ∧ Holds(Has(Daddy, A_{2} ), S0′) \\ Holds(Has(Daddy, A_{3} ), S0′) ∧ Holds(on(A_{3} , top A_{1} ), S0′) \\ ∀b.Holds(Clear(b), S0′) ≡ b ≠ A_{1} \\ Holds(on(A_{1} , Table), S0′) ∧ Holds(on(A_{2} , Table), S0′) \\ Occurs(Does(Daddy, Move(A_{3} , Table)), S0′) \\ Result(Does(Daddy, Move(A_{3} , Table)), S0′) < S1′ \\ Occurs(Does(Daddy, Move(A_{2} , Top A_{1} )), S1′) \\ Result(Does(Daddy, Move(A_{2} , Top A_{1} )), S1′) < S2′ \\ Occurs(Does(Daddy, Move(A_{3} , Top A_{2} )), S2′) \\ Result(Does(Daddy, Move(A_{3} , Top A_{2} )), S2′) < S3′ \end{matrix} (7)

We also need to know that no other actions that would interrupt the block stacking occur.

\begin{matrix}∀s′, g, G, e.S0′ ≤ s′ ≤ S3′ ∧ (s′ ≠ S0′ ∨ e = Move(A_{3} , Table))∧ \\ (s′ ≠ S1′ ∨ e = Move(A_{2} , Top A_{1} )) ∧ (s′ ≠ S2′ ∨ e = Move(A_{3} , Top A_{2} )) → \\ ¬(Occurs(e, s′) ∧ Changes(e, On(a, b), g, G)) \end{matrix} (8)

We call the sentences from 7 to 8 Nar1D We now notice that if B is the axiomatization of blocksworld in the Appendix of the full paper, and T is the axiomatization of traveling, then

\begin{matrix}B ∧ T ∧ Nar1D ∧ Nar1J ⊧ Holds(On(A_{3} , Top A_{2} ), S3′)∧ \\ Holds(On(A_{3} , Table), S1′) ∧ Holds(At(Junior, London), S1 ) \\ ∧Holds(At(Junior, Moscow), S2 ) \end{matrix} (9)

Thus we can derive the obvious conclusions of our narrative. Narrative 2

In this narrative Junior loses the ticket and sends a telegram to Daddy asking for money. Daddy, who normally indulges Junior, sells a block and sends Junior the money, who buys a London-Moscow ticket and goes on to Moscow.

This axiomatization appears in the full paper.

Elaboration of Narratives

Suppose we are asked, “How did Junior fly from Glasgow to London?” and want to respond with facts about taking a taxi to the airport, presenting his ticket at the check-in counter, going to the gate, getting on the airplane, taking his assigned seat, etc. We can add this additional narrative with its intermediate situations, and we can throw in reading the book if we like. There is no reason to discard Occurs(Does(Junior, Fly(Glasgow, London, T_{1} )), S0 ). We merely have a redundant way of reaching the same conclusion. This is allowed in our formalism, and this property is demonstrated by the two ways in which we describe how Daddy gets the money for Junior.

However, we would like a sentence relating the more detailed narrative to the less detailed narrative, i.e. of asserting that one realizes the other. For this we will at least need narratives as objects, and this has not yet been introduced.

Note that the relation Elaborates(N2, N1), when we get around to introducing it, will not be like the relation between a subroutine call and the subroutine. N1 will not in any sense be the definition of N2. N2 could be realized in a number of ways, only one of which corresponds to N1.

Planning and Prediction

We would like to treat the circumstances of the previous narrative from the point of view of planning. In that case we need to be explicit about the consequences of actions and other events. The difference between planning and narrative is that in narrative we know that events and actions will succeed. This allows us to make assumptions we otherwise could not make. We can also assume that all the important effects of actions are mentioned. When we plan we need to show that we have taken into account all the important effects.

Let us consider the purposes of Junior and Daddy and predict what actions they will take and what the outcome will be. Of course, Junior losing the ticket will be an unpredicted event. We just throw it in, but then we should be able to predict what Junior and Daddy will subsequently do. This seems more difficult than either planning or predication.

Philosophical Considerations

Reality may be regarded as the deterministic limit of nondeterminist approximations. In what a human or robot can know about the world many events are not inevitable. In any human account, it did not have to be raining when Benjamin Franklin first arrived in London. Indeed, maybe it wasn’t. Even if the world is deterministic, any achievable description of it is nondeteterministic. Elaborations of particular narratives sometime remove some of the nondeterminism by accounting for the causes of particular events and for fluents holding in the results of these events.

Therefore, it may be worthwhile to regard the world as determinist and suppose that every event has causes whether we know them or not. Thus any particular nondeterminism is potentially eliminable.

It might be supposed that quantum mechanics vitiates these considerations, but we don’t think it requires modifications on the common sense level. Free will in a determinist world is discussed in [MH69b].

Remarks

We have always felt that the careful classification of the ways in which events can overlap is unnecessary for almost all common sense reasoning. We think this article shows it. Moreover, it is also usually unnecessary to combine concurrent events into compound events as do Gelfond, Lifschitz and Rabinov [GLR91b].

References

[Cos96] Tom Costello. Domain Formula Circumscription. under review, 1996.

[Cos97] Tom Costello. Non-monotonicity and Change. PhD thesis, Stanford University, 1997.

[GLR91a] M. Gelfond, V. Lifschitz, and A. Rabinov. What are the limitations of the situation calculus. In Working Notes: AAAI Spring Symposium Series on the Logical Formalization of Commonsense Reasoning, pages 59–69, 1991.

[GLR91b] Michael Gelfond, Vladimir Lifschitz, and Arkady Rabinov. What are the limitations of the situation calculus? In Robert Boyer, editor, Automated Reasoning: Essays in Honor of Woody Bledsoe, pages 167–179. Kluwer Academic, Dordrecht, 1991.

[KS94] R. Kowalski and F. Sadri. The situation calculus and event calculus compared. In Logic Programming - Proceedings of the 1994 International Symposium, pages 539–553, 1994.

[KS97] R. Kowalski and F. Sadri. Reconciling the Situation Calculus and Event Calculus. Journal of Logic Programming, 31:39–58, 1997.

[McC59] John McCarthy. Programs with Common Sense^{10}. In Mechanisation of Thought Processes, Proceedings of the Symposium of the National Physics Laboratory, pages 77–84, London, U.K., 1959. Her Majesty’s Stationery Office. Reprinted in McC90.

[McC63] J. McCarthy. Situations, Actions and Causal Laws. Technical Report Memo 2, Stanford University Artificial Intelligence Project, Stanford, CA, 1963.

[McC89] John McCarthy. Artificial intelligence, logic and formalizing common sense. In Richmond Thomason, editor, Philosophical Logic and Artificial Intelligence. Klüver Academic, 1989.

[McC92] John McCarthy. Overcoming an Unexpected Obstacle. Available as http://www-formal.stanford.edu/jmc/elaboration.html, 1992.

[McC95] John McCarthy. Situation Calculus with Concurrent Events and Narrative^{11}. 1995. Contents subject to change. Reference will remain.

[MH69a] J. McCarthy and P. Hayes. Some Philosophical Problems From the Standpoint of Artificial Intelligence. In D. Michie, editor, Machine Intelligence 4, pages 463–502. Edinburgh University Press, Edinburgh, UK, 1969.

[MH69b] John McCarthy and Patrick J. Hayes. Some Philosophical Problems from the Standpoint of Artificial Intelligence^{12}. In B. Meltzer and D. Michie, editors, Machine Intelligence 4, pages 463–502. Edinburgh University Press, 1969.

10http://www-formal.stanford.edu/jmc/mcc59.html 11http://www-formal.stanford.edu/jmc/narrative.html 12http://www-formal.stanford.edu/jmc/mcchay69.html

[PR93] J. Pinto and R. Reiter. Adding a time line to the situation calculus. In Second Symposium on Logical Formalizations of Commonsense Reasoning, pages 172–177, 1993.

[PR95] J. Pinto and R. Reiter. Reasoning about Time in the Situation Calculus. Annals of Mathematics and Artificial Intelligence, 14(2-4):251–268, September 1995.

[Rei91] R. Reiter. The frame problem in the situation calculus: A simple solution (sometimes) and a completeness result for goal regression. In V. Lifschitz, editor, Artificial Intelligence and Mathematical Theory of Computation, pages 359–380. Academic Press, 1991.

[Rei93] R. Reiter. Proving properties of states in the situation calculus. Artificial Intelligence, 64(2):337–351, December 1993.

[Sha97] Murray Shanahan. Solving the Frame Problem, a mathematical investigation of the common sense law of inertia. M.I.T. Press, 1997.