Tài liệu Báo cáo khoa học: "PARAHETRIZED FOR LINGUISTIC ABSTRACT FORMATION OBJECTS PROCESSING" doc

PARAHETRIZED ABSTRACT OBJECTS
FOR LINGUISTIC INFORMATION PROCESSING
Helene Bestougeff, Gerard Ligozat
CNRS-Universite Paris VII
Z,Place Jussieu 75005 PARIS FRANCE
ABSTRACT
Programming languages which have
adequate primitives for linguistic
information processin~ and a clear
semantics at the formal computational
level are now slowly emergin~ as a
convergent effort from computer science,
linguistics, and artificial intelligence.
Our work on the processin~ of a special
kind
of
linguistic information, namely
temporal information ,has led us to
advocate the use of a language with the
following characteristic features:
-
high level of abstraction;
- capacity for inference;
- modularity.
A high level of abstraction is needed
to deal with complex lin£uistic notions
which are not easily reducible to
elementary data structures.
A capacity for inference is required,
as most criteria or tests in linguistics
make use of particular kinds of

deductions, at different levels of the
linguistic analysis.
As for modularity, a typical situation
in linguistics has to do with a hierarchy
of concepts or units, and the relations
between those units at different levels.
This paper discusses the relevance of
the choice of parametrized abstract
objects
as tools for linguistic
information processing and exemplifies
the use of such objects for temporal
information.
INTRODUCTION
In computational linguistics, more
than often there is a tendency to
directly implement a model without really
~oing through a specification step which
would provide a correct abstraction of
the implementation. This attitude has at
least two drawbacks: Firstly, there is no
formal way of comparing two models; this
can lead to some pointless discussions
between different approaches which, at
an abstract level, can be shown to be
equivalent; secondly, any extension or
modification of the implemented model
requires a different program instead of
a mere adjustment at the abstract level
which should facilitate the modular

updatin~ of the implementation and allow
a formal comparison between the old and
the new model.
Our work on tense -and time has
convinced us that, especially in
linguistic domains where models are
either loose or controversial, a
systematic approach to linguistic
information processin~ allowing
compatible constructions at all levels is
highly desirable. We therefore advocate
the use of a language with the following
features:
-
high level of abstraction;
- capacity for inference;
- modularity.
This paper is in two parts. In the
first part, we try to justify our choice
of abstract parametrized objects as
adequate tools for lin~uistic information
processing; in the second part we
exemplify our approach by ~ivin~ a
detailed account of the way we define and
construct temporal objects.
PARAMETRIZED ABSTRACT OBJECTS
One of
the
basic difficulties in
natural language processing arises from

the fact that modularity is both a
desirable and hardly attainable property
of the systems. At first it seems quite
reasonable to break the programs into
manageable, modular sub-programs0
especially as the linguistic data, at
least at first approximation,lend
themselves to a clear-cut classification
in terms of morphology, syntax, semantics
and pra~matics. Moreover, comparatively
sophisticated techniques and methods are
already available in eachsubfield.
Unfortunately, it has now become
107
commonplace knowledge that this strategy
of developing separate modules for each
sub-problem and integratin~ them smoothly
is not satisfactory: the operations of
parsing sentences, producing internal
representations, reasoning about them,
answerin~ questions, generatin~ text, and
so on, are strongly interdependent. The
degree, order and location of the
interactions between different parts may
vary significantly, according to
individual situations.
A consequence of the realization of
this fact has been the development of
strongly integrated, usually procedural
systems, where the individual sub-

programs operate simultaneously on
several deeply intricated linguistic
levels . The price one has to pay for a
relative success
of
this approach is in
terms of understandability
and
~eneralization: many systems are strongly
dependent on the particular type of
problem they have been programmed to
solve, and possible extensions or
transpouitions would require fundamental
modifications.
Uhat kind of software tools would
allow at the same time modularity and
multi-faceted, polymorphic and concurrent
interactions between processes ?
Modularity and complex interactions are
characteristic features of the object
oriented paradigm .
Modularity iS provided
by
the
structuration in terms of objects.
Complex interaction is a consequence of
the distribution of the control between
t~e different objects and of the
(possibly multiple) inheritance
facilities between hierarchically

