Experience with KRL-0: One Cycle of a Knowledge Representation Language

EXPERIENCE WITH KRL-0 ONE CYCLF: OF A KNOWLEDGE REPnESF:NTATION

LANGUAGE

Daniel G. Bobrow, Terry Winograd, and the 1\RL research group·

"The projectl' and implementation described in this paper were done at Xerox Polo Alto Research Center, Palo Alto, California by Don Bobrow. Run Kaplan, and Martin Kay from Xerox PARC; Jonathan King. David Levy, Paul Martin. ~litch Model, and Terry Winograd from Stanford; Wendy Lehnert from Yale; Donald A. Norman from U.C. San Diego; Brian Smith from M.I.T; and Henry Thompson from U.C Berkeley.

The goal of the KRL research group is to develop a knowledge representation language with which to build sophisticated systems and theories of language understanding. This is a difficult goal to reach, one that will require a number of years. We are using an iterative strnlegy with repeated cycles of design, implementation and testing. An initial design is described in an overview of KRL (Bobrow & Winograd, 1977). The system created in the first cycle is called KRL-0, and this paper describes its implementation, an ana lysis of what was learned from our experiments in using KRL-0, and a brief summary of plans for the second iteration of the cycle (the KilL-! system). In writing this paper, we have emphasi~:ed our difficulties and di sappointments more than our successes, because the major lessons learned from the iterative cycle wt>re in the form of problems. We mention only briefly in the summary of experiments those features of KRL-11 that we found most satisfactory and useful.

In order to put our experiments in some perspective, we summarize here the major intuitions we were testing in the design of K R L-0:

1. Knowledge should be organized around conceptual entities with as~ociatcd descriptions and proc~dures.
2. 1\ description must be able to represent partial knowledge about :tn· entity and accommodate multiple descriptors which can desc ribe the associated entity frotll diffcr.:nt viewpoints.
3. /\n important method of description is comparison with a known entity, with further specification of the described instance with respect to the prototype.
4. Reasoning is dominated hy a proces~ of recognition in which new objects and events are compar.:d to stored sets of expected prototypes. and in which specialized reasoning strategies are keyed to the5e prototypes.
5. Intelligent pro:;rams will require multiple active processes with explicit use r-provided ~;c hcduling and r(source alluction heuristics.
6. Information should be clustcreu to reflect usc in processes whose results arc affected by rcsource limitation and differences in information accessibility.
7. 1\ knowlcdg~ representation hlll);IJage :nust provide a flexible sd uf underl ying tools. rathc~r than embody specific commitments :tl>nut either procco;sing stratq;ics or the rcprcscnt:ttion of specific areas or knowledll.e.

Some of th~s:: intuitions were explored in GUS (Buhrow, ct al, 1977). a di:tlu:; sy,,te rn for makinJ airline rc~ervations. GUS used ideas of proc.:dural attJchmcnt (Winograd, 1975), and context dependent description (Bobrow & Norman, 1975). Experience with GUS led to some changes to our ideas for KRL-0, although GUS and KRL-0 were bJsically concurrent projects; we started programming GUS just prior to intensive design on KRI.-0. The GUS system was primJrily an attempt to explore the integration of already existing programming technology for a performance demonstration , while KRL-0 was a first attempt at outlining a new basis for representation .

I. nuilding the 1\RL-0 System

