Subject: From: AIList Moderator Kenneth Laws <AIList-REQUEST%sri-ai.arpa@CSNET-RELAY>

From: [email-masked]
Date: Thu, 24 Oct 85 16:20:44 edt

Received: from sri-ai.arpa by CSNET-RELAY.ARPA id a021261; 24 Oct 85 2:49 EDT
Date: Wed 23 Oct 1985 23:01-PDT
Reply-to: AIList%sri-ai.arpa@CSNET-RELAY
US-Mail: SRI Int., 333 Ravenswood Ave., Menlo Park, CA  94025
Phone: (415) 859-6467
Subject: AIList Digest   V3 #154
To: AIList%sri-ai.arpa@CSNET-RELAY
Received: from rand-relay by vpi; Thu, 24 Oct 85 06:27 EST

AIList Digest           Thursday, 24 Oct 1985     Volume 3 : Issue 154

Today's Topics:
  Seminars - Representation of Natural Forms (MIT) &
    LOGIN: Logic Programming with Inheritance (UPenn) &
    Database Updates in Prolog (UPenn) &
    Concurrent Logic Programming (CMU) &
    Person Schemata (UCB) &
    NETTALK: Connectionist Speech Learning (UPenn)

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

Date: Mon 21 Oct 85 09:55:17-EDT
From: "Brian C. Williams" <[email-masked]>
Subject: Seminar - Representation of Natural Forms (MIT)

           [Forwarded from the MIT bboard by SASW@MIT-MC.]

Thursday 24, October  4:00pm  Room: NE43- 8th floor Playroom

                    The Artificial Intelligence Lab
                        Revolving Seminar Series

    "Perceptual Organization And The Representation Of Natural Form"

                            Alex P. Pentland
                AI Center, SRI Int'l and CSLI, Stanford

To understand both perception and commonsense reasoning we need a
representation that captures important physical regularities and that
correctly describes the people's perceptual organization of the
stimulus.  Unfortunately, the current representations were originally
developed for other purposes (e.g., physics, engineering) and are
therefore often unsuitable.

We have developed a new representation and used it to make accurate
descriptions of an extensive variety of natural forms including people,
mountains, clouds and trees.  The descriptions are amazingly compact.
The approach of this representation is to describe scene structure in a
manner similar to people's notion of ``a part,'' using descriptions that
reflect a possible formative history of the object, e.g., how the object
might have been constructed from lumps of clay.

For this representation to be useful it must be possible to recover such
descriptions from image data; we show that the primitive elements of
such descriptions may be recovered in an overconstrained and therefore
reliable manner.  An interactive ``real-time'' 3-D graphics modeling
system based on this representation will be shown, together with short
animated sequences demonstrating the descriptive power of the
representation.

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

Date: Tue, 22 Oct 85 18:21 EDT
From: Tim Finin <[email-masked]>
Subject: Seminar - LOGIN: Logic Programming with Inheritance (UPenn)

                                Colloquium
                               3pm 10-26-85
                   23 Moore, University of Pennsylvania

       LOGIN: A LOGIC PROGRAMMING LANGUAGE WITH BUILT-IN INHERITANCE

                              HASSAN AIT-KACI
                     A.I. Program, MCC, Austin, Texas

Since  the  early days of research in Automated Deduction, inheritance has been
proposed as a means to capture a special kind of information;  viz.,  taxonomic
information.    For  example, when it is asserted that "whales are mammals", we
understand that whatever  properties  mammals  possess  should  also  hold  for
whales.    Naturally, this meaning of inheritance can be well captured in logic
by the semantics of logical implication.  However, this  is  not  operationally
satisfactory.    Indeed,  in  a  first-order  logic  deduction system realizing
inheritance as implication, inheritance from "mammal" to "whale" is achieved by
an  inference step.  But this special kind of information somehow does not seem
to be meant as a deduction step---thus lengthening proofs.  Rather, its purpose
seems  to  be  to  accelerate,  or focus, a deduction process---thus shortening
proofs.