dependent objects. The possibility of
using different points
of
views
fOr
the
same objects is a consequence of this
structuration.
This approach leads to focussing on
the basic process of abstraction. In
this context, abstraction is a process
which, starting from a description of the
data, yields an abstract specification.
This involves three steps.
- define the relevant objects for the
problem under study;
- define the possible functions and
relations on the objects;
-give explicitly the constraints
between the functions and relations.
The object-oriented approach is
usually equated with the Smalltalk
"vision" ( Goldberg and Robson, 1983 ),
while other views of objects are rejected
as being irrelevant or even self
contradictory.
Smalltalk objects can be characterized
by
the following properties:
- Each object is an instance of a class

(a generic object).
-
Each object has a local memory which
can only be updated by functions (or
procedures) local to the object.
-
Objects are orsanlzed into a tree-llke
hierarchy implyin~ tree-like inheritance.
-
Communication between objects is
organized through message passing.
However ,it has been argued that the
object oriented approach can be
fruitfully carried over into applicative
language contexts (Steels ,198Z) or into
particular systems based on lo~ic where
the fundamental mechanism is data
abstraction (Goguen et al. 1983).
As regards Smalltalk, it does not
provide systematic facilities for
deflnin~ abstract data types; all
computations are highly dependent on side
effects (assi£nment is systematically
used in local operations) and there is no
explicit typing.
ge favour the approach exemplified by
such lan£uaaes as OBJ and their possible
extensions (Goguen and Meseguer, 1984),
as we think that they will allow ,in the
lon~ range, a more efficient programming

style and make the systematic proof of
programs possible.
The OBJ languaQe is based upon data
abstraction: an object
is
a type (i.e. a
domain of values with functions accessing
those values);
objects are
organized into
a hierarchy ( an acyclic ~raph)
representin~ the dependencies among
types. Computations are performed by
using equatlonal axioms as oriented
rewrite rules.
Therefore , granted the availability
of a theorem prover ,
the
consistency of
the specifications given in the abstract
data type can be formally checked. More-
over , since the objects have a clear
mathematical definition, all the
techniques of abstract algebra are also
available.
More generally, axioms could be given
not only as equations . but also as
formulas in a logical theory (such as
first order predicate calculus or
temporal logics) assuming those theories

satisfy some given restrictions ( Goguen
and Bursta11, 1984).
As we have no access yet to any
version of OBJ, we have decided , in a
first stage, to restrict the object
structure to its free component, i.e.
only the signatures, not the axioms are
defined. Therefore~ the computations have
to be explicitely coded. As a
consequence,, no checking of consistency
108
is possible for the time being.
The actual implementation is done in
the ML language (Gordon et al., 1979).
ML is a functional language which is
fully higher-order. "It has a polymorphic
type
discipline which combines the
flexibility
of
programming in a typeless
language with the security
of
compile-
time type checking". Moreover, one can
define one's own types , which may be
abstract and/or recursive.
To give a flavour of the ML
programming style, consider a possible
definition of the abstract recursive type

