[mod.ai] Seminars - Programming Languages & Temporal Knowledge

gideon%edai.edinburgh.ac.uk@CS.UCL.AC.UK (Gideon Sahar) (06/17/86)

EDINBURGH AI SEMINARS

Date:    Wednesday 28th May l986
Place:   Department of Artificial Intelligence
         Seminar Room
         Forrest Hill
         EDINBURGH.

Dr. M. Steedman, Centre for Cognitive Sciences and Department of Artificial 
Intelligence will give a seminar entitled - "Combinators, Universals and
Natural Language Processing".

Combinators are primitive elements in terms of which we can define the notion
of defining a function, as with the lambda operator of LISP, without the use
of the bound variables which are associated with that operator, and which are
so expensive for interpreters of LISP and related functional programming
languages.   For some time, my colleagues and I have been arguing that the
syntax and semantics of certain problematic "unbounded dependencies" and 
"reduced" constituents in natural language constructions such as English
relative clauses and coordinate constructions can be elegantly captured by
extending Categorial Grammars (discussed by Ewan Klein here a couple of months
ago) with operations corresponding to certain simple combinators.   Such
grammars hold out the promise of a theory according to which natural language
syntax is a very direct reflection of a computational efficient applicative
semantics which minimises the use of bound variables.   The paper concerns
some implications for processing and the prediction of certain contrasts
between the grammars of Spanish and English.



Date:    Wednesday, 4th June l986
Time:    2.00 p.m.
Place:   Department of Artificial Intelligence,
         Seminar Room,
	 Forrest Hill,
	 EDINBURGH.


Professor Colin Bell, University of Iowa will give a seminar entitled -
``A Point-Based Representation of Temporal Knowledge in Automated
Project Planning".

A point-based temporal reasoning system is presented as an alternative
to existing interval-based temporal logics.   It appears to be
especially applicable in nonlinear hierarchical planning where such
temporal quantities as activity durations and scheduling delays are
uncertain.   Temporal constraints representable in this system fall into
a very restricted class.  However, it is argued that representing more
general constraints results in computational intractability.   Details
of implementation are discussed.



Date:    Wednesday, 11th June l986
Time:    2.00 p.m.
Place:   Department of Artificial Intelligence,
         Seminar Room F10,
	 80 South Bridge,
	 EDINBURGH.


Mr. Peter Jackson, Department of Artificial Intelligence, University of
Edinburgh will give a seminar entitled - ``Towards a Methodology for
Designing Problem Solving Architectures in the Object-Oriented Style".

Although current object-oriented systems provide the programmer with both
software modules (such as production rule interpreters and theorem provers)
and software tools (such as browsers and debuggers), they fail to provide a
set of guidelines as to how to select and combine modules to create a
particular architecture.  Too often, one is given some combination of
Flavors, OPS and Prolog (or their look-alikes), and then left to get on with
it.  A further criticism is that the modules provided do not lend themselves
to adaptation by specialization in the spirit of the object-oriented
environment in which they are embedded.

A methodology for creating 'abstract architectures', which can be
instantiated via a process of specialization, is described in the context of
a new object-oriented programming language called SLOOP.  A detailed example
is given of how to create a generic production rule architecture whose
behaviour is easy to modify incrementally, together with a sample problem
solving program.  It is suggested that certain features of SLOOP, namely
its transparency and the fact that it is mostly implemented in itself, make
it particularly useful as a vehicle for tasks of this kind, while some of
the facilities offered, such as pattern-matched parameter-passing and the
ability to compile SLOOP into Lisp and thence into native code, encourage a
functional style of programming without extracting too high a price in terms
of efficiency.