MacHack 1994/MacHack 1994.toast/MacHack™94/Talks & Papers/Timothy Knox/Prolog FAQ ⁄ Resource Guide

Text File | 1994-06-24 | 109.9 KB | 2,270 lines | [TEXT/MSWD]

Posted-By: auto-faq script
Archive-name: prolog/faq

Original-by: [e-mail] (Jamie Andrews)
Version: 1.12
Last-modified: 7/15/93 by [e-mail] (Jamie Andrews)

     This article contains the answers to some Frequently Asked
Questions (FAQ) often seen in comp.lang.prolog.  It is posted
(twice a month, currently on the 1st and 16th) to help reduce
volume in this newsgroup and to provide hard-to-find information
of general interest.

     This article includes answers to the following questions.

0. General information
1. What is the Association for Logic Programming?
2. Where can I get a public-domain, free Prolog for (the IBM PC,
   the Mac, Unix)?
3. What commercial systems are available?  What about systems
   available for a price from research institutions?
4. How do I get in touch with my Prolog's users' group,
   sales representative, or technical support line?
5. I think language X is better than Prolog.  What do you think?
6. My Prolog prof assigned me this problem.  Can you help
   me with it?
7. Can you suggest some books on Prolog?
8. Are there any FTP archive sites for comp.lang.prolog?
9. How can I get a copy of the draft ISO Prolog standard?
   Where can I go for more information about it?
10. How does the WAM (Warren Abstract Machine) work?  How do I
   write a WAM-based compiler or a WAM emulator?

     Please forward suggestions for further questions and
answers to the current FAQ maintainer, [e-mail] (Jamie
Andrews).

Changes in this version:
* Updated information for BinProlog.
* Updated information for Open Prolog.
* Updated information for ai.uga.edu site systems.
* Added information for Aquarius Prolog.
* Added information for XSB.
* Added information for TPM (the Transparent Prolog Machine).
* Added contact information for Expert Systems Ltd. / Prolog-2.
* Added information for Covington's summary of the Prolog standard.
* Added question 10.

            *    *    *

0. General information

     The newsgroup "comp.lang.prolog" discusses the language
Prolog and other "logic programming" languages.  Logic
programming languages, in general, are programming languages
which incorporate some of the language of mathematical logic;
unification and backtracking search are common operational
features.  For more background information about Prolog, see the
list of books in Question 7 of this list.

            *    *    *

1. What is the Association for Logic Programming?

     To keep up with the current state of logic programming
technology, readers can join the Association for Logic
Programming (ALP) and receive their Newsletter.  For details on
how to join, contact:

        Cheryl Anderson,
        ALP Administrative Secretary,
        Dept. of Computing,
        Imperial College,
        180 Queen's Gate,
        London, SW7 2BZ, UK

Email:   [e-mail]
Fax:    [phone]
Phone:  [phone] x5011

     The Prolog Resource Guide (v0.6) was printed in issue 5/1
of the Newsletter (Feb. 1992). This lists information concerning
Prolog Archives, Books, Suppliers, etc.  It is now maintained by
Mark Kantrowitz ([e-mail]), and
posted periodically to comp.lang.prolog (see question 3).

     To send in Newsletter contributions, write to:

        Andrew Davison,
        Dept. of Computer Science,
        University of Melbourne,
        Parkville,
        Melbourne, Victoria 3052,
        AUSTRALIA

Email:   [e-mail]
Fax:    [phone]
Phone:  [phone] / 5230
Telex:   AA 35185

            *    *    *

2. Where can I get a public-domain, free Prolog for (the IBM PC,
   the Mac, Unix)?

     The following are anonymous-FTP sites for free Prologs
which are either in the public domain or are "copy-lefted"
(permitted to be copied with some restrictions on commercial use).

     [Please see Mark Kantrowitz's monthly "Prolog Resource
Guide" posting (see question 3) for information about non-free
implementations.]

     (Please note that for extensive development work, users
will probably want a robust interpreter or compiler with good
debugging facilities and a standard syntax, among other things.
While public-domain systems are a valuable service to the
community, they do not necessarily have all these things, and
users should weigh carefully what they want to do against the
capabilities and costs of the available systems.)

For the IBM PC:
- BinProlog 1.71, anonymous FTP from clement.info.umoncton.ca
  (139.103.16.2), directory BinProlog.  Compiler for 386/486 machines.
  E-mail: [e-mail] (Paul Tarau).
- Anonymous FTP from aisun1.ai.uga.edu, directory ai.prolog;
  download "Contents" first.  ADA Prolog and ESL Prolog.
  E-mail: [e-mail] (Michael Covington).
- SWI Prolog, anonymous FTP from swi.psy.uva.nl (192.42.96.1),
  directory pub/SWI-Prolog; or from ftp.th-darmstadt.de
  (130.83.55.75), directory pub/programming/languages/prolog.
  Portable, copy-lefted.

For the Apple Macintosh:
- Anonymous FTP from aisun1.ai.uga.edu, directory ai.prolog;
  download "Contents" first.  Demo version of LPA MacProlog.
  E-mail: [e-mail] (Michael Covington).
- Open Prolog 1.0d40, anonymous FTP from grattan.cs.tcd.ie
  (134.226.32.15), directory pub/languages/open-prolog.  In
  SEA/binhex form.
  E-mail: [e-mail] (Michael Brady).
- UPMAIL Tricia Prolog, anonymous FTP from ftp.csd.uu.se
  (130.238.12.1), directory pub/Tricia; get README first.
  Email: [e-mail].
- TPM (the Transparent Prolog Machine), anonymous FTP from
  hcrl.open.ac.uk, directory /pub/software.  Demo LPA
  MacProlog with the TPM debugger built on top.

For Unix systems:
- BinProlog 1.39, anonymous FTP from clement.info.umoncton.ca
  (139.103.16.2), directory BinProlog.  Compiler for SPARC
  (SunOS 4.x + Solaris), SUN3, NEXT.
  E-mail: [e-mail] (Paul Tarau).
- SWI Prolog, anonymous FTP from swi.psy.uva.nl (192.42.96.1),
  directory pub/SWI-Prolog; or from ftp.th-darmstadt.de
  (130.83.55.75), directory pub/programming/languages/prolog.
  Portable, copy-lefted.
- SB-Prolog, anonymous FTP from cs.arizona.edu, directory
  "sbprolog/v3".  Version 3.  Copy-lefted.
- Modular SB-Prolog (= SB-Prolog version 3.1 plus modules),
  anonymous FTP from ftp.dcs.ed.ac.uk (129.215.160.5), file
  pub/dts/mod-prolog.tar.Z .  Interpreter for SPARC.
  E-mail: [e-mail] (Brian Paxton).
- ALF (Algebraic Logic Functional language), WAM-based language
  with narrowing/rewriting, anonymous FTP from ftp.germany.eu.net,
  directory "pub/programming/languages/LogicFunctional".
  E-mail: [e-mail] (Rudolf Opalla).
- CLP(R), available by e-mail request from Joxan Jaffar,
  "[e-mail]".  Constraint logic programming language,
  for academic and research purposes only.
- Aquarius Prolog 1.0, send message with body "get aquarius-info
  license" to [e-mail].  High performance,
  commercial functionality except debugging and modules.  For
  SPARC, DECstation, MIPS, HP 9000 series, Sun 3.  Copy-lefted.
- XSB, system with OLDT-resolution and HiLog capability.  Compiler
  for Linux, Sun, Sparc, and NeXT.  Anonymous FTP from
  cs.sunysb.edu (130.245.1.15), directory pub/XSB.
  E-mail: [e-mail]

            *    *    *

3. What commercial systems are available?  What about systems
   available for a price from research institutions?

     Many commercial systems are listed in the periodically
posted Prolog Resource Guide.  The Resource Guide also lists
many systems which are not exactly "commercial", but available
for a price from research instutitions.  The list of such
systems was originally compiled by Chris Moss, of Imperial
College.  The rest of the Resource Guide was originally compiled
by Dag Wahlberg, of Uppsala University.

     The Resource Guide is now maintained by the kind efforts
of Mark Kantrowitz, "[e-mail]", who
posts it ON THE 14TH OF EVERY MONTH on comp.lang.prolog.  It is
also available by anonymous FTP from "ftp.cs.cmu.edu" [128.2.206.173]
in the directory "/afs/cs.cmu.edu/user/mkant/Public/AI/", as the
file "prolog-resource-guide.text".

     Readers should also note that the newly formed Prolog
Vendors' Group is contactable electronically via the Secretary,
Al Roth.  His email is "[e-mail]".

            *    *    *

4. How do I get in touch with my Prolog's users' group,
   sales representative, or technical support line?

     Here are some e-mail addresses of these contacts, listed
alphabetically by company or major product name.  Please note
that sometimes phoning or writing to the company will get better
response than e-mail.

ALS (Applied Logic Systems):
  Information:    [e-mail]
  Sales:    [e-mail]
  Tech support:    [e-mail]

Amziod (Cogent Prolog):
  All:        [e-mail]

Expert Systems Ltd. (Prolog-2):
  Sales:    [e-mail]
  Support:    [e-mail]
  Users' group:    [e-mail]

LPA:
  Sales:    [e-mail]
  Tech support:    [e-mail]

PDC Prolog:
  Information:    [e-mail]
  Sales:    [e-mail]
  Tech support:    [e-mail]

ProLog by BIM:
  Contact:    [e-mail] (Kathleen Pierco)

Quintus:
  Users' group:    [e-mail]
  Sales:    [e-mail]
  Tech support:    [e-mail]

Sepia:
  User's group:    [e-mail]
  Information:    [e-mail]
  Tech support:    [e-mail]

SICStus:
  Users' group:    [e-mail]
  Sales:    [e-mail]
  Tech support:    [e-mail]

Turbo Prolog:
  Turbo Prolog is the older name for PDC Prolog (see above).

            *    *    *

5. I think language X is better than Prolog.  What do you think?

     These debates rarely result in any productive discussion.
To some extent, one's favourite language is based on irrational
ideology.

     However, many people now agree that different languages are
good for different things.  Prolog seems to be good for problems
in which logic is intimately involved, or whose solutions have a
succinct logical characterization.  Like other interactive,
symbolic languages, Prolog is also good for rapid prototyping.

     Also, please note that there are many different "Prologs"
and other logic programming languages available, all with
different capabilities.

            *    *    *

6. My Prolog prof assigned me this problem.  Can you help
   me with it?

     If your instructor assigned it to you, he or she probably
wanted you to do it yourself.  If it's an introductory Prolog
course, your question might be elementary to most readers, so it
might be a waste of network resources to ask it.  Please ask
your instructor, a friend, a teaching assistant, or a local
newsgroup for help first.

     That being said, there are comp.lang.prolog readers who
would be glad to help people making a legitimate attempt to
learn Prolog.

            *    *    *

7. Can you suggest some books on Prolog?

     The Prolog Resource Guide (see above, question 3) contains
a listing of Prolog books.  It is maintained by Mark Kantrowitz
([e-mail]), and posted periodically
on comp.lang.prolog.

     Here are some of the most popular books on Prolog.

_Programming in Prolog_.  William F. Clocksin and Christopher S.
Mellish.  Springer-Verlag, 1987.  (Introductory.)

_The Art of Prolog:  Advanced Programming Techniques_.  Leon
Sterling and Ehud Shapiro.  MIT Press, 1986.  (Advanced.)

_The Craft of Prolog_.  Richard A. O'Keefe.  MIT Press, 1990.
(Advanced.)

_Foundations of Logic Programming_.  John Lloyd.
Springer-Verlag, 1988 (2nd ed).  (Logic programming theory.)

            *    *    *

8. Are there any FTP archive sites for comp.lang.prolog?

     Yes.  As of the latest check, the following archive sites
contain selected recent articles from comp.lang.prolog in the
indicated directories.

"cs.dal.ca": /pub/comp.archives/comp.lang.prolog
"rtfm.mit.edu": /pub/usenet/comp.lang.prolog
"src.doc.ic.ac.uk": /usenet/comp.archives/auto/comp.lang.prolog
"cnam.cnam.fr": /pub/Archives/comp.archives/auto/comp.lang.prolog

     Some other sites contain copies of this FAQ list and the
Prolog Resource Guide (see question 3).  For users with "archie"
access, type "archie comp.lang.prolog" for an up-to-date list of
sites having either archives or the periodic postings.

            *    *    *

9. How can I get a copy of the draft ISO Prolog standard?
   Where can I go for more information about it?

     You can pick up a copy by anonymous FTP from site
