The Implementation of the Temporal Portion of the Discourse

Grammar
LRE 61-062 [D.2.Temporal]
December 1994
Summary
Title The Implementation of the Temporal Portion of the Discourse Grammar
Project reference LRE 61-062
Project Title Towards a Declarative Theory of Discourse
Authors Claire Grover, Janet Hitzeman, Marc Moens
Document ID D.2.Temporal
WP Discourse Representation
Version 1.0
Status Final Report
Date December 1994
Location Edinburgh

Content This deliverable describes implementation work which uses and extends the ale
system, focussing on the work pertaining to temporal phenomena. The grammar developed
is an implementation of the analyses developed in work packages A and B with the additional
techniques for reducing ambiguity described in this document.

i
Contents
1 Introduction 1
2 Constraints on narrative continuations 2
3 An HPSG implementation of a discourse grammar 5
3.1 The algorithm : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 7
4 A description of the code 10
4.1 The Narrative Rule : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 10
4.2 The Elaboration Rule : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 21
4.3 Additions to the sentence grammar : : : : : : : : : : : : : : : : : : : : : : : : 25
4.3.1 Temporal expressions : : : : : : : : : : : : : : : : : : : : : : : : : : : 25
4.3.2 Temporal nps : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 27
4.3.3 The role of temporal expressions : : : : : : : : : : : : : : : : : : : : : 28
4.3.4 Aspect : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 30
4.3.5 Elliptical clauses : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 32
4.3.6 Punctuation : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 34
5 Evaluation 35
5.1 The test suite : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 35
5.2 Results : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 37
5.2.1 Tests for the sentence grammar : : : : : : : : : : : : : : : : : : : : : : 37
5.2.2 Tests for the temporal discourse grammar : : : : : : : : : : : : : : : : 38
A Tables listing constraints on narrative continuations 41
B Listing of Temporal Discourse Grammar 48

ii
1 Introduction
The purpose of the research in work package D is to make explicit the representation of dis-
course information and operations over the discourse grammar that is implicit in the results
of work packages A and B, Discourse Analysis and Discourse Representation. This deliver-
able reports on our computational implementation of the theoretical research into temporal
phenomena discussed in the previous deliverables as well as algorithms for reducing ambigu-
ity described in this deliverable. The feature structures and rules used in the D.2.General
deliverable are the ones described in detail here and the linguistic motivation for the analyses
described here can be found in the A+ and B deliverables and in Section 2 of this deliverable.
The goals of the temporal component were to yield a detailed representation of the temporal
structure of the discourse, taking into account the e ect of tense, aspect and temporal expres-
sions while at the same time minimising unnecessary ambiguity in the temporal structure.
The method combines a constraint-based approach with an approach based on preferences:
we exploit the hpsg type hierarchy and uni cation to arrive at a temporal structure using
constraints placed on that structure by tense, aspect, rhetorical structure and temporal ex-
pressions, and we use the temporal centering preferences described by [Kameyama et al., 1993]
to rate the possible temporal structures and choose the best among them.
The starting point for this work was Scha and Polanyi's discourse grammar (Scha & Polanyi
1988; Prust et al 1994). For the implementation we extended the hpsg grammar [Pollard and
Sag, 1994] which Gerald Penn and Bob Carpenter rst encoded in Carpenter's ale [Carpenter,
1993]. This deliverable will focus on our temporal processing algorithm, and in particular on
our analysis of narrative progression, rhetorical structure, perfects and temporal expressions.
Section 2 describes a series of constraints and preferences that, in order to reduce ambiguity,
we make use of in determining the temporal/rhetorical structure of discourse. Section 3
gives a sketch of the hpsg implementation, and section 4 gives a detailed description of the
code. Section 5 describes the test suite we have developed for evaluating this component.
Appendix A contains tables which describe the constraints on narrative continuation, and
Appendix B contains the listing of the temporal portion of the grammar.

1
2 Constraints on narrative continuations
Probably the best known algorithm for tracking narrative progression is that of Hinrichs [1986],
which formalises the apparent default that an event will occur just after a preceding event,
while a state will overlap with a preceding event. This algorithm gives the correct results in
examples such as the following:
(1) John entered the room. Mary stood up.
(2) John entered the room. Mary was seated behind the desk.
In (1) the event of Mary's standing is understood to occur just after John enters the room,
while in (2) the state in which Mary is seated is understood to overlap with the event of
John's entering the room.
However, if there is a rhetorical relationship between two eventualities such as causation, elab-
oration or enablement, the temporal defaults can be overridden, as in the following examples:
(3) a. John fell. Mary pushed him.
b. Local builders constructed the Ford St. Bridge. They used 3 tons of bricks.
In (3a) there is a causal relationship between Mary's pushing John and his falling, and the
second event is understood to precede the rst. In (3b), the second sentence is an elaboration
of the rst, and they therefore refer to simultaneous (and, in fact, nondistinct) events rather
than to two sequential events.
It has been suggested that only world knowledge allows one to detect that the default is being
overridden here. For example, Lascarides & Asher (1991) suggest that general knowledge
postulates (in the case of (3a): that a pushing can cause a falling) can be invoked to generate
the backward movement reading.
The problem for practical systems is twofold. We might assume that in the case of narrative
Hinrichs' algorithm is the default, but each time the default is applied we need to check all
our available world knowledge to see whether there isn't a world knowledge postulate which
might be overriding this assumption. This clearly would make the processing of text a very
expensive operation.
An alternative is to assume that the temporal ordering between events in two consecutive
simple past tense sentences can be any of the four possibilities (just after, precede, simultane-
ous and overlap). But then the resulting temporal structures will be highly ambiguous even
in small discourses, and sometimes this ambiguity is unwarranted. Consider:
(4) Mary stared at John. He gave her back her slice of pizza
Here, it would appear, only one reading is possible, i.e. the one where John gave Mary her
slice of pizza just after she stared or started to stare at him. It would be undesirable for the
temporal processing mechanism to postulate an ambiguity in this case.
Of course, sometimes it is possible to take advantage of certain cue words which either indicate
or constrain the rhetorical relation. For example, in (5) the order of the events is understood

2
to be the reverse of that in (1) due to the cue word because which signals a causal relationship
between the events:
(5) John entered the room because Mary stood up.
As Kehler (1994) points out, if forward movement of time is considered a default with consecu-
tive event sentences, then the use of \because" in (5) should cause a temporal clash|whereas
it is perfectly felicitous. Temporal expressions such as at noon and the previous Thursday
can have a similar e ect: they too can override the default temporal relations and place con-
straints on tense. In (6), for example, the default interpretation would be that John's being
in Detroit overlaps with his being in Boston, but the phrase the previous Thursday overrides
this, giving the interpretation that John's being in Detroit precedes his being in Boston:
(6) John was in Boston. The previous Thursday he was in Detroit.
This suggests that the use of the tenses does not specify a temporal relation between events in
themselves, but that the narration relation in (1) gives a forward movement of time and the
causal relation in (5) and the presence of the temporal adverbial in (6) results in a backward
movement in time.
The possibilities for rhetorical relations (whether something is narration, or elaboration, or
a causal relation) can be further constrained by aspect. For example, a state can elaborate
another state or an event:
(7) a. Mary was tired. She was exhausted.
b. Mary built a dog house. It was a labour of love.
But an event can only elaborate another event, as in (8):
(8) a. Mary built a dog house. She used two tons of bricks.
b. Mary was tired/working hard. ?She built a dog house.
For the eventive second sentence of (8b) to be an elaboration of the rst sentence, it must
occur in a stative form|for example as a progressive (i.e., She was building a dog house).
Because of considerations like these, our aim in the implementation work was to treat tense,
aspect, cue words and rhetorical relations as mutually constraining, with more speci c infor-
mation such as explicit cue words having higher priority than less speci c information such
as tense. The main advantage of this approach is that it yields temporal structures without
having to rely on detailed world knowledge postulates. World knowledge does come into the
picture, but in the form of semantic patterns between words. These patterns are easier to
provide than are the detailed world knowledge postulates required in some other approaches,
and result in similar and sometimes more precise temporal structures with less processing
overhead.
The semantic patterns are invoked in particular for processing stretches of discourse of more
than two sentences. Although tense can provide a further constraint on the temporal structure
of such discourses, it can also add a further ambiguity. Consider (9):

3
(9) Sam rang the bell. He had lost the key.
Clearly, the event described by the past perfect sentence must precede the event described by
the rst, simple past sentence. However, if a third sentence is added, an ambiguity results.
Consider the following possible continuations of (9):
(10) a. ...Hannah opened the door.
b. ...It fell through a hole in his pocket.
The temporal relation between these continuations and the portion of earlier text they attach
to is constrained along the lines sketched before. The problem here is determining which
thread in the previous story they continue; (10a) continues the thread in which Sam rings the
bell, but (10b) continues the thread in which Sam loses the key.
A further ambiguity is that when the third sentence is past perfect it may be a continuation
of a preceding thread or the start of a new thread itself. Consider:
(11) a. Sam rang the bell. He had lost the key. It had fallen through a hole in his pocket.
b. John got to work late. He had left the house at 8. He had eaten a big breakfast.
In (a) the third sentence continues the thread about losing the key; in (b) the third starts a
new thread.1
Table 1 lists the possible temporal relations between the eventualities described by two con-
secutive sentences, where the rst sentence (S1 ) may have any tense and aspect and the
second sentence (S2 ) expresses a simple past event. For example, if a simple past eventive
sentence follows a simple past eventive sentence the second event can be understood to occur
just after the rst, to precede the rst or it can be simultaneous with the rst (an elaboration
relation), but the two events cannot overlap. The constraints when S2 has various other tense
and aspect are shown in Appendix A.
For the problem with multi-sentence discourses, and the \threads" that sentences continue,
we use an implementation of temporal centering [Kameyama et al., 1993]. This is a technique
similar to the type of centering used for nominal anaphora [Sidner, 1983, Grosz et al., 1983].
Centering assumes that discourse understanding requires some notion of \aboutness." While
nominal centering assumes there is one object that the current discourse is \about," temporal
centering assumes that there is one thread that the discourse is currently following, and that,
in addition to tense and aspect constraints, there is a preference for a new utterance to
continue a thread that is semantically related to it and a preference to continue the current
thread rather than switching to another thread. Kameyama et al. con rmed these preferences
when testing their ideas on the Brown corpus.
As an example of how the \semantic relatedness" of an utterance to previous threads is
determined, consider the example below:
1
We will not discuss the additional problem that if the nal sentence in (11b) is the end of the text, the text
is probably ill-formed. This is because a well-formed text should not leave threads \dangling" or un nished.
This is probably also the reason for the ill-formedness of the well-known example Max poured a cup of co ee.
He had entered the room.

4
 S1 S2 Relation Example
just-after Mary pushed John. He fell.
past event past event precede John fell, Mary pushed him.
overlap no
simult I assembled the desk myself. The drawers only took me
ten minutes.
just-after Mary stared at John. He gave her back her slice of pizza.
past activity past event precede no
overlap Mary stared at John. He gave her back her slice of pizza.
simult no
just-after no
past state past event precede no
overlap Mary was angry. She pushed John.
simult no
just-after Sam had arrived at the house. He rang the bell.
past perf event past event precede Sam arrived at the house. He had lost the key. He rang
the bell.
overlap no
simult Mary had pushed John. She pushed him hard.
just-after John had eaten oranges. He reached for a napkin.
past perf activity past event precede no
overlap no
simult no
just-after no
past perf state past event precede no
overlap Martha discovered the broken lock. Someone had been
in the garage. They rearranged the tools.
simult no

Table 1. Possible relations when S2 expresses a simple past event.

