[2-3] Free and Commercial Constraint Systems

See the comp.lang.prolog, comp.lang.lisp, comp.ai and comp.lang.scheme
FAQs and Resource Guides for possibly more up-to-date and complete

Note on costs: there is a difference between FREE software (which may
have restrictions attached), Public Domain software (FREE-PD), CHEAP
software (arbitrarily and approximately: less than 100 pounds or 200
dollars or 300 deutschmarks), shareware (CHEAP-SH), and software which
is COMMERCIAL [to avoid calling it non-cheap or expensive]. Some
software may not be available for commercial use, although commercial
enterprises may be able to use it for their own research. These are
labelled C=N/A. Costs may also vary depending on whether the customer
is (A) academic, (E) Eastern European, or (C) a commercial enterprise.
So each section here will have a header of the following form:
[COST A=CHEAP,E=FREE,C=PRICE]. If something has the same cost for all
groups, I abbreviate the entry to e.g. [COST FREE-PD].

Warning: there is no guarantee that this information is correct and it
should not be treated as implying some kind of contract either on my
part (FAQ maintainer) or on the part of the supplier. Please notify me
of errors.

   AKL:					[COST A=E=FREE,C=N/A]
AKL (previously Andorra Kernel Language, now Agent Kernel Language) is
a concurrent constraint programming language that supports both
Prolog-style programming and committed choice programming. Its control
of don't-know nondeterminism is based on the Andorra model, which has
been generalised to also deal with nondeterminism encapsulated in
guards and aggregates (such as bagof) in a concurrent setting. See, for

 Sverker Janson and Seif Haridi, "Programming Paradigms of the Andorra
 Kernel Language", in Proceedings of ILPS'91. MIT Press, 1991.

 Torkel Franzen, "Logical Aspects of the Andorra Kernel Language", SICS
 Research Report R91:12, Swedish Institute of Computer Science, 1991.

 Torkel Franzen, Seif Haridi, and Sverker Janson, "An Overview of the
 Andorra Kernel Language", In LNAI (LNCS) 596, Springer-Verlag, 1992.

 Sverker Janson, Johan Montelius, and Seif Haridi, "Ports for Objects
 in Concurrent Logic Programs", in Research Directions in Concurrent
 Object-Oriented Programming, MIT Press, 1993 (forthcoming).

The above papers on AKL are available from <">sics.se:/pub/ccp/papers>">ftp://sics.se:/pub/ccp/papers>.
An (as yet non-released) prototype implementation of AKL is available
for research purposes (contact sverker@sics.se).

   ALE:					[COST FREE-PD]
ALE (Attribute Logic Engine), a public domain system written in
Prolog, integrates phrase structure parsing and constraint logic
programming with typed feature structures as terms. Types are arranged
in an inheritance hierarchy and specified for the features and value
types for which they are appropriate. Grammars may also interleave
unification steps with logic program goal calls (as can be done in
DCGs), thus allowing parsing to be interleaved with other system
components. While ALE was developed to handle HPSG grammars, it can
also execute PATR-II grammars, DCG grammars, Prolog, Prolog-II, and
LOGIN programs, etc. Grammars and programs are specified with a version
of Rounds-Kasper Attribute Value Logic with macros and variables. ALE
supports lexical rules and empty categories for grammars, using a
bottom-up, breadth-first dynamic chart parser. ALE supports last call
optimization, negation by failure and cuts in definite clauses, which
may be used independently or integrated into grammars. The system is
available free for research purposes, from Bob Carpenter

Bertrand is the language described by Leler in his book (see section
[1-6]). See [1-5] PTF for more details.



CHARME was a commercial product from Bull. The latest version is called

CHIP V4 (Constraint Handling In Prolog) is designed as an extension to
Prolog offering three constraint solving domains: Integers, Rationals
and Booleans. The system was originally developed at ECRC in Munich and
now extended by the same team at COSYTEC in Paris. CHIP V4 includes
extensions to the three domains: symbolic constraints, update demons
and cumulative constraints. The system is available with optional
interfaces for X11 and DOS graphics (XGIP), Oracle or Ingres database
connection (QUIC), C language interface (CLIC) and embedded application
interface (EMC). CHIP V4 is written completely in C, and is available
on a range of workstations including SunSparc IBM RS6000, HP 9000/700,
Decstations and PC386/486 (Dos 5.0). An academic discount is offered
for educational and research purposes. For more information contact
COSYTEC, Parc Club Orsay Universite 4 rue Jean Rostand, 91893 Orsay
Cedex, France, phone +33-1-60-19-37-38, fax +33-1-60-19-36-20 or email

   CHR:					[COST FREE with ECLIPSE]
Constraint Handling Rules (CHRs) is a library of ECLiPSe [see separate
entry] for writing custom constraint systems in a high-level language.
CHRs is essentially a committed-choice language consisting of guarded
rules that rewrite constraints into simpler ones until they are
solved. The usual formalisms to describe a constraint theory, i.e.
inference rules, rewrite rules, sequents, first-order axioms, can be
expressed as CHR programs in a straightforward way. The CHR release
includes a full colour demo involving geometric constraints, a compiler
(into ECLiPSe), two debuggers, a runtime system and 18 constraint
solvers. There are solvers for lists, sets, trees, terms, finite and
infinite domains, booleans, linear polynomials over reals and
rationals, for incremental path consistency, and for terminological and
temporal reasoning. CHR documentation is available by anonymous ftp
from ftp.ecrc.de:/pub/eclipse/doc in the extensions-manual. You can
also ftp a technical report describing constraint handling rules (file
ECRC-92-18.ps.Z in directory pub/ECRC_tech_reports/reports) and their
application to temporal and terminological reasoning (files
ECRC-94-05.ps.Z and ECRC-94-06.ps.Z). For more information on CHRs
contact Thom Fruehwirth (thom@ecrc.de).

   CIAL 1.0 (Beta)			[COST FREE]