"ai.uga.edu", directory "ai.prolog.standard".  The directory
also contains a summary of the standard, by Michael Covington,
in the "isoprolog" files.  Note that no one at that site can
answer any questions about the standard; it is just an FTP site
for the standard in the USA.

     For more information about the ISO Prolog standard, contact

Roger Scowen
ISO/IEC JTC1 SC22 WG17 (Prolog) convener,
DITC/93,  National Physical Laboratory
TEDDINGTON, Middlesex TW11 0LW
UNITED KINGDOM
Tel: [phone]
Fax: [phone]
E-mail: [e-mail]

            *    *    *

10. How does the WAM (Warren Abstract Machine) work?  How do I
   write a WAM-based compiler or a WAM emulator?

     Reportedly the best tutorial is Hassan Ait-Kaci's book
_Warren's Abstract Machine: A Tutorial Reconstruction_ (MIT
Press, 1991).  A public-domain WAM emulator, written in C++ by
Herve Touati, is available by anonymous FTP at site
"gatekeeper.dec.com", in directory "pub/plan/prolog/ucb".

            *    *    *

Acknowledgements

     For help in putting together this FAQ, thanks to Andrew
Davison, Mike Brady, Michael Covington, Stephen Bevan, John
Dowding, Thilo Kielmann, Paul Singleton, Dave Moffatt, Dani de
Ridder, Per Bilse, Chris Moss, Kathleen Pierco, Paul Tarau,
Jonathan Kamens, Jan Wielemaker, Dag Wahlberg, Micha Meier, Don
Sannella, Clive Spenser, Yuan Liu, Jonas Barklund, and Ian
Dickinson.  Special thanks to John Dowding for suggesting a good
format for the list, and to Chris Moss, Dag Wahlberg, and Mark
Kantrowitz for their work on the Prolog Resource Guide.

--Jamie Andrews.
  [e-mail]
---------------------------------------------------------------------------



Archive-name: prolog/resource-guide/part1
Last-Modified: Wed Oct  6 00:03:00 1993 by Mark Kantrowitz
Version: 1.12

;;; ****************************************************************
;;; Prolog Resource Guide ******************************************
;;; ****************************************************************
;;; prg_1.faq -- 41997 bytes

Contributions and corrections should be sent to Mark Kantrowitz
at [e-mail].

This guide lists a variety of resources for the Prolog community,
including books, magazines, ftp archives, and products. It is posted
once a month to the newsgroups comp.lang.prolog and comp.object.logic.

The original version of this guide (Version 0.6, Dec 11, 1991) was
compiled by Dag Wahlberg, Uppsala University, Sweden <[e-mail]>.
Other people who helped with the compilation include Chris Moss
<[e-mail]>, Mats Carlsson, SICS <[e-mail]>,
Michael A. Covington <[e-mail]>, Jocelyn Paine
<[e-mail]>, Per G. Bilse, PDC <[e-mail]>, David Cohen, BIM
Systems Inc <[e-mail]>, Mark Korsloot <[e-mail]>, and
David W. Talmage <[e-mail]>.

Thanks also to Jamie Andrews <[e-mail]>.

Suggestions and comments to:    [e-mail]

----------------------------------------------------------------
Table of Contents (Part 1):

  [1-0] Introduction
  [1-1] Sources of information about Prolog
  [1-2] FTP Archives and Other Resources
  [1-3] Prolog-related Mailing Lists
  [1-4] Books and Magazine Articles
  [1-5] The Prolog 1000 Database
  [1-6] X-Windows Interfaces
  [1-7] Is there a straight-forward way of compiling Prolog to C?
  [1-8] What is the Basic Andorra Model and AKL?

Prolog Implementations (Part 2):
  [2-1] Public Domain or Free Prolog Implementations
  [2-2] Commercial Prolog Implementations

Search for [#] to get to topic number # quickly. In newsreaders which
support digests (such as rn), [CTRL]-G will page through the answers.


Recent Changes:
;;; 1.9:
;;; 20-JUL-93 mk    Updated IC-Prolog II entry and the PARLOG entry.
;;; 10-AUG-93 mk    Inserted [1-7] about compiling Prolog to C.
;;;
;;; 1.10:
;;; 24-AUG-93 mk    Corrected subscription info to EJFLP.
;;; 25-AUG-93 mk    Added entry on theorem-provers mailing list to [1-3].
;;;
;;; 1.11:
;;; 13-SEP-93 mk    Added entry on SLG to part 2.
;;;
;;; 1.12:
;;;  6-OCT-93 mk    Added entry on JB Prolog 2.1
;;; 12-OCT-93 mk    Added mention of Goedel mailing list to Goedel entry.

----------------------------------------------------------------
Subject: [1-0] Introduction

This guide lists Prolog resources: archives, newsgroups, books,
magazines, compilers, interpreters and anything else you can think of
which has to do with the proliferation of Prolog. Also included is a
list of suppliers of products and a list of publishers. As Prolog has
a strong historical tradition in Europe, we've tried to ensure that
the information is relevant to all readers, both European and North American.

This guide is posted regularly to comp.lang.prolog and comp.object.logic.
It may also be obtained by anonymous ftp from CMU:

   To obtain the file from CMU, connect by anonymous ftp to any CMU CS
   machine (e.g., ftp.cs.cmu.edu [128.2.206.173]), using username
   "anonymous" and password "name@host". The files prg_1.faq and prg_2.faq
   are located in the directory
       /afs/cs.cmu.edu/project/ai-repository/ai/pubs/faqs/prolog/
   [Note: You must cd to this directory in one atomic operation, as
   some of the superior directories on the path are protected from
   access by anonymous ftp.] If your site runs the Andrew File System,
   you can just cp the file directly without bothering with FTP.

The FAQ postings are also archived in the periodic posting archive on
rtfm.mit.edu [18.70.0.224]. Look in the anonymous ftp directory
/pub/usenet/news.answers/ in the subdirectory prolog/. If you do not
have anonymous ftp access, you can access the archive by mail server
as well.  Send an E-mail message to [e-mail]
with "help" and "index" in the body on separate lines for more
information.

Disclaimer:

   We have taken great care in making the information in this document as
   accurate as possible. However we are not responsible for any problems
   which might occur from using information supplied in this guide.

----------------------------------------------------------------
Subject:  [1-1]  Sources of Information about Prolog

The newsgroups comp.lang.prolog, comp.object.logic, and (to a lesser
extent) comp.ai are a source of information and discussion about Prolog.

A "Frequently Asked Questions" posting is posted to comp.lang.prolog
twice a month by Jamie Andrews <[e-mail]>. The Prolog FAQ and this
Prolog Resource Guide are intended to complement one another.

The draft ISO standard for Prolog is available by anonymous ftp from
ai.uga.edu:/ai.prolog.standard [128.192.12.9]. An unofficial summary
of the draft ISO Prolog standard is available from
ai.uga.edu:/ai.prolog.standard/ as isoprolog.tex or isoprolog.ps.Z.
Send mail to Michael Covington <[e-mail]> for more information.

----------------------------------------------------------------
Subject: [1-2]  FTP Archives and Other Resources

The following are achives that contain Prolog-related material, such as
code, interpreters, articles, etc. Most of the archives are ftp sites.
They are listed by domain.name and [IP Address]. To access them and
download programs type at the prompt:

    ftp <site name> (or IP address)
    login: "anonymous",
    password: your own return email address,
    cd <directory>, ls to see files,
    set binary,
    get <filename> to transfer file to your system
    stop with quit or exit

Deviations from this general scheme may occur but the above should
work in most cases.


Artificial Intelligence Programs:
   ai.uga.edu [128.192.12.9]

   Contains public domain Prologs, such as Open Prolog and ESL PD Prolog,
   all programs from the book by Covington, Nute, and Vellino, (see
   the section on Books below), PrEd (a small text editor for Prolog)
   and some technical reports with accompanying code. Maintained by
   Michael Covington, the University of Georgia, [e-mail].

ALE:
   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 <[e-mail]>.

ALP-UK Library:
   The best Prolog library currently is the one collected by the ALP-UK
   group. It is available to members at 30 pounds sterling for a Sun
   cartridge or 2 pounds/IBM DOS disk. (non-members maybe, how much?) It
   contains MBs of Prolog systems (including SB Prolog), libraries
   (including the Edinburgh library), benchmarks, grammars, theorem provers,
   object and graphics systems etc. For more information, write to ALP-UK
   Library, Sanjay Raina, Librarian, Dept. of Computer Science, University
   of Bristol, University Walk, Bristol BS8 1TR, UK, call [phone]
   x3304, or send email to [e-mail].

CASLOG
   CASLOG (Complexity Analysis System for LOGic) is an experimental
   semi-automatic complexity analysis system for logic programs. It can
   perform the worst-case analysis for complexity measures: argument size
   complexity, number of solutions complexity, and time complexity.

   CASLOG extends the techniques developed for analyzing imperative and
   functional languages to deal with nondeterminism and generation of
   multiple solutions via backtracking in logic languages. The analyses
   for different complexity measures are implemented in a unified
   framework and share several common features. First, the predicates in
   a program are processed in an order generated by a bottom-up
   topological sorting over the call graph of the program. Second, the
   complexity function for a predicate is derived from the complexity
   function of its clauses by using the information about the mutual
   exclusion relationships between its clauses. Third, the complexity
   function for a clause is inferred based on the data dependency
   relationships between its literals. Fourth, the complexity functions
   for recursive clauses are in the form of difference equations and are
   transformed into closed form functions using difference equation
   solving techniques. This unified framework can simplify proofs of
   correctness and the implementation of the algorithms.

   CASLOG is available by anonymous ftp from cs.arizona.edu:caslog/. This
   is an alpha distribution, and includes CASLOG version 1.0, a
   preliminary user manual, a paper on CASLOG, and a set of examples.
   For more information, contact Nai-Wei Lin <[e-mail]>.

Constraint Programming Paper Archive:
   Aarhus University, Denmark, has established an anonymous ftp archive
   for papers on "Constraint Programming" at ftp.daimi.aau.dk:pub/CLP/.
   For further information, contact Brian H. Mayoh <[e-mail]>.

Eden
   Eden is a Poplog-based AI microworld developed by Simon Perkins,
   Jocelyn Paine and Edmund Chattoe of the Oxford University Artificial
   Intelligence Society. It is intended to serve as a testbed for
   learning and planning programs. Programs written in Pop-11, Prolog,
   Lisp, and ML control a "bug" that lives in a 2-dimensional world. Any
   kind of algorithm may be used to control the bug, including genetic
   algorithms, neural nets, and rule-based systems. Eden consists of a
   grid of cells, each of which can contain objects such as keys, doors,
   boulders and quicksand. Bug's objective is to find and eat a piece of
   food which the simulator has placed somewhere within this grid. To do
   this, Bug must negotiate its way towards the food while dealing
   intelligently with obstacles. Eden's laws of physics allow Bug to take
   one of several different actions when it encounters an object. The
   simulator then works out the consequences of the chosen action on Bug
   and on Eden, and displays these graphically in a Ved window. Bug's
   perceptions are updated to reflect the new state of the world, and the
   cycle repeats. Eden is available by anonymous ftp from the Imperial
   College archive, src.doc.ic.ac.uk [146.169.2.1] in the directory
   computing/programming/languages/prolog/pd-software (a shortcut is
   packages/prolog-pd-software) as the file eden.tar.Z. Eden includes
   PopBeast, a simple Prolog bug which can read and parse simple
   commands, extract their meaning, plan how to satisfy these commands,
   and then carry out the plans.

   The Oxford University AI Society is running an international AI
   competition for Eden bugs. Send your source code to Jocelyn Paine
   <[e-mail]> or Edmund Chattoe <[e-mail]> by
   May 1, 1993, if you'd like to enter.

Logic Programming Bibliographies:
   duck.dfki.uni-sb.de [134.96.188.92]

   The BiBTeX bibliographies are available in /pub/lp-proceedings.
   BibTeX entries for the proceedings of the following conferences
   are included: SLP84-87,91, NACLP89-90, ILPS91, ICLP82,84,86-91,93,
      JICLP92, LP88, RTA89,93, PLILP90-92, ALPUK91, ICOT92, ALP90,92,
      CADE90,92, CTRS90,92, LICS86-91, UNIF89, EPIA89,91,93, TACS91,
      TAPSOFT93, EAIA90
   and the following journals: JLP85-93, JAR91,92, JSC91,92, IANDC82-92.

   The ftp server supports tar'ing on the fly, so if you type "get
   bibtex.tar" you will get a tar'ed version of the "bibtex" directory.
   Send comments and bug reports to [e-mail].

Machine Learning Algorithms Implemented in Prolog:
   In 1988 the Special Interest Group on Machine Learning of the German
   Society for Computer Science (GI e.V.) decided to establish a library
   of PROLOG implementations of Machine Learning algorithms. The library
   includes - amongst others - PROLOG implementations of Winston's arch,
   Becker's AQ-PROLOG, Fisher's COBWEB, Brazdil's generation of
   discriminations from derivation trees, Quinlan's ID3, inverse
   resolution, and Mitchell's version spaces algorithm. The programs are
   currently available via anonymous ftp-server from the GMD:

    ftp.gmd.de:/gmd/mlt/ML-Program-Library [129.26.8.90]

   Send additional PROLOG implementations of Machine Learning
   Algorithms, complaints about them and detected bugs or problems
   to Thomas Hoppe, <[e-mail]>. Send suggestions and
   complaints about the ftp library to Werner Emde, Gesellschaft
   fuer Mathematik und Datenverarbeitung, Bonn, <[e-mail]>.

Natural Language Processing in Prolog:

   The Prolog and DCG programs from Pereira and Shieber's book, "Prolog
   and Natural Language Analysis", are available by anonymous ftp from
   das.harvard.edu:pub/shieber/pnla/. See the file README for the
   conditions under which the material is distributed. If you retrieve
   the files, please send an email message to the authors letting them
   know how you plan to use them. For further information, write to
   Fernando Pereira <[e-mail]> or Stuart Shieber
   <[e-mail]>.

Object-Oriented Program in Prolog:

   OL(P), Object Layer for Prolog, is an object-oriented extension to
   Prolog.  It provides an object-oriented structuring and reuse
   mechanism for Prolog in a manner that preserves performance and
   semantics. The object-oriented layer is compiled into Prolog without
   introducing any side-effects.  OL(P) takes the view of objects as
   collections of predicates (called methods).  To Prolog, OL(P) 1.1 adds
   objects with methods, data encapsulation, instances, and multiple
   inheritance. Object methods can access Prolog predicates and vice
   versa. The OL(P) incremental compiler translates OL(P) programs to
   Prolog programs that don't need runtime interpretation (e.g., no
   search is needed for inheritance).  OL(P) 1.1 comes with prepared
   installation for SICStus Prolog and QUINTUS Prolog (both on UNIX),
   documentation, simple built-in project management, some libraries,
   and example programs. The source is included, so you can port OL(P)
   to different platforms, different Prolog systems, and different
   logic programming languages. OL(P) is available by anonymous ftp
   from parcftp.xerox.com:/ftp/pub/ol/ [13.1.64.94]. Written by Markus
   P.J. Fromherz <[e-mail]>.