of binary trees, with tip values
of
an arbitrary type (denoted by *) and non
tip nodes of some other arbitrary type
(denoted by **). (This exemple is taken
from Gordon et al., 1979):
absrectype
(*,**)
tree
=
* +
** # (*,**)tree
#
(*,**)tree
with tiptree x = abs_tree (inl x)
and comptree (y,tl,t2) =
abs_tr(~u (inr (y,tl,t2))
and istip t =isl(rep_tree t)
and tipof t=
outl(reptree
t)
and labelof t = fSt(OUtr (reptree t))
and sonof t =snd(outr(reptree t))
This type is defined as recursive and
abstract. The symbols "+" and "#"
respectively, denote the two type
constructors "disjoint sum" and
"cartesian product" The functions
"abs_tree" and "rep_tree" ,both of them
of type

(ty -> ty), are only available
inside the definition
of
the abstract
type "tree" : abs_tree maps the concrete
representation of a tree unto its
abstraction; rep_tree has the converse
effect. Finally, isl, inl, inr, outl,
outr are functions or predicates on the
disjoint sum. They are defined as
follows:
isl: (* + **) -> bool
tests membership
of
left summand;
inl: * -> (* + **)
injects into left summand;
inr: * -> (** + *)
injects into right summand;
outl: (* + **) ->
*
projects out left summand;
outr:
(* + **) -> **
projects out right summand.
The signature of this type is the set
of operators:
tiptree=-: * -> (**,*)tree
comptree=-:
• # (**,*)tree # (**,*)tree ->(*,**)tree

istip=-: (*,**)tree ->bool
tipof=-: (*,**)tree ->**
l~belof=-:(*,**) tree -> *
sonof=-:
(*,**)tree ->((**,*)tree
# (**,*) tree))
The version of ML we use (INRIA ,1984)
is written in Lisp with access to the
lisp system. So our object environment is
constructed as a collection of abstract
data types. The hierarchy between types
results from the combination and
enrichment of more basic types. This
hierarchy creates multiple inheritance
relations between types. Some examples
will be given in the context of temporal
objects.
Clearly, the management of the object
level must be done on top of ML The
explicit coding mixes Lisp and ML.
As we work in a functional environment
there is no "local memory".However, this
is , to our viewpoint, a minor drawback
compared to the advantage of the
abstraction facilities.
In a next stage, we intend to introduce
the necessary axioms and perform the
computations in a deductive style.
This approach can be used for the
formal representation of natural

language, or as a grammar formalism . In
particular the syntactical
and
semantical
analysis can be done in terms of objects.
(De Boissieu and Forest , 1985).
PROCESSING TEHPORAL INFORMATION
Tense and time representation in natural
languages is generally studied under
one of the three main disciplines :
logics, linguistics,
and
artificial
intelligence. A brief overview of these
4
different vlewpolnts is given in
(Bestougeff an Ligozat, 1984).
The main problem is to choose the
relevant objects in order to get an
adequate abstraction. It must be strongly
emphasized that we deny ourselves the
right to assume any particular physical
representation of time from the outset.
The concrete properties result from the
specifications.
The choice of the basic objects is
somehow arbitrary, but it should
nevertheless comply to the following
rules :the objects must be
- close to linguistic intuit{on.

- general enough to be reusable as
such in different contexts, or give rise
to new objects
by
enrichment or
inheritance.
The second point is required to avoid
109
ad-hoc and independant specifications. To
achieve these goals it may be necessary
to define primitive objects, which do
not
have any lingustic interpretation but are
merely buildinE blocks whose use enhances
modularity
In this case ,the lower level objects can
be hidden to the user
Keeping this in mind ,we can now
proceed to the description of the
linguistic motivations which are behind
the construction of temporal objects
The idea is to ~ive a systematic way of
representing temporal information
by
defining abstract structures based upon
the concepts and the hypotheses of a
particular linguistic theory.
The linguistic theory we rely on is
that of A. Culioli (Culioli, 1980),
suitably adapted to computational

purposes.
Temporal information can be informally
characterized as information pertaining
to the location and "shape" of the states
and events described by natural language.
In
particular, this includes what is
commonly referred to as aspect.
Furthermore, temporal information in
natural language has both a descriptive
and an operative structure: it describes
and allows the users to make systematic
inferences. Among these inferences are
those concerned with the ordering of
events, but such inferences are only part
o~ a whole set of inferences on the
factuality, the degree of completion, the
type of occurrence, of the situations
considered. In fact, it can be argued
that the ordering relations are not
necessarily of a primary nature.
Some examples will illustrate the
kind of data and inferences we have in
mind.
Consider the following simple
sentences:
(i) John is ill.
(2)
John repairs cars.
(33 John is repairing my car.

(4) John repaired my car.
(5) John has repaired my car.
(6)
John was repairing my car.
(7) My car has been repaired.
(83 My car is repaired now.
(9) John was singing.
(i0) John sang.
(Ii) John has been singing.
(12) Cats are smart.
We wish to account for some basic
information imparted by the use of such
sentences. For example:
-
Sentence (2) does not imply (3),
neither does sentence (3) imply sentence
(2).
- Sentence (4) implies sentence (7), not
(8).
- Sentence (5) implies sentence (8).
- Sentence (6) implies neither sentence
(7) nor, a fortiori, (8), whereas
sentence (9) implies sentences (i0),(ii).
The different uses of the simple
present tense in (I) and (Z) are related
to a difference between the semantic
types of the verbs t_So bee ili and to
repair. We will account for this
difference by adapting a classification
(essentially due to Vendler (1967)) into

four semantic types ( state, activity,
accomplishement, achievement
)
. The
usefulness
of
such a classification is
further illustrated
by
comparing the
behaviour
Of
the verb to repair in
sentences (6, 7, 8) with that of the verb
t So sin~ in (9, 10, 11).
The
comparison between (4) and (6) in
relation with (7) shows the necessity
of
suitably representing the difference
between the simple and the progressive
past, at least for verbs of the type to
repair a car
,
which are classified as
accomplishments.
To represent the difference between
(4) (simple past) and (5) (present
perfect), we have to express what makes
(8), but not (4), derivable from (5).

Reichenbach's system of temporal indexes
(point of speech, point of event, point
of reference ) can be used to handle
this phenomenon (Reichenbach, 1957 ). It
provides a way of describin~ the notion
of "present relevance", which is present
in (5) , but not in (4).
The contrast between (1 , 2) and (12.)
points to another kind of distinction one
has to make: (i) expresses a state, (2) a
habit, which hold at the moment of
speech. On the contrary, (12) states a
general fact which is basically
undetermined with respect to the moment
of speech. Dependence on the time of
speech is a fact of temporal deixis. Ue
shall refer to it as enunsiativit Z ,
(following A. Culioli) . By opposition
situations such as (12) will be termed
aoristic.
The preceding examples give sume idea
of the type of information that has to be
represented. We have deliberately played
down the purely sequential type of
information, which is the only type of
temporal information most systems are
concerned with.
Moreover, the purely sequential
type of information is mostly incomplete
110

(this is stressed in particular
by
Smith
(1978)). Consider the followina examples:
(13) John saw his doctor this morning:
he is ill.
(14) John saw his doctor this morning:
now he is ill.
Contrastin~ (13) and (14) shows a
potential indeterminacy in the relation
between the two sentences. Smith (1978)
claims that sentences like (I), where no
explicit "reference time" is provided
(e.g. by a time adverbial such as now)
are temporally incomplete. Ue will be
content at this point of our discussion
with notin~ the need for a convenient
notation for such a phenomenon.
TEMPORAL OBJECTS
Ue assume that temporal information
in a text can be represented
by
proceedin~ in three steps of increasin~
difficulty:
-
Tense in main clauses.
-
Tense in subordinate clauses.
-
Tense in texts.

This hierarchy follows that Of Ejerhed
and Janlert ( 1981).
To summarize the discussion of the
previous paragraph, the followina
elements of temporal information have to
be abstracted:
-
temporal deixis (enunciative vs.
aoristic situations) . Followin~ Comrie
(1976), we use the term "situation" as a
generic term coverin~ states, events or
processes .
- inception and termination of a
situation.
- information relative to the
completion of the situation.
-
local inferences on situations.
-
mass/count properties of situations.
In our system, these elements are
reconstructed from the followin~
linguistic data:
- tenses in the finite forms of verbs.
temporal specifiers (temporal
adverbials).
-semantic types of situations
(computed from the semantic type of the
verbs & la Vendler, and the syntactic
structure of the proposition).

At this point, most existin~ systems
of representation make a choice, since a
notion of duration has to be included in
the model as well. Either one conceives
of the basic elements as points, and the
notion of an interval has to be
introduced; or an interval is a basic
element, and a second relation (of
overlapplna or inclusion ) is introduced.
In fact, in most existina models of time,
the basic elements of time are conceived
as
elements or
subsets of (a subset o£)
the real line (or some ramified structure
built from it).
The choice of either "points" or
"intervals" as basic elements leads to
definite advantages and particular
difficulties. The point model is
basically simpler,
but
in
some
way harder
to justify semantically. However, as
shown by Kamp (1979) and Van Benthem
( 1980 ), both points of views are
essentially equivalent.
Our claim in the matter follows the

~eneral philosophy of abstraction:
Instead o£ the nature of
the
basic
elements, consider their intended
properties and combination rules for
buildin~ derived elements. This
combinatorial point of view is implicit,
for example, in Allen's model (Allen 83),
where a set of "intervals" is abstractly
characterized by the relations holdin~
between its elements. It can be shown
(Bestou~eff and Li~ozat ,1984) that any
set theoritic model of Allen's axioms is
equivalent to (a subset) of the intervals
(that is, couples of points) on a totally
ordered set.
In our model,the basic elements are
typed boundaries, with a (partial) order
defined on them. As shown in (Bestougeff
and Li~ozat, 1984) an alternative way of
considerin~ the same abstraction would be
in terms of "intervals", where an
interval is a couple (bl, b2) of
boundaries with bl <b2 . In other words,
the term "interval" has only the notions
of a be~innina and an end associated with
it, and it is immaterial whether one or
the other terminology is used. No
topolowical p~operties are implied , only

combinatorial properties (in terms of the
types of boundaries ) are retained in the
abstraction. Boundary types are
introduced in the model in order to
represent aspectual properties of the
data.
As an example, consider again
sentences (1) to (12).
The state be ill in (i) holds upon an
interval whose left and right boundaries
are "closing" and "opening",
respectively. This is a general situation
for states in an enunciative setting.
The event John repair my ca _~ in (5),
conversely, holds upon an interval with
resp. "opening" and "closina" left and
right boundaries. Consequently, the
adjacent resultin~ state
"my
car is
repaired" holds on an interval with a
111
"closing" left boundary, as a state
should. The combination in (5) of a verb
of accomplishment with a "closing" risht
boundary insures that such a resulting
state does indeed exist. This is to be
contrasted with the situation in
(6).
There, the right boundary is an "opening

one", which prevents the inference of a
completed action from bein8 made•
It
seems
that the introduction of
such typed boundaries is enough
to
capture the intuition behind the use of
topological intervals in systems
representing tense and time. The approach
chosen here prevents the overloading of
the objects with unnecessary or
undesirable properties, as is the case
when a concrete model like the real line
is adopted.
In terms of implemented objects, this
corresponds to the definition of abstract
intervals from typed boundaries and
predicate information (the latter can be
empty).
AS an example , the explicit
definition of an interval is as follows :
abstype intv =boundary # pred# boundary
with make_intv (11,12,13)=
abs_intv (11,12,13)
and left I =fst (rep intv i)
and right
1 =
snd (snd (rep_intv i))
and 8etp 1 =fst (snd (rep_Intv l))

and purl (b,i)=
if fst (rep_intv i)
=U
then abs_intv
(b,fst(snd(rep_intv)),
snd(snd (rep_intv
i)))
else i
and putr(b,i)=
if snd(snd(rep_intv i)) =
U
then abs_intv(fst(rep_intv i),
fst(snd(rep_intv i)),b)
else i
and show_intv 1 =rep_intv i;;
The signature of this object is the
set of typed operators:
make_in#v=-:
(boundary # pred# boundary) -> intv
le~t=-: intv -> boundary
right=-: intv -> boundary
getp =-: intv -> pred
purl =-: (boundary#in#v) -> intv
purr =-: (boundary # intv ) -> intv
show intv =-:
intv ->(intv + (intv # nseq))
It seems intuitively satisfying to
consider the stretch of time involved in
a simple clause as totally ordered. The
local inferences operate on this

restricted scope.
To abstract this phenomenon
we
introduce interval sequences with
constraints on the boundary types of
adjacent intervals:
absrectype
nseq= intv
+
in# #
nseq
force=-: intv -> nseq
ncons=-:(intv#nseq) -> nseq
make tnseq=-:(intv # nseq) -> nseq
show nseq=-:
nseq -> (intv + (intv # nseq))
The central object in the model
corresponds to a simple clause. It is
called a polytyped stt-ing (or PTS). It is
obtained from an interval sequence by
addin~ the information about temporal
indexes a la Reichenbach:
abstype pts =nseq #index
make_pts=-:((nseq #index) -> pts)
fl=-: pred -> pts
f2=-: pred -> pts
fn=-: pred -> pts
rules:-:
(status # tense # vendler # adverbial)
-> pred -> pts)

apply rules =-:
(pred
# status) ->
pts
where the functional type "pred-> pts"
denotes the set of functions which build
PTS's from predicate information.
The predicate information is given
through the " rules" where "status" is
the information relative to the
enunciative vs. aoristic status; "tense"
denotes the morphological tense of the
clause, "vendler" , the Vendler class
(i.e. state, activity, accomplishement
or achievement ) computed from classe(s)
assigned to verbs in the dictionary and
the syntactical configurations ; finally
"adverbial" corresponds to information
attached to the time adverbials.
Up to this point , we have described
the fundamentals of the system of
representation. Of course, the actual
construction of the representative
temporal object for a text in a given
language is highly language dependent.
For instaxlce, the present tense in French
(which is the language we are working on)
is not in a simple correspondance with
the "corresponding" simple present in
English. Consequently , referrin~ to the

objects described above, the functions
"fi", and "rules" are quite specific to
the structure of the language
represented.
The temporal relations in longer units
of discourse are comparatively much more
loosely specified. Consider the following
112
example:
(15) Shakespeare is dead. John is ili.
And I am not feelin~ well either.
Apart from considerations pertainin~
to real-world knowledge, no information
is given about the relative order of the
beginnings of the three situations
considered. So the representation should
allow for indeterminacy, either in
listin~ all possible alternatives (this
would be the case in Allen's model), or
in leaving the order unspecified. This
more economical solution is chosen here.
Compare (15) to the followin@:
(16) Mary ~ot pregnant. She married John.
(17) Mary married John. She got pregnant.
Here, the order of discourse seems
pertinent and should be represented.
More complex examples in this respect
are:
(18) John was
angry

when Mary dropped the
V as e .
(19) Mary dropped the vaue. John was
ansry.
(20) John was angry. Mary dropped the
vas e.
where (19) or alternatively (20) can be a
paraphrase of (18).
The precedin~ discussion shows that
the total ordering at the sentence level
cannot in ~eneral be extended to lar~er
units in a simple way. The eventual
relations between different simple
sentences are a result of a computation
makin~ use of the temporal structure of
those sentences and the order of
discourse.
This fact is captured as follows: The
structure representin~ a text is
constructed stepwise. At each step of the
construction,
the
exlstin~ structure
provides a context, in which the order of
discourse, in particular, is represented.
In technical terms, the corresponding
object is called "temporal site". It is
composed of a sequence of PTS's together
with a set of relations on the boundaries
of the constituent PTS's.So the next

sentence to be examined, taken in
isolation, is represented by a possibly
incomplete structure (a polytyped string)
with a total order on it, but with
possible indeterminacies (for example, in
the assignment of time indexes). This new
structure is inserted into the old one,
(already constructed temporal site )
thereby creatin~ new constraints
resulting in the evaluation of some
undetermined parameters in both
structures.
Here a~ain, the precise combination
rules are lanKua~e specific, as they
depend on the semantic properties of the
time relations in the lan~uaae.
It is beyond the scope of this paper
¢o give the rules used for French.
However ¢o ~ive an indication of what the
construction amounts to , consider
the
following english sentences:
(21) John was in love with Nary;
(22) John has built his house;
(23) John was building his house when I
left for Rome.
The analysis of (21) yields:
tense : simple past;
status : enunciative (by default);
vendler :state;

adverbial :none.
Denoting by "p" the predication: John
is in love with Mary, the structure of
the representing PTS can be Symbolized by
the formula :
C1 p O2 ~ 03 ($3 R2)
where the C's and O's denote closin8 and
opening boundaries and S and R,points of
speech and reference respectively . These
are indexed by the order of occurrence of
the correspondin~ boundaries. ~ denotes a
dummy predication.
Consider sentence
(22)
Here
tense : present perfect;
status : enunciative (because of the
present perfect tense);
vendler : accomplishment (perfect form);
adverbial : none.
The formula :
01 p C2 reslt(p) 03 ($3 R3)
describes the associated 9TS, where p is
John builds his house and reslt(p) is a
resultin~ state, obtained by local
inference, which expresses : the house is
built .
Finally, consider sentence
(23).
The

associated temporal site can be
symbolized by:
1: O1 p 02 ~ 03
2:01 q C2 ~ 03
($3,R2)
(S3,R2)
REL:
01:1 < 01:2
02:1 >= 01:2
This temporal site contains two FTS's,
with p = John builds his house and q=
I leave for Rome .q is an achievement in
Vendler's classification. The additional
information concerns the ordering
relations between the boundaries of the
PTS's, numbered 1 and 2.
Ue have been mainly concerned with
the representation of what we have termed
enunciative situations (as opposed to
aoristic ones). This is justified , as
113
such
situations
play a
central role in
discourse. Concerning aoristic
situations, similar representative
s~ructures are used, which are in fact
more
strictly constrained.

Habitual situations (e.g. sentence
(2)) involve a particular treatment of
the predicative component, but otherwise
fit into the general scheme described
above. From this point of view, they are
no different from factual situations.
Dispositional sentences, on the other
hand, cannot be discussed without
entering the domain of modalit¥. Although
this may seem a serious limitation
(especially for English, where modality
is all pervasive ), we leave it aside in
the present consideration of tense and
time.
The preceding discussion illustrates
the use of linguistic inference at three
distinct levels:
a) At the simple sentence level,
building a representation involves a
first type of inference, which makes use
of morpho-syntactic and lexico-semantic
information .
b) At the next higher level, as
illustrated
by
examples (15-20), another
type of inference is used to specify and
build the correspondln~ structures
(temporal sites).
c) Still another kind of lln~uistic

inference should account for the possible
derivabilities Or paraphrasings mentioned
pr0pos examples (1-12). Its
formalization should make it possible to
describe this inference which, starting
from a ~iven temporal site allows to
deduce new sites from it.
Whereas the first two types of
inference
are
constitutive of the
derivation of temporal structures and are
central to our activity, the last type
has still to be defined and examined in a
systematic way i.e. defined explicitely
as derivation rules. In this context, the
facilities for self-reference and
structural inference in the software
environment are of primary relevance.
REFERENCES
Allen,J.A.1983 Maintaining knowledge
about temporal intervals. Comm.ACM 26
pp.832-843.
Bes%ougeff, H. and Ligozat, G. 1984a
Processing Tense Information in French
Utterances. Proceedings of the
6th
European Conference on Artificial
Intelligence. Pisa, Italy:209-Z12
Bestougeff, H. and Ligozat, G. 1984b

L'inf~rence temporelle en situation
orient~e par l'action. Proceedings of
the CNRS Greco Seminar.Nancy, France.
Bestougeff, H. and Ligozat, G. 1984c
Temporal Intervals Revisited.
CNRS Research Report, Paris 7.
Culioli, A. 1980 Valeurs aspectuelles et
op4rations 4noncia~ives. In David,J.and
Martin, R., Eds., La notion d'aspect.
Klincksieck, Paris: 181-193.
Comrie, B. 1976 Aspect. Cambridge
University Press
De Boissieu, A. and Forest, F. 1985
Analyse linguistique en termes
d'objets.CNRS Research report,Paris 7.
Ejerhed, E.I. and Janlert, L.E. 1981
Representing
time
in natural language
processing. In Proceedings o£ the
Workshop on Models of Dialogue
Linkopin~ UIT.
Goguen,J.A. Meseguer, J. P1aisted, D.
1983 Programming with Parametrized
Abstract Objects in OBJ. in Theory and
Practice of Software Technology. D.
Ferrari, M.Bolognani and Goguen Eds.
North Holland.
Goguen, J.A. and Burstall, R.M. 1984
Introducing Institutions. in

Proceedings , Logics of Programming
Workshop. EoClarke and D.Kozen Eds.
Lecture Notes in Computer Science,
Vol 164 Springer Verlag.
Goguen J.A. and
Meseguer
J. 1984
Equality,Types,Modules and (why not?)
Generics for Logic Programming. J.
Logic Programmin~ 1984:2.
Goldberg, A. and
Smalltalk-80.The
implementation.
Publishin~ Company.
Robson, D. 1983
language and its
Addison Wesley
Gordon,M.J., Milner, A.J. Wadsworth,L.P.
1979 Edinburg LCF. Lecture Notes in
Computer Science Vol
78
Springer
INRIA. 1984 The ML Handbook Version
5.1. Report of Institut National de
Recherche en Informatique et
Automatique. France.
Kamp, H. 1979 Events, Instants, and
Temporal Reference. In Egli,U. and Von
Stechow, A., Eds. Semantics from a
multiple point o£ view. De Gruyther,

Berlin: 376-417.
114
Reichenbach, H. 1957 The Philosophy of
Space and Time. New York.
Smith, C. 1978 The syntax and
interpretation of temporal expressions
in English. Linguistics and Philosophy
2: 44-99.
Steels, L. 1983 ORBIT : An Applicative
View of Object Programming. in
Integrated Interactive Computing
Systems .P.Degano, E. Sandewall Eds.
North Holland.
Van Benthem, J. 1980 Points and
periods. In Rohrer, C., Eds., Time,
Tense, and Quanti£iers, Niemeyer,
Tuebingen:39-57.
Vendler, Z.
1967
Linguistics in
Philosophy. Cornell University Press,
Ithaca.
115