CIAL is an interval constraint logic programming language. The main
difference between CIAL and other CLP(Interval) languages is that a
linear constraint solver, which is based on preconditioned interval
Gauss-Seidel method, is embedded in CIAL in addition to the interval
narrowing solver. The main motivations for a linear solver are:
* Pure interval narrowing fails to narrow the intervals to any useful
  width even for such simple systems as {X+Y=5, X-Y=6}. Interval
  splitting may help but is costly.
* Pure interval narrowing cannot always detect inconsistency or halt
  (in a reasonable time). A simple example is {A+1=D, A+B=D, A>0, B<0}.
* Efficient linear constraint solver is also important to the study of
  efficient non-linear constraint-solving. Recent results show that
  interval Newton method works better than pure interval narrowing for
  solving non-linear constraints, but may require to solve many linear
  constraints in order to give the best results.
This version of CIAL prototype is implemented as an extension to CLP(R)
v1.2 and tested on Sun Sparc machines. You should have obtained CLP(R)
from IBM prior to installing CIAL. Our distribution is in the form of
patches to the CLP(R) sources. [See entry on CLP(R) below].

E-mail cial@cs.cuhk.hk to request CIAL, and for more details.

[FAQ maintainer's note: I have deleted most of the references provided,
for space reasons, if they are in well-known journals and conferences;
the CIAL team have not simply cited only their own work. MBJ.]

C.K. Chiu and J.H.M. Lee. Towards practical interval constraint solving
in logic programming. (To appear) In Proceedings of the Eleventh
International Logic Programming Symposium, Ithaca, USA, Nov.1994.

J.H.M. Lee and T.W. Lee. A WAM-based abstract machine for interval
constraint logic programming and the multiple-trailing problem.
Proceedings Sixth IEEE International Conference on Tools with
Artificial Intelligence, New Orleans, Nov 1994.

   CLP(BNR):				[COST ???]
CLP(BNR) [Constraint Logic Programming with Booleans Naturals and
Reals] is an experimental CLP Language developed at the Bell-Northern
Research Computing Research Lab. CLP(BNR) is a Prolog-based language
that incorporates an arc-consistency propagation algorithm on
interval-bounded constraints which handles general algebraic
constraints over continuous, integer and boolean variables. This allows
programmers to express systems of non-linear equations on real
intervals that can be arbitrarily mixed with integer and boolean
constraints equations. For more information on CLP(BNR) contact
Andre' Vellino <vellino@bnr.ca> (613)763-7513, fax (613)763-4222
Bell-Northern Research, Box 3511, Station C, Ottawa, CANADA K1Y 4H7
See also section [1-6] for papers by Benhamou/ Older/ Vellino.

   CLP(F):		NON-LINEAR	[unavailable]
This extension of CLP(Intervals) has an underlying domain that consists
of boolean, integers, reals, real-valued functions of one variable, and
vectors of domain elements. Function variables are constrained by
functional equations and by putting interval constraints on the values
of their derivatives at points and intervals. The system can be used to
solve constraint problems involving ordinary differential equations.
Contact Tim Hickey <tim@cs.brandeis.edu>

[1] T. Hickey. CLP(F) and Constrained ODE's, T. Proceedings of the 1994
Workshop on Constraints and Modelling, Ithica, NY, November, 1994.
Available at: ftp://ftp.ecrc.de/pub/faculty/tim/Papers/islp94.ps

   CLP(FD):				[COST FREE]
CLP(FD) 2.2 is a constraint logic programming language over Finite
Domains. It is based on the wamcc Prolog compiler which translates
Prolog to C. It provides several constraints "a la CHIP" on Finite
Domains and Booleans and some facilities to build new constraints.
clp(FD) is 4 times faster than CHIP v3.2 on average.  Available from
Requires GNU C (gcc) version 2.4.5 or higher. Ported to Sparc
workstations, PC under linux, sony mews, dec ultrix, portable generally
to 32-bit machines with gcc. See also under WAMCC, below. For more
details, contact the author Daniel Diaz <Daniel.Diaz@inria.fr> INRIA
Rocquencourt, FRANCE.

					[Commercial users: see next section]
CLP(R) is a constraint logic programming language with real-arithmetic
constraints. The implementation contains a built-in constraint solver
which deals with linear arithmetic and contains a mechanism for
delaying nonlinear constraints until they become linear. Since CLP(R)
subsumes PROLOG, the system is also usable as a general-purpose logic
programming language. It includes facilities for meta-programming with
constraints. The system consists of a compiler, byte-code emulator,
and constraint solver. CLP(R) is written entirely in C and runs on
Suns, Vaxen, MIPS-based machines (Decstations, Silicon Graphics), IBM
RS6000s and PS2s. Includes MS-DOS support. It is available free from
IBM for academic and research purposes only. For more information,
write to Joxan Jaffar, H1-D48, IBM Thomas J. Watson Research Center,
P.O. Box 704, Yorktown Heights, NY 10598, or send email to
joxan@watson.ibm.com or joxan@yktvmh.bitnet. Current version 1.2.

   CLP(R):				[COST CHEAP]
CLP(R) is a constraint system from Monash University for VAX, Sun, and
Pyramid (Unix). Costs $150. For more information, write to Monash
University, CLP(R) Distribution, Department of Computer Science,
Clayton, Victoria 3168, Australia, or send email to
clp@moncsbruce.oz.au. [Although the system is still available, it has
not been maintained or supported for about 5 years, and it will remain
that way.]

A constraint-based drawing package from the same stable as ThingLabII.
See information on the Seattle ftp site in section [1-5].

Public domain constraint system written by Manfred Meyer
<meyer@dfki.uni-kl.de>. [More details soon.]

cu-Prolog is an experimental constraint logic programming language
available free from Japan's Institute for New Generation Computer
Technology (ICOT). Unlike most conventional CLP systems, cu-Prolog
allows user-defined predicates as constraints and is suitable for
implementing a natural language processing system based on the
unification-based grammar. For example, the cu-Prolog developers
implemented a JPSG (Japanese Phrase Structure Grammar) parser in
cu-Prolog with the JPSG Working Group (the chairman is Prof. GUNJI,
Takao of Osaka University) at ICOT. cu-Prolog is a complete
implementation of Constraint Unification (cu), hence the name.
cu-Prolog is implemented in C for BSD UNIX 4.2/3. Professor Sirai of
Chukyo-University has also implemented cu-Prolog for the Apple
Macintosh and DJ's GPP (80386/486 MS-DOS machine with the DOS
extender). Available free by anonymous ftp: see section [1-5].