Pleuk Grammar Development System:

   Pleuk is intended to be a shell for grammar development, in that many
   different grammatical formalisms can be embedded within it.
   Grammatical formalisms that currently work with Pleuk include CFG (a
   simple context-free grammar system), HPSG-PL (a system for developing
   HPSG-style grammars, produced at Simon Fraser University, Canada, by
   Fred Popowich, Sandi Kodric and Carl Vogel), Mike (a simple
   graph-based unification system, enhanced with additional operations
   for the treatment of free word order proposed by Mike Reape in various
   publications), SLE (a graph-based formalism enhanced with arbitrary
   relations in the manner of Johnson & Rosner and Doerre & Eisele.
   Delayed evaluation is used to compute infinite relations.  This system
   has been used for the development of several HPSG-style grammars) and
   Term (a term-based unification grammar system, originally developed
   for the support of Unification Categorial Grammar of Zeevat, Klein and
   Calder). Sample grammars are provided for all of these formalisms.
   Work continues apace on other formalisms, including Bob Carpenter's
   Ale system for typed feature structures, and Veronica Dahl's Static
   Discontinuity Grammars.

   Pleuk requires SICStus prolog version 2.1#6 or later, plus a variety
   of ancillary programs available free of charge from many FTP servers.
   Pleuk is available via anonymous FTP from the University of Georgia
   Artificial Intelligence FTP library, hostname
   ai.uga.edu:/ai.natural.language/ as the files pleuk.1.0.tar.Z,
   pleuk.PSmanuals.tar.Z, and pleuk.README.  Pleuk will also be available
   shortly from the Natural Language Software Registry, German Research
   Institute for Artificial Intelligence (DKFI), Saarbruecken.  For more
   information, send email to [e-mail].

Prolog Repository:
   Established by Jocelyn Paine of Experimental Psychology, Oxford
   University in 1987. The current catalogue (January 1991) contains
   30 entries. For catalogue, queries and contributions contact POPX at:
      [e-mail] (internet) or
      [e-mail] (janet)

   FTP access is available through the Imperial College archive at
      src.doc.ic.ac.uk  (146.169.2.1)
   in the directory
      computing/programming/languages/prolog/pd-software
   with a short-cut link of:
      packages/prolog-pd-software
   To access it, cd to either of the above directories via
   anonymous ftp. The file README gives a brief summary of the
   contents of the directory and CATALOGUE gives a (long!)
   description of each entry. Entries include the Logic Programming
   Tutor from Paine's book, the DEC-10 public-domain library, the
   Linger natural-language corrector, a simple object-oriented
   add-on for Prolog, graph utilities, among other things.

   Files in the archive are also available on MS-DOS floppies for a
   nominal fee to cover the cost of floppies, postage, and packing.

Prolog to SQL Compiler:
   The Prolog to SQL Compiler translates database access requests,
   which consist of a projection term and a database goal, to the
   appropriate SQL query. The compiler is written in standard Edinburgh
   Prolog and has been ported to a number of Prologs. The code posted to
   comp.lang.prolog works in ECRC's SEPIA Prolog, but should be easily
   ported to other Prologs. A detailed tech report on the implementation
   is available by email from [e-mail] (include
   your full postal address). The compiler is copyright, but may be used
   free of charge for non-commercial purposes and redistributed provided
   the copyright notice is retained intact.

PSI:
   PSI is a handy system for the management and retrieval of your
   personal data, be it addresses, CD collections, or bibliographic
   references. It is intended for the non-commercial user. It may not be
   as full-fledged as some data-base systems, but has some features that
   you won't find in most commercial systems. Also, you may find it
   easier to set up and faster to use. PSI is useful for a broad range of
   data. Indexing with descriptors makes searching for the data you need
   fast, and the interface to other data-base formats (import and export)
   is quite powerful. PSI was written in LPA MacProlog and is a "genuine
   'double clickable' Mac application". PSI runs on all Macs with System
   6 or 7 in 1MB of main memory. As LPA MacProlog isn't yet 32-bit clean,
   PSI isn't either. Extensive documentation and some examples are
   included. PSI is available by anonymous ftp from
   sumex-aim.stanford.edu, directory info-mac/app, file psi-23.hqx. It
   was also available on a recent Nautilus CD-ROM and will be on the
   first Info-Mac CD-ROM.

SEL:

   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 <[e-mail]>.

----------------------------------------------------------------
Subject: [1-3]  Mailing Lists

Prolog and Logic Programming:
   [e-mail] (general)
   [e-mail] (nitty gritty)

   All requests to be added to or deleted from this list, problems,
   questions, etc., should be sent to [e-mail]

   [The host sushi.stanford.edu no longer exists, as of 11/24/92.
    Does anybody know the new location of the mailing lists?]

Lambda Prolog:
   [e-mail]

   To subscribe, send mail to [e-mail].

Electronic Journal of Functional and Logic Programming (EJFLP)

   EJFLP is a refereed journal that will be distributed for free via e-mail.
   The aim of EJFLP is to create a new medium for research investigating the
   integration of the functional, logic and constraint programming paradigms.

   For instructions on submitting a paper, send an empty mail message with
      Subject: Help
   to:
      [e-mail].
   You will receive an acknowledgment of your submission within a few hours.

   To subscribe to the journal, send an empty mail message to the following
   address:
       [e-mail]
   You will receive an acknowledgment of your subscription within a few days.

   If there are any problems with the mail-server, send mail to
   [e-mail].

   The editorial board is: Rita Loogen (RWTH Aachen), Herbert Kuchen (RWTH
   Aachen), Michael Hanus (MPI-Saarbruecken), Manuel MT Chakravarty (TU
   Berlin), Martin Koehler (Imperial College London), Yike Guo (Imperial
   College London), Mario Rodriguez-Artalejo (Univ. Madrid), Andy Krall
   (TU Wien), Andy Mueck (LMU Muenchen), Tetsuo Ida (Univ. Tsukuba,
   Japan), Hendrik C.R. Lock (IBM Heidelberg), Andreas Hallmann (Univ.
   Dortmund), Peter Padawitz (Univ. Dortmund), Christoph Brzoska (Univ.
   Karlsruhe).

PDC-L:
   [e-mail] is a discussion list for PDC Prolog users.

Theorem Provers:
   [e-mail]

   This (unmoderated) list is intended for announcements of interest to
   people interested in automated theorem proving.

   To subscribe, send your email address to [e-mail].

----------------------------------------------------------------
Subject: [1-4] Books and Magazine Articles

A BiBTeX bibliography of Logic Programming Conferences is available by
anonymous ftp from duck.dfki.uni-sb.de. See [1-2] above.

A partially annotated bibliography of work on integrating
object-oriented and logic programming is available by anonymous ftp
from menaik.cs.ualberta.ca:pub/oolog/ in PostScript and BibTeX
formats. Written by Vladimir Alexiev <[e-mail]>.

The following books are regarded as popular and widely used. Also
included are some books about WAM. This is not intended to be a complete
Prolog bibliography.

   Ait-Kaci, Hassan, "Warren's Abstract Machine: A Tutorial Reconstruction",
   MIT Press, Cambridge, MA. 1991.
   ISBN: 0-262-51058-8 (paper), 0-262-01123-9 (cloth).

   Bratko, Ivan, "Programming in Prolog for Artificial Intelligence",
   2nd Edition, Addison-Wesley, 1990

   Campbell, J.A. (ed):     "Implementations of Prolog", John Wiley, 1984

   Clocksin, W.F. and Mellish, C.S: "Programming in Prolog", 3rd Ed.
   Springer Verlag, 1987, $29. (Basic Introduction).

   Conlon, Tom: "Programming in Parlog". Addison-Wesley, 1989,
   ISBN 0-201-17450-2.

   Covington, Michael A.; Nute, D.; and Vellino, A. "Prolog
   Programming in Depth", Scott, Foresman & Co., 1987. ISBN 0-521-40984-5

   Deville, Yves: "Logic Programming, Systematic Program Development",
   International Series in Logic Programming, Addison-Wesley, 1990, 338 pages.
   ISBN 0-201-17576-2.

   Gregory, Steve: "Parallel Logic Programming in Parlog: The Language
   and Its Implementation", Addison-Wesley, 1987, ISBN 0-201-19241-1.

   Hogger, C.J.: "Introduction to Logic Programming", Academic Press 1984

   O'Keefe, Richard A.:     "The Craft of PROLOG", MIT Press, 1990,
   ISBN 0-262-15039-5.

   Kluzniak and Szpakowicz: "Prolog for Programmers", Academic Press 1985

   Kowalski, R.A.: "Logic for Problem Solving", New York 1979, Elsevier Publ.

   Le, Tu Van,  "Techniques of Prolog programming, with implementation
   of logical negation and quantified goals", John Wiley, New York, 1993.
   ISBN: 0-471-57175-X (American edition), 0-471-59970-O (International
   edition).  LnProlog, a Prolog interpreter that supports negative
   finding queries and quantified queries is available together with
   the book.

   LLoyd, John: "Foundations of Logic Programming", 2nd Edition,
   Springer-Verlag, 1988. (Intro to logic programming theory.)

   David Maier and David S. Warren: "Computing with Logic: Logic
   Programming with Prolog", Benjamin Cummings, Menlo Park, CA, 1989.

   Dennis Merritt: "Building Expert Systems in Prolog", Springer-Verlag 1989.
   Explains how to build various expert system shells in Prolog, including
   forward/backward chaining, FOOPS, rete-network, frames and more. Includes
   complete source code listings. (Source code from the book is also
   sold on disk by Amziod.)

   Dennis Merritt: "Adventure in Prolog", Springer-Verlag, 1990.
   Teaches Prolog by leading the reader through the construction of an
   adventure game. The exercises lead the reader through three other
   programs:  an intelligent database, an expert system and an order-entry
   program.  While most texts teach Prolog with fragments of interesting code,
   this book takes a more pragmatic (as opposed to theoretical approach) and
   shows the reader how to assemble complete Prolog programs.

   Nilsson, Ulf and Maluszynski, Jan, "Logic, Programming and Prolog",
   John Wiley & Sons, 1990, ISBN 0-471-92625-6.

   Peter Ross, "Advanced Prolog: Techniques and Examples",
   Addison-Wesley, 1989, ISBN 0-201-17527-4.

   Sterling, Leon (ed): "The Practice of Prolog", MIT Press, 1990
   ISBN 0-262-19301-9

   Sterling, Leon, Shapiro, Ehud: "The Art of Prolog: Advanced Programming
   Techniques", MIT Press, 1986 ISBN 0-262-19250-0

   Tick, E.: "Parallel Logic Programming". MIT Press, 1991

   David H. D. Warren: "An Abstract Prolog Instruction Set", Technical Note
   No 309, SRI International, Menlo Park, CA, 1983.

   David H. D. Warren, "Logic Programming and Compiler Writing," in
   Software-Practice and Experience 10(2), 1980.

   Wolfram, D.A., "The Clausal Theory of Types", Cambridge Tracts in
   Theoretical Computer Science {\bf 21}, Cambridge University Press,
   1993.

   Subrata Kumar DAS, "Deductive Databases and Logic Programming",
   Addison-Wesley Publishing Company, July 1992, 448 pages.
   ISBN 0-201-56897-7.