KRI.-0 was implemented in INTERUSP (TeitelmJn, 1975), along the lines desc ribed in Bobrow and Winot; rad (1977). The design was specified mostly during the summer of 1975. The initial KRL-0 implementation was programmed prim:uily by Bobrow, Levy, Thompson , and Winograd during December and January, with parts of the develorrnelit being done by the rest of the KRL group. It included basic structure manipulating facilities, a reader and printer ftH KRL structures, a simple agenda manager and scheduler, a procedure directory mechani sm, and a matcher which handl ed only the most elementary cases. ~~lany more pi eces wen:: built into this system by people working on the test rrojccls over the following (, month5. The system was first impkn1e11ted on the MAXC computer at Xerox PARC and later transferred to the SUtvlEX PDP-10, (where one of the projects was clone as an /\IM Pilot project). and to the li··1SSS PDP-10 at Stanford. When the test projects were complete, the system was retired from active duty.

1\s an experimental system, there was no commitment to continue support after the initial purposes were sati o;f i<:d. Despite its avowed experimental natnre, however, building KRL-0 was a major system programming cff"ort: progr~mming any "new AI l;; nguage" for users is larger task than just trying out the new ideas. Having the many facilities pf INTERLISP to build on eased our programming burden, but a number of new facilities were built for the project:

• Ron Kapl an developed a set of utiliti es, including spec ial data structure manipulation and formatted priJ.ting routines. as a base for much of th~ implementation. The entire utility package (cJII ed u:;vs) was in~erfaced so smoutltly tltat the ust:r could think of it as simpl y an extended INTU:I.Isl'. This padagc will be used in the development of KRL-1.
• An on- line cro~s-cefc re nce and decumcn tation system (called the N.\MES systL'Ilt) wns u:;ed to coordinat<.: lh~ efforts uf the people dving inter::ct ive dd1ugg ing uf a sh:J rcd se t of progra1ns. The f:tc il ity was designed and built hy P.on Kaplan and ivlartin Kay. It COilllllUIJi<:atecl with the editor <~nd file pack:I!;C

f<.H.:i ii ti;.:·-\ in INTERJ.IS:· SO lh:!l lht! r: ru~~,fallllll l! r w::·, oron:plcd fur a CO!lllllL'Ilt wht; !H:vcr prot~r tuns or rct:nrd declarations were created or ed ikd. The information avai lable to the system (e.g. procedure name, variable names, etc.) was combined with u s,~ r supplied comments in a standardized da ta base whi ch could be interrogated on line. The programmer was automaticall y warned of potential naming confli cts with any thing anywhere else in the system. It also provided facilities for entering comments associated wi th global variable names and file names. The file of names grew to contain over 1000 entries during the cour~e of implementing KRL-0. For the KRL-1 in1plemen tati on we are extend ing the interface to wo rk with Masterscope, the INTERLISP cross- reference and program ana lysis package written by La rry Masintcr.

• A simulated match interface was built by Paul M:utin, which enabled the programmer to intercept call s to the matcher and gat her data on what kinds of problems came up befor.: programm ing the necessa ry ex tensions. The use r returned an answer for the match, and on fut.ure identi ca l ma tches the same answer was used.
• A tracing facility for the matcher was implemented by Jon:ilhan K in.z. to facil il<l te debugging of programs v:i1ich were organized around matching

As pwhlems came up in using KRL-0, they we re hand led in severa l W<~ys. Those which seemed general and could bt: handkcl within the ex isting framewo rk we re set up as tasks fo r the KIU.-0 prog r~ m!llin :; effort. Usual ly des ign di scuss ions were shared l;y everyone:, and the implementati on clone by the person whose program f<:crd the problem. Those problems which we re ci the r too speciali zed or obviously beyond the scope of our current dc<;ign we re programmed around by the problelil·fimkr. Most of these c~scs led to changes in the KIU .-1 clcsiL;n to ~cco 111odat.e solutions more nat ural ly. Bec:.1usc :.:RL-0 was er111Jeddcd in INTEit l.iSP, "patching" was usually straightforw:ml in that it was the same as what wou ld have been involved in trying to wr it e the program in a bare l l·: r r: iU.I':P in the first place. Of course, sometimes these "patches" interacted witl1 ot her p<Hts of the KRL code in nn predictc:d ancl confu,: ing ways. Those probl ems for which there was no ~cce ptahlc way to esc:l[JC we re ch:riked up to exrericncc. ;: nd the 60a ls of the progr:tm rcduced acco rd ingly. Usu;!il y t_his was in C: IS·: s ·.vl1cre ti Jerc had be,'ll an umesolvcd questi o;1 as to how much the prugr;un should be cxpeckd to li:ll·idlc. Issues raised by these problems were a mnjc r driving force in the KRI.- t design.

A very rc u ~~ ~~ draft of a mJnual was d ist ribut ed, bu t bcca 111C ra pidl y ob;.olt::tc as ~i:( ~;yst em evolved. It w:1s highly in cun1p!u~ (l'or cx:unp l.:. the section on the match(·r co n s i s t ~J t>l. a si11gk Jnr:t~raph de.,crihing why the ~;ection w:1s r,o ing to he dit'ficu lt to write). It was never cor11pldcd or re-edited, and tho··:·: doing the programming had to rely on di sctbsion with the implementers and on the source code of the interpreter for up to date information. It worked reasonably well , with some frustration. but not enough so that anyone ever fel t moved to volunteer the time to do the writing needed to produce a real manual and keep it current. We were somewhere around the upper bound of the size of project (number of people, amount of programming) where so informal an approach was feas ible.

2. Experiments using K RL-0

KIU.-0 notation and programs were tested in nine different sma ll projects. Each of these projects was intended to test some aspect of the K RL-0 language or system. They took from 3 to 15 person-weeks of effort each. In most cases, the goal was to produce an actual running program which could handle enough examples to convince us that it did ~ha t the or iginal progr:~m was intended to. In no case was an effort made to do the kind of fin ~ l debugging and polbhing which would make the program robust or us::tbk by anyone but the original author. We wi ll descr ibe three of these in detai l: a cryptarithemeti c problem solve r; a story anal ysis program; and a medi cal diagnos is system. We li st below the other projects that were done to give a flavor of the range uf projects tried:

• LEGAL done by Jon:~than King an i m plemcntation of a portion of a lega l reasoning system s~etc hcd by Jd fery Meldman (1975) in hi s doctoral cli ss·:rtation. Thi s program forced con s id c r ~: ti on of match in :J. in whi ch both patterns and data could speci fy bindi ngs that we re needed.
• ARCHES- - done by Paul Martin-- a concept lt':~ rning progam based on l'atri<: k Winston's (19 75 ) program for rcco!)n izi ng vi sual scenes. Matching sets of des<:r iptions, and the u-;e of inotance> <·s patterns were the in teresting pa rts of this project
• COl L -- done by Wendy Lehnert -·· :'1 new program for drawin;; inferences about objects, based on methods related to those of co n c~ptu . l l dependency. This program used the contingent desc ript ion mechanism to select kno-.vltdg\.! to be used in a part icu lar contex t, and the agenda to interweave syntactic and semantic process ing of input Engl ish.
• FLOW -- dune by J);ul i:obrow ar1d Df·n Norman - - a program sketch whi ch ~, irnulakd :1 pns<Jn's access to long tcrn1 memory \':l:ile using a n:cently lear11t:d simple computer l:ul!;'lagc. The ind cx ir11~ mechani sm of KRL was used to ~ ; itilll i ~ le prop~rtie\ of human a,;soci:.t ivc rdr icv:d (including er ror:; ,,r va ri ous kinds).
• PHYSIOLOCIY - - done by Brian :Smiih -- a program ske tch whirh explored lhc probkms of using KRL-0 for a system wl1ich could rc : ;~;o n abou t p h y~;io l ogica l proo::sscs. Th is project l'tnccd consitit:rat ion of the ga ps in KRL-0 with respect to specify ing temporal and causal structures, and the need for stronger structuring to factor information in units by viewpoints, e.g., informat ion about the heart as viewed as a mechanism, versus information when viewing it from an anatomical perspective.
• KINSHIP-- done by Henry Thompson -- a theoretical paper, using the KRL-0 notation as a basis for comparing kinship terms in Engli sh and Sherpa. The attempt to communi cate results of encoding to non-computer sc ienti sts led to a simplified notation whi ch has contributed to the syntax for KRL-1.

Cryptarithmctic

The initial test program was a simple cryptarithmcti c problem solver (see Newell and Simon, 1972 for a description of the domain) written by Terry Winograd and debugged and extended by Paul Mart in. It exercised the basic data structures, agenda, and triggeri ng facilities, and was successfully tested on several problems (including DONALD +GERALD= ROI3ERT with 0=5). No attempt was made to provide complete coverage of the class of problems handled by humans. Interesting aspects of the design included:

• ~ Use of triggers to combine goa l direc ted and data dirrcted proce:.s ing

• Us<! of "patterns" to suggest strategies
• Us.: of levels on the agenda to control ordering of strategies
• Usc of multiple descriptors to accumul:Jte information about the value of a letter
• Use of contingcn<.:i es to handle hypothetical assignments
• Use of the signal table to control work within hypoth<.:tical worlds

Muc::h of the process ing w;1s assoc iated with proced ures attached to the units for Colu:Hn (a vertical column in the addition problem) and Lcttrr. The Unit for Colnmu is given below. It give:; son1e idea of the us·; of procedural att ~!chment to prop~, t~atc information. sea rch fnr palt~rns swh as a column with TwoBI:·nl;s ancl trig['er arithmetic proco:ssing (using the I.ISI' function l'rocc~sCol wnn).

(C'OI.li~IN liNIT Basic <SE I.F II> <tcftN<'ighhnr (a Column)> <r i :~h t i'Jl'ig::hn r (a C'ulnmn)>

<t npl.r11rr (a I dtn)>

<bo11omLt·11rr (a Le11er)

(lri~crrs (WhenKno11n

(lloWhrnl\nm·n (topLc11cr) Column

(Tr)TnFurthrrStlrcify UNIT

'(Twolllanks Onrlllonk TwinAddend)

<sumLdtcr (a Letter) (triggt·rs (WhrnKnown 'AddendType]> (lloWhenl\nown (topLe11rr hotomLr11er) Column (ChrrkSumF:~tuaiAddrnd UNIT]> <top()igit (a Digit) (trigJ.:<rs (WhenKnown (A"ign 'lopl.e11t·r)(l'roces;Column)))> <ho11omlligit (a Digit) (lrig~rrs (Whenl\nown (A"ign 'bo!toml.r11rr)(ProcessColumn)))> <snmiJigil (a lligit) (trig~ers (Whrnl\ nown (A"icn 'suml.rtlrr)( l'roressColunm)))> <sum I ( itn lntrj~cr) (wlikh t,sumOf (AIIItt·u" (the carryln) (the topDi~it)(thr hotloml>igil)))} (tri ~r:crs (Whcnl\nown (ProrrssCnlumn))) > <carryln I (an lult·ger) (XOR 0 I)

(the carryOut from Column(the ri ~htNci~hhnr))(; CARRYOUT)}

(tri gr:··rs (Whcnl\nown (GoFill 'CARilHlUTJ(ProrrS\Column)))> ( t·arryO"t I (:m lntt~rr)

(XOR ()I)

(the t·arryln from Column (the lr fiNeiglihor)) ( ; CAHRYIN)}

(lri ~~rrs (Whrnl\nown (C;oFill 'CAP.H\'IN) (l'roccssColnmn)))> -1

There was a set of recogni zed patterns for columns (for cxnmplc, ~ cclumn with the sum letter identical to one of the add.:nds ) and a s.: t of pattern driven strategi.:s was associated with each. Each strntcgy was a u~;p proced ure which used the K RL-o structures onl y as a data b:~ se. Some of the strntegies c~'uo;ed values to be computed. Whenever a new value W<1S filled into a column , tri[!g,ers c;w~ed data driven strategies to be suggested, such as trying to hound the poss ible value of other letters based on this information. Constraints on valu.::s were <1dclecl in the form of new desc riptions for the value of the letter, for example srecifying that the value must be an even or odd integer. Each such descr iption was added to the ex ist ing dcscrirtion of th.: value of that letter, so that at any point in the computation, some letters had a value described as a s r~cific di git, while others lwei comrlex dcsciptions, such as "(j rcat~r than 3 and odd". Fach time a new description was added. a tri gp,e r in the unit for Lt: tter caused a proccdur·e to be run which matched each s till-un<~ssigncd digit aga inst the ;;curmulated d<:scr iption, and if onl y on~.: mat<.:hcd, it was ~ss i gn c d.

V/hen new strategies were sugges ted by a new value b''in t', filled in, or by . the match of one of til e p~tter ns desc ri bing rolun1n ;;, ~ill of the trin:.cred stratcgi,·s were put ontn the: ac;cnda. They were ass i~,;n ed priority levels on the b~1 s i s or a fixed scheme: Level l was in11ncdiak propag;Jtion of infunn:Jtiun (e.g. if the value or a kttt.:r is lkkrmincd, then that v:lluc gets cnt~rcd into all of the places wh~.:re the lcuer appears). Level 2 was for straightforward arithmetic computations. Level 3 for the strategy being worked on currently, Level 4 for other simple strategies, Level 5 for more complex and less likely strategies. Level 6 for last-ditch strategies (brute force trial and error) ancl Level 7 contained a single entry which caused the problem to be abandoned.

This rather ad hoc use of agenda levels achieved a number of goals. The usc of Level 1 for simple propagation served as a kind of data locking scheme to maintain consi stency. As long as there were more results to be propagated, no other part of the program would run. This meant, for example, that if some letter were assigned to a digit, no other letter could be assigned to the same digit before the result had been properly recorded. The use of a separa te level for the current strategy allowed it to trigger sub-st rategies without ge tting put aside for work on a different st rategy. 1 his meant that each strategy could run to completion. The use of levels to distinguish how promising different strategies were allowed the system to focus its effort on whatever were the most likely thing~ at the moment. Pbcing last-ditch strategi es on lower levels when they were thought of made it easy fo1· the program to fall back 011 them -- thcy automatically ran if nothing at any hi gher priority was schedul ed. Thi s provided a we~k global structuring in what was inherently a data-driven process.

The mechanisms for multiple worlds <1nd contingent descriptors made it poss ible to deal with hypothesized values while using the norm;Ji mechani sms. When all hut two possible v~tlu t.:s had been .:l imina ted for some letter, and no other strategies were pendi;1g, the program chose one of them, and created a hypothetical world. in which the letter had that value. D.:: ,crihing the letter as having that value hypothetically caused all of the same triggering as would noncontingent assignment of the value. leading to propagation of new info,ma tion, computations, strat egies, etc. However, by modifying the signal tahk, all deri ved information was asserted as con tingent on that hypothctie<il world. This special signal tabl e al so affected the process ing in two other ways: First, only si mp!.: strategies were all owed to be placed on the agenda. Second, if a contradicti on o<.:currecl, the hypothesis was rcjcct·~d instead of the prohlcrn being rleclarcd impossible. If a hypotl;c;i:. was rejec ted, the contingent descriptors were not renwved, but would not be accessed by programs lookinn for <kscr iptions in other hypothetical worlds, or in the world of actually inf<!r rc<.l facts.

Sam

D:1vid Levy implemented and tested a proeram which reproduced the simrle test analysis ~ n<.l q111:sti oning a,;pccts of the SAM program (Schank et. al, !975) wh ich uses scripts in analyzing short "storit·s" containing styli1.ccl sequences of events. It used Ron Kaplan's GSP parser(Kaplan, 1973), and a grammar written by Henry Thompson for the initial input of the stories. It processed two stories (Schank, p. 12), summarized them and answered a number of simple questions. It was a full fledged language- processor in that it took its input in English and generated Engli sh output. Questions were entered in an internal representation. Its main features were:

• Interfacing an extstmg parser (Kaplan's GSP) with a KRL-0 program which used the results of the parsing for further analysis
• Using slots to represent the basic el ements {both events and participants) of scripts, and perspectives to represent instances of the scripts.
• Using the noti on of "focus lists" as the basis for determining definite reference, including reference to objects not expli citl y mentioned in the input text. It used the index mechanism to speed up sea rch through the focus li sts.
• Using the matcher in a complex way to compare story events to prototypical script events, with side effects such as identifi ying objects for future reference
• Using units describing lexical items and English grammatical structures as the b:tsis fur analysis and generation, using signals and procedural attachment

SAM's basic processing loop consisted of parsing, construction of conceptual ent iti es followed by script lookup:

l'arsin!:· A sentence from the story was fed to GSP, which .produced as output a surface syntac ti c parse identifying clauses, noun phrases. etc. as a KRL decla rati ve structure. For ex:t rnpl e, for the sentence "John went to a reslamant" GSP prodlll:cd the foll owing rather shall ow syntac ti c structure:

(a llcdarc wilh clause = (a Clall'e wilh surr:H:cForm .:::: ".fohn M-'('Ot to H reshmrant" verb = GO subject =(a Nounl'hrasc with head = .JOliN) prep PI =(a l'rcposi ti onall'hrase wil h pr<·pos ition " TO ohjccl = (a ~:ounl'hrase wilh head = I! ESTA ll RANT dcl crminer = A))))

Construction of conceptual entities. The next step was to map this syntactic object into a set of conceptual objects with the help of declarative and procedural information stored in the prototypical syntactic units (Clause, Nounl'hrase, etc.) and in the lexical units. For exampl e, the Clause unit specified that the filler of the verb slot would guide the mapping process for the entire clause, and the lexical representation of each verb included a case frame mapping from syntactic to conceptual structures. Following is a partial description of SAM's representation of the verb "go":

[ GO UN IT Individual <self {(a Verb wilh root = "go" past = "wcnl") (which lsAConsliluentOf (a Clause wilh referent = (a Go with goer = (the rcferenl from Nouol'hrase (lhc "'hjecl from Clause (a Clause))) source = (lhe rr ft· r~n t from Nounl'hrase (the ohjecl frn ~o1 Pnp<i,i lionall'hrase (a Prrp·;sitinnaJPhra'\e with preposil ioa = FROM))) destination = (the referent from Nounl'hrase (the ohj l·rl fro1n l'rcpos itionaiPhr:llie (tt PrcposHion:1IPhrase wit:1 prepos ition = TO))))))} >]

As a desc ripti on was crea ted fo r each conceptual object (e.g. as it was determined that the appropri ate f ille r fo r the goer slot in the above exampl e was (a Person wit h name = "John")), thi s desc ripti on was matched against a li st of units in a f ocus li st whi ch contained the conceptual objec ts thus f ar crea ted. If the description matched one of \hesc objects, the slot was filled with a po inter to thi s object, and th is object was moved to the front of the focus li st. In o rder to make the sea rch through the focus li st faste r, the index f ar: ility was used to fi nd good potenti al matches from the li st. If the desc ri ption matched no objec t, a new object (a KRL unit) was rren tcd , the descr iption was attachl!d to it, and thi s obj·:cl was pushed onto th \! f ront of the focus li st. In thi s way referents we re establi shed and maintai ned .

Thi s scheme handl ed pronumina! as we ll as dcfi nit;! reference. from the wo rd "she", fo r examp le, the concepli:al descri pt ion (a Fcmalc l'crson) was constr ucted, a desc ription which would ma tch the las t menti oned reference (if any) to a female person (e.g. "the wa itress").

Script lookup. Nex t the program tr ied to identify the conceptual event just crea ted as a step in an ac tive script. lt did thi s by stepping through the sc ript from the las t event identified, and matching the description of this prototypical event to the event just created from the input sentence. This process exercised the KRL matcher rather heavily. Once the step in the script (represented as a slot) was identified, this slot was filled with the new conceptual event. In addition, any previous steps not explicitly fill ed by story inputs were then filled by creating conceptual events from the prototypical descriptions contained in the script. These events too were added to the focus list. The program also dealt with what-if's or predictable error conditions, but these wi II not be discussed here.

The result of this iterative process was therefore the construction of a representation for the story consisting of:

• a set of syntactic units representing the surface syntac~ic form of the input sentences
• a set of conceptual units representing story objects: people, events (including inferred events), physical objects
• a focus list containing these objects
• a (partially) instantiated script, whose event slots were fill ed with the conceptual events in the focus list

Having analyzed a story, SAM could then summarize, paraphrase, and answer questions.

The different stages of process ing in the analysis of inputs were controlled through the use of special signal tables. These tables provided sp<:!c ial responses to the addition of descriptions to units. For example, the search for a referent wa,; keyed by a signal se t off by the add ition of a perspective of type NounPhrase. The generation process used a different set of signal tables to direct the inverse process of building a surface syntactic construction from a conceptual object. SAM was an interesting exercise in system construction, useful mainly as a tool for understanding problems in representation and debugging KRL-o. When finished, it did not, and was not intended to, rival tile power of the Yale group's original program.

i\-lt·dical

Mitch Model implemented and tested a program for medical diagnosis based on a model for diagnosis which had not been directly implemented before (Rubin, 1975). In writing the program, it was neccss,ny to fill in a number of details, and correct some minor inconsistencies in the original. The program successfully dupli cated. with some minor exceptions, the performance dc;;cribed for Kubin's hypothesized system. l'art of the reason for the exceptions was incomplete specifications in Rubin's thesis, but there was also a major problem in that the implementation LISP code and data base completely filled the storage available in the KRL system. (This program, SAM, and COIL were the most extensive tests, and all ran into space problems discussed below). Some of the major features of the implementation were:

• ~ The use of the abstraction hierarchy to represent the set of disease types and finding types. with information and procedures attached at different levels of generality.
• ~ The use of KRL-o triggers to implement the conceptual "triggering" of potential diagnoses on the basis of having relevant symptoms described
• The use of signals to provide run-time monitoring of what the system was doing as· it generated new hypotheses and evaluated them
• A direct encoding of the declarative "slices" of Rubin's version into the declarative forms of KRL-0. This included extensive use of the "Using" descriptor (a declarative conditional) to explicitly represent the decision trees in the units for diagnosing different conditions

There were four major kinds of representational objects in the system.

• ~ ·"Elementary hypotheses" which corresponded to the "slices" of Rubin's thesis; these were named after the disease [e.g. Glomeruli/is or Rena!lnfarclion] the data structure was intend~d to represent. Elementary ., hypotheses had descriptions in slots to indicate such things as likely symptoms, links to other elementary hypotheses that might be rel nted, and how to evaluate how well the patients symptoms would be accounted for · by a diagnosis of this disease.
• ~ "Elementary hypothes is instances" were data structures created for each diagnosis the system decided might nccount for the presented symptoms; these contained pointers to the findings that suggested the diagnosis, and a pointer to the elcmentarv hypothesis representing

the discnsc of the diagno>is. It alw con t:tined values for how well the diagnos is accounted for the symptoms, obtain~d by applying the ev<dtwli·Jn i1~formation represented in th~ clemcnt~ry hypothesis to the specific detail s of the denwnwry hypotiKs i ~; instance.

• "Findings" we re units for specific symptoms, fa~ts, hi storica l inf(lrm;il ioa. physical c.x:11:1ina ti on data, ·lr lab dat.a (q;. Ft'W'r, fl ema luria. or /Jinpsy); a finding was mostly a hook on which to hang proccduml information about what to do when tile patient exhibited SOIIll: thin .~ abnormal with respect to the particular kind of finding.
• Finding instances were the input to the system, having a structure similar to that Rubin suggested in her thesis, having slots for such things as finding, duration, severity, and normality. There were also further specified finding instances such as symptom instance.

The system worked essentially as follows. A unit might be described by:

(a Symptomlnstance with

mainConccpt = Hematuria

presence = "present"

snerity = "gross"

time = (a Timel'oint with

direction = "past" magnitude = (a Qu:mtity with unit = "days" number = 3)))

A WhenKnown trigger on the presence slot of the Symplomlnstance prototype would be set off; examination of the specific description caused this entity to be desc ribed also as: (a Symptomlnstancc with normality = "abnorm;:l") Further trigge rs and traps might result in the creation of new elementary hypothesis instances, according to the information found in the desc ription. After all the information propagation activity, each of the currently active elementary hypothes is instances would be evaluated based on information found in the corresponding elementary hypotheses. !3ased on the evaluation, the status of the elementary hypothesis instances might be changed to reflect possible dispositions of the hypothesis such as acceptance, rejection, or alteration.

The indexing facility was used to facilitate operations such as obtaining a list of all the hypotheses activated by a finding. Functionals and To.lo,falch triggers on prototypes were defined to handle special time-related matches to enable the system to tell. for example, that "3 days ago" is more recen t than "1 year ago" or that "48 hours" is the s~me as "2 days". Signal tables were used locally to govern the handling of error-like occurrences and globally to effect trace and printout: different degrees of detail were specified by use of several signal tables, and it was thus quite simple to change modes by pushing or popping a table. The agenda was used for organizing the flow of control in a manner sin1ilar to that described for the Cryptarithmatic program. The built-in triggering mechani sms provided the means for a very natural modding of the kind of medic<il reasoning discussed in Rubin's thesis.

3. The problems

As we had hoped, these projects pointed out many ways in which KRL-0 was deficient or awkward. People were able to complete the programs, but at times they were forced into ad hoc solutions to problems which the language should have dealt with. The problems can be grouped as:

• Basic representation problems -- ways in which it was difficult to express intuitions about the semantic and logical structure of the domain
• Difficulties in manipulating descriptions explicitly
• Shortcomings in the matcher
• The awkwardness of the LISP-KRL interface
• Facilities which should have been available as standardized packages
• Infelicitous syntax
• Cramped address space

Due to the embedding of KRL-0 in INTERLISI', none of these problems were fatal. Even with the difficulties, we found it possible to write complex programs rapidly, and to experiment with interesting representation and processing strategies. This list al~o does not incluck the social and organizational problems which arc bound to infect any effort of this nature. Everyone on the project exhibited heroism and stoicism, persisting in their programming without a manual and in a rapidly evolving language which kept slipping out from under the programs almost as fast as they could be mollified.

Basic representation probl(·ms

KRL-0 embodied a number of commitments as to how the world should he represented. Some of these seemed intuitively justifiable, but did not work out in practice. Others were too vague to implement in a way which seemed satisfactory.

The categorizatio11 of units: Each unit had a category type (as described in Bol)row and Winograd (1977, pp 10-12)) of Individual, Manifestation, lfasic, Specialization, or Abstract Category. Thi s was bas~d on a number of intuitions and experiments about human reasnuing, and on the belief that it would facilitate mechanisms such as the qui ck rejection of a match if there was a b:1sic rate:.;ory disagreement. In practice, these di stinctions tumcd out to be too limiting. In many of th <~ hi cr<lrchies for spcTializcd domains (such as medicine) thcfc was no ohvillus way to assign IJasic, Specialization, and Abstract. In <kaling with units describing events, the notion of Manifestation was not precise enough to be useful. It was generally felt that although the concepts involved were useful, they had been embedded at too low a level in the language.

Viewpoints: One of the major issues in developing KRL was the desire to have facilities for "chunking" knowledge into relevant units. This proved to work out well in most cases, but there was an additional dimension of organization which was lacking. For many purposes, it is useful to combine in a single unit information which will be used in several contexts, and to associate with each piece of the description some ·identifier of the context (or viewpoint) in which it will be used. In the natural language programs, it seemed natural to classify descriptions associated with words and phrases according to whether they related to the structure of syntactic phrases, or to meaning. In the physiology sketch, there were clear places where different viewpoints (e.g. looking at the form of an organ or looking at its function) called for using different information. There were two primitive mechanisms for doing this factoring in KRL-0 -- attaching features to descriptors, and embedding information in contingencies. Both were used, but proved clumsy and felt ad hoc.

The relation between prororype and concept: KRL is built on the assumption that most of the information a system has about classes of objects is stored in the form of "prototypes" rather than in quantified formulas. In general, this proved to be a useful organizational principle. llowcver, there were cases of complex interac tions between instance and prototype. In the medical domain, for example, a disease such as AcutcHenaiFailure could be thought of as an instance of the prototype for Disease but could al so be thought of as a prototype for specific cases of this disease. There are a number of issues which arise in trying to represent these connections, and although KRL-0 did not make obviously wrong choices, it also did not make obviously right ones. In general, we seem to have been hoping that too. many consequences would just naturally fall out of the notation, when in fact they take more explicit mechanisms.

Further specification hierarchies: In simple network or frame systems (see, for example �oldstei:-~ and Roberts, 1977) there is a natural notion of hierarchy, in which each descendant inherits all of the slots (or cases) from its parent. Thus, if a Ghe is a fmthn sp~c ified Act then it has a slot for actor as well as its own slots for object and recipient. In a system based on multiple description, the inheritance of slots is not as straightforward. Thi s is especially true when there is an attempt to do Merlin- like rcnsoning nnd use perspectives to "view an x as a y". Tile basic in hcri tance mechani sm in KIU .. -0 does not include autlllnatic inheritance of slots. This is vital for cases in which there arc multiple descriptions using the same prototype units. However, it makes it nwkward (though poss ible:) to program the cases where the slots arc to be inherited simply. Therefore. we included a mechani sm for "further specification" which allowed a unit to inherit slots (along with their attached procedures) from a single parent. This was not fully implemented into the system, and was a dangling end in the implementation.

The factoring of context-dependent descriptions: One major design decision in KRL was the use of an object-factored data base, rather than a context-factored one. The unit for a particular object contained all of the different contingencies representing the facts about it in different worlds. This proved quite successful; however, when combined with the kind of descriptions provided by mappings, another issue arises. Using the example of the cryptarithmetic units given earlier, consider the problem of representing what is known about a column in the addition problem if worlds are used to represent hypothetical assignments. Imagine that we know that in the unmarked global world, Column! is an instance of Column, with values for topLetter, bottomLetter, etc. If in a hypothetical Worl<ll (in which some value is assumed for a letter) we infer that its sum is 17, we want to add a contingent descriptor. This could be done in two ways:

(during Worldl lhcn (a Column with sum= 17))}>]

[Column[ UNIT ln~hidual <self I (a Column with topl.rttcr = A ... ) [Column! UNIT Individual <self I (a Clllumn with topl-.cttcr = A sum = (during Worltll then 17) ... )} >]

These are equiv:ilent at the semantic level, and the first was chosen in the initial implementation -- all factoring into contexts was done at the top level of slots. However this proved to be tremendously clumsy in practice, since it mennt that much of the information was duplicated, especially in cases of recursive embedding. This was ex:1cerbated by the fact that features (See Bobrow and Winograd, p. 14) demanded factoring as well, and were used for a variety of purpuscs, such as the viewpoints mentioned above. There was a reimplcmen tation midway in the life of KRL-0 in which the basic data structures were chan;;cd to make it possible to merge as much of the shared information as poss ible. There are a number of clifficult tradeoffs between storage redundancy, running efficiency, and readability when debugg ing, and we n.:ver found a fully satisfactory solution within KR!.-0.

Data structure manipulation

KRL-0 was not a fully declaratively recursive language in the sense that machine language and pure I.ISP are. It was not possible to write KRL-0 descriptions of the KRL-0 structures (e.g. units, slots, descriptions) themselves, and use the descriptive mechanisms to operate on them. Instead, there were a number of LISP primitives which accessed the data structures directly. People ran into a number of problems which could be solved by explicit surgery (i.e. using the LISP functions for accessing KRL data structures, and RPLACA and RPLACD) but which gave the programs a taint of ad hocery and overcomplexity. As an exercise in using KRL representational structures, Brian Smith tried to describe the KRL data structures themselves in KRL-0. A brief sketch was completed, and in doing it we were made much more aware of the ways in which the l:lnguage was inconsistent and irregular. This initial sketch was the basis for much of the development in KRL-1.

Deletion of information: One of the consequences of seeing KRL-structures as descriptions, rather than uninterpreted relational structures was a bias against removing or replacing structures. Desc riptions are by nature partial, and can be expanded, but the most natural style is to think of them as always applicable. Thus, for example, if a slot was to contain a list (say, the list of digits known to have been assigned in a cryptarithmdic problem), the descriptor used in an instance was the Items descriptor, which is interpreted as enumerating some (but not necessarily all) items in a set. If the description of some object changed over time, then it was most naturally expressed explicitly as being a time-dependent value, using the Contingency descriptor. There are some deep representational issues at stake, and the intuition of thinking of descriptions as additive was (and still is) important. However, it led to an implementation which made it impossible to delete descriptions (or remove items from lists) without dropping to the level of LISP manipulations on the descriptor forms. This caused problems both in cases where values changed over time, and in cases where the programmer wanted the program to delete unnecessa ry or redundant descriptors in order to gain efficiency. Although deletion and replace.ment were doable (and often done), they went outside of the K RL semantics in a rather unstructured way.

Explicit manipulation of descriptions: For some of the programs, it was useful to have parts of the code which dealt with the descriptions themselves as objects. For example, in the cryptarithmetic program, the set of descr iptions being added to the value slot of an individual Digit could be thought of as a set of "constraints", and used in reasoning. One might ask "What unused digits match all of the descriptors· accumulated for the value of the letter A". This is quite different from asking "Which unused digits match the description 'the value of letter A"'. Similarly, in the implementation of Winston's program, the descriptions themselves needed to be thought of and manipulated as relational networks. The ability to usc desc riptions in this style gave power in writing the programs, but it had to be done through LISP access of the descriptor forms, rather than through the standard match and seek mechanisms.

l'roblems with the matcher

Specifying the match strategies: The matcher in KRI.-0 took a KRL-0 description as a pattern, and matched it against another description viewed as a datum. For each potential descriptor form in the pattern, there were a set of strategies for finding potentially matching descriptions in the datum. The ordering of these n:Hned strategies, and the interposition of special user-defined strategies was controlled by usc of the signal mechanism. This was designed to give complete flexibility in how the match was carried out, and succeeded in doing so. Many specialized match proccses were designed for the different projects. However, the level at which they had to be constructed was too detailed, and made it difficult to write strategies which handled wide ranges of cases. The strategies were mostly reflections of the possi ble structures in the datum, and did not deal directly with the meaning of the descriptors. This led to having to consider all of the possible combinations of forms, and to programs which did not function as expected when the descriptions contained different (even though semantically equivalent) forms from those anticipated.

Returning bindings: Since patterns for the matcher were simply KRL-0 descriptors, and there was no coherent meta-desc ription language to define procedural side effects, it was very difficult to extract the bindings from a match. This was handled in the legal example, which most needed it, by providing special signa l tables for these matches, again leading to a feeling of ad hocery to get around a basic problem in matching.

Control of circularities: In using matching as a control structure for reasoning, it is often useful to expand the match by looking at the desc riptions contained in the units being compared. Consider the units:

[Give UNIT Basic

<self (A Receive with

received= (the given) receiver = (the receiver) giver = (tl1e giver))>

<giver (A Person)> <rereher (A Person)>

<given (A PhysicaiObject)>]

[Receive UNIT Basic

<self (A Give with giten= (the received) receiver = (the receher) giver = (the giver))> <gi>er (A Person)> <recei>er (A Person)> <recehcd (A l'hysicaiObjcct)>] [f.vent17 UNIT Individual <self (A Ghe with giver = Jane recei\'C·r = Joan given = (A Hammer))>

If asked whether the pattern (A Receive with received = (A Hammer)) matches Eventl7, the matcher needs to look in the unit for Give in order to see that every Give is indeed a Receive, and to match up the slots appropriately. However, this can lead to problems since descriptions in units could ensily be self -referential, and mutually cross-referential. In a slightly more complex case, the matcher could try to match a Give by looking at its definition as a Hcccive, and then transform that to a Ghc. and so on. Some of the early match stra tegies we developed fell into this trap and looped. The si mple sol ution that was adopted to limit such circular expansion was to adopt a depth first expansion policy, and to limit the total depth of expansion (recursion through definition). This obviously works both in this case, and to limit arbitrarily large non-circular sea rches. In the limited data bases we used, it never caused a match to be missed when the programmer expected it to be found . But it is a crude device which does not provide adequate control over search.

Inefficiencies due to generalily: Since the matcher was designed to allow a wide range of strategies, a fairly large amount of processing was invoked for C<lch call. Often, the programmer wnnted to check for the direct presence of a ce rtain descrip tor, and to avoid the overhead, dived into LISP. Thus, instead of writing:

(Matd1 'Evrnt 17 '(A Give wilh giver = .Jane) 'S i lllf' leSt rur lu rc ,'vi at r h. ra b lc)

it was possi ble to write:

(f.Q 'Jane

(Gctltem (GetFillcr 'giver (GetPcrspcctive 'Give (GctSiot 'self 'F.vcnt17)))))

Given that the SimpleStructureMatchTable caused the matcher to look only at direct structural matches, the two forms were equivalent, and the second avoided much of the overhead. Many problems arose. however, in cases where later decisions caused the description form to be different (for example, embedded in a contingency) but to reflect equivalent

information.

Problems in the interface between KnL and LISP

One of the major design decisions in KRL-0 was the use of LISP for writing procedures, rather than having a KRL programming language. This was viewed as a temporary measure, allowing us to quickly build the first version, and work out more of the declarative aspects before trying to formulate a complete procedural language in the following versions. A number of awkward constructs resulted from the need to interface LISP procedures and variables to the KRL environment.

Limited procedural allachment modes:· Only the simplest forms of procedural attachment were implemented. Thus, for example, there was no direct way to state that a procedure should be invoked when some combination of slots was filled into an instance. Procedures had to be associated with a single condition on a single slot. It was possible to build more complex forms out of this by having a trigger establish further triggers and traps (there are examples of this in the unit for Column given above), but this led to some rather

baroque programming.

Communication of context: When a trap or trigger was invoked, the code associated with it needed to make use of contextual information about what units were involved in the invocation and what state the interpreter was in (for example in the use of hypothetical worlds). This was done simply by adopting a set of LISP free variables which were a~.:cessible by any piece of code, and were set to appropriate values by the interpreter when procedures were invoked. This approach was adequate in power, but weak in structure, and a number of the detailed problems which arose in the projects grew out of insufficient documentation and stability of what the variables were, and what they were expected to contain when.

Unstructuredness of procedure directories: The notion of having a "signal table" containing procedural variables was a first step towards breaking out of the normal hierarchical definition scheme of USI'. The intention in devel oping a KRL procedural language is to develop a set of structun:d control notions which make it unnecessary for the programmer to fill in the detailed responses to each possible invocation. In the absence of this, KRL-o signal tables had much the flavor of machine code. A clever programmer could do some striking things with them (as in their use in SAM for controlling language analysis and generation), but in general they were hard to manage and understand.

Underdeveloped Facilities

The KRL overall design (see Bobrow and Winograd, p. 3) involved a series of "layers" beginning with the primitive underl ying system and working out towards more knowledge-specific domains. Part of the ability to implement and test the language so quickly came from deferring a number of problems to higher layers, and letting users build their own speci~lized versions of pieces o( these layers as they needed them. In most cases this worked well, but there were some areas in which a certain amount of effort was wasted, and people felt hampered by not having more general facilities.

Sets and sequences: KRL-0 provided only three primitive descr iptors (Items, i\llltems, and Sequence) for represen ting sets and sequences. Notions such as subset, position in sequence, member of set, etc. all had to be built by the user out of the primitives. Everyone needed some of them, and it became clear that a wdl thought out layer of standard units and procedures would have greatly simplified the use of the language.

Indexing schemes: The index mechanism built into KRL-0 was based on simple collections of key words. It was assumed from the beginning that this was to be viewed not as a theory of memory access, but as a minimal primitive for building reali stic access schemes. One of the projects (FLOW) attacked this directly, but the rest stuck to simple uses of indexing, and did not explore its potential in the way they might have if a more devehlped set of facilities had been provided initially.

Scheduler regimes: As with indexing, the scheduler mechanism of KRL-o was intended primarily as a primitive with which to build interesti ng control structures which explored uses of parallelism, asynchronous multi-processing, etc. The only structuring was provided by the use of a multi-layer queue Like the category types discussed above, it was an attempt to embed some much more specific representation decisions into a system which in most places tried for generality. It was not restrictive, since the system made it possible to ignore it totally, allowing for arbitrary manipulation of agenda items. However, because it (and no other scheme) was built in, it tended to be used for problems where other regi n1cs would have been interest ing to explore.

Notation

The KRL-0 notation was strongly LISP-based, using parenthesization as the primary means of marking structure.

This made it easy to parse and manipulate, but led to forms which were at times cumbersome. This was especially true because of the use of different bracketing characters ("()", "{}", "0") for descriptors. descriptions and slots. At times a un i l would end with a sequence such as "})})} > )". There was one simplification made during the course of the implement~ ti on . allowing the description brackets "{}" to be omitted around a description containing a single descriptor. The examples in this paper use this convention. In addition, better nota tions were needed for expressing sets and sequences, and were explored in the KINSIIIP project.

Limited address space

One of the shortcomings which most strongly limited the projects was in the implementation, not the basic design. tNTERLISr is a paged system, based on a vi rtual memory which uses the full 18 bits of the PDP-10 address space. The philosophy has always been that with some care to separate working sets, system facilities could grow to large sizes without placing extra overhe:td on the runnin3 of the program when they were not be ing used. This has led to the wealth of user aids and facilities whi ch differentiate tNTERLISP from other LISP systems.

As a result. more than half of the address space is uscd by the tNTERLISP system itself. The KRL-0 system added another quarter to thi s, so onl y a quarter of the space was ava ilable for user programs (including program storage, data structure storage, and working space). Both of the extended systems (SAM and Medical) quickly reached thi s limit. This resulted in cutting back the goa ls (in terms of the number of stories and questions handled by SAM, and the ~mount of the sample diagnosis protocol handl ed by Medi cal), and also led the programml'!rs to . put a good deal of effort into squeezing out mnximal use of their dwindling space. Some des igns were ~ketched for providing a separate vir tual memory space for KRL data structures, but their implementation was put off for later versions, since the lessons lea rned in using KRL-0 within the space limitati on were quite suffici ent to give us direction for KRI.-1.

4. Current Directions

The projects descr ibed above were com rktcd by the end of summer 1976. Since that time, we have been primarily engaged in the design of KRL-t, and as of this writing (June 1977) arc in the midst of implementing it. The development has involved a substantial shift of emphasis towards semanti c regularity in the languaGe. and a formal understanding of the kinds of reasoning processes which were described at an intuitive level in the earlier paper. Much of this has been the result of collaboration with Brian Smith at M.I.T, who is developing a semantic theory (called KRS for Knowledge Representation Semantics) which grew out of attempts to systematize and understand the principles underlying systems like KRL.

The new aspects of KRL-1 include:

• A uniform notion of meta-description which uses the descriptive forms of KRL-1 to represent a number of things which were in different ad hoc forms in KRL-0. The old notions which are covered include features, traps and triggers, index terms, and a variety of other detailed mechanisms. The emphasis has been on providing a clear and systemati c notion of how one description can describe another, and how its meaning can be used by the interpreter. A number of the
• problems related to the manipulation of desc ription forms are solved by this approach.
• more structured notion of the access and inference steps done by the interpreter. The interpreter is written in a style which involves ope r~ting on the meaning of the forms, rather than the detail s of the forms themselves. This makes poss ible a more uniform framework for desc ribing matching and searching procedures. and the results they produce. It allows the language to be described in tl'!rms of a clear semantics (see Hayes, 1977 for a discussion of why this is important). We expec t it to make the development of complex M~tc h and Seek processes much l'!asier.
• A notion of data compaction which makes it poss ible to use simple data record structures to stand for complex descr iptor structures, according to a set of declarations about how they are to be interpreted. This enables the system to encode all of the internal structures (e.g. the structure which represent~ a unit) in a form which can be manipulated as though it were a full-fledged description.
• A compiler whi ch conve rts simple Match, Seek, and Describe expressions into corresponding INTERLISP record structure manipulatio11s, reduci ng the overhead on those inst:111ces of these processes in which only simpl e operations arc to be done. Thi s should make it possible to preserve efficiency while writing much more uniform code, with no need to usc explicit LISP manipulations of the structu res. Use of the not ions of compiling and compaction allows the conceptually correct but notationally expensive usl: of uniform metadescription to be support ed without excessive running cost in thl'! common cases.
• A uniform notion of system events which allows more general kinds of procedural attachment, and includes traps, triggers, and signals. Al so. by including much of the INTERLISP interface in description form, it has become more uniform and understandable as well.
• A simplified syntax, in which indentation is used to express bracketing, eliminating the need for most parentheses. It also uses "footnotes" for attaching meta-descriptions, and has simple set and sequence notations.
• Simplified notions of categories, inheritance chains, and agendas, which avoid some of the specific commitments made in KRL-0.
• Expanded facilities for sets, sequences. scheduling, time-dependent values, category hi erarchies, matching information and multiple-worlds. These are all built up out of the simpler, uniform facilities provided in the kernel, but they represent a subs tantial body of standardized facilities available to the user.

We are currently ex ploring a number of different solutions to the address space problem. Until LISP sys tems with a larger address space are available, some sort of swapping mechani sm will be necessary, but we sec this as a temporary rather than long-term problem.

Tile cycle of testing on KRL-1 will be similar to the one described in this paper, but with an emphasis on a smaller number of larger systems, instead of the multiple mini-projects described above. We feel that with KRL-0 we ex plored a number of important representa tion issues, but were unable to deal with the emergen t probl ems of large systems. Issues such as associat ive indexing, viewpoints, concurrent processing, and large-scale factoring of knowledge can only be explored in systems large ~nough to frustrate simplistic solutions. Severa l programs will be written in KRL-1, on the order of magnitude of a doctoral disserlati<)n project. Current possibilities inclurlc: a system for comprehension of narratives; a system which reasons about the dynamic st:lle of a complex multi - process program, anti interacts with the user about that stale; and a travel arrangement system rel<tted to GUS (Bobrow ct. al., 1977). Current plans include n1uch more extensive description and documentation of the system than was the case with K Rt.-0.

We do not view KRt.-t as the final step, or even the next-to-last step in our project. In Bobrow and Winograd, 1977 (pp. 34-3(,) we discussed the importance of being able to describe procedures in KIU . structures. 011r plan at th:~t time was to design a comprehensive programming formalism as part of KRL-1. In light of thl! shift of emphasis tow;mls better understanding the aspects whit.:h we had already implemented, we have postponed this effort for later versions, still considering it one of the major foundations needed for a full KRL system. There remains the large and only vaguely understood task of d~aling in a coherent descriptive way with programs and processes. It is likely that to develop this aspect will take at least two more cycles of experience, and as we learned so well with KRL-0, there is always much much more to be done.