
     ENTAILMENT AND DISENTAILMENT OF ORDER-SORTED FEATURE CONSTRAINTS
                                 (SUMMARY)

                    Hassan Ait-Kaci    Andreas Podelski
                       Digital Equipment Corporation
                         Paris Research Laboratory
                          85, avenue Victor Hugo
                       92500 Rueil-Malmaison, France
                        {hak,podelski}@prl.dec.com


                                 ABSTRACT

LIFE uses matching on order-sorted feature structures for passing arguments
to functions.  As opposed to unification which amounts to normalizing a
conjunction of constraints, solving a matching problem consists of deciding
whether a constraint (guard) or its negation are entailed by the context.
We give a complete and consistent set of rules for entailment and
disentailment of order-sorted feature constraints.  These rules are
directly usable for relative simplification, a general proof-theoretic
method for proving guards in concurrent constraint logic languages using
guarded rules.

(ait-kaci.ps.Z, 6 pages)



      SEPARABILITY OF POLYHEDRA AND A NEW APPROACH TO SPATIAL STORAGE

                   Alexander Brodsky    Catherine Lassez
                  I.B.M. Thomas J. Watson Research Center
                               P.O. Box 704
                        Yorktown Heights, NY 10598


                                 ABSTRACT

Efficient storage and access methods for large amounts of spatial objects
are key issues in Geographic Information Systems (GIS), Computer Aided
Design (CAD), VLSI design and also Linear Constraint Databases (LCDBs)
[BJM92], a new application domain in which objects are convex
multidimensional polyhedra represented as conjunctions of linear
constraints over real variables.  Typically, the first step of query
processing is the filtering out of irrelevant information.

We propose a new filtering method which is based on pre-evaluation of
projections of objects (polyhedra) on a number of selected axes.  We are
concerned with how to achieve any desired quality of filtering by selecting
(a minimum number of) optimal axes, while keeping storage overhead low.

(brodsky.ps.Z, 5 pages)



CONSTRAINT OPTIMIZATION USING PREFERENCE LOGICS: A NEW ROLE FOR MODAL LOGIC

          Allen L. Brown, Jr.    Surya Mantha    Toshiro Wakayama

                          Webster Research Center
                             Xerox Corporation


                                 ABSTRACT

A family of modal logics of preference is presented.  It is argued that
modeling preference as a modal operator captures it at the correct level of
granularity and extracts the logical core of the notion of preference.
Next, the problem that motivated the development of preference logics is
discussed in some detail.  The paper ends with a list of other areas in
which preference logics have shown promise.

(brown.ps.Z, 10 pages)



     USING A VISUAL CONSTRAINT LANGUAGE FOR DATA DISPLAY SPECIFICATION

                              Isabel F. Cruz
                      Department of Computer Science
                             Brown University
                         Providence, RI 02912-1910
                             ifc@cs.brown.edu


                                 ABSTRACT

In this paper we introduce the U-term language, a constraint-based language
that has a visual syntax, and allows for the declarative specification of
the display of data.  Other features of the U-term language include: (1)
simplicity and genericity of the basic constructs; (2) ability to specify a
variety of displays (pie charts, bar charts, etc.); (3) compatibility with
the object-oriented framework of the database language DOODLE.

(cruz.ps.Z, 12 pages)



         CONSTRAINT MANAGEMENT IN A DECLARATIVE DESIGN METHOD FOR
                         3D SCENE SKETCH MODELING

            Stephane Donikian                  Gerard Hegron
                  IRISA                  Ecole des Mines de Nantes
           Campus de Beaulieu               3 rue Marcel Sembat
       35042 Rennes Cedex, FRANCE      44049 Nantes cedex 04, FRANCE
            donikian@irisa.fr                  hegron@emn.fr


                                 ABSTRACT

In this paper, we present a dynamic model associated with an intelligent
CAD system aiming at the modeling of an architectural scene sketch.  Our
design methodology has been developed to simulate the process of a user who
tries to give a description of a scene from a set of mental images.  The
scene creation is based on a script which describes the environment from
the point of view of an observer who moves across the scene.  The system is
based on a declarative method viewed as a stepwise refinement process.  For
the scene representation, a qualitative model is used to describe the
objects in terms of attributes, functions, methods and components.  The
links between objects and their components are expressed by a hierarchical
structure, and a description of spatial configurations is given by using
locative relations.  The set of solutions consistent with the description
is usually infinite.  So, either one scene consistent with this description
is calculated and visualized, or reasons of inconsistency are notified to
the user.  The resolution process consists of two steps: firstly a logical
inference checks the consistency of the topological description, and
secondly an optimization algorithm deals with the global description and
provides a solution.  Two examples illustrate our design methodology and
the calculation of a scene model.