Magazine Articles:

   BYTE Magazine, August 1987. 5 introductory articles on Prolog.

   Uwe Schreiweis: Beredte Logik, Konzepte der 'KI-Sprache" Prolog,
   (Eloquent Logic, Concepts of the AI language Prolog), iX Magazine,
   October 1992, pages 84-90.

   Uwe Schreiweis: Basis der Fuenf, Die Sprache Prolog in der Public
   Domain, (Base of the Five, Prolog in the Public Domain), iX Magazine,
   October 1992, pages 92-94.

   Uwe Schreiweis: Fuenfte Generation, Kommerzielle Prolog-Systeme,
   (Fifth Generation, Commercial Prolog Systems), iX Magazine, October
   1992, pages 96-102.

   Klaus Bothe: Weniger Raum, Speicherplatzbezogener Prolog-Benchmark,
   (Less Space, A Space Oriented Prolog Benchmark), iX Magazine, October
   1992, pages 106-7.

Magazines Related to Prolog:

   Logic Programming Newsletter (4 issues/yr)
   Included with membership in the Association for Logic Programming
   ($20 regular, $10 students). For membership information, write to
   Cheryl Anderson (ALP), DoC-ICSTM, 180 Queens Gate, London SW7 2BZ,
   UK, phone [phone] x5011, fax [phone], or send email
   to [e-mail]. Contributions are welcome and should be sent
   to Andrew Davidson <[e-mail]>.

   AI Communications (4 issues/yr)
   "The European Journal on Artificial Intelligence"  ISSN 0921-7126,
   European Coordinating Committee for Artificial Intelligence.

   AI Expert (issued monthly) ISSN 0888-3785, Miller Freeman Publishers
   See a copy of the magazine for list of BBS's in NA. On CompuServe: GO
   AIEXPERT. Regularly reviews Prolog interpreters and compilers.

   Expert Systems (issued Feb, May, Aug and Nov) ISSN 0266-4720,
   Learned Information (Europe) Ltd. Subscription: GBP 85 or USD 110

   IEEE Expert (issued bimonthly) ISSN 0885-9000, IEEE Computer Society

   The Journal of Logic Programming (issued bimonthly), (North-Holland),
   Elsevier Publishing Company, ISSN 0743-1066

   New Generation Computing, Springer-Verlag. (LOTS of Prolog in it.)

----------------------------------------------------------------
Subject: [1-5]  The Prolog 1000 Database

The Prolog 1000 is a database of real Prolog applications being
assembled in conjunction with the Association for Logic Programming
(ALP) and PVG. The aim is to demonstrate how Prolog is being used in
the real world and it already contains over 500 programs with well
over 2 million lines of code. The database is available for research
use in SGML format from the Imperial College archive
   src.doc.ic.ac.uk:packages/prolog-progs-db/prolog1000.v1.gz
If you have or know about a program that might qualify for inclusion,
send an email message to Al Roth ([e-mail]) for an
electronic entry form which only takes a few minutes to complete. Or
write to Prolog 1000, PO Box 137, Blackpool, Lancashire, FY2 0XY,
U.K., Fax: [phone] Telephone: [phone]. (Floppy disks for
PC or Mac in text form are also welcome, and paper entries may also be
sent). Queries may also be addressed to: Chris Moss
([e-mail]), Leon Sterling ([e-mail]).
----------------------------------------------------------------
Subject: [1-6] X-Windows Interfaces

PI:
   PI is an interface between Prolog applications and the X Window System
   that aims to be independent from the Prolog engine, provided that it
   has a Quintus-style foreign function interface (such as SICStus, YAP).
   It is mostly written in Prolog and is divided in two libraries: (1)
   Edipo, a low-level interface to the Xlib functions, and (2) Ytoolkit,
   a high-level user interface toolkit that allows you to create and
   manage graphical objects, define new classes of objects, and handle
   user interaction. PI is available by anonymous ftp from
   ftp.ncc.up.pt:/pub/prolog/pi_1.2.tar.gz and includes documentation
   and some demos. Also see ytoolkit.tar.Z. PI has been tested in
   Quintus Prolog 3.1.1 and SICStus 2.1 #8. Send questions, comments,
   and bug reports to Ze' Paulo Leal, Universidade de Porto, Portugal,
   <[e-mail]>.

XWIP:
   export.lcs.mit.edu:/contrib/xwip.tar.Z
   ftp.uu.net:X/contrib/xwip.tar.Z

   XWIP is an X Windows interface for PROLOG.

XPCE:

   XPCE is an object-oriented X-window interface toolkit for symbolic
   programming languages (Prolog and Lisp), offering a high level of
   abstraction for communication with X11, Unix processes, Unix
   networking facilities (sockets) and Unix files. XPCE's built-in
   classes (about 150) are mostly written in C.  The XPCE/Prolog
   interface allows the user to create and manipulate instances of these
   classes.  The user can also create new XPCE classes from Prolog.
   XPCE's window related classes provide various styles of menus,
   primitive graphical objects, compound graphical objects and Emacs
   oriented programmable text manipulation windows. The distribution
   contains several demo programs, including a diagram drawing tool
   (PceDraw), an animation demo, an Epoch-like editor, a graphical
   interface to Unix ispell, and an online hyper-text manual for XPCE
   itself.  A demo version of XPCE/SWI-Prolog for Linux may be obtained
   by anonymous ftp from swi.psy.uva.nl:pub/xpce/linux/ [145.18.114.17].
   The non-demo versions (for SWI-Prolog, SICStus Prolog, Lucid Common
   Lisp and LispWorks) require filling out a license and paying a fee
   (see the file pub/xpce/INFO).  To be added to the mailing list
   [e-mail] send mail to [e-mail]. Send
   bugs to [e-mail]. [Mail to xpce-request bounced, 7/8/93.]

----------------------------------------------------------------
Subject: [1-7] Is there a straight-forward way of compiling Prolog to C?

Two methods of compiling Prolog to C have been reported in the
literature:
   -  WAM-based approaches
   -  Continuation-based approaches

The WAM-based approach compiles Prolog programs into a sequence of C
function or macro calls to WAM instructions. A brief description of
this method and some results are given in the paper:

   Michael R. Levy and R. Nigel Horspool, "Translating Prolog to C: a
   WAM-based Approach", in Proceedings of the Second Compulog Network
   Area Meeting on Programming Languages, and the Workshop on Logic
   Languages in Pisa, May 1993. (Available by anonymous ftp from
   csr.uvic.ca:/pub/mlevy/.)

A "quick-and-dirty" method is to implement the WAM functions as described
in Ait-Kaci's tutorial, to label each call with a C case label, and then throw
a giant switch(P) statement around the entire sequence of calls, where P
is the WAM program counter.  On return from any instruction that modifies
P, a "goto Start" must be inserted. (This method was posted by Rob
Scott, <[e-mail]>, based on the JANUS papers by Saraswat.)

This strategy will work, but does not allow you to modularize your
prolog program. Predicates in prolog seem to generate 8 to 15 WAM
instructions per clause, so (assuming very roughly a clause per
line)you might expect your 1,000 line program to expand to a switch
statement containing up to 15,000 lines. Some C compilers can't handle
such a big switch statement.

Levy and Horspool solve this problem by compiling each Prolog
predicate to a seperate C function. A dispatch loop mechanism is used
to call the C functions. C switch statements are used only inside the
functions.  A predicate that calls another predicate sets P to contain
the address of the C function that implements the called predicate,
(and sets another register called W in their scheme) and then returns
to the dispatcher instead of calling the predicate. This bypasses the
C run-time stack.  This lets one exploit WAM optimizations (like LCO)
and yet retain the ability to create many modules. Their system
performs well when compared with byte-code compilers, but translated
code runs slower than code produced by native code compilers.  On the
other hand, it outputs portable ANSI C that can run on any machine
with a C compiler.

Other approaches to translating to C use continuations. The idea here
is to translate every Prolog predicate to a C function that has
an additional argument, namely a continuation function. If the function
fails, it simply returns, but if it succeeds, it executes the continuation.
When the function regains control from the continuation, it can then try
to generate a new solution. Here are two references
that describe systems built using continuations:

   J. L. Weiner and S. Ramakrishnan, "A Piggy-Back Compiler for Prolog",
   in Proceedings of SIGPLAN T88 Conference on Programming Language
   Design and Implementation, Atlanta, Georgia, 1988, pages 288-296.

   J. L. Boyd and G. M. Karam, "Prolog in C", Carleton University,
   Ottawa, 1988.