In this talk, I shall argue that the syntax and operational  interpretation  of
first-order  terms  can  be  extended  to  accommodate  for  taxonomic ordering
relations between constructor symbols.  As a result, I shall propose  a  simple
and efficient paradigm of unification which allows the separation of (multiple)
inheritance from the logical inference machinery of Prolog.  This  yields  more
efficient computations and enhanced language expressiveness.  The language thus
obtained, called LOGIN, subsumes Prolog, in the sense that conventional  Prolog
programs are equally well executed by LOGIN.

I  shall  start  with  motivational  examples, introducing the flavor of what I
believe  to  be  a  more  expressive  and  efficient  way  of  using  taxonomic
information,  as opposed to straight Prolog.  Then, I shall give a quick formal
summary  of  how  first-order  terms  may  be  extended  to  embody   taxonomic
information  as  record-like  type  structures, together with an efficient type
unification algorithm.  This will lead to a technical proposal for  integrating
this  notion  of  terms  into  the  SLD-resolution  mechanism  of  Prolog. With
examples, I shall illustrate a LOGIN interpreter.

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

Date: Tue, 22 Oct 85 11:35 EDT
From: Tim Finin <[email-masked]>
Subject: Seminar - Database Updates in Prolog (UPenn)

                         Colloquium - 3pm 10-24-85
                   216 Moore, University of Pennsylvania

             A LOGICAL APPROACH TO DATABASE UPDATES IN PROLOG

                   DAVID S. WARREN , SUNY AT STONY BROOK

The  power  of  the  logic  programming  paradigm  (exemplified  by  the Prolog
programming language) lies in its close relationship  to  logic.    This  gives
logic  programs a clean, simple, and elegant declarative semantics, making them
easy to understand and reason about.  It has turned out, however, that in order
to   make   Prolog   a  practical  and  usable  programming  language,  several
computational (and non-logical) extensions must be  added.    These  extensions
include  the  ``not''  operator, the ``setof'' operator, the ``var'' predicate,
and the ``assert'' and  ``retract''  operators.    To  the  extent  that  these
operators  are  non-logical, they destroy the declarative semantics of programs
that use them.    Such  a  program  can  only  be  understood  by  knowing  its
computation sequence.

Progress  has  been  made  in  providing  a  logical  semantics for the ``not''
operator in Prolog, and the circumstances  under  which  Prolog's  negation  as
failure rule coincides with logical ``not'' are now reasonably well understood.
This has allowed Prolog programs which use the ``not''  operator  (meeting  the
appropriate constraints) to be understood declaratively.

This talk describes an approach to providing a logical semantics for the Prolog
operator ``assert''.  We use a simple modal logic, which leads to a  slightly
different  operational  semantics  for ``assert'' and suggests ways that the
assert operator should be restricted in application.  The resulting system  has
interesting implications for a theory of database updates.

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

Date: 22 Oct 1985 1109-EDT
From: Lydia Defilippo <[email-masked]>
Subject: Thesis Oral - Concurrent Logic Programming (CMU)

                     ABSTRACT OF THESIS PROPOSAL

Speaker: Vijay A. Saraswat
Date:    Friday - 1 November, 1985
Time:    10:00 am
Place:   7220
Topic:   CONCURRENT LOGIC PROGRAMMING LANGUAGES

The domain of logic programming languages, consists, of the most part,
of programming languages based on Horn logic which provide modified
forms of top-down, SLD-refutation execution engines.  A program in
these languages consists of a set of definite clause axioms with
(perhaps implicit) control information for guiding the underlying
engine.  Execution is initiated by the presentation of a conjunction
of goals or queries and terminates when the engine, following the
prescribed control, discovers either a proof of the goals, or the
impossibility of such a proof.  Concurrent logic programming (CLP)
languages provide execution engines capable of pursuing concurrently
proofs of each of the goals in a conjunctive system (so-called
and-parallelism) and also different possible proof paths for each goal
(or-parallelism).  Examples of existing concurrent Horn languages are
Concurrent Prolog, Parlog, GHC, Delta-Prolog and CP[!,|,&].

In this thesis I propose to lay a sound theoretical foundation for,
and explore the paradigm of, CLP languages.  Specifically, I propose
to investigate the design, semantics, implementation and use of such
languages.