(12) Sam arrived at the house at eight. He had put on his new suit. Sue opened the
door.
The diculty in this example is determining whether the third sentence continues the thread
begun by the rst or second sentence. Using the semantic relationships we have stored we
know that a house has a door, and through that semantic link between the rst and third sen-
tences we prefer to connect the third sentence to the thread begun by the rst. The approach
to representing semantic relationships we take is one used by Morris & Hirst [1991] wherein
the words in the lexicon are each associated with each other and given a rating according to
how semantically \close" they are. We thus avoid relying on high-level inferences and very
speci c world knowledge postulates, our goal being to determine the temporal structure as
much as possible prior to the application of higher-level inferences.

3 An HPSG implementation of a discourse grammar

Following Prust et al (1994), our model of discourse consists of units called Discourse Con-
stituent Units (dcus) which are related by various temporal and rhetorical relations. For the
purpose of this paper a basic dcu can be thought of as representing a sentence, and complex

5
dcus are built up from basic and complex dcus.
In our ale implementation, a dcu contains the following features for temporal information:
cue word: Cues to rhetorical structure, e.g., \because."
v and np list: Contains discourse referents found in this dcu, and is used to compare the
NPs of the current dcu with those in previous threads, in order to rate the semantic
\closeness" of the dcu to each thread.
psoa index: Contains the semantic aspect (event, state, activity). We have extended the
Penn & Carpenter implementation of the hpsg grammar so that semantic aspect is
calculated compositionally (and stored here).
rhet reln: The relation between this dcu and a previous one. Lexical items and phrases
such as cue words (stored in cue word) a ect the value of this slot.
temp center: Used for temporal centering; Keeps track of the thread currently being fol-
lowed (since there is a preference for continuing the current thread) and all the threads
that have been constructed so far in the discourse.
fwd center: Existing threads
bkwd center: The thread currently being followed
temp expr relns: Stores the semantic interpretation of temporal expressions associated
with this dcu.
temp relns: Stores the temporal relations between the eventualities in the discourse.
tempfoc: The most recent event in the current thread which a subsequent eventuality may
elaborate upon (be simultaneous with), overlap, come just after or precede.
tenasp: Keeps track of the tense and syntactic aspect of the dcu (if the dcu is simple).
tense: past, pres, fut
aspect: simple, perf, prog, perf prog

To allow the above-mentioned types of information to mutually constrain each other, we

employ a hierarchy of rhetorical and temporal relations (illustrated in Figure 1), using the
ale system in such a way that clues such as tense and cue words work together to reduce
the number of possible temporal structures. This approach improves upon earlier work on
discourse structure such as [Lascarides and Asher, 1991] and [Kehler, 1994] in reducing the
number of possible ambiguities; it is also more precise than Hinrichs' approach in that it takes
into account ways in which the apparent defaults can be overridden.
Tense, aspect and rhetorical relations a ect the value of the rhet reln type that expresses
the relationship between two dcus. Cue words are lexically marked according to what rhetor-
ical relation they specify, and this relation is passed on to the dcu. Tense and semantic aspect
also contribute to the value of rhet reln. Explicit relation markers such as cue words and
temporal relations must be consistent and take priority over indicators such as tense and as-
pect. For example, sentence (13) will be ruled out because the cue phrase as a result con icts
with the temporal expression ten minutes earlier:
6
 rhet

just_before overlaps simultaneous precedes no_rhet_reln

sequences causes background elaboration results reverse_sequence contrast list enumeration

Figure 1. The type hierarchy used for constraints.

(13) #Mary pushed John and as a result ten minutes earlier John fell.
On the other hand, if temporal expressions indicate an overlap relation and cue words indicate
a background relation, these contributions are consistent and the rhet reln type will contain
a background value (the more speci c value of the two).

3.1 The algorithm

The algorithm used for calculating the temporal structure of a discourse can be summarised
as follows. It consists of two parts, the constraint-based portion and the preference-based
portion:

1. The possible temporal/rhetorical relations are constrained.

(a) If there is a temporal expression, it determines the temporal relationship of the
new dcu to the previous ones, and defaults are ignored.
(b) Lexical items such as cue words in uence the value of the rhet reln type (See
Figure 1).
(c) If steps (a) and (b) attempt to place con icting values in the rhet reln slot, the
parse will fail.
(d) If there is no temporal expression or cue phrase tense and semantic aspect also in-
uence the value of the rhet reln type (See Table 1), so that rhetorical relations,
tense and aspect constrain each other.
2. If more than one possibility exists, semantic preferences are used to choose between the
possibilities.
(a) A \semantic distance" rating between the new dcu and each previous thread is
determined. (If there are no existing threads a new thread is started.)
(b) If the thread currently being followed is among the highest rated threads, this
thread is continued. (This corresponds to temporal centering's preference to con-
tinue the current thread.)
(c) If not, the dcu may continue any of the highest rated threads, and each of these
solutions is generated.

7
Charts such as Table 1 provide the observations we use to ll in the value of the rhet reln.
Those observations are summarised below. In what follows, the event variable associated with
dcu is e :
i i

 e2 can overlap with e1 if