A constraint-solving algorithm. See information on the Seattle ftp site
in section [1-5]. See paper by Freeman-Benson et al in section [1-6].

Echidna is an object oriented constraint logic programming language
developed by the Intelligent Systems Lab at Simon Fraser University
between 1990 and 1993. Constraints in Echidna include finite domain
constraints (as in CHIP) and disjoint real interval domain constraints.
Real domains are implemented by interval hierarchies which allow for
the representation of domains with disjoint sets of intervals.
Hierarchical domains also allow control of the precision of constraint
processing. Since complete search procedures exist for all levels of
precision, it is possible to quickly search through regions with no
solutions at low precision. Where low precision constraint processing
indicates a possible solution, precision can be increased to ensure
convergence on a real solution.
Echidna supports a form of incremental intelligent backtracking for
multiple user queries which provides an effective interactive
mixed-initiative control regime. Users can issue and selectively
retract queries to arrive at a solution to their problem.
Development and support for Echidna v1.0 were halted in 1993. For more
information, go to <http://fas.sfu.ca/cs/research/groups/ISL/> or
<ftp://ftp.fas.sfu.ca/pub/css/esl/echidna> or contact Bill Havens
<havens@cs.sfu.ca>. See:

[1] W.S. Havens: Intelligent Backtracking in the Echidna CLP Reasoning
System, International Journal of Expert Systems: Research and
Applications 5(4), 1992, M. Harandi (ed.), Jai Press, London, 21-45.

[2] Greg Sidebottom and W.S. Havens: Hierarchical Arc Consistency for
Disjoint Real Intervals in Constraint Logic Programming. Computational
Intelligence 8(4), 1992. 601-623. Also available as

   ECLIPSE:				[COST A=FREE,E=FREE,C=see below]
ECLiPSe (ECRC Logic Programming System) combines the functionalities of
several ECRC systems, including Sepia, MegaLog and CHIP. ECLiPSe
includes a Prolog compiler with extended functionality that is Quintus
and SICStus compatible, a tightly connected database system based on
the BANG file system, a CLP system, and an interface to the Tcl/Tk X11
toolkit. The BANG database can store not only relations, but also any
Prolog structures and programs. The CLP system contains several
libraries with various types of constraint handling schemes, including
atomic finite domains, linear rational constraints, CHR (constraint
handling rules) and Propia (generalised propagation). See also the
separate entry for CHR.] It also supports writing further extensions
like new user-defined constraints or complete new constraint solvers.
ECLiPSe also includes a profiler, user-definable syntax, metaterms as
first-class citizens, coroutining, and unlimited precision integer and
rational numbers. ECLiPSe is available free of charge for all academic
and government-sponsored organizations. Commercial users may obtain
ECliPSe for DM 7000, but for research purposes only. It is distributed
in binary form for Sun-3, Sparc, and many other types of machine. Send
orders or requests for further information to eclipse_request@ecrc.de
or write to ECRC, Arabellastrasse 17, 81925 Munich, Germany. The
ECLiPSe documentation (ASCII and dvi) and some shareware packages
ported to ECliPSe are now available on WWW at URL
<http://www.ecrc.de/eclipse/eclipse.html> and also by anonymous ftp
from ecrc.de:/pub/eclipse. To subscribe to the eclipse_users@ecrc.de
mailing list, send mail to eclipse_request@ecrc.de.

See ECLIPSE. SEPIA is no longer delivered as a stand-alone system, but
as a part of ECLiPSe.

FSQP (Feasible SQP; FORTRAN; developed by J.L. Zhou and A.L. Tits) and
CFSQP (C version of same, with enhancements; port and enhancements due
to C.T. Lawrence) are software packages aimed at solving constrained
optimization problems, including constrained minimax problems (where
the max is taken over a finite number of smooth functions). (C)FSQP's
main distinguishing feature is that all the iterates it generates
satisfy the constraints, except for nonlinear equality constraints, for
which mere "semi-feasibility" is maintained (given a scalar constraint
h(x)=0, if h(x0)<=0 (resp. >=0), then h(xk)<=0 (resp. >=0) for all k.)
This is of value in many engineering related problems. Extensive
numerical tests show that FSQP's efficiency is comparable to that of
the most popular (non-"feasible") codes. Detailed User's Manuals are
available. (C)FSQP is available free of charge to academic and other
non-profit organizations (as well as, for an evaluation period, to
for-profit organizations) but may not be redistributed without the
authors' approval. To obtain FSQP or CFSQP, please contact Andre Tits