The thesis is intended to make contributions to each of the following
areas:

--  programming language design, via
    --  an understanding of the design space for
        concurrent programming languages based on annotated Horn logic,
    --  the design of a paradigmatic CLP language (CP[!,|,&,;]) providing
        a reasonably complete set of control structures for the parallel
        exploration of the refutation search space, and,
    --  an extensive comparison of CLP languages with related
        computational models outside the realm of logic programming,
        such as Actors, CSP, data-flow languages (including the
        systolic computational model) and constraint-based languages

--  theoretical computer science via an understanding of the formal
    (operational and denotational) semantics of, and reasoning systems
    for, concurrent logic languages, including an understanding of
    the `logic' in such languages,

--  programming language implementation, via a compiler-based
    implementation of the specific concurrent language CP[!,|,&]
    targetted to a uniprocessor machine,

--  the `correct' design of efficient concurrent algorithms in the
    framework of unification-based concurrent logic programming
    languages,

--  knowledge representation languages, via the design of a
    `higher-level' object-oriented, schema-based language
    featuring multiple inheritance with exceptions, and its
    implementation in Cp[!,|,&].

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

Date: Wed, 23 Oct 85 13:52:25 PDT
From: [email-masked] (Cognitive Science Program)
Subject: Seminar - Person Schemata (UCB)

                   BERKELEY COGNITIVE SCIENCE PROGRAM
                              Fall 1985
                  Cognitive Science Seminar - IDS 237A
                   Tuesday, October 29, 11:00 - 12:30
                     240 Bechtel Engineering Center
               Discussion: 12:30 - 1:30 in 200 Building T-4

                          ``Person Schemata''

                         Mardi J. Horowitz M.D.
                    Professor of Psychiatry, U.C.S.F.

          The speaker directs the recently formed Program  on  Cons-
     cious  and  Unconscious  Processes of the John and Catherine T.
     MacArthur Foundation.  Research on person schemata  is  one  of
     the core agendas of this program.
          After a brief description of the program,  the  discussion
     will  focus  on  clinical  phenomena  as segmented by different
     states of mind in a single individual.  By examining the confi-
     guration  in  each state of mind as it occurs over time, it may
     be possible to infer what the self schemata and role  relation-
     ship  models  are  that  organize thoughts, feelings and action
     into observed patterns.  The theory that forms  the  basis  for
     such  inferences  includes  the  postulate  that  each person's
     overall  self  organization  may  include  a  partially  nested
     hierarchy  of multiple self-concepts.  A frequent set of states
     of mind in pathological grief reactions will provide a concrete
     illustration  of  phenomena, methods of inference, and a theory
     of person schemata.

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

Date: Wed, 23 Oct 85 16:43 EDT
From: Tim Finin <[email-masked]>
Subject: Seminar - NETTALK: Connectionist Speech Learning (UPenn)

                   Colloquium - University Of Pennsylvania
                           3pm 10-29-85, 216 Moore

           NETTALK:  TEACHING A MASSIVELY-PARALLEL NETWORK TO TALK

                            Terrence J. Sejnowski
               Biophysics Department, Johns Hopkins University

Text  to  speech  is a difficult problem for rule-based systems because English
pronunciation is highly context dependent and  there  are  many  exceptions  to
phonological   rules.      A   more   suitable   knowledge  representation  for
correspondences between letters and phonemes will be described in  which  rules
and  exceptions  are  treated  uniformly  and can be determined with a learning
algorithm.  The architecture is a layered network  of  several  hundred  simple
processing  units  with several thousand weights on the connections between the
units.  The training corpus is continuous informal speech transcribed from tape
recordings.   Following training on 1000 words from this corpus the network can
generalize to novel text.  Even though this network was not designed  to  mimic
human  learning,  the development of the network in some respects resembles the
early stages in human  language  acquisition.    It  is  conjectured  that  the
parallel  architecture  and  learning algorithm will also be effective on other
problems which depend on evidential reasoning from previous experience.

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

End of AIList Digest
********************