(donikian.ps.Z, 10 pages)



                 THE GEOMETRY IN CONSTRAINT LOGIC PROGRAMS

                     Thomas Dube          Chee-Keng Yap
                   dube@cs.nyu.edu        yap@cs.nyu.edu

                Courant Institute of Mathematical Sciences
                            New York University
                             251 Mercer Street
                         New York, New York, 10012


                                 ABSTRACT

Many applications of constraint programming languages concern geometric
domains.  We propose incorporating strong algorithmic techniques from the
study of geometric and algebraic algorithms into the implementation of
constraint programming languages.  Interesting new computational problems
in computational geometry and computer algebra arises from such
considerations.  We look at what is known and what needs to be addressed.

(dube.ps.Z, 7 pages)



       ON THE SEMANTICS OF OPTIMIZATION PREDICATES IN CLP LANGUAGES

                              Francois Fages

               LIENS-CNRS,          and        LCR Thomson-CSF,
        Ecole Normale Superieure,           Domaine de Corbeville,
              45 rue d'Ulm,                   91404 Orsay Cedex,
           75005 Paris, France                      France.
            fages@dmi.ens.fr


                                 ABSTRACT

The Constraint Logic Programming systems which have been implemented
include various higher-order predicates for optimization.  In CLP(FD)
systems, several optimization predicates, such as "minimize(G(X),f(X)),"
"minimize-maximum(G(X),[f1(X),...,fn(X)])," are implemented by using branch
and bound algorithms.  In CLP(R) systems, the Simplex algorithm used for
satisfiability checks can also be used for linear optimization through the
predicate "rmin(f(X))" which adds to the constraints on X the ones defining
the space where the linear term f(X) is minimized.  These optimization
constructs do not belong however to the formal CLP scheme of Jaffar and
Lassez, and they lack a declarative semantics.  In this paper we propose a
general definition for optimization predicates, for which one can provide
both a logical and a fixpoint semantics based on Kunen-Fitting's semantics
of negation.  We show that the branch and bound algorithm can be derived as
a refinement of the implementation of the semantics using CSLDNF-resolution,
and that the branch and bound algorithm can be lifted to a full first-order
setting with constructive negation.

(fages.ps.Z, 9 pages)



                        A HIGHER-ORDER EXTENSION OF
               CONSTRAINT PROGRAMMING IN DISCOURSE ANALYSIS

                               Tim Fernando
                Centre for Mathematics and Computer Science
             P.O. Box 4079, 1009 AB Amsterdam, The Netherlands
                              fernando@cwi.nl


                                 ABSTRACT