{ dcu2 describes a state, or
{ dcu1 does not describe an activity and dcu2 describes an activity, or
{ dcu1 describes an atelic and dcu2 describes an activity.
 e2 can occur just-after the tempfoc of e1 if
{ dcu2 describes a simple tense event, or
{ dcu1's tempfoc is an event and dcu2 is simple-tense atelic, or
{ dcu1's tempfoc is complex event/activity and dcu2 is complex event, or
{ dcu1's tempfoc is a complex event and dcu2 is a complex state.
 e2 can precede e1 if
{ dcu2 describes an event, or
{ dcu1 describes an event and dcu2 describes a past perfect stative.
 e2 can elaborate on e1 if
{ dcu1 describes an event, or
{ dcu1 describes an activity and dcu2 describes an atelic, or
{ dcu1 and dcu2 describe states.
Using this algorithm, we can precisely identify the rhetorical and temporal relations when
cue words to rhetorical structure are present, as in (14):
(14) John fell (e1) because Mary pushed him (e2 ).
temp relns: e2 precedes e1
We can also narrow the possibilities when no cue word is present by using constraints based
on observations of tense and aspect interactions such as those shown in Table 1. For example,
if dcu1 's tempfoc represents an activity sentence and dcu2 a simple past sentence, then in
spite of the lack of rhetorical cues we know that e2 is just-after e1 , as in (15):
(15) Mary stared at John (e1 ). He gave her back her slice of pizza (e2 ).
temp relns: e2 just-after e1
Also, when several structures are possible we can narrow the possibilities by using preferences,
as in the examples below:
(16) Sam arrived at the house at eight. He had lost the key.
a. ...He rang the bell.
b. ...It fell through a hole in his pocket.
8
Both continuations can attach to either the thread in which Sam arrives at the house or
the thread in which Sam loses the key. However, the use of the np the bell in (a) links it
semantically to the np the house in the rst thread, so semantic preferences indicate that
this is the best thread to attach to. There are no strong semantic links between (b) and the
previous threads (unless pocket and key are related, which would give us the correct result),
so the two attachment possibilities are rated equally. In this case, the preference is to attach
to the current thread, so (b) is correctly determined to continue the thread in which Sam
loses the key. The temp relns are shown below:
(17) Sam arrived at the house at eight (e1 ). He had lost the key (e2).
a. ...He rang the bell (e3).
temp relns: e2 precedes e1, e3 just-after e1
b. ...It fell through his pocket (e3 ).
0

temp relns: e2 precedes e1, e3 just-after e2

0

9
4 A description of the code
4.1 The Narrative Rule
We have a single binary rule for building narratives, although in some sense the rule is
equivalent to a number of distinct rules since there are several de nitions of the goal statements
calculate_tstuff and form_new_threads. This is the goal statement that does most of the
work in calculating the temporal relations and the temporal foci. The rule is as follows:

10
(18) narrative rule
(dcu_narr,
content:Plist,
context:(backgr:Cset,
c_inds:Ci),
v_and_np_list:NPs,
phonetic_form:Phon,
temp_center:NewTCenter,
temp_relns:Tr,
temp_expr_relns:TEr,
tempfoc:[Tf],
rhet_reln:Rhet,
rhet_rule:narrative,
schema:Sch,
tenasp:Ta)
===>
cat> (dcu,Dcu1,
content:Plist1,
context:(backgr:Cset1,
c_inds:Ci1),
v_and_np_list:NPs1,
phonetic_form:Phon1,
temp_center:TCenter,
temp_relns:Tr1,
temp_expr_relns:TEr1),
cat> (dcu_basic,Dcu2,
content:Plist2,
context:(backgr:Cset2,
c_inds:Ci2),
cue_word:Cue,
v_and_np_list:NPs2,
phonetic_form:Phon2,
rhet_reln:Rhet,
schema:Sch,
temp_relns:Tr2,
temp_expr_relns:(TEr2,[(hd_tloc:(effect_on_threads:Effect),
tl_tf:Tf)|_])),
goal> append_lists(Phon1,Phon2,Phon),
goal> union(Cset1,Cset2,Cset),
goal> append_lists(NPs1,NPs2,NPs),
goal> equal3(Ci,Ci1,Ci2),
goal> calculate_tstuff(Dcu1,Dcu2,Tf,Reln,Rhet,Effect,Cue,TCenter,NewTCenter),
goal> append_lists(Plist1,Plist2,Plist),
goal> append_lists(TEr1,TEr2,TEr),
goal> append_lists(Tr1,Tr2,Tr3),
goal> append_lists(Tr3,Reln,Tr).

This rule combines two dcus (Dcu1 and Dcu2) into a single parent dcu. Dealing with the
simpler aspects of the rule rst, the value of phon on the mother (Phon) is the result of
appending the phon value of the second daughter (Phon2) to the phon value of the rst
daughter (Phon1) and, similarly, the contextjbackgr value of the mother is the union
of the contextjbackgr values of the daughter (goal> union(Cset1,Cset2,Cset)). The

11
goal equal3(Ci,Ci1,Ci2) simply uni es the contextual indices part of context on all three
nodes. The goal append_lists(NPs1,NPs2,NPs) creates a list of the NPs in a thread to be
used for semantic preference analysis.
The goal calculate_tstuff and the nal four append_lists goals establish the values for
temp relns, temp expr relns and content on the mother|i.e. they instantiate the vari-
ables Tr, TEr and Plist. calculate_tstuff nds the temporal relation between the two
daughter dcus (the variable Reln) by using semantic preferences if necessary and by keeping
within the constraints enforced by tense, aspect, rhetorical relations and temporal expressions,
and determines the new tempfoc (Tf) and the new temporal center (NewTCenter). The rst
append_lists goal after calculate_tstuff adds the content of Dcu2 to the content of the
portion of the discourse already processed. The three nal append_lists goals create a list
of all temporal relations found so far in processing and stores this value in the temp relns
slot of the mother, and create a list of all the additional constraints on the temporal relations
given by temporal expressions, storing this value in the temp expr relns slot of the mother.
There are two calculate_tstuff clauses: One applies if the new dcu can be interpreted
preceding or occurring just after the tempfoc, and one which applies if the dcu can be inter-
preted as overlapping with the tempfoc. These rules apply within the constraints shown in
the tables in Appendix A or in cases in which the constraints are overridden by a rhetorical
cue word or a temporal expression. In cases in which more than one temporal order is possible
he rst rule applies preference techniques.
The rst calculate_tstuff rule is shown below:
calculate_tstuff((Dcu1,tempfoc:[(Tf1)]),
Dcu2,NewTempFoc,Relns,Rhet,Effect,Cue,
(bkwd_center:Bkwd,fwd_center:Threads),
(fwd_center:NewThreads,
bkwd_center:[Dcu2|Thread])) if
%% Separate the current thread from the list of previous threads
remove(Bkwd,Threads,PrevThreads),
%% Are the criteria met for attaching to the current thread?
same_thread_attachment_possible(Effect,Dcu2,Rhet,Tf1,
SameThreadPoss,Bkwd,PossThreads1),
%% Are the criteria met for attaching to a previous thread?
prev_thread_attachment_possible(Effect,Dcu2,Rhet,PrevThreadPoss),
append_threads(PrevThreadPoss,PossThreads1,PrevThreads,PossThreads),
%% One of these sets of criteria must have been met or rule fails
xor(SameThreadPoss,PrevThreadPoss),
%% Determine which is the best of the possible threads to attach to
semantic_ratings(PossThreads,Dcu2,Cue,Bkwd,Thread),
%% Attach Dcu2 to the appropriate thread or create new thread
form_new_threads(SameThreadPoss,PrevThreadPoss,
Bkwd,Thread,Relns,Rhet,Effect,Dcu1,Dcu2,Cue,
PrevThreads,NewThreads,NewTempFoc).

When this rule is triggered, Dcu1 holds the tempfoc (Tf1) and the complete list of threads
as they have been determined so far in the processing of the discourse (Threads). According
12
to the Kameyama et al data, there is a preference for attaching to the current thread, so,
after determining which thread is currently being followed by means of the remove clause we
determine whether it is possible to attach to the current thread under the constraints given by
the tables in Appendix A (again allowing for temporal expressions and cue words to override
these constraints). This is done with the same_thread_attachment_possible clause shown
below:
same_thread_attachment_possible(Effect,Dcu2,just_before,Tf1,plus,X,[X]) if
criteria1(Effect,Dcu2,Tf1),!.
same_thread_attachment_possible(_,_,_,_,minus,_,[]) if true.

same_thread_attachment_possible makes use of the criteria described in the following

clauses:
criteria1(Effect,_,_) if
boundp(Effect),
consistent_effect(Effect,just_before),!.
criteria1(no_effect,(pindex:event,tenasp:aspect:simple),_) if true,!.
criteria1(no_effect,(pindex:atelic,tenasp:aspect:simple),pindex:event) if true,!.
criteria1(no_effect,(pindex:event,tenasp:aspect:perf),
(pindex:event,tenasp:aspect:perf)) if true,!.
criteria1(no_effect,(pindex:event,tenasp:aspect:perf),
(pindex:activity,tenasp:aspect:perf)) if true,!.
criteria1(no_effect,(pindex:state,tenasp:aspect:perf),
(pindex:event,tenasp:aspect:perf)) if true,!.

boundp(no_effect) if !,fail.
boundp(flashback) if true,!.
boundp(flash_forward) if true,!.

consistent_effect(no_effect,_) if true,!.
consistent_effect(flashback,precedes) if true,!.
consistent_effect(flashback,overlaps) if !,fail.
consistent_effect(flashback,same_eventuality) if !,fail.
consistent_effect(flash_forward,just_before) if true,!.
consistent_effect(flash_forward,overlaps) if !,fail.
consistent_effect(flash_forward,same_eventuality) if !,fail.
consistent_effect(_,overlaps) if true,!.
consistent_effect(_,same_eventuality) if true,!.
consistent_effect(_,no_rhet_reln) if true,!.

If we are attaching Dcu2 to the current thread, the event it describes will be interpreted as
just after the tempfoc of Dcu1, so any temporal adverbial information must be consistent with
this. The rst criterion is that if a temporal expression has given an indication that Dcu2 is to
be interpreted as a ashback or a \ ashforward" (i.e., if the value of the effect on threads
slot is lled) then this information must be consistent with other explicit information. This is
the clause that allows temporal expression information to override other criteria. For example,
13
a temporal expression such as ten minutes earlier will assign effect on threads a ashback
value, which is only consistent when other information in the sentence doesn't disallow the
interpretation that the event described by Dcu2 precedes the tempfoc of Dcu1.
If the rst criterion fails, the second criterion to be considered is whether Dcu2 is a simple past
tense event. Whenever this is true, it can be interpreted as occurring just after the tempfoc
of Dcu1.
The third criterion is if the tempfoc is an event and Dcu2 is simple-tense atelic. The fourth
and fth clauses check whether the tempfoc is a perfect event/activity and Dcu2 is perfect
event. The nal clause checks if the tempfoc is a perfect event and Dcu2 is a perfect state.
The clause same_thread_attachment_possible sets the boolean SameThread to either plus
or minus. The next step in the calculate_tstuff clause is to check whether it is possible for
Dcu2 to attach to a previous thread, using the clause previous_thread_attachment_possible:

prev_thread_attachment_possible(Effect,Dcu2,precedes,plus) if
consistent_effect(Effect,precedes),
event(Dcu2),!.
prev_thread_attachment_possible(Effect,(Dcu2,tenasp:(aspect:perfect)),
precedes,plus) if
consistent_effect(Effect,precedes),
event(Dcu1),
state(Dcu2),!.
prev_thread_attachment_possible(_,_,_,minus) if true.

This clause also checks if a temporal expression overrides the option of attaching to a previous
thread, and it checks that the one of the constraint (that Dcu2 describes an event, or that
Dcu1 describes an event and Dcu2 describes a past perfect stative) is met.
Having determined which threads Dcu2 can attach to according to the various constraints
given by tense, aspect, rhetorical structure and temporal expressions, we append these lists
of threads. At this point, the rule fails if neither attachment to the current thread nor to a
previous one is possible.
If there is more than one thread that Dcu2 can attach to, the clause semantic_ratings uses
preferences to decide which is the best choice:
semantic_ratings([],_,_,_,[]) if true,!.
semantic_ratings(Threads,(v_and_np_list:NPs),_,CurrentThread,Thread) if
!,semantic_distance_pairs(NPs,Threads,RatingList),
highest(RatingList,HighestRating),
prioritize(RatingList,HighestRating,Threads,CurrentThread,Thread).

The rst preference technique is to compare the nps in Dcu2 to the nps in the preceding
threads and to assign a rating which corresponds to some measure of semantic \closeness."
Following Morris & Hirst, we simply pair each lexical item with the others and assign each
pair a closeness rating as in the following clauses:

14
semantic_distance(X,X,rating2) if true,!.
semantic_distance(house_,key_,rating1) if true,!.
semantic_distance(house_,door_,rating1) if true,!.
semantic_distance(dog_,bark_,rating1) if true,!.
semantic_distance(ring_,open_,rating1) if true,!.
semantic_distance(X,Y,rating1) if
semantic_distance_list(Y,X,rating1).
semantic_distance(_,_,rating0) if true,!.

The clause semantic_distance_pairs, shown below, forms pairs of the nps in Dcu2 with
ratings, creating a list of such pairs for each thread:
semantic_distance_pairs(_,[],[]) if true.
semantic_distance_pairs(NPs,[Thread1|Rest],[Rating|Z]) if
semantic_distance_list(NPs,Thread1,Rating),
semantic_distance_pairs(NPs,Rest,Z).

Once the individual word pair ratings are determined, they are added to get a total for
each thread. We will omit discussion of the mathematics involved because, due to the fact
that there are no numbers in ale, several clauses had to be introduced to de ne numbers
and addition and notions such as \greater than," and a discussion of these is not crucial to
the topic at hand. Also note that many of the operations of determining semantic ratings,
gathering nps and searching through lists of threads are repeated here. This can be greatly
optimised through the use of hash tables or global variables, but ale at least in its current
version, doesn't provide such facilities.
Once the RatingList containing the ratings for each thread is determined in semantic_ratings,
the highest rating is determined. There may be more than one thread with this rating, so a
second preference technique is applied via the clause prioritize:
prioritize(RatingList,HighestRating,Threads,CurrentThread,CurrentThread) if
all_best(RatingList,HighestRating,Threads,ThreadList),
member(CurrentThread,ThreadList),!.
prioritize(RatingList,HighestRating,Threads,_,Thread) if
best(RatingList,HighestRating,Threads,Thread).

all_best([],_,_,[]) if true.
all_best([X|Y],X,[T|Z],[T|Q]) if
all_best(Y,X,Z,Q),!.
all_best([_|Y],X,[_|Z],Q) if
all_best(Y,X,Z,Q),!.

best([X|_],X,[T|_],T) if true.
best([_|Y],X,[_|Ts],T) if
best(Y,X,Ts,T).

If the current thread is among the threads that scored highest, Dcu2 continues the current
thread. This is the center retention preference of temporal centering. If the current thread
15
is not among the threads, for each of the threads which scored highest a result is created in
which Dcu2 continues that thread.
The nal clause in this calculate_tstuff clause, form_new_threads, takes the thread(s)
that Dcu2 has been determined to continue, and makes the necessary additions to the parent
dcu including forming the new forward and backward centres, deciding on the new tempfoc,
and adding the new temporal relation to the temp relns slot. There are three parts to this
clause: The rst allows attachment of Dcu2 to the thread currently being followed, the second
allows creation of a new thread containing just Dcu2, and the third allows attachment of Dcu2
to a previous thread:

16
% Attach to same thread.
form_new_threads(plus,_,Thread,Thread,
[(just_before:(arg1:Pindex1,arg2:Pindex2))],
just_before,Effect,
(Dcu1,tempfoc:[(Tf1,pindex:Pindex1)]),
(Dcu2,pindex:Pindex2),Cue,
PrevThreads,NewThreads,NewTempFoc) if
determine_new_threads(Dcu1,Dcu2,Cue,NewThreads),
choose_new_tempfoc(Dcu2,Tf1,NewTempFoc),!.

% Create new thread.

form_new_threads(_,plus,Bkwd,[],
[(precede:(arg1:Pindex2,arg2:Pindex1))],
precedes,Effect,
(Dcu1,tempfoc:[(pindex:Pindex1)]),
(Dcu2,pindex:Pindex2),
Cue,PrevThreads,
[[Dcu2],Bkwd|PrevThreads],Dcu2) if true,!.

% Attach to previous thread.

form_new_threads(_,plus,[(Y,pindex:PindexY)|Bkwd],
[(X,pindex:Pindexf)|Thread],
[(just_before:(arg1:Pindexf,arg2:Pindex2)),
(precede:(arg1:Pindex2,arg2:PindexY))],
precedes,Effect,
(Dcu1,fwd_center:Fwd),
(Dcu2,pindex:Pindex2),Cue,
PrevThreads,NewThreads,Dcu2) if
not_equal(Bkwd,Thread),
% Temporal expressions are consistent with precedes
consistent_effect(Effect,precedes),
add_to_thread(Fwd,[X|Thread],Dcu2,NewThreads),!.

These clauses add di erent values to the temp_relns slot: If Dcu2 is attached to the current
thread, the event described by Dcu2 is just after the tempfoc of Dcu1. If a new thread
is created, the event described by Dcu2 precede s Dcu1's tempfoc, and if Dcu2 continues a
previous thread, the event it describes occurs just after the tempfoc of that previous thread
and precede s the tempfoc of the current thread. The clauses called by form_new_threads are
shown below:

17
determine_new_threads((Dcu1,tempfoc:[Tf1,(pindex:Pindex1)],
temp_center:fwd_center:Threads),
Dcu2,Cue,NewThreads) if
determine_cue_word(Cue),
member_thread(Tf1,Threads,Thread),
add_to_thread(Threads,Thread,Dcu2,NewThreads),!.

% An event or activity can be the TEMPFOC, but not a state because

% states don't advance the narrative.
choose_new_tempfoc(Dcu,OldTempfoc,OldTempfoc) if
state(Dcu),!.
choose_new_tempfoc(Dcu,_,Dcu) if true,!.

add_to_thread([X|Rest],X,Dcu,[[Dcu|X]|Rest]) if true.
add_to_thread([X|Y],Z,Dcu,[X|Q]) if
add_to_thread(Y,Z,Dcu,Q).

The second clause of calculate_tstuff is shown below:

calculate_tstuff((Dcu1,tempfoc:[(Tf1,pindex:Pindex1)]),
(Dcu2,pindex:Pindex2),
Tf1,[(included_in:(arg1:Pindex1,arg2:Pindex2))],
overlaps,Effect,Cue,
(bkwd_center:Bkwd),
(fwd_center:NewThreads,bkwd_center:[Dcu2|Bkwd])) if
consistent_effect(Effect,overlaps),
criteria3(Dcu1,Dcu2),
determine_new_threads(Dcu1,Dcu2,Cue,NewThreads),
initialize(Bkwd).

criteria3(_,pindex:state) if true,!.
criteria3(pindex:event,pindex:activity) if true,!.
criteria3(pindex:state,pindex:activity) if true,!.
criteria3(pindex:atelic,pindex:activity) if true,!.

This clause applies when one of the criteria in criteria3 are met and information in the sen-
tence is consistent with the interpretation that that state overlaps the tempfoc, as determined
by consistent_effect.
An example of a parse is shown in (20). For clarity we have simpli ed the output feature
structure in a number of ways.

18
 discussed in the next section, gives two additional parses. Without the use of preferences,
The narrative rule gives four parses for this example, and the elaboration rule, which is

(19)
Thomas rang the bell. He was tired. Hannah opened the door.
LOCAL 2 local_ind
LOCALITY
ROOT_TYPE defnpro
AGENT 33 GEN masc
SEMINDEX 0 NUM sing
ind PER third
thomas SYNINDEX 0
HD 30
LOCAL 63 local_ind
LOCALITY
ROOT_TYPE defnpro
PATIENT 32 GEN neut
SEMINDEX 1 NUM sing
ind PER third
ring bell SYNINDEX 1

LOCAL 2
LOCALITY
CONTENT HD 15 EXP 5
ROOT_TYPE ppro
SEMINDEX 0

tired thomas SYNINDEX 0

LOCAL 64 local_ind
LOCALITY
ROOT_TYPE defnpro
AGENT 10 GEN fem
TL SEMINDEX 3 NUM sing
ind PER third
hannah SYNINDEX 3
19

TL 6 12
LOCAL 65 local_ind
LOCALITY
ROOT_TYPE defnpro
PATIENT 9 GEN neut
SEMINDEX 4 NUM sing
ind PER third
open door SYNINDEX 4
ne_list_qfpsoa ne_list_qfpsoa
ARG1 60 event ARG1 60
TEMP_RELNS INCLUDED_IN , JUST_BEFORE
incl pair ARG2 state jbefore
61
pair ARG2 62 event
CONTENT 6
CONTENT 30 CONTENT 15

DISCOURSE_REFS 32 , 33 CUE_WORD no_cue_word CUE_WORD no_cue_word

DISCOURSE_REFS 9 , 10
PINDEX 60 DISCOURSE_REFS e_list PINDEX 62
POLARITY pos PINDEX 61
POLARITY pos
RHET_RELN 54 rhet POLARITY pos RHET_RELN 14 just_before
SCHEMA 30 RHET_RELN 29 overlaps
XDTRS 52 , 28 , 13 SCHEMA 12
TEMP_RELNS e_list SCHEMA 15
TEMP_RELNS e_list
TEMPFOC 52 TEMP_RELNS e_list TEMPFOC 13
ASPECT simple ASPECT simple
TENASP TENASP ASPECT simple
ta_pair TENSE past ta_pair TENSE past TENASP
ta_pair TENSE past
V_AND_NP_LIST thomas_ , ring_ , bell_ V_AND_NP_LIST e_list V_AND_NP_LIST hannah_ , open_ , door_
dcu_basic XDTRS e_list dcu_basic XDTRS e_list XDTRS e_list
dcu dcu_basic
2 ≠ 63 63 ≠2 64 ≠ 65 65 ≠ 64
there would be a total of 9 parses. Without constraints and preferences there would be 17
parses. This 65% reduction in the number of parses is a welcome result, but it still gives is a
large amount of ambiguity in large discourses. The advantage of taking this constraint-based
approach, however, is that it's not crucial that we decide on the temporal/rhetorical structure
of the discourse at this point in processing. In fact, we can simply constrain the possible
structures using the type hierarchy (See Figure 1) and leave the nal determination of the
structure to later processing when higher-level information comes into play. Instead of working
with several parses, we would maintain one parse with an underspeci ed representation of
the temporal/rhetorical structure.

20
4.2 The Elaboration Rule
The elaboration rule, shown below, handles cases in which two (or more) utterances describe
the same eventuality:

21
elaboration rule
(dcu_elab,
content:Plist,
context:(backgr:Cset,
c_inds:Ci),
np_list:NPs,
phonetic_form:Phon,
temp_center:(fwd_center:NewThreads,bkwd_center:Bkwd),
temp_relns:Tr,
temp_expr_relns:TEr,
tempfoc:[Tf],
rhet_reln:elaboration,
rhet_rule:elaboration_rule,
schema:Sch,
tenasp:Ta)
===>
cat> (dcu,Dcu1,
content:Plist1,
context:(backgr:Cset1,
c_inds:Ci1),
np_list:NPs1,
phonetic_form:Phon1,
temp_center:(bkwd_center:Bkwd),
tempfoc:[(Tf1,pindex:Pindex1)],
temp_relns:Tr1,
temp_expr_relns:TEr1),
cat> (dcu_basic,Dcu2,
content:Plist2,
context:(backgr:Cset2,
c_inds:Ci2),
cue_word:Cue,
np_list:NPs2,
phonetic_form:Phon2,
pindex:Pindex2,
rhet_reln:elaboration,
schema:Sch,
temp_relns:Tr2,
temp_expr_relns:(TEr2,[(hd_tloc:(effect_on_threads:Effect),
tl_tf:Tf)|_])),
goal> (equal(Dcu1,dcu_narr) ;
equal(Dcu1,dcu_basic)),
goal> append_lists(Phon1,Phon2,Phon),
goal> union(Cset1,Cset2,Cset),
goal> append_lists(NPs1,NPs2,NPs),
goal> equal3(Ci,Ci1,Ci2),
goal> criteria2(Effect,Dcu2,Dcu1),
goal> determine_new_threads(Dcu1,Dcu2,Cue,NewThreads),
goal> choose_new_tempfoc(Dcu2,Tf1,Tf),
goal> append_lists(Plist1,Plist2,Plist),
goal> append_lists(TEr1,TEr2,TEr),
goal> append_lists(Tr1,Tr2,Tr3),
goal> append_lists(Tr3,[(simultaneous:(arg1:Pindex1,arg2:Pindex2))],Tr).

Like the narrative rule, the elaboration rule applies under the constraints shown in the tables
in Appendix A. The criteria2 clause shown below allows the rule to apply if one of three
conditions are met:

22
criteria2(Effect,_,_) if
boundp(Effect),
consistent_effect(Effect,same_eventuality),!.
criteria2(no_effect,_,(pindex:event)) if true,!.
criteria2(no_effect,(pindex:atelic),(pindex:activity)) if true,!.
criteria2(no_effect,(pindex:state),(pindex:state)) if true,!.

The rst condition allows temporal expressions to override the constraints in the tables. If
no such expression is present, the second condition allows the rule to apply if Dcu1 describes
an event, the third condition allows the rule to apply if Dcu2 describes an atelic and Dcu1
describes an activity, and the nal clause allows the rule to apply if both Dcu1 and Dcu2
describe states. Aside from the di erent constraints and the fact that this rule assigns a
simultaneous relation to the temp_relns slot, this rule behaves similarly to the narrative rule
described in the previous section.

23
An example to which the elaboration rule applies is the following:
(20) Thomas arrived at the house at eight. He was tired.

LOCAL 3 local_ind
LOCALITY
ROOT_TYPE defnpro
AGENT 1 GEN masc
SEMINDEX 0 NUM sing
ind PER third
thomas SYNINDEX 0
HD 5
P_LOCATED 1

LOCALITY|ROOT_TYPE defnpro
CONTENT
PLOC
GEN neut
P_LOCATION SEMINDEX 2 NUM sing
ind PER third
at_physloc house SYNINDEX 2
arrive
LOCAL 3
LOCALITY
TL 42 45 EXP 4
ROOT_TYPE ppro
SEMINDEX 0

tired thomas SYNINDEX 0

ne_list_qfpsoa
TEMP_RELNS SIMULTANEOUS
ARG1 52 event
simul pair ARG2 53 state
CONTENT 5 CONTENT 42
DISCOURSE_REFS 1 CUE_WORD no_cue_word
PINDEX 52 DISCOURSE_REFS e_list
POLARITY pos PINDEX 53
RHET_RELN 41 rhet POLARITY pos
SCHEMA 5 RHET_RELN 47 elaboration
XDTRS 40
TEMP_RELNS e_list , 46 SCHEMA 45
TEMPFOC 40 TEMP_RELNS e_list
ASPECT simple ASPECT simple
TENASP TENASP
ta_pair TENSE past ta_pair TENSE past
V_AND_NP_LIST thomas_ , arrive_ , house_ V_AND_NP_LIST e_list
dcu dcu_basic XDTRS e_list dcu_basic XDTRS e_list

24
4.3 Additions to the sentence grammar
We'll now discuss several additions we've made to the lexicon and rules in order to represent
temporal and rhetorical phenomena.

4.3.1 Temporal expressions

For the purpose of analysing the temporal structure of a discourse, the more interesting
temporal expressions are those that a ect that structure.2 These expressions include those
that relate the time of the eventuality to speech time, such as last week (i.e., the week before
speech time) and those that relate the time of the eventuality to reference time, such as the
previous week. Following Hitzeman [1993], we treat temporal expressions of the form [P NP]
(such as on Tuesday, for an hour) as phrases which can attach at VP-level in which case
they don't relate the eventuality to speech time or reference time, and can also attach at
sentence-level in which case they relate the time of the eventuality to reference time (unless
lexically speci ed to do otherwise). For example, (21) has two readings:
(21) Mary has lived in Amsterdam for four years.
When the adverbial phrase for four years is attached at VP-level the interpretation is that
there was some four year interval in the past during which Mary lived in Amsterdam, and when
the adverbial is attached at sentence-level the interpretation is that Mary lives in Amsterdam
at reference time (which is equivalent to speech time in the present perfect [Reichenbach,
1947]) and has done so for the four years preceding reference time. We have chosen to
represent only the more interesting structure-a ecting sentence-level expressions.
We have expanded the hpsg grammar so that it parses certain types of temporal expressions,
including days of the week, sentence-level temporal adverbials such as for an hour and on
Tuesday, and expressions that are lexically speci ed to relate the time of the eventuality to
reference time (such as the previous week) or speech time (such as last week). All temporal
expressions are eventually appended to the temp expr relns feature of the dcu along with
the appropriate reference time for that utterance to further constrain the time at which the
eventualities occur. Both types of expressions must appear in the dcu so that they can
be used in resolving vp-ellipsis examples such as Bill left at noon and so did John. The
representation of the relative temporal order of eventualities that we build as the discourse
progresses is based on lower-level inferences resulting from cue words, tense, and temporal
centering, all of which are discussed in detail here.
2
See the discussion surrounding example (6).

25
The lexical entry for Thursday is shown below:
thursday --->
word,
phon:[t,h,u,r,s,d,a,y],
nps:[],
synsem:loc:((cat):(head:(temp_np,
count_mass:count,
drefs:(basic_tree,
root:(nom_type:Type,
label:thursday_,
ind:Index)),
mod:none,
temp_features:(durative:plus,
measure_term:minus,
clock_calendar_term:plus,
event_NP:minus,
time:minus,
day_name:plus,
month_year:minus,
season:minus,
self_refers:minus),
predicate:thur),
subcat: [],
marking:unmarked),
cont:(type:(defnpro,Type),
index:(ref,Index,
locality:(root_type:Type,
local:Ind),
synindex:(per:(Per,third),
num:sing,
gen:(Gen,neut)),
semindex:(per:Per,
gen:Gen)),
restr:e_set)),
(@ empty_non_loc),
qstore:e_set.

Thursday is represented as a temporal NP, which requires it to have features indicating

what sort of a temporal unit it expresses. Thursday is described here as expressing a time
that is durative, can be found on a calendar and is the name of a day. It is not a measure
term (such as an hour), it doesn't not express an event (as does the war, which can be
used as a temporal term in phrases such as during the war), and it doesn't express a time
(such as 3:00 ), a month, year, or season. Finally, it cannot self-refer, i.e., a year such as
1994 can be used to refer to the current year as in Have you given blood in 1994?, spoken
in 1994, while Thursday is unacceptable in a similar sentence such as Have you had your
morning co ee on Thursday?, spoken on that Thursday. This information is important for

26
deciding whether such an expression will be acceptable in a certain temporal adverbial. The
information concerning drefs and indices in this lexical entry relates to the sentence-level
nominal anaphora resolution techniques.

4.3.2 Temporal nps

In addition to temporal prepositional phrases, we wanted to introduce a mechanism for han-
dling temporal nps that adjoin at sentence level, a ecting the time of the eventuality without
the help of a preposition, as in (22):
(22) Sam arrived last week.
One option for treating these expressions is to treat all temporal nps as optionally doing the
work that the preposition does, namely putting the temporal information into the appropriate
slots of the sentence's sign. We could do this either by having two lexical entries for each
temporal noun or by having a rule that promotes a temporal np to something that does the
work of the preposition. Either way, we introduce ambiguity and the amount of processing
doubles.

27
The solution we have chosen is to introduce an additional schema for parsing adjuncts, shown
below:
schema5_and_a_half rule
(Mother,phrase,synsem:loc:cont:HeadCont,
nps:NPs,phon:MomPhon)
===>
cat> (HeadDtr,phrase,synsem:(loc:((cat):(head:verb,
subcat:[]),
cont:(HeadCont,
nucleus:(temploc:(location:(predicate:P,
pred_mods:Ms),
effect_on_threads:Effect,
containment_reln:[during])))),
non_loc:to_bind:slash:e_set),
phon:Cat1Phon,nps:NPs1),
cat> (AdjnDtr,phrase,synsem:loc:(cat):(head:(temp_np,
temporal_effect:Effect,
predicate:P,
pred_mods:Ms,
mod:none),
subcat:[]),
phon:Cat2Phon,nps:NPs2),
goal> (append_lists(NPs1,NPs2,NPs)),
goal> (head_feature_principle(Mother,HeadDtr),
subcat_principle(Mother,HeadDtr,[]), % no comp-dtrs
marking_principle(Mother,HeadDtr),
% spec_principle: not necessary - no comp-dtrs or marker-dtr
% semantics_principle: circumvented
% universal_trace_principle: not necessary - no comp-dtrs
% parochial_trace_principle: not necessary - no comp-dtrs
% subject_condition: not necessary - sch2,3 or word_promotion_1 will
nonlocal_feature_principle(Mother,HeadDtr,[AdjnDtr]),
single_rel_constraint(Mother),
clausal_rel_prohibition(Mother),
relative_uniqueness_principle(Mother,[AdjnDtr,HeadDtr]),
conx_consistency_principle(Mother,[AdjnDtr,HeadDtr]),
deictic_cindices_principle(Mother,[AdjnDtr,HeadDtr])),
goal> append_lists(Cat1Phon,Cat2Phon,MomPhon).

This schema, which is called \5 1/2" after the adjunct schema number 5, applies when a
sentence with an empty subcat is adjacent to a temporal np. Because no preposition can
intervene, there is no ambiguity for a sentence- nal temporal adjunct.

4.3.3 The role of temporal expressions

Temporal expressions such as at noon, yesterday and for an hour a ect the temporal structure
of the discourse in two ways: First, they are given an interpretation in context and this
interpretation is added to the list temp expr relns. The resulting list contains pairs of an
index that expresses the reference time of the sentence followed by the interpretation of the
temporal adverbial. the contents of the temp expr relns feature for the expression last
Thursday is shown below:

28
 2 3
located 2 event
** 66 7
66
containment reln
2
[during]
3 77++
1 66 64
predicate h
thur
i 7 77
5 75
;

4 location pred mods relative to 3

previous

This list contains one (reference time,expression) pair that relates the index of an event
in the discourse (indicated here with the index [2]) to the time that it occurred, in this
case indicating that it occurred on the Thursday before speech time (where speech time is
indicated by the index [3], which refers to an entry in the c inds feature). The reference time,
indexed here by [1], is necessary for interpreting expressions such as the previous Thursday.
The feature containment reln contains a list of possible relations that the time of the
event has to the time described by the predicate and its modi ers. These relations are
taken from Allen's [Allen, 1984] list of the 13 possible relations that can occur between two
intervals. In this case, the event occurs during the previous Thursday. The information on
the temp expr relns feature is combined with the list on the feature temp relns, which
contains information about the relationships between the events in the discourse. These two
lists would be the input to a module which takes care of propagating temporal constraints and
checking for their consistency. Logically, the information in this example could be rewritten
in a more standard Davidsonian fashion, as in (23):
(23) 9e2 event(e2) [9 t1 ,t3 previous(thursday,t1,t3)) ^ during(e2 ,t1)]
Here the formula previous(thursday,t1,t3) is intended to result in the interpretation that
the Thursday in question is the one most closely preceding time t3. Previous would be given
the translation:
(24) Pt1t3 P(t) ^ :9t2 (P(t2 ) ^ t1 6= t2 ^ t1  t2  t3 )
The expression the previous Thursday would be treated identically except that the feature
relative to would have the index of reference time rather than speech time.
The second way in which temporal expressions a ect the temporal structure of the discourse
is that they constrain the temporal order that calculate_tstuff can assign to two dcus.
If calculate_tstuff didn't take the phrase a week earlier into account, it would incorrectly
predict that the two eventualities expressed by the sentences below overlap:
(25) John was in Boston. A week earlier he was in Detroit.
In such cases where the temporal information overrides the default way in which a certain
sequence of tenses is interpreted, calculate_tstuff disregards the tense information as
described above.

29
4.3.4 Aspect
The original proposal concerning communicating the aspect of the sentence to the discourse
grammar for analysing narrative progression was that the sentence aspect would be stored
within the nucleus feature, which, as a head feature, passes that information up to the
parent.3 However, as noted in that proposal, the aspect of the sentence is not simply a lexical
attribute of the verb, but is built up compositionally from various other phenomena in the
sentence, such as whether the direct object is a mass or count NP, and the presence of certain
prepositional phrases or adverbials.
We computer compositionally the aspect of each sentence as the sentence is built up. The
aspect of each phrase is stored in nucleusjpsoa index. Temporal adverbials are an example
of the aspect-a ecting linguistic phenomena. For example, a temporal for -phrase selects for
an atelic eventuality and returns a telic eventuality via its lexical entry [Moens and Steedman,
1988], as illustrated by the lexical rule below:
for --->
word,
synsem:loc:((cat):(head:(prep,
pform:for_prep,
mod:(synsem,
loc:((cat):(head:(verb,
aux:minus)),
cont:(psoa,
nucleus:(qfpsoa:VerbQfpsoa,
tloc:VerbTloc,
% selects for ATELIC
psoa_index:atelic,
polarity:VerbPolarity))))),
subcat: [(loc:(cat):head:(temp_np,
predicate:P,
temp_features:(measure_term:plus,
durative:plus,
measure:Duration)))]),
cont:(psoa,
nucleus:(qfpsoa:VerbQfpsoa,
tloc:(VerbTloc,
located:VerbPsoaIndex,
containment_relation:[eq,duringi],
location:(local_to_R:minus,
predicate:P,
duration:Duration)),
% creates an EVENT
psoa_index:event,
polarity:VerbPolarity),
quants:[])),
(@ empty_non_loc),
qstore:e_set.

We had planned to use ale's constraint mechanism to mark a verb like eat as belonging to
the telic aspectual class when it has a singular object (as in eat a sandwich) and as atelic
3
B.2 p. 15-17.

30
when it has a plural object (as in eat sandwiches). However, it appears that constraints don't
function as expected in this version of ale.4 Instead, we created two new types for each
verb: pp goal and dobj goal. A verb such as walk will have a value of pp goal:plus
because a prepositional phrase that can act as a goal when combined with walk will produce
an event. For example, walk , which is lexically marked as an activity, becomes an event in
the expression walk to the house. Prepositions such as spatial to are marked with a value
of is goal:plus to signal that they can serve as a goal. The adjustment of the aspect of
the expression is done when then pp attaches to the vp in schemas 5a and 5b via the clause
adjust_aspect_with_adjunct:

adjust_aspect_with_adjunct(synsem:loc:(cat):head:(verb,pp_goal:plus), %walk to X
synsem:loc:(cat):head:(prep,is_goal:plus),
synsem:loc:cont:psoa_index:event) if true,!.
adjust_aspect_with_adjunct(synsem:loc:cont:psoa_index:Index,_,
synsem:loc:cont:psoa_index:Index) if true,!.

The rst clause states that if the verb is marked as pp goal:plus and the prepositional
phrase is marked as is goal:plus then the aspect of the mother category is event. The
second clause passes up the aspect of the head category.
A similar procedure is done in schema 2 to adjust the aspect depending on the type of direct
object. As the clauses below describe, if the verb is marked with dobj goal:plus indicating
that the singular/plural, count/mass distinctions a ect the aspect of the vp, then when the
object is a mass np or a plural np the aspect is activity and when the object is a singular
count np the aspect is event :
adjust_aspect(synsem:loc:(cat):head:(verb,dobj_goal:plus), %eat mush
synsem:loc:(cat):head:(noun,count_mass:mass),
synsem:loc:cont:psoa_index:activity) if true,!.
adjust_aspect(synsem:loc:(cat):head:(verb,dobj_goal:plus), %eat a cookie
synsem:loc:((cat):head:(noun,count_mass:count),
cont:index:synindex:num:sing),
synsem:loc:cont:psoa_index:event) if true,!.
adjust_aspect(synsem:loc:(cat):head:(verb,dobj_goal:plus), %eat beans
synsem:loc:cont:index:synindex:num:plur,
synsem:loc:cont:psoa_index:activity) if true,!.
adjust_aspect(synsem:loc:cont:psoa_index:Index,_,
synsem:loc:cont:psoa_index:Index) if true,!.

4
The newer version of ale claims to have xed this problem.

31
4.3.5 Elliptical clauses
In order to treat VP ellipsis, certain lexical items have been added, including did and too .
The lexical entry for too is shown below:
too --->
word,
phon:[t,o,o],
nps:[],
synsem:loc:((cat):(head:(cue_phrase,
mod:(synsem,
loc:((cat):(head:vform:fin,
subcat:[]),
cont:(Cont,temp_psoa,
nucleus:(rhetorical_links:parallel))))),
subcat:[]),
cont:Cont),
qretr:[],
qstore:e_set.

The word too modi es a verb phrase with an empty subcategorization frame, and marks the
nucleus of that sign with the rhetorical relationship parallel , indicating that this is an elliptical
sentence. The elided parts are recovered either through priority union or a VP-ellipsis rule.
Elliptical sentences are parsed using the ellipsis_allowance rule shown below:
ellipsis_allowance rule
(phrase,synsem:(loc:((cat):(head:(verb,Head,
elliptical:plus,
drefs:(unary_tree,
root:e_node,
dtr1:Dref1)),
subcat:[(@ np(Ind),
loc:(cat):head:drefs:Dref1)],
marking:Marking),
cont:(nucleus:(qfpsoa:(agentive,
agent:Ind),
index_list:[Ind]),
psoa_index:Pindex,
quants:[]))),
phon:Phon,
nps:NPs,
qstore:QStore,
qretr:QRetr)
===>
cat> (word,synsem:(loc:((cat):(head:(Head,verb,aux:plus),
marking:Marking,
subcat:(hd:(@ np(Ind)),
tl:ne_list_synsem)),
cont:psoa_index:Pindex),
non_loc:to_bind:slash:e_set),
phon:Phon,
nps:NPs,
qstore:QStore,
qretr:QRetr).

32
This rule allows an auxiliary to elide the subcategorized items within the vp by simply
dropping those items o the subcategorization list.

33
4.3.6 Punctuation
A full_stop now signals the end of a sentence, so that parsing now can be done with
commands such as:
?- rec[sam,saw,hannah,full stop].
?- rec[sam,arrived,at,the,house,at,eight,full stop,hannah,opened,the,door,
full stop].
The lexical entry for the full stop is shown below:
full_stop --->
full_stop,
synsem:none,
phon:[pause],
nps:[],
qretr:[],
qstore:e_set.

This entry represents a full stop as a pause with no syntactic or semantic content. Because
it modi es nothing and subcategorizes for nothing, and because it is of category punctuation
rather than a word or phrase, it acts like a barrier beyond which no entry can look for a
subcategorized element or modi er. The barrier provided by a full stop is exempli ed by the
inability of the who -phrase to attach to the nal np in the rst sentence in the example below
(taken from a U.S. newspaper):
(26) Mother and son were moving to Southern California, where Ms. Nichols-Daniel planned
to marry Nick's father. Who will raise the boy and where he'll live remained uncertain.

34
5 Evaluation
This section describes the test suite we have designed to aid in the evaluation of the temporal
portion of the grammar.

5.1 The test suite

1. Thomas does too.
2. Hannah likes ants.
3. Thomas rang the bell.
4. Thomas had arrived.
5. Hannah had opened the door.
6. Thomas had rung the bell.
7. Hannah ate bread.
8. Hannah ate a sandwich.
9. Hannah ate sandwiches.
10. Thomas had arrived at eight.
11. Thomas arrived at the house.
12. Thomas arrived at the house at eight.
13. Thomas visited Hannah last Thursday.
14. Thomas visited Hannah last week.
15. Thomas visited Hannah two weeks ago.
16. Thomas had visited Hannah two weeks ago.
17. Thomas had visited Hannah the previous week.
18. Hannah likes ants. Thomas does too.
19. Thomas rang the bell. He was tired.
20. Thomas rang the bell. Hannah opened the door.
21. Thomas rang the bell. Hannah had opened the door.
22. Thomas rang the bell. He was tired. Hannah opened the door.
23. Thomas arrived at the house at eight. Hannah opened the door.
24. Thomas arrived at the house at eight. He had lost the key. Hannah opened the door.

35
25. Thomas arrived at the house at eight. He had lost the key. it fell through a hole in his
pocket.
26. Thomas rang the bell. He had lost the key. Hannah opened the door.
27. Thomas rang the bell. He had lost the key. It fell through a hole in his pocket.
28. Thomas was tired. He rang the bell.
29. Hannah had arrived. She opened the door.
30. Thomas rang the bell. He had lost the key the previous week. Hannah opened the door.
31. Thomas rang the bell. He had lost the key. He dropped it.
32. Thomas was tired. the bell was orange. Thomas rang the bell.
33. Thomas was tired. Hannah was happy.
34. Thomas arrived at the house. He rang the bell. He had visited Hannah the previous
week.

36
5.2 Results
5.2.1 Tests for the sentence grammar
This section tests various additions to the sentence grammar which enabled us to test discourse-
level phenomena.
?- rec[thomas,does,too,full stop].
Number of parses: 1
Comments: Tests parsing of elliptical sentences and marks them as \parallel"
?- rec[thomas,rang,the,bell,full stop].
Number of parses: 1
Comments: Test for simple past.
?- rec[thomas,had,arrived,full stop].
Number of parses: 1
Comments: Test for past perfect.
?- rec[hannah,had,opened,the,door,full stop].
Number of parses: 1
Comments: Test for past perfect with object.
?- rec[thomas,had,rung,the,bell,full stop].
Number of parses: 1
Comments: Test for past perfect with object.
?- rec[hannah,ate,a,sandwich,full stop].
Number of parses: 1
Comments: When the object is a singular count noun, the aspect of this sentence is
event .
?- rec[thomas,walked,to,the,house,full stop].
Number of parses: 1
Comments: The goal-PP changes the aspect of this sentence from activity to event .
?- rec[thomas,arrived,at,the,house,full stop].
Number of parses: 1
Comments: Tests spatial PP.
?- rec[thomas,arrived,at,the,house,at,eight,full stop].
Number of parses: 1
Comments: Tests multiple PPs.
?- rec[thomas,visited,hannah,last,thursday,full stop].
Number of parses: 1
Comments: Tests a \ ashback" temporal expression.
?- rec[thomas,visited,hannah,last,week,full stop].
Number of parses: 1
Comments: Tests a \ ashback" temporal expression.
37
5.2.2 Tests for the temporal discourse grammar
The \Parses:" sections below list the contents of the temp_relns slot after parsing. The
examples headed with an \X" instead of a number are parses that are possible under the
constraints but that have been eliminated by the preferences.
The addition of the end_markers at each end of the string to be parsed are for use with the
version of the code containing both the nominal and temporal rules. The temporal code alone
doesn't utilise the end_markers.
?- rec[end marker,thomas,rang,the,bell,full stop,he,was,tired,full stop,end marker].
Comments: An event followed by a state
Parses:
1. simultaneous[ring,tired]
(Incorrect, but we must allow for cases such as \They built a dog house. It was a
labour of love.")
2. included in[ring,tired]
(Tiredness overlaps with ringing)
3. just bef[ring,tired]
(E.g., if the ringing caused the tiredness)
?- rec[end marker,thomas,rang,the,bell,full stop,hannah,opened,the,door,full stop,
end marker].
Comments: Two consecutive eventive sentences
Parses:
1. simultaneous[ring,open]
(Incorrect, but we must allow for cases such as \I assembled the desk myself. The
drawers only took me ten minutes.")
2. just before[ring,open]
(He rings the bell and then Hannah opens the door.)
X. precede[open,ring]
(Eliminated by preferences)
?- rec[end marker,thomas,rang,the,bell,full stop,hannah,had,opened,the,door,full stop,
end marker].
Comments: A simple past eventive followed by a past perfect eventive
Parses:
1. precede[open,ring]
(Hannah opens the door before Thomas rings the bell.)
?- rec[end marker,thomas,rang,the,bell,full stop,he,was,tired,full stop,hannah,opened,the,
door,full stop,end marker].
Comments: A sequence of events/states
Parses:
1. simul[ring,tired], simul[ring,open]
38
 2. simul[ring,tired], just bef[ring,open]
3. incl in[ring,tired], simul[ring,open]
4. incl in[ring,tired], just bef[ring,open]
5. just bef[ring,tired], simul[ring,open]
6. just bef[ring,tired], just bef[ring,open]
X. simul[ring,tired], precede[ring,open]
(Eliminated by preferences)
X. incl in[ring,tired], precede[ring,open]
(Eliminated by preferences)
X. just bef[ring,tired], precede[ring,open]
(Eliminated by preferences)
?- rec[end marker,thomas,arrived,at,the,house,at,eight,full stop,hannah,opened,the,door,
full stop,end marker].
Comments: Two consecutive eventives with a temporal expression
Parses:
1. simul[arrive,open]
(Incorrect, but we must allow for cases such as "I assembled the desk myself. The
drawers only took me ten minutes.")
2. just before[arrive,open]
(Thomas arrives and then Hannah opens the door)
X. precede[open,arrive]
(Eliminated by preferences)
?- rec[end marker,thomas,was,tired,full stop,he,rang,the,bell,full stop,end marker].
Comments: Mix of event with state
Parses:
1. just before[tempfoc of tired,ring]
(Thomas rings the bell while he's tired.)
2. simultaneous[tempfoc of tired,ring]
(Incorrect, but we must allow for cases such as "I assembled the desk myself. It
was beautiful. The drawers only took me ten minutes.")
?- rec[end marker,hannah,had,arrived,full stop,she,opened,the,door,full stop,end marker].
Comments: Starting the discourse with a past perfect
Parses:
1. simultaneous[arrive,open]
(Incorrect, but we must allow for cases such as ")
2. just bef[arrive,open]
(Hannah arrives and then opens the door.)
X. precede[open,arrive]
(Ruled out by preferences)

39
?- rec[end marker,thomas,was,tired,full stop,hannah,was,happy,full stop,end marker].
Comments:
Parses:
1. included in[tired,tired]
2. just before[tired,"event"] (where "event" = tempfoc of "tired")
3. simultaneous[tempfoc of tired,tired]

40
A Tables listing constraints on narrative continuations
The tables in this appendix describe the possible temporal relationships that can occur be-
tween two (or more) consecutive sentences of the various tenses and in the various categories
of semantic aspect. S1 and S2 refer to consecutive sentences and tf1 refers to the temporal
focus of S1 . When S1 is equivalent to tf1 the relation is speci ed only with respect to S1 .
The constraints used in the narrative and elaboration rule are taken from these tables. If
a simult relation is possible this indicates an elaboration rhetorical relation, and the elabo-
ration rule applies. If one of the other temporal relations is possible the narrative rule applies.

41
 S1 S2 Relation Example
just-after S1 Mary pushed John. He fell.
past event past event precede S1 John fell. Mary pushed him.
overlap tf1 no
simult S1 I assembled the desk myself. The drawers
only took me ten minutes.
just-after S1 Mary stared at John. He gave her back her
slice of pizza.
past activity past event precede S1 no
overlap tf1 no
simult S1 no
just-after S1 no
just-after tf1 Sam arrived at eight. He was tired. He
rang the bell.
past state past event precede S1 no
precede tf1 ?John fell. He was in pain. Mary pushed
him.
overlap S1 Mary was angry. She pushed John.
overlap tf1 no
simult S1 no
simult tf1 I assembled the desk myself. It was beau-
tiful. The drawers only took ten minutes.
just-after S1 Sam had arrived at the house. He rang the
bell.
past perf event past event precede S1 Sam arrived at the house. He had lost the
key. He rang the bell.
overlap tf1 no
simult S1 Mary had pushed John. She pushed him
hard.
just-after S1 John had eaten oranges. He reached for a
napkin.
past perf activity past event precede S1 no
overlap S1 no
simult S1 no
just-after tf1 Martha discovered the broken lock. Some-
one had been in the garage. They rear-
ranged the tools.
just-after S1 no
past perf state past event precede tf1 no
precede S1 no
overlap S1 Martha discovered the broken lock. Some-
one had been in the garage. They rear-
ranged the tools.
overlap S1 no
simult tf1 no
simult S1 no

Table 1. Possible relations when S2 expresses a simple past event.

42
 S1 S2 Relation Example
just-after S1 Mary got up. She ran towards the docks.
past event past activity precede S1 no
simult S1 They built a bridge in Boston. They used
copper and steel.
overlap S1 no
just-after S1 no
past activity past activity precede S1 no
simult S1 Mary ran towards the docks. She ran
quickly.
overlap S1 Mary ran towards the docks. She tried not
to look behind her.
just-after tf1 John spotted the police. He was quiet. He
quickly ran toward the docks.
just-after S1 John was quiet. He quickly ran toward the
docks.
past state past activity precede tf1 no
precede S1 no
simult tf1 John ran. He was silent. He ran quickly.
simult S1 no
overlap S1 John was quiet. He stared at the wall.
overlap tf1 no
just-after S1 John had made his decision. He ran toward
the docks.
past perf event past activity precede S1 no
simult S1 They had built a bridge in Boston. The
used copper and steel.
overlap S1 no
just-after S1 no
past perf activity past activity precede S1 no
simult S1 She had walked down the beach. She
walked slowly, thoughtfully.
overlap tf1 Mary had run along the docks. She tried
not to look behind her.
just-after S1 John had been nervous. He ran toward the
docks.
just-after tf1 John recognized he was in danger. Mary
had been on the beach. He ran towards
the docks.
precede S1 no
past perf state past activity precede tf1 no
simult S1 John had run along the beach. He was
silent. He ran quickly.
simult tf1 John had run along the beach. He was
silent. He ran quickly.
overlap S1 Mary had been on the beach. John walked
toward her.
overlap tf1 no

Table 2. Possible relations when S2 expresses a simple past activity.

43
 S1 S2 Relation Example
just-after S1 Mary pushed John. He was surprised.
past event past state precede S1 no
simult S1 They built a dog house. It was a labour of
love.
overlap S1 Mary pushed John. She was angry.
just-after S1 no
past activity past state precede S1 no
simult S1 Mary walked down the beach. It was a
slow, pensive walk.
overlap S1 Mary walked down the beach. She was
content.
just-after S1 no
just-after tf1 Mary pushed John. He was surprised. He
was very surprised.
past state past state precede S1 no
precede tf1 no
simult S1 Mary was angry. In fact, she was furious.
simult tf1 They built a dog house. It was a labour of
love. It was a pleasure.
overlap S1 John was content. There was a pizza in
front of him.
overlap tf1 John sat down at the table. He was con-
tent. There was a pizza in front of him.
just-after S1 John had arrived at the house. He was
relieved.
past perf event past state precede S1 no
simult S1 They had built a dog house. It was a
labour of love.
overlap S1 John had arrived at the house. He was in
Boston.
just-after S1 no
past perf activity past state precede S1 no
simult S1 Mary had walked down the beach. It was
a slow, pensive walk.
overlap S1 Mary had walked along the beach. She was
content.
just-after S1 no
just-after tf1 Mary had pushed John. He was surprised.
He was very surprised.
precede S1 no
past perf state past state precede tf1 no
simult S1 Mary had been angry. In fact, she was
furious.
simult tf1 They had built a dog house. It had been a
labour of love. It was a pleasure.
overlap S1 John had been content. There was a pizza
in front of him.
overlap tf1 John had sat down at the table. He had
been content. There was a pizza in front
of him.
Table 3. Possible relations when S2 expresses a simple past state.
44
 S1 S2 Relation Example
just-after S1 no
past event past perf event precede S1 Sam arrived at the house. He had lost the
key.
simult S1 no
overlap S1 no
just-after S1 no
past activity past perf event precede S1 Mary walked along the beach. John had
left.
simult S1 no
overlap S1 no
just-after tf1 John had nished his thesis. He was happy.
He had decided to show it to Betty.
just-after S1 no
past state past perf event precede tf1 John put down his pen. He was happy. He
had nished his thesis.
precede S1 John had achieved his dream. He was
happy. He had nished his thesis.
simult tf1 John had achieved his dream. He was
happy. He had nished his thesis.
simult S1 no
overlap S1 no
overlap tf1 no
just-after S1 John had travelled to Boston. He had
booked himself in at the Y.
past perf event past perf event precede S1 John had travelled to Boston. He had got-
ten the idea from Mary.
simult S1 John had driven across Sweden. He had
started in Denmark.
overlap S1 no
just-after S1 Mary had stared at John. He had given
her back her slice of pizza.
past perf activity past perf event precede S1 no
simult S1 no
overlap S1 no
just-after tf1 John had nished his thesis. He had been
happy. He had decided to show it to Betty.
just-after S1 no
past perf state past perf event precede tf1 John had been prepared for the interview.
He had read the documentation.
precede S1 John had achieved his dream. He'd been
happy. He had nished his thesis.
simult tf1 John had achieved his dream. He'd been
happy. He had nished his thesis.
simult S1 no
overlap S1 John had been nervous. He had forgotten
his phone number.
overlap tf1 no
Table 4. Possible relations when S2 expresses a past perfect event.

45
 S1 S2 Relation Example
just-after S1 Mary stood up. She ran along the beach.
past event past perf activity precede S1 no
simult S1 Mary ran to the docks. She ran quickly.
overlap S1 no
just-after S1 no
past activity past perf activity precede S1 no
simult S1 Mary ran along the beach. She ran with
determination.
overlap S1 no
just-after tf1 John had said something rude. Mary was
angry. She had glared at him.
just-after S1 no
past state past perf activity precede tf1 no
precede S1 Mary was angry. John had simply walked
away from her.
simult tf1 John had walked away from Mary. She was
angry. He had walked away quickly.
simult S1 no
overlap S1 Mary was angry. She had glared at John.
overlap tf1 Mary had glared at John. She was angry.
She had stared deep into his eyes.
just-after S1 Mary had stood up. She ran along the
beach.
past perf event past perf activity precede S1 no
simult S1 Mary had run to the docks. She ran
quickly.
overlap S1 no
just-after S1 no
past perf activity past perf activity precede S1 no
simult S1 Mary had walked along the beach. She had
walked slowly.
overlap S1 no
just-after tf1 John had said something rude. Mary had
been angry. She had glared at him.
just-after S1 no
past perf state past perf activity precede tf1 no
precede S1 Mary had been angry. John had simply
walked away from her.
simult tf1 John had walked away from Mary. She had
been angry. He had walked away quickly.
simult S1 no
overlap S1 Mary had been angry. She had glared at
John.
overlap tf1 Mary had glared at John. She'd been an-
gry. She had stared deep into his eyes.
Table 5. Possible relations when S2 expresses a past perfect activity.

46
 S1 S2 Relation Example
just-after S1 no
past event past perf state precede S1 John called the police. Someone had been
in the garage.
simult S1 no
overlap S1 John called the police. He had felt they
could help.
just-after S1 no
past activity past perf state precede S1 no
simult S1 Mary walked down the beach. It had been
a slow, pensive walk.
overlap S1 Mary walked down the beach. She had
been content.
just-after tf1 no
just-after S1 no
past state past perf state precede tf1 no
precede S1 John was confused. Someone had been in
the garage.
simult tf1 They had built a dog house. They were
pleased. It had been a labour of love.
simult S1 no
overlap S1 Someone was in the garage. They had
known there was cash in there.
overlap tf1 John had gone to the kitchen. He was hun-
gry. He had known there was some cold
chicken left.
just-after S1 no
past perf event past perf state precede S1 John had called the police. Someone had
been in the garage.
simult S1 no
overlap S1 Someone had been in the garage. They had
been in a hurry.
just-after S1 no
past perf activity past perf state precede S1 no
simult S1 Mary had walked down the beach. It had
been a slow, pensive walk.
overlap S1 Mary had walked down the beach. She had
been content.
just-after tf1 no
just-after S1 no
past perf state past perf state precede tf1 no
precede S1 John had been confused. Someone had
been in the garage.
simult tf1 Someone had been in the garage. They had
a key.
simult S1 Mary had been happy. She had been
ecstatic.
overlap S1 Someone had been in the garage. They had
known there was cash there.
overlap tf1 John found the back door open. Someone
had been in the garage. They had known
there was cash there.
Table 6. Possible relations when S2 expresses a past perfect state.
47
B Listing of Temporal Discourse Grammar
temporal rule
(dcu,
content:Content,
context:Context,
phonetic_form:Phon,
temp_center:NewTCenter,
temp_relns:TempRelns,
temp_expr_relns:TempExprRelns,
tenasp:(tense:Tense,
aspect:Aspect),
xdtrs:Dtrs)
===>
cat> (end_marker),
cat> (dcu,Dcu,
content:Content,
context:Context,
phonetic_form:Phon,
tenasp:(tense:Tense,
aspect:Aspect),
xdtrs:Dtrs),
cat> (end_marker),
goal> give_initial_state_a_tempfoc(Dtrs),
goal> calculate_temp_relns(Dcu,Dtrs,TempRelns,TempExprRelns,NewTCenter).

% An initial state overlaps with some preceding event

give_initial_state_a_tempfoc([(pindex:(State,state),
temp_relns:[(included_in:(arg1:(pindex:event),
arg2:State))])|_])
if true,!.
give_initial_state_a_tempfoc(_) if true,!.

calculate_temp_relns(Dcu,[],X,Y,Z) if calculate_temp_relns(_,[Dcu],X,Y,Z),!.
calculate_temp_relns(_,[(temp_relns:T,
temp_expr_relns:TE,
temp_center:TC)],T,TE,TC) if true,!.
% Incremental processing
calculate_temp_relns(_,[X,Y|Z],TempRelns,TempExprRelns,TC) if
apply_temporal_rules(X,Y,Parent1),
calculate_temp_relns(_,[Parent1|Z],TempRelns,TempExprRelns,TC).

% --------------
% Narrative rule
% --------------
apply_temporal_rules((dcu,Dcu1,

48
 v_and_np_list:NPs1,
temp_center:TCenter,
temp_relns:Tr1,
temp_expr_relns:TEr1),
(dcu,Dcu2,
cue_word:Cue,
v_and_np_list:NPs2,
rhet_reln:Rhet,
temp_relns:Tr2,
temp_expr_relns:(TEr2,[(hd_tloc:(effect_on_threads:Effect),
tl_tf:Tf)|_])),
(dcu_narr,
v_and_np_list:NPs,
temp_center:NewTCenter,
temp_relns:Tr,
temp_expr_relns:TEr,
tempfoc:[Tf],
rhet_reln:Rhet,
rhet_rule:narrative)) if
append_lists(NPs1,NPs2,NPs),
calculate_tstuff(Dcu1,Dcu2,Tf,Reln,Rhet,Effect,Cue,TCenter,NewTCenter),
append_lists(TEr1,TEr2,TEr),
append_lists(Tr1,Tr2,Tr3),
append_lists(Tr3,Reln,Tr).

% ----------------
% Elaboration rule
% ----------------

apply_temporal_rules((dcu,Dcu1,
v_and_np_list:NPs1,
temp_center:(bkwd_center:Bkwd),
tempfoc:[(Tf1,pindex:Pindex1)],
temp_relns:Tr1,
temp_expr_relns:TEr1),
(dcu_basic,Dcu2,
cue_word:Cue,
v_and_np_list:NPs2,
pindex:Pindex2,
rhet_reln:elaboration, %where would this comefrom?
temp_relns:Tr2,
temp_expr_relns:(TEr2,[(hd_tloc:(effect_on_threads:Effect),
tl_tf:Tf)|_])),
(dcu_elab,
v_and_np_list:NPs,
temp_center:(fwd_center:NewThreads,
bkwd_center:Bkwd),

49
 temp_relns:Tr,
temp_expr_relns:TEr,
tempfoc:[Tf],
rhet_reln:elaboration,
rhet_rule:elaboration_rule,
tenasp:Ta)) if
append_lists(NPs1,NPs2,NPs),
criteria2(Effect,Dcu2,Tf1),
determine_new_threads(Dcu1,Dcu2,Cue,NewThreads),
choose_new_tempfoc(Dcu2,Tf1,Tf),
append_lists(Plist1,Plist2,Plist),
append_lists(TEr1,TEr2,TEr),
append_lists(Tr1,Tr2,Tr3),
append_lists(Tr3,[(simultaneous:(arg1:Pindex1,arg2:Pindex2))],Tr).

criteria2(Effect,_,_) if
boundp(Effect),
% Temporal expressions are consistent with same_eventuality
consistent_effect(Effect,same_eventuality),!.
% Dcu2 is a simple-tense anything
criteria2(no_effect,(tenasp:aspect:simple),_) if true,!.
% Tf1 is complex tense event, Dcu2 is complex tense event
criteria2(no_effect,(tenasp:aspect:perf),(tenasp:aspect:perf)) if true,!.

form_new_daughters_list((Dcu1,xdtrs:[]),(Dcu2,xdtrs:[]),[Dcu1,Dcu2])
if true, !.
form_new_daughters_list((Dcu1,xdtrs:[]),(xdtrs:Dtrs2),[Dcu1|Dtrs2])
if true,!.
form_new_daughters_list((xdtrs:Dtrs1),(Dcu2,xdtrs:[]),NewDtrs) if
append_lists(Dtrs1,[Dcu2],NewDtrs),!.
form_new_daughters_list((xdtrs:Dtrs1),(xdtrs:Dtrs2),NewDtrs)
if append_lists(Dtrs1,Dtrs2,NewDtrs),!.

% Attach to same thread.

determine_new_threads((Dcu1,tempfoc:[(Tf1)],
temp_center:fwd_center:Threads),
Dcu2,Cue,NewThreads) if
determine_cue_word(Cue),
member_thread(Tf1,Threads,Thread),
add_to_thread(Threads,Thread,Dcu2,NewThreads),!.

calculate_tstuff((Dcu1,tempfoc:[(Tf1)]),
Dcu2,NewTempFoc,Relns,Rhet,Effect,Cue,
(bkwd_center:Bkwd,fwd_center:Threads),
(fwd_center:NewThreads,
bkwd_center:[Dcu2|Thread])) if
%% Separate the current thread from the list of previous threads

50
 remove(Bkwd,Threads,PrevThreads),
%% Are the criteria met for attaching to the current thread?
same_thread_attachment_possible(Effect,Dcu2,Rhet,Tf1,
SameThreadPoss,Bkwd,PossThreads1),
%% Are the criteria met for attaching to a previous thread?
prev_thread_attachment_possible(Effect,Dcu2,Rhet,PrevThreadPoss),
append_threads(PrevThreadPoss,PossThreads1,PrevThreads,PossThreads),
%% One of these sets of criteria must have been met or rule fails
xor(SameThreadPoss,PrevThreadPoss),
%% Determine which is the best of the possible threads to attach to
semantic_ratings(PossThreads,Dcu2,Cue,Bkwd,Thread),
%% Attach Dcu2 to the appropriate thread or create new thread
form_new_threads(SameThreadPoss,PrevThreadPoss,
Bkwd,Thread,Relns,Rhet,Effect,Dcu1,Dcu2,Cue,
PrevThreads,NewThreads,NewTempFoc).

% Attach to same thread.

form_new_threads(plus,_,Thread,Thread,
[(just_before:(arg1:Pindex1,arg2:Pindex2))],
just_before,Effect,
(Dcu1,tempfoc:[(Tf1,pindex:Pindex1)]),
(Dcu2,pindex:Pindex2),Cue,
PrevThreads,NewThreads,NewTempFoc) if
determine_new_threads(Dcu1,Dcu2,Cue,NewThreads),
choose_new_tempfoc(Dcu2,Tf1,NewTempFoc),!.

% Create new thread.

form_new_threads(_,plus,Bkwd,[],[(precede:(arg1:Pindex2,arg2:Pindex1))],
precedes,Effect,
(Dcu1,tempfoc:[(pindex:Pindex1)]),
(Dcu2,pindex:Pindex2),
Cue,PrevThreads,
[[Dcu2],Bkwd|PrevThreads],Dcu2) if true,!.

% Attach to previous thread.

form_new_threads(_,plus,[(pindex:PindexY)|Bkwd],
[(X,pindex:Pindexf)|Thread],
[(just_before:(arg1:Pindexf,arg2:Pindex2)),
(precede:(arg1:Pindex2,arg2:PindexY))],
precedes,Effect,
(fwd_center:Fwd),
(Dcu2,pindex:Pindex2),_,
_,NewThreads,Dcu2) if
not_equal(Bkwd,Thread),
add_to_thread(Fwd,[X|Thread],Dcu2,NewThreads),!.

51
append_threads(plus,PossThreads1,PrevThreads,PossThreads) if
append(PossThreads1,PrevThreads,PossThreads),!.
append_threads(minus,PossThreads1,_,PossThreads1) if true.

same_thread_attachment_possible(Effect,Dcu2,just_before,Tf1,plus,X,[X]) if
criteria1(Effect,Dcu2,Tf1),!.
same_thread_attachment_possible(_,_,_,_,minus,_,[]) if true.

prev_thread_attachment_possible(Effect,Dcu2,precedes,plus) if
consistent_effect(Effect,precedes),
event(Dcu2),!.
prev_thread_attachment_possible(_,_,_,minus) if true.

xor(plus,_) if true,!.
xor(_,plus) if true,!.

criteria1(Effect,_,_) if
boundp(Effect),
% Temporal expressions are consistent with just_before
consistent_effect(Effect,just_before),!.
% Dcu2 is a simple-tense event
criteria1(no_effect,(pindex:event,tenasp:aspect:simple),_) if true,!.
% Tf1 is an event and Dcu2 is simple-tense atelic
criteria1(no_effect,(pindex:atelic,tenasp:aspect:simple),pindex:event) if true,!.
% Tf1 is complex event/activity and Dcu2 is complex event
criteria1(no_effect,(pindex:event,tenasp:aspect:perf),
(pindex:event,tenasp:aspect:perf)) if true,!.
criteria1(no_effect,(pindex:event,tenasp:aspect:perf),
(pindex:activity,tenasp:aspect:perf)) if true,!.
% Tf1 is a complex event and Dcu2 is a complex state
criteria1(no_effect,(pindex:state,tenasp:aspect:perf),
(pindex:event,tenasp:aspect:perf)) if true,!.

% Checks if a temporal expression such as "in 10 minutes" indicates

% a temporal structure that is consistent with the choice of a
% rule to assign the eventualities a certain temporal structure.
consistent_effect(no_effect,_) if true,!.
consistent_effect(flashback,precedes) if true,!.
consistent_effect(flashback,overlaps) if !,fail.
consistent_effect(flashback,same_eventuality) if !,fail.
consistent_effect(flash_forward,just_before) if true,!.
consistent_effect(flash_forward,overlaps) if !,fail.
consistent_effect(flash_forward,same_eventuality) if !,fail.
consistent_effect(_,overlaps) if true,!.
consistent_effect(_,same_eventuality) if true,!.

52
consistent_effect(_,no_rhet_reln) if true,!.

boundp(no_effect) if !,fail.
boundp(flashback) if true,!.
boundp(flash_forward) if true,!.

% An event or activity can be the TEMPFOC, but not a state because

% states don't advance the narrative.
choose_new_tempfoc(Dcu,OldTempfoc,OldTempfoc) if
state(Dcu),!.
choose_new_tempfoc(Dcu,_,Dcu) if true,!.

% Effect: state overlaps tempfoc of Dcu1

calculate_tstuff((Dcu1,tempfoc:[(Tf1,pindex:Pindex1)]),
(Dcu2,pindex:(state,Pindex2)),
Tf1,[(included_in:(arg1:Pindex1,arg2:Pindex2))],
overlaps,Effect,Cue,
(bkwd_center:Bkwd),
(fwd_center:NewThreads,bkwd_center:[Dcu2|Bkwd])) if
% Temporal expressions are consistent with overlaps
consistent_effect(Effect,overlaps),
determine_new_threads(Dcu1,Dcu2,Cue,NewThreads),
initialize(Bkwd).

spast(Dcu) if equal(Dcu,(tenasp:(tense:past,aspect:simple))),!.
pperf(Dcu) if equal(Dcu,(tenasp:(tense:past,aspect:perf))).
pperf(Dcu) if equal(Dcu,(tenasp:(tense:past,aspect:perf_prog))).

get_tfocus(X,Y) if equal(X,(tempfoc:Y)).
get_tenasp(X,Y) if equal(X,(tenasp:Y)).

same_ta(X,Y) if
spast(X),spast(Y),!.
same_ta(X,Y) if
pperf(X),pperf(Y).

event(pindex:event) if true.
state(pindex:state) if true.
activity(pindex:activity) if true.
atelic(pindex:atelic) if true.

53
References
[Allen, 1984] J. F. Allen. Towards a general theory of action and time. Arti cial Intelligence,
23(2):123{154, 1984.
[Carpenter, 1993] Bob Carpenter. ALE: The Attribute Logic Engine User's Guide. Labora-
tory for Computational Linguistics, Philosophy Department, Carnegie Mellon University,
version edition, May 1993.
[Grosz et al., 1983] B.J. Grosz, A.K. Joshi, and S. Weinstein. Providing a uni ed account of
de nite noun phrases in discourse. In Proc. ACL-83, pages 44{50, 1983.
[Hinrichs, 1986] E. Hinrichs. Temporal anaphora in discourses of english. Linguistics and
Philosophy, 9(1):63{81, 1986.
[Hitzeman, 1993] J. M. Hitzeman. Temporal Adverbials and the Syntax-Semantics Interface.
PhD thesis, University of Rochester, Department of Linguistics, Rochester, NY, 1993. Also
available as TR 931, Cognitive Science Program, University of Rochester.
[Kameyama et al., 1993] M. Kameyama, R. Passonneau, and M. Poesio. Temporal centering.
In Proc. ACL-93, Columbus, OH, 1993.
[Kehler, 1994] Andrew Kehler. Common topics and coherent situations: Interpretating ellip-
sis in the context of discourse inference. In 32nd Annual Meeting of the Association for
Computational Linguistics, pages 50{57, June 1994.
[Lascarides and Asher, 1991] A. Lascarides and N. Asher. Discourse relations and defeasible
knowledge. In Proc. ACL-91, pages 55{63, University of California at Berkeley, 1991.
[Moens and Steedman, 1988] M. Moens and M. Steedman. Temporal ontology and temporal
reference. Computational Linguistics, 14(2):15{28, June 1988.
[Morris and Hirst, 1991] J. Morris and G. Hirst. Lexical cohesion computed by thesaural
relations as an indicator of the structure of text. Computational Linguistics, 17(1):21{48,
1991.
[Pollard and Sag, 1994] Carl Pollard and Ivan A. Sag. Head-Driven Phrase Structure Gram-
mar. University of Chicago Press and CSLI Publications, 1994.
[Reichenbach, 1947] Hans Reichenbach. Elements of Symbolic Logic. McMillan, 1947.
[Sidner, 1983] C. L. Sidner. Focusing in the comprehension of de nite anaphora. In M. Brady
and R. Berwick, editors, Computational Models of Discourse. MIT Press, Cambridge, MA,
1983.

54