The Garnet system is a fully functional user interface development
environment and toolkit implemented on top of a comprehensive one-way
constraint system. It is in CommonLisp for X/11. All widgets and other
user interface elements are implemented using the constraint. The
constraints are implemented as part of the object system, and the
object system with constraints can be used independently of the
user-interface components, if desired. Garnet is available for free by
anonymous FTP from a.gp.cs.cmu.edu ( Retrieve
/usr/garnet/garnet/README. More information on Garnet is available from
http://www.cs.cmu.edu:8001/Web/Groups/garnet/garnet-home.html or in the
newsgroup comp.windows.garnet or e-mail garnet@cs.cmu.edu. See also [1-5]
PTF for more details. See also Multi-GArnet, below.

Goedel is intended to be a declarative successor to Prolog.
It is defined as supporting certain constraint domains, but these are
not yet implemented. See the comp.lang.prolog FAQ for more details.

   ICOT language CU-PROLOG:
See entry CU-PROLOG.

   ICOT language CAL in ESP:		[COST FREE]
To execute this system, SIMPOS Ver.7 must be running on your PSI.
CAL is a sequential constraint logic programming language which can
deal with various constraints including non-linear polynomial
In the CAL system, you can use Context. A context is a constraint set.
A new context is created whenever the constraint set is changed. The
history of changing contexts is manipulated by the Context Tree, and
Current Context is the target of the context manipulation. You can
set a context on the context tree arbitrarily as the current context.
Functions include finding real roots:
The query "find" computes real roots of the univariate equations
and returns one solution. The user can obtain other solutions by
backtrack, and branches of the context tree are created.
The CAL system has 4 constraint solvers,
 (1) Algebraic constraint solver
 (2) Boolean constraint solver
 (3) Linear constraint solver
 (4) Set constraint solver
Available free by anonymous ftp: see section [1-5].

 A. Aiba, K. Sakai, Y. Sato, D. J. Hawley, and R. Hasegawa:
 Constraint Logic Programming Language CAL. In Proceedings of the
 International Conference on Fifth Generation Computer Systems 1988,
 November 1988.

 Contrainte Avec Logique version 2.12 User's manual
 Institute for New Generation Computer Technology,
 in preparation.

   ICOT language CAL Common ESP version written in CESP:   [COST FREE]
Same as CAL in ESP, but can run on Unix, needing: UNIX machine, Emacs
CESP, C language compiler, GNU MP, 50Mbyte disk, 16Mbyte memory
Available free by anonymous ftp: see section [1-5].

CAL was developed at ICOT (Institute for New Generation Computer
Technology) in a Japanese national project, Fifth Generation Computer
Project. CAL utilizes Buchberger algorithm to deal with linear and
non-linear algebraic equation constraints. See previous entries for more
details or contact Akira Aiba <aiba@icot.or.jp>

[1] Ko Sakai, Akira Aiba. CAL : A Theoretical Background of Constraint
Logic Programming and Its Application. Journal of Symbolic Computation
(1989) 8, pp. 589 -- 603

   ICOT language Hierarchical CLP Language CHAL:	[COST FREE]
You need the SIMPOS/ESP environment to run CHAL.
Hierarchical Constraint Logic Programming Language: CHAL A hierarchical
constraint logic programming language processor which introduces
hierarchy in terms of strength of constraints.  Hierarchical constraint
logic programming language CHAL consists of constraint hierarchy solver
which manipulates various strength of constraints in various domains
and constraint language processor.
An Extension of Constraint Logic Programming Language Usual constraint
logic programming languages output nothing if there is no solution for
given constraints. On the other hand, by introducing hierarchy of
strength in constraints, CHAL ignores some weak constraints in order to
output some better solutions. This function is important in planning
and design problems.
Available free by anonymous ftp: see section [1-5].

   ICOT language PCHAL:			[COST FREE]
Hierarchical Constraint Parallel Solver: P-CHAL
Similar to CHAL, above.
Parallel Solving of Constraint Hierarchy: P-CHAL reduces computational
costs by a bottom-up calculation of maximal consistent sets and
parallel processing of GDCC.
Available free by anonymous ftp: see section [1-5].

   ICOT language Knowledge Representation Language Quixote: [COST FREE]
Main documentation in Japanese.
Quixote is a DOOD (Deductive Object-Oriented Database) system
developed at ICOT. The following are outstanding Quixote features.
1. Object identity defined over extended terms (object terms).
2. Constraints in terms of subsumption relation among object terms.
3. Property inheritance among objects.
4. Modularized and hierarchical knowledge bases defined by modules
and rule inheritance between them.
5. Queries having additional assertions to knowledge bases, and
answers with assumed constraints.
Available free by anonymous ftp: see section [1-5].

Kazumasa Yokota, Deductive Object-Oriented Databases, Computer
Software, Vol.9, No.4, pp3--18, 1992 (in Japanese).

Hideki Yasukawa, Hiroshi Tsuda, and Kazumasa Yokota,
Object, Properties, and Modules in QUIXOTE,
Proc. of FGCS92, pp257--268, 1992.

Quixote Ver.III consists of (1) Quixote client on UNIX with C,
X-Window(X11R5), and GNU-Emacs, and (2) Quixote server on PIM/PIMOS
with KL1. Both UNIX workstation (such as SS2) and PIM/PSI are required
to run this version of Quixote.

   ICOT language Micro Quixote (Version 0.5):		[COST FREE]
Micro Quixote is another implementation of the language Quixote. It is
implemented with C. It eliminates many features of Quixote, and only
implements core feature of Quixote. However, it's small, and easy to
install. And more, it is expected that Micro Quixote could run on other
operating systems apart from Unix.
Available free by anonymous ftp: see section [1-5].

   ICOT language GDCC (Guarded Definite Clauses with Constraints):
					[COST FREE]
GDCC is the parallel constraint logic programming experimental system.
GDCC has been developed on PIMOS and runs only on PIMOS. Therefore,
PIMOS needs to be installed on your machine before GDCC is installed.
Includes linear constraints, boolean constraints, and the find utility
(Algebraic constraint solver) which is used to find approximate real
roots from the results of solving algebraic constraints.
Available free by anonymous ftp: see section [1-5].

GDCC was developed at ICOT in a Japanese national project, Fifth
Generation Computer Project. GDCC utilizes Buchberger algorithm to
deal with linear and non-linear algebraic equation constraints.
Different from CAL, GDCC is a parallel CLP language based on cc
paradigm. There are two versions of GDCC, one is a system written in
KL1, a parallel logic programming language, that runs on a parallel
inference machine called PIM developed in the project, and the other
is a system written in KLIC that is a KL1 language processor for UNIX
workstations. See previous entry or contact Akira Aiba <aiba@icot.or.jp>

[1] Satoshi Terasaki, David J. Hawley, Hiroyuki Sawada, Ken Satoh,
Satoshi Menju, Tarou Kawagishi, Noboru Iwayama, and Akira Aiba.
Parallel Constraint Logic Programming Language GDCC and Its Parallel
Constraint Solvers. International Conference on Fifth Generation
Computer Systems 1922, Tokyo

[2] Hiroyuki Sawada, Satoshi Terasaki, and Akira Aiba. Parallel
Computation of Groebner Bases on Distributed Memory Machines. Journal
of Symbolic Computation, Vol.18, No.3, pp.207--222, September 1994.

   IF/Prolog 5.0			[COST COMMERCIAL]
IF/Prolog 5.0 is a full ISO-compliant Prolog which incorporates
constraint solving technology. IF/Prolog is available on ALL UNIX
systems, VMS, OSF/1, MS-Windows and Mainframes. Constraint domains
include Boolean constraints, Rational terms, Linear terms, Equations
and Inequations, Finite Domain Constraints and Co-routines. Interfaces
to standard software packages and other programming languages including
C, C++ and FORTRAN, SQL (Ingres, Oracle and Informix) and X11 (Motif
and Athena widgetsets). IF/Prolog has full screen X11 and Windows based
debuggers and online hypertext help and quick reference guide.
IF/Prolog 5.0 is available on ALL UNIX, OSF/1, VMS and MS-Windows, OS/2
platforms. There is a 50% accademic discount and demo licences are
avilaible. Further information contact: Annette Kolb (marketing) or
Dr. Andrew Verden (technical) at IF Computer GmbH, Ludwig-Thoma-Weg
11a, D-82065 Baierbrunn, tel +49 89 7936 0037, fax +49 89 7936 0039.
E-mail prolog@mch.sni.de

ILOG SCHEDULE is an add-on to ILOG SOLVER, used to develop finite
capacity scheduling applications. ILOG SCHEDULE includes a natural
object model for representing schedules in terms of activities and
resources used and shared by these activities. Three categories of
constraints are predefined:
 - TEMPORAL CONSTRAINTS. Users may link any two activities together
   by any type of precedence constraint. Minimum and maximum delays
   between activities can be imposed.
 - CAPACITY CONSTRAINTS. Unary resources represent resources of
   capacity one. Volumetric resources represent resource pools of
   non-differentiated resources. State resources represent situations
   where an activity uses a resource only under specific conditions.
   The capacity of a resource can be constrained either at each time
   unit or over given time periods.
 - RESOURCE UTILIZATION CONSTRAINTS. An activity may require, consume,
   provide and produce resources, in an amount represented either
   as a constant or as an ILOG SOLVER variable. This allows the
   representation of the case where the duration of the activity
   varies with the amount of resources assigned to the activity.
ILOG SCHEDULE is available on the same platforms as ILOG SOLVER. For
further information and contact addresses, see entry on ILOG SOLVER.

[Ilog and Bull have agreed to sell the same thing under different
names. Charme Object and Ilog Solver have been merged. M Jampel.]
ILOG SOLVER (formerly called PECOS) is a highly efficient C++ class
library that implements constraint programming. SOLVER has been used
to develop fielded applications handling large problems in areas such
as job shop scheduling, timetabling, configuration, transport,
logistic planning, network routing, and frequency allocation.
SOLVER implements integer variables, floating point variables, Boolean
variables, and set variables. Constraints include =, <=, >=, <, >, +,
-, *, /, subset, superset, union, intersection, member, Boolean or,
Boolean and, Boolean not, Boolean xor, cardinality, element, generic
constraints, and meta constraints (conjunction and disjunction of
constraints, order among constraints). Non-linear constraints can be
solver by interval approximation methods. You can add new constraints
to SOLVER by deriving new C++ classes. SOLVER provides a backtracking
search and a branch-and-bound algorithm together with a large number of
search strategies. SOLVER also provides C++ classes and functions that
implement non-deterministic programming.
SOLVER is available on most Unix platforms and on MS-Windows. For
further information, please contact:
- In the USA and Canada:        - Outside the USA:
  ILOG, Inc.                      ILOG SA
  2005 Landings Drive             9, rue de Verdun, BP 85,
  Mountain View, CA 94303.        94253 Gentilly Cedex, France
  Phone: +415 390-9000            Phone: +33 1 4908 3500
  e-mail: info@ilog.com           e-mail: info@ilog.fr
  URL: http://www.ilog.com        URL: http://www.ilog.fr

LIFE (Logic, Inheritance, Functions, and Equations) is an experimental
programming language with a powerful facility for structured type
inheritance. It reconciles styles from functional programming, logic
programming, and object-oriented programming. It subsumes the
functionality of its precursor languages LOGIN and Le_Fun, and may be
seen as an extension of Prolog. The syntax of Wild_LIFE has been kept
as close as possible to that of the Edinburgh standard for Prolog.
LIFE offers natively high-level abstraction facilities and convenient
data and control structures particularly well-suited for AI
programming. LIFE implements a constraint logic programming language
with equality (unification) and entailment (matching) constraints over
order-sorted feature terms. The interplay of unification and matching
provides an implicit coroutining facility thanks to an automatic
suspension mechanism. This allows interleaving interpretation of
relational and functional expressions which specify structural
dependencies on objects. The Wild_LIFE interpreter is the first
implementation of the LIFE language available to the general public.
It is a product of the Paradise project at Digital Equipment
Corporation's Paris Research Laboratory (DEC PRL). Wild_LIFE runs on
DECstations (Ultrix), SparcStations and RS/6000 systems and should be
portable to other Unix workstations. It is implemented in C, and
includes an interface to X Windows. Wild_LIFE is available by anonymous
ftp from gatekeeper.dec.com:/pub/plan as the file Life.tar.Z. To be
added to the mailing list (life-users@prl.dec.com), send mail to
life-request@prl.dec.com. Send bug reports to life-bugs@prl.dec.com.
See also [1-5] PTF for more details.

   NEWTON:		NON-LINEAR	[unavailable]
The constraint group at Brown University has developed a CLP language
called Newton to solve
 - systems of nonlinear equations and inequalities
 - unconstrained optimization
 - constrained optimization
The language uses interval arithmetic and is based on a box-consistency
on various interval extensions. It is competitive with continuation
methods on their benchmarks, outperforms all interval methods we know
of, and has solved traditional benchmarks from numerical analysis
containing hundreds of variables. Contact Pascal Van Hentenryck

[1] F. Benhamou, D. McAllister, P. Van Hentenryck. CLP(Interval)
Revisited, in ILPS'94, Ithaca, NY, November 1994.

[2] P. Van Hentenryck, D. McAllister, D. Kapur. Solving Polynomial
System using A branch and Prune Approach. Forthcoming.

[3] P. Van Hentenryck, L. Michel. The Design and Implementation of
Newton. In CCP'95, Venice, Italy, May 1995.

Nicolog is a CLP language with the capabilities of CLP(BNR) and most
of the capabilities of cc(FD). Constraints in Nicolog are compiled
into a generalization the indexical constraints found in cc(FD) and
clp(FD). This generalization of indexical constraints is called
projection constraints. Projection constraints add conditional
operators which allow the implementation of the cardinality, blocking
implication, and constructive disjunction constraints found in cc(FD).
Nicolog has a very simple implementation (5000 lines of Prolog for the
compiler and 5000 lines of C++ for the extended WAM emulator) and yet
runs as fast as emulator based CLP languages such as cc(FD) and CLP(BNR).
Moreover, the possibility of programming directly in projection
constraints makes Nicolog more flexible than other CLP systems. For
more information, go to <http://fas.sfu.ca/cs/research/groups/ISL/> or
<ftp://ftp.fas.sfu.ca/pub/css/esl/nicolog> or contact Greg Sidebottom
<gsidebot@mprgate.mpr.ca> or see

opbdp is an implicit enumeration algorithm for solving linear 0-1
optimization problems, including a bunch of heuristics for selecting a
branching literal.  Several preprocessing techniques (coefficient
reduction, fixing, equation detection). Preprocessed problem can
written to a file readable by CPLEX and lp_solve. Technical report
included. If your favorite linear-programming based solver fails on
your problem you might give opbdp a chance. Needs a C++ compiler which
supports templates. Contact Peter Barth (barth@mpi-sb.mpg.de).

Version 0.90 of the Omega Calculator and Omega Library is now
available, including source code. The Omega library/calculator
manipulates sets of integer tuples and relations between integer
tuples. Some examples include:

{ [i,j] : 1 <= i,j <= 10};
{ [i] ->[i,j] : 1 <= i < j <= 10};
{ [i,j] ->[j,j'] : 1 <= i < j < j' <= n};

The conditions describing a set or tuple can be an formulas can
described by an arbitrary Presburger formula. Relations and sets can be
combined using functions such as composition, intersection, union and
difference. It also provides routines to generate code to iterate over
the points in an integer tuple set. The Omega library provides a
high-level, C++ interface to our routines. The Omega calculator is a
text-based interface to the Omega library. Omega is available for
anonymous ftp from ftp.cs.umd.edu:pub/omega/omega_library. More
information is available by email from omega@cs.umd.edu on the www at

   OZ:					[COST FREE]
Oz is a concurrent constraint programming language designed for
applications that require complex symbolic computations, organization
into multiple agents, and soft real-time control. It is based on a new
computation model providing a uniform foundation for higher-order
functional programming, constraint logic programming, and concurrent
objects with multiple inheritance. From functional languages Oz
inherits full compositionality, and from logic languages Oz inherits
logic variables and constraints (including feature and finite domain
constraints). Search in Oz is encapsulated (no backtracking) and
includes one, best and all solution strategies.
DFKI Oz is an interactive implementation of Oz featuring a programming
interface based on GNU Emacs, a concurrent browser, an object-oriented
interface to Tcl/Tk, powerful interoperability features (sockets, C,
C++), an incremental compiler, a garbage collector, and support for
stand-alone applications. Performance is competitive with commercial
Prolog and Lisp systems. DFKI Oz is available for many platforms
running Unix/X, including Sparcs and 486 PCs. Applications DFKI Oz has
already been used for include simulations, multi-agent systems, natural
language processing, virtual reality, graphical user interfaces,
scheduling, placement problems, and configuration.
Version 1.0 of DFKI Oz (January 23, 1995) is available by anonymous ftp
from ps-ftp.dfki.uni-sb.de:/pub/oz, or through the WWW from
Tutorials, reference manuals, and research papers are available from
the same sources. You may start with "A Survey of Oz" (8 pages) and
continue with "An Oz Primer" (110 pages). For specific questions mail
oz@dfki.uni-sb.de. To join the Oz users mailing list, contact

ProFIT (Prolog with Features Inheritance and Templates) is an extension
of Prolog with sorted feature structures (including multi-dimensional
inheritance), finite domains, feature search, cyclic terms, and
templates. ProFIT works as a pre-processor, which takes a file
containing a ProFIT program as input, and gives a file with a Prolog
program as output. Sorted feature terms and finite domains are
compiled into a Prolog term representation, and the usual Prolog term
unification is used at runtime, so that there is no slowdown through a
unification algorithm, and no meta-interpreter is needed. ProFIT uses
the same techniques for compiling sorted feature terms and finite
domains into Prolog terms as the Core Langauge Engine of SRI Cambridge
and the Advanced Linguistic Engineering Platform (ALEP 2.2) by the
European Community, BIM, and Cray Systems. ProFIT is not a grammar
formalism (although it is motivated by NLP), although it provides some
ingredients that are considered typical of grammar formalisms. The goal
of ProFIT is to provide these datatypes without enforcing any
particular theory of grammar, parsing or generation. ProFIT can be used
to extend your favourite Prolog-based grammar formalism, parser and
generator with the expressive power of sorted feature terms. Cyclic
terms can be printed out and a user-configurable pretty-printer for
feature terms is provided. ProFIT is available free of charge by
anonymous ftp from coli.uni-sb.de:/pub/profit
Implemented in Sicstus Prolog (2.1 #9) by Gregor Erbach, Univ.
Saarlandes, Saarbruecken, Germany <erbach@coli.uni-sb.de>

Prolog III was the first commercial Constraint Logic Programming
language. It incorporates all the main features of PROLOG II+, but
also gives the user the ability to express constraints over various
different domains. In particular the fundamental concept of constraint
resolution allows for numerical processing and also a complete
treatment of Boolean algebra, in a logic programming style. Version
1.5 of PROLOG III is available on wide range of platforms including PC,
MAC, UNIX, ULTRIX, VMS, NeXTSTEP, ALPHA OSF1. For more information,
write to PrologIA, Luminy - case 919 - 13288 MARSEILLE cedex 09 -
FRANCE or contact Fabienne LELEU : ph (33) 91 26 86 36 fax (33) 91 41
96 37 e-mail prologia@prologianet.univ-mrs.fr

Prolog IV is an ISO-compliant replacement for the Prolog III language.
It incorporates all the main features of Prolog III with some important
changes. Prolog IV allows programmers to express a wide variety of
constraints over real and rationnal numbers, integers (finite domains),
booleans and lists. In addition to expressing classical linear
programming problems on discrete and continuous quantities this permits
among other things the adressing of mixed real/integers problems and
the use of boolean operations to formalize constraint disjunctions.
The algorithms include a non-optimised algorithm for lists (different
from Prolog III), Gauss and Simplex algorithms for equations and linear
inequalities over rationals, and an interval method for approximate
solving of non-linear constraints over reals. The compiler is
integrated into a complete graphic programming environnment featuring
the following tools: project editor, multi-window text editor, grapher,
debugger, and on-line help.
Prolog IV is available on Unix Platforms (for about $11400) and
PC's with Windows (about $6400). These prices include two days of
training. For sales, contact Fabienne LELEU, Case 919 - Luminy 13288
Marseille cedex 09, France. Phone +33 91 26 86 36 - Fax +33 91 41 96
37. Email: prologia@prologianet.univ-mrs.fr For more information, you
can contact Andre Touraivane, Prologia Director of Research at the
same address, or email touraivane@prologianet.univ-mrs.fr

QUAD-CLP(R) is an experimental constraint logic programming system
developed in the course of PhD research by Gilles Pesant. The CLP(R)
version 1.1 source code was used as a platform for the implementation.
The system provides a further treatment of non-linear _arithmetic_
constraints over the reals as opposed to delaying them unconditionally.
It concentrates on quadratic constraints, rewriting them so that they
can actually be decided upon or generating a conservative approximation
of them (while still delaying them), potentially improving control over
the computation. In both cases the idea is to fall back on linear
constraints, more easily handled.
QUAD-CLP(R)'s incomplete solver for non-linear constraints caters for
problems of respectable size which require a certain amount of
reasoning on these constraints but cannot afford the prohibitive cost
of a complete treatment. Contact Gilles Pesant <pesant@IRO.UMontreal.CA>
The file "qclpr_tar.Z" contains the whole package: executable file
(for Sparc/SunOS and Sparc/Solaris platforms), some rudimentary pages
information and a directory containing examples.

[1] G. Pesant, M. Boyer. QUAD-CLP(R): Adding the Power of Quadratic
Constraints. Principles and Practice of Constraint Programming:
Proceedings of the Second International Workshop (Rosario, Orcas
Island, Washington, USA) (Alan Borning, ed.), Lecture Notes in Computer
Science, vol. 874, Springer-Verlag, Rosario, Orcas Island, Washington,
USA, 1994, pp. 95--108.

					[See last paragraph]
The Quantum Leap Problem Solving Engine (PSE) works like a community of
competing and cooperating experts - each one using a different
methodology to obtain the best solution to a problem. Users employ the
Problem Representation Facility (PRF), an object based, graphical
interface, to build statements of their problems. Quantum Leap employs
a coordinated team of optimization methods, including: Linear
Programming, Quadratic Programming, Generalized Reduced Gradient,
Conjugate Direction, Evolutionary Programming, Simulated Annealing,
Zoomed Enumeration, Logical Reduction, Pseudo Boltzman, and Heuristic
Search. It also offers an object-oriented, tabular, multidimensional
representation, with inheritance and self-reference, both numeric and
symbolic constructs, an English-like language, internal and external
(C) user defined functions, and many built-in aggregates and numeric
functions. It has a Client-Server Architecture, with the PSE
implemented locally, on another LAN node, or remotely. A multi-PSE
version finds faster solutions to many problems via parallel
processing. Users can define multiple objectives, and priorities among
goals. The system finds "Best Balanced" points for infeasible problems,
and multiple solutions to some problems. APIs are available that allow
a compiled model to be used as a stand-alone application. Quantum
Development wants you to solve your problem, then grant the right to
publish your approach! In return, you become a member of the LEAPER
program, use Quantum Leap for only shipping and materials cost. Leapers
will receive the LEAPER LETTER, a moderated news-list for exchange of
technical information. To receive more information, send email to
leapers@qdc.com. The body of the note should contain, as the first
line: GET <offer>. Or contact Joseph Elad (President) jelad@qdc.com
or Wenming Kuai wkuai@qdc.com. Phone USA (302) 798-0899, fax (302)

   RISC-CLP(REAL):	NON-LINEAR	[unavailable]
RISC-CLP(Real) is a logic programming language with constraints over
the real numbers and exact arithmetic. The core-solver of the language
is the partial Quantifier Elimination Algorithm for real closed fields.
This is an improvement of the original quantifier elimination algorithm
due to Collins'. RISC-CLP also employs the Groebner Basis algorithm of
Buchberger. The system was intended as a study of a CLP solver based on
purely algebraic methods, generally too slow for such an application,
and is not meant for distribution. The interpreter and the solver are
implemented on top of the computer algebra system SACLIB in C language.
Contact Hoon Hong <Hoon.Hong@risc.uni-linz.ac.at> (SACLIB and GROEBNER
are available at ftp://ftp.risc.uni-linz.ac.at and

[1] H. Hong. Non-linear real Constrains in Constraint Logic
Programming. International Conference on Algebraic and Logic
Programming, Springer Lecture Notes in Computer Science 632, 201-212.

[2] H. Hong. RISC-CLP(Real): Constraint Logic Programming over Real
Numbers. Constraint Logic Programming: Selected Research. Eds. F.
Benhamou and A. Colmerauer. MIT Press. 1993.

Screamer is an extension of Common Lisp that adds support for
nondeterministic programming. Screamer consists of two levels. The
basic nondeterministic level adds support for backtracking and undoable
side effects. On top of this nondeterministic substrate, Screamer
provides a comprehensive constraint programming language in which one
can formulate and solve mixed systems of numeric and symbolic
constraints. Together, these two levels augment Common Lisp with
practically all of the functionality of both Prolog and constraint
logic programming languages such as CHiP and CLP(R). Furthermore,
Screamer is fully integrated with Common Lisp. Screamer programs can
coexist and interoperate with other extensions to Common Lisp such as
CLOS, CLIM and Iterate.

In several ways Screamer is more efficient than other implementations
of backtracking languages. The overhead to support backtracking is only
paid for those portions of the program which use the backtracking
primitives. Deterministic portions of user programs pass through the
Screamer to Common Lisp transformation unchanged. If only small
portions of your programs utilize the backtracking primitives, Screamer
can produce more efficient code than compilers for languages in which
backtracking is more pervasive.

Screamer is fairly portable across most Common Lisp implementations.
Screamer is available from ftp.ai.mit.edu:/pub/screamer.tar.Z. Contact
Jeffrey Mark Siskind <qobi@ai.mit.edu> for further information.

There is a tools repository (ftp site) for user-contributed Screamer
code: ftp.cis.upenn.edu:/pub/screamer-tools. The repository is also
accessible at http://www.cis.upenn.edu/~screamer-tools/home.html
Questions about the repository to screamer-repository@cis.upenn.edu.

   SEL:					[COST FREE]
SEL is a declarative set processing language. Its main features are
subset and equational program clauses, pattern matching over sets,
support for efficient iteration and point-wise/incremental computation
over sets, the ability to define transitive closures through circular
constraints, meta-programming and simple higher-order programming, and
a modest user-interface including tracing. The language seems
well-suited to a number of problems in graph theory, program analysis,
and discrete mathematics. The SEL compiler is written in Quintus Prolog
and the run-time system is written in C. It generates WAM-like code,
extended to deal with set-matching, memoization, and the novel control
structure of the language. SEL is available by anonymous FTP from
ftp.cs.buffalo.edu:/users/bharat/SEL2/. The FTP release comes with a
user manual, bibliography of papers (including .dvi files), several
sample programs, and source code. For further information, write to
Bharat Jayaraman <bharat@cs.buffalo.edu>.

See ECLIPSE (also see 'ECRC SEPIA').

SICStus Prolog is a Unix prolog by SICS. It is portable to most UNIX
machines (Berkeley UNIX is preferred over System V). SICS Aurora and
Echo is a parallel emulator for Sequent Balance, Sequent Symmetry,
Encore Multimax, and BBN Butterfly (Unix). For more information, write
to SICS, Swedish Institute of Computer Science, P.O. Box 1263, S-164
28 KISTA, Sweden, call +46 8 752 15 02, fax +46 8 751 72 30, or send
email to sicstus-request@sics.se or sicstus@sics.se. Bug reports
and tech support questions should be sent to sicstus-bug@sics.se.
To subscribe to the users group and implementors mailing list, send
email to sicstus-users-request@sics.se.

A constraint-solving algorithm. See information on the Seattle ftp site
in section [1-5]. See paper by Freeman-Benson et al in section [1-6].

Chris Hanson's implementation of Steele's constraint system is
available by ftp from martigny.ai.mit.edu:/archive/cph/constraint.tar
or nexus.yorku.ca:/pub/scheme/new/constraint.tar.Z. A compressed
version is also stored there. The software is source code for MIT
Scheme. It should run in release 7.1.3. Most of the MIT Scheme
dependencies could be eliminated, but it also uses the following
procedures which aren't in standard Scheme: error, bkpt, macros,
dynamic binding, and string output ports. The code corresponds pretty
closely to Guy Steele's PhD thesis implementation, which you can obtain
in printed form from the MIT AI Lab publications office as AI-TR-595
for $15.00 (email publications@ai.mit.edu for more information). For
more information, send email to Chris Hanson

ThingLabII is a constraint-based package. See information on the Seattle
ftp site in section [1-5].

Toupie is a finite domain $\mu$-calculus interpreter designed by A.
Rauzy <rauzy@labri.u-bordeaux.fr>. It uses Decision Diagrams to
represent relations and formulas. Decision Diagrams are an extension of
the BDD first introduced by Bryant. The original propositional
$\mu$-calculus interpreter was designed to express properties of finite
states machines. In addition to classical connectives of the
propositional calculus, it provides the two quantifications and the
possibility to define relations as least or greatest fixpoints of
equations. Toupie is a $\mu(\cal FD)$ interpreter, i.e. an extension to
finite domains handling numerical linear constraints. This language has
been successfuly used for abstract interpretation of Prolog, analysis
of mutual exclusion algorithms, classical logic puzzles and
model-checking a recent presentation can be found in ESOP'94 "Symbolic
Model Checking and Constraint Logic Programming: a Cross-
Fertilization". [Information kindly supplied by Marc-Michel
Corsini <Marc.Corsini@labri.u-bordeaux.fr>.]

Trilogy is a constraint system developed by Complete Logic Systems. It
costs $100. For more information, write to Complete Logic Systems, Inc,
741 Blueridge Avenue, V7R 2J5, North Vancouver BC, Canada, or call
604-986-3234. [Does the company still exist?]

VS Trilogy is a Prolog compiler available from Vertical Software for
$395. For more information, write to Vertical Software Ltd., 14-636
Clyde Ave, W. Vancouver, BC, V7T 1E1, Canada, call 604-925-0321, or fax

WAMCC 2.2 is a WAM-based Prolog to C compiler. It conforms more or
less to the Edinburgh standard, and includes most of the usual built-in
predicates, a top-level, a Prolog debugger and a WAM debugger. It is
designed to be easily extended (for example see clp(FD)). WAMCC's
speed is halfway between SICStus emulated and SICStus native code on a
Sparc (1.5 times faster and 1.5 times slower, respectively). It
requires GCC 2.4.5 or higher and has been tested on Sparc workstations.
It should be easily ported to 32-bit machines with GCC. WAMCC is
available free by anonymous ftp from
For more information, write to Daniel Diaz <Daniel.Diaz@inria.fr>,
INRIA Rocquencourt, FRANCE.

;;; *EOF*
Go Back Up

Go To Previous