Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Path: utzoo!linus!security!genrad!mit-eddie!mit-vax!eagle!harpo!seismo!hao!hplabs!sri-unix!SHARON@SU-SCORE.ARPA
From: SHARON@SU-SCORE.ARPA
Newsgroups: net.ai
Subject: Ph.D. Oral
Message-ID: <13650@sri-arpa.UUCP>
Date: Mon, 7-Nov-83 18:20:15 EST
Article-I.D.: sri-arpa.13650
Posted: Mon Nov  7 18:20:15 1983
Date-Received: Thu, 17-Nov-83 02:37:58 EST
Lines: 45

From:  Sharon Bergman <SHARON@SU-SCORE.ARPA>

                [Reprinted from the SU-SCORE bboard.]


                                  Ph.D. Oral
          COMPILING LOGIC SPECIFICATIONS FOR PROGRAMMING ENVIRONMENTS
                               November 16, 1983
                      2:30 p.m., Location to be announced
                              Stephen J. Westfold


A major problem in building large programming systems is in keeping track of
the numerous details concerning consistency relations between objects in the
domain of the system.  The approach taken in this thesis is to encourage the
user to specify a system using very-high-level, well-factored logic
descriptions of the domain, and have the system compile these into efficient
procedures that automatically maintain the relations described.  The approach
is demonstrated by using it in the programming environment of the CHI
Knowledge-based Programming system.  Its uses include describing and
implementing the database manager, the dataflow analyzer, the project
management component and the system's compiler itself.  It is particularly
convenient for developing knowledge representation schemes, for example for
such things as property inheritance and automatic maintenance of inverse
property links.

The problem description using logic assertions is treated as a program such as
in PROLOG except that there is a separation of the assertions that describe the
problem from assertions that describe how they are to be used.  This
factorization allows the use of more general logical forms than Horn clauses as
well as encouraging the user to think separately about the problem and the
implementation.  The use of logic assertions is specified at a level natural to
the user, describing implementation issues such as whether relations are stored
or computed, that some assertions should be used to compute a certain function,
that others should be treated as constraints to maintain the consistency of
several interdependent stored relations, and whether assertions should be used
at compile- or execution-time.

Compilation consists of using assertions to instantiate particular procedural
rule schemas, each one of which corresponds to a specialized deduction, and
then compiling the resulting rules to LISP.  The rule language is a convenient
intermediate between the logic assertion language and the implementation
language in that it has both a logic interpretation and a well-defined
procedural interpretation.  Most of the optimization is done at the logic
level.