Variables on which constraints are imposed incrementally can be said to
carry "existential" force in the following sense.  Under a translation,
commonly used in analyzing natural language discourse, of first-order
formulas into programs from quantified dynamic logic, such a variable is
introduced (at the level of formulas) by an existential quantifier.  The
present paper extends that translation to support constraints on variables
introduced, as it were, by universal quantification.  The extension rests
on a certain program construct "=>" that can be interpreted (following
Kleene's realizability analysis of universal-existential clauses) by
closing the collection of states on which the programs act under partial
functions.  An alternative "reduced" interpretation of "=>" can also be
given over sets of states from dynamic logic (not unlike Concurrent Dynamic
Logic).  These interpretations can be related by what is essentially a
reduction to disjunctive normal form, involving so-called and-or
computations.

(fernando.ps.Z, 10 pages)



  A DISJUNCTIVE DECOMPOSITION CONTROL SCHEMA FOR CONSTRAINT SATISFACTION

                             Eugene C. Freuder
                               Paul D. Hubbe

                      Department of Computer Science
                        University of New Hampshire
                         Durham, NH 03824, U.S.A.
                              ecf@cs.unh.edu
                              pdh@cs.unh.edu


                                 ABSTRACT

The paper presents a control schema for constraint satisfaction.  Several
algorithms, old and new, are formulated as instances of this schema by
specifying different methods of problem decomposition.  This formulation
facilitates description and comparison of the algorithms and suggests
directions for further research.  A new decomposition method is presented
that is virtually guaranteed to reduce problem size, while always retaining
at least one of the solutions to the original problem.

(freuder.ps.Z, 10 pages)



          TERMINOLOGICAL REASONING WITH CONSTRAINT HANDLING RULES

            Thom Fruehwirth                 Philipp Hanschke
        ECRC, Arabellastrasse 17          DFKI, Postfach 2080
      D-W-8000 Munich 81, Germany   D-W-6750 Kaiserslautern, Germany
              thom@ecrc.de               hanschke@dfki.uni-kl.de


                                 ABSTRACT

Constraint handling rules (CH rules) are a flexible means to implement
"user-defined" constraints on top of existing host languages (like Prolog
and Lisp). Recently, M. Schmidt-Schauss and G. Smolka proposed a new
methodology for constructing sound and complete inference algorithms for
terminological knowledge representation formalisms in the tradition of
KL-ONE.  We propose CH rules as a flexible implementation language for the
consistency test of assertions, which is the basis for all terminological
reasoning services.
   The implementation results in a natural combination of three layers:
(i) a constraint layer that reasons in well-understood domains such as
rationals or finite domains, (ii) a terminological layer providing a
tailored, validated vocabulary on which (iii) the application layer can
rely.  The flexibility of the approach will be illustrated by extending
the formalism, its implementation and an application example (solving
configuration problems) with attributes, a new quantifier and concrete
domains.

(fruehwirth.ps.Z, 10 pages)



              A POWERFUL EVALUATION STRATEGY FOR CLP PROGRAMS

               Hong Gao                       David S. Warren
    Department of Computer Science    Department of Computer Science
     State University of New York      State University of New York
         Stony Brook, NY 11794             Stony Brook, NY 11794
         gaohong@cs.sunysb.edu             warren@cs.sunysb.edu








                                 ABSTRACT

This paper presents a new, powerful evaluation strategy (OLDTC-AM) for CLP
programs.  OLDTC-AM is developed by combining the OLDT evaluation strategy
with a logical answer manipulation mechanism.  Under the OLDTC-AM
evaluation strategy, the termination characteristics of CLP programs are
greatly improved and the expressive abilities of CLP languages are greatly
increased.  One application of this power is the direct solving of
optimization problems.  Through an example, we show how an optimization
problem can be expressed as a CLP program simply and be solved logically in
the constraint logic framework.

(gao.ps.Z, 8 pages)



                 PRACTICAL ISSUES IN GRAPHICAL CONSTRAINTS

                             Michael Gleicher
                        School of Computer Science
                        Carnegie Mellon University
                           Pittsburgh, PA 15213
                            gleicher@cs.cmu.edu


                                 ABSTRACT

Use of constraint-based techniques in interactive graphics applications
poses a variety of unique challenges to system implementors.  This paper
begins by describing how interface concerns create demands on interactive,
constraint-based, graphical applications.  We will discuss why such
applications must be able to handle systems of non-linear constraints, and
survey some of the techniques available to solve them.  Employing these
numerical algorithms in the contexts of interactive systems provides a set
of challenges, including dynamically setting up the equations to be solved
and achieving adequate performance and scalability.  This paper will
explore these issues and describe the methods we have used in our efforts
to address them.

(gleicher.ps.Z, 9 pages)



                 CONCURRENT CONSTRAINT PROGRAMMING AT SICS
                     WITH THE ANDORRA KERNEL LANGUAGE
                            (EXTENDED ABSTRACT)

                       Seif Haridi   Sverker Janson
               Johan Montelius   Torkel Franzen   Per Brand
              Kent Boortz   Bjorn Danielsson   Bjorn Carlson
               Torbjorn Keisu   Dan Sahlin   Thomas Sjoland

                      SICS, Box 1263, S-164 28 KISTA
                 Tel +46-8-752 15 00, Fax +46-8-751 72 30
                       E-mail {seif,sverker}@sics.se


                                 ABSTRACT

SICS is investigating a new generation of languages for symbolic processing
that are based on the paradigm of concurrent constraint programming.  A wide
range of pertinent topics are being studied.  In particular our efforts are
devoted to producing a high quality programming environment based on the
Andorra Kernel Language (AKL), a general purpose concurrent constraint
language.

(haridi.ps.Z, 10 pages)



                 FOURIER'S ELIMINATION: WHICH TO CHOOSE ?

                             Jean-Louis Imbert
            G.I.A. Parc Scientifique et Technologique de Luminy
                      163, Avenue de Luminy, case 901
                    F-13288 Marseille cedex 9 (France)
                       Email: imbert@gia.univ-mrs.fr


                                 ABSTRACT

Variable elimination is of major interest for Constraint Logic Programming
Languages [JaLa86], and Constraint Query Languages [KKR90], where we would
like to eliminate auxiliary variables introduced during the execution of a
program.  This elimination is always suitable for final results.  It can
also increase the efficiency of the intermediary processes.  We focus on
linear inequalities of the form ax <= b, where a denotes a n-real vector, x
an n-vector of variables, b a real number, and the juxtaposition ax denotes
the inner product.  In this paper, we will focus exclusively on methods
related to Fourier's elimination [Fourie].  Our aim is to make visible the
links between the different contributions of S.N. Cernikov [Cern63], D.A.
Kolher [Kohl67], R.J. Duffin [Duff74], JL.J. Imbert [Imbe90], and J.Jaffar,
M.J. Maher, P.J. Stuckey and R.H.C. Yap [JMSY92].  This study, which has
never been done before, is of great interest for languages such as CHIP,
CLP(R) and Prolog III. We show that the three methods proposed by Cernikov,
Kolher and Imbert produce exactly the same output (without more or less
redundant inequations), up to multiplying by a non-zero positive scalar.
We present and discuss the improvements of Cernikov, Duffin, Imbert and
Jaffar and al, and propose a new improvement.  We give a short analysis of
the complexity of the main improvements and discuss the choice of the
method in relation to the problem at hand. We propose a pattern algorithm.
Finally, we conclude with a comparative assessment through a brief example
and a few remarks.

(imbert.ps.Z, 13 pages)



                MEMOIZATION IN CONSTRAINT LOGIC PROGRAMMING

                               Mark Johnson
         Department of Cognitive and Linguistic Sciences, Box 1978
                             Brown University
                              mj@cs.brown.edu


                                 ABSTRACT

Motivated by a natural language processing application, this paper shows
how to extend memoization techniques for logic programs to constraint logic
programming.  The lemma table proof procedure presented here generalizes
standard memoization proof procedures such as OLDT resolution by (i) allowing
goals and constraints to be resolved in any order, (ii) permitting
memoization on sets of goals and constraints rather than only individual
goals, and (iii) allowing the solutions recorded in the memo table to
include unresolved goals and constraints, which are "inherited" by the
calling routine.

(johnson.ps.Z, 9 pages)



      LOCAL CONSISTENCY IN PARALLEL CONSTRAINT-SATISFACTION NETWORKS

                Simon Kasif                   Arthur L. Delcher
      Department of Computer Science     Computer Science Department
       The Johns Hopkins University      Loyola College in Maryland
            Baltimore, MD 21218              Baltimore, MD 21210
             kasif@cs.jhu.edu                delcher@loyola.edu


                                 ABSTRACT

We summarize our work on the parallel complexity of local consistency in
constraint networks, and present several basic techniques for achieving
parallel execution of constraint networks.  We are interested primarily in
developing a classification of constraint networks according to whether
they admit massively parallel execution.  The major result supported by our
investigations is that the parallel complexity of constraint networks is
critically dependent on subtle properties of the network that do not
influence its sequential complexity.

(kasif.ps.Z, 7 pages)



               EXPLOITING CONSTRAINT DEPENDENCY INFORMATION
                       FOR DEBUGGING AND EXPLANATION

              Walid T. Keirouz, Glenn A. Kramer, Jahir Pabon
               Schlumberger Laboratory for Computer Science
                             8311 North RR 620
                               PO Box 200015
                           Austin, TX 78720-0015
                   {walid,gak,jahir}@austin.slcs.slb.com


                                 ABSTRACT

Constraint programming is another form of programming and, as such, should
be supported by appropriate environments that provide debugging,
explanation and optimization capabilities.  We are building tools needed
for such an environment and using them in the context of geometric
constraint programming for graphics and mechanical design.  In this paper,
we present the components of such an environment and their capabilities.
We describe the use of constraint dependency graphs for debugging and
explanation, and present an algorithm for identifying constraints that
cause a model to be over-constrained.

(keirouz.ps.Z, 10 pages)



            IMPLEMENTING COMPUTATIONAL SYSTEMS WITH CONSTRAINTS

             Claude Kirchner   Helene Kirchner   Marian Vittek
                           INRIA-Lorraine & CRIN
                   615, rue du Jardin Botanique, BP 101
                   54602 Villers-les-Nancy Cedex FRANCE
                E-mail: kirchner@loria.fr, vittek@loria.fr


                                 ABSTRACT

The paper presents a framework to describe, experiment and study the
combination of different computational systems including the constraint
solving paradigm.  Computational systems are interpreted in a first-order
setting thanks to an evaluator that rewrites formulas.

(kirchner.ps.Z, 10 pages)



                    AGGREGATION IN CONSTRAINT DATABASES
                           (PRELIMINARY REPORT)

                             Gabriel M. Kuper
                                   ECRC
                              Arabellastr. 17
                            D-8000 Muenchen 81
                                 Germany.


                                 ABSTRACT

We discuss the issues that arise when we add aggregation to a constraint
database query language.  One example of the use of aggregation in such a
context is to compute the area of a region in a geographic database.  We
show how aggregation could be added to the query language, tuple calculus,
and discuss the problems that arise from the interaction of aggregate
operators and constraints.

(kuper.ps.Z, 8 pages)



             CONSTRAINT SATISFACTION IN FUNCTIONAL PROGRAMMING

                              Francois Major
               National Center for Biotechnology Information
                       National Library of Medicine
                       National Institutes of Health
                            Bethesda, MD 20894
                          major@ncbi.nlm.nih.gov

                      Marcel Turcotte and Guy Lapalme
         Departement d'Informatique et de Recherche Operationnelle
                          Universite de Montreal
                         Montreal, Quebec, Canada
                                  H3C 3J7
                        turcotm@medcn.umontreal.ca
                         lapalme@iro.umontreal.ca


                                 ABSTRACT

Motivated by an application in molecular biology, the prediction of
biopolymer three-dimensional structures, an appropriate polymorphic tree
search control structure has been implemented using a functional
programming language to evaluate different tree search approaches to solve
discrete combinatorial problems in three-dimensional space.  The control
structure is the basis of a constraint programming framework implemented in
the functional programming paradigm.  The non-strict semantic (lazy
evaluation) and other features of higher-order functional programming
languages have allowed to introduce constraint programming features in the
functional programming paradigm.

(major.ps.Z, 4 pages)



               2LP: LINEAR PROGRAMMING AND LOGIC PROGRAMMING

                      Ken McAloon and Carol Tretkoff
                          Logic Based Systems Lab
                 CUNY Graduate Center and Brooklyn College
                            2900 Bedford Avenue
                            Brooklyn, NY 11210
                       mcaloon@sci.brooklyn.cuny.edu
                      tretkoff@sci.brooklyn.cuny.edu


                                 ABSTRACT

The 2lp system is a step in the "Operatica Program," a project whose grand
design is to provide an elegant and powerful programming language
environment for combining AI and OR methods for decision support software
systems.  The term "Operatica" was coined by J.L. Lassez to suggest an
analogy with the Mathematica system which provides a programming
environment for symbolic mathematical computation.  In the dialogue between
AI and OR, there are two basic themes: (1) declarative programming and the
notion of logical consequence and, (2) procedural programming and the
search algorithm in its many variations.  Integrating AI and OR requires an
environment that combines a modeling language with a logic based language.
2lp, which stands for "linear programming and logic programming," has the
simplex based search mechanism of linear programming and the backtracking
mechanism of logic programming built in.  2lp is both an algebraic modeling
language and a logical control language.  By bringing these techniques
together in a language which has standard C style syntax and treats the
mathematical module in an object-oriented way, this technology provides
very powerful and usable tools for decision support programming.

(mcaloon.ps.Z, 12 pages)



               AN INCREMENTAL HIERARCHICAL CONSTRAINT SOLVER

  Francisco Menezes  Pedro Barahona         Philippe Codognet
   (fm@fct.unl.pt)   (pb@fct.unl.pt)    (codognet@minos.inria.fr)
     Departamento de Informatica,           INRIA-Rocquencourt
     Universidade Nova de Lisboa        BP 105, 78153 Le Chesnay,
   2825 Monte da Caparica, PORTUGAL              FRANCE


                                 ABSTRACT

This paper presents an incremental method to solve hierarchies of
constraints over finite domains, which borrows techniques developed in
intelligent backtracking, and finds locally-predicate-better solutions.  A
prototype implementation of this method, IHCS, was written in C and can be
integrated with different programming environments.  In particular, with
Prolog producing an instance of an HCLP language.  Possible applications of
IHCS are briefly illustrated with a time-tabling and a set covering
problem.  Because of its portability and incremental nature, IHCS is well
suited for reactive systems, allowing the interactive introduction and
removal of preferred constraints.

(menezes.ps.Z, 10 pages)



     CONSTRAINING THE STRUCTURE AND STYLE OF OBJECT-ORIENTED PROGRAMS

                Scott Meyers                  Carolyn K. Duby
          Dept. of Computer Science       Cadre Technologies, Inc.
         Brown University, Box 1910         222 Richmond Street
            Providence, RI  02912          Providence, RI  02903
              sdm@cs.brown.edu                 ckd@cadre.com

                              Steven P. Reiss
                         Dept. of Computer Science
                        Brown University, Box 1910
                           Providence, RI  02912
                             spr@cs.brown.edu


                                 ABSTRACT

Object-oriented languages fail to provide software developers with a way to
say many of the things about their systems that they need to be able to
say.  To address this need, we have designed and implemented a language for
use with C++ that allows software developers to express a wide variety of
constraints on the designs and implementations of the systems they build.
Our language is specifically designed for use with C++, but the issues it
addresses are applicable to other object-oriented languages, and the
fundamental software architecture used to implement our system could be
applied without modification to similar constraint languages for other
object-oriented programming languages.

(meyers.ps.Z, 10 pages)



      HIGHER-ORDER LOGIC PROGRAMMING AS CONSTRAINT LOGIC PROGRAMMING

                              Spiro Michaylov
              Department of Computer and Information Science
                         The Ohio State University
                      Columbus, OH 43210-1277, U.S.A.
                         spiro@cis.ohio-state.edu

                              Frank Pfenning
                        School of Computer Science
                        Carnegie Mellon University
                     Pittsburgh, PA 15213-3891, U.S.A.
                               fp@cs.cmu.edu


                                 ABSTRACT

Higher-order logic programming (HOLP) languages are particularly useful for
various kinds of meta-programming and theorem proving tasks because of the
logical support for variable binding via lambda-abstraction.  They have
been used for a wide range of applications including theorem proving,
programming language interpretation, type inference, compilation, and
natural language parsing.  Despite their utility, current language
implementations have acquired a well-deserved reputation for being
inefficient.  In this paper we argue that HOLP languages can reasonably be
viewed as Constraint Logic Programming (CLP) languages, and show how this
can be expected to lead to more practical implementations by applying the
known principles for the design and implementation of practical CLP
systems.

(michaylov.ps.Z, 9 pages)



     CONSTRAINT SATISFACTION, CONSTRAINT PROGRAMMING, AND CONCURRENCY

                     Ugo Montanari and Francesca Rossi
                            University of Pisa
                        Computer Science Department
                    Corso Italia 40, 56100 Pisa, Italy
                          {ugo,rossi}@di.unipi.it


                                 ABSTRACT

Recently constraint satisfaction has been embedded in various high-level
declarative programming environments, like the Constraint Logic Programming
framework, and even more recently such environments have been extended with
concurrency, like in the Concurrent Constraint Programming paradigm.  The
merging of different areas of research is always an exciting event, and
prolific of new ideas.  We believe that here it is particularly so, since
the above areas, while apparently very far in aims and techniques, are
found more and more interconnected, to the point that their coexistence
leads to new unexpected directions of research.  In fact, we believe that
interesting results in constraint satisfaction and in constraint
programming can be mixed with concurrency with the consequence that more
concurrency, as well as a more natural view of constraint programming, are
derived.

(montanari.ps.Z, 9 pages)



                          PROGRAMMING IN CLP(BNR)

     William J. Older                   Frederic Benhamou
     Bell Northern Research             Groupe Intelligence Artificielle
     Computing Research Laboratory      Faculte des Sciences de Luminy
     PO Box 3511, Station C             case 901,163, avenue de Luminy
     K1Y 4H7 Ottawa, Ontario, Canada    13288 Marseille Cedex 9 France


                                 ABSTRACT

CLP(BNR) is a constraint system based on relational interval arithmetic and
forms part of BNR Prolog /v.4.  This is a much more powerful system than
previous versions and allows a much wider class of problems to be handled,
including discrete domain problems and boolean equations.  It is also
integrated more closely into Prolog, thus providing for smoother and more
flexible interaction between Prolog and the constraint system.  This paper
describes the programming interface and gives some simple programming
examples.

(older.ps.Z, 11 pages)



                     ROBOT PROGRAMMING AND CONSTRAINTS

                               Dinesh K. Pai
                        Computer Science Department
                      University of British Columbia
                               pai@cs.ubc.ca


                                 ABSTRACT

Constraints play a central role in the analysis and planning of robot
motion.  We suggest that constraints form an appropriate language with
which to program robot motion as well and describe the Least Constraint
framework.

(pai.ps.Z, 8 pages)



                   CONSTRAINTS IN NONMONOTONIC REASONING

                   William C. Rounds and Guo-Qiang Zhang
                    Artificial Intelligence Laboratory
                          University of Michigan
                            Ann Arbor, MI 48109
                       {rounds,gqz}@engin.umich.edu


                                 ABSTRACT

We report on the use of constraints to govern partial models of first-order
logic.  These models are constructed using systems of default rules, as in
the default logic of Reiter, but where Reiter's rules build logical
theories, our rules build models.  Our approach takes advantage of
domain-theoretic notions.  A system of default rules is a straightforward
generalization of Scott's notion of information system, already an
important tool in understanding constraint programming.

We apply our theory to resolve an anomaly due to Poole on the meaning of
defaults.  Using finite default models, constraints, and a constructive,
rule-based notion of conditional degree of belief, we give a probabilistic
way of interpreting default statements.

(rounds.ps.Z, 11 pages)



            THE SKYBLUE CONSTRAINT SOLVER AND ITS APPLICATIONS

                             Michael Sannella

                      Department of Computer Science
                          and Engineering, FR-35
                         University of Washington
                             Seattle, WA 98195
                        sannella@cs.washington.edu


                                 ABSTRACT

The SkyBlue constraint solver is an efficient incremental algorithm that
uses local propagation to maintain sets of required and preferential
constraints.  SkyBlue is a successor to the DeltaBlue algorithm, which was
used as the constraint solver in the ThingLab II user interface development
environment.  Like DeltaBlue, SkyBlue represents constraints between
variables by sets of short procedures (methods) and incrementally
resatisfies the set of constraints as individual constraints are added and
removed.  DeltaBlue has two significant limitations: cycles of constraints
are prohibited, and constraint methods can only have a single output
variable.  SkyBlue relaxes these restrictions, allowing cycles of
constraints to be constructed (although SkyBlue may not be able to satisfy
all of the constraints in a cycle) and supporting multi-output methods.
This paper presents the SkyBlue algorithm and discusses several
applications that have been built using SkyBlue.

(sannella.ps.Z, 11 pages)



          A REAL-TIME EXTENSION TO LOGIC PROGRAMMING BASED ON THE
             CONCURRENT CONSTRAINT LOGIC PROGRAMMING PARADIGM

                        Tony Savor, Paul Dasiewicz
          (tsavor@vlsi.uwaterloo.ca, dasiewic@vlsi.uwaterloo.ca)

             Department of Electrical and Computer Engineering
                          University of Waterloo
                     Waterloo, Ontario, Canada N2L 3G1


                                 ABSTRACT

Although concurrent logic programming languages provide a suitable
implementation environment for real-time systems, they fail to give any
notion of temporal correctness.  We define a set of semantics whereby
temporal constraints, consisting of delay, maximum execution time, and
priority specifications can be implemented into existing concurrent logic
programming languages.  The notion of temporal inheritance is described
which allows distribution of common temporal constraints to processes that
are all part of the same task.  We give some examples illustrating the
utility of the language extension.

(savor.ps.Z, 9 pages)



                    SYNTHESIS OF CONSTRAINT ALGORITHMS

                             Douglas R. Smith
                             Kestrel Institute
                           3260 Hillview Avenue
                        Palo Alto, California 94304
                             smith@kestrel.edu


                                 ABSTRACT

We report here on our current efforts at developing automated methods for
deriving problem-specific constraint propagation code.  This effort is part
of a broader development of automated tools for transforming formal
specifications into efficient and correct programs.  The KIDS system serves
as the testbed for our experiments and provides tools for performing
deductive inference, algorithm design, expression simplification, finite
differencing, partial evaluation, data type refinement, and other
transformations.  We have used KIDS to derive over 60 algorithms for a wide
variety of application domains, including scheduling, combinatorial design,
sorting and searching, computational geometry, pattern matching, and
mathematical programming.

(smithD.ps.Z, 6 pages)



  CONSTRAINT-BASED LANGUAGES FOR SCIENTIFIC DATABASE AND MODELING SYSTEMS

                      Terence R. Smith and Keith Park
                         University of California
                         Santa Barbara, CA 93106


                                 ABSTRACT

We focus our attention on the manner in which constraint programming (CP)
may serve as a basis for languages that support the modeling and database
activities of a large class of scientific investigators.  In particular, we
will examine the applicability of high-level languages based on constraints
to problems relating to scientific modeling and database systems for
large-scale environmental modeling.  We believe that it is necessary to
have a clear model of the nature of scientific investigations in order to
proceed with such an examination.  We therefore base our discussion of the
applicability of such languages on a model of scientific investigation, and
examine several classes of problems that arise as a consequence of the
model.

(smithT.ps.Z, 5 pages)



                     SET-BASED CONCURRENT ENGINEERING

                               Allen C. Ward
                            Assistant Professor
        Department of Mechanical Engineering and Applied Mechanics
                          University of Michigan
                         Ann Arbor, MI 48109-2125
                          alward@um.cc.umich.edu


                                 ABSTRACT

Concurrent engineering (CE) shortens design cycles and improves design
quality by designing more of the total system, including both the product
and the manufacturing system, in parallel.  Reason and empirical studies
suggest that members of the design team should communicate and reason about
sets of possible solutions, rather than changes to a single solution.  This
process can in part be formalized and automated.  This paper summarizes my
recent work in this area.

(ward.ps.Z, 4 pages)



                 CONSTRAINT PROGRAMMING IN CONSTRAINT NETS

               Ying Zhang                      Alan K. Mackworth
     Department of Computer Science     Department of Computer Science
     University of British Columbia     University of British Columbia
             Vancouver, B.C                     Vancouver, B.C
             Canada V6T 1Z2                     Canada V6T 1Z2
             zhang@cs.ubc.ca                    mack@cs.ubc.ca


                                 ABSTRACT

We view constraints as relations and constraint satisfaction as a dynamic
process of approaching a stable equilibrium.  We have developed an
algebraic model of dynamics, called Constraint Nets, to provide a real-time
programming semantics and to model and analyze dynamic systems.  In this
paper, we explore the relationship between constraint satisfaction and
constraint nets by showing how to implement various constraint methods on
constraint nets.

(zhang.ps.Z, 10 pages)



            A CONSTRAINT BASED SCIENTIFIC PROGRAMMING LANGUAGE

                              Richard Zippel
                            Cornell University
                             Ithaca, NY 14853
                             rz@cs.cornell.edu


                                 ABSTRACT

Scientific programs tend to be quite large and complex, and their creation
is quite error prone.  We have been pursuing a program transformation
approach to the creation of scientific programs, where the transforms can
be conventional compiler optimizations like loop unrolling, strength reduc-
tion and common subexpression elimination, and more mathematical
transformation like applying Newton's method to a coupled system of
algebraic equations or a Runge-Kutta method to a system of ordinary or
partial differential equations.

The language to which these transforms is applied contains, by necessity, a
combination of conventional programming constructs and constructs from
continuous mathematics such as differential equations, integrals and
function spaces.  We call this language SPL.  A very appropriate way to
combine these different constructs is to begin with a conventional
programming language, but one where the type system is extended to include
types like continuous functions and further extend it to use constraints to
represent the algebraic and differential equations of the scientific
problem.

(zippel.ps.Z, 5 pages)