Oliver Ridoux <[e-mail]> reports that a
continuation-based approach works well when used to compile
LambdaProlog. His scheme translates every predicate into a function
that uses and modifies the success and failure continuations, with
recursion in the predicate becoming iteration in the continuation
passing mechanism. Inside the function one uses whichever intermediate
machine one fancies. Clauses within the function can be either the
branches of a switch statement or simply labelled when using a C
system that can store labels. This approach can still generate
monstrous C programs that blow up the C compiler, but the C programs
aren't as large as those generated by a one module to a function
scheme. Approaches that replace recursion in a predicate with
recursion in a function tend to overload the C stack and lead to
sloppy memory management.  Two technical reports describing Ridoux's
approach are available by anonymous ftp from ftp.irisa.fr in pm/*.ps.Z
and mailv06/*.ps.Z.

Michael Covington <[e-mail]> points out that a very simple
approach is to write a Prolog interpreter in C, then store the Prolog
program in that program's data! This will, of course, execute slowly.
One might imagine all sorts of other schemes. For example, a query
could be treated as a stack of "suspensions" (with the left-most goal
on top).  The top suspension is executed by selecting the appropriate
clause (possibly using indexing), and then, if necessary, pushing new
suspensions on the stack (the body of the clause whose head unified
with the current suspension).

Another question to ask is this: Is there any reason why you should want to
convert Prolog to C at all? George Saab of Quintus Corp. pointed out that,
with Quintus Prolog, you can create a standard .o file from a Prolog file,
which can then be linked with your other .o files to create an executable.
What's more, your Prolog code can be called from C code and vice versa.

On ther hand, the advantage of distributing "Prolog objects" as C rather than
.o files is portability.

M. Gaspari  and G. Attardi describe an approach to translating Prolog to C
based on the provision of a common runtime architecture. This is
described in

   G. Attardi and M. Gaspari, "Multilanguage Interoperability", in
   Proceedings of The 3rd International Symposium, PLILP 91,
   Springer Verlag, LNCS #528, 1991.

[Note: Thanks to Michael Levy, Department of Computer Science,
University of Victoria, <[e-mail]>, for writing this section.]

----------------------------------------------------------------
Subject: [1-8] What is the Basic Andorra Model and AKL?

The Basic Andorra Model is a way to execute definite clause programs
that allows dependent and-parallelism to be exploited transparently.
It also supports nice programming techniques for search programs.  The
idea is to first reduce all goals that match at most one clause.  When
no such goal exists, any goal (e.g., the left-most) may be chosen.
The BAM was proposed by David H. D. Warren, and his group at Bristol
has developed an AND-OR parallel implementation called Andorra-I,
which also supports full Prolog.  See, for example,

   Seif Haridi and Per Brand, "Andorra Prolog, an integration of Prolog
   and committed choice languages", in Proceedings of the FGCS 1988,
   ICOT, Tokyo, 1988.

   Vitor Santos Costa, David H. D. Warren, and Rong Yang, "Two papers on
   the Andorra-I engine and preprocessor", in Proceedings of the 8th
   ICLP. MIT Press, 1991.

   Steve Gregory and Rong Yang, "Parallel Constraint Solving in
   Andorra-I", in Proceedings of FGCS'92. ICOT, Tokyo, 1992.

AKL (Andorra 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 example,

   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 by anonymous ftp from sics.se in
/pub/ccp/papers. An (as yet non-released) prototype implementation of
AKL is available for research purposes (contact [e-mail]).

----------------------------------------------------------------
;;; *EOF*
---------------------------------------------------------------------------




Archive-name: prolog/resource-guide/part2
Last-Modified: Wed Oct  6 00:03:08 1993 by Mark Kantrowitz
Version: 1.12

;;; ****************************************************************
;;; Prolog Resource Guide ******************************************
;;; ****************************************************************
;;; prg_2.faq -- 56588 bytes

This is part two of the Prolog Resource Guide. This part lists
available Prolog implementations, both free and commercial.

Send suggestions and comments to: [e-mail]

Prolog Implementations (Part 2):
  [2-1] Public Domain or Free Prolog Implementations
  [2-2] Commercial Prolog Implementations

Search for [#] to get to topic number # quickly. In newsreaders which
support digests (such as rn), [CTRL]-G will page through the answers.

----------------------------------------------------------------
Subject: [2-1] Public Domain or Free Prolog Implementations

The following list of free Prolog and logic programming
implementations excludes those listed in the comp.lang.lisp FAQ (i.e.,
Prolog interpreters written in Lisp).  Note that commercial prolog
implementations are often more robust and better supported than public
domain and free prolog implementations.

   A.D.A. Public Domain Prolog:
      aisun1.ai.uga.edu:ai.prolog/adapdpro.zip

      A rather slow implementation of Prolog for MS-DOS systems, originally
      a product of Automata Design Associates (now defunct), 1570
      Arran Way, Dresker, PA 19025, 215-335-5400.

   ALF:
      ALF (Algebraic Logic Functional programming language) is a
      language which combines functional and logic programming techniques.
      The foundation of ALF is Horn clause logic with equality which
      consists of predicates and Horn clauses for logic programming, and
      functions and equations for functional programming.  The abstract
      machine is based on the Warren Abstract Machine (WAM) with several
      extensions to implement narrowing and rewriting.    In the current
      implementation programs of this abstract machine are executed by an
      emulator written in C. It is available by anonymous ftp from
      ftp.germany.eu.net (aka simpson.germany.eu.net) in the directory
      /pub/programming/languages/LogicFunctional as the files alf_*.zoo
      (Documentation, C sources for the emulator, the preprocessor and the
      compiler). For further information, contact Rudolf Opalla
      <[e-mail]>.

   Aquarius Prolog:

      Aquarius Prolog is a high-performance, portable Prolog implementation
      developed since 1989 by the Aquarius Project at UC/Berkeley, the Advanced
      Computer Architecture Laboratory (ACAL) at the University of Southern
      California (USC), and at Digital Equipment Corporation's Paris Research
      Laboratory. The developers are Tom Getzinger, Ralph Clarke Haygood, and
      Peter Van Roy. Aquarius Prolog includes:

     - A compiler with global analysis.  The compiler is built around the
       Berkeley Abstract Machine (BAM) execution model for Prolog. BAM
       retains desirable features of the Warren Abstract Machine (WAM),
       but allows for significant further optimizations and is easier to
       map onto actual general-purpose machines.

     - A back-end that maps the BAM onto various actual general-purpose
       machines, including MIPS R3000 (DEC Ultrix and MIPS RISC/os),
       SPARC (SunOS), HP 9000 300/400 with MC68020, MC68030 or MC68040
       processors (HP-UX), and Sun3 (SunOS).

     - A run-time system offering substantially the same built-in
           predicates and memory management as Quintus Prolog, with additions
           such as two kinds of destructive assignment.  Most of the built-in
           predicates are written in Prolog, with little or no performance
           penalty.

      Aquarius Prolog also includes an interpreter and documentation.
      Aquarius Prolog comes in two distributions, Enduser and Full. The
      latter includes full source code and implementation notes.

      Aquarius Prolog may be obtained free of charge from USC, after signing
      and returning a license agreement. To get the license agreement, send a
      message to [e-mail] with
     get aquarius-info license
      in the message body. To get more information about the Full and
      Enduser distributions, send the listserver a message containing
      one or both of the two lines:
          get aquarius-info readme-full
          get aquarius-info readme-enduser
      To subscribe to the aquarius-prolog mailing list, send the listserver a
      message with body:
          subscribe aquarius-prolog <Your real name here>
      To get more information about the abilities of the listserver, send it a
      message with 'help' in the body.

      For further information, write to University of Southern California,
      Advanced Computer Architecture Laboratory (ACAL), Attn: Aquarius Prolog
      Licensing, 3740 S. McClintock, Suite 131, Los Angeles, CA 90089-2561, or
      send email to [e-mail].

   BeBOP:
      The BeBOP language combines sequential and parallel Logic Programming
      (LP), object oriented programming and meta-level programming. The LP
      component offers both don't know non-determinism and stream AND
      parallelism, a combination not possible with concurrent LP languages.
      BeBOP's object oriented features include object IDs, encapsulation,
      message passing, state updating, and object behaviour modification.
      The meta-level capabilities are based on the treatment of Prolog
      theories as first order entities, which enables them to be updated
      easily and lets fragments to be passed between objects in messages.
      BeBOP is implemented by translation down to NU-Prolog, and its
      parallel extension, PNU-Prolog.  The BeBOP system (BeBOP and bp) and
      the PNU-Prolog preprocessor pnp can be obtained by anonymous ftp from
      munnari.oz.au:pub/bebop.tar.Z [128.250.1.21].  The release comes with
      a user manual, several papers (in Postscript format), sample programs,
      and source code.  The BeBOP system requires the NU-Prolog system,
      compiler and interpreter, the pnp preprocessor (which is included as
      part of the BeBOP system release), GCC or a similar compiler, Yacc (or
      Bison) and Lex. For more information, contact Andrew Davison,
      <[e-mail]>, Dept. of Computer Science, University of Melbourne,
      Parkville, Victoria 3052, Australia, call [phone]/9101, or fax
      [phone].

   BinProlog:
      clement.info.umoncton.ca:BinProlog/binpro.1.71.tar.Z [139.103.16.2]
      The file papers.tar.Z contains papers related to the implementation.

      BinProlog replaces the WAM by a more compact continuation passing
      logic engine based on a mapping of full Prolog to binary logic
      programs.  BinProlog is free for research and other non-profit
      purposes. Version 1.71 runs on Sparc, Sun3, NeXT, and 386/486. The
      compiler makes 400 KLIPS on a Sparc 10-20 (101 KLIPS on a NeXT) and
      still uses a very small (38K under Solaris 2.1) emulator, making it
      among the fastest freely available C-emulated Prologs. Comments and
      bug reports should be sent to [e-mail].

   CLP(R):
      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
      [e-mail] or [e-mail]. Current version 1.2.

   Common ESP:

      CESP (Common Extended Self-contained Prolog) is an object-oriented
      system by the AI Language Research Institute, Kamakura, Japan. The
      binary is free for R & D use only -- send 1/4in CMT Sun3 and Sun4
      (Sparc) with Sun OS R4.0.3, R4.1 or R4.1.1. For more information,
      write to AI Language Research Institute Ltd, Yoshitoku Bldg, Shiba
      3-15-14, Minato-Ku, Tokyo 105, Japan, fax [phone], or send
      email to [e-mail] or [e-mail].

   CORAL:
      CORAL is a deductive database/logic programming system developed at
      the University of Wisconsin-Madison. It is a declarative language
      based on Horn-clause rules with extensions like SQL's group-by and
      aggregation operators, and uses a Prolog-like syntax.

      CORAL is available via anonymous ftp from ftp.cs.wisc.edu.  The
      distribution includes source code compatible with AT&T C++ Version 2.0
      or later, executables for Decstations and SUN 4s, the CORAL User
      Manual, and some related papers containing a language overview and
      implementation details.  (A version of the source code compatible with
      GNU g++ will be available shortly.) For more information, contact
      Raghu Ramakrishnan, <[e-mail]>.

   cu-Prolog:
      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). cu-Prolog is available free by anonymous ftp from
      ftp.icot.or.jp. For further information, send email to [e-mail],
      or write to ICOT Free Software Desk, Institute for New Generation
      Computer Technology, 21st Floor, Mita Kokusai Bldg., 4-28, Mita
      1-chome, Minato-ku, Tokyo 108, Japan, fax [phone].

   ECLiPSe:
      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 containing several libraries with
      various types of constraint handling schemes, and an X11-based graphic
      system (KEGI).  The BANG database can store not only relations, but
      also any Prolog structures and programs. ECLiPSe also includes a
      profiler, user-definable syntax, metaterms as first-class citizens,
      coroutining, unlimited precision integer and rational numbers, and a
      library for generalized propagation Propia. ECLiPSe is available for a
      nominal fee of DM 300 (~$200) to all academic and government-sponsored
      organizations. It is distributed in binary form for Sun-3 and Sparc
      machines. Send orders or requests for further information to
      [e-mail] or write to ECRC, Arabellastrasse 17,
      D-81925 Munich 81, Germany. The ECLiPSe documentation (ASCII and dvi)
      and some shareware packages ported to ECliPSe are now available by
      anonymous ftp from ecrc.de:/pub/eclipse. To subscribe to the
      [e-mail] mailing list, send mail to [e-mail].

   eLP:
      eLP (Ergo Lambda Prolog) is an interpreter written by Conal Elliott,
      Frank Pfenning and Dale Miller in Common Lisp and implements the core
      of lambda Prolog (higher-order hereditary Harrop formulas). It is
      embedded in a larger development environment called ESS (the Ergo
      Support System).  eLP implements all core language feature and offers
      a module system, I/O, some facilities for tracing, error handling,
      arithmetic, recursive top-levels, on-line documentation and a number
      of extended examples, including many programs from Amy Felty's and
      John Hannan's thesis.  It should run in Allegro Common Lisp, Lucid
      Common Lisp, Kyoto Common Lisp, CMU Common Lisp and Ibuki Common Lisp.
      The eLP implementation of lambda Prolog is no longer developed or
      maintained, but it is still available via anonymous ftp from
      ftp.cs.cmu.edu:/afs/cs.cmu.edu/project/ergo/export/ess/. The file
      ergolisp.tar.Z contains the Ergo project's extensions to Common Lisp,
      including some facilities for attributes and dealing with abstract
      syntax trees. The file sb.tar.Z contains the Ergo
      Parser/Unparser/Formatter generator and ab.tar.Z contains the Ergo
      Attribute Grammar facility. The file elp.tar.Z contains the Ergo
      implementation of lambda Prolog.  To customize grammars you need the
      sb.tar.Z file.  When you retrieve the system, please print, fill out,
      and send in a copy of the non-restrictive license you will find in the
      file LICENSE. To subscribe to the [e-mail] mailing list, send
      mail to [e-mail]. Bugs should be sent to
      [e-mail].

   ESL Prolog-2 (PD Version):
      ai.uga.edu:ai.prolog/eslpdpro.zip [128.192.12.9]

      A prolog for MS-DOS systems with good performance. It deviates
      slightly from Edinburgh standard (strings "like this" are not lists
      of ASCII codes), but you can add a declaration that makes it fully
      Edinburgh-compatible. (Add the line
       :- state(token_class,_,dec10).
      at the beginning of the program.) It is a more limited version
      of the interpreter from the Commercial Version (see [2-2] below).
      [Please note that ESL Prolog is NOT a UGA product, they just run
      the machine on which a copy is made available. Anyone with
      questions should contact ESL in Oxford, England (see [2-2] below).]

   Goedel:
      GOEDEL is intended to be a declarative successor to Prolog.  The
      main design aim of Goedel is to have functionality and expressiveness
      similar to Prolog, but to have greatly improved declarative semantics
      compared with Prolog.  This improved declarative semantics has
      substantial benefits for program construction, verification,
      debugging, transformation, and so on. Considerable emphasis is placed
      on Goedel's meta-logical facilities, since this is where Prolog is
      most deficient.  In particular, Goedel has declarative replacements
      for Prolog's var, nonvar, assert, and retract.  Goedel is a strongly
      typed language, its type system being based on many-sorted logic with
      parametric polymorphism. The release includes the Goedel system, a
      draft book on the language, a user manual, and 50 example programs.
      Goedel must be compiled in SICStus Prolog; a sparc executable is
      included in the distribution. Goedel is available by anonymous ftp
      from ftp.cs.kuleuven.ac.be:/pub/logic-prgm/goedel [134.58.41.2] and
      ftp.cs.bris.ac.uk:/goedel [137.222.102.102]. For more information,
      write to [e-mail]. Please send an email message to
      this address (with your name, institution and address) to this address
      when you obtain the system. To subscribe to the
      [e-mail] mailing list, send mail to
        [e-mail]
      indicating that you wish to join the Goedel discussion group.

   IC-Prolog II:
      src.doc.ic.ac.uk:/computing/programming/languages/prolog/icprolog/.
      The emulator is available at present only in Sun-4 binary form.
      Source code may be released later in the year when project
      finishes.

      Produced by Imperial College, IC-Prolog II is a multi-threaded
      Prolog system.  It includes a Parlog sub-system, an interface to
      TCP primitives and "mailboxes", a high level communication
      system.  These enable distributed applications (such as
      client/server systems) to be written using logic programming.
      The distribution also includes a simple expert system shell and
      the preprocessor for the Prolog language extension L&O from the
      book "Logic & Objects" by Frank McCabe.  (The sources for the
      L&O extension is also available to LPA MacProlog users in the
      subdirectory 'lo'.)

      See "I.C. Prolog II : a Multi-threaded Prolog System" by Damian
      Chu and Keith Clark and also "IC Prolog II: a Language for
      Implementing Multi-Agent Systems" by Damian Chu.  Postscript
      copies of these two papers may be found in the subdirectory
      'papers'.

      Standalone versions of the Parlog system for Sun-3 and Sun-4
      can also be found in this directory.

      Contact Damian Chu <[e-mail]> for questions about IC
      Prolog II, and contact Zacharias Bobolakis <[e-mail]> for
      information about L&O.

   JB-Prolog:
      JB-Prolog 2.1 is a slim and powerfull prolog for the MacIntosh. Its key
      features are: Arbitrary long integers, fast interpreter only, source
      line debugger, user interface toolkit, persistent objects. It is
      available from the CMU AI repository as
     ftp.cs.cmu.edu:user/ai/lang/prolog/impl/JBprologJBprolog2.1.sit.hqx
      For more information contact Jan Burse, [e-mail],
      XLOG, Postbox 423, 8042 Zuerich, Switzerland.

   Prolog/Mali (Lambda-Prolog):
      Prolog/Mali is a compiler for the higher-order language Lambda-Prolog.
      Lambda-Prolog is an extension of Prolog defined by Miller (Miller,
      D.A., and Nadathur, G., "Higher-order logic programming", 3rd
      International Conference on Logic Programming, pages 448-462, London
      1986). It is an extension of Prolog where terms are simply typed
      lambda terms and clauses are higher order hereditary Harrop formulas.
      The main novelties are universal quantification on goals and
      implication.  Prolog/Mali is a complete system which includes a C
      translator, a linker, libraries, runtime, and documentation, and runs
      on UNIX.  It requires the MALI-V06 abstract memory package.
      Prolog/Mali is available by anonymous ftp from ftp.irisa.fr:pm/.
      Written by Pascal Brisset <[e-mail]> (or <[e-mail]>)
      and Olivier Ridoux ([e-mail]). To be added to the mailing list,
      send mail to [e-mail]. For more information, send
      mail to [e-mail].

   LIFE:
      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 ([e-mail]),
      send mail to [e-mail]. Send bug reports to
      [e-mail].

   Lolli:
      Lolli is an interpreter for logic programming based on linear logic
      principles. Lolli, named for the linear logic implication operator
      "-o" called lollipop, is a full implementation of the language
      described in the paper "Logic Programming in a Fragment of
      Intuitionistic Linear Logic" (Josh Hodas & Dale Miller, to appear in
      Information and Computation), though it differs a bit in syntax, and
      has several built-in extra-logical predicates and operators. To
      retrieve a copy of the Lolli system, ftp (anonymously) to
      ftp.cis.upenn.edu and retrieve the file pub/Lolli/Lolli-07.tar.Z. This
      distribution includes full ML source, along with a Makefile, as well
      as several background papers and a collection of example programs. For
      those who do not have SML-NJ at their site, the authors hope to
      provide pre-built binaries for a variety of architectures. These
      binaries can be found on ftp.cis.upenn.edu in the directory
      pub/Lolli/binaries. At present Sparc and NeXT binaries are available.
      If you compile lolli on a new architecture, please contact Josh Hodas
      at <[e-mail]> so that he can make your binary
      available.

   NCL:
      NCL (Net-Clause Language) is aimed at describing distributed
      computation models using term unification as a basic processing and
      control mechanism. It is embedded in standard Prolog and comprises two
      parts -- net-clauses and data-driven rules, which can communicate each
      to other and to standard Prolog programs.  A net-clause is a special
      domain in the database defining a network of nodes and links. The
      nodes are represented by Prolog compound terms. The variables
      occurring within the nodes are global logical variables, which can be
      shared within the scope of the net-clause thus playing the role of
      network links.  Two control mechanisms are implemented: a spreading
      activation scheme similar to the connectionist spreading activation
      and to the marker passing mechanism in SN (in logic programming it is
      seen as a restricted forward chaining) and a default mechanism based
      on using variables to propagate terms without being bound to them,
      thus implementing the non-monotonicity of default reasoning.  The
      Data-driven Rules implement a full scale forward chaining for Horn
      clauses.  They simulate a data-driven parallel computation, where each
      rule is a process (in contrast to the traditional parallel logic
      programming where each goal is a process). The NCL/Prolog interpreter
      along with a reference manual and a set of examples is available by
      anonymous ftp at ai.uga.edu:ai.misc/ncl.tar.Z. For more information
      contact Zdravko Markov, Institute of Informatics, Bulgarian Academy of
      Sciences Acad.G.Bonchev Street, Block 29A, 1113 Sofia, Bulgaria,
      <[e-mail]>.

   Open Prolog:
      Open Prolog (OP) is a Prolog interpreter for the Apple Macintosh.

      It follows the so-called 'Edinburgh' syntax and supports most standard
      Prolog features, including Definite Clause Grammars.
      Extra predicates can be added via drop-in external predicates, similar to
      Hypercard's XCMDs.

      OP will work in any Macintosh from a Plus upwards, and is now
      32-bit clean.

      OP's home site is grattan.cs.tcd.ie [134.226.32.15] in
       languages/open-prolog
      It is also available from other sites, such as:
      sumex-aim.stanford.edu (info-mac)
         mac.archive.umich.edu [141.211.165.41]
         nexus.yorku.ca:/pub/prolog/  [130.63.9.1]
         aisun1.ai.uga.edu [128.192.12.9]
         /afs/umich.edu/group/itd/archive/mac/development/languages

      For more information, write to Michael Brady, Computer Science
      Department, Trinity College, Dublin 2, IRELAND, send email to
      [e-mail], call [phone], or fax [phone] (5 hours
      ahead of East Coast US time).


   PCN:
      PCN (Program Composition Notation) is not a logic programming
      language, but it has similarities to Strand and other concurrent logic
      programming languages. PCN is a parallel programming system that
      provides a simple language for specifying concurrent algorithms,
      interfaces to Fortran and C, a portable toolkit that allows
      applications to be developed on a workstation or small parallel
      computer and run unchanged on supercomputers, and integrated debugging
      and performance analysis tools. PCN includes a runtime system,
      compiler, linker, a set of standard libraries, virtual topology tools,
      a symbolic debugger (PDB), an execution profiler (Gauge), and a trace
      analysis tool (Upshot). PCN was developed at Argonne National
      Laboratory and the California Institute of Technology.  PCN runs on
      Sun4, NeXT, IBM RS/6000, SGI Iris, Intel iPSC/860, Intel Touchstone
      DELTA, Sequent Symmetry running Dynix (not PTX), and should be easy to
      port to other architectures. PCN is in the public domain and can be
      obtained by anonymous ftp from
     info.mcs.anl.gov:/pub/pcn/pcn_v2.0.tar.Z
      The distribution includes a user's guide containing a tutorial and
      reference material. For further information on PCN, please send email to
      <[e-mail]> or contact Ian Foster <[e-mail]>
      708-252-4619 or Steve Tuecke <[e-mail]> 708-252-8711.


   PD Prolog 19:
      wuarchive.wustl.edu:/mirrors/msdos/prolog/prolog19.arc (IBM PC)
      aisun1.ai.uga.edu (128.192.12.9)

   PDSS KL1:
      PDSS KL1 is an implementation of FGHC, a concurrent logic programming
      language developed at ICOT in Japan. Runs on Suns, HPs, DECs, and the
      Sequent Symmetry. Available free by anonymous ftp from ftp.icot.or.jp.
      A representative paper on the language is Kazunori Ueda and Takashi
      Chikayama, "Design of the Kernel Language for the Parallel Inference
      Machine", The Computer Journal, December, 1990. For more information,
      send email to [e-mail] or write to ICOT Free Software Desk,
      Institute for New Generation Computer Technology, 21st Floor, Mita
      Kokusai Bldg., 4-28, Mita 1-chome, Minato-ku, Tokyo 108, Japan, fax
      [phone].

   Portable Prolog System:
      Portable Prolog System is an interpreter from the University of York.
      Runs on any system having a Pascal compiler. For more information,
      write to University of York, Software Distribution Officer, Department
      of Computer Science, University of York, York, YO1 5DD, UK, call +44
      (904) 59861, or fax [phone].

   ROLOG:
      cs.uiuc.edu:/pub/ROLOG

      Parallel PROLOG compiler with a reduce-OR process model.

   SB-Prolog:
      cs.arizona.edu:/sbprolog
      sbcs.sunysb.edu:/pub/sbprolog

      Stony Brook Prolog runs on Sun4, Pyramid-98x, DEC3100, SGI Iris,
      Amiga, and MS-DOS machines. Contact [e-mail] for more
      information. Two versions are available: version 2.5 is an
      interpreter for Amigas and version 3.1 is an interpreter and compiler
      for Unix and MSDOS/386.

      SB-Hilog runs in SB-Prolog and Quintus Prolog and is available on
     sbcs.sunysb.edu:/pub/hilog/

      src.doc.ic.ac.uk [146.169.3.7] contains SBProlog 3.1 executables for
      MS-DOS/386 in languages/sbprolog, filename sbpmsdos.zip.

      nic.funet.fi contains SBProlog executables for Amiga in
      /pub/amiga/fish/disks100-199/ff140.

      Modular SB-Prolog (= SB-Prolog version 3.1 plus modules) is available
      by anonymous FTP from ftp.dcs.ed.ac.uk (129.215.160.5), as the file
      pub/dts/mod-prolog.tar.Z. Includes interpreter for SPARC. For more
      information, write to Brian Paxton <[e-mail]>.

      [NOTE: SB-Prolog is superseded by XSB (see below) and hence is
       no longer supported by Stony Brook or the University of Arizona.
       The only reason to continue using SB-Prolog is for DOS, since
       XSB does not run under DOS and there are currently no plans to
       port it to DOS.]

   SLG:
      The SLG system is a meta interpreter implementation of the
      well-founded semantics of normal logic programs [Van Gelder, Ross, and
      Schlipf, JACM, Vol. 38, July 1991]. It is developed by Weidong Chen
      and David Scott Warren, and is available free by anonymous ftp from
      Southern Methodist University or SUNY at Stony Brook
     seas.smu.edu:pub
     sbcs.sunysb.edu:pub/XSB/
      as the file slg.tar.gz. The SLG system is written in Prolog and
      allows integration of regular Prolog execution with SLG resolution.
      SLG resolution is a method for goal-oriented query evaluation of
      normal logic programs under the well-founded semantics [Chen & Warren,
      PODS'93]. It handles both positive and negative loops, and terminates
      for all programs with the so-called bounded-term-size property. For
      function-free programs, polynomial data complexity is guaranteed.
      Comments, requests, and bug reports should be sent to Weidong Chen,
      <[e-mail]>, Computer Science and Engineering, Southern
      Methodist University, Dallas, Texas 75275-0122, phone [phone], or
      David Scott Warren, <[e-mail]>, Department of Computer
      Science, SUNY at Stony Brook, Stony Brook, NY 11794-4400, phone
      516-632-8454.

   SWI Prolog:
      swi.psy.uva.nl:pub/SWI-Prolog/pl-1.6.12.tar.Z [192.42.96.1] (Main source)
      [The patch level (last digit) is regularly updated and diffs between
      patch levels are located in the same directory.]
      mpii02999.ag2.mpi-sb.mpg.de:pub/tools/SWI/ [139.19.20.250] (OS/2)

      rs3.hrz.th-darmstadt.de  [130.83.55.75]
      ftp.th-darmstadt.de:pub/programming/languages/prolog [130.83.22.253]

      SWI-Prolog includes a fast compiler, a profiler, C interface, a
      module system, libraries, and dynamic loading.
      Runs on Atari ST, Gould PN, NeXT, HP, IBM Linux, DEC MIPS, IBM
      PS/2 AIX, OS/2, IBM RS/6000, Sun3, Sun4, Sparc, and Vax.
      Written by Jan Wielemaker, SWI, University of Amsterdam,
      Roetersstraat 15, 1018 WB     Amsterdam, The Netherlands,
      <[e-mail]>. Ported to OS/2 by Andreas Toenne,
      <[e-mail]>. The mailing list is [e-mail].
      To be added to the list, send mail to [e-mail].


   Toy Prolog:
      An interpreter written in Pascal. About 3500 lines of source. Free with
      "Prolog for Programmers" by Kluzniak and Szpakowicz (Academic Press
      1985). Toy Prolog has been ported to the Atari ST by Jens
      Kilian <[e-mail]>.

   Tricia:
      Tricia is a free Prolog high-level emulator with interpreter available
      by email from Uppsala University. Runs on Macintosh, Sun3, Sun4, Apollo
      DN-3500/4500/5500 (OS version 10.*) and HP-730's. For more information,
      write to Uppsala University, Tricia project, Computing Science
      Department, Box 520, S-751 20 UPPSALA, Sweden, fax [phone], or
      email to [e-mail] or [e-mail]. It is
      available by anonymous ftp from
     ftp.csd.uu.se:pub/Tricia/
      A copy is also available in the directory
     /afs/umich.edu/group/itd/archive/mac/development/languages
      if your site runs the Andrew File System, or by anonymous ftp from
      mac.archive.umich.edu.

   XSB:
      XSB is a Prolog-based Logic Programming System that extends the
      standard functionality of Prolog with an implementation of OLDT
      (tabling) and HiLog terms. It is a descendent of PSB-Prolog and
      SB-Prolog. OLDT resolution is useful for recursive query computation,
      allowing programs to terminate correctly in many cases where Prolog
      does not. HiLog supports a type of higher-order programming in which
      predicate symbols can be variable or structured.  This allows
      unification to be performed on the predicate symbols themselves in
      addition to the arguments of the predicates. XSB includes an
      optimizing compiler, C interface, a module system, list processing
      libraries, and dynamic loading.  XSB is a descendant of SB-Prolog.
      XSB runs on Sun3, Sun4, 386/486 PCs (Linux and 386 BSD), SGI machines
      (IRIX), HP 300/400 series (HP-UX) and NeXT, and can be compiled using
      either the GNU C compiler or the Sun C compiler. Porting XSB to any
      32-bit machine running Unix should be straightforward.  THIS IS A BETA
      RELEASE. XSB is available by anonymous ftp from
      sbcs.sunysb.edu:pub/XSB/XSB.tar.Z [130.245.1.15]. For further
      information, write to XSB Research Group, Computer Science Department,
      SUNY at Stony Brook, Stony Brook, NY 11794, or send email to
      [e-mail].

----------------------------------------------------------------
Subject: [2-2] Commercial Prolog Implementations

The Prolog Vendors' Group may be contacted by email via the Secretary,
Al Roth, at <[e-mail]>.

Index:

   Atari/Amiga:
    SPIES YAP

   Macintosh:
    AAIS Prolog
    ALS Prolog
    IF/Prolog
    IQSOFT MProlog
    LPA Prolog
    POPLOG
    Prolog III
    Quintus Prolog
    SPIES YAP

   IBM PC:
    ALS Prolog
    Arity Prolog
    CIM-Prolog
    Coder's Prolog
    Cogent Prolog
    Delphia Prolog
    ESL Prolog-2 (Commercial Version)
    IF/Prolog
    IQSOFT MProlog
    LPA Prolog
    OU Prolog
    PDC Prolog
    Prolog III
    Quintec Prolog
    Quintus Prolog

   Unix:
    AIAI Edinburgh Prolog
    ALS Prolog
    BIM Prolog
    CIM-Prolog
    Coder's Prolog
    Delphia Prolog
    EDCAAD C-Prolog
    ESL Prolog-2 (Commercial Version)
    IF/Prolog
    IQSOFT MProlog
    MU-Prolog, NU-Prolog
    POPLOG
    Prolog III
    Quintec Prolog
    Quintus Prolog
    SICStus Prolog
    SNI Prolog
    SPIES YAP

Many of the following vendors offer educational discounts to
universities. Be sure to ask for current pricing information.

Commercial Prolog Implementations:

   AAIS Prolog is an Edinburgh-standard compiler and interpreter that runs on
   the Apple Macintosh and costs $298. Write to Advanced AI Systems,
   Inc., PO Box 39-0360, Mountain View, CA 94039-0360, call 415-948-8658,
   fax [phone], or email [e-mail]. Reviewed in
   AI Expert, Feburary 1991.

   AIAI Edinburgh Prolog is a high level prolog emulator that runs on
   Acorn R140 (RISC iX), DG AViiON (DG/VX 4.1), Vax (Berkeley Unix, VMS),
   Gould Encore (Unix), HP 9000/300 (HP-UX), MIPS RISC (RiscOS), Sequent
   (DYNIX V3), Sun 2,3,4 (SunOS-3,4). For more information, write to
   AIAI, AI Applications Institute, Software Secretary, University of
   Edinburgh, 80 South Bridge, Edinburgh EH1 1HN, UK, call +44 (31) 650
   2734, fax [phone], or send email to [e-mail].

   ALS Prolog runs on 80386 machines, including DOS ($799), Sun 386i, Xenix,
   Apple Macintosh ($499), System V Unix (Microport), Sun3, Sun4, Sparc,
   Aviion, NeXT, VAX and Delta88. It is available from Applied Logic
   Systems, Inc., PO Box 90, University Station, Syracuse, NY 13210-0090,
   phone [phone], fax [phone], or email [e-mail] or
   [e-mail]. Send a message to [e-mail] with subject line "HELP"
   to get a general information file in reply.

   Arity Prolog is an emulator with interpreter and runs on DOS ($650),
   OS/2 ($1k), Windows (extra $350), OS/2 V.2, and Windows-NT. (Note that
   Windows support means that you can write Prolog programs that
   manipulate Windows. The Windows version of Arity Prolog does not
   itself run under MS Windows.) For more information, write to Arity
   Corporation, Damonmill Square, Concord, MA 01742, call 800-722-7489
   (508-371-1243), fax [phone], or send email to
   [e-mail] or Paul G. Weiss <[e-mail]>.

   Prolog by BIM is a prolog compiler that runs on Sun4, Sparcs and
   RS/6000. It includes Carmen, a user-interface generator for XView
   and SunView and interfaces to various databases and windowing
   packages. For more information, contact BIM Systems, Inc., 11111
   Santa Monica Boulevard, Suite 650, Los Angeles, CA 90025, call
   310-445-1500, fax to 310-445-1515, or email to [e-mail].
   Outside North-America write to BIM s.a./n.v., Kwikstraat 4, B-3078
   Everberg, Belgium, call [phone], fax to [phone] or
   email to [e-mail] (Kathleen Pierco). Earlier version reviewed
   in AI Expert, January 1991.

   CIM-Prolog is a high-level emulator with interpreter for Apollo Domain
   and Sun. Also standard Prolog for Apollo Domain, IBM PC/AT, INMOS
   transputer, and Sun. A parallel version is also available.
   For more information, write to Creative Soft GmbH, Turnstrasse 10, D-8510
   Fuerth, Germany, call [phone], or fax [phone].

   Coder's Prolog 2.0 is a Prolog Interpreter from Austin Code Works. Works
   on any system with a C compiler (it is designed for use with C programs).
   For more information, write to Austin Code Works, 11100 Leafwood Lane,
   Austin, TX 78750-3587, call 512-258-0785, fax [phone], or send email
   to [e-mail].

   Cogent Prolog is an Edinburgh-standard compiler and interpreter.
   Compiled and interpreted code may be intermixed in the same program
   (for ease of debugging). The full system includes a debugger, definite
   clause grammar support, full-screen shell, standard listener, support
   for 16-bit and 32-bit protected mode, linker, .exe generator and
   royalty-free distributable runtime ($248). Compiler & interpreter
   without linker and distributable runtime ($149).  Interpreter alone
   ($49).  Also available is an interactive tutorial, the Active Prolog
   Tutor ($75) and full source code for expert system shell prototypes
   for forward/backward chaining, frames, Rete-network and more ($82).
   All are IBM-PC based. For more info or tech support, email
   [e-mail], or contact Amziod, 40 Samuel Prescott Dr., Stow,
   MA 01775. 508-897-7332 (FAX [phone]).

   Delphia Prolog is an Edinburgh-standard compiler and interpreter that
   runs on Sun3, Sun4, Sparc, RS/6000, Apollo, HP9000/300, Unigraph 68xxx,
   386/486 (SCO Unix), DecStation (Ultrix), Sony NEWS (Unix), VAX (VMS,
   Ultrix), uVax (Ultrix), VaxStation (Ultrix). Write to Delphia, 27 Avenue
   de la Republique, 38170 Seyssinet, France, call 33-76-26-68-94 or fax
   33-76-26-52-27. An earlier version was reviewed in AI Expert, January 1991
   and Feburary 1991.

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

   EDCAAD CProlog is a prolog interpreter for Sun (SunOS), VAX (Ultrix,
   VMS), Apollo, and 68000 (Unix). For more information, write to EDCAAD,
   Department of Architecture, Edinburgh University, 20 Chambers St.,
   Edinburgh EH1 1JZ, UK, call [phone], fax [phone],
   or send email to [e-mail].

   ESL Prolog-2 (Commercial Version), is a high-level emulator with
   interpreter and compiler for Sun3, Sun4, HP9000 (Unix), RS/6000
   (Unix), VAX (VMS), IBM PC (MS-DOS, Windows 3.0/3.1), and 386. It is an
   Edinburgh standard prolog with a number of extensions. The windows
   version includes BIPs for programming windows graphics and dialogues.
   For more information, write to Expert Systems Limited (ESL), Attn:
   Nick Henfrey, The Magdalen Centre, Oxford Science Park, Oxford, OX4
   4GA, England, call [phone], fax [phone], or email
   <[e-mail]>.

   HyperProlog. See Delphia Prolog.

   IBM PROLOG for AIX/6000 (PFA) is a high performance implementation of
   the PROLOG language, combined with a powerful programming environment,
   especially designed for the IBM RISC System/6000 under AIX. PFA was
   developed by BIM as an adaptation of ProLog by BIM for the IBM RISC
   System/6000 under AIX. It was selected by IBM Europe as their
   official PROLOG implementation for the RISC System/6000 (Program
   Number 5776-FAH). For more information: In North-America contact BIM
   systems, 11111 Santa Monica Bld, call 310-445-1500, fax to
   [phone]; in Europe contact your local IBM representative.
   Elsewhere contact BIM, Kwikstraat 4, B-3078 Everberg, Belgium, call
   [phone], or fax [phone], or email [e-mail].

   IF/Prolog is a Prolog interpreter and compiler with X-window and
   OSF/Motif development environment, bidirectional C interface, on-line
   hypertext manual, and X-window, OSF/Motif interfaces and various SQl
   interfaces. It runs on Apollo, Aviion 300, Macintosh (A/UX), microVAX
   2000 (Ultrix), Vax (Ultrix, VMS), VaxStation (Ultrix), DEC Alpha
   (OSF/1, VMS), HP9000, Sun3, Sun4, Sparc, UTS, AIX/370, IBM RS/6000,
   Decstation (Ultrix, OSF/1), Sequent S16, Silicon Graphics, Sony News
   (Unix), Motorola, Nixdorf, Interactive Unix, SCO UNIX, DOS-based 386
   PCs, and Windows 3.0/3.1. For more information, write to American
   InterFace Computer, Inc., One Westlake Plaza, 1705 Capital of Texas
   Highway South, Suite 200, Austin, TX 78746, call 512-327-5344, or fax
   512-327-5176, or e-mail [e-mail]. European Customers may write
   to InterFace Computer GmbH, Garmischer Strasse 4, D-8000 Muenchen 2,
   Germany, call [phone], fax [phone], or email
   [e-mail]. Reviewed in AI Expert January 1991.

   ILOG SOLVER (formerly called PECOS) is a C++ library that implements a
   CLP (Constraint Logic Programming) instance known as finite domains.
   This library includes:
     - Prolog control structures:  non determinism, choice points,
       backtracking and cut. Modification of user-defined objects can be
       trailed so that their state is restored when a failure occurs.
     - Finite domain logical variables, and associated constraints.
     - Finite sets logical variables and associated constraints.
     - Interval floating point variables, and associated
       constraints, analoguous to what is found in BNR Prolog.
     - Predefined search and optimisation algorithms.
   However, ILOG SOLVER does not uses unification for passing arguments,
   which enables a smooth integration with C++. For further information,
   contact [e-mail] or [e-mail], write to Bruno Levy,
   Pecos Marketing Manager, ILOG SA, Direction Commerciale, 12 Avenue
   Raspail, 94251 Gentilly Cedex, call (33 1) 47-40-80-00, or
   fax [phone].

   IQSOFT MProlog is a high-level emulator with interpreter for Unix,
   Macintosh and IBM PC. Runs on Vax (Unix 4.2 BSD), 68000-based machines
   (Unix), Tektronix 4404, HP3000, and Siemens 1. For more information,
   write to IQSOFT, SZKI Intelligent Software Ltd., Iskola u. 10.,
   Budapest, H-1011, Hungary, call [phone], fax [phone], or
   send email to [e-mail].

   LPA Prolog is a prolog compiler for IBM PCs (DOS, Windows, 386) and Apple
   Macintosh. LPA Prolog ++ is an object-oriented programming system
   based on Prolog. Write to Logic Programming Associates, Ltd., Studio
   4 Royal Victoria Patriotic Building, Trinity Road, London SW18 3SX,
   England, call [phone], fax [phone], or email
   [e-mail], [e-mail] (Clive Spenser),
   or [e-mail]. In the US call 800-949-7567.
   LPA products are distributed in North America by Quintus under the
   Quintus name.

   Maxon Prolog is available for the Atari ST from the German magazine
   'ST-Computer' for 298 DM. Tel: [phone].

   MU-Prolog, NU-Prolog are prolog interpreters from the University of
   Melbourne. Source licences are available for educational institutions.
   Implemented in C for BSD Unix. Currently running on Sun3, Sun4, Vax,
   Elxsi, Encore, and SGI. For more information, write to University of
   Melbourne, MU-Prolog Distribution, Department of Computer Science,
   Parkville, Victoria 3052, Australia, call [phone], or send email to
   [e-mail] or [e-mail].

   OU Prolog is a prolog interpreter from Open University for IBM PC
   (MS-DOS). Includes video, books. Ask for item PD622 and quote
   reference SA69. For more information, write to Open University,
   Learning Materials Sales Office, PO Box 188, Milton Keynes MK7 6DH, UK.

   PDC Prolog runs on IBM PCs (DOS, OS/2, Windows and SCO Unix). Formerly
   known as Turbo Prolog from Borland. Includes a native code compiler
   but is incompatible with most other prologs. Its variables are
   strongly typed, unlike most other prologs. For more information, write
   Prolog Development Center, 568 14th Street, Atlanta, GA 30318, call
   800-762-2710, (404-873-1366), fax [phone] or email
   [e-mail] (general information), [e-mail] (sales),
   [e-mail] (tech support). A BBS is run at 404-872-5358. European
   customers may write to Prolog Development Center, A/S, Hj Holst Vej
   5A, DK-2605 Broendby, Denmark, call [phone], or fax +45 36 72
   02 69. Reviewed in AI Expert January 1991.

   POPLOG is a high-level prolog emulator with interpreter. The POPLOG
   environment integrates four AI programming languages in one
   environment: Lisp, Prolog, ML and POP11. POPLOG can also load in C and
   Fortran binaries. Runs on VAX (Ultrix, VMS), VAXStation (Ultrix),
   DECStation (Ultrix), Sun 3,4, Sparc, Solbourne, HP Apollo 9000/400,
   Sparc (HP-UX), MIPS (RISCOS), Sequent Symmetry (Dynix), Apple
   Macintosh (AUX), SONY News (News-OS), and Silicon Graphics Iris
   (Irix). The academic version from Sussex University. For more
   information, write to POPLOG, Sussex University, Poplog Manager,
   School of Cognitive Sciences, Falmer, Brighton BN1 9QN, UK, call +44
   273 608367, fax [phone], or send email to [e-mail]
   or [e-mail]. The commercial version is available
   from Integral Solutions Ltd as Integral Poplog and Pop++. For more
   information, write to Integral Solutions Ltd, Unit 3, 23 Campbell
   Court, Bramley, Basingstoke Hampshire RG26 5EG, UK, call [phone]
   28, fax [phone], or send email to [e-mail] or
   [e-mail]. The North American retailer is Computable
   Functions Inc. For more informatin, write to Computable Functions Inc.,
   35 S. Orchard Drive, Amherst, MA 01002, call 413-545-3140, or fax
   413-545-3140. Contact Robin Popplestone, [e-mail], for info
   on a new book on Pop-11.

   Prolog III integrates constraint programming with Prolog. It runs on
   Apple Macintosh, IBM PC (386, MS-DOS), Next, Sun3, Sun4, Sparc, HP9000,
   Apollo, RS/6000, Bull DPX, Masscomp (Unix), Vax (Ultrix, VMS),
   DecStation and MicroVAX. For more information, write to PrologIA,
   Parc Technologique de Luminy, Case 919, 13288 Marseilles cedex 09, France,
   call 33-91-26-86-36, fax [phone], or send email to
   [e-mail] or [e-mail]. The US point of contact
   for Prolog III by PrologIA is BIM Systems, Inc.

   Prolog-86 is available from Solution Systems Inc. For more
   information, write to Solution Systems Inc., 335-D Washington Street,
   Norwell, MA 02061, call 617-337-6963, or fax [phone].

   PTC is a portable Prolog compiler based around an optimized Prolog to
   ANSI C compiler.  It runs on Sun, SGI, IBM (Unix), and HP.  PTC
   includes an integrated compiler/interpreter, project-file-based
   compilation, a Motif user interface, editor, debugger, online help,
   and support for C modules. It costs $1,495 for the development
   environment and $795 for each additional runtime library.  For more
   information, write to Paralogic Inc., 115 Research Drive, Bethlehem,
   PA 18015, call 215-861-6960, fax [phone] or email
   [e-mail].

   Quintec Prolog is a high-level emulator with interpreter for IBM PC
   (MS-DOS), Vax, VAXstation (Ultrix, VMS), Decstation (Ultrix), and
   Sparc (SunOS4.0). For more information, write to Quintec Prolog,
   Quintec Systems Ltd., Midland House, West Way, Botley, Oxford OS2 0PL,
   UK, call [phone], or fax [phone].

   Quintus Prolog is a low level emulator that runs on Unix (Sparc, sun2,
   sun3, sun4, 386i, VAX (Ultrix, VMS), uVAX (Ultrix), HP9000, Apollo,
   DecStation, IBM RT, Sequent S/27, S/81, IBM PS/2 (AIX), Intel 80386
   (Unix V.3), Intergraph, Solbourne, RS/6000, and MIPS), IBM PC (DOS,
   Windows), and Macintosh. Includes a cross-referencing facility. For
   more information, contact Quintus Corporation, 2100 Geng Road, Palo
   Alto, CA 94303, call 1-800-542-1283 (415-813-3800), fax [phone],
   or email [e-mail] (sales), [e-mail] (tech support).
   To be added to the users group mailing list, send mail to
   [e-mail]. Version 3.0 reviewed in AI Expert
   January 1991 and February 1991 and IEEE Expert April 1991. LPA
   products are distributed in North America by Quintus under the Quintus name.

   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 [phone], fax [phone], or send
   email to [e-mail]. Bug reports and tech support questions
   should be sent to [e-mail]. To subscribe to the users group
   and implementors mailing list, send email to [e-mail].

   SNI Prolog Version 3 is an implementation of the Prolog language that
   is compatible with the ISO Standard draft. It is available from
   Siemens Nixdorf for Unix workstations for about DM 11100 in Germany.
   SNI Prolog runs on the SGI, SNI and Sun platforms, and ports to other
   systems, including MS-DOS, are in progress. Includes coroutines,
   finite domains, numerical and boolean constraints, garbage collection,
   incremental compilation, dynamic linking, hypertext style on-line
   help, a window environment with an integrated editor, interfaces to
   INFORMIX, Motif/XWindows and C. The constraint programming features of
   SNI Prolog provide support for solving problems from operations
   research such as dynamic resource allocation and flexible scheduling
   with numerical constraints or the verification of complex systems with
   Boolean constraints. For more information, write to Siemens Nixdorf
   Informationssysteme AG, Otto-Hahn-Ring 6, D-8000 Munich 83, Germany,
   Attn: Hans-Juergen Stenger, Systems Planning, call [phone],
   fax [phone], or send email to [e-mail].

   SPIES YAP is a high-level emulator with interpreter for Sun3, Sun4,
   VAXstation, SGI, HP9000, Apple Macintosh and Amiga (Atari ST). For
   more information, write to SPIES, Sociedade Portuguesa de, Importacao
   e Exportacao de Software, Lda Av da Republica, 46 - 2, 1000 Lisboa,
   Portugal, call [phone], or fax [phone].

   Turbo Prolog. See PDC Prolog.

Parallel Prologs:

   Densitron CS Prolog is a parallel prolog compiler and interpreter for
   IBM PCs (MS-DOS or OS/2), T414/T800 transputer (mono or multi), 386
   (Unix V), uVAX (VMS), or VAX(VMS). Also standard Prolog for MS-DOS,
   UNIX and VAX. For more information, write to Densitron, Unit 4,
   Aiport Trading Estate, Biggin Hill, Kent, TN16 3BW, UK, call +44 959
   76331, or fax [phone].

   Paralogic is a parallel implementation of the Clocksin and Mellish
   Prolog. It runs on DOS-based PCs or Apple Macintoshes with the INMOS
   Transputers. For more information, write to Paralogic Inc., 115
   Research Drive, Bethlehem, PA 18015, call 215-861-6960, fax
   215-861-8247 or email [e-mail]. It is also
   distributed by Computer Systems Architects, 905 N. University Avenue,
   Provo, UT 84604-3422, 800-753-4272 (801-374-2300), or fax [phone]
   as n-parallel Prolog.

   PARLOG is a parallel emulator from Imperial College for the Sequent
   Balance, Sequent Symmetry, Encore Multimax, Alliant FX (Unix), Sun
   (Unix, 1 processor). For more information, write to Imperial College,
   Department of Computing, Parlog Distribution Secretary, 180 Queen's
   Gate, London SW7 2BZ, UK, call [phone] x7537, fax [phone]
   8024, or send email to [e-mail]. The single processor
   versions of PARLOG for the Sun-3 and Sun-4 are now available free of
   charge.  Please refer to the entry regarding IC-Prolog II in this
   Resource Guide. Parallel Logic Programming produces PC-PARLOG and
   MacPARLOG for the IBM PC and Macintosh computers.  For more
   information contact Parallel Logic Programming Ltd., PO Box 49,
   Twickenham, Middlesex TW2 5PH, UK or call [phone].

   Strand-88 is a parallel emulator for Sun3, Sun4, Sparc BBN Butterfly,
   GPT2000, Cogent Multimax, Intel iPSC/2, iPSC/860, MIPS RiscStation,
   Sequent Symmetry Balance (Unix System V or Mach, Helios) and
   communication component from CSTools, Express in some cases. Also
   Transputer systems PC hosted systems from Paracom, Telmat and others,
   Unix hosted systems from Meiko, Paracom, Telmat and others, Apple
   Macintosh, Atari ATW, and NeXT. Price dependent on configuration and
   scale of target machine. For more information, write to Strand
   Software Technologies Ltd., Ver House, London Rd, Markyate, Herts AL3
   8JP, UK, call [phone], fax [phone], or send email to
   [e-mail].

   SICS Aurora and Echo. See SICStus Prolog above.

Object Oriented Systems:

   LAP is an object-oriented system by Elsa. For more information, write
   to Elsa Software, La Grange Dame Rose, 6 ave du Marechal Juin, 92366
   Meudon-La-Foret Cedex, France, call [phone], fax +33 (1)
   46 30 55 26, or send email to elsa![e-mail].

   SPIRAL is an object oriented system by CRIL for Sun3 and Sun4 under
   Unix. For more information, write to CRIL, Conception et Realisation,
   Industriel de Logiciel, 146 bd de Valmy 92707, Colombes Cedex, France,
   call [phone], or fax [phone].

Constraint Systems:

   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
   [e-mail].

   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. [This phone number was recently disconnected -- 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
   604-688-8479.

----------------------------------------------------------------

;;; *EOF*
---------------------------------------------------------------------------