Path: senator-bedfellow.mit.edu!bloom-beacon.mit.edu!news2.wam.umd.edu!cadig2.usna.navy.mil!crab.cs.usna.edu!not-for-mail
From: crabbe@usna.edu (Ric Crabbe and Amit Dubey)
Newsgroups: comp.ai,news.answers,comp.answers
Subject: Artificial Intelligence FAQ:6/6 AI Software [Monthly posting]
Followup-To: comp.ai
Date: Sat, 2 Aug 2003 04:12:10 +0000 (UTC)
Organization: United States Naval Academy
Lines: 1777
Approved: news-answers-request@MIT.EDU
Expires: 3 AUG 2003 21:54:49 GMT
Message-ID: <bgfdmq$k8f$1@crab.cs.usna.edu>
Reply-To: crabbe@usna.edu, adubey@coli.uni-sb.de
NNTP-Posting-Host: crab.cs.usna.edu
X-Trace: news.usna.navy.mil 1059797491 20131 131.122.89.100 (2 Aug 2003 04:11:31 GMT)
X-Complaints-To: news@usna.navy.mil
NNTP-Posting-Date: 2 Aug 2003 04:11:31 GMT
Summary: FTP Resources for AI
Xref: senator-bedfellow.mit.edu comp.ai:68345 news.answers:255307 comp.answers:54388

Archive-name: ai-faq/general/part6
Posting-Frequency: monthly
Version: 2.1
Maintainer: Ric Crabbe <crabbe@usna.edu> and Amit Dubey <adubey@coli.uni-sb.de>
URL: http://www.faqs.org/faqs/ai-faq/general/part6/preamble.html
Size: 82158 bytes, 1700 lines

;;; ****************************************************************
;;; Answers to Questions about Artificial Intelligence *************
;;; ****************************************************************
;;; Written by Amit Dubey, Ric Crabbe, and Mark Kantrowitz
;;; ai_6.faq 

If you think of questions that are appropriate for this FAQ, or would
like to improve an answer, please send email to the maintainers.

Part 6 (AI Open-Source and Other Software by Sub-field)
  [6-1] Languages
  [6-2] General AI Software
  [6-3] Well-known Classics

  the rest of the sections are an alphabetical listing by topic:

  [6-4] Agent Modelling, Artificial Life
  [6-5] Blackboard Architectures, Case Based Reasoning, Chatbots,
  Chess,  Constraint Programming
  [6-6] Data Mining, Defeasible Reasoning, Expert Systems
  [6-7] Frame Systems, Fuzzy Logic, Games, General, Genetic Algorithms, ICOT
  [6-8] Knowledge Representation, Machine Learning, Medical
  [6-9] Natural Language Processing
  [6-9a] Speech
  [6-10] Neural Networks
  [6-11] Organizations, Pedegogy, Probability, Planning, Qualitative Reasoning
  [6-12] Robotics
  [6-13] Temporal Reasoning, Theorem Proving, Truth Maintenance
  [6-14] Search, Simulated Annealing

  the following are commercial AI software.

  [6-15] Constraint Satisfaction

Search for [#] to get to question number # quickly.

--------------------------------------------------------------------
Subject: [6-1] Languages

   Its assumed that you can find your way to common languages like
   LISP, C++ or Prolog by doing a web search; what are listed here are
   some other languages that AI researchers may find
   interesting. [Because I had trouble finding a good prolog recently,
   I've added some prolog listings here.]

   XSB Prolog:

   XSB is a Logic Programming and Deductive Database system for Unix
   and Windows. It is being developed at The Computer Science
   Department, Stony Brook University, in collaboration with
   Katholieke Universiteit Leuven, Universidade Nova de Lisboa, and
   Uppsala Universitet.  http://xsb.sourceforge.net/

   Amzi! Prolog + Logic Server:

   "Embed Prolog rule-based components in C/C++, Java, Delphi, Visual
   Basic, Web Servers and more. Develop Unicode and/or ASCII
   logic-bases using the Windows interactive development environment
   (IDE). Integrate them with ODBC databases. Deploy them with the
   Logic Server Libraries. Extend Amzi! Prolog with your own
   functions/libraries. For Windows, Linux, Solaris, HP/UX. Available
   on any other platform with a custom port (see below). Royalty-free
   runtime"  http://www.amzi.com/products/prolog_products.htm
   Free Academic, Personal & Evaluation License.

   Mozart:

   Mozart is an advanced development platform for intelligent,
   distributed applications.  The system is the result of a decade of
   research in programming language design and implementation,
   constraint-based inferencing, distributed computing, and
   human-computer interfaces.
   

   JEOPS - The Java Embedded Object Production System:

   It's a project intended to give Java the power of production
   systems. JEOPS adds forward chaining, first-order production rules
   to Java through a set of classes designed to provide this language
   with some kind of declarative programming. With that, the
   development of intelligent applications, such as software agents or
   expert systems is facilitated.
   http://www.di.ufpe.br/~csff/jeops/

   KIEV:

   Kiev is a backwards-compatible extension of Java that includes support
   for (amount other things) lambda-calculus closures (ie functional
   programming) and Prolog-like logic programming.  Please see
   http://www.forestro.com/kiev/index.html

   LAMBDA-CALCULUS-BASED LANGUAGES:

   LISP's theoretical origins lie in Church's lambda calculus.  A number of
   new languages that fix some shortcomings of LISP's implementation of the
   lambda calculus are Scheme (simpler and fully tail recursive), ML
   (support for types using the typed lambda calculus;
   cm.bell-labs.com/cm/cs/what/smlnj/sml97.html) and Hashell (like ML but
   it implements lazy evaluation properly; www.haskell.org).

   POPLOG:
   
   POPLOG is a multi-language software development environment
   providing incremental compilers for a number of interactive
   programming languages, notably: Pop-11, Prolog, and Common Lisp.  
   http://www.cs.bham.ac.uk/research/poplog/poplog.info.html

   CLIPS:

   CLIPS is a productive development and delivery expert system tool
   which provides a complete environment for the construction of rule
   and/or object based expert systems. CLIPS is used throughout the
   public and private community including: all NASA sites and branches
   of the military, numerous federal bureaus, government contractors,
   universities, and many companies.  The CLIPS home page is:
   http://www.ghgcorp.com/clips/CLIPS.html 

   SCREAMER:

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

   In several ways Screamer is more efficient than other implementations
   of backtracking languages.  First, Screamer code is transformed into
   Common Lisp which can be compiled by the underlying Common Lisp
   system.  Many competing implementations of nondeterministic Lisp are
   interpreters and thus are far less efficient than Screamer.  Second,
   the backtracking primitives require fairly low overhead in Screamer.
   Finally, this overhead to support backtracking is only paid for those
   portions of the program which use the backtracking primitives.
   Deterministic portions of user programs pass through the Screamer to
   Common Lisp transformation unchanged.  Since in practise, only small
   portions of typical programs utilize the backtracking primitives,
   Screamer can produce more efficient code than compilers for languages
   in which backtracking is more pervasive.

   Screamer is fairly portable across most Common Lisp implementations.
   It currently runs under Genera 8.1.1 and 8.3 on both Symbolics 36xx
   and Ivory machines, under Lucid 4.0.2 and 4.1 on Sun SPARC machines,
   under MCL 2.0 and 2.0p2 on Apple Macintosh machines, and under Poplog
   Common Lisp on Sun SPARC machines.  It should run under any
   implementation of Common Lisp which is compliant with CLtL2 and with
   minor revision could be made to run under implementations compliant
   with CLtL1 or dpANS.

   Screamer is available by anonymous FTP from 

      ftp.cis.upenn.edu:/pub/screamer.tar.Z

   Contact Jeffrey Mark Siskind <Qobi@research.nj.nec.com> or David McAllester
   <dmac@research.att.com> for more information.

   The Screamer Tool Repository, a collection of user-contributed
   Screamer code, is available by anonymous ftp from

      ftp.cis.upenn.edu:/pub/screamer-tools/

   or by WWW from

      http://www.cis.upenn.edu/~screamer-tools/home.html

   Please direct all inquires about the repository to
   screamer-repository@cis.upenn.edu. 

--------------------------------------------------------------------
Subject: [6-2] General AI Software

   "AGLETS"

   IBM has created a software package for creating internet agents using
   Java applets.  It's an interesting concept, and worth a look.  See
   http://www.trl.ibm.co.jp/aglets/


--------------------------------------------------------------------
Subject: [6-3] Well-known Classics

   For a large collection of Eliza programs, see

      ftp.cs.cmu.edu:/user/ai/areas/classics/

   The software from Peter Norvig's book "Paradigms of AI Programming" is
   available by anonymous ftp from unix.sri.com:/pub/norvig/ and on disk in
   Macintosh or DOS format from the publisher, Morgan Kaufmann. The
   software includes Common Lisp implementations of: Eliza and pattern
   matchers, Emycin, Othello, Parsers, Scheme interpreters and compilers,
   Unification and a prolog interpreter and compiler, Waltz
   line-labelling, implementation of GPS, macsyma, and random number
   generators.  For more information, write to Morgan Kaufmann, Dept. P1,
   2929 Campus Drive, Suite 260, San Mateo CA 94403, call 800-745-7323,
   or fax 415-578-0672. (Mac ISBN 1-55860-227-5; DOS 3.5" ISBN
   1-55860-228-3; or DOS 5.25" ISBN 1-55860-229-1).

   The doctor.el is an implementation of Eliza for GNU-Emacs
   emacs-lisp. Invoke it with "Meta-X doctor".

   The original Parry (in MLISP for a PDP-10) is available in
   labrea.stanford.edu:/pub/parry.tar.Z.

   RACTER is *not* public domain.  It costs $50 for MS-DOS and Macintosh
   versions, the Inrac compiler is $200 (MS-DOS only), and the Inrac
   manual alone is $25. Racter is available from John Owens, INRAC
   Corp./Nickers International Ltd., 12 Schubert Street, Staten Island,
   NY 10305, Tel: 718-448-6283, or Fax: 718-448-6298.  Racter was
   published in 1984, and written in compiled BASIC. To read some of
   RACTER's work, see "The Policeman's Beard is Half Constructed",
   Computer Prose and Poetry by Racter, Warner Books, 1984.  ISBN
   0-446-38051-2 (paperback). Written by William Chamberlain and Thomas
   Etter. Some discussion of RACTER appears in A.K. Dewdney's book, "The
   Armchair Universe". The Macintosh version runs only on SEs and Pluses
   (it comes on a single-sided 400k copy-protected disk, with an old
   version of the system). Racter is also sold by the following
   mail-order software retailer: Mindware, 1803 Mission Street, Suite
   414, Santa Cruz, CA 95060-5292, phone 800-447-0477 (408-427-9455),
   fax 408-429-5302.  Mindware sells a variety of similar programs for
   MS-DOS and Windows, including Joseph Weintraub's PC Therapist.

   You can nab a copy of Terry Winograd's seminal SHRDLU from
   ftp://ftp.cc.utexas.edu/pub/AI_ATTIC/Programs/Classic/Shrdlu


--------------------------------------------------------------------
Subject: [6-4] Agent Modelling - Artificial Life

In addition to programs available free by anonymous ftp, we've
included some programs which are available by contacting the authors,
and some programs which charge a nominal fee.

Agent Modelling:

   ANIMALS is a simulation system written by Toby Tyrrell,
   <toby@castle.ed.ac.uk>, for his PhD thesis.  The thesis examines the
   problem of action selection when dealing with realistic, animal-like
   situations: how to choose, at each moment in time, the most
   appropriate out of a repertoire of possible actions.  It includes a
   description is given of a simulated environment which is an extensive
   and detailed simulation of the problem of action selection for
   animals.  This simulated environment is used to investigate the
   adequacy of several theories of action selection (from both ethology
   and artificial intelligence) such as the drive model, Lorenz's
   psycho-hydraulic model and Maes' spreading activation network, and
   outlines deficiencies in each mechanism. Finally, it proposes a new
   approach to action selection is developed which determines the most
   appropriate action in a principled way, and which does not suffer from
   the inherent shortcomings found in other methods. The thesis includes
   a review and bibliography of existing work on action selection. The
   thesis is available by anonymous ftp from 

      ftp.ed.ac.uk:/pub/lrtt/ [129.215.146.5]

   as the files as.1.ps.Z, as.2.ps.Z, ..., and as.7.ps.Z.
   The simulation software is also available from the same site, as the
   file se.tar.Z. The simulation software was written in Suntools rather
   than Xtools.  It can be run only from SunView or OpenWindows.  The
   action selection problem modelled by the simulated environment
   comprises 15 different `sub-problems' (getting food, reproducing, not
   getting lost, being vigilant for predators, etc), many internal and
   external stimuli, and 35 different low-level actions to select
   between.

   ***ViewGen SCHEDULED TO BE DELETED FROM THE FAQ***

   ViewGen (Viewpoint Generator) is a Prolog program that implements a
   "Belief Ascription Algorithm" as described in Ballim and Wilks (see the
   bibliography section on User Modelling).  This can be seen as a form of
   agent modelling tool, which allows for the generation of arbitrarily deep
   nested belief spaces based on the system's own beliefs, and on beliefs 
   that are typically held by groups of agents.  ViewGen is available by
   anonymous ftp from 

      crl.nmsu.edu:/pub/non-lexical/ViewFinder [128.123.1.18] (user anonymous)
      ftp.ims.uni-stuttgart.de:/pub/ballim    [141.58.127.8] (user ftp)

   as the file ViewGen.tar.Z. The theory of belief ascription upon which
   it is based is described in detail in Ballim and Wilks, and a general
   framework for attributing and maintaining nested propositional
   attitudes is described in Afzal Ballim's dissertation which is
   archived with the Viewgen program (in the files 

      ViewFinder-{A4/A5/US}.tar.Z, 

   the variable part indicating the format of the PostScript file).
   The inheritance reasoner is in the file vf-hetis.tar.Z.
   Implemented in Sicstus prolog, and hence easily convertible to
   any Edinburgh-style prolog. Contact Afzal Ballim <afzal@divsun.unige.ch>
   for more information. 

   http://www.cl.cam.ac.uk/users/rwab1/agents.html
   Ralph.Becket@cl.cam.ac.uk

   http://www.cs.bham.ac.uk/~amw/agents/index.html
   [Interface Agents]
   Andy Wood <amw@cs.bham.ac.uk>
   
   http://www.cs.umbc.edu/agents/
   [Tim Finin's Software Agents Page]

Artificial Life:

   http://alife.santafe.edu/
   One of the major institutions do Artificial Life research, The
   Santa Fe Institute's web page has lots  of information.

   Swarm is a software package for multi-agent simulation of complex
   systems, originally developed at the Santa Fe Institute. Swarm is
   intended to be a useful tool for researchers in a variety of
   disciplines. The basic architecture of Swarm is the simulation of
   collections of concurrently interacting agents: with this
   architecture, we can implement a large variety of agent based models.
   See: http://www.swarm.org/

   Tierra is an artificial life system for studying the evolution of
   digital organisms. Tierra consists of a virtual computer and its
   operating system, whose architecture has been designed in such a way
   that the executable machine codes are evolvable.  This means that the
   machine code can be mutated (by flipping bits at random) or recombined
   (by swapping segments of code between algorithms), and the resulting
   code remains functional enough of the time for natural (or presumably
   artificial) selection to be able to improve the code over time.
   Tierra runs on Unix, Win32, the Amiga and MS-DOS. Tierra's homepage is at:

	  http://www.isd.atr.co.jp/~ray/tierra/

   The software can be downloaded from

      alife.santafe.edu:/pub/SOFTWARE/Tierra [192.12.12.130]

   To be added to the tierra-announce mailing list, send an email to
   Tom Ray (the author of Tierra as well as the list administrator) at
   ray@santafe.edu.  Send bug reports or questions about the code or
   installation to tierra-bug@life.slhs.udel.edu.

   For those without access to anonymous ftp, the Tierra software may be
   obtained on disk for $50 ($20 for upgrades) from Virtual Life c/o Tom Ray,
   ATR HIP Labs, 2-2 Hikaridai Seika-cho Soraku-gun Kyoto 619-02 Japan.  The
   software ships on PC formatted disks, but contains the source for all
   versions.

------------------------------------------------------------------
Subject: [6-5] Blackboard Architectures - Constraint Programming

Blackboard Architectures:

   ***GBB SCHEDULED TO BE DELETED FROM THE FAQ***
   GBB (PD Version) -- ftp.cs.umass.edu:/gbb/

Case-based Reasoning:

   ***CL-Protos SCHEDULED TO BE DELETED FROM THE FAQ***
   CL-Protos   -- ftp.cs.utexas.edu:/pub/porter/
		  (Get the README file for more information)
                  Contact: Bruce W. Porter <porter@cs.utexas.edu>
                           Ray Bareiss <bareiss@ils.nwu.edu>
                           Erik Eilerts <eilerts@cs.utexas.edu>
                           Dan Dvorak 

   ***MICRO-xxx SCHEDULED TO BE DELETED FROM THE FAQ***
   MICRO-xxx  -- ftp.cs.umd.edu:/pub/schank/icbr/
                 Contact: waander@cs.umd.edu
                 The directory /pub/schank/icbr/ contains the complete
                 code for "Inside Case-Based Reasoning" by
                 Riesbeck and Schank, 1989. This includes code
                 for an instructional version of CHEF by Kristian Hammond.

Chatbots:
   
    AI:
    There is a much maligned chatbot at the Warner Brothers page on
    the AI movie.
    http://aimovie.warnerbros.com

    Alice: 
    A.L.I.C.E. (Artificial Linguistic Internet Computer Entity) is an
    award-winning open source natural language artificial intelligence
    chat robot. The software used to create A.L.I.C.E. is available as
    free open source Alicebot and AIML software.  Winner of the 2000
    Loebner Prize.  See:
    http://www.alicebot.org

    Mind:
    Free public-domain source code of a learning chat-bot based on
    "Chomskyan linguistics and the neural feature extraction of Hubel
    and Wiesel."  The bot starts out knowing little, and tries to learn
    to chat with the user.  Theory, documentation and source code are
    available from:
        http://sourceforge.net/projects/mind/
    and the JavaScript Mind runs immediately when one clicks on
        http://mind.sourceforge.net
    while using the Microsoft Internet Explorer browser.

    Hippie:
    A C-based version of Alice:
    http://hippie.alicebot.com/

Chess:

   ***SAN Kit SCHEDULED TO BE DELETED FROM THE FAQ***

   The SAN Kit chess programming C source toolkit provides common routines
   for move notation I/O, move generation, move execution, etc. Only search
   routines and an evaluation function need be added to obtain a working
   chess program. It runs on Apple Macintosh (Think C 5.0),
   Commodore Amiga (SAS C), MS-DOS, and Unix. It is available by
   anonymous ftp from

      raven.alaska.edu:/pub/coherent/sources32/ [137.229.10.39] in the
      chess.lm.com:/pub/chess/Unix/

   as the compressed tar file SAN.tar.Z or SAN.tar.gz.
   Contact Steven J. Edwards <sje@world.std.com> for more information.
  
Constraint Programming and Non-determinism:

   Dragonbreath http://www.ai-center.com/projects/dragonbreath/ is an
   optimization engine based on constraint programming and local
   search.  The engine is built to solve search problems, i.e.,
   problems for which you don't really know how to construct a
   solution but can describe what potential parts a solution can
   consist of and which restrictions must be satisfied by the parts /
   the parts' constellation.  Parts can be variables as well as
   structural components. In addition, you can specify a preference
   between different solutions, i.e., solve optimization problems.

   JACK is a new library providing constraint programming and search for Java. 
   JACK consists of three components: 
   - JCHR: Java Constraint Handling Rules 
       A high-level language to write constraint solvers 
   - JASE: Java Abstract Search Engine
       A generic search engine for JCHR to solve constraint problems 
   - VisualCHR:
       An interactive tool to visualize JCHR computations
   JACK and its documentation are available for browser use and for download at:
     http://www.pms.informatik.uni-muenchen.de/software/jack/


---------------------------------------------
Subject: [6-6] Data Mining - Expert Systems

Data Mining and Knowledge Discovery in Databases:

   ***Explora SCHEDULED TO BE DELETED FROM THE FAQ***
   Explora is a data mining package written in Lisp for the Macintosh. It
   includes a natural language hypertext-type interface for presentation
   of dicoveries. It is available at:
      http://orgwis.gmd.de:80/explora/
   
   Data Mine
   http://www.cs.bham.ac.uk/~anp/TheDataMine.html
   [Bibliographies, On-line papers, Software, and Other Resources]
   Andy Pryke <anp@cs.bham.ac.uk>

Defeasible Reasoning:

   An implementation of J. Paris and A. Vencovska's model of belief is
   available by anonymous ftp from

      ftp.cs.cmu.edu:/user/ai/areas/reasonng/defeasbl/belief/

   Paris and Vencovska's paper (Artificial Intelligence, 64(2), December
   1993) provides a mathematical model of an agent's belief in an event
   by identifying it with his ability to imagine the event within the
   context of his previous experience.  This approach leads to beliefs
   having properties different from those normally ascribed to it. The
   implementation was written by Ian Pratt <ipratt@cs.man.ac.uk> and Jens
   Doerpmund <dorpmunj@cs.man.ac.uk> and runs in Common Lisp.


Expert Systems:

   Free ftpable expert system shells are listed in the Expert Systems
   Shells FAQ, which is available by anonymous ftp from

      ftp.cs.cmu.edu:/user/ai/pubs/faqs/ai/expert_1.faq

   http://www-ksl.stanford.edu/knowledge-sharing/agents.html
   [Interactive expert systems and "agents". Includes nice model of
   space shuttle engines.]

------------------------------------
Subject: [6-7] Frame Systems - ICOT

Frame Systems:

     FrameWork   -- ftp.cs.cmu.edu:/user/ai/areas/kr/frames/framework/

     Theo        -- Contact: Tom.Mitchell@cs.cmu.edu

     FrameKit    -- Contact: Eric.Nyberg@cs.cmu.edu

     KR          -- Contact: Brad.Myers@cs.cmu.edu

     PARKA       -- Contact: spector@cs.umd.edu
                    Frames for the CM

     PARMENIDES (Frulekit) -- Contact: Peter.Shell@cs.cmu.edu 

     FROBS       -- cs.utah.edu:/pub/frobs.tar.Z
                    Contact: Robert Kessler <kessler@cs.utah.edu>

     PFC         -- linc.cis.upenn.edu: ??

     YAK         -- Contact: Enrico Franconi <franconi@irst.it>

Fuzzy Logic:

   FLIE    -- ural.ethz.ch:/robo/flie/   [129.132.104.194]
              Contact: vestli@ifr.ethz.ch
              Fuzzy Logic Inference Engine, Institute of Robotics, ETH.

   RICE (Routines for Implementing C Expert systems) is a fuzzy/MV logic
   inference engine written in C. A C++ front-end with classes is provided.
   Tested with Borland C/C++ 3.1, Microsoft C/C++ 7.00 and GCC 2.4.5;
   examples are included. Documentation is available in WP 5.1 format and 
   PostScript. Available by anonymous ftp from ntia.its.bldrdoc.gov and 
   ftp.cs.cmu.edu. For more info contact Rene' Jager, <R.Jager@ET.TUDelft.NL>.

   FuNeGen 1.0 is a fuzzy neural system capable of generating fuzzy
   classification systems (as C-code) from sample data.
   FuNeGen 1.0 and the papers/reports describing the application and the 
   theoretical background can be obtained by anonymous ftp from

      obelix.microelectronic.e-technik.th-darmstadt.de:/pub/neurofuzzy/

Game Playing:

   METAGAME is a game-playing workbench for developing and playing
   metagame programs. It includes a generator for symmetric chess-like
   games; definitions of chess, checkers, chinese chess, shogi, lose
   chess, lose checkers, french checkers, and tic tac toe translated into
   symmetric chess-like games; a legal move generator; and a variety of
   player programs, from simple through sophisticated.  The METAGAME
   Workbench runs in Quintus or Sictus Prolog.  Available by anonymous
   ftp from 
      ftp.cl.cam.ac.uk:/users/bdp/metagame3a.tar.Z [128.232.0.56]
   For more information, contact Barney Pell <bdp@cl.cam.ac.uk> of the
   University of Cambridge Computer Laboratory.

General AI:

   Generation5: Artificial Intelligence Repository.
   http://library.advanced.org/18242/index.shtml
   A repository of AI information and code, plus interviews with
   famous AI people.

   National Research Council of Canada's complete reseource page:
   http://ai.iit.nrc.ca/ai_top.html

Genetic Algorithms:

   SCS (Simple Classifier System) is a C port of the system from
   Appendix D of "Genetic Algorithms in Search, Optimization, and Machine
   Learning" by David E. Goldberg. It was ported to C by Erik Mayer
   <emayer@uoft02.utoledo.edu>. For more information, contact the author.

   SCS-C is another port to C of Goldberg's Simple Classifier System.
   It includes some extensions, and runs on Sun 10/30 and Atari ST. SCS-C
   is available via anonymous ftp as scs-c-0.98j.tar.Z from
   lumpi.informatik.uni-dortmund.de:/pub/LCS/src/ [129.217.36.140].  The
   documentation alone is available as scs-c-doc.tar.Z in the directory
   /pub/LCS/docs/.  For more information, contact Joerg Heitkoetter
   <joke@ls11.informatik.uni-dortmund.de>, c/o Systems Analysis Group,
   LSXI, Department of Computer Science, University of Dortmund, D-44221
   Dortmund, Germany.

   GENITOR is available by anonymous ftp from the Colorado State
   University Computer Science Department in 
      beethoven.cs.colostate.edu:/pub/GENITOR.tar [129.82.102.183]
   For further information, contact starkwea@cs.colostate.edu or
   mathiask@cs.colostate.edu. If these fail to work, contact
   whitley@cs.colostate.edu.

   Other packages are described in detail in Nici Schraudolph's survey
   of free and commercial GA software (see the Genetic Algorithms
   Repository in [5-1]). Some of the free ones from Nici's list are
   summarized below. Many are available from the GA Repository.

     GAucsd      Genetic algorithms software 
                 cs.ucsd.edu:/pub/GAucsd/GAucsd14.ps.Z [132.239.51.3]
                 Contact GAucsd-request@cs.ucsd.edu
                 To be put on a mailing list of GAucsd users, send
                 the message "add GAucsd" to listserv@cs.ucsd.edu.

     GAbench     Genetic algorithms benchmarks and test problems  
                 cs.ucsd.edu:/pub/GAbench/
                 Thomas Kammeyer (tkammeye@cs.ucsd.edu)

     EM          Evolution Machine (EM)
                 ftp-bionik.fb10.tu-berlin.de:/pub/software/Evolution-Machine/
                     [130.149.192.50]
                     em_tc.exe (EM for Turbo C)
                     em_tcp.exe (EM for Turbo C++)
                     em_man.exe (the manual)
                 Joachim Born <born@max.fb10.tu-berlin.de>

     Genie       GA-based modeling/forecasting system
                 Lance Chambers <P_Stampoul@fennel.cc.uwa.oz.au>

     GENOCOP     GEnetic algorithm for Numerical Optimization for
                 COnstrained Problems. Optimizes function with any
                 number of linear constraints (equalities and inequalities)
     Genetic-2   Optimization package for the linear transportation problem.
     Genetic-2N  Optimization package for the nonlinear transportation problem.
                 All three were developed by Zbigniew Michalewicz and are
                 described in detail in his book "Genetic Algorithms + Data
                 Structures = Evolution Programs", Springer Verlag,
                 August 1992.
                    unccsun.uncc.edu:/coe/evol/ [152.15.10.88]
                    (also known as ftp.uncc.edu)
                 Zbigniew Michalewicz <zbyszek@unccvax.uncc.edu>

     WOLF        Simulator for G/SPLINES algorithm (genetic spline models)
                 ftp://riacs.edu/pub/wolf-4.0.tar.Z

     GAC, GAL    GA written in C/Lisp. Similar to John Grefenstette's Genesis.
                 Bill Spears <spears@aic.nrl.navy.mil>

     ESCaPaDE    Experiments with evolutionary algorithsm.
                 Frank Hoffmeister <iwan@ls11.informatik.uni-dortmund.de>
                 (Send mail with subject line "help" or "get ESCaPaDE")

     mGA1.0      Common Lisp implementation of a messy GA as described in
                 TCGA report 90004.
     SGA-C       C-language port and extension of the original Pascal
                 SGA code presented in Goldberg's book "Genetic
                 Algorithms in Search, Optimization & Machine
                 Learning", Addison Wesley, 1989. See TCGA report 91002.
     SGA-Cube    Goldberg's SGA code modified for nCUBE 2 hypercube
                 parallel computer.
                 All three are available by e-mail from 
                 Robert Elliott Smith <rob@comec4.mh.ua.edu>.

     BUGS        Demonstrates genetic algorithms.
                    santafe.edu:/pub/misc/BUGS/
                 Joshua Smith <jrs@santafe.edu>

     SGPC        Simple Genetic Programming in C
                    sfi.santafe.edu:/pub/Users/tackett/
                 Walter Alden Tackett and Aviram Carmi (gpc@ipld01.hac.com)

     GENEsYs     lumpi.informatik.uni-dortmund.de:/pub/GA/src/ [129.217.36.140]
                 Use "ftp" as user name, e-mail address as password.
                 Thomas Baeck <baeck@ls11.informatik.uni-dortmund.de>

     GAGA        Jon Crowcroft <jon@cs.ucl.ac.uk>. cs.ucl.ac.uk:darpa/gaga.shar
     Splicer     Steve Bayer <bayer@galileo.jsc.nasa.gov>
     PARAGENESIS GA-Repository/e-mail Michael van Lent <vanlent@cs.utk.edu>
     GENESIS     GA-Repository/e-mail John Grefenstette <gref@aic.nrl.navy.mil>
     OOGA        GA-Repository/e-mail John Grefenstette <gref@aic.nrl.navy.mil>
     DGENESIS    Erick Cantu <ecantu@babbage.rhon.itam.mx> or 
                             <ecantu@itamvms1.bitnet>.

     PGA         Parallel Genetic Algorithms testbed
                 ftp.dai.ed.ac.uk:/pub/pga-2.4/pga-2.4.tar.Z (192.41.104.152)
                 Peter Ross, peter@aisb.ed.ac.uk

     ANT         PC Version of 'John Muir Trail' experiment.
                 ftp.std.com:/pub/pbrennan
                 Patrick M Brennan <pbrennan@world.std.com>

   GPQUICK is a simple GP system implemented in C++.  It features an
   elegant object architecture with function (Function), program
   (Chrome), GA (Pop) and problem (Problem) classes.  The Problem class
   is proposed as a portable representation for problems that would be
   source compatible with a variety of other GP systems.  GPQUICK uses a
   steady state GA, tournament selection, one type of mutation, and
   subtree crossover.  It uses a fast, compact linear representation for
   S-expressions. It includes documentation from the associated magazine
   article (Byte, "Some Assembly Required", February 1994). GPQUICK is
   available by anonymous ftp from
      ftp.cc.utexas.edu:/pub/genetic-programming/code/
   as the files gpquick.tar (unix version, tested with CC and g++) and
   gpquick.zip (PC/ANSI C version, tested with Borland 3.1).
   For more information, write to Andrew Singleton <p00396@psilink.com>.

   GENlib is a library of functions for genetic algorithms together with
   two applications of the library to train neural networks. The library
   is available by anonymous ftp from
      ftp.neuro.informatik.uni-kassel.de:/pub/NeuralNets/GA-and-NN/
   for academic research and educational purposes only. Commercial uses

ICOT:

   Japan's Institute for New Generation Computer Technology (ICOT) has
   made their software available to the public free of charge.  The
   collection includes a variety of prolog-based programs in symbol
   processing, knowledge representation, reasoning and problem solving,
   natural language processing. All programs are available by anonymous
   ftp from ftp.icot.or.jp.  Note that most of the programs are written
   for the PSI machines, and very few have been ported to Unix-based
   emulators.  For further information, send email to ifs@icot.or.jp, 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 +81-3-4456-1618.

-------------------------------------------------------
Subject: [6-8] Knowledge Representation - Medical

Knowledge Representation:

   OpenCyc -- OpenCyc is the open source version of the Cyc(r)
	      technology, the world's largest and most complete
	      general knowledge base and commonsense reasoning
	      engine. OpenCyc can be used as the basis for a wide
	      variety of intelligent applications.  

	      web site: http://www.opencyc.org
	      documentation: http://www.opencyc.org/doc
	      download: http://sourceforge.net/projects/opencyc

   KNOWBEL -- ai.toronto.edu:/pub/kr/ as the files knowbel.tar.Z and
              manual.txt.tar.Z 
              Contact: Bryan M. Kramer, <kramer@ai.toronto.edu>
              Telos temporal/sorted logic system.

   SB-ONE  -- Contact: kobsa@inf-wiss.uni-konstanz.de
              KL-ONE family. Currently undergoing revision and will be
              renamed KN-PART+.
   KRIS    -- Contact: baader@dfki.uni-kl.de
              KL-ONE family (Symbolics only)
   BACK    -- Contact: back@cs.tu-berlin.de
              ftp.cs.tu-berlin.de:/pub/doc/reports/tu-berlin.de/kit/Back52
                 Files are BACK_V52.intro and Back52.tar.Z
                 Tar file includes Tutorial/Manual in postscript format
                 and installation instructions.
              KL-ONE family
   CLASSIC -- Contact: dlm@research.att.com
              KL-ONE family
   MOTEL   -- Contact: hustadt@mpi-sb.mpg.de
              mpi-sb.mpg.de:/pub/tools/motel.tar.Z [139.19.1.1]
              Modal KL-ONE (contains KRIS as a kernel). 
              Implemented in Prolog.

   FOL GETFOL -- Contact: fausto@irst.it
              Weyrauch's FOL system

   COLAB/RELFUN  -- Contact: boley@informatik.uni-kl.de
                    Logic Programming
   COLAB/FORWARD -- Contact: hinkelma@dfki.uni-kl.de
                    Logic Programming
   COLAB/CONTAX  -- Contact: meyer@dfki.uni-kl.de
                    Constraint System for Weighted Constraints over
                    Hierarchically Structured Finite Domains.
   COLAB/TAXON   -- Contact: hanschke@dfki.uni-kl.de
                    Terminological Knowl. Rep. w/Concrete Domains

   SNePS (Semantic Network Processing System) is the implementation of a
   fully intensional theory of propositional knowledge representation and
   reasoning. SNePS includes a module for creating and accessing
   propositional semantic networks, path-based inference, node-based
   inference based on SWM (a relevance logic with quantification) that
   uses natural deduction and can deal with recursive rules, forward,
   backward and bi-directional inference, nonstandard logical connectives
   and quantifiers, an assumption based TMS for belief revision (SNeBR), a
   morphological analyzer and a generalized ATN (GATN) parser for parsing
   and generating natural language, SNePSLOG, a predicate-logic-style
   interface to SNePS, XGinseng, an X-based graphics interface for
   displaying, creating and editing SNePS networks, SNACTor, a
   preliminary version of the SNePS Acting component, and SNIP 2.2, a new
   implementation of the SNePS Inference Package that uses rule shadowing
   and knowledge migration to speed up inference.  SNeRE (the SNePS
   Rational Engine), which is part of Deepak Kumar's dissertation about
   the integration of inference and acting, will replace the current
   implementation of SNACTor.  SNePS is written in Common Lisp, and has
   been tested in Allegro CL 4.1, Lucid CL 4.0, TI Common Lisp, CLISP
   May-93, and CMU CL 17b. It should also run in Symbolics CL, AKCL 1.600
   and higher, VAX Common Lisp, and MCL. The XGinseng interface is built
   on top of Garnet.  SNePS 2.1 is free according to the GNU General
   Public License version 2. The SNePS distribution is available by
   anonymous ftp from 

      ftp.cs.buffalo.edu:/pub/sneps/  [128.205.32.9] 

   as the file rel-x-yyy.tar.Z, where 'x-yyy' is the version. The other
   files in the directory are included in the distribution; they are
   duplicated to let you get them without unpacking the full distribution
   if you just want the bibliography or manual. If you use SNePS, please
   send a short message to shapiro@cs.buffalo.edu and
   snwiz@cs.buffalo.edu. Please also let them know whether you'd like to
   be added to the SNUG (SNePS Users Group) mailing list. 

   URANUS is a logic-based knowledge representation language. Uranus is
   an extension of Prolog written in Common Lisp and using the syntax of
   Lisp. Uranus extends Prolog with a multiple world mechanism for
   knowledge representation and term descriptions to provide
   functional programming within the framework of logic programming.
   It is available free by anonymous ftp from 

      etlport.etl.go.jp:/pub/uranus/ftp/ [192.31.197.99]

   for research purposes only.  For more information contact the author, 
   Hideyuki Nakashima <nakashim@etl.go.jp>.

Machine Learning:
 
   The prudsys XELOPES library (eXtEnded Library fOr Prudsys Embedded
   Solutions) is an open platform-independent and
   data-source-independent library for Embedded Data Mining. It was
   developed in close cooperation with the Russian MDA specialist
   ZSoft Ltd. XELOPES is CWM-compatible, supports the relevant Data
   Mining standards and can be combined with all prudsys products.
   http://www.prudsys.com/Produkte/Algorithmen/Xelopes

   RFCT is a tool based on C4.5 and written in Java. It uses C4.5 to
   discover temporal and causal rules, and has the following features:
    *) Has a graphical user interface.
    *) Handles temporal data, both in input and output.
    *) Can function in an unsupervised manne.r
    *) Outputs temporal/causal rules in a useful manner, so the user can
       have a good understanding of what influences the result.
    *) handles continous values (can discretize real-valued variables).
    *) Can output rules in Prolog, thus the rules are readily
       executable.
    The package, including full source code, example files, and online
    help, is available freely from
    http://www.cs.uregina.ca/~karimi/downloads.html.
 

   LIBSVM -- a support vector machines (SVM) library for
               classification problems by Chih-Chung Chang and
               Chih-Jen Lin. See:
               http://www.csie.ntu.edu.tw/~cjlin/libsvm

   Weka     -- a GPLed Java machine learning toolkit
	       http://www.cs.waikato.ac.nz/ml/weka/
	       Is associated with an ML book.  See:
	       http://www.cs.waikato.ac.nz/~ml/weka/book.html

   COBWEB/3 -- Contact: cobweb@ptolemy.arc.nasa.gov

   IND      -- Contact: NASA COSMIC, <service@cossack.cosmic.uga.edu>
               Tel: 706-542-3265 (ask for customer support)
               Fax: 706-542-4807
               IND is a C program for the creation and manipulation of
               decision trees from data, integrating the CART,
               ID3/C4.5, Buntine's smoothing and option trees, Wallace
               and Patrick's MML method, and Oliver and Wallace's MML
               decision graphs which extend the tree representation to
               graphs. Written by Wray Buntine, <wray@kronos.arc.nasa.gov>.

   AUTOCLASS -- Contact: taylor@ptolemy.arc.nasa.gov
               AutoClass is an unsupervised Bayesian classification system for
               independent data. 

   FOIL     -- ftp.cs.su.oz.au:/pub/ [129.78.8.208] 
               as the files foil4.sh, foil5.sh, and foil6.sh.
               Each shell archive contains source, a brief manual,
               and several sample datasets. FOIL2 should be available
               from sumex-aim.stanford.edu:/pub/FOIL.sh. FOIL 6.0 now uses
	       ANSI C.
               Contact: J. Ross Quinlan <quinlan@cs.su.oz.au>
                        Mike Cameron-Jones <mcj@cs.su.oz.au>

   RWM      -- Contact: H. Altay Guvenir <guvenir@trbilun.bitnet>
               RWM is a program for learning problem solving strategies,
               written in Common Lisp (tested on Suns and NeXT).


   MOBAL is a system for developing operational models of application
   domains in a first order logic representation. It integrates a manual
   knowledge acquisition and inspection environment, an inference engine,
   machine learning methods for automated knowledge acquisition, and a
   knowledge revision tool.  By using MOBAL's knowledge acquisition
   environment, you can incrementally develop a model of your domain in
   terms of logical facts and rules.  You can inspect the knowledge you
   have entered in text or graphics windows, augment the knowledge, or
   change it at any time. The built-in inference engine can immediately
   execute the rules you have entered to show you the consequences of
   your inputs, or answer queries about the current knowledge. MOBAL also
   builds a dynamic sort taxonomy from your inputs. If you wish, you can
   use several machine learning methods to automatically discover
   additional rules based on the facts that you have entered, or to form
   new concepts. If there are contradictions in the knowledge base due to
   incorrect rules or facts, there is a knowledge revision tool to help
   you locate the problem and fix it.  MOBAL (release 3.0b) is available
   free for non-commercial academic use by anonymous ftp from

      ftp.gmd.de:/gmd/mlt/Mobal/

   The system runs on Sun SparcStations, SunOS 4.1, and includes a
   graphical interface implemented using Tcl/TK.

   PEBLS (Parallel Exemplar-Based Learning System) is a nearest-neighbor
   learning system designed for applications where the instances have
   symbolic feature values.  PEBLS has been applied to the prediction of
   protein secondary structure and to the identification of DNA promoter
   sequences. PEBLS 3.0 is written in ANSI C and is available by
   anonymous ftp from blaze.cs.jhu.edu:/pub/pebls/pebls.tar.Z
   [128.220.13.50] for research purposes only. For more information,
   contact Steven Salzberg <salzberg@cs.jhu.edu>.

   OC1 (Oblique Classifier 1) is a multivariate decision tree induction
   system designed for applications where the instances have numeric
   feature values.  OC1 builds decision trees that contain linear
   combinations of one or more attributes at each internal node; these
   trees then partition the space of examples with both oblique and
   axis-parallel hyperplanes.  OC1 has been used for classification of
   data from several real world domains, such as astronomy and cancer
   diagnosis.  A technical decription of the algorithm can be found in
   the AAAI-93 paper by Sreerama K. Murthy, Simon Kasif, Steven Salzberg
   and Richard Beigel.  A postscript version of this paper is included in
   the distribution. OC1 is a written entirely in ANSI C. OC1 is
   available by anonymous ftp from  

      blaze.cs.jhu.edu:/pub/oc1/ [128.220.13.50]

   This distribution is provided for non-commercial purposes only. For
   more information, contact Sreerama K. Murthy <murthy@cs.jhu.edu>
   (primary contact), Steven Salzberg <salzberg@cs.jhu.edu>, or Simon
   Kasif <kasif@cs.jhu.edu>, Department of Computer Science, The Johns
   Hopkins University, Baltimore, MD 21218.

   Set-Enumeration (SE) Trees for Induction/Classification. Significant
   research in Machine Learning, and in Statistics, has been devoted to
   the induction and use of decision trees as classifiers.  An induction
   framework which generalizes decision trees using a Set-Enumeration
   (SE) tree is outlined in  

      Rymon, R. (1993), An SE-tree-based Characterization of the Induction
      Problem. In Proc. of the Tenth International Conference on Machine
      Learning, Amherst MA, pp. 268-275.

   In this framework, called SE-Learn, rather than splitting according to
   a single attribute, one recursively branches on all (or most) relevant
   attributes. An induced SE-tree can be shown to economically embed many
   decision trees, thereby supporting a more expressive hypothesis
   representation. Also, by branching on many attributes, SE-Learn
   removes much of the algorithm-dependent search bias. Implementations
   of SE-Learn can benefit from many techniques developed for decision
   trees (e.g., attribute-selection and pruning measures). In particular,
   SE-Learn can be tailored to start off with one's favorite decision
   tree, and then improve upon it by further exploring the SE-tree. This
   hill-climbing algorithm allows trading time/space for added accuracy.
   Current studies (yet unpublished) show that SE-trees are particularly
   advantageous in domains where (relatively) few examples are available
   for training, and in noisy domains. Finally, SE-trees can provide a
   unified framework for combining induced knowledge with knowledge
   available from other sources (Rymon, 1994).  

      Rymon, R. (1994), On Kernel Rules and Prime Implicants. To appear in
      Proc. of the Twelfth National Conference on Artificial Intelligence,
      Seattle WA.

   A Lisp implementation of SE-Learn is available from Ron Rymon
   <Rymon@ISP.Pitt.edu>. A commercial version in C is currently under
   development.

   MLC++ is a Machine Learning library of C++ classes being developed at
   Stanford.  More information about the library can be obtained at URL

      http://robotics.stanford.edu:/users/ronnyk/mlc.html

   The utilities are available by anonymous ftp from

      starry.stanford.edu:/pub/ronnyk/mlc/util/

   They are currently provided only as object code for Sun, but source code
   will be distributed to sites that wish to port the code to other compilers.
   For more information write to Ronny Kohavi <ronnyk@CS.Stanford.EDU>.

Medical Reasoning:

   TMYCIN -- sumex-aix.stanford.edu:/tmycin  

------------------------------------------------------------------------
Subject: [6-9] Natural Language Processing

Natural Language Processing:

 * ALE (Attribute Logic Engine) is a freeware system written in Prolog
   that integrates phase-structred parsing, semantic-head-driven generalization 
   and constraint logic programming with typed features such as terms.
   You can find ALE at http://www.sfs.nphil.uni-tuebingen.de/~gpenn/ale.html
   The site http://www.ltg.hcrc.ed.ac.uk/projects/ledtools/ale-hpsg/ details
   how to build an NLP grammar using a head-driven phase structured grammar
   (HPSG) and ALE.

 * Eric Brill's trainable rule-based part of speech tagger (version 1.0.2)
   is available by anonymous ftp from 

      ftp.cs.jhu.edu:/pub/BRILL/Programs/

   This tagger is based on transformation-based error-driven learning, a
   technique that has been effective in a number of natural language
   applications, including part of speech and word sense tagging,
   prepositional phrase attachment, and syntactic parsing.  For more
   information, you can obtain relevant papers in 

      ftp.cs.jhu.edu:/pub/BRILL/Papers/

   If you do download the tagger and wish to be on the mailing list for
   future releases, bug reports, etc, please send mail to Eric Brill
   <brill@cs.jhu.edu> or <brill@goldilocks.lcs.mit.edu>.

 * Hdrug is an environment to develop logic grammars, parsers, and
   generators for natural languages.  The package comes with a number of
   example grammars, including a Categorial Grammar, a Tree Adjoining
   Grammar, a Unification Grammar in the spirit of Head-driven Phrase
   Structure Grammar, an Extraposition Grammar, a Definite Clause
   Grammar, and a port of the HPSG grammar from Bob Carpenter's ALE
   system. Each of the grammars comes with a set of parsers, such as 
   Earley-like chart parsers, left-corner parsers and head-driven
   parsers. Some grammars come with variants of the head-driven
   generator. The package allows easy comparison of different
   parsers/generators, extensive possibilities of compiling feature
   equations into Prolog terms, graphical (Tk), LaTeX and ordinary Prolog
   output of trees, feature structures and Prolog terms, and plotted
   graphs and tables of statistical information. Hdrug runs in Sicstus
   Prolog and requires ProTcl and Tcl/Tk. It is available by anonymous
   FTP from

      tyr.let.rug.nl:/pub/prolog-app/Hdrug/

   or by WWW from

      http://tyr.let.rug.nl/~vannoord/prolog-app/Hdrug/

   For more information, write to Gertjan van Noord <vannoord@let.rug.nl>.

 * NLBean(tm) version 2: a natural language interface to databases. 
   It is an example of conversion of natural language from a limit domain
   to SQL querries for database access.  Go to http://www.markwatson.com

 * Grok is a project dedicated to developing a large collection of
   basic tools for NLP.  See more at

      http://grok.sourceforge.net

------------------------------------------------------------------------
Subject: [6-9a] Speech

 * The ISIP project at Mississippi State University is a public-domain
   speech-to-text system currently in an Alpha release.  See

      http://www.isip.msstate.edu/projects/speech/

 * CMU's Sphinx system is available from

      http:// www.speech.cs.cmu.edu/sphinx/Sphinx.html

 * RECNET is a complete speech recognition system for the DARPA TIMIT and
   Resource Management tasks.  It uses recurrent networks to estimate phone
   probabilities and Markov models to find the most probable sequence of
   phones or words.  The system is a snapshot of evolving research code.
   There is no documentation other than published research papers.  It is
   configured for the two specific databases and is unlikely to be of use as
   a complete system for other tasks. It is available by anonymous ftp from

      svr-ftp.eng.cam.ac.uk:/misc/recnet-1.3.tar.Z

   Related publications can be found in 

      svr-ftp.eng.cam.ac.uk:/reports/ (see the ABSTRACT file first).

   You will need the relevant CDROMs, 150MByte of free space for TIMIT and
   300MByte for RM. If you use the code, the author would appreciate an
   email message so that he can keep you informed of new releases. Write to
   Tony Robinson, <ajr@eng.cam.ac.uk>, for more information.

 * CELP 3.2a is available from super.org:/pub/celp_3.2a.tar.Z
   [192.31.192.1] with copies available on
   svr-ftp.eng.cam.ac.uk:/comp.speech/sources/ The code (C, FORTRAN,
   diskio) all has been built and tested on a Sun4 under SunOS4.1.3.  If
   you want to run it somewhere else, then you may have to do a bit of
   work.  (A Solaris 2.x-compatible release is planned soon.) Written by
   Joe Campbell <jpcampb@afterlife.ncsc.mil> of the Department of
   Defense. Distribution facilitated by Craig F. Reese
   <cfreese@super.org>, IDA/Supercomputing Research Center.

 * The OGI Speech Tools are set of speech data manipulation tools
   developed at the Center for Spoken Language Understanding (CSLU) at
   the Oregon Graduate Institute of Science and Technology (Portland
   Oregon). The tools can be used to compute and display signal
   representations, label speech at different levels (e.g., phonetic,
   phonemic and word), train neural network classifiers, and display the
   output of classification or recognition algorithms time-aligned with
   the speech. The OGI Speech Tools were written in ANSI C.  The OGI
   Speech Tools are available by anonymous ftp from

      speech.cse.ogi.edu:/pub/tools/ 

   as ogitools.v1.0.tar.Z. For more information, write to Johan Schalkwyk
   <tools@cse.ogi.edu>. If you're using the tools, please let Johan know
   by sending him a mail message.

 * PC Convolution is a educational software package that graphically
   demonstrates the convolution operation.  It runs on IBM PC compatibles
   using DOS 4.0 or later. A demo version is available by anonymous ftp
   from 

      ee.umr.edu:/pub/ [131.151.4.11]

   as pc_conv.*.  University instructors may obtain a free, fully
   operational version by contacting Dr. Kurt Kosbar <kk@ee.umr.edu> at
   117 Electrical Engineering Building, University of Missouri/Rolla,
   Rolla, Missouri, 65401, phone 314-341-4894.

   http://mambo.ucsc.edu/psl/speech.html

 * Online Speech Synthesizer using the RSYNTH package
      http://www_tios.cs.utwente.nl/say/  (prefered URL)
   Axel.Belinfante@cs.utwente.nl

 * AsTeR (Audio System For Technical Readings) is a computing system that
   orally renders technical documents marked up in LaTeX. An interactive
   demo is accessible via the URL
      http://www.cs.cornell.edu/Info/People/raman/aster/demo.html
   This document presents a collection of math examples rendered in
   audio by AsTeR and in Postscript by LaTeX/DVIPS from the same original
   LaTeX source. A version of the demo that uses inline images can be
   found in the URL
      http://www.cs.cornell.edu/Info/People/raman/aster/aster-toplevel.html
   For more information, write to T.V. Raman <raman@crl.dec.com>,
      http://www.cs.cornell.edu/Info/People/raman/raman.html
   If you download a copy of his thesis, please send him a short email message.

   http://ophale.icp.grenet.fr/esca/esca.html
   [European Speech Communication Association (ESCA)]
   Christian Benoit, <benoit@icp.grenet.fr> or <esca@icp.grenet.fr>

   http://www.cs.bham.ac.uk/~jpi/synth/museum.html
   [Examples of speech synthesis from different systems.]
   Jon Iles <j.p.iles@cs.bham.ac.uk> or http://www.cs.bham.ac.uk/~jpi/

   http://faculty.washington.edu/~dillon/PhonResources.html
   [Archive of resources for studying speech sounds, primarily English.
   Includes symbols and samples of English phones/phonemes, both
   American and British; tips, tutorials, basic walk-throughs of
   waveform analysis; and examples and links to TTS synthesizers,
   mainly in Europe.]
   George Dillon <dillon@u.washington.edu>


------------------------------------------------------------------------
Subject: [6-10] Neural Networks
(see ftp://ftp.sas.com/pub/neural/FAQ5.html for a more complete list)

Neural Network Toolkits:

   The Stuttgart Neural Network Simulator supports a number of different
   kinds of neural networks.  It's build on a C kernel, and has an X-Windows
   GUI interface to "create, manipulate and visualize nets in various ways."
   You can find out more from http://www-ra.informatik/uni-tuebingen.de/SNNS 

Neural Systems (Biological Simulation):

   BIOSIM is a biologically-oriented neural network simulator.  It
   implements four neuron models: a simple model only switching ion
   channels on and off, the original Hodgkin-Huxley model, the SWIM model
   (a modified HH model) and the Golowasch-Buchholz model (the most
   enhanced model). Dendrites consist of a chain of segments without
   bifurcation.  It is in the public domain and runs on Unix workstations
   (a less-powerful PC version is also available). BIOSIM includes a
   graphical user interface and was designed for research and teaching.
   It is available by anonymous ftp from

      ftp.uni-kl.de:/pub/bio/neurobio [131.246.9.95]

   For more information, write to Stefan Bergdoll <bergdoll@zxa.basf-ag.de>.

    GENESIS (short for GEneral NEural SImulation System) is a general
    purpose simulation platform which was developed to support the
    simulation of neural systems ranging from complex models of single
    neurons to simulations of large networks made up of more abstract
    neuronal components. GENESIS has provided the basis for laboratory
    courses in neural simulation at both Caltech and the Marine
    Biological Laboratory in Woods Hole, MA, as well as many other
    institutions. Most current GENESIS applications involve realistic
    simulations of biological neural systems. Although the software
    can also model more abstract networks, other simulators are more
    suitable for backpropagation and similar connectionist modeling.
    The homepage is located at:    http://www.genesis-sim.org/GENESIS/

------------------------------------------------------------------------
Subject: [6-11] Organizations - Qualitative Reasoning

Organizations:
   AAAI, the American Association of Artificial Intelligence homepage:
   http://www.aaai.org/

   IJCAI, the International Joint Conference on Artificial
   Intelligence home page: http://ijcai.org/

   The Association for Computational Linguistics homepage:
   http://www.aclweb.org/ 

Pedagogy:

   Temple University's page on teaching AI:
   http://yoda.cis.temple.edu:8080/IIIA/ai.html

Probabilistic Reasoning:

   BELIEF is a Common Lisp implementation of the Dempster and Kong fusion
   and propagation algorithm for Graphical Belief Function Models and the
   Lauritzen and Spiegelhalter algorithm for Graphical Probabilistic
   Models. It includes code for manipulating graphical belief models such
   as Bayes Nets and Relevance Diagrams (a subset of Influence Diagrams)
   using both belief functions and probabilities as basic representations
   of uncertainty. It is available by anonymous ftp from

      ftp.stat.washington.edu [128.95.17.34]

   and by email from the author, Russell Almond <almond@stat.washington.edu>.
   Contact the author at almond@statsci.com for information about a
   commercial version GRAPHICAL-BELIEF currently in the prototype stages.

   IDEAL is a LISP system developed for building and evaluating influence
   diagrams and Bayesian networks.  It is accompanied with a graphical
   user interface (CLIM-based) for constructing, editing, and solving
   belief networks and influence diagrams. For more information, write
   to srinivas@rpal.rockwell.com.

Planning:

   St. Amant's NCSU AI Planning Resources-
   http://www.csc.ncsu.edu/faculty/stamant/planning-resources.html 
   A List of links to planning sites all over the world.

   NONLIN   --  http://www.cs.bham.ac.uk/research/poplog/nonlin/
		http://www.aiai.ed.ac.uk/~bat/bat.html about the
		author.

   RHETORICAL -- ftp.cs.rochester.edu:/pub/packages/knowledge-tools
               Contact: Brad Miller <miller@cs.rochester.edu>

   SNLP     -- cs.washington.edu:/pub/snlp.tar.Z
               Contact: weld@cs.washington.edu
               Nonlinear planner.

   IDM      -- sauquoit.gsfc.nasa.gov (128.183.101.29)
               Contact: idm-users@chelmsford.gsfc.nasa.gov
               STRIPS-like planning.

   PRODIGY  -- Contact: prodigy@cs.cmu.edu
               Integrated Planning and Learning System

   SOAR     -- http://bigfoot.eecs.umich.edu/~soar/
               Contact: soar-request@cs.cmu.edu
               Integrated Agent Architecture. 
               Supports learning through chunking.

   CLIPS    -- CLIPS Expert System Shell
	       http://www.jsc.nasa.gov/~clips/CLIPS.html
	       Executable and Documentation directory:
	       http://www.ghgcorp.com/clips/download/
	       There are also some DLLs for CLIPS. 
	       http://www.intelliwise.com/links.htm
	       (Thanks Sergio Navega)
	       Java variant: :http://herzberg.ca.sandia.gov/jess

Qualitative Reasoning/Qualitative Physics:

   QSIM     -- cs.utexas.edu:/pub/qsim
               Contact: Ben Kuipers <kuipers@cs.utexas.edu>

   QPE      -- multivac.ils.nwu.edu:/pub/QPE
               contact: Prof. Kenneth D. Forbus <forbus@ils.nwu.edu>
               Qualitative Process Engine (an implementation of QP theory)

---------------------------------------------------
Subject: [6-12] Robotics

Robotics:

   A list of pointers to sources of robotics information on the Internet. 
      http://cs.indiana.edu/robotics/world.html

   http://piglet.cs.umass.edu:4321/robotics.html
   [Robotics Internet Resources Page]

Robotic Simulation (Planning Testbeds and Simulators):

 * See Steve Hanks, Martha E. Pollack, and Paul R. Cohen, "Benchmarks,
   Test Beds, Controlled Experimentation, and the Design of Agent
   Architectures", AI Magazine 14(4):17-42, Winter 1993.

 * The ARS MAGNA abstract robot simulator provides an abstract world in
   which a planner controls a mobile robot. This abstract world is more
   realistic than typical blocks worlds, in which micro-world simplifying
   assumptions do not hold. Experiments may be controlled by varying
   global world parameters, such as perceptual noise, as well as building
   specific environments in order to exercise particular planner
   features. The world is also extensible to allow new experimental
   designs that were not thought of originally. The simulator also
   includes a simple graphical user-interface which uses the CLX
   interface to the X window system. ARS MAGNA can be obtained by
   anonymous ftp from 

      ftp.cs.yale.edu:/pub/nisp 

   as the file ars-magna.tar.Z. Installation instructions are in the file
   Installation.readme. The simulator is written in Nisp, a macro-package
   for Common Lisp. Nisp can be retrieved in the same way as the
   simulator. Version 1.0 of the ARS MAGNA simulator is documented in
   Yale Technical Report YALEU/DCS/RR #928, "ARS MAGNA: The Abstract
   Robot Simulator". This report is available in the distribution as a
   PostScript file. Comments should be directed to Sean Philip
   Engelson <engelson@cs.yale.edu>.

 * Erratic, a mobile robot simulator and controller by konolige@ai.sri.com is
   available by anonymous ftp from

      ftp.ai.sri.com:pub/konolige/erratic-ver1.tar.Z

 * The Michigan Intelligent Coordination Experiment (MICE) testbed is a
   tool for experimenting with coordination between intelligent systems
   under a variety of conditions.  MICE simulates a two-dimensional
   grid-world in which agents may move, communicate, and affect their
   environment.  MICE is essentially a discrete-event simulator that
   helps control the domain and a graphical representation, but provides
   relatively few constraints on the form of the domain and the agents'
   abilities.  Users may specify the time required by various activities,
   the constraints on an agents' sensors, the configuration of the domain
   and its properties, etc.  MICE runs under XWindows on Un*x boxes, on
   Macs, and on TI Explorers, with relatively consistent graphical
   displays.  Source code, documentation, and examples are available via
   anonymous ftp to ftp.eecs.umich.edu:/software/Mice/Mice.tar.Z.  MICE was
   produced by the University of Michigan's Distributed Intelligent Agent
   Group (UM DIAG).  For further information, write to
   umdiagmice@caen.engin.umich.edu.

 * RSIM, a SGI-based simulator from the University of Melbourne, with very
   nice graphics, is available by anonymous ftp from

      krang.vis.citri.edu.au:/pub/robot

   Write to cdillon@vis.citri.edu.au for more information.
   
 * Simderella is a robot simulator consisting of three programs: CONNEL
   (the controller), SIMMEL (the robot simulator), and BEMMEL (the
   X-windows oriented graphics back-end). SIMMEL performs a few matrix
   multiplications, based on the Denavit Hartenberg method, calculates
   velocities with the Newton-Euler scheme, and communicates with the
   other two programs.  BEMMEL only displays the robot.  CONNEL is the
   controller, which must be designed by the user (in the distributed
   version, CONNEL is a simple inverse kinematics routine.)  The programs
   use Unix sockets for communication, so you must have sockets, but you
   can run the programs on different machines.  The software is available
   by anonymous ftp from

      galba.mbfys.kun.nl:/pub/neuro-software/pd/ [131.174.82.73]

   as the file simderella.2.0.tar.gz. The software has been compiled using
   gcc on SunOS running under X11R4/5 on Sun3, Sun4, Sun Sparc 1, 2, and
   10, DEC Alpha, HP700, 386/486 (Linux), and Silicon Graphics
   architectures. For more information, send email to Patrick van der
   Smagt, <smagt@fwi.uva.nl>. 

 * RP1 is a Java-based robot simulator.  It allows applications to build
   arbitrary landscapes and a data-configurable robot which can interact with
   a simulated environment or solve a virtual maze.  The system provides
   abstract features that model real-world objects such as walls, light
   sources, and goals.  For more information, see:

      http://rossum.sourceforge.net

   TILEWORLD -- cs.washington.edu:/new-tileworld.tar.Z
               Planning testbed


-----------------------------------------------------
Subject: [6-13] Temporal Reasoning - Truth Maintenance

Temporal Reasoning:

   See also KNOWBEL above.

   MATS     -- Metric/Allen Time System
               Contact: Henry Kautz <kautz@research.att.com>
               MATS is a Common Lisp program which solves temporal
               constraint problems.  Input constraints are either
               difference inequalities or Allen-style qualitative constraints.

   TMM      -- New implementation of Dean & McDermott's Temporal Map
               Manager system written in Common Lisp.  
               See SIGART Bulletin 4(3), July 1993.
               Contact: carciofi@src.honeywell.com

   MTMM     -- Modified version of Dean & McDermott's TMM written in
               MCL.  Available on diskette.
               Contact: Eckehard Gross <gross@gmd.de>

   TimeGraph-- Metric and Qualitative temporal reasoning system which
               handles (<, =, >) point relations, bounds on absolute
               calendar/clock times, and bounds on durations. Data entry
               and retrieval is through interval or point relations.
               The system is scalable in the sense that storage
               remains linear in the number of relations added.
               Efficient retrieval is achieved through a simple 
               timepoint numbering scheme and metagraph structure.
               See SIGART Bulletin 4 (3), pp. 21-25, July 1993.
               Contact: Lenhart Schubert (schubert@cs.rochester.edu)

   TimeGraph II (TG-II) handles the set of the relations of the Point
   Algebra and of the Pointizable Interval Algebra (also called Simple
   Interval Algebra by P. van Beek). Temporal relations are represented
   through a "timegraph", a graph partitioned into a collection of "time
   chains" which are automatically structured for efficiency. The system
   is scalable, in the sense that the storage tends to remain linear in
   the number of relations asserted. Efficient query handling is achieved
   through a time point numbering scheme and a "metagraph" data
   structure. TG-II is written in Common Lisp.  For a description of the
   theory underlying the system see:

      [1] Alfonso Gerevini and Lenhart Schubert, "Efficient Temporal
	  Reasoning through Timegraphs", in Proceedings of IJCAI-93.
      [2] Alfonso Gerevini and Lenhart Schubert, "Temporal Reasoning in 
	  TimeGraph I-II", SIGART Bulletin 4(3), July 1993.
      [3] Alfonso Gerevini and Lenhart Schubert, "Efficient Algorithms 
	  for Qualitative Reasoning about Time", Artificial Intelligece, 
	  to appear. Also available as IRST Technical Report 9307-44, 
	  IRST 38050 Povo, TN Italy; or Tech. report 496, Computer Science 
	  Department, University of Rochester, Rochester 14627 NY, USA.

   TimeGraph II is available by anonymous ftp from

      ftp.cs.rochester.edu:/pub/packages/knowledge-tools/

   as the files tg-ii.readme and tg-ii-1.tar.gz. If you retrieve a copy
   of TimeGraph II by anonymous ftp, please let them know that you've
   retrieved a copy by sending a message to 

      bug-tg2-request@cs.rochester.edu

   For more information, contact Alfonso Gerevini <gerevini@irst.it> or
   Lenhart Schubert <schubert@cs.rochester.edu>.

   Tachyon  -- Performs constraint satisfaction for point-based metric
               reasoning.  Qualitative constraints are also handled by
               translation into quantitative ones.  Written in C++. 
               See SIGART Bulletin 4(3), July 1993.
               Contact: Richard Arthur (arthurr@crd.ge.com)
               
   TimeLogic-- The TimeLogic system is an interval-based forward
               chaining inference engine and database manager of
               temporal constraints.  Relational constraints,
               indicating relative order between intervals, are based
               on Allen's interval logic.  The TimeLogic system also
               supports durational constraints, indicating relative
               magnitude between intervals, and reference links, used
               for the explicit or automatic construction of interval
               hierarchies.  Constraints are posed and propagated in
               user-defined contexts with inheritance. Supports relative
               metric constraints but no absolute dates or times.
               Written in Common Lisp.
               Contact: Peggy Meeker (timelogic-request@cs.rochester.edu)

   TemPro   -- A temporal constraint system that uses both interval
               algebra and point-based algebra. Written in Common Lisp.
               Contact: J-P Haton <jph@loria.fr> or
                        F. Charpillet <charp@loria.fr>

   TIE      -- Temporal Inference Engine.  Written in Common Lisp.
               Contact: E. Tsang (Essex University, UK)

   TCNM (Temporal Constraint Network Manager) manages non-disjunctive
   metric constraints on time-points and on durations in an integrated
   way. These constraints allow us express absolute, qualitative and
   metric constraints on time-points and on durations, which are managed
   in an integrated way. In the updating processes, a non-redundant and
   global consistent Temporal Constraint Network is always maintained by
   means of an efficient and complete propagation method, with a O(n**2)
   temporal complexity. Sound and complete retrieval processes have a
   constant cost. Written in Common Lisp.  For more information, contact
   Federico A. Barber <fbarber@dsic.upv.es>.  See also SIGART Bulletin
   4(3), July 1993.

Theorem Proving/Automated Reasoning:

   Coq is the Calculus of Inductive Constructions. It runs in 
   Caml-Light and is available by anonymous ftp from

      ftp.inria.fr:/INRIA/coq/V5.8.3 (unix version)
      ftp.inria.fr:/INRIA/coq/V5.8.2 (mac version)

   The Mac version is standalone, not requiring Caml-Light. The unix
   version requires Caml-Light, however, which is available from

      ftp.inria.fr:/lang/caml-light

   Documentation is included in the distribution. Questions and comments
   should be directed to the Coq hotline <coq@pauillac.inria.fr>. 

   DTP is a general first-order theorem prover incorporating
   intelligent backtracking and subgoal caching, as well as a trace
   facility that can display proof spaces graphically.  It is
   implemented in (CLtL2) Common Lisp, and is available on the web at
     http://don.geddis.org/dtp/

   Elf implements the LF Logical Framework (based on the theory of
   dependent types) and gives it a logic programming interpretation in
   order to support search and the implementation of other algorithms (e.g.
   evaluation or compilation in programming languages).  It comes with a
   number of examples from logic and the theory of programming languages
   such as the Church Rosser theorem for the untyped lambda-calculus and
   type soundness for Mini-ML.  It is written in Standard ML and includes
   some support code for editing and interaction in gnu-emacs. It is
   available by anonymous ftp from 

      ftp.cs.cmu.edu:/afs/cs/user/fp/public/

   as the files README (general information), elf-04.tar.Z (Version 0.4
   of Elf, 1 Jul 1993), elf-examples.tar.Z (Version 0.4 of Elf examples,
   unchanged from Version 0.3), and elf-papers/ (DVI files for papers
   related to LF and Elf, including a "tutorial" and a bibliography). For
   more information, contact Frank Pfenning <fp+@cs.cmu.edu>,
   Department of Computer Science, Carnegie Mellon University.

   FRAPPS (Framework for Resolution-based Automated Proof Procedures) is
   a portable resolution theorem-prover written in Common Lisp. It is
   available via anonymous ftp from a.cs.uiuc.edu:/pub/frapps [128.174.252.1].
   If you take a copy of FRAPPS, please send a short note to Prof.
   Alan M. Frisch <frisch@cs.uiuc.edu>.

   Gazer is a sequent calculus based system for first order logic with a
   novel inference rule, gazing, that enables the system to determine
   which of a possibly large number of definitions and lemmas should be
   used at any point in a proof. Available from the authors, Dave
   Barker-Plummer <plummer@cs.swarthmore.edu> and Alex Rothenberg
   <alex@cs.swarthmore.edu>. 

   ISABELLE-93. Isabelle is a highly automated generic theorem prover
   written in Standard ML.  New logics are introduced by specifying their
   syntax and rules of inference.  Proof procedures can be expressed
   using tactics and tacticals. Isabelle comes with 8 different logics,
   including LCF, some modal logics, first-order logic, Zermelo-Fraenkel
   set theory, and higher-order logic. Isabelle-93 is not upwardly
   compatible with its predecessor, but comes with advice on converting
   to the new simplifier.  Isabelle-93 is available by anonymous ftp from
   the University of Cambridge,

      ftp.cl.cam.ac.uk:/ml/ [128.232.0.56]

   as Isabelle93.tar.gz. It is also available from the Technical
   University of Munich, 

      ftp.informatik.tu-muenchen.de:/lehrstuhl/nipkow/ [131.159.0.198]

   The distribution includes extensive documentation, including a 71-page
   introduction, an 85-page reference manual, and a 166-page description of
   the various logics supplied with Isabelle. For more information, write
   to Larry.Paulson@cl.cam.ac.uk and Tobias.Nipkow@informatik.tu-muenchen.de.
   An Emacs-Lisp package for Isabelle by David.Aspinall@dcs.ed.ac.uk
   is available from  

      ftp.dcs.ed.ac.uk:/pub/da/isa-mode.tar.gz

   The users mailing list is isabelle-users@cl.cam.ac.uk and is moderated.

   KEIM is a collection of software modules, written in Common Lisp with
   CLOS, designed to be used in the production of theorem proving
   systems.  KEIM is intended to be used by those who want to build or
   use deduction systems (such as resolution theorem provers) without
   having to write the entire framework. KEIM is also suitable for
   embedding a reasoning component into another Common Lisp program.
   KEIM offers a range of datatypes implementing a logical language of
   type theory (higher order logic), in which first order logic can be
   embedded.  KEIM's datatypes and algorithms include: types; terms
   (symbols, applications, abstractions), environments (e.g., associating
   symbols with types); unification and substitutions; proofs, including
   resolution and natural deduction style. KEIM also provides
   functionality for the pretty-printing, error handling, formula parsing
   and user interface facilities which form a large part of any theorem
   prover. Implementing with KEIM thus allows the programmer to avoid a
   great deal of drudgery.  KEIM has been tested in Allegro CL 4.1 and
   Lucid CL 4.0 on Sun 4 workstations.  KEIM is available for
   noncommercial use via anonymous FTP from

      js-sfbsun.cs.uni-sb.de:/pub/keim/keim*

   For more information contact Dan Nesmith, Fachbereich Informatik/AG
   Siekmann, Universitaet des Saarlandes, Postfach 1150, D-66041
   Saarbruecken, Germany, or send email to keim@cs.uni-sb.de.  A mailing
   list for KEIM users is also being set up.  Send mail to
   keim-users-request@cs.uni-sb.de to be put on the list.

   MVL      -- t.uoregon.edu:/mvl/mvl.tar.Z [128.223.56.46]
               Contact: ginsberg@t.stanford.edu
               Multi-valued logics

   Boyer-Moore -- ftp.cli.com:/pub/nqthm/nqthm.tar.Z
                  rascal.ics.utexas.edu:/pub/nqthm   128.83.138.20
   See also the pub/proof-checker/ subdirectory, which contains Matt
   Kaufmann's proof checking enhancements to nqthm. 

   Nqthm-1992 is the Boyer-Moore theorem prover. The 1992 version of the
   theorem prover is upwardly compatible with the previous (1987)
   version. Included in the distribution are thousands of Nqthm-checked
   theorems formulated by Bevier, Boyer, Brock, Bronstein, Cowles,
   Flatau, Hunt, Kaufmann, Kunen, Moore, Nagayama, Russinoff, Shankar,
   Talcott, Wilding, Yu, and others. The release of Nqthm-1992 includes
   three revised chapters of the book `A Computational Logic Handbook',
   including Chapter 4, on the formal logic for which the system is a
   prover, and Chapter 12, the reference guide to user commands.  Nqthm
   runs in Common Lisp, and has been tested in AKCL, CMU CL, Allegro CL,
   Lucid CL, MCL, and Symbolics CL. Nqthm-1992 is available by anonymous
   ftp from

      ftp.cli.com:/pub/nqthm/nqthm-1992/  [192.31.85.129]

   as the file nqthm-1992.tar.Z. See the file README in the same
   directory for instructions on retrieving nqthm.  See also the 

      /pub/pc-nqthm/pc-nqthm-1992/

   directory (files README-pc and pc-nqthm-1992.tar.Z), which contains
   Matt Kaufmann's interactive proof-checking enhancements to Nqthm-1992.
   For more information, contact Robert S. Boyer <boyer@cli.com>, J.
   Strother Moore <moore@cli.com>, or Matt Kaufmann <kaufmann@cli.com>,
   Computational Logic Inc., 1717 West 6th Street, Suite 290, Austin, TX
   78703-4776.  Send mail to nqthm-users-request@cli.com to be added to
   the mailing list.

   The Nuprl Proof Development System is available by anonymous ftp
   from ftp.cs.cornell.edu:/pub/n/. Nuprl should run in any Common
   Lisp with CLX. There are also (obsolete) interfaces for Symbolics Lisp
   machines and Suns running the SunView window system. Nuprl has been
   tested with Allegro, Lucid, AKCL. For further information, contact
   Elizabeth Maxwell, <maxwell@cs.cornell.edu>, Nuprl Distribution
   Coordinator, Department of Computer Science, Upson Hall, Cornell
   University, Ithaca, NY 14853.

   Otter         -- info.mcs.anl.gov:/pub/Otter/Otter-2.2/otter22.tar.Z
                    anagram.mcs.anl.gov:/pub/Otter/
                    Contact: otter@mcs.anl.gov
                    Resolution-based theorem prover.

   RRL       -- herky.cs.uiowa.edu:/public/rrl [128.255.28.100]
                Rewrite Rule Laboratory

   See SEQUEL entry in the Lisp FAQ, part 6. 

   SETHEO        -- flop.informatik.tu-muenchen.de:/pub/fki/ [131.159.8.35]
                    Get the files setheo.info and setheo.tar.Z.
                    SETHEO (SEquential THEOrem prover) is an automated
                    theorem prover for formulae of predicate logic. 
                    SETHEO is based on the calculus of ``connection
                    tableaux''. SETHEO runs on Sun SPARCs only.  
                    Contact: setheo@informatik.tu-muenchen.de
                                
   XPNet (X Proof Net) is a graphical interface to proof nets with an
   efficient proof checker. It is available by anonymous ftp to
   ftp.cis.upenn.edu:/pub/xpnet.tar.Z [130.91.6.8]. For further
   information, write to Jawahar Chirimar <chirimar@saul.cis.upenn.edu>, 
   Carl A. Gunter <gunter@saul.cis.upenn.edu>, or Myra VanInwegen
   <myra@saul.cis.upenn.edu>.

Theorem Proving/Automated Reasoning (Problems):

   ATP Problems  -- anagram.mcs.anl.gov:/pub/ATP_Problems/*
                    Collection of ATP problems from Otter, CADE, and JAR.
                    The problems include algebra, analysis, circuits,
                    geometry, logic problems, Pelletier's problem set,
                    program verification, puzzles, set theory, and topology.

   The TPTP (Thousands of Problems for Theorem Provers) Problem Library
   is a collection of test problems for automated theorem provers (ATPs),
   using the clausal normal form of 1st order predicate logic.  The goal
   of the TPTP is to provide a firm basis for the testing, evaluation,
   and comparison of ATP systems through a comprehensive library of ATP
   test problems in a general purpose format. The TPTP includes tools to
   convert the problems to existing ATP formats, such as the OTTER, MGTP,
   PTTP, SETHEO, and SPRFN formats.  Each problem includes a list of
   references and other relevant information.  The TPTP also aims to
   supply general guidelines outlining the requirements for ATP system
   evaluation. The TPTP can be obtained by anonymous ftp from either the
   Department of Computer Science, James Cook University, Australia,

      coral.cs.jcu.edu.au:/pub/research/tptp-library/   [137.219.17.4]

   or the Institut fuer Informatik, TU Muenchen, Germany,

      flop.informatik.tu-muenchen.de:/pub/tptp-library/ [131.159.8.35]

   as the files ReadMe (general information about the library),
		TPTP-v1.1.0.tar.gz (the library itself), and
		TR-v1.0.0.ps.gz (a postscript technical report about the TPTP).
   The TPTP is also accessible through WWW using either of the URLs

      ftp://coral.cs.jcu.edu.au/users/GSutcliffe/WWW/TPTP.HTML
      http://wwwjessen.informatik.tu-muenchen.de/~suttner/tptp.html

   Additions and corrections may be sent to Geoff Sutcliffe
   <geoff@cs.jcu.edu.au> (Fax: +61-77-814029) or Christian Suttner
   <suttner@informatik.tu-muenchen.de> (Fax: +49-89-526502).  If you
   would like to be kept informed of new versions of the TPTP, please
   send email to either of them.

Truth Maintenance:

   The truth maintenance system and problem solver implementations
   described in the book "Building Problem Solvers" by Ken Forbus and
   Johan de Kleer are available by anonymous ftp from

      	multivac.ils.nwu.edu:/pub/BPS/
	parcftp.xerox.com:/pub/bps/ 

   For more information send mail to Johan de Kleer <deKleer@parc.xerox.com>.
   Send bug reports to bug-bps@ils.nwu.edu.

-----------------------------------------------------
Subject: [6-14] Search

Search:

   AISEARCH is a C++ class library for search algorithms implemented by 
   Peter Bouthoorn <peter@icce.rug.nl>. It includes implementations of
   DFS, BFS, uniform cost, best-first, bidirectional DFS/BFS, and AND/OR
   DFS/BFS search algorithms. It is available by anonymous ftp from
   obelix.icce.rug.nl:/pub/peter/ as aisearch.zip or aisearch.tar.Z.

Simulated Annealing:

   ASA (Adaptive Simulated Annealing) is a powerful global optimization
   C-code algorithm especially useful for nonlinear and/or stochastic
   systems. Most current copies can be obtained by anonymous ftp from

      ftp.alumni.caltech.edu:/pub/ingber/ASA.tar.gz [131.215.48.62]

   an uncompressed version, asa, also is in that archive.  There are several
   related (p)reprints in the Caltech archive, including sa_pvt93.ps.Z,
   "Simulated annealing: Practice versus theory." The first VFSR code was
   developed by Lester Ingber in 1987, and the reprint of that paper is
   vfsr89.ps.Z, "Very fast simulated re-annealing".  If you cannot use
   ftp or ftpmail, then copies of the code are also available by email
   from the author at ingber@alumni.caltech.edu. To be added to the
   mailing list, send mail to asa-request@alumni.caltech.edu.

   The VFSR code was made publicly available in 1992 under the GNU GPL, by
   Lester Ingber and Bruce Rosen.  The last version of that code before
   the introduction of ASA is available via anonymous ftp from
   ringer.cs.utsa.edu:/pub/rosen/vfsr.tar.Z.  Bruce Rosen has a comparison
   study, "Function Optimization based on Advanced Simulated Annealing,"
   which is available via anonymous ftp from
   archive.cis.ohio-state.edu:/pub/neuroprose/rosen.advsim.ps.Z.
   [VFSR is no longer supported, but ASA is. --mk]


________________________________________________________
Subject: [6-14] Constraint Satisfaction
   
   COMERCIAL PRODUCT COMERCIAL PRODUCT COMERCIAL PRODUCT 

   Koalog Constraint Solver. Koalog Constraint Solver is a
   constraint solver written in the JavaTMprogramming language.

   It provides technology for solving satisfaction and optimization
   problems, including:

    * scheduling;
    * time-tabling;
    * resource-allocation;
    * configuration:

   COMERCIAL PRODUCT COMERCIAL PRODUCT COMERCIAL PRODUCT 

---
[ comp.ai is moderated.  To submit, just post and be patient, or if ]
[ that fails mail your article to <comp-ai@moderators.isc.org>, and ]
[ ask your news administrator to fix the problems with your system. ]
