Copy Link
Add to Bookmark
Report
AIList Digest Volume 5 Issue 218
AIList Digest Tuesday, 22 Sep 1987 Volume 5 : Issue 218
Today's Topics:
Queries - Expert Systems on the Mac & KRL &
Publication Vehicles for AI & 'how' and 'why' in Prolog,
AI Tools - Object-Oriented Prolog & Procedures and Data &
Lisp Syntax & OPS5 for the PC,
Humor On the Kids Screaming Behind
----------------------------------------------------------------------
Date: 21 Sep 87 18:31:41 GMT
From: rochester!ritcv!waw@RUTGERS.EDU (Walter Wolf)
Subject: Expert Systems on the Mac
In the near future, I have to implement an expert
system on a Mac. I am aware of two tools:
1) Humble, a shell developed by Xerox which runs entirely
within a Smalltalk environment and
2) Some combination of ExperIntelligence products, such as
common OPS5, Common Lisp and the inerface builder.
An extensive graphic interface is a required part of the
system.
I would greatly appreciate hearing from anyone who knows
anything (pro or con) about these or other tools for the Mac.
Please e-mail to me -- I will summerize and post anything
of general interest.
Thanks in advance,
Walter Wolf
waw@rit
rochester!ritcv!waw
------------------------------
Date: 12 Sep 87 15:16:00 GMT
From: mcvax!unido!uklirb!spieker@seismo.css.gov
Subject: KRL-Information wanted - (nf)
Hi, there in netland!
I heard about the frame-oriented language KRL (Bobrow,Winograd). Looking
for further information about KRL since 1980 I found nothing. So I would
appreciate getting some more recent information.
Already found:
Bobrow, Winograd: An Overview of KRL, a Knowledge Representation Language
Lehnert, Wilks: A Critical Perspective on KRL
Bobrow, Winograd: KRL: Another Perspective
Thanks in advance
Peter Spieker
Universitaet Kaiserslautern
Fachbereich Informatik
P.O.Box 3049
D-6750 Kaiserslautern
West-Germany
E-mail(UUCP): spieker@uklirb.uucp (...mcvax!unido!uklirb!spieker)
------------------------------
Date: 16 Sep 87 20:54:07 GMT
From: linus!philabs!raca@husc6.harvard.edu (Rich Caruana)
Subject: Query about publication vehicles for AI
Quite a few months back I saw a posting here about the different forums
for AI publications and their citation frequencies. The posting stated
that in AI, unlike in most other fields, most publications and citations
were in conference proceedings (particularly IJCAI and AAAI). Other
fields cite journals much more heavily than conferences.
For reasons too complex and too boring to go into, I'd be very
interested in getting:
a) this original posting, or
b) a reference or source for this information, or
c) any other information regarding this subject.
E-mail or post as you see fit:
Usenet: philabs!raca
Arpanet: raca@philabs.philips.com
You can also call me at 914-945-6450 if that is easier.
Thanks ahead of time.
Richard A. Caruana
AI Department
Philips Labs
345 Scarborough Rd.
Briarcliff Manor, NY 10510
[The SIGART Newsletter had a survey of the online retrieval
services a few issues back. About half of the available AI
literature could be found in one of the common databases; half
of the remaining citations were in another. -- KIL]
------------------------------
Date: 17 Sep 87 10:43:40 GMT
From: mcvax!kddlab!icot!nttlab!gama!shako!mazda@seismo.css.gov
(N.Mazda)
Subject: 'how' and 'why' in prolog
Does anyone know how to program 'How' and 'Why' in Dec-10
Prolog? I am novice to both Expert Systems and Prolog.
Thank you in advance for your valuable info.
MAZDA, N. at ISEP, U. of Tsukuba, Japan.
------------------------------
Date: Wed, 16 Sep 87 18:25 EDT
From: Brad Miller <miller@DOUGHNUT.CS.ROCHESTER.EDU>
Reply-to: miller@cs.rochester.edu
Subject: Object oriented PROLOG
Date: Sun, 13 Sep 87 14:55:07 EDT
From: lakshman@ATHENA.MIT.EDU
Hi! Does anybody have a source code for creating objects with
inheritence capabilities and other standard stuff in PROLOG that
can be made available in the public domain ?
Jaideep Ganguly
Our HORNE system might do what you want, though it doesn't produce PROLOG, it
does produce horn clauses. HORNE is a prolog-like language, with a
sublanguage: REP that is pretty much like KL-1 but does certain things more
intelligently (in our opinion), like use e-unification to assign values to
slots which allows you to deal with the value of a slot that has not yet been
assigned better than if it were only a variable; types are supported on
objects and variables; variables can be constrained with arbitrary predicates,
etc. etc. REP objects have roles which are inherited in the type hierarchy.
(that is, if you define a type ACTION with role ACTOR and a subtype of ACTION
as, say, HIT, it will also have an ACTOR role since it's parent type does. TR
is available, send $2.50 to Gail Cassell, TR Secretary @ the phys address in
the header to this note if you want more info.
The code for HORNE/REP is written in CL using some ZL extensions, and runs on
the symbolics 7.1 or TI 2.1 systems (soon 3.0). Unfortunately, its also pretty
much unsupported: about a year ago we started to rewrite it from the ground up
to handle contextual reasoning, and provide other major enhancements, and the
result, RHET, will probably not be publically available until the spring. (on
the other hand, it may be worth waiting for: HORNE is pretty crufty being a
translation from franz and showing the stretch marks of an active research
tool of several years).
Neither are strictly in the public domain, but the non-commercial licence (for
HORNE/REP) is for a site and only $150. You are free to reuse the code as you
like. I'm not familiar with other legal details, you can ask Peg for a licence
agreement if you are interested or curious. Basically it's just something that
says we don't care what you do with it, but we are absolved of any
responsibility.
At any rate, if you were to get HORNE/REP; REP sits on top of HORNE and
produces horn clauses as I said; you may be able to play with the code and
have it produce PROLOG forms instead, though I think it does depend on being
able to create variables with types and/or constraints. (even that can be
modeled in pure PROLOG, it just might be more work than you are willing to
invest)...
Hope this helps,
Brad Miller
------
miller@cs.rochester.edu {...[allegra|seismo]!rochester!miller}
Brad Miller
University of Rochester Computer Science Department
------------------------------
Date: 16 Sep 87 20:15:17 GMT
From: nuchat!uhnix1!sugar!peter@uunet.uu.net (Peter da Silva)
Subject: Re: procedures and data
> [instead of]
>
> (+ a b)
>
> A program might look like
>
> + (2 2)
In the lisp 1.5 system on the 11/70 at Berkeley some years ago this was an
alternate input parser. You could switch to it using the ($mumble) special
function. I thought it ugly, but some people liked it. I think this was
called nlambda form, because it also deferred evaluation of the arguments
until you eval-ed them.
FORTH has a valid alternative syntax and semantics that captures some of the
flavor of lisp. You might want to look into it for ideas.
--
-- Peter da Silva `-_-' ...!hoptoad!academ!uhnix1!sugar!peter
-- 'U` ^^^^^^^^^^^^^^ Not seismo!soma (blush)
------------------------------
Date: Wed, 16 Sep 87 15:48:18 GMT
From: Christopher Dollin <kers%hplb.csnet@RELAY.CS.NET>
Subject: procedures and data
Hi
I am afraid that Eric Lee Green has become confused, mostly (I suspect) by
some of Lisp's more obscure design decisions.
Eric is correct in saying that evaluating a symbol with a procedure value (ie
a procedure as its value) should return the value of the data cell of the
symbol; indeed, in both Scheme and Vulgar Lisp, this is exactly what happens
(the difference is just in the way those values are obtained).
Eric then goes on to say:
But wait, how do we actually execute the procedure!
Lisp does this with hand-waving and head-nodding, by making programs
consist of lists, the first element of which is always assumed to be a
procedure which needs executing.
In other words, we are introducing "syntactic sugar" to work around
the problem of having to explicitly indicate what we wish to be
executed.
Well ... NO. Irrespective of language (by and large), we need some way of
indicating that a (procedure) value is to be APPLIED rather than just USED (eg
passed as an argument, delivered as a result). The Lisp convention is to
represent programs as lists (for the inconvenience of the user) and apply the
value found at the head of such a list be applied to the arguments which are
the values found in the rest of the list. This is NOT syntactic sugar;
syntactic sugar means constructs which are nice to write but can be
re-expressed within the language without the construct, and Lisp has precious
few of them.
It is true that
(defun urgh (junk foo) (blah1) (blah2))
and
(+ a b)
have the same form, although in the "defun" the arguments are literal data
and in the "+" they are expressions to be evaluated. That's because the
"defun" is SYNTAX; it defines the shape of the language, and is interpreted at
compile-time (loosely speaking) where the values being manipulated are
parse-trees. The fact that they look the same is a consequence of a Lisp
design decision that application (whether of a run-time procedure or a
syntactic processor) is indicated in the same way, viz, by the list notation.
So, to answer the questions ...
Can this dichotomy between value and execution be mended for
procedure-objects without hand-waving?
Yes. The distinction between syntactic processing (== compile-time ==
pre-process time) and execution (== evaluation == run-time) is not
hand-waving, and has little to do with procedure values.
Would requiring literal data to be quoted be too big an imposition upon
the programmer, and would it be worth the gain in expressiveness? (just
imagine macros without the mess).
Yes it would, and it wouldn't work; you can't express quote without drawing
the distinction between compile-time and run-time. No gain in expressiveness
would result. [It wouldn't make macros any less horrible, either].
The kludgy scheme doesn't help, either. For example, it requires the system to
know which symbols are procedure names in advance - the very thing that the
Lisp syntax avoids (although Vulgar Lisp persists in using the bizzare
two-value system for symbols).
In fact Scheme does NOT distinguish the evaluation of a procedure-valued
symbol from that of a non-procedure-valued object. What is DOES distinguish is
the use of an apparantly function-calling form, viz
(f x1 x2 ... xn)
where the symbol "f" is one of its built-in syntactic constructs (or a macro
in those Schemes with macros in them). And this, as I implied above, is
ESSENTIAL - in any language.
Hope this helps,
Regards,
Kers
PS Wow - a whole reply on this topic and I haven't said how much nicer Pop is
than Lisp!
(Using KMail 10-Apr-87 (Kers))
------------------------------
Date: Thu 17 Sep 87 10:40:44-PDT
From: Rich Alderson <ALDERSON@Score.Stanford.EDU>
Subject: Lisp Syntax
In AIList V5 #213, we find:
Date: 14 Sep 87 04:25:10 GMT
From: mtune!codas!killer!usl!elg@RUTGERS.EDU (Eric Lee Green)
Subject: procedures and data
...
When procedure symbols are encountered in the eval stream, they are called
with the next list in the eval stream as the parameter list. A special
prefix character is necessary to explicitly access the procedure-object,
to, for example, assign it to another variable.
A program might look like
+ (2 2)
print ( / (2 f))
Without commenting on the questions raised, I'd just like to point out that the
proposed syntax is "eval-quote" Lisp (as opposed to "eval" Lisp) extended to
non-top-level forms. An "eval-quote" Lisp, such as Lisp 1.5, is one in which
the top-level loop is defined in Lisp as
(defun top-level-loop ()
loop-top
(print (apply (read) (read)))
(go loop-top))
(NB: This is typical Lisp 1.5 programming style--"let" and friends didn't yet
exist.)
Rich Alderson
alderson@score.stanford.edu
------------------------------
Date: Thu, 17 Sep 87 10:15 EDT
From: Len%AIP1%TSD%atc.bendix.com@RELAY.CS.NET
Subject: OPS5 for the PC
Date: Thu, 17 Sep 87 10:05 EDT
From: Len Moskowitz <Len@HEART-OF-GOLD.ABATSD>
Subject: OPS5 for the PC
To: "3077::IN%\"AIList-Request@kl.sri.com\""@TSD1.ABATSD
Message-ID: <870917100518.5.LEN@HEART-OF-GOLD.ABATSD>
I reviewed TOPSI 2.0 (from Dynamic Master Systems of Atlanta, Georgia,
404-565-0771) in the August 1986 issue of BYTE. It was an incomplete, slow,
non-standard OPS5 but was reasonably priced (under $400) and useful for some
applications. A later release was supposed to include Rete but the beta
version I saw was still pretty buggy. By now though, it might be solid.
I reviewed OPS5+ (from Computer * Thought of Plano, Texas, 214-424-3511) on
Byte's BIX computer information service in June of 1987. OPS5+ is a very fast,
and complete OPS5 for the PC with useful extensions. It interfaces well with
external procedures written in C. It is also very expensive (around $1700).
You also have the option of running the Common Lisp version of Forgy's OPS5
under a PC Common Lisp, though it'll likely be slower than OPS5+.
By the way, anyone looking for a PC-based production system language should
seriously consider NASA's CLIPS, available from COSMIC (404-542-3265)for $200.
It is program number M87-11021. The documentation is an additional $17. It is
written in C and source is provided.
I'd be happy to send out copies of the reviews. Please send a large,
self-addressed, double-stamped envelope to:
Len Moskowitz
Bendix TSD
mc 4/8
Teterboro, NJ 07608
------------------------------
Date: Fri, 18 Sep 87 20:07:11 MDT
From: t05rrs%mpx1@LANL.GOV (Dick Silbar)
Subject: On the kids screaming behind
About two weeks ago someone posed the problem of the vacuum cleaner
salesman and the housewife; he was supposed to guess the ages of the
three kids knowing the sum of ages was 13 and the product equal to
the house number. Nice problem. However, Rajan Gupta points out to
me that any vacuum cleaner salesman worth his salt would have had
enough visual and audible clues from the kids screaming in the back-
ground to have given the answer right off. People on the AIList are,
I gather, not supposed to use plausible reasoning?
------------------------------
End of AIList Digest
********************
