noeeeehe ehmmheeeeeeeeeeal - dtic · naval postgraduate school monterey, california 93940 11....
TRANSCRIPT
AD-AlGA 586 NAVAL POSTGRADUATE SCHOOL MONTEREY CA FIG 9/2
CONDITION RECOGNITION FOR A PROGRAM SYNTHESIZER.IUI N
UNLSIID JUN Al J S LAPE. C W MI LLER
USIEIEEEEEEEE
NOEEEEhEEhmmhEEEEEEEEEEAl
0NAVAL POSTGRADUATE SCHOOLMonterey, California
THESISCONDITION RECOGNITION FOR A
PROGRAM SYNTHESIZER
by
Joseph Shawn Lapeara id'
Charles Wayne Miller
June, 1981
Thesis Advisor: Douglas R. Smith
Approved for public release; distribution unlimited
k __9_2__0%
SECURITY CLASSIFICATION OF THIS PAGE (Uhum bag. Soto)___________________
REPR OCUMENTATION PAGE NUMBS TRU~TIfNS ORI. R9PORT NUNNE 12. OOVTACCESSIO it. L RCIP~INT CATALOG mNMBER
4. TITLE (awaug ucEle) I. TYPE or REPORT S, PERIOD COVERED
Condition Recognition for a Program Synthesizer Juner' 1981 is
S. PERFORMING ORG. REPORT NUMER
7. AUT040OR(sj 6. CONTRACT OR GRANT NUMSCRI.)
Joseph Shawn LapeCahrles Wayne Miller
9. PERFORMING ORGANIZATION NAME AND ADDRESS 10. PROGRAM ELEMENT. PROJECT, TASKAREA A WORKC UNIT NUMBESA
Naval Postgraduate SchoolMonterey, California 93940
11. CONTROLLING OFFICE NAME AND ADDRESS 12. REPORT DATE
Naval Postgraduate School June 1981Monterey, California 93940 13. NUNBER1OF PAGES
14714. MONITORING AGENCY NAMEK & ADORIESS0lI differen h Cag~ifI1i1d O0111*0 IS. SECURITY CLASS. (of this raper)
Unclassified
160. 21JCk ASSIFIC ATIOk/ DOWN GRADIN4GNDULE
IS. OIST RIBUTION STATEMEN1T (of this Rea4J
Approved for public release, distribution unlimited
17. OISTRIBUTION STATEMENT (of do@ abstrimi entere~d Ia o , It different. *4 M~)
IS. SUPPLEMENTARY NOTES
IS. KEY WORDS (Cagglm.. a~ v"idea i naaaaamW end 5Idielp A k ber)
program synthesis, automatic programming, conditions, example computation,static processing, dynamic processing, miniterms, character set hierarchy,condition recognition
20. ABISTRACT (C4stMa On... 0041 1 Odd 10 1060605' Ai #~*Irby AS'Aell -o)
-An enumeration algorithm which synthesizes programs from examplecomputations is presented. The algorithm, originally proposed by Alan W.Biermann of Duke Ualiversity, assigns a labelling of the instructions containedin an example trace consistent with producing minimum state Moore machinerepresentations for the synthesized programs. Techniques for processing theinformation to reduce enumeration are given. Biermann' s algorithm isextended by trace preprocessing techniques which identify and generalize
00 IAN11473 C0OITION OPl I NOV #6 If OB0SOLETE(Page 1) SIX 0102-018-4*01
SECURITY CLASUIFICATION OP THIfS *AS# eln =70=1000,0
conditions on instruction sequencing in the synthesized programs without theuserfs assistance. The techniques are presented using text editing as thedomain, but are general enough to be extendable into other domains.
Acressol orNTIS AI
DD orvM 1472 2S/14 IFA'b2%l4-601 sge9 CAWUIC66*ION@ Oi ?IS &afbbe&#*d
6.*-~-
Approved for public release; distritution unlimited.
CONDITION RECOGNITION FOR A PROGRAM SYNTFESIZER
by
Charles Wayne MillerCaptain, Uinited States .Marine CorpsB.E., Vanierllt University, 1472
and
Josepn S~nawn LapeCaptal.., United States Marine CorpsB.S., University of Louisville, 197b
Submitted in partial fufi'lilment of tnerequirements for tne degree of
MASTER OF SCIENCE IN CO' PUT;P. SCIENCE
from tne
NAVAL POSTGRADUATE SCHOOLJune 19EI
A u t h o r s _ _ _ --- -------
Approved by: -- - -- - - -- - -
-- - -Se -n- - -- -r
C- a no epartm Comuter Science
U LDean of Inor mation and Policy Sciences
3
ABSTRACT
An enumeration aleoritnm whicn synthesizes prorrams from
example computations is presented. Tne alporitnm, originally
proposed by Alan i. Biermann of Duie University, assiens a
laoelling of the Instructions contained in an example trace
consistent with prolucing minimum state Moore macnine
representations for the syntnesized programs. Tecnniques for
processing the information to reduce enumeration are given.
Blermann's algoritnm Is extended by trace preprocessing
techniques wlich identify and generalize conditions on
Instruction sequencine in tfe synthesized proarams witnout
the user's assistance. The techniques are presented using
text editing as the domain, but are general enough to be
extendable into other lomains.
4
TABLE OF CONTENTS
I. INTRODUCTION ---------------------- 1
A. BACKGROUND -------........---------- .. 1v
B. AUTOMATIC PROGRaMmING ----------- ----------- 16
1. '4enerai ------------------------------ 16
2. Problem Specification witnt Natural Languaze -19
3. Formal Problem Spezification -------------
4. Input-Output Pair Specification -------------
5. Example Computations .------------------------ b
5. A General Automatic Programmer Desipn ------- 29
C. OBJECTIVES ------------------------------------------ 2
D. THESIS ORGANIZATION ------------------------------- 3
II. SYNTHESIZER --------------------------------- 5
A. GOALS ------------------------- 5
B. OiEREE --------------------------------
1. eneral Description ------------------------- 36
2. Trace Coline ---------------------------------
3. Innut/Output Trace Renresertation -----------
C. SYNTHESIS PROCEDURE ------------------------------ 7
1. Function ---------------------------- 44
2. Concepts -------------------- 45
D. SYNTHESIZER STRUCTURE --------------- - ---- 52
1. Static Processing ------------------ 52
2. Dynamic Processing ----------------------- 57
a. Label Assignment ------------------------ 59
b. Difference Set Resolution --
5
c. Dynamic juivaience --
. 5acxup/t1xup -- 7Z
III. ?~P~i3S?------------------------------------------
. &PR L1ZR 3nEIPI T N -,
~.DFSI1N FOR A CCJNTEZ F~ --------- 7
1. overview -- - - - - - - - - - - - - - - - - -U
2. Stru-tur- ot tne Condition Pre;c-sscr -
3. Preprocessor Data Strur. .re5 --
4. Implementation ------- ----------
C. DESI N FOR A CONTE XT SVJSITIVE WViRO -1 N' .... - ----
1. Cverview -- - - - - - - - - -- - - - - - - - 7
2. Implementation ...- Iiz
1V. CONCLUSIONS AND RECOMMEND&TIONS --------------------
A. SYNTFESIZEh --------------------------------------
B. CONDIrION PROCESSING ---------------------------11
AFFENDIX A: FRO0,RAM LISTING- F0 SYNTHESIZE -------------- 1
lIST OF EFERENCS----------------------------------- ----- 4
I'JITIA! D13T1HI '0TT11X LIST -----------------------------------
NOE.6
LIST OF FI:UES
1. In i ti a i i z e (I Se q u e n t f'o r tnie S o :a re R oo t P r ,)rle -i -. .-----
?. An '1rapti Co.ruta onr---------------------------------,
~.PIpu Mora ---------------------------------------*. Input Tra-e -
5 cn-4etermiirist,: Voore Macalnre ....-- "
C. Deter-rinisti- Moore ' acni - - --
7. Instruction-Conrit ion-Instruct i cr Triple --
. C.aininq of Difreren-e Set Reiatio a
Y. Non-leterin1stic Input Trace -7
1Z. Deterinistic Trace -- e'
11. Strain1tt-line Program --
12. Minimum State Machine --
13. Ilnstruction Set Lower 5 --oss --- I
STypici Input to -tatic i-rore- sor -------------------
15. "oore acmine for Input Trace ----------------------- ,
1. Inter-ediate Tra'e Tare ----------- ----------------
17. TraceTa ------------------------------------------
2- . Partial Trace Laeiin ------------------------------.
IY. Partially Determinec. "oore "acaire -,--------- ----
2'. Trace Taole/Failure Memory Confip-uratio: for a
Forcel Assienment--------------------------- --------
21. Trace Table Entry Snowi_ Aritrary
Assion7ient etnoa ------------------------------------
7
22. Nondpter~inistir! InDUt Trace ------------- 6
23. Trace rable/Faliure memory Conf'iguration
After Assieni"ent at thle Fourth Level -------- 5
24. Nondeterministic Pref'ix Label Assignment -------- l
2b. Trar*e Tatle/Failure Meoy-------------7
?6. Computation Without Ezpiicit Conditions-------------- 76
27. Computation 'ditn Explicit Conditions ---------76
29. Svnttesizer Action ------------------- 1
?9. ASCII Ve,:tor ---------------------------------------- b
30~. Default Hierarcmyv----------------------------------- 2
31. Moditted Hierarchy -- ----- ----- -
3?. Format of Transition Table ------------------------ 3
33. Monitor Output -- ----------------- ------- 9
34. Completel Transition Table -------------------------- 93
35. Condition for "Time" and "time"----------- ------- 99
8.........
ACKNOWLEDGEMENT
We wisn to acicnowi ege Alan 'w. Blermann for tte extra fte i
ttat P e f urnis feI u5 while we were doing the researcn rcr
this thesis, and for the insigtts wnict te gave us on
!rethods of proerammine by example.
IJ
I. INTRODUCTION
A. SACCGROUND
Since the introduction of electronic computine macnines,
manual tasks that are mundane, tedious ani/or repetitious
nave been considered for automation. The computer is iaeally
suited for tnls type work since it neitner complains c±*
boredom nor wanders from its assigned task. Tne macnine
meticulously sequences throuzh a series of' computations over
and over, producing answers consistent witnin tne
limitations of the hardware. &s consistent as tfle computer
is at performing tasks, assigning tne tasks is still left to
the user of the system.
Programming the early macnines was a difficult chore.
Communications between man and macnine were only
accomplishable through the language of tne machine. This
machine language consisted of binary coaei iacnine
operations. Tae efficient macnine language programmer had to
memorize these codes or Keep a list of the codes close ty.
All control transfer points had to be coded in atsolute
macnine addresses wlich tne programmer calculated by qant. A
prorrammmer had to interpret the binary representation of
the machine operations to determine tne cause of errors in
protrams. There were no diacnostic messages to aid tne user
in isolating errors. The difficulty of programming in
m3.nine lanpuaee led to a searcn to rini better way5 cf
generating prorrams. ?ne first step was tne recor~tlon tnat
tfe computer was a zool boo geeper. capable Of computinO
absolute addresses from labels and translating mrnemoni -
representations of" machine operation codes. Wetster's New
Word Dictionary, Second Edition, defines mnemonic to te, a
system or tecnnique of Improving memory by tne use of
certain formulas. Soon proerams were written wnicn would
accept abstract programs containing mnemonics and labels,
convert the mnemonics into macnine operation codes and
translate tne labels into absolute macnine ad .resses. Tiese
programs produced executable macnine ianguage co(4e as
output. These translation proerams were called assemblers
and the data tney translated were called assembly larguage
programs.
Assembly language provided some automation of tne manual
tasts associated witn machine lanouaqe propramminz. An
important convenience of assembly language Is tae
readability of the prorams wnen corparel tc Tacni.e
language programs. The mnencmics convey tne meaning of treir
function wnile tne labels relieved tne proprammer o
calculating absolute addresses for control transfer points.
Assembly language provided a level of abstraction wnicn
allowed prorrammers to concentrate on tne proprammine
problem witnout dealing witn every atomic macnine operation.
The assembler provided booieepinR, address translation and
11
mneumonic iecodlng fast and efficiently. Programmers were
now capable of producinz more code in less time witn *ewer
errors with assembly language.
Assembly lanruaee eased tae programmers tasT but it
still could not be considered a panacea for -omputer-rurran
interaction. Assembly language still required tne programmer
to maintain control over many macnlne operations and ne nad
to provide tne logic to control tne flow o program
execution. The instructions used to perform contrcl
functions appears as similar code fragments in most programs
written in assembly lanauare. These code fraernents per'orrred
fuctions such as controlling brancning decisions and Keeping
count of loop indices. When it was observed that co-7mon code
fragments appeared across a wide range of assembly programs.
it was recognized tnat tnese code fragments could te
represented as a single Instruction and the computer could
translate tne single instruction into tne code fragment it
represented. The prorrams that translate these -omplex
instructions are called compilers or interpeters. Tne
complied or interpeted lanpuares that followed assembly
language in this evolutionary process incorporated the
prowram fraements as a silnle instruction for tne language.
Constructs sucn as FOR, DO WHILE and IF THEN are examples cf
nigner level control structure implementation.
FORTRAN was the first in a lonR line of" hiefner level
languages. FORTRAN differed from tne others by oecomIng
i2
endeared to a family of users and the lanpuaee endures today
as one of the most frequently used nigher level languages.
What aualities of tfe lantuaze produced tnis popularity?
The FORTRAN language is attributed to Jonn Backus. Fis
primary goal when lesigning tne lanpuage was to mare tne
language resemble the notation used in nign sclool alpeora.
Since the notation used in nign school alebra was familiar
to a wide audience, FORTRAN zave a friendly appearance. Tte
language's apparent simplicity is tne endearing quality of
FORTRAN. Some other lanouage Implementors failea to
recognize tais point and tneir languages never received wide
acceptance. ALGOL is an example of a powerful language tnat
never received the acceptance anticipated.
Otner programming languages tnat followed added ccmpact
representation of otner recurrine proRram fragments. The
higher level constructs were not limited to control
structures but also included constructs for tata
manipulation functions. Iverson's [11 APL (A Programmirg
Language) provided powerful operators capable of performing
complex functions such as matrix multiplication in cne
instruction.
This trend continues today. Many of tne newer lanruares
implement sophisticated and powerful operators and control
structures. Some of these languages are for a select sewment
of computer users, intended for application to a particular
domain. The users are expected to be familiar witfl the
13
domain, so tne form of tne language snould te familiar to
the user also. A problem witn a domain specific lanruace is
its inability to adapt to otner areas. To work in anotner
area the user must become farriliar with another lanzuaee. A
phenomenon demonstrated by many computer users is a
reluctance to adapt themselves and learn a new lanpuace tnat
may be more appropriate for a given task. Eitner they break
the egg witn a sledge nammer or dip the well witn a spoon.
When required to use a new languape, the user will lizely
use only a small subset of tne language tnat is capatle of
doine the job. Worst than usine only a subset of tne
language features is the tendency to bring old programming
styles applicable to tne old language into tne new language.
The point that is to be made is ttat learnine a new
programming language is a nard chore and is avoided wnenever
possible.
Another direction wlicn tne automation of progranming
tasks nas taken is the development of a proerarrinz.
environment. A programming environment automates soie of tfe
manual chores by providiln the user with aids that assist
him in constructing programs. The environment includes a
proeramiine laneuare, an interactive syntax--directe! editor
and an on-line debugger. Tne editor provides syntax error
diagnostics vnlie the proRrammer Is creating tne source
file. The prowrammer is forced to correct the syntax error
immediately before the editor will allow him to continue
procrammine. The error should be readily apparent to tne
programmer because it is in tne latest input. The on-line
debuaner allows the prorrammer to actively test nis proeram,
halt execution, cnecic tte value of variables, ctange the
value of varia0les or cnange tne code itself. Prok;ram
environment systems may even allow tne programmer to swit'n
from tne tne editor to tne on-line debugger and baci at any
time. A procrammine environment can be summarized as a
friendly interface utilizing an intelligent editor wnich can
recornize syntax errors in the associated prograirming
language and one tnat contains otner Interactive prcgramrnlng
tools.
Programming has been called an art form requirine
Intellectual creativity. Tne automation of Intellectual
behavior is a field of study within Computer Science called
Artificial Intelligence. The study of tne automation ef
proerammine tass which require human-liKe reasonInip is
called Program Syntnesis or Automatic ProgramminR. It is nct
our intention to provide a definition of intelligent
behavior for a macnine since tnere is (ons lterable
disagreement even among tne experts. However, we note that
tne goal of researcn in automatic programming is tne same
goal thnat led to all vne advances in programmine laneuaRes.
Informally, tnis goal is to male the interaction tetween man
and computer as painless as possible. That is, painless for
tne man but not necessarily for tne computer. DliJrstra (2J
objects to our automation of proerammine by clairine, ge
Stould not automate prograiming even if we can, oecause it
would tare away our enjoyment of the tasK. We note tnere
are those wao may require the use of computer services trnat
nave neitner tme time nor inclination to Obtain tne required
education to do thnat cnore. These Include professions su-h
as lawyers, pnysicians, and even tneoretical pnysicists. We
assume, if proerammine be-!omes fully autoratel, tne
programmers will then turn tneir attention toware. otner
creative and stimulatinz pursuits. R. ?ammin nas said. "The
purpose of computing is insignt not numbers."
Many on-going efforts are aimed at providing better
systems for the user so ne may create prorrams faster, with
less errors and wita Less effort. Tne nistory of programring
lancuace development nas shown that automation of many
programming tasts is feasible. HIow mucn more of te
prorrammine tasts can be alutomatea? What would re considered
the ultimate system for producing computer programs?
B. AUTOMATIC PROGRAMMING
1. General
Prorram syntbesis or automatic prozrarrin Is a
research topic concerned witn the development of system's
that provide more and more automation of tne proRramiring
process, particularly those tasics requiring numan-lile
reasoning. The goal is not to create systems tnat proiram
themselves, but to create systems wtich can construct, under
ih
the direction or a user, prozrams that can perform some
function ne desires. These systems must be easy to use, easy
to learn, and increase the exiciency or the user. The users
of these systems will no longer be restricted to tne few
computer professionals, but will include otner professional
fields as well as non-professionals. Automatic prcgrammir.r
systems are to interact with tne user, recognize
'rejuirements, and then synthesize a correct proaram tnat
satisfies the requirements.
Two questions arise in tne researcn on automatic
programming. First, wnat is tne form of tne interaction
between the user and the system? This question is called tne
specification problem because it is concerned with issues
relatine to how the user is to Inform tne system of nhis
requirements. The second question is, given a specification
method, what syntnesis tecnnique is available to be applied
that will transform the specification into an appropriate
program. The tecnnique used for syntnesis is often aependent
upon the form of tne problem specification and most of tne
projects involvine automatic programming consler bOth
problems toretner. It has been proposed by Green [3J tnat
the two questions snoull be separated with research
proceedinr concurrently on both problems. He proposes tnere
is a standard intermediate representation of tne problem
specification whicn would permit interaction between the two
problems.
17?
Four tecnni4ues nave been proposea for tne
specification problem wnicn dominate tne literature on
automatic programming. Eacn of the proposed te-nniques of
problem specification Introduce a different approacn to tne
syntnesis problem. The four specifliation tecnniques can be
categorized as follows:
1. Natural Laneuaee.
2. Formal Problem Specification.
3. Input-output Pairs.
4. Example Computations.
.ach of these specification tecnniques will be dicussed in
tne following subsections and tne relationsnip to a
synthesis approach will he discussed.
2. Problem Specification with. Natural Language
A visionary approach to the speciflcatlon problem is
the use of natural language. Natural language provides a
fast, comfortable metnod of communication wnicn is already
understood by numans. Implementation of' a natural lanRuape
understanding system has proven to be a very di:'flLut
problem (Glass 14j).
Two forms of natural language are the spogen form
and the written form. Understandine spoKen lang,.age
Increases the degree of difficulty because tne communicaticr
Is in the form of audio waves. Once the audio Input Is
captured, it must be converted into another form for furtner
syntactic and semantic analysis. The reader will note tnat
18
once the audio input has been captured and convertet the
problem of written 3nd spoken ianeuage becomes tne same.
That is, the internal representation of tne spoken and
written word can be tne same and tne problem becomes one of
inferring meaning from the representation. Future advances
in voice unaerstanaing nardware can be expectec and tnese
alvances may be expected to find tneir way into use.
A complete natural lanzuage understandinz system
would be expected to be able to understand all Prarmatizally
correct sentences. However, natural languages to nct nave
finite zrammars. This complexity implies a coTplete
understanding system cannot oe implemented. However, a
system capable of understanding a subset of natural language
can prove useful in specific domains. Early examples of
programming znrougn natural language dialogue is presented
in a survey by Heidorn (5]. Curren, work on understandin,
natural language may be found in Piermann [5J, and Walker
17].
In conclusion natural language understanding is a
difficult problem that can De solvel only in limited
domains. The use of natural language in programming ta been
shown to be possible by Heldorn [bJ, and by Biermann [6j in
limited domains. The systems developed up to today nave been
experimental systems and tne results will aid in
understanding the problem. Natural language prcerammine
systems will not be available for Industry for at least a
19
decade. Finally, we present the example Piermann t£]
describes as a natural language specification for a problem.
Tnis example is quoted from his paper on natural lanp'vaoe
programming. Its intent is to give a feel for proerammine in
natural language. Tnls example does not specify tne
aleorithm that is to be used althouen a natural lanzuaee
programming system would be capable of accepting suct a
specification.
"Wnen I asi for a status report on adoctorial student, eive me his or ner yearin grad school, source and amount offinancial support, and wnicn core examshave been passed. If the student has becuna tnesis give me tne advisor and tnesistopic.
3. Formal Problem Snecification
The second tecnnique is formal specification of tne
problem. &s the name implies, tne input is in a more rigid
structure than natural language. Tnis tecanique allows tne
user to convey the benavior ne deslres tne syntnesized
program to nave without specifyine the alporithm ttat is to
be used. Smith [9j gives tne following definition for tne
form of a formal specification of a problem A."A(W) = z such that z c S & P(z,x) wnere x c D &I(x) wnere D and S are the input and output datatypes respectively, and I and P are tne input an.output conditions respectively.
An example of a formal problem specification for a program
to compute the intewer square root of a nonnegative inteeer
n may be found in Manna and 'aldinger [9].
20
"sqrt(n) <== FIND z SUCH THATinteger(z) & z*2 =< n < (z 2) 2WHERE inte~er(n) N 0 =< n
In the above example n Is an element of tne input data type,
z is an element of the output data type, sqrt is tte problem
name, integer(n) . 0 =< n is tne input condition, and
integer(z) 6 z**2 =< n < (z+l) * 2 is tne output conaition.
Formal Droblem specification and its appli:ation to
tne program synthesis prociem can best te explained tnrou'n
examination of the work by Manna and Waldineer [9], Manna
and Waldinger (10], and Smitn [9]. Althougn all of tne worK
is similar in that the formal specification is cnanzed into
an appropriate program by some form of rewrite. It is
valuable to differentiate the approaches by their rewritinw
methods.
The first example is tne system of Manna and
Wallinger [9]. Their system, called a deductive approach,
converts the formal specification into a proran, in soTe
target language. Tneir approacn, "combines tecnniaues of
unification, mathematical induction. and transformation
rules into a single system." The following is an brief
explanation of this conversion.
A structure is needed to contain initial and
intermediate results of the conversion process. Tnis
structure is call a sequent. The sequent is a tableau
containing two lists. The first list is a list of assertions
and the second list is a list of goals. Each element in
21
eltner list may nave an output expression associatec witn
it. Figure 1 represents a sequent as a tahle. Eafh row in
tne table nay contain eitner an assertion or a goal but not
both. Firure 1 is tne initial sequent for the integer square
root problem given above. Tne input condition nas been
placed in tile assertion list and tne output condition placed
in tie goal list. Tne output variable is associated wItn tae
output condition in tne output expresssion column. Tnis
initiation action assumes tie input condition is true and a
search is attempted for tne trutn of tne goal or output
condition.
sqrt(n) <== FIND z SUCH THATInteger(z) and z**2 =< nand n < (z+l) *a 2WHERE integer(n) and 0 =< n
Assertions t Goals Output I
sqrt(n)
inteper(n)ana
integer(z)and
z**2 =< n zand
-n < (z+i)
Firure 1. Initialized Sequent for the Square Root Probler"
22
Durin tnis searcn if the sequenT ever contains a row where
the assertion can te trivially shown to be false or tne eoml
snown to be true anI If' the output expression for tnat row
contains only primitives from the tareet lan ,uace then tne
output expression is taKen as tne lesired syntnesi~ed
propam.
Once the tableau is initialized, tne syster, 's
deductive rules are applied to the assertions and eoals. The
application of these rules will cause the creeaticn of new
assertions and coals and associated output expressions. Tne
rules may tten be applied to the new goals and assertions
untl tne condi tion for a program is satisfied. The
application of the rules chance tn entries in tfe tableau
withnout cnanging Tne meaning of tne tableau. We recommend
that the interested reader review tne original worK for a
description of tne rules and their application.
The attraction of tals taneorem-provinR tecnnique is
that tie resulting program can be prcven correct by the saTe
steps used to create it. Currently there is not a running
Implementation of tnis technique. One or tne implementation
questions is letermining wnat rule to apply at eacn step in
the synthesis process. This problem can be viewed as a
search through all possible sequences of rule applications.
This search space may become astronomical for any relatively
complex program since it may require hundreds of rule
applications. dnat is needea is a mecnanism tnat can control
23
the search in a reasonable fasnion. Tne rorm or control 7,ay
be neuristic in tnat tnere is a feel for wnere a rule sncUid
be applied. If this intuitive feel :an be quantized, tnen
this tecnnique may become practical.
Earlier wort by Manna and Waldineer [10J on tne
DEDALUS automatic programing system also required formal
problem specifications. Tne DEDALUS system, an imple'iented
automatic procrammine system, utilized only transformation
rules. A tranformation rule simply rewrites a portion of tne
specification into another equivalent form. The continuous
application of these rules would eventually result in a
proeram in the tarret laneuake.
4. Input-Output Pair Specification
Input-output pairs is a metnod of descritinp a
problem witn examples of input and output behavior. For
example, if someone wanted to lescribe a proeram to compute
tne Fibonacci numbers tnen tie could supply tne input-outpost
pairs.
(I, i)(2. 3)(3, b)(5, 9)(8,13)
The goal of a synthesizer system is to determine the
desired program from the examples of the input-cutput
behavior. One approach is to enumerate all possible programs
in the target language in order and test ea-h prorram for
thne desirel behavior. That is, test eacn enumerated proirem
24
by rivine it tne input from each of' the examples ana see if
tne program will Rive tne associated output. Tne enumeration
will produce the correct propram at sore poirt tut you
cannot determine if an arbitrary program can ircauce tne
desired behavior (see 7iermann [111 }. Tnerefore, the
following taeore is given by Piermanr, "Tne programs ft'r
tne partial recursive functions cannot te generated from
sample of input-output behavior. A large class of programs
may be inferrea from examples of input-output pairs provided
they belone to the class of procrams where tne naitin
problem is lecidable. Smitn (121 an - Summers [13] nave
looted at the synthesis of LISP programs for example
input-output pairs. It has been shown that a restricted
class of LISP procrams can be synttesized from example pairs
without enumeration over tne class. The reader is irvitec to
review Biermann (14] and Gold (151 for tneoretical
background information.
5. Example Computations
Program specification using example ccmputations
allows more information to be obtainel from tne user. An
example computation is a sequence of instructions, without
an explicit control structure, which tne user provides tie
system in order to describe the benavior ne wants from a
program. Vxamples are a good communication metnod wni'n
people use to describe new concepts or explain new
processes. To describe a problem to the computer the user
25
uses tne available instructions and provides an example of
what he wants done. Figure 2 snows an example computaticr
tnat demonstrates now to compute tne first 1I Fitonacci
numbers.
In Figure 2 the two operand Instructions f OV. ADr)
perform the action on the two operands and leave the result
in the first operand. For example, it A = 2 and B = 3 tnen
ADD A,B would result in A = b and B = 3. All of tne
instructions perform action on some variables execpt for the
START, HALT, and NOTE instruction. START and BALT flag tne
begin and end of the program respectively. The NOTE
instruction is providing information on the reason for tne
execution of tne next instruction.
This metnol of specification depends on tne user to
supply more information about tne problem, Includine the
algorithm to be synthesized. The algoritnm is implicitly
defined by the example computation that is Riven. Ttis
specification technique should be contrasted with tne
previous tecnnioues. Note that the formal specification and
tte input-output pair specification only required tne user
to specify the desired benavior witnout specifyinp tne
algorithm. Thus It can be claimed that these two Tetnols
intentionally ignore information tnat the user nas, assuming
that most users have an idea of the form of the alRorithm.
26
STA?9T START
"Ov A,1A~
1;UR 11% TMo V AE
DQ C,1c
PRINT A
DCO C FRINT .b
ADD BA
PRI NT B D C - C
DCR C
Al:)D A.,3
* PRINT A
PRINT A C=
DCR C DCR C HL
NOTE C =< 0 C 0~
HALT ADD 2,A
Figure 2. An Example Computation
27I
Tae primary contrioutor to tne understanding of
program synthesis has been Alan d. Biermann (see Blermann
and &rlsnnaswaiy [1i and Biermann, Baum and Petry [17j ). In
particular, Biermann [161 provides a formal definition of an
algorithm tnat will syntnesize programs from exarple
computations. The alzoritnm and variations nave provided tne
oasic structure upon wnicn tnis tnesis nas oeen developel.
Briefly, tae algoritnm identifies tne conditions tnat may
nave inadvertently (or purposely) been left out of the
computation. A condition is a predicate as aefined in
predicate calculus. Tnat is, an entity for wnlich a trutn
value may be measured. Once tne omitted conditions nave been
inserted, tne algoritnr finds a labelling for tne
instructions such that a program witn a minimum number of
instructions is produced. To explain tnis labelling, assume
the instruction ADD A,E appears in three different locations
in an example computation (see lFieure 2). Suppose It was
Known that there has to be two occurrences of tne
instruction. Then two of the instructions could be labeled
witan a 1 and the otner instruction labeled witn a ? to
indicate that the instruction labeled 2 is different from
tne instructions labeled 1. Finding tne labels for tne
instructions in the example computations requires an
enumeration search of all possible latellings. The labelling
selected is tne first labelling that produces a proFram tnat
is deterministic.
28
This ileoritnm is comrate and the syntnesized
programs are sound. Completeness meanF tnat tne algoritam
can synthesize every possible proeram. Soundness Tean tnat
tne synthesize program will correctly exect-e tne example
used to construct it. A disadvantage of tnis syntnesls
method is the alroritfnm is an enumeration sear-n and i.- the
worst case will require exponential time on tne lengtn of
the example computation to find a bolution. Tecnniques nave
been developed to speed up tnis searcn tnat will produce
satisfactory response for most pratical programs.
6. A General Automatic Programmer Design
Before leaving tnis section on automatic program we
wish to discuss a design for an automatic proerammer that
uses at least two of the specification tecnniques. Tne name
of the system is PSI and was desiened by a croup of
researchers at Stanford's Artificial Intelligence
Laboratory. The research effort was headed by Cordell Green
[,61. Green nas presented a nighn level design of an
autoprogranmer tnat identifies some ot" the more important
areas that need furtner researchi. Green admits tnat tne
design was an effort to focus attention on some of tne
sub-areas of the overall synthesis problem. His modular
design does focus attention on different aspects of tne
problem. The desien decision to split tne overall problem
into two main sub-problems of acquistion and syntnesis Is of
particular interest. Tnis desicn choice allows worg to
29
proceed concurrently on two nard problems witn tne interface
hetween tue problems being some intermealate representation
of thne problem.
PSI is a knowledge-based program unlerstandir
system oreanizea as a collection of" interacting modules.
Fieure 3 details the tielf level nodular desizn of' tne PSI
system. The PSI design divides tne system into two groups.
The acquisition Proup interfaces witn tre user and collects
tne specification given by tne user while tne syntnesis
rroup produces a proram in some tareet lanuare tnat meets
the user's requirements. Communications between tr.e two
major groups is tarougn an intermediate representation
called the program model. The goal of tae acquisition eroup
is to accept tne user's specification cy eitner natural
lancuare dialorue or by traces, and present a unilied entity
to the syntnesizer group. Tne implementation of tne
synthesizer eroup is then simplifiea tecause or" tne
consistent representation it receives. Since tne user's
input is convertel Into an intermediate representation tnat
is supplied to the syntnesizer group, tne user is free to
switcn from one specification tecnnique to anotner during
prorram specification.
The overall interaction witf tne user is meant to be
throuph natural lantuage lialorue. Since natural language
understanding is not currently witnin tne
30
F
of. -4
.... I a)-- - -- - -- - - - - ------ - - - - - - - - - - v
I .4 -. I c'
$..a
G)
S- - - -- -- -- -- - - -- - -- -- -- -- -- --
I -.4 ~ -*~I -I . - I 0)
id $- 1 1 444• I--,I I .- -- , I
I - I L
.. . - - I n - .
0 m)
4) c I II I I I-- I I I
P. I I. . . I i
I~~- iO14PI CUl ~ W~ I jIr IO:N 614 1* 1I6- 9L~ I~I
j '~- I--4i W31
state of the art, the system must interact in a subset o*'
natural language limited to a particular domain.
Tne system-user interaction is to appear as natural
as possible. Tne system nas been designed to incluae a
mixed-initiative lialocue capability wnicn means the user or
the computer can assume tne dominant communication role at
different tImes urinR the discourse. This allows the user
to provide as mucn inowledge as ne can to nelp tne syntnesis
process and allows the computer to assist tne user by asking
questions or providing responses. The system develops a
current model of tne user and a model of the context tnat
assists tte system in determining wmen to assume the
Initiative and wnat questions to asK the user.
A partial implementation was completed in 1Y7b t.at
Included tne syntnesis expert and thne efficiency expert from
tne syntnesis croup. The acquisition croup modules nave
proven to be a more lifficult assignment and only portions
of the acquistion croup nave been implemented. The important
point of tae PSI design is that it provides a modular
livisiun of tne program syntnesis problem tnat helps provoke
study into taese sub-problems.
C. OB'ECTIVES
Automatic programmers, whicn synthesize programs from
example computations, require conditions to be explicitly
defined by the user in order to generate programs witn a
minimum number of instructions. Previous wort ( Blermann and
Krisnnaswamy [161, and Biermann [18J ) nas reduced tne
number of required conditions, tut nas not eliminated tne
need for the user to explicitly state a minimal set of
conditions.
The explicit aefinition of conditions is not 3 natural
part of an example computation. Tnat is, one would not
normally give control structure information when usinz
examples to explain now a tasK is to be performed. Our
objective is to provide an environment where tne user may
define the tasks ne wants accomplished witnout explicitly
definine the control structures tnat specify tne 'low of
execution in a syntnesized program.
We will implement an automatic programming system based
upon the example computation specification method in order
to study the feasibility of Identifying conditions from user
actions. We limit tnis study to the domain of text editine
in order to provide a well defined area in wnicn to wore. It
is hoped that the results of our efforts may provide Insier.t
into tne overall problem and generate further researcn whicn
will extend condition Identification to other domains.
D. THESIS OR1ANIZATION
The thrust of this thesis is the developement of metnods
for the automatic construction of conditions necessary for
the proper synthesis of programs from example computations.
Example computation is one approach to the problem of
protram synthesis. Chapter One Introduces the reader to
33
program synthesis ant gives a brief nistorical perspective
of tne evolution of" this field of study. Cnapter One also
provides a comparison of tie different proposed approacnes
to this problem.
An automatic programmer has been implemented to support
tnis research. This syntnesizer was levelope to use tne
example computation metnod for program specification.
Chapter Two is a detailed explanation or our particular
implementation. Chapter Two includes a aiscussion of
tecnniques we nave incorporated in our implementation wnich
speed up tne synthesis process.
Chapter Thtree presents our approach to reneratine
conditions given an example computation. It iescribes
alcorithms which will eenerate conaitions from a sequence of
editor Instructions.
Chapter Four discusses tne result of our research. A
brief discussion is included on tne merits of tne
synthesizer which we nave implemented and recommendations
are given for potential improvement. Finally, Cnapter Four
presents a review of our worK on Ideatt irazion and
construction of condtions from example computations. Areas
requirn& further research have been nlimnlizated and
examples of possible applications to otner domains nave been
pointed out.
A. GOALS
There is a two-foil purpose benind aesipr.ine and
buildinR the program syntnesizer. Tne first directly rpIates
to the usefulness of the syntnesizer. It is hoped that by
l"yine tne proundworic for an autoprogramming systam, tne
impetus will be provided that will eventually result In a
total automatic programming environment telng available for
the user. This environment is envisioned as an intera-tive
one consisting of several components: an interface to
provide the user wilt the means to perform example
computaZons, a linI between tne interface and tne
synthesizer wnicq records the user actions and transmits a
trace of those actions to tne syntnesizer, tne syvtnesizer
itself whicn produces the algcritm in some internal forT,
and, finally, a translator tnat receives tne internal
representation of tne aigoritnm and translates it into
michine-reacable form and/or user-reaaable for. Tte second
purpose for wntcn the syntnesizer is built is to Drovide a
suitable vehicle to be used in the main area of research
tnat this thesis explores. If an autoprogrammer can generate
correct alrorithms from example computations, now much can
be done to relieve tne user from navinp to include orancninR
or looping con!Itions in his Pxample computations?
35
1. en ral Description
An automatic proera-niie system wnin pro1ues
programs based upon tne user's input of example comoutations
tas a natural appeal. Ex-mple nomputations are 5eulir."s t'
Instructions Derforrred in an aiioritnrric manner. For
instance, if the user is doing a matrix multiply, co ' u 1in
the entry for the resultant matrix involves the bum of
products from tne appropriate row and column o: tne
multiplicand and multiplier Tatrices, respectively. #On.en
nu7)ans communicate ideas to eacn otner, tne proper rse of
example computations often plays a vital role. It is nard to
imagine trying to explain tne metnol of multiplyvin two
matrices together, or trying to explain tne concept of
set-sutset relationships witnout being able to draw eearmples
that enmance the explanations. Tnis metncd of communication
seems to be vital to human uncerstanding of alrr tc5 .
Since programmers often use small eyample corputations wr.ile
cod Ine proerams, it seems tnat a logIcal ap.roa-r to
automatic programming would consist of tfte macnine doin4 tae
actual prowram synthesis based upon example computatiors
given by the programmer.
Program syntnests is the act of putting instructions
togetner in sucn a way tnat an alroritnm is tuilt wnicn
accomplisnes a desired tast. Ctviously, an algorltn wnicn
is an exact replication of the sequence of instructions will
accomplish tne task, tut it Is uninteresting since it cannot
be generalized to accomplish a set of related tasks. For
example, a linear sequence of instructions which multiplies
two 2 x 2 matrices together will only work for 2 x 2
matrices; nowever, by allowing loop constructs and if-tnen
constructs, an algorithm can be produced wlch performs tne
more ceneral task of multiplying any two matrices witn leral
row and column dimensions. So, in the case of the matrix
multiply, the task of the program syntnesizer Is to produce
a general matrix multiply alcoritnm given tne example
computation for a 2 x 2 matrix multiplication in some form
such as:
c(I,lJ = a[i,lJ * b[i,lj + a[l,2J * b[2,1J
c[1,2] = all,l] * b~l,2] + a[l,2J * bL2,2]
c(2,11 = a12,1I * b[l,lJ * a(2,2] * b(2,11
c(2,21 = a[2,1] * bl1,2] + a[2,21 * b[2,21
Generalizine from tne example computation also
requires some means of noting when tne array bounds nave
been reached for this example. In other words, conditions
nave to be interposed between some instructions wnere a
cnanage in tne flow of control for tne algoritnm Is
necessary. An input trace is defined as a sequence of
instructions and conditions whica describes the example
computation. In the matrix multiply example this mitfnt be
accomplished thusly:
37
c [1,11 --C11,11 = C [1,11 + A,13 * BtI,1jC[i,11 = c[II1 + A[1,]2 - B[2,11
COND - col index of A = col size of A
C~L,2] 0C[1,21 = c(1,21 * A[,lj * B[1,2JC[I1,2 = C(1,21 + Al1.21 4 B12,2J
COND - col index of A = col size of A
C[2,2j = c[2,21 + A(2,Zj q B12.21
COND - row & col Index of C = Dimension of C
STOP
The procram synthesizer used for this thesis is
designed around concepts and ideas on syntnesizinp a program
riven example traces as described in reference 1171.
Previous researcn, references (16, (171, and [181, seems to
indicate that correct proerams can be synthesized on the
basis of relatively few sample computations, out tnat tne
amount of time required to do tne syntnesis grows very
quicily as a function of progran complexity.
2. Trace Coding
Tne syntnesis procedure is domain independent; that
is, the input trace can be coded into any consistent
representation, and it will not affect the operation of the
synthesizer. Since the synthesis procedure Is independent of
the input trace representation, alphanumeric characters will
be used to represent Instructions and conditions. They are
distineuished from each other by tneir position within the
38
tracp rather tnan by tneir Symbolic representation. Fcr
example, an 'a' mignt represent an Instruction or a
condition. Within the instruction set itself, identical
instructions are encoded as identical symtois. k simple
trace of a routine to find all positive numbers in an input
strea'n miint be:
A =0
READ B
COND - B is negative
A = A + 1READ B
COND - B is nepative
A = A + I
READ B
COND - B is positive
PRINT B
If the instruction A=A+l is represented by a t', eacn
occurrence of tnat instruction in tne trace will nave to be
represented by a 'b'. The reason for tnis constraint is
obvious. Since tae synthesizer only receives a tra-e of t'ke
example execution, it cannot determine wnetner A=A+l is tne
same instruction beinR encountered repeatedly in a loop, as
it is in this example, or wnetner there are several
Independent occurrences of A=A+l. Fieure 4 is an example of
a typical coded input trace. The left-nand column entries
are conditions and tne rignt-nand column entries are
39
instructions. Fiture 4 Is read as state 's' transistions on
condition "x' to state 'a' which in turn transitions on 'x"
to state "b', and so forth.
transitions states
Sz ax bI Cx by eI Cz b• Cy sy a
by dx bI fX dX bx f• dy s
Figure 4. Input Trace
3. Input/Output Trace Representation
A Moore-type representation, as lefinel in [17J, can
be used to fhtiklIalt certain features that must be dealt
with when producing an algoritnm from an example trace.
Throuhout the rest of the discussion, Moore machines and
algoritnms will be used synonymously. Conditions relate to
transitions and instructions relate to states of the
machine. In fact, tne function of the syntnesizer can be
viewed as that of determinine a minimum-state deterministic
40
Moore macnine equivalent of a non-deterministic Moore
machine. Representine input traces as Moore macnines will
often snow the non-deterministic structure of the example
trace. This non-determinism must be resolved by tne
synthesizer in order for an alaoritnm to be eenerated.
Figure 5 is tie Moore machine representation of tne inDut
trace of Fieure 4. Notice that at node "b', tne trate is
non-deterministic. Transition 'y' leads from node 'b' to two
different nodes; similarly, transition "x" leads from nole
b' to two separate noles. Figure 6 is tne deterministic
Moore machine which has been constructed by our synthesizer
based upon the input trace given in Figure 4. The
non-determinism has been resolved by splittine state 'a'
Into two states distinguished from eacn other by an integer
prefix label. The assionment of the prefix label is the
mechanism used by toe syntnesizer to prevent
non-determinism. In order to accompllsh tnis assignment, the
syntnesizer uses an enumeration tecnnique. Eacn Instruction
is assigned a prefix label in a manner tnat !aintains
determinism and assures that the alrorithm will correctly
execute the input trace. It is easy to verify that tne
deterministic Moore macnine of Fiure 6 will execute the
trace.
41
xx
Figure 5. Non-mee8rministic Moore Macnine
Fiur . ~tr~tl~t~ ore~1clxl
2 b
C. SYNTHESIS PROCEDURE
1. Function
Tne function of tne syntnesizer pro.ram is to
orovide a -ri nium-state, correct propram consistont witn VIe
Input trace of tne example computation. Tne syn tneei 5
Drocess will be completed when it is deter-inei wri-'
occurrence of a labellea instruction correspon ,5 to eacn
particular instruction in the input trace. In order to
accomplish ta is goal, tne syntnesizer Is ta5Icaliv
structured as a deptn-first searcn aigorltrm. BacKup ari
fixup mechanisms exist to enhance the searcn procelure when
pruning nas not Kept tne algori nm from traversinz a
fruitless brancfh ot the searcn tree. Tne spar-n Te.nanism
attempts to assion a latel to eacn instructior. In ucn a
manner that tae generated algoritnm remains tecinicanLy
correct; tiat is, nondeterminis-n ib not allowel to exist ind
the orizinal trace can still te excu.tel. I numoer cf
tecqniaues exist within the byntneblizer #rirn ai Drunine c!'
tne searcn tree, and therety matce it possible to evntne1ze
more complicatel programs in a reasonable amount of tire
tnan could otnerwise oe expected from a zeneral enumeration
tecnnique. These tecnniques offset the major disadvantage of
exponential crowtn of tne search space as a "unctlon of
input wnicn is found in a general enumerative searcn
technique.
44
z. Concepts
Certain definitions and concepts must re presentvi
before the actual aleorilm is Iistussed. In order to
facllitate tne discussion, it Is necessary tc refer to
Figure 7. Each level in the figure consists o an
instruction-condition-lnstruction triple, referren to as an
I-C-1. In Figure 7 tre lertmost 5yrooi unipr I-C-I is
referred to as tte Imading instructior cf t"e tr1ple, tne
middle symbol is the condition, and the rizntmost tvr-tol is
tne trailinr instruction. Tne traillnr instruction at ie'!el
I becomes the leading instruction at level i+1. So tnls
input trace represents tne Instruction-condition sequence 's
r a n S r a
level I-C-I
1 5ra
2 ans
13 sra
4 ada
~axa
6 aya
7 axa
Sanr
Figure 7. Instruction-Condition-Instructlon Triple
Two levels i and J are said to belong to the sane
caule-class if the elements of the level are the sarre.
45
Instruction elements o" tne trace wnicn are in tne same
couple-class may oe assigned tne same prerix laoel auring
syntnesis if the assignment does not cause non-leterminism.
For example, eiven tne trace in Fieure 7, levels I and 5 are
in ne same couple-class, as are levels 5 ant 7. Difference
set relations are another situation tnat can exist wnlicn is
of interest. The first two elements of level i ant level J
are tne same, but tne third element is not t!e same. A
difference set relation indicates tnat tne leading
Instructions cannot be represented by tne same state
regardless of the prefix laoel assigned during syntnesis
because the leadine instruction has the same transition to
two different trailing instructions. Again usine the above
trace, level 2 and level 8 fall into tnis category. In this
situation, the inlex 8 would be entered into tte difrerence
set for level 2. By implication, the index 2 is also in trne
lifference set for level t, altnouefh, in practice, it is not
entered.
Once the initial couple-class informatin and
difference set information nave been determinea, additional
difference set information can be obtained tnrotgn tne
cnaining nature of differencing. For example, suDpose tne
trace consists of the one snown in Figure S. Tnen tne Moore
machine representation of this trace is shown in Fizure 9.
46,
index trace
b axa6 axa7 ays
ala.
ayt
Fizure S. CnPainine of Difference Set Relations
FiueI o-eemnsi nu rc
hiurace is obvouy oeter'inistic InincTac
state 'a* transitions by 'y' to two difterent states.
Difference set resolution requires tnat tne index fcr 'ayt'
be In the difference set of 'ays'. Since that requirement
causes different states to represent the 'a' in 'ayt' and In
'ays', and further since the trailing 'a' In the preceding
level Is exactly the saime instruction, the precedine levels
nov satisfy tne difference set relation. Thie leading
47
Instruction and the condition are tne sarme, but tne trailin_instruction in tne I-C-I triple is different since they nave
previously been assigned to a difference set relation.
Therefore, tne lead instruction must be labelled witn a
different prefix during assignment and similarly, the levels
above tnem'. So the Moore machine will now be deterministic
and in the following form.
X x
la ... 2a
is i t
Figure i. Deterministic Trace
Given a partial trace derived from the example
execution, tnere are numerous Moore macnines that (,ar be
constructed to satisfy tne trace. At one end ot tne
spectrum, a prowram can be constructed such that eacn
succeeding state is assigned a different prefix latel. This
method always results in a straiert-line prcram. Facn
instruction has one transition entering it and one
transition exitinr from it. Allowinz tlis metnoa produces
the maximum size program consistent witn tne input trace.
See Figure 11. Tnis is not a particularly desirable metnod
since it does not recognize loop structures that can
significantly reduce tne size of tne program. Additionally,
48
it hides the basis structure ot tte aleoritnm. Tte major
advantage, of course, is that absolutely no searcn is
required to produce a deterministic macnine.
condition instruction
- a
x a
x a
x a
Figure 11a. Trace Figure 1lb.Program
Figure 11. Stralgat-Line program
On the other end of the spectrum, a prorram can te
constructed such tnat each identical instruction receives
the same prefix label. This method tames full advantape of
loop structures, and will result in a minimum state macnine.
However, such a metnod will seldom produce a deterministic
machine; therefore, it will not produce a satisfactory
algoritnm. See Figure 12.
level cond instr1 - a2 x a
3x a Y4 x aX5 y a la lb
y b y
Figure 12a. Trace Figure 12b. Program
Fieure 12. Minimum State Machine
49
Tne best solution lies somewnere tetweer, these
endpoints. A reasonable first zuess at the numter of states
required to produce a leterministic macnine witni: tnis
spectrum can be made by establisnline a lower tound on tne
number of states. The carainality of the instruction set is
defined as the number of different instructions appearing in
the trace. Using tne above figure as an example, it can te
determined tnat tne cardinality oif tne instruction set is
two; that is, tnere are two different instructions, 'a' and
" b', in the trace. Tnis neasure provides an absolute lower
bound on the number of states required in tfe final ma-nine.
This lower bound can be refined by determining a lower bound
on the number of states needea for eacn individual
instruction. Once again, using the above figure as in
example illustrates this concept. The instruction 'a' at
level 5 must be different than the instructions at levels 1
tnrougn 4 because of difference set resolution, or else
nondeterminism results on the transition "y'. Therefore, in
order to maintain determinism, tne instruction 'a' nust re
allowed at least two states. Summation of tne lower tounts
for each of the instructions gives a lower bound on tr.e
total number of states required for the macnine. For tnis
particular example, the prorram would be eenerated as:
50
x
Fieure 13. Instruction Set Lower Bounds
If the searcn space is viewed as a tree _tructure
then the levels of' the tree can be associatei witr t.e
instructions by' assigning the f'irst Instruction in tne input
trace to the first level, tne second instruction to tIe
second level, ana so fortn. Tne vrancnlni factor at eacn
level is the state lower bound computed for the irstructicn
seen at that level. The prefix label assioznez to tne
instruction is represented by tne specific brancn used to
traverse to the next level.
Tne idea of nrovilinp a lower bound on tne nurnner of
states leads to an iteratively exuanjinp leptn-tirst sear,-..
When all possible combinations of prefix labels nave been
tried, but tne algorithm remains non-ieterrrinistlc, tne
lower bound is incremented and the search Is restarted *ror"
the top level. When toe lower bound Is Increased, tne search
tree obtains additional paths to tne final solution ty
increasing tne brancning factor associated with one or more
instructions. The deptr or a successful sear:h into tne tree
51
is restricted by the lower touna on tne number of noaes
required by tt.e deterministic macnine. Only wnen a pattern
of prefix assignments has been mate wnifl allows tne
algoritnm to remain ieterministic and all o " th e
instructions in tne original trace aave been assipned prefix
labels will the syntnesis terminate. Tnis mecnanism prevents
a straielit-line model from beine output at tne alorit m
unless It is tne only one tnat can satisfy the input trace.
More importantly, it provides tVie minimum-state
deterministic macnine capable of executing the input trace.
D. SYNTHESIZER STRUCTURE
The syntnesis program is subdivided into two primary
modules: static DrocessinR of the input trace; and aynamic
processing of the information extracted from the input trace
by the preprocessing, or static processing pnase. Static
processine provides Information such as couple-classes,
difference sets, anl lower bounds on tfe numter of Tacnine
states. Dynamic processine uses Knowlelee innerited from
preprocessing to guile the searchl mecnanism to a final
output of the alroritrr. These two modules will te discussed
in turn, and the primary mecnanIsms involved will be
amplified.
1. Static Processing
Static processink can be conceptualized as
consisting of three main functions: (a) accept tne input
trace; (b) preprocess the trace for difference sets,
52
couple-classes, and state bounds; and (c) prepare a trace
table for furtner use by dynamic processine. Cnce tnis
preprocessing nas been accomplisqed, tne statiz module is no
longer necessary to tne syntnesizer.
In the current confieuration, tne static module
expects to find tne input as a sequence of
instruction-condition-instruction triples. Fizure 14 is an
example of an input trace.
level trace
1 anp2 psa3 aga4 ayrb rsr6 rsr7 rra
saa
9 ayt
Fiture 14. Typical Input to Static Processor
Racn line consists of a triple, for example "anp'.
The 'a' represents an instruction, tne "n' represents tne
condition wnicn causes the program trace to transition to
the next instruction 'D'. For each level, tne first element
represents tne same Instruction as tne last element of tne
preceding level. This is easier to see It the above trace is
represented as a Moore macnine in which the nodes are
instructions and tne conditions are transitions. State 'a'
transitions on condition 'n' to state 'p' wlich transitions
on condition 's' to state 'a' wnics transitions on condition
' baCK to state 'a-, etc.
535
n r
Firure 15. Moore Machline for Input Trac e
level trace c-c difference set
1 anp-
2 p s a
1 {SI
4 ayr -49
5 rsr 2
6 rsr 2
7 rra -
8 aga 1
9 ayt -
Figure 16. Intermrediate Trace Table
54
Each occurrence or an instruction symbol in the input tra-e
is representel by tne same state at tnis point in tne
synthesis.
Once tne input trace nas been acceptea, static
processine can beein. Static processinv consists of
determining tne level indices associated witn eact
couple-class and with each difference set. For tne trace of
Figure 15, these are snown in Figure 15.
There are two couple-classes in this trace. Tney are
[agaJ at levels 3 and 8, and [rsrl at levels 5 and 6. Te
reiaining levels are not assigned to a couple-class because
no other levels matcn with tnem. Couple-class inforTation is
useful to the dynamic processor for determining forced
assienments anl dynamic non-equivalence. These ideas will te
discussed more fully in tne section on dynamic processing.
Difference sets exist for levels 3 and 4. Level 4
ias a difference set wnicn contains tte index 9; that is,
tne eleient at level 4, 'ayt', 'ust nave a different prefix
label on 'a' than tne element at level ., 'ayt'. It the "3'
is not latelled iifferently during the syntnesis,
nonleterminism will result since the same transition would
lead to different nodes.
Difference set resolution is a very powerful
mechanism for ensuring deterministic benavior of the
algoritnm. A considerable amount of the prefix label
asslenments to the nodes can be resolved usinR difference
55
sets. Notice that level S appear! in tne difference set fir
level 3 even thougn levels and 9 are in tne sa-e
couple-class. kt first tnis appears contradictory since
equivalent couple-class names imply that tne elements are
tne saie, but difference set existence forces tne lead
instructions to be different. Tnis points out tne relative
power of couple-class information and difference set
information. Difference set information is imiutaole.
Couple-class information only tints at equivalence. In tnis
particular example, tne entry at level 3 was caused ty toe
cnaininR effect of' difference set resolution. Notice tnat
since toe 'a' at level 4 iust be different tnan tne 'a' at
level 9, and notice that since tne trailine 'a' at level 3
is, by defirition, the same as the leading 'a' at level 4,
the trailing 'a' at level 3 cannot be tne same as tne
trailing 'a' at level S; tnerefore, levels 3 and 8 cannot be
in tne same couple-class.
To compute tte lower bound on the number of states
in tne algorithm, tne iinlium number of states neeaed for
each Instruction is summed. For tnis same example, the
instruction set consists of ta,p,r,tl. Toe 0ounds for p,r,
and t are each 1. Tne bound for 'a' is 2. Tnere must be at
least two different occurrences of 'a' from the difference
set resolution. Therefore, tne minimum number of states with
which a deterministic Moore machine can be constructed for
ttis trace is 5.
56
Finally, static proressInf passes al te
information concerning tne input trace to the cynai c
processor via a trace table in the 'ollowilne torm. Eacn
level has only one associated condition and one associatel
instruction. Since difference set information is associated
with the lead instruction in an
instruction-condition-instruction sequence, It is enterea at
tnat level. Since couple-class Information is associated
vitn tne entire instruction-condition-instruction sequence,
It is associated with the trailinz condition-instruction
pair.
level condition Instruction c-c difference set
1 - a2 n p3 s a - 14 g a 1 1915 y r6 s r 2 -7 s r 2B r a9 g a 1 -
1 y t
Figure 17. TraceTable
2. Dynamic Processing
Dynamic processing involves asslgnlng prefix labels
to the states of the macnine. In tnls way, separate
occurrences of tne same instruction are differentiated. Tne
dynamic processor is the search mechanism for t!e
synthnesizer. It operates In such a way tnat, at any point in
57
the synthesis, the portion of the trace previously pro'-essed
represents a deterministic Moore macnine. In order to
maintain the determinism, dynamic processine steps tnroueh
tnree pnases:(1) assignment of tne prefix label to tne
instruction; (2) difference set resolution, and ',) dynamic
equivalence assurance. Additionally, eacn of these pnases
nave built in fixup anI backup conditIons associated wit
t tem. The fixup/baciup conditions encountered durine
difference set resolution or during dynamic equivalence
cneckine are indicators tnat, if tne current assipnrrents
remain tne same, a nondeterminism will occur in future
assirnments. As such, they inform the pruning mecnanisms of
the searca algorithm.
An Intecral part of the dynamic processor is tne
failure memor . It controls the search. The failure memory
may be conceptualized as a L x M matrix where L is tne row
size and corresponds to tne number of levels in the trace.
Eacn row has M columns wnere m Is equal to tne lower bound
assiwned to the instruction contained on tnat level of the
trace. An entry into tne failure memory at some level I ant
sore column J, where 1 <= i <= L and 1 <= j <= M, prevents
the assignment of j as a prefix label for tte instruction at
level i. When a failure memory cell contains an entry It Is
called a valid cell; otnerwise it is Invalid. Eact cell of
tne failure memory is a two-element entry. The structure
factor is the first element. It indicates wlicn level of tne
58
trace caused tae entry. The free state factor is tne second
element. As tne name Indicates, tnis element Is a function
of tne number of free states available at tne time of'
assignment. Tqe specifics of the failure memory operation
and tne nature of failure memory entries will be discussed
throukhout the rest of the section as each phase of the
dynamic processor is discussed.
a. Label Assignment
As previously mentioned, latel assignment is tne
first function provided by the dynamic processor. A label
assipnment can be eitner forced or arbitrary. Additionally,
the assirnment can result in tne creation of a new state, a
label-name combination not seen before. A forced assignment
occurs wnen the instruction at the current worKine level is
a member of tte same couple-class as an instruction at a
prior level, and tne lead instruction into botn of those
levels nas tae same label assignment. The current worzine
level is defined as Tne level of' tne trace whicn contains
the most recently assienel pretix label, but ditf'eren~e set
resolution and dynamic equivalence cnec ing nave not been
completed at tnat level. An example is eiven in tne trace
shown in Figure 18.
Tne label at level 7 is forced by tne label
assignments at levels 4 and 5. Notice that the instructions
at level 5 ani at level 7 are in tne same couple-class,
49
level conlition instruction c-C label
4 a a - 25 n r 3 15 r a 4 27 n r 3 .19 r a 4 .2
.indicates forced trove
Figure 18. Partial Trace Labelling
and that the instructions at levels 4 and 6 nave tne saie
prefix label. This condition forces tne instruction at level
7 to nave tae same prefix label as tne Instruction at level
5. The Moore machine representation of tne partial trace is
snown in Figure 19. The assignment at level LQ is also forced
for similar reasons. By definition, any forced assinrrent
involves previously assigned states, label-instruction
combinations, tnat nave been seen before; tnerefore, no
forced assignment can result in a new state.
a n
r
Figure 19. Partially Determined Moore Macnine
' . . ... . . . . . . . . d ' ' ' - " . .. ' .. ., : . . . 1 .. .6. . . ......
The failure memory can be used in conjunction
with forced assignments to signal a bacKup condition to tre
search. It tne failure memory entry corresponding to tne
label assizament at the current worKinw level is valid, tnen
a contradiction results from the forced assignment. Sup)ose
that the trace table and failure memory are as snown in
Figure 20, and tne forced assignment at level 8 nas just
been made. The entry '1.1' at row 2, column 8 of tne failure
memory is interpreted in the followine manner. The intezer
to tne left of the decimal indicates tnat the entry was
caused by the current assionment at level 1. The "1' to tne
right of the decimal point is the number of free states + 1
available when the asslnment at level 1 caused tne failure
memory entry; therefore, wnen the entry was made there were
no free states available. A free state is one wnicn nas not
been bound to a particular instruction.
The assIrnment at level 8 is forced. In other
words the sequence of the previous absiznments causes tne
prefix laoel of tne instruction at level H to be a 2.
However, the failure memory contains an entry at row L
column 2, FM(9,2). This entry indicates tnat tne Instructicn
at level 8 cannot be assiened the label '2', for if it were
to be assigned a '2', a nondeterminism will result. To
resolve the conflict, baCKup is initiated until tne last
unforced assignment is found. In this case, the bacWup is to
level 6.
The assignment at level b will be cnanged ana t:e searcn
will continue from there.
Trace Table Failure Memory
level cond instr c-c label 1 2
4 a a - 2 - - -n r 3 1 - - -
6 r a 4 2 - - -
7 n r 3 .1 - - -
L r a 4 .2 - 1.1-
Figure 20. Trace Table/Failure Memory Configuration
for a Forced Assignment
If tne assignment is not forced, tne failure
memory row corresponding to the current worrinR level is
searched for tne first occurrence of an invalid cell. An
invalid cell is one which does not contain a failure memory
entry. If a cell is invalid, tae assignment of a prefix
label correspondinR to the failure memory column inaex for
that cell is possible on that level of the trace. Tne 'olumn
number of the first invalid cell becomes tne latel
assirnment for the instruction at that level. For example,
suppose level 5 is the current working level and tne trace
table and failure memory nave the confieuration snown in
Figure 21.
62
Trace Table Failure Memory
level cond Instr 1 2 4 4
5 r a 1.1 4.1 - -
Figure 21. Trace Table Entry Snowing
Arbitrary Assignment Metnod
Tne first Invalia entry in tne failure memory on
row 6 is In column 6; tnerefore, instruction I a' for level 6
will be assigned a prefix label of 3. Tnese non-forced
assiRnments may result in the creation of a new state; that
is, a label-instruction pair not previously assigned during
the synthesis. If, at some future point in tne search, a
backup is initiated tnat reaches tis level of tne trace,
tne backup mecnanism will not stop to perform a retry. kt
any point in the synthesis, all previous levels have
received assignments based on the constraint that tue
minimum number of states has been used consistent with
maintaining determinism; tnerefore, assigning a lifferent
prefix label to a state which has been defined as a new
state only cnanges the name of tne state, and does not
cnanwe the structure of tne algorithm. Since tne structure
of the algoritnm has not been changed, the cause of the
nondeterminisi is still present.
One otLer type of assianment should be mentioned
at tnis point. Pseudo-assignment occurs when tnere is only
63
one invalid cell left in a failure memory row at a level
otner tnan tne current worcing level and there are no free
states available. AlthouRn pseudo-assienment does not
immediately cause a label to oe assigned to the instruction
at that level, it does simulate a looK-anead mecnanism for
the search tecnnique by triggering difference set resolution
and dynamic eoulvalence chectinR as If that level of toe
trace were assigned a value. Since the pseudo value is tae
only value currently possible for that level, If a backup or
fixup condition is encountered durine pseudo assienment, the
assignment mecnanism can immediately try another label at
the current worginr level; thereby savine the unnecessary
search of a pats whicn it already knows to be nonproductive.
Once a tentative label assignment nas been male
to the instruction at the current woriing level, difference
set resolution anI dynamic equivalence cnecking can te
performed. Althougn tnese actions may cause a fixup on t'e
prefix label at tne current worting level, their primary
purpose Is to furnish infor'mation to the failure rerory t..at
will nelp guile future label assignments.
b. Difference Set Resolution
Difference set resolution prevents future
assiwnments beine made that are Known to ^ise
nondeterminism if the current assirnments remain uncnangei.
Difference sets outline a sirnificant portion of tne
structure of toe Input trace without regard to label
64
assirnments In that they prevent notdeterminismn trofr
occurring as a result of the same transition out of a state
leadine to more thlan one followine state. Consider 'Fiwure
Figure 22. Nondeterministic Input Trace
There are several instances wnere difference set
resolution will force a state to be split into two or rrcre
different states. States 'a', 'q', 'p', and 11tt' all nave
nondeterministic transitions -associated with them. Tfle trac-e
table and failure memory configuration for tnis trace is
shown in Fieure 23.
65
Trace Table Failure Mpery
level cond instr c-c difference set latel 1 2 3
1 - a - 3,,5,1b,1 S - -
2 n p {4,1113 s a 2 j5,15,1St 2 1.14 n p 1 {iI 2 2.15 S a 2 - 3 1.1 3.16 r 3 - 1
7 s a -
8 v - {9,i ,2 I
10 r P 4 {2A1 r p 5 {211 2.1 4.112 s t - ti3,14,17113 s t S {I4,I?114 s t1 515 s a 7 1.1 3.116 n r 3 -
1? n t - -
is s a 7 - 1.1 3.1
19 n r 3 -20 p 9 - -
21 r p 5 - 4.1
22 s a 2
Figure 23. Trace Table/Failure Memory Configuration
After Assienment at the Fourth Level
As dynamic processing proceeds wtr label
1sstrnments, ilfrerence set resolution occurs. Difference
sets are resolvea by mating an entry into tne failure memory
row at thie level corresponding to tne aifference set
element, and tne column corresponding to the prerix label
assigned to the instruction at tne level from wnicn tne
difference set is beine resolved if the cell has not alreali
been made valid through a previous assignment. For examplP,
if tne prefix assignment at level 1 is a '1', tne failure
memory entries are made in column 1 at levels 6,5,15,1?.
66
Similarly, when tne assienment "1' is made at level 2,
failure entries are made at levels 4 and 11. Now wren tne
assignment at level 3 Is iade, tne lynamic processor will
not try to assion a prefix value of '1' since tne failure
memory cell at (3,1) is valid. The assignment will
automatically be '2". Notice that at level 5 the Drevious
assirnments nave caused tne prefix label to be a "6'. Tn
otter words, the failure memory nas caused the searcn tree
to be pruned so that an assienment of '1' or '2' will not te
tried. Either one of these assignments would nave resulted
in nondeterminism being Introduced into the trace at level
6.
n Ir
Figure 24a. Prefix Label Equals 1
67
n 1ir
la ip2ap
5
Ficure 24b. Prefix Label Equals 2
Figure 24. Nondeterministic Prefix label Assignments
While failure memory entries are teing made
under difference set resolution, it Is possible for a row to
nave all cells valid except one. This nas oeen previously
defined as a situation leadinr to pseulo-assiznment. T!'.is
situation has occurred at level 11 in tne example -iven in
Ficure 23. When sucn an occurrence happens a looK-anead
mechanism is triggered to resolve the difference set at tnat
level. In this example, the failure memory cell at (21,3)
his been valilated with an entry wflic indicates the !urrent
worting level as level 4 when the pseudo-assignment occurred
at level 11. Another situation wlich can occur in a failure
memory row Is when all the entries in the row become valid.
68
This condition is called an incipient fence. #fen an
incipient fence exists and tnere are no free statps
available, then no assiftnment can be made at that level.
T .is condition is called a fence.
Since the searcn mecnansm always Knows tne
level from whict it is doing loot-anead ty differen-e set
resolution, it is able to perform a fixup on tne label
assignment at the earliest possible time. A fiTup is
accomplisfsed by incrementinp the prefix label bv one. If an
entire row in the failure memory bec-omes valid and there are
no free states available a fixup must be performed on tne
label assinment at the current wortine level. If the label
is left the same, then when the search reacnes the fenced
level, no assienment will be possible. Eact time a fixup
occurs, all entries made in the failure memory as a result
of t~e previous label assiznment are deleted, and entries
are then made based on tne new label.
c. Dynamic Equivalence
Couple-class information furnished by StaTiC
processine ails in tne determination of dynamic
nonequivalence. Dynamic nonequivalence can occur during the
syntnesis at any level below tne current working level when
the couple-classes are equal. Dynamic equivalence results
wnen instructions in the same couple-class nave bpen
assiened the same prefix label. Consider Ficure 25. The
I-C-I triples at levels 5 and 6 and at levels 11 and 12 are
69
talai; therefore, they are in the sare couple-class. The
instruction 'a' at level 5 aas been assigned a Drefix cf
' 2', and the instruction Oa' at level S has been assiRned a
prefix of '1'. Now, if tne instruction at level 11 Is
assigned a prefix of '2' and the instruction at level 12 is
assitned a orefix of '1', dynamic equivalen-e will c-cur.
Furtner, tne assignment at level 12 will te forced. D3narc
non-equivalence results when such an issienment scheme
causes non-determinism. Dynamic equivalence crecing
functions as a looK-anead reclanism ty preventing tne fut,:re
occurrence of a forced assignment wnlcfn will result in
nondeterminism. Suppose the synthesizer is Inspecting tne
trace in Figure 6, ani has just assiened the instrurction at
level 6 a prefix of "1'.
Notice that level 12 is in tne same couple-class
as level 6. Since the instruction at each of these levels is
in tne same couple-class, the possibility exists tnat tnev
may be the same instruction. If tne instruction at level 11
is assigned a label of '2' wnen tne woriing level reacnes
that part of the trace, then the assirnment at level 12 will
be a forced assignment of '1'. However, an entry nas already
been made in the failure memory at (12,1) wnich Indicates
that the instruction at level 12 cannot be assigned a prefix
label of i.
70
i I i....e Id
TraceTable Failure Memory
level cond instr c-c latel 1 2 L
5 d a 1 2 4.1- -
6 r a 2 1 - - -7 g a 2 .. . .
ii f a - - - 6.112 e a 2 - 4.1 - -
13 n a 3 .. . .
Figure 25. Trace Table/Failure Memory
In order to avoid tnis contradiction and a
backup, dynamic nonequivalence processing causes in entry at
(11,2) of the failure memory wnicn corresponds to tne
labelling of '2" given to the instruction at level 5. Once
tnis is accomplisned, wnen the wortini level descends to
level 11, an assienment of '2' cannot be made and as a
result, tne assignment at level 12 will no longer be eorcea
by dynamic equivalence whicn rives the synt.iesizer a cnance
to try otner assignments that will maintain determinism rf
the alroritnm.
Pseudo-assignment conditions and fixip
conditions can occur in the failure memory as a result of
validation of all but one of the failure memory cells In a
row in the same manner that they occur in difrerence set
resolution. Addlitionally, lynamtc equivalency and differpnce
set resolution can interact to cause failure memory entries
71
in the following manner. If a failure memory entry is maie
by difference set resolution at any level wnicn is In the
same coupla-class as a level previously assigned a prpt'ix
label, and if tne failure iemory entry prevents the
assignment that will cause the instructions to become ;art
of tne same state, then dynamic no-equivalence will result;
therefore, an entry must be made in tne failure memory to
indicate tnls condition.
3. Bactup/Fixup
The discussion of backup and fixup conditions nas
been saved until last. The basic idea benind constructin-
tne syntnesizer is to provide as mucn information as
possible to the search mechanism, and thereby dire-t tre
label assignment witn a minimal number of retries. Wltn tnis
in mind bactup and fixup become last resorts.
The fixup operation attempts to resolve
nondeterminism by incrementine the label at tne current
working level wnen a contradiction occurs. If t.. nawly
incremented label is not a legal assignment or does not
correct tne contraliction, tnen bacKup must be inittitao.
Tne fixup operation cannot be attempted It' tne assIrnient at
the current wortine level is forced or if the assipnmert
created a new state. In eitner of tnese cases, a fixup
operation would leave nondeterminism in the aleoritnm.
If a fixup fails, or cannot be attempted, bacKup is
initiated. Baccup must be initiated from tne current worKinr
72
level when any level is discovered wnicn contairs one cf
these conditions:
1) The label assignment is forced and the failure memory
cell corresponaine to that level an! latel Is valid.
2) The label assignment causes a contradi-ticn and
represents a new state, or
3) There is no free state available for tne instru-tion
at a particular level, and all entries in tne failure
memory row at that level are valil.
The backup begins at tne current working level regardless cf
which level trierered the mechanism, and continues until
none of the three conditions given above are present. At
tnat level a fixup operation is attempted and tne searcfn
begins anew. Any entries into tne failure memory w.tic'h were
caused by levels greater tnan or equal to tne new current
workinR level are Invalidated by resettine t~e failure
memory entries to (0,0). Additionally, any dssir'nments are
deleted alone with their side-effects, 5u-n as annotatior.s
on forced assignments an! new states. IO' oacicup causes tne
woriine level to be decreirented to zero, a free state is
added for the use of the first instruction needin- more
states tnan initially allotted as tne lower bound.
73
III. PREPROCESSOR
A. PRObLEM SPECIFICATION
The program syntnesizer expects a set of triples wnere
each triple is an Instru:ction, a condition, and an
instruction. Biermann (21 nas snown teat condltions
inadvertently or purposely omitted by tne user Tay re
inserted into a trace. The alrorit-m for insertion of
conditions collects tne set of atoms seen on tte transitions
for an instruction. An a is an entity whicn has a value
of either 'true' or 'false'. A nnnd.tinn is composed by
logical conjunction and disjunction operations on atoms. Fnr
example, an atom may be 'c <= V', but a condition may te "r
<O 1.nd a = 4'. A set of mtntqrm5 is computed from tne set
of atoms and one of tne minterms is inserted after eacn
occurrence of that instruction in tne trace. If {a,tf is a
set of atoms, then tne set of minterms will e
{a, b, {-a, b,{a,-b}, {-a,-bl wnere - stands for lopial
negation. It nas been snown in reference [16J tnat only one
of the minterms can be true for earn occurrenr' of a
transition from any single instruction.
One problem witn the algorithm is tnat it is Incapaie
of Inserting conditlons if tne user has failed to supply ary
atoms after a particular instruction. For example, i the
user should specify instruction Ii followed ty instruction
74
12 in one part of the trace and instruction I! followed t y
13 in another part of the trar-e, but tne user t'ails to
provide a condition after eitner occurrence of I, tten tne
"ltorltnm will be unable to renerate a condition for 11. It
is assumed that II does not appear with an atom elsewhere !n
tne trace. The syntvesizer will force two states for 11 to
resolve any nondeterminism. This mecnanIsm is fully
explained in Section II. If conditions nad teen supplied in
the above example, the differ-nce in the two prorams would
be tne nuiber of states assirned to instruction Ii. FInure
2b snows a partial computation witnout, explicitly exnressed
conditions along witn tne associated synthesized program
fraement. Figure 25 assumes that Ii does not appear
elsewhere in the trace. Figure 27 is a representation of tte
same partial computation except tnat the conditions cl and
c2 nave been explicitly expressed. Tne computations in tot
figures are the same, and eacn proeram frapment will
correctly execute either trace; therefore, the proprair5 -rust
be equivalent prorrams with respect to program tenavinr.
However the prorram in Fieure 27 is miniml in that it
contains fewer states because the user explicitly supplied
the conditions.
75
O MAN I-#l4l . n~ll ._ h.
Example Computation
Svntnesized Prorra
Figure 26. Computation witnout Explicit Conditiors
(S,. . , 1f ,c ,1 1. 1,B .. ,F)
Example Computation
Synthesized Prorram
Figure 27. Computation witn Explicit Conditions
We intend to show that there are mechanistrs wrt -n an be
used to automatically generate tne necessary conditions fi3r
the correct synthesis of an alrorltrm Droducet by an mxarple
conputation without tne user explicitly ipeining tem. The
problem may be lescribed as follows. Given an -xample
computation witrnout explicitly defined conditions, infer
those conditions necessary to control tne flow if
computation in a manner such that the synthesized proeram
will demonstrate tne benavior desired by tne user. In oreter
76
to facilitate tre solution to tne problem, a condition will
be viewed as a function tnat returns a value of 'true' or
"false' when callel ratter than a lovical operation on
atomic boolean entities. Tne problem can then be tncunt cf
as constructine a function.
Very little information is available to tne current
version of the synthesizer when the user provides only a
sequence of Instructions. Certainly not enou-n tc generate
minimal programs as described In Figure 27. Tnls lei us to
search for other sources of information that would allow us
to construct toe necessary conditions. We soon realized tnat
the Instructions issued by the user do not exist in a
vacuum. These instructions manipulate data. If tne entire
computer memory, includIng registers, Is viewed as tne
domain of interest, then execution of an instruction always
changes this state. Intuitively, toe domain also reflects
the reason that the user decided to execute a particular
instruction. A search of a space of tnis size in order to
determine tne reason is Impractical; however, ooservin only
those data elements affected by the sequen-e of Instructions
can often be quite practical and can significantly reduce
the search space.
We chose the text editing domain as the domain of
interest since we felt that it would be sufficiently
Interesting to warrant application of svntnesis techniques.
This domain was selected because, first, tecnnioues
7
developed in tflis lomain may .be general enougn for extensier
into other dorains, se'7ondly. the world for tnis domain can
be descrlted as tne set of all cnaracters contailned in a
particular text file wnicn males the world 'inite, and
finally, tne instruction set is srall enough to e
managea ble.
Altnought our primary researcn is Ire,,te! toward
studyinp tecnniques to apply to automatic contition
generation, we feel that tte synthesizer could be a powerf'ui
text editor and Could provide some useful features not
normally seen in conventional text editors. Extended
features could include the ability to capitalize the first
letter of every sentence, the ability to capitalize all
small letters in tne text, the ability to identify a string
and perform some operation before, after or on it . or any
combination of these editinp actions.
The worring nypotnesis is to nave tne user process tne
text file in a normal manner and have tne syntnesIzer infer
a program from nis actions. Two requirements were levied
upon tne user. Tne first requirement on tne user Is tnat le
must inform tte syntnesizer when ne desires to nave a
program generated so tnat tne syntnesizer can teIn
monitoring tne user's actions. A great deal of time was
spent trying to figure out methods tnat allowed one reneral
mechanism to be used to monitor the user's actions and the
resultine cnanes In the text file. Since we could not
78
produce such a mechanism, a second reouirement was levied on
tne user. This requirement recognizes a basic cAstinction
between two different aspects of text e4itinp,: context itree
substitutions, and context sensitive substitutions. go
define a context free environment to be one In wnicn tne
cnaracter to be operated upon Is not dependent on characters
around it. CapitalizinR all occurrences of small letters Is
an example of a context free operation. A contexi sensitive
operation is lefined as an operation in wnict trne action to
be performel on a character or sequence of characters
depends upon otaer characters around tne main c.aractpr cf
interest. Capitalizinp the first letter of every sentence is
a context sensitive operation. Conaition inference in a
context sensitive environment is Innerently more difficult
than in a context free environment in that the condition
must be constructed from events wlicn require a loox-anead
capability not inherent in the synthesizer. The user will te
free to switcn from environment to envirorn ent at nis
convenience. The synthesizer will create proora"i segments
from each environment wnicn can be used to construst a
conplete prorram by a post-processor.
B. DESIGN FOR A CONTEXT FREE ENVIRONMENT
1. Overview
Programs that operate on a single entity can te
constructed by the synthesizer. Fteure 2F snows the
construction of a program from a trace intended to
79
coimunicate that the letter ".'I snould be apitalized
wnerever It appears in tne text file. Tne column latelled
"trace' contains triples of the form instruction, condition,
instruction. B is the start instruction, R is tne novo right
instruction, C is tne capitalize or change instruction and S
Is the stop instruction, respectively. Tne conditions for
tnis trace are tne cnaracters seen in tne text file prYor to
the execution of toe second instruction In eacn triple. The
special conlition "o" is tne null condition, and Is always
inserted after the start instruction.
Tne generated program will correctly execute tne
trace that was used to construct it, and by examination of
the program it can be snown that the program will convert
all d's to D's in a text file consistin_ of the cnaracters
A, b, C, I, F and G. There are no arcs available for otnor
cnaracters in the cnaracter set. In order to zenerate a
program to perform the same function on an irbitr3ry text
file, tne user would be forced to Five an eTample of tne
desired transition for every ctaracter in tne chrarter set.
Since it is desiraole to relieve tne uicer of tne
chore of providing an inordinate number of examples in order
to completely specify tne function, a metnod is required
that utilizes a few examples of the types of conditions that
are to appear on tne arcs to generalize tne conditions into
a more compact and complete form. If a ceneralization can be
found, the multiple arcs may be replaced with a more Peneral
condition and, tr.eretore, correct 'roerams can oe 'reited
wttn fewer examples. However the combination of' arrs cetween
nodes must te accorplisned so that determinism is maintained
or the syntnesizer will not create a mimimum state macnine
capable of performing the desired functior. Tnat means that
tIe _eneralization tecftnIque must De able to handle
conflicts properly. The arcs in Firvre 2B tnat origInate at
state R and terminate at state R appear to -onsist of"
elevents from tne capital letters and small letters. The
generalization of {hI x e capital letters U tz! z 6 s-all
lettersl would appear to be a reasonable replacement ror all
of thne R to R arcs. If tnis generalization was made a
conflict woull result because tIe letter 'd' is also an
element of the {zj z f small lettersi.
Trace Syntnesizel proram
B R A/b F16R AR
R CR /P I C ===>1 STNTHESIZER === 0CDRDR 11
CsRG R sR LA S
Figure 28. Syntnesizer kctior
2. Structure of tie Condition Preprocessor
The preprocessor is designed to accumulate k.nowledge
from the traces it is provided, then use tne Knowledge to
construct meaningful conditions. The preprocessor scans t~e
Input trace looring at tne instructions and cnaracters tnat
81
-5-
are seen before the instructions. Tnis phase extra-ts pairs
of instructlors from tne trace. Tne trate in Figure 2H woiiud
nave tbe instruction pairs (.bR), (R,R), (R,C) and (C,PF
extracted. Attached to eacn of these pairs is the set cf
characters that were seen between tne pair. Tne preprocessor
then analyzes the information to determine if a
gen eralIzati on can be mate frim the set of cnaracters
associated dita eacn instruction pair.
The natural division mentioned above allows tne
preprocessor to be divided into two modules. Tre first
module performs tne scanning function wnile tne second
module analyzes tae information and anpltes a neuristi- to
provide the most general condition Dossiole. The
i rpleMentation of the preprocessor will be discussed later,
but before It can be discussed an explanation of the data
structures required ty the preprocessor is needea.
3. Preprocessor Data Structures
To simplify tne problem we define two tvpes of
instructions in this domain. Instructions thiat specify tne
current location of interest are cursor Dositionlre
instructions. Instructions tnat ctange tne state of tre
domain are data manipulation instructlo-s. Tne preprocessor
accepts as input a sequence of instructions and an
associated sequence of cnaracters. Tne first Instruction in
tne instruction sequence is always the start instruction
wnicn does not nave a character associatei witn It. The last
8!2
Instruction in the sequence Is always a nalt intruct *o.
Every action performed by the user Is ̂ aDtured ina apuri _e
to tue instruction seguence list. Tne character ssouen.P is
created in narmony witn the instruction seauence. In t e
quiescent state the cursor will indicate a certain ,osition
in the text. When the user performs some action sucn as move
tne cursor rignt, a monitor piccs up tne value in tne old
position and associates tnat value witn tne inctr,)ctlon
executed rv tne user. For examnie, assume a user has a text
file in lower case letters that ne wants to cnange to all
upper case letters. The user initiates tte synthesizer then
proceeds across tne line of text cnanging lower case letters
to upper case letters. For the purpose of this example,
assume tne line of text is change lower case to upper
case . As the user moves arross tne line matinp
substitutions, the condition monitor captures tre actions
performed and the characters seen. The example line would
yield an instruction sequence of (P, C, R, C, R, C, P, C.
C, S). The associated cnaracter sequence world te; (c,
C, n, H, a, A, ... , e, 0). The "C" and "R in tne
Instruction sequence are the capitalize and move right
instruction, respectively. Note that tne caDitalize
instruction does not reposition the cursor and wnen tne user
moves the cursor to tne right, tne result of tne capitalize
instruction is associated with the move.
93
Anotner data structure needed ty tne preprocessor is
the ASCTI vector. The ASCII vector is a 12F-byte linear
array witn indicec numbered 0 tnrouen 1?'?. Each tyte in tne
array is referenced ty the decimal value of a particular
ASCII character. For example, tne array elerert rpservpi for
the ASCII character '0' is indexed ty 4-9 decimal. The arrav
element reserved for tne ASCII cnararter 'a' is intexed y
t6 decimal. Tne vector defines a partition -f tne ASCII
c.haracter set by usin the followine te-nnique. The ASCII
character .set has been divided into eight mutually exclusive
subsets.
Subset 0 Capital letters
Subset I Small letters
Subset 2 Numbers
Subset 3 space character <sp>
Subset 4 Symbols
Subset 5 Punctuation
Subset 5 Arithmetic operators
Subset 7 Control characters
Ah Subset name is entered into the ASCII vector at eacn
cell by converting the ASCII character to its decimal
equivalent and using tnat value as the array index. The
default partition is shown in Fifure 29.
84
Index 30 31 ... 39 65 6 ...
! I! I
2 21...1 2 L LAI I
I I I I
ASCII 0 1 ... 9 A B ... Z
Fizure 29. ASCII Vector
Tne cnaracter set nlerarcny is delined bv tne tree
structure in Figure 30. The tree is related to the ASCII
vector tnrouRn the cnaracter subset names contained on eacn
node one level above the leaf nodes. For tne dPfault
nierarcny shown in Fig'ure 30, a zero would te entered in tne
ASCII vector for all capital letters, and a 1 would be
entered for all small letters. If a cifferant partition of
the character set is required the user can modi ry the
nierarcny or create his own. An example will be given to
explain tow tne modification may be accomiplisned. Assume a
partition is desired where tne vowels are isolated into a
set. Assume furtner that tae the vowels are to be Subdivided
into capital vowels and small vowels. The flerar-ny would te
modified by placing a son calle, 'vowels' on tne alpnaeetic
node. Attach to the new node two sons. -alled 'Cap-voweI5'
and 'Small-vowels', witn arcs to tne appropriate cnaracters.
Relabel the nierarcny so that siolln relations are numnerel
in increasing order. Finally, initialize tne ASCII ve-tor
witn tne new labelling. All of the modifications can be done
by the system when the user calls for the modifi-ation Tne
modified nierarcny is snown In Figure 31.
8bt
ASCII
DIsplayable control
special Alofla-nurneric
[Arith-1 jPunc-1 Syrnbols! !Space! jAlpnabetic! !Num~eric!ietic 1 tua- 1 3 1----'opera-, fion f --- --- - ----Itors 1 5 1 T1
6 <sp>
77- -- --
A .. Z a .. z
Firure 30. Derault Hierarc.hy
86
ASCII
--- ------------
- -----
to I 7r
:,. p -S~e7. .,Cajwetas vo s
letters: ----- ietters,!
voweisl v ow eis;
----~ ~ - - -- -- - - - -- - - -
B e ...u y 7 ... zCap-letter Cap-vowels SF Ili-vloeI5 callelter<
leSS LESSCap-vowels i .l-, o* 1
Fipure 31. 'oci.'ea -ierarcn:7
t I
The next lata structure use! vy the preprocessor Is
the transition table. The transition table contains tne
knowledge gleaned from scanning tne instruction sequen-e and
tne character se4uence createa oy the monitor. F'irure '52
snows the format of the transition table. The transition
table is an array of records with each record containing
Information on a transition. In the table, Ii ana 12 are
instructions vere 12 directly follows Ii In at least one
place in the instruction sequence. 'Active-sets' is a field
that contains information on sets of cnaracters tnat have
been observed by tne monitor on tne transition froT Ii to
12. The fields 'Set-i' tnrouen 'Set-n' contain the value for
set name, the count of the elements from the set associated
wltn tne transition anl a pointer to a linKed list of the
elements. The records that would be created for the tra-e
given In Figure 23 would be associated witn the transitions
B to R, R to R, R to C, C to R and R to S.
III I- I Active-sets 1 Set-i , Set-2 : . Set-nI I • . I
I I I I I I I
Figure 32. Format of toe Transition Table
4. ImDlementation
The context free preprocessor consist of two Tain
modules; the scanner and the insertion modules. Another
Important module not part of the preprocessor is the user
monitor. Tne monitor gatners tne actions of tne user and
creates two arrays. One array contains tte sequence of
Instructions tne user providel and tne otner contains
in formation of what was true before an instruction was
executed. The information tnat Is gatnered is tnen passed to
tne appropriate preprocessor.
Tne example instruction and cnaracter sequences
Riven in Fieure 35 will be the example use! to explain the
mecnanism of tne preprocessor. Figure 33 is llustrative of
a collection of actions tnat were performed by sone user.
Tne user's roal is: CnanRe all lower case letters in a text
file into upper case letters. The user nas activated tae
condition Tonitor, positioned the cursor at tne berinninp of
a line of text and moved rignt along tne line, cnaneine tte
lower case letters to upper case wnenever one appeared anove
tne cursor. Fieure 33 is an example of output from tre
monitor assuming the line tne user processed was Tie
numbers 1, 2, 3, b, 7 ARE prime. . Tie first column in
Figure 33 is tna cnaracter array. It centains tne cnarictor
under tne cursor prior to execution of tne Instruction in
column two. Column two is a trace of' tne actions perforred
by the user. Tte "R" represerts tne .move cursor rignt'.
instruction and tne "C" represents a cnange witnout cursor
reposition instruction. Figure 33 can be read as: Tne
cnaracter in column one was observed and tne instruction in
column two was executel.
89
inaex cnaracter Instructiorvector vector
I T R2 a C
H Re C
5 E R5 <sp> R7 n C
22 1 RR
<sp> R25 2 R
37 R
39 R
49 C
Figure 33. Monitor Output
Tre scan module or tne preprocessor is activatea
wehen the user Indicates tne representative exqmple is
coiplete. Let "Inst-iniex" be an inciex for tne instruction
array tnat is initialized to 1. Tr.e tirst step is to rreate
a transition from tne start instruction to tne first
instruction in te instruction array ani add tr.e transition
to the transition table. Tnls transition will Indicate tne
beeinnine of tne protram and will transition to tne virst
instruction provided on a null condition. The module tnen
moves down tne instruction array creatine otter transitions
and adding tnem t o tne transition table. Duplicate
90
transitions will not appear in the table. A transition is
defined as a pair (11,12), Ii and 12 are instructions anl 12
follows Ii witnin tne instruction array. Tne Instruction
array in Fivure 33 yiells transitions (R,C), (C,R). (P,R).
Tne transitions are constructed by indexing tnrough
the instruction array. The instruction at inst-inaex and
Inst-index ' 1 form a transition. Tte transition is tne
match against tne transition table. If a matcn occurs, tne
character in the character array at inst-index + 1 is
extracted and its ASCII value is used to index into tne
ASCII vector. The value stqred in the ASCII vector is used
as an exponent for two and stored in a temporary variable. A
bit by bit logical OR is perforlied between the temporary
variable and tae Active-sets variable for tne transition and
tne result is stored in Active-sets. Active-sets contains
the information of every set from the partition that has
elements seen on tne transition. Tne operation lescribed
above allocates one bit for eacn set in the partition. If
Aective-sets equals 1 tnen bit one of Active-sets is a I
signifying at least one element of set 1 has been seen cn
this transition. A two would sipnify that soe element of
set two nad been seen and a three would signify ttat some
element of set one and some element of set two nad been
seen.
In the transition table are fields for each set that
nas been determinel to be active for tne transition. Witnin
91
eacn of the set fields tnere are tnree subfields, tne first
is the set naire, the seconl is a count of the elements seen
for tne set and the last is a pointer to the start of a
circularly linked list containine the elements used from tne
set. The value that was obtained from tne ASCII vector is
used as a set name and matcnel apainst each of the set
fields' set name. If the set name matcnes an entry the
character at Inst-index + 1 is added to tne linked. list in
lexicowraphical order if not already on the list and tne
count is incremented by one. If a match does not occur on
the set name a new set field is created and eiven tne name
that was obtained from the ASCII vector, the count is set to
one, and tne cnaracter Is put on tne list.
When the scan module reaches the end of the input,
tne transition table contains an entry for eacn transition
that was seen. Each transition is associated with all tne
sets that nad elements seen witn the transition. Finally
eacn transition is associated witn tne actiial elements
t.rougn the linked list for each set. The information is
then passel to the insertion module for analysis. Flure 34
snows the completed transition table and the linKed list of
elements for each set.
Once a completed transition table nas been created,
control Is passed to tne insertion -nodule. Tne Insertion
module processes the information in the transition tatle and
assigns a condition for each transition.
92
LAN-,-
I I An a cs s ttt Ir r v12 e I Set-n
IBIRI 1 1 1 1 1 <7> 1
RICI 2 ', 1 '19 1 (<0
IcI I i 0 s 1 <5> 'IRI 4 3 <1> 1 2 I <2> 1 3 11 1 <3> 5 b 1 1 1 <>
<1> <2> <3> <> <b> <6) <7>
A 1! n <I> < e p po
41 INI
17 1
i1 11 is!I
NOTE: Tne notation <1>, (2>, etc. represents a pointer tothe linced list headed by the same symbol.
Figure 34. Completed Transition Table
93
The Active-sets entries provide an efricient
mecnanism for recognizing potential conflicts on emanating
arcs. Performine a tit by bit AND on tne Active-sets entries
that nave a common originating intruction yields tne sour-e
of conflicts. Tne bit positions that are on (bit equals 1)
are tne set (or sets) tnat nave nad elements on multiple
transitions. For example, let (11,12) and (11,13) be entries
in the transition table with Active-sets value of five (Z1
binary) and three (00i1 binary) respectively. Let Q equal
tne result of the bit by bit AND of the Active-sets values
given above (i.e. 0001). Q indicates that there is a
conflict between tne transition (Ii,I2) and the transition
(11,13). Furthermore, Q indicates that tne set causing the
conflict is labelled zero in the aierarcny of Figure .0
because the on bit is in the rignt most position wnicn
corresponds to two raised to tne zero exponent. Usinp tne
exponent to enter the nierarcny, it can be determined that
capital letters were seen on both transitions. Onpe all tre
conflicts for transitions wita tne same originating
intruction are inown, tne conflicts must be resolved before
an assignment of conditions can be made.
Extending the example given above, assume that eignt
capital letters were seen on transition (I1,12) and t'our
capital letters were seen on the transition (II,1M). A
partial conlition can be constructed for the transition
(I1,12) as a set difference between tne set of capital
letters and tne actual elements seen on the transition
(Il,13). Tne partial condition for tne (Il,13) transition
becomes the set of capital letters tnat were aCtUalyseen
w!th tis transition. The inItial conditions for tnese
transitions become the union of tne sets indicatea in
Active-sets as not being in conflict and tne sets createi ty
the resolution of conficts. Tnerefore, tne conaltion for
(11,12) is (t x x 4 capital lettersl - {xlx c capital
letters on otner transitionsi) U Jx',x a numeric}, ana tne
* condition for (11,13) becomes { z z c ({actual capital
letters seenl U ismall lettersf)J. In tnis example, it was
assumed tnat tne sets, numeric and small letters, were an
appropriate eeneralization for tne transition. In practice
it cannot be done without consideration of the numoer of
elements that have been seen from the set on the transition.
If the count field for the set exceeds a taresnola value for
the set, the eeneralization Pay be macne, otnerwise tne
elements tnemselves become the partial condition for tne
transition.
After a condition nas been constructed for a
transition, a final stronz weneralization tecnnique is
enployed. The Active-sets value for the transition again
supplies tne starting point for tnis tecnnique. Notice
adjacent bits in Active-sets correspond to adjacent nodes in
tne nierarcny. Therefore, a cnecc is made of tne Active-sets
to see if it has adjacent bits with a value of one. It' it
95
FVAD-AI04 586 NAVAL POSTGRADUATE SCHOOL MONTEREY CA F/S 9/2
CONDITION RECOGNITION FOR A PROGRAM SYNTHESIZER.IUI NJUN al J S LAPE, C W MILLERUNCLASSIFIED NL
22ffIIIIIIIIII
EEohhohmhhEI-IEEEEEllEllEEE*rnuuuuuurnumIIIIIIIIIIIIII
does then a generalization may be attempted. Assume tne
condition (({capital lettersl - tA E I 0 Uj) U ismall
letters} U tnumericl) Mas been constructed :or some
transition. The Active-sets value for tnis transition must
be seven (0111 binary). With tie default nierarcny in Fieure
32, a generalization to Alpnabetic and tnen to Alpna-numervc
would be attempted. Notice tnat a generalizatlon to
Alpna-numeric would fail because of a confl1ict witn another
transition. Intuitively (talpna-numericf - IA, E, I, 0, Uj)
would be a correct cnoice for the -ondition for tnis
transition. A general procedure for tce construction of
reneralized conditions is eiven below.
A set of nodes T = ty, ,z, ... , y, is
eeneralizable to a node X if the set of' node Y form a
complete and exhaustive set of leaves to the subtree rooted
at X. Further, a set of nodes Z = {z1 , z. , ... , zM } is
eeneralizable to the set 4 = {wl, w2, ... ,w J, J < m, where
eacn w is a generalization of a subset Z.
IF the condition = F U F U ... U Fwhere F =z - q, i 1,n
where qc C zi (qj possibly null)
THEN the condition Is set to W -U qU
wnere W is tne smallest setV = 1w, , w2 , .. . , w) Isuch tnat W generalizes {z, , ... , z
96
C. DESIGN FOR A CONTEIT SENSITIVE ENVIRONMENT
1. Overview
Condition generation In tne context sensitive
environment is a more difficult task tnan in tne context
free environment. This difficulty arises from tne s' ope of
Irnowledge required to ,aie decisions on wnat a condition Is
to be. The conditions themselves are more complex te7ause
tney depend not only on tne character tnat is being seen,
nut also depend on characters tnat precede and follow tne
current cnaracter under consideration. The following example
will be used to illustrate the difficulties and our solution
to this problem. Assume a user wishes to capitalize all
occurrences of tne word 'time' in some text file. Also
assume that the word occurs at the beeinninR, at the enl,
and in the middle of sentences in the text file. The
question is tow to construct a proeram that performs tne
desired function given only tne actions tae user performs as
an example of the required program.
The assumption about the position o the word "'ti'e'
in tne text file implies tnat tne requested action needs to
be accomplished on strians that nave very different
characteristics. Certainly, botn 'time' and 'Time' snoula .e
capitalized as should 'time,' , 'time?' and 'time<sp>'. On
the other hand the string 'time' should not be capitalized
when it occurs witin a word liKe 'sometime' or 'timely'.
97
Any generated program that benaves as iescribed
above must be able to recognize an occurrence of tne string
or some variation of tne string. The totality of t.s
Information must be glued togetner to provide a single
condition that is descriptive of. what the surroundine
environment must be lire before tne action is performed. The
implication Is that tne condition itself must be arle to
perform caecking ani Iook-anead. In other words, the
condition for tne transition to tne operation must in fact
be a procedure which responds 'true' whenever the string of
interest is recognized. Assume for tne present tnat tne
strine of Interest can be discerned from the user's actions,
(a hard problem by itself, see Angluin [19J ) one must wonder
now sucn a procedure can be constructed and then inserted
into tne generated program wnicn performs the function of a
condition on some transition in the program. Figure 35 snows
a procedure whqi:h recognizes the word time'. Note tne
robustness of tte procedure In tnat it distinguishes between
the differine occurrences of 'time' as mentioned above.
Figure 35 points out that tne problem is not just generating
a procedure as a condition but also generating conditions
within the procedure that is to be tne overall rondition.
Tne arcs labeled 'T v t' and '<SP> v tpunctuationl' snould
be noted with interest because they provide the robustness
tne condition procedure needs. Tne discovery of arc labels
for the condition procedure vill be discussed next.
98
IIASCIII t<sp>ff
R
(sp>
(TT v t)
R
R
R
(<sp> v tPunc.1)
!Requested!Opera tion!
Figure 35. Condition f'or "time" and "Time"*.
2. Lmnpientation
The monitoring of user actions provides ttle
instruction and cnaracter sequence In tne same manner as
done in the context free mode. A consideration was eiven to
require 'ore information be provided by tne monitor,
however, the notion was discarded because it would reouire
the user to be aware of the functioning of tne preprocessor.
Requiring tne user to provide Information to tne system
would betray our goal for the system. The user should only
be required to initiate tne system and tnen perform ealting
as if the system was not actively monitorine his actions. We
feel the requirement of specifying whether the user wants to
perform context free or context sensitive operations is tne
maximum tnat should be asied. If it were feasitle to
recognize tne lifference between tne two modes from tne
user's actions alone, tnis limitation would be also removed.
Given only tne instruction sequence, tne cnaracter
sequence, and the information of a -ontext sensitive
environment, tne first assipnment of the conte7t sersitive
preprocessor is to discern tne strine of characters upon
whicn some operation Is to be performed. Tnis is a pattern
recognition problem of considerable difficulty. Anpluin (19J
provides the followine theorem, "There is an effective
procedure wnicn, when given a sample S as input, outputs a
pattern p which is descriptive of S. The sample S is a
subset of tn. set of all strings over the alpnatet of the
I
laneuaze. The effective procedure is computationally
expensive dnd not Ilplerentationally desiraole for our
system. The procedure is an enumeration tecnnique on
patterns witn a length less than tne snortest example in tte
sample set S. Each of tne enumerated patterns is testec to
determine if it is descriptive of the entire set S. Tte
longest pattern that is descriptive of S is the most
specific pattern for the set. Clearly, as tne lengtn of' the
of the sample grows, the number of enumerate. patterns will
grow exponentially. Angluin [191 states, "In tne general
case, the test performed on the patterns is an NP-complete
problem. . The test she is referring to is the cneck to see
if the enumerated pattern is descriptive of S.
For implementation purposes, we need a mechanism
that falls well snort of tne exponential tenavior of the
effective procedure mentioned above. The text editine domain
has two types of Instructions for tne purpose of tris paper.
The first type of instruction %ill he called cursor
positioning instructions wnlile tne second type will e
called data manipulatinR instructions. Assumine the text
file is to be represented as a linear array, only one cursor
position instruction need concern us. All cursor positioning
commands such as move left, move up or move down can be
represented as move right instructions. Data manipulation
instructions operate on one character and do not reposition
tne cursor.
101
The metnol we nave adopted for determining tne
strint of interest and the context of tne string is basea on
tne above definition of tne types of instructiors availale
in tne text editing dorain. The preprocessor scans tne
instruction sequence loolcine for an occurrence of a data
manipulation instruction. The character associated with tnis
instruction is then taKen as the first cnaracter of tne
string of interest. Other characters are added to tte strire
by continuing the scan until multiple occurrences of cursor
positioninr instructions are encountered. A nypothesis is
then constructed consisting of three parts. The first part
is tne beginning context. It is constructed from tne
characters tnat preceded the string in the cnaracter
se4uence. The second part Is the string itself and tne final
part is the endink context constructed from the characters
seen after tne string. For engineering considerations, tme
number of characters in the bezinnine and ending context
will be limited to twenty characters. The probability of tte
context exceeding twenty cnaracters on botn sides of" tne
strinr in the text elitint domain is small enouzn to iwnore.
Once a nypotnesis is proposed it is set aside as an
active hypothesis and scannine of tne input continues. Otner
cises of data manipulation instructions surrounded by cursor
positioning instructions will result in otner nypotnesis
being constructed. As these hypothesis are added to the
active nypotnesis iAst tney are chected for consistency and
if the new hypothesis causes conflicts they are resolved ty
constructing another nypotnesis from tne conflicting
hypothesis. To demonstrate this mecnanism we present an
example which will illustrate the generation of fnypotneses
and resolution into a condltion function. Tne example used
is the construction of the function which will recognize tne
string 'tine'.
Suppose the text file contained the tollowine
sentences somewnere in tne file.
The time is two oclocK.It is time to go to tea.Time the runner.Did you run out of time?
Also, suppose tne user has specified the environment is to
be context sensitive and nas berun to perform actions on tne
file. The monitor coull create the following Instruction and
character sequence fragments from tne user moving tnrouen
the text file and capitalizing tnese occurrences of 'time'.
(RRRRCRCRCRCRRRR ...)(The tTIImMeE is ... )
(RRRRRRCRCRCRCERRR ...)(It is tTiImMet to ...)
(RCRCRCRRRRR ...)(TiImMeE the ...)
(... RRRRRRRR.RRCRCRCRCRR)(... run out of tTilmMeE?)
103
This example is not to imply the user must cnanre all
occurrences in tne text file but ne snoula provide enougn
examples from the file to insure tis desires are understool.
If tne user has not supplied a distinguisning set of
examples and an incorrect program is zenerated ne may add to
tne set of examples.
Scannine the first instruction sequence until tne
first data manipulation Instruction results in tne string
"time' beine constructed. The resultine ftypotnesis is tnat
the string 'time' is witnin tae context of 'Tne(sp>" and
'<sp> is two oclocK.'. Tne nypotnesis may be viewea as tne
followine data structure.
Hypotnesis 1:Begin context: Tne<sp>
Strine: timeEnd context: <sp>is two oclocK.
A second hypothesis would be zenerated for the next portion
of the instruction sequence as snown below.
Hypothesis 2:Begin context: It is<sp>String: timeEnd context: <sp'to ko to bed.
A comparison of taese two aypotheses indicates a
disaereement between the contexts. The conflict is resolved
by determining the longest beginnine and endine 'context that
agree between tne two nypotneses and generate a nypotnesis
reflective of ttis agreement. By worKing bacKward from the
last cnaracter in tne begin context for botn nypotneses, it
is possible to ascertain tnat the only character in
104
agreement is tne space. Woring forward from the first
cnaracter in the end context for botf nypotneses, apain orly
character in agreement is tne the space. A tnird nypotnesis
wita tne new begin and end contexts Is renerated as follows:
Hypothesis 3:Begin context: <sp/String: timeEnd context: <sp>
This hypothesis specifies tnat tne string 'time'
must be preceded ani followed by a space. Note tne test of
the hypothesis implies tne user is allowed to specify one
string during an example computation. It Is also Implied
that there must be a bezin and an end context for the
string. Since it is possible to nave two hypotheses where
one of the context strines do not agree in any of tne
characters, a method must exist to provide tne appropriate
context.
Whenever the comparison between context of two
nypotneses results in tne null string, a disjunction is
formed from the characters immediately next to the string.
For example, the instruction sequence given above woulc give
the hypothesis:
Hypotnesis 4:Begin context: Did you run out of<sp>Strine: timeEna context: 7
A comparison between nypothesis 3 and nypotnesis 4
would result in the null string for the end context. Since
there must be an end context, the disjuction of <sp> and ?
105
is formed and tnis tecome tne end context for tne new
hypothesis. Generalization tecnniques tnat were mentionea in
tne section on context free environment ar, tnen applied in
an attempt to reduce tne end context to tne most -eneral
context consistent witn tne data seen. The only alteration
in the generalization scheme is tne lowering of tne
tnreshold values for important sets. In tnis example, tne
threshold value for the punctuation set wruld be lowered to
1 and the ending context would become { x! x=space or x c
tPunctuationfl.
The final problem to be solved is tne recognition of
variations in a strine. Examples o variations of a string
are, 'Time' and "time', or 'enclosure' and 'inclosure'. As
mentioned, if tne user intends to capitalize all occurrences
of 'time', 'Time' is to be included. Note these variations
of the strinp become tne conpouna labels for tne arcs In
Figure 35. The system includes a rule that enables tle
recognition of variations of strings provided tne user gives
an example of the variation. The rule simply states tnat tne
string length will be establisned to be as long as tne
longest string encountered during processing. Again, using
the example, the hypotnesis ror 'Time the runner.' would be:
Hypotnesis 5:Berin context: ... TString: imeEni context: <sp>tne runner.
It has been establisned by precedine user actions
that tne string length for tne nypotnesis snould be 4. By
106
matcnine the pattern in hypothesis 5 witn tne btrirn Irom
nypotnesis 4 it can be deterinea tnat tne string in
Hypothesis b shoula be expanded by inserting a "T' in front
of the string. Anotner nypotnesis is then generated where
tne string will te tne disjuction tetween tne strins 'tie"
and 'Time'. The final nypotnesis from the example woul1 thern
be:
Hypotnesis b:Beein context: <sp>String: 'time' v 'Time'Eni context: t xl x = space or x e Punc.1
Once tnis nypotnesis nas teen generated, it Is tnen
used to examine the Input for neRative examples that can
strengtnen or weaken tne nypotnesis. Suppose tne input
contained the fragment ... timely results.... Pro-essinR
the input witn Hypotnesis 6 would snow a matcn for the
strinR, but tne ena context would not agree; therefore, tne
nypothesis will be strengthened by cnaneina tne end context
as shown below:
Final Hypothesis:
Begin context: <sp>String: 'time' or 'Time'Eni context: lxlx=space v
x e Punc. Nx a small lettersl
After the input has been processed ani a final
hypothesis proposed, the hypotnesis is used to construct a
procedure such as shown in Figure 35. The first part of the
procedure to be constructed is the transitions ror the
beginning context. The states in tne procedure are tne
107
instructions in tne instruction set, and the arc labels
consist of the information In Lne final nypotnesIs. A start
state is placed in the procedure with an arc to a move rignt
instruction (R). Since the procedure Is a strine matcn or
iooK-anead routine all states other than tne start state
will be move rizht instructions. Each of tte states will
have two arcs exiting them. Tne labels on tiese two arcs
Will be the necation of the each other.
Tne construction is accomplisned by placing tne
first character of the becin context on tne exitin&n arc
going to a new move right state. The other arc is labeled
with the negation of the character and tnis arc terminates
at the first move right state. Each character or the bein
context creates another move right state labeled as
mentioned.
The string from tne nypotnesis is then used to
complete tne procedure that has been partially constructed.
If the string is composed of disjunctions, the characters
are used to form disjunctions. Each of the disjunctions are
combined wita conjunctions. The final nypotnesis above
provides a string of 'time' or 'Time'. The conjunction of
disjunctions will be formed as:
('T' v 't') & ('i' v '1') & ('m v 'm') & ('e' v 'e)
Upon reduction the strine will be expressed as:
('T" v 't') & 'i' & 'm' & 'e'
Each disjunction becomes a label on an arc to a new move
108
rignt state ani tne negation Decomes tne latel on an arc
back to tne original move rignt state.
Finally, tne end context is aldej in tne same manner
as the begin context. The first character oecomes the latei
on thne last move rignt state created frim the string and new
states are aled for eacn character in the end context. Tne
result of tnese operations is displayed in Figure 65.
109
IV. CONCLUSIONS AND RECOM'ENrATIONS
A. STNTHESIZER
Tne syntnesizer tnat nas been implemented for tnis
tnesis will produce programs from example computations in a
reasonable amount of time. Tne system response for most of
tne traces was witfhin 1v seconds on a Dipital Yqupient
Corporation PDP-11/50 minicomputer. The response time is a
function of tne lengtn of tne trace and tne rnumcer of
multiple occurrences of a particular instruction or set of
instructions In tne final algoritnm, wItn multiple
occurrences of an instruction affectina response time tne
most. As Blermann (17J nas noted, tnis nas a nice
implication for prorramminR by example because most
algoritnms do not exnibit tne cnaracteristic of ftavnng a
laree number of instances of tne same instruction. In otner
words, almost all multiple occurrences of an instruction In
an input trace are indicative of a loop in tqe aliorltnm.
In all of tne test cases except tnose tnat requlred a
large amount of backups, static processing accounted for at
least talf of tne total response time. Future modifications
to tne syntnesizer wnicn would decrease tne total response
time could be directed toward desirninr tne static
processing stage more efficiently. However, tne trade-off
between static processing and dynamic processinj must be
-1ept in perspective. static processing is a linear fur ction
of the lenett of tte tra e, whereas dynamic processin',
since it is an enumerative search tecnnique, is i n
exponential function of tne lengtn of thne trace.
Another area wnich should be considered is t.e dynamic
processing stage. Tnere exists a pletnora of researcn
ouestions within this area. The primary one being: Can rrcre
information be gleaned from tne input trace auring static
processine wnich will decrease trne search time r'or dynamic
processing? Difference sets and couple-classes provide scTe
powerful mecnanisms for decreasine tne amount of searcn;
however, lower bounds computations on the number or states
required by the macnine often increase tne amount of searct.
Lower bounds are restrictive in nature. They are desizned to
force tne final algorithm Inte a minimum state configuration
which, in many cases, causes extra search time. Relaxation
of the lower bounds ccmputation will result in a 'inal
algorithm which may not be expressed in a minimum nurer of
states, but which will still oe determlnistic. There r-ient
be better methods of initially computing the number of
states whicn would result in a closer estimate of tne actual
number of states required for tne algoritnm. Obviously, the
closer tne initial guess is to tne actual requirement, tne
less backup incurred, and, therefore, the less search ti're
requi red.
111
.1.'
Since tie amount of search requirel Is governed Dy tne
failure memory entries, the more dense tne failure iemory
can be male, the more directed tne search be-omes. So
anotner area for researcn is to determine If more
information exists In the fillure memory entries than is
currently being used. How lucn information do tne structure
factor and the free state factor provile? Is there another
factor which would be useful?
Finally, a more Reneril question can oe addressed. Tre
underlying structure of tnis technique is an enumerative
search. Can the tecnnique be zeneralized to Include otner
algoritnms wnich are enumerative In nature? 'dhat
modifications to the failure memory are needed? How would
difference sets and couple-classes be redefined?
B. CONDITION PROCESSING
The condition processor front-end to tne synthesizer
relieves tne user from worrying about some of tne control
structure considerations by automatically !eneratinf?
conditions. Anotner allition which would increase tne power
of the syntnesizer Is an automatic loop varlatle generator
as discussed by Biermann 1181. Altnougn the text editine
environment nas been used in this tnesis worr, tne part of
the condition processor desien which deals with a context
free environment is general enougn thnat it could be designed
to operate in any domain.
112
Condition generation in a context sensitive ervironrnt
Is a 'iurn harder problem further complicatea by requisite
pattern matching and pattern generation. Before tnis Type cf
condition.reneration can be generalized. mucn worr nas to te
done to increas-e the efficiency of pattern reneration
scnemes. Angluin (19J nas shown a pattern generation scneTe
which is a polynomial time alzoritfn for pattern eeneration
witn one variable, but tne domain we nave exafoined will
require at least two variables. There is not a polynomial
ti-ne algorithm for pattern generation witn two varlatles.
Heuristic tecnniques will probably be necessary to proviie
methods of pattern generation wtticn will be fast enouen. to
be useful over a wide range of problems.
113
in
.4 0 U=')(U a4 -aJ C3
a,4
0~ 5.
4.v d)L 0C 3 0. N1J D 0 4A (a "
a, t ~G0 4)AQ ..4~ r- 4-A
40 ~ 41 4.t 4)C
) -- 1 kA 0 C: 4 . -4 * QJ
GD. "~ 04GD .
60 E
0) 0 C J-G
U'90 0
0.4 .4-4 .'~114 5
Ininkn 4A
C3 E4 -40A:c cu -V u
'3 u 0);3 c
4.3 '3 (V 0.4 0.
-4 n'- 4A0 toI
vi..- a.o o2 'ii 5-. 6
E3 W i .. r- a)-4 to -40 ) 4-' cu W
-- V) 'U:44 w- 0 . N 4 & 443 to. -P &0 0' a) 0.4 4)
m. -4 0) 0. ;" 0 J .4 3 '% 31 vi vi IV 4.3 01 %.4G
10 13 c3 a)J --4 In 0.0 '
940E3 G.. 10 4 C-4 4#a 0 cu' f 0 4j3~fAC0W I - wl 4 n0 $-a m1N- 0 0 9
Q i E 0 4 to 39 '34 %4 4,04J 4 4tw a 1 434- .I' £ 0 .,in. In .
M (0 W'0 * U F cu &4 ~ 4.b4*. 4
op- " 61 Id ea %A40.- C:0( :to f f 0 0-0 = £ .0 0 u in E4 C4 CU A e.-I
*iQ v 0v -0 9: 04 41 -4 b,'. .160..- .t;( C0 c1 "10 1
0".~ to W') In U.Q£ '3o$ 4 ;Qajn :334 E4E --4 FE'3 6-2 =
o. E4 .-. 4 la 03 -4 = EOE :It
or -4 t3 £0 A0a0 400 £0 m(o( t
G 4 '0 0 I W) t 0 Q3 '3 AZ E 4
g3 -44 4-0 &04.- 1 0' zo .m ( U 3 '3U - (V 4 '0* u -C:Q aa: -4 % Z
041 o * 0-4 E &. "0 ':v3 *4 = % 0E.:31-4(3-4A II1.3 rd 434) (1 3 InS .00.e aq I
92- (130 V -0 -4'.. 0) to0 0£ O 1U..4 IncQ n " )0 id *A0 A i r - 4%
00 0.44 43 I ) cu3' =0 u. 4 F- -E-y 4 Q a0 dm414 4.# 4 u .4'3 OII Id eo3 '3U' $A z '
a0 if: 0. '3 -4' 4ad 4 0 3 a~ r- l
.1.4 '3 0.. 43. 4 £0 V0 -4 V4
~~4U~~~~fl0~d In..4 (3U' 0'0 -
0140 In43L3 3 40 141 C)115
0*
tn -4
0
o P'4 $- 0
'4 - *ACJ= unE' '4
AL 4W.Jf 04 &. 0oa '4-.4GG o~~ ff 64 #a
Ad P. *0 N AV)t 0s 0 10 0
93 0.q..4 a)G * 0 CU -4 - 4.1 .. 0 in 0 IV w 0 cu
v 4.E cu 0 14.4 0 4 0 '40 c
0) d)-4 .40 0)0?0"5q1A ~ 00 94 -4 '4 .-j cu '~a
In C 0) . '4 4-4.-I 0 0ai
An : :3A M 0 0-4 000 to Q'4 S.
0 >*;~ ** * SZ * *
,4 N
-u E- -Ign Q49z6- C 06- C 0 z0
vi A-4 .0- . O
93~~~'-' r.a0 n931 t 9 $ oA 0 3= C E 3S
.4wo q q-4 4 q-4 6-4 4- dU C q- .4 L)4G~ C. )4r J - a
%-4 %-44. 44c, f*- %-4;scto d) I0Z~ a) a)'U-' ILO- " mt $4
skata _.4~ b 5 wo' fW l- w 4-
wa)@ o~aJ~w ~ ~ ~ ~ ..... c..116-
CU
in- V-Q
QJLQ C.) k F -o
0 ckJU
444 -4
P 6 4'..E
C:4 4-D a 0Z W
to to1 c,.
0 4'o CU0
40 '41 to -4
40 0 toO. t
&0 L, An i *u 06 vo0 9 4 '04. Idl 93 C) -
00 ov 0. q o
r40 Z.0c-d '0-s .
9:O 0 Q) cl ZO '-4 -4 1
10J 46.0~l
6..L.4 &-,~ 10.-6
4'0)4 .- 04 0 0
.4-4- 0 4 .00 M4
' 100 -4 '-
o. V4 #4 g4 Ujo a
U a- 0 ) * -.
.v4 '41 W ' ) k' 0
L44 w4)GO o4'b'
a r.OO to 0. to(.%4F
0 . a- b ~~ N #j 0 ow . W6-40 . = --
&'5. to-~ b00'g
do4 6A of; . 0 .0 .eb0
04v 64 0664 4'.-P '
117
to
-
00
0 E- 0
0- 4) cu&4 44
V-4
q-4 E-*0 W -noW
. 4
11
0 'o
U E~
. 4 a. -4 A- 0 N
A .) 0 =3 k. 0t
0'. N. U I 4 CU 3
-4l 44.4 tob 4. E G: wto w 44; -4ne n 0 q9
(U 04 04. (U *~E E P4 1E 10 E
Nw j S~ N. 111.5
O~~o e ow ~ 4e-'.Q~ob4 Gi~enen l~G+
+b -QG Ere X:o -4 M -4 4-fOA 6..J -4 C.)
0 0 6a- -C
E. E.. E O tO4
L11* u* 1 11q .. ow -* a
r.~~~I 63 a ODII0a
- %A. W4 4 W4. -. -. w
~*.. E-. .~1U-. 4Z ~119-
CU 4. a)
CU 0
>2 -4Q, a) c c.
-
4-40
0 OCI. . )..-f
+I 0
4- ~ '-4 4. .4 A 4
+. -4
C4 . 0 E2 cu C.
vi ( ai 0~ " S. IV~ (v C WC.) U1 ea Cl) 30
n in. o- 0
~ ~- 44 -4 E- -4 -40 (u Q~ ~.fa N/ III. C) E f V0
.4~-- # -4 vi t 4
,a ~ ~ ~ ~ -N 1vg oV Q& '
E-C-5-4 -4 -4 E4 ;:so j 4.. -120
o -E
c) 0 W) $..
(U a,
4.3 cu u rr- E s...
- --4 --4. -1 W, -3tO fl4 -4 t"-'(U
.4 0 J 0 0 : 939 0U- C A -
CU em. -
0n a. #-6 =O..-4. SO~ 0- 0 0
4.. I .13 C L,C.) -41 4 c
Ad GJ P4 ." Ift a 4
ri 0.0 to -4a % I Ci
0 ~ J= 0 ) c Ec -oa 4. a ev --4 a)cu
E fa 0) --4 ai~ E Er:
a) 0n --0 0. fu- aJcu
+ C34 to .4 0 -4QOJ C+ (v G GJ -4
-4 . 4 A 3 -4 ~ 4fr0*j .- uU E 0. C' ajiW
+) 4 a'U 1-e0s0
)4 4-4a~ .3 " -
E P.~ - -4 -4 0 =~ &4- Nw 4.) 44.) a)) 0ld. E-
Q) 0 LO c0 4* 4 --4 E
E- u4 A.. A= .. P6 40) 4- 4-'- -4U00~ E -0
cu -4 Ad4 9-4 0 j= IMI.-4w -
E If (u E l.. - -4 *-1.. Id *4 0*4 4 + m I c h ~ -31
0. u -4436 -t If. 111-
(U 440 :.3
F M-
121
-4
-4 0
aj .-4 Q.
=1 4 .)LnJ
&.4
(U E +n+ 4 aWP4 S 4 -
(Ud -'.EE U LJ4G
10 0M tn &n
(u E- E. toCln '
4 a--4 cu +4*4 .
Gj in 4.--4. 6
-4 0- 04 -
6q 14 4) -4 -4 ILI
:;0 9= *- l4.
~WO & I -4EW.) E 0
& 4 E (
- ~ + 04+
+- +
be +
122
di BEul V-4 L
4.V)
44 in
di InU O -- V
kn u P.LI
~~4j 0 ~ C Qd,4 ~-4 -) S0
bJ~qU gji-~ B..3 -.~>.4*-
-
go 0 W ~v. 0 -4 -4. V) -4x -'-
cu to 0 di IV P.-C) jP. -4 E*- k*
0- w ... oP -oi '..- -4
C: .4 S. *+ n .- -I
.4 in p% 84 04sV.jo 3 * C.v V- n U-4
F -.1 4-4 -0 *-.-. - U-
ci a) Ln > Ed c-L +
"* m 4 -4 (U E- +C,- ifl4. Id~
fo 4 tol .4 #-4& - .- 4 f
uII 6-0 &.. (U-0 W) ".- .
i .i 4-V to L 3 .. f= 4d .4di W 0-
41 ** -4 #j 0 E-41-4 'S. -4go in08. 0-.
U4 9.d3V 4 II
di ~1" 0.0- 0-4 c ..*
P6 4- +:I I i
0 .~ 4 * ~ U -4
W4 + d -
di 0.- --
C A d 4 S . 4 3
123
*'.. 1 -4
it 0 4. )4.
4.1 Q.0 F-.4ogsF a)0a)
-+ 4b' =J.a C 4-4 E :0 04 .)6.
* ) C.3 0 0 i&A
4.)r. 10 j b-.
lE E.0A4 F 0jV
oe--j4-a 'O (U -4 -4 00
(1) 4.3;0.4 b.4. £ Ib41
() 0 .- 4 0 it .
r. . - 4 4-.
to4 to * 4.) 4.) ) 4
0 r- r- 4-4 -4 (a.. eW 0 0 0V-4
Qn0. 6n #- d () I-l -0.3-. WUO -' ' a CU -4 41--4. ... -4~U )' =1 (U *. c + -
II.- , 64 . caI- 4 +~ 1 - 92 -- +
4-0. $- 4. + (a 4 E
4.) 4)0 -4~ :3 .. ,4 03 V10ninf 40 P.f 0 " 0 ) E- * C)
'.A .. 40 V1 ~ - CU V)--- 6.3 0. z~i -11 -4 -4 -Z 4
r- W4 .-4 P.- 4-- ". 4.a
aw to0 4 0n 4U.46 CU 0.3c .4 0 (1 ) '.)d) As I'f. s -:.4 4. -4 4fl25
GJ%4 0) .4.- P. 6-X3%-44 %" -4 vO C)4 '-1i
9d. ed4 . 4 4 W4 ". 4 O4-4 W f-493 16 P . 0. -h4.. 4E -1,1*.1Ja W- .e444 .4 i*4 It -I4%. .
- .&4
U N U a if 0 N
124
,~aE
cJ -4 c a)4.a)
:3 0.4 GJ CU
Q L..-49 0 P-C 4
5..n0 OE S.. 0 a) 0Z in (a
3B M 10- = 0 ) 0 E E r
--o a(o4V% o ) 9. i L) 02 4 r-4#.4a *0* 4J-b.0JV) .) QJ 4--a
a)O .. 0 o 0 to0 t -
:3*u*, #- 0-- =9 L -4 $- -C
64l~ *-aOJ 4Lpn *a_-4 V)faO (U. J= CU .) 4J.4
0 4n Ia0-4 -4 S. UJ
0 -4G J 4 k- 10Q >Ugo0* 4I.. $-= 4 Cfl S 4 0)
-4 0 -Q).C.o M cu -3: 5 40 IC4Jd 4-4 I 4:3 0 cu
ro0w)0 W)O AI IIi. V) + 0. OC_ I
to 0C * 0-4 93 -* l 14 U A 0 dS. -10-.4 -4' 4)(-4P H. :V
a) Q 6a X - a) 411 0 -4 J.EGJ 0aE 0 ev %n )S. - -4. C- E - E W1
a)S. 0) k aw A: . U :.- 493wl c w C 0) cu 0 4-4 E E - S.. b4J GJQJ2 (I 0 E 0 j=j=29 -20 >b-4 a1 C~- F ul
> ) A&1 6 -4 a .a~ * C: *& 10.. \/4 0 -4 040 (OD ) petto( '0 *4 .- 0J w4 >I
0 flJ ~ 0 IA a) *a 4 * v-4 (L *.0 0) in it4. AS. o..4C C -4 11-)0. Ad - )0A
&a 093 -4.0. -4-O.4 0 #a (u 4).- &0 C: 0) ifSP4to > .fS. 4) C4 .14 4.9. sm
04 W%.4 (U~ E ~ a C.) U. -4 4.-w) d 0Q.ES. A 0 a -to IV.t C4 &-. ES.bj-4 Gj E w0- j 4 a .I &1 -- *a I 0.4
bi to to' E 64 () -4w40 0 ~ U4 W4 > -ll4
0 W n r -0 3 % ~4 ) 40 %A -0 (0A3 in W WI4 f" PI-4 D. .4 CU 0i (U ofl-4 2
0a E U II1.-4S40 E C .0%
125
CU w
0
c) r.- CUJD
-4~
.40 kn WIn n
4." ti ca4 b. C2II
c0)0 In IC.) * a-.4 to In in, E.- #-I .. ~.0 ~ -4 *- .- E 6 n
C.) -0+ 0 000 + 7 + ~UJ.4 4'"
Q4 j3'f -4 T + U10j 0 d 0) In c. I3 ii 0 n ., -04. a 'ISI II d 0~.~ "I .0. 11 -1%o..
#A n t It 4-f- -4l b.3EJ4j -+ -.. ' = 04
a) hd a hd Is Q60 L.'nO 0 0)0 0)r- Q
- U4j- (V)0 11 a) oE Q0() -- q 00 + IZ cu =W 00u 1. *a - 4 - IL * - *a-4 .'. - - a)i .V1 c (A= o o In Ln o 0I0 ) (U 4 vi 0) a) W-4 u)
S3. In *a a)0.2 -- #.a'S "..k4k.=0k0m L4 =0)cuI0I V) IEO ( 0ILO.).J 0 =~ ! .)-UEO 0 .- 00 P .4. ) ". In0)0 CO CA(i-CU (1.-' ) E %'n 0.~ 0 In- (85' 0.. 0
0)) - L..3 0 4 E S-e- 0) E 0 .4 0~ -". *+0 4-' -4 0) a-00 0.0
to( oi %nU -4 0. lif- I=. - 1. 0,,o 0J= (U h E hdE 4. -4 311 4 ' 0) -4 E
a. -- a) ~-4 -4 IJ00In m046) 0
Wn a.C- 0) o--. 93. CU 2 0. 0
126
0) E44-4Q 4 0 C
94 4.0
to CE
004-'1 9Li3 -4 21
4n to0v (U laoL
0 0. 0 c: ) cu4
in =1 10
*.) d0 p V- 4
0 0u (U (U 16.
-o 0. to*'o-4 0'. 04.& .- fp 4.W E 44
0)6- -4 0 0- C6'4
E~- 0.0)0 04 E.'
0.10) 0-4 164UE~
+-" E.4 0)) 0V 311 =4 +~ 4)4)+0 &. S. QE 0 1. -W 1
d) 0u to tvIL a 4 ) 0 0 ) J,.
a.-- 16 ;-~ 4 NI 4.'I. -. q -40 I4.- I
0 6 0 m: E 40 4 to 4.'0 1Z04 EE) "cu > - -. 4 e4 Uu-4- &0.--
Eo*a in toc t0 jd 0-.
+ 0" 0 J 0 -4 3E'J C " 11- F-04 hd 0 o!400 1) 0E *X~ E-40il :
cu#* E4 (U Q in-4 -4 0)0oA-
(U'a 8) )-4'. -400+ tu -0. b'J- J.4 9 A C210 W )
+ 4w : -.4 -4 Li "V V al~- to A.. O-'
936p+a. %- 4 Oc U
-4- 0
(U tArE
03 '
*j 'V 5.. .4
P C.D
fa0 S. 0
.C4 (o N 4-
>6 0 ... f . '-S 3.4
Ln " $V-l
V4- kn 1= -4 0
:W. isJ' 4) .0-0 E ~L01L9w -4 GO I 4U4 o.k(U 04. S %.- 01 1 .. 0
* 4 .- 4 #* +P4. 0 *0a)0 E
.4 ) + S.. -40)-- M6. cI-
-4 + . *- # A ;- U u*. 0 L) (U'03. t1 ~ ' -E4 (cu0 1) l - 1
.0 16 4 (1) C 09 -
16 =J 401 03U61N S If ~ .C.'* 03)~ do 6q ;D4 - 0 04
'A to a - P V .6'A4f0. d)1* r-4 -4A. cl 4) -0 to30.IV 0S..
r4 40 -O44MAD. A k jo. C0f.)03 E'AJ.j to~ #a to LA 'A + .4)~- IVSa'. &.0 1 002 O- to 0 j
P-4 -# d) ~ ,. 4U fl. 160 01.4
A2 c.- C) lr4-4 UA 3 *'.4~.
to to 4.0 G4 4 . 0 tor. N1 #a S.. f"0114o
6.464if&0 f 6.11 .- C) j. to 0) 0 . +)
4 o -4 E- -4 06 -9 4 40-d 4-p -4 ' 0 -0 -4~.U-03 OJ1 J)-0 %A .0 do. -4 03 .tv ..... u u- Up 0~
O'e 0'~J 0 0. Vf 3. 40-4- 50.55 s..Sa . 0 1A4 l
128
4A
.~CliU -u
JI..4
0 d
to4V4 O* 4 UQ
Fm. E I --44J
0 v 0 -W)
:p o i o .vi vi. 0= CO) (U W ) i Q u
(U4. S4..-4G J 11 10ruEIND ~ ~ ~ N4$ 6.e
0.lC; 0-4~ n IL--JO aiOU 4. - j C 4 + - ItI )
on vs0 0 -4 k a U4
6D,' E-.ld' 00 -44
0O~ ii 4 * C:P4 C
04 V1 U-1 0' Eo =I Ed z I00~ O~~i 'F - -
0 l -r -0.4 -
I-6oo %nwE 0 t woO- .44 6a P4 C. N 4 I) t
ILIQ w4bE %4 11 to -4 0. 64 ± E If
#a C" 1=1,i. flO IhA4 W14 ON. %4
0U,..4~~r O0A0 x- e ~-
#" 0 6n~ .U 0 *. b. *4.
al 'U04. P44i o4 $14 ~ - 14 L
GiO ~129
0.3 -
W-4 --4
1. 4 00 Q0
V) co -
;P4 E-4l
o3 to(
0 E- r-~
-'1 -4 1" 0 .
63 > "- -4 -4
0.) -4 .t #.a P-4 > 3
-. 4 L0h ) a).W04L
go -4 =1 -4 C.)
W 0 0.) hef q i - (
1 0 - 3 11 l1 - -
'.3 -0 ::1 940 C.) Am
-4 $4 fa. to~E ~ 4 ~0) i E- -0 C) -4 C- 4c.)
S-4 'd 0. U &.4 u 1
P, 0 =f b. 4 ~ to
030 wi 0k QO. - 0. ~-4 -
hd "4 -4 S4 6-4 ~~. 4~
0. $A3 Ad. ~ 0 )~
W--4
94 N a...e E -.to
'U c
4.3 ~ 0U ~ *~ N. ~ 130
(U a)
W a)
61 6a 0 to vGo4 -Z -4 U4
0 0 r. V% a), -if r
0) LU -4A 0 0
CU 9: 0 *4 f4 1 -4 .
o =0. A:4 -4~ -4- )40
k~ 4 Ad4 .0  AD 4A
ul- a) I.$ .. x -4 0- 4)4
C 4q4 o - U
4-4w tS m
N.a ~ 4l j= E~ -~4 C. 0 -4U. 4 "I'I 4)0 011 4AIQAn0
4. 44 a C) 11W( -4 A
430 )0 E: m" l
(U ) W 4 u ) U -P4 > CE.d E o04 0 .' -44-U U~l 0 i0 Ad uf
-4 jo (a~ 4-~ 0
E..4. s. 4 01C 0.S.. W. f=~- 0 m S."C m) -4 $A
TO 1- S2 r NO OE *. E-4 4 = V
W -4 V) 40 -4 - 4 FA . 4 U3 E- - E-4
40 -0 V) to* M .$4. 4) to 0J 0)a -2 -40 m~ to
v#- to 6a 40 S2 1")I -144 &' 0E E-UN ' towif 4 Id a) 0 -.4e3.0.
*-a W -.. int 4 -.
im w- -4 4 :p4 d)3- 0Z-4f
39 .0 R *a 53 -4 w -40 00o
1.. 4 J~ qfl oo- &a0 to-Q) 0 L 0 '..S w N
4) -4 0 . 4 a 0md.. 3 * 1 )4
-4 w44- ~ , $ 0
.-"O~ J 40 4 ~ 94.
-i 'm E 0 .44 .0 -4~131 -
-q1. Ad0
di -4 0
0 3-, .4A& 00ago 31 E
PA -- o. #:Ga GaV :w -4 ( LO
E4 E-4 *P
1 - 4 IfWo4 :3 0 -hdS 4 4
cu &4 X'
(U C- ;M E u 1 U Ga -IV ai - 41c e G .4-$4 / -44 U .4-q
-- E4 0 () cl X -4 in- 0a-U rE-4 *2 ; IJW++ v -
Ga#- EU , - - E- - G
to4E It cuc 9:- 3
w- to~ -4 1 C4 i - 4 3 1 1 bd *- -
to to 4)A k 1 A - E-4 ~ato m GJ4 to4 64~ Ua 6-.I
X30 k a F 6D E a)~ d) -4e~ S4
1116 1,. 14 0Z 14E-4-
116 GE~5-0 II I
GaO fr4' - 0 A~U132
IId
,-4
toA431 &a M-1- 3 -
.. 4i1 h
E-40
0
0 U 4
54
o .
#9 - "l II S3 .A3- k -""- t
133
.. . . . . . . . .. .. - - I 1 . . .
0Abi -4 0E
-44 0l-
&S 4 h.j 4c0i 6.1' -f
.4 4
0 . ra r u 3
It 0 -4 W c
o 4 4*a oa4 0 -
#.a C3I It.. -4-) -
0.b toN 10 cJ + 0
34 >- m - 4 4 0e -4 I ..
to (aO 113 1 931 i 4) N 4.3 * bC0
a) 0) da 0 Fs P= .. )d k .-. I= 04. /4.3 C3 u .3 0)C . 4 14 1- 00.4 N + I kiv00 a)s~ on to& 00" 2A2Ai + -1164 Ifl 4.3 4.u XI c5to t45 b .. 11 1 ..5 '4 -4 I
d)E4440 *0 164 &43 4 & 0 0) % II I
a. -4-4 &- P ) t J . L4'd -4 -4
0 1. toA t).v #vI -4 0 :1-.t L 3904 ." *j- JA - , 1- &4 f"* . 3 4 0 -. d
Adi 3 3 -39i- . E 4-
a .RI0 -- 4 0). ml0 4-
-411 P404l 4-4 39~ 4. 0
s- fh 3Iq 41d
54 ~ a'a '-' 33 iidi .4.1.34
] 00
hd &
- 4 Q A 40 .. 0 9
Ov 1:X: -
to 0. v4-4 m
cu 64 P. "a j t
C - 4 X: 0:E4Cto a%.I rm d) & 4Z
+-4 I 9Il~' - ii C.) =
oq * 0 * 0 16. Oj
r0o P4
1356
0) 0
E0 (u 9
-4 C.) C
10 10 E1 dC WE543 O-V 4.) 44.
ajk 40 4 0 U
4-a 0)
44 ) 0 10 I --4 -4 4) 01 4)
CO) $4 0 0)
9 0-4 r. 0Ji 5
4) tv 4.)
1.4 1.4
-- 4 ;0. E. PO5 --f
;0-4 44 II vi4 M4-4 -U r-0 -a#a L
-4 t0 -4 11
m0 65..4 Ad0)1GJ' 0' 'U- --4 ts 04F
4.) 4. U. 4 4.) 0 a
CU0 0) ) 0* .-i v 6..-a-44 -4l Id -- nt + 4 5..n -
0 6 M t E) f4) y - 4~ P0 4 (U LJ rfl. E.. U =-.W41
w4 .4 -4 4)W hd 6- 'U4~ &. c
6) U ) C3 0t) to) J=1 11 -4A2 ti &0~t E-44 -- E- UE E -
to (U P-4 c 4u >) 6451j (a
540 C) 0)0 (U ) f*)i- U +3 M: T-4 NA2 C. to 0-4 4 rA4~ FS4 U4.
a0 *- Li 0 aEU * -N 0 4 4
cu- 4) 4) Ad 0)*i9~S 40-4 4 )0 0- 'a ' 4 -..4.
be a. W4 -0 E ~ ~ .-4W rq to 10 4) -00 s
*~ Cl4.~ 0 ~ I-'4 E Fs~r4 *%136.
-4 '-4
a) CP l -- q C
1-4- a)U *U a)E Zi 4) P. i
qu PP (Cb 31; cP. E4 ;QO -4 0) P
0) QGj '.n' to ittAC( CL.4 0 G di 1.4V
aO 92 0-i.i --4 -- G V' L;" > p .
U4 It4N G
(C~~- *2G G -4 PE-* -
0= . 0 W) V)£ to &"4
0- -4u 04. -P4 go.M-4C-4 (U O9,O- wl rs. . " f G.) Q " -
0 0) OP 1..c 4.1U (C z Lo o..- 0o 0. Ts-4U" 9
o.i* =) *.. P--4 0G -' &4. E-&n- If~ "C --4 L) P :3 E 9.4 -
toP (cG 2 cn Iu u -ain E
00)4. (1) vO .34 MOPP' -+GJ-
S.. Ga 4 $-a *-4 (U .- 4P - J4WI - 4 -4-4
*A 4.fi W) L) *C NN. * o 1 =f4. Pa.- ( - ,3 1
137
54
0 31
-. a
f 0 Oi
4) 9
U) - f
X: 04
o 4,nM0 V
+n ait 3 3(I,- E-A40
+ii a - 63
al 0"\ 94-C4 -4
3 9-.--- 4-'~ 4-138G
0u (L Q
CU
0) W 4-4b95G di - 0 -4
.. 4 S.. -
C: a)4 hJ (4)U - b) f0.- a) di 14 =.- (v
d *w4 P-4U() LE) 'U Zf -
to M c o 4 LAOJ- C.4 .- 4 -0 o ~ E (a) (
A2 (D.-4 I.. C):4)u -4 ea -Ao.to4 = ( 0 a)) #. '.) --4 Q~d
-- V4 4- UO.4 11
Tj GO >O4 4
di- CL) 4) 0 C)' #-a . -- 4 5.in toS. 04 m.) E di 1 0--4b~ > 0f to W 4)0 a '
a)0 di l-4 $- n nP -4 &14 )
P . -4 -4 0. () A94uC&CU9 q0 (1 )Wt if-4
P. V4) 0 E-4 II -
a).~ 04) QJ-4J -i44-4)0foafl.o ra 0 cu CI- 1 3 -
W)* 4004 to =1a *=e n -- 4 ..0- 0-4c 0 & .4, 4):3loU, -. 1
4)0 0 *-4- .2 -- *4JC-4
0)di 0 0.) -M-4 :b 4- = )C))
o) * 0 0) E 7 E-40afC J= 4JJ CUC -2
W to > 4 -4Q :,4d)E I CU 0ja0 U.--
-4 P- .'4k :3 fO( 4)4 *.4 E- m4) IV *a -~4 :3. 1"~ 6a 4) CH0 11
0- 00"4 r 0 d4I= . -- ^ o Aill *c)0ad 96. :*p va w= t u- 4& 4
* -a =101.%41 04)E #- .- .4 a) ..
-4 d) 0 0 *a r40 93 ij-4 ko4.- 90 cu O 40 w It 4-4cu 00 53 9 16h5Ec.X.U 4 4 L24t 04zS* &0 >0 W-4 4
lu 0) to 5..4 0 v0 d W : 1%4..G 4 93.. 04 l a - E4 i A- ILI
lp 0 a C) ba9 C /(u1
E (U41. ou 1 .
139
a a-
'4 0 4
0.1 -- 4-
III I -4 I -
l e 4b IE 1
m to $3 *
f - 4 -111 C
(a4to-. 1 -4
00 W 4 0 .t -(
toG t 4 40 39l - 00 P4 +_
&4-4 - 4 I ~ k 4& -4 ( o
-4- * R - U &a 46-6- = - -DW' 4x & . 4 10 '4 UfC > P
** 04 " r -4 -. "d E. (Z -
r. 0914 (U Fffi0 -j. 4 II* *-e
X:I I 4I I ~ANl :Siil I 4 Y4
-49.4I III1140
1- 4
cn II &0 --~I1 II 9e. -
*- 0 0 -' .W-4 00 - -
. --* ,... 13
w I4 wa w 0
vi 0
It- .4 " d . as a
S U-- &4 ,w t
Z ,, 0 .-- cu
II /I-. --- I -1 1 :5)
-4 ~ IV or 11 -
k k- 44 J
k -49 "4 4 9- ,0
- 0 - 00 ' *- - ,
04 r00 0&
1 . , i I K i- . 1 .
%w .4- 01 v W4 0 is. a) g0I
-* 1-4Cgo V-44w4 .,0 C/2.4 k Il -) I I/")Cfl1, U :- - II -, -
S0 .* &r 0 4 I
0 * l q-4 0-...4 4 0)-
:06'Q "0
*W4I'- IZQJ.- -44
54,.fl 5 1.4.41 4~4 141
-4 a 4(
ou Q. C.)
-4) 0 4A
kU S. 0toa 1. 6
o CD to-4 c
0.4 -4WW 'A4
00 4* &- + c m0.0 0 + -4 "I"
44 0. E-'C0
0=
041U 04tbV g.o
uuaJ'a +Wo
V- tug
" 3- C)0d P4GJ4
aj~ajQ -,142
1\0
W149
0. 0
W-4 +t" s
-14
L IST D i EF C E Z
1. 1Ive rson, O., Cra to rb , A CA r ~rInSA t i 0ns cn ro---.-irg Tan~id,- an~ri Sgcztemic, Vol. 1 , N'o . , ct-te - 19-79 .
2. DIstr a, E. 4 ., A i s,i ]i no nT'--i 'r~rri r--, Pre r., 4
r. reer.. C. , "Te D-biken otf tne PSI . ro 1 -Syr tr t,
nr SnftwA-P Ernginring P.4-A',Octooer 1&?~z.
Glass, R__F._,____________P o __________-- ______
Zorpu ti nz Wo rlda, 1977 .
b. Heidorn, 1 . E. , "Automatic ?rowraprrpin? Thqrow-en NaturalLa ngua ge DialIog : A Sur vey T T'4M J Dos Dv ',q 33tJuly 1z075
6. Bier-nann, A. W., %,aturai Tranguac Prrrz-sir-, pappr inpreparation, Naval Posti-ra'iuate Scftool, 19061.
7. Wlalier, D. E., flnp,ni0'1 nr' , ic TAngu; P, El'Sevjer
S-nitn , 1;. R. , .A CPS I n for inl Autmratic Pro-rr-InSysto-n , rigag-1inss n** rpi- ?t) Ttzrnar~ana :Qi L
rnrPOz!-z n A~rf"3ia Ert~ !--~r Vancouver,B. 0., Canada, lYt~l.
14. 61na Z. and Wallin-ver, R., -P Deductive Approacn toProgram Syntnesis,'. ACM Tr-,nqsArtjrior nn r~AmLanyuagqps A~n1 yj Vol. 2, No. 1, F. -l?Z~anuary 1980.
10. Minna, Z. and dallinoer, R., "Syntflesis: Pre ams ~=Progra1is," 1Ehk mrnatnc nn SnetapTol. SE-5, 4Jo. 4, july 19079.
I1I. rm3n n , A. 9. Aroa-tem to Auto-,ti-! ?roP:irr-:ir.?
i2. snTita, r. .,A z:rv e xcf ta e Syn t aZ-S is ofI IPPrigrais from Exam~les ?rnrPeejino; +'rIn' tfmrr at nA I WgrrtkfloL n; ProguaM Cnns ~it ion,Bonas, Frince, I O
13. ISu mm ers , .P. D., "A "-toaoio--y for LISP rz'Co -,s tru ct o n ftraom E x arp 1 es , i A.C L 4-, F. 1 b 1-1-(5,19 i77 .
14. Bt er-rann, A. h. "T'ri Inference of* Reoul ar 1 z F ~r ogr, 7f r om E xarn pI es T tP E EP t1' Ti ryrm L;r-qnr
TnAortion anr1 Covnt!'o, Vol. 19., P. 447'j74, 1qb7.
1,-4. ti erman n, A. W . anl Kr I nnaswamy , R " Co n s t ricti nt-P rog ram s ftrorl Exa ple C omputa t ions, T PP '"A ~crti or. C!
Septerrter 1976.
17. Bleriiann, A.., Baum, R. I. ani Petr~r, F. E., *Soeer.irgup tae Fyntnssis of ?ro--rams frcnY Traces, - 4Transat-tica~s on COrPr ptrs, Vol . C-?'i, No. ?-, F . -1dP. 12e-1355, Fetruarv 167b.
lE BierTarn, A. d. , "Automa tic Irrtc of, I.!22';-nxlnInstructl')ns in Pro, -am Syritnesis", InFratna.jnhlrna j o** CInrQiit-~ a~ 1L~r Mr nn Zr('1 -c;S 7ol.7
No. 1, Marcn 1 7S
19. AnglulnA D., "Fin,41ne Patterns Commn to a Set ot
Aurust
BIBLIOGRAPHY
Bibel, W.4 "Syntax-Dtrected, Semantics-Supported ProrramSyntnesis , At1iicial Intplitzence, Vol. 14, P. 243-261,1Y83.
Follet, R., "Syntnesisinx Recursive Functions with SideEffects , ArtificiAl Tntelligpnce, Vol. 13, P. 175-20,1980.
Hewitt, C.E. and Smith, B., Toward a Proprairrine Apprentie,TFEE T nArtjnnil qnftware Vneireerin Vol. SE-i, No. 1,P. 26-45, March 1975.
1 4b
INITIAL DISTRIBUTION LIST
No. Copies
1. Defense Tecnnical Information Center 2Cameron StationAlexandria, Virginia ?2314
2. Library, Code 0142 2Naval Postgraduate ScnoolMonterey, California 93940
3. Department Chairman, Code 5"'? 1Department of Computer ScienceNaval Postgradtuate SchoolMonterey, California 93940
4. Professor Douglas R. Smitn, Code 52SC 1
Department of Computer Sclen-eNaval Postgraduate ScnooMonterey, California 93940
5. Captain C. '. Miller, USMC 1109 Arterburn Rd.Louisville, Kentucky 40222
6. Captain J. S. Lape, USMC 1b207 Doncaster CourtSprinfield, Virginia 221bO
147