Towards Automating Explanations
Proceedings of the Seventh International Joint Conference on Artificial Intelligence. INFERENCE and REASONING. Pages 362-366.
© 1981 International Joint Conferences on Artificial Intelligence
Abstract
This paper discusses an approach to the modelling of the explanation process within the framework of a graphics-based CAD system currently under development, which can describe its own use, including the common ways to make and recover from errors. With a coordinated textual and pictorial display, the system, CADHELP, simulates an expert demonstrating the operation of the graphical features of the CAD tool. It consults a knowledge base of feature scripts, built up using situational script and commonsense algorithmic methods, to explain a feature, generate prompts as the feature is being operated, and to give certain types of "help" when a feature is misused. CADHELP provides these services by summarizing the feature script in different ways depending upon what it has told the user previously. The summarization process is based upon a series of "sketchification" strategies, which prescribe which parts bf a knowledge structure, a causal chain, or a single concept can be thrown away, since the listener should be able to infer them.
- Birnbaum, L. and Selfridge, M. Problems in Conceptual Analysis of Natural Language. CSTR-168, Yale U., New Haven, CT.
- Carbonell, J. R. An Artificial Intelli- gence Approach to CAI. ~ .II:aru~.. &..!!.-Machine Systems. MHS-11.
- Charniak, E. Towards a Model of Children's Story Comprehension. AITR-266.
- M.I.T. Cambridge, MA.
- CHAR77l Charniak, E. Ms Malaprop, A Language Comprehension Program, ..fr.Q£.. .ill.1!l ~. ..J.Q1.nt ~.~AI. Cambridge, MA.
- Chester, D. Proofs into English. November. Translating Mathematical Artificial Intelligence.
- Cullingford, R. Script Application: Com- puter Understanding of Newspaper Stories. CSTR-116.
- Yale U., New Haven, CT.
- Cullingford, R. Pattern-Matching and Inference in Story Understanding. Discourse Processes. Vol. 2, No. 4.
- Cullingford, R., Krueger, M. and Sel- fridge, M. Automated Explanations as a Component of a Computer-Aided Design System. ~. Jnt. ~. ~ Systems, &..!!. & Cybernetics. Cambridge, MA. October.
- CULL81J Cullingford, R. Integrating Knowledge Sources for Computer 'Understanding' Tasks. ~ ~. ~&~. February.
- Goldman, N. Conceptual Generation. In Schank, R. (ed.), Conceptual Information Processing. North Holland.
- McDonald, D. Language Production as a Process of Decision-Making under Constraints, AI Lab. TR, M.I.T. Cambridge, MA.
- Reeves, W. GPAC User's Manual. Computer Systems Research Group. Univ. of Toronto, Toron- to, Canada.
- Rieger, C. Conceptual Memory. In R. Schank (ed.), Conceptual Information Processing. North Holland .
- Rieger, C and Grinberg, M. The Declara- tive Representation and Procedural Simulation of Causality in Physical Mechanisms. ~. I1f1D .Int.. • .sl. IJCAI
- iD.l ~. ~AI. Cambridge, Mass.
- Schank, R. and Abelson, R. Scripts ~ ~ and Understanding. Erlbaum. Hillsdale, NJ.
- Simmons, R. and Slocum, J. Generating En- glish Discourse from Semantic Networks. ~. _AW. Vol. 15, No. 10.
- Stories. Wilensky, R. Understanding Goal-Based CSTR-140. Yale Univ., New Haven, CT.
References were extracted automatically from the PDF and may contain errors.
Full text extracted automatically from the PDF; figures, tables and equations may differ. The PDF is the version of record.
I. Introduction
The ability to explain things is an impor tant, but poorly understood, component of intelli gent behavior. This paper discusses an approach to the modelling of the explanation process within the framework of a graphics-based CAD system, called CADHELP, which can explain its own opera tion to its user, including the common ways to make and recover from errors. Functionally, the CAD system is a familiar sort of graphical tool for the design domain of digital logic circuits. It provides a standard set of graphical features, such as drawing, dragging and rubber-band line techniques, and accepts user input during. design from such standard devices as terminal, light pen
and data tablet.
CADHELP contains detailed knowledge
structures, which simulate an expert user's
The research summarized here was sponsored by the Advanced Research Projects Agency of the Depart ment of Defense, and monitored by the Office of Naval Research under Contract N00014-79-C-0976. The support of these agencies is gratefully ack
nowledged.
knowledge of how the basic graphical features work, or may fail to work. CADHELP explains it self by demonstration, i. e., by mimicking an ex pert operating the device while explaining it. The explanation mechanism contains a . set of natural-language generation heuristics whJ.ch allo~1 it to create explanatory text or prompts from the underlying knowledge structure in a context sensitive manner. CADHELP is primed to tell a user only what he, as a resurt of an explicit com mand or by dialog history, does not already know. Therefore, subsequent explanations reflect the knowledge the user gained from earlier ones by om itting detailed restatement of concepts he should now understand.
II. An Example
In this section, we present a sample explana tion which CADHELP has produced. The user selects the graphical feature to be explained, and the level of the explanation (viz., summary, normal operation, or errors) with simple typed inp~t. CADHELP cannot "understand" natural language J.n put, and thus cannot engage in mixed-initiative dialogue [CARB70] with its user. Our desire was not to produce an intelligent computer-aided in structional (CAI) system, but rather to focus on the rather poorly understood generative component that any such system will require,
CADHELP produces explanations by expressing "concepts" (encoded in a conceptual dependency format [SCHA77J) selected from the knowledge structure describing the selected feature. The text generated is not canned, but varies in signi ficant ways according to the context it is being produced in. (In the current implementation, how ever, the display component of the explanation is prestored.) Suppose the user asks to have ex plained the graphical feature of "dragging" ob jects (in this domain, logic devices) into posi tion in the design area using the light pen. In a "summary" explanation, the normal operation of the feature is described in the highest-level terms available:
To move an object to a location, use the drag feature.
Select the drag feature. Select the object. Drag the object into the design area. Position the object. Exit from the drag feature.
In the "normal" mode of explanation, the operation is expanded in a greater level of de tail:
To move an object to a location, use the drag feature.
(Light pen and parts flash as they are named) The light pen hangs on the hook on the graphics device.
The hook is to the right of the screen.
The light pen has a sensor.
The light pen has a handle.
The light pen has a connection to the system.
Select the drag feature by pointing the
light pen.
Grasp the light pen.
Hove the light pen to the screen.
Touch the light sensor to the drag symbol.
The symbol flashes.
Select the object by pointing.
Drag the object into the design area. Hove the light pen into the design area. The object follows.
Remove the light pen when the object is at the location.
Exit from the drag feature by pointing.
An explanation of "errors" describP.s how com mon mistakes involving the feature can be made,
and how to recover:
When you move the object into the design area, the system receives an input from the light pen when the light pen touches the object. The system predicts where you are moving the
light pen to.
The system redraws the object at the place. The system waits to receive an input from the light pen.
If you move the light pen too fast, the system does not get an input.
The system cannot redraw the object.
To continue dragging, point to the object~
III. Representing ·Expert Knowledge
In designing a mechanism which simulates the explanations generated by an expert, we have as sumed that what is to be communicated is a knowledge structure (KS), a large body of inter connected declarations (propositions or asser tions) describing a knowledge domain. Explana tion, then, can be conveniently modelled as a pro cess by which a more or less complete copy of a declarative KS is moved from the memory of the ex plainer to that of the listener.
Several claims can be made about the charac teristi cs of a KS suitable for CADHELP-style ex planations. First, it should be language ~. since we wish to be able to generate a number of paraphrases of the same underlying event. We would also like to be able to drive both the text generator and the display device from the same representation.
The units of the descriptions of features are called conceptualizat~ons. graphical The conceptualizations are connected together at the lowest level of the KS into causal chain~. The type of causal connection between the events is expressed in terms of the primitive causals of the commonsense algorithmic representation [RIEG77] for mechanisms. KS's for explanation, as bundles of causal chains including well-understood actors and objects, conform well to the notion of a si tuational script [SCHA77]. The KS describing the operation of a graphical feature is called a feature ~. and the objects appearing in them which differ from use to use of the script are called ~ variables. Feature scripts are built according to the "standard" methods des cibed, for example, in [CULL78], and so will not be pursued further here. Ho~u details of CADHELP scriPt structure can be found in [CULLBO].
IV. Explanation Strategies
The key observation concerning explanations of feature scripts is that they contain dozens of conceptualizations and causal relations which could be selected for expression. Thus, the pro cess of explaining appears to be one of deciding what .nQi to say rather than what to say. For ex ample, the feature script $LPPOINT, which describes "pointing to a graphical object with the light pen," contains fourteen conceptualizations, interconnected by ten causal relations. Each assertion and relation is potentially expressible, but an explainer seems to focus on only certain
elements of the KS during the explanation.
Note that the speaker has the dual problem to the inference problem the understander has. The understander is expected to fill in what the speaker left out, by various types of inferences [e.g., CHAR72, RIEG75, CULL79, WILE79]. The speaker seeks as economical an expression of the thought to be communicated as possible. He leaves "sketchy" the parts of the utterance the hearer should be able to infer. we call this .process conceptual ske tchifica tion. In examining what sounds natural in CADHELP-style explanations, it·s clear that speakers sketchify what they say at every level. Selection and suppression occur in the use of the top-level pointer to the KS, causal chains to express an operation, unit events from a causal chain, and, finally, conceptual
cases in a conceptualization.
Examples of sketchification are easy to find in the example explanations of Section II. Con sider the use of the term "point," for example. In the "normal" mode of explanation, CADHELP ini tially assumes that the user knows so little about pointing that the instrument used, the light pan, must be located and described. Then the mainpath sequence of actions comprising a pointing episode is expanded. In the second use of "point," the instrument is named, but the action sequence is not given again. In the final use of "point," the description is reduced to the minimum. The in strument and the actor, which can be inferred, are not named. But the object pointed to, which is variable from use to use of $LPPOINT, must be
named.
The role of sketchifying can be seen within single concepts, as well. Consider the syntactic phenomenon called the "imperative". Conceptually, this involves the suppression in the surface form of the conceptual actor. But from the point of view of explanation, it's known to both parties who the actor is: the user. Because of this, the explanation need not explicitly name the actor, since this can be inferred. Similarly, certain uses of the infinitive construction are sketchy expressions of an inferrable fact about the under lying concept, If I say "I decided to go home," my hearer is expected to infer that the unnamed per son who will go is the same as the one who decid ed, It appears that many syntactic constructions are the surface manifestations of underlying redundancies of these sorts.
CADHELP's explanation strategies are organ ized into a hierarchy containing three levels of ske tchifica tion, The ~-Sy!llmarization level uses intent/summary conceptualizations associated with feature scripts for descriptions of KS's which have already been explained, The explainer keeps a small working memory of the features which have been the subject of an "explain" command, or which were imbedded in a feature which was explained.
The ~ phenomenological level explains a KS in terms of the user's actions and the system responses he can see directly. This type of ex planation is implemented by a small set of demon like rules (on the order of a dozen) which examine the causal chains associated with the feature, paring these down to concepts in which the user is explicitly named as actor, or which are mental information transfer events by the user in response to systEID actions. Thus, during the ex planation of "dragging", various objects are made to flash at various points as the feature is operated, The system also redraws the selected ob ject to give the illusion of the object's moving. The system as actor is suppressed by a sketchifi cation rule, however, which eventually forces the language generator to use actorless constructions such as: "the symbol flashes" or "the object fol lows." Phenomenological level summarization is used for descriptions of "normal" operation, in cluding the generation of prompts during the actu
al execution of a graphical feature.
The third, most detailed level expands each mainpath and support conceptualization in a causal chain. This is called the ~~ conversational level because it explains the KS in terms of the give and take between the user and system, which is a kind of conversation. Because the details of how the system reacts to tt!e user's manipulations are important in giving an under standing of how the user has gone wrong, conversational level summarization is used in error/recovery explanations. As in the phenomenological-level summar i zation, the tech nique of causal-chain sketchification is carried out bv a set of r·ul e!:l , operating as demons, which select concepts to throw away. (The rules are, in fact, a subset of the ones used in phenomenologi cal summariztion,)
A. Background
By comparison with natural language under standing and inference, the research subarea of natural language generation has received relative ly little attention. Although several language generators exist (e.g,, [SIHH72], [CHES76], [MCD060]) which are capable of impress! ve fluency, these begin with a syntactic representation of the string to be created, including the words to be used. Thus, they are unsuited for use in a system such as CADHELP, which must ge·nerate from a con ceptual representation of a feature to be ex plained. Goldman's BABEL [GOLD75] is one of a very limited number of examples of a sentence gen erator which starts with a conceptual representa tion of the thought to be uttered (in conceptual dependency format) and maps it into a surface En glish string. Goldman's approach, however, is ba sically suited for sentence at a time generation. The present research was motivated by the desire to build a generator capable of producing paragraph-length texts describing a knowledge structure, in which the factors that make for fluency could be explicitly studied.
B. Generation in CADHELP
CADHELP's generator, CGEN, has data and con trol structures which are very similar to the CA language analyzer described in [BIRNSO]. Its pri mary data structure is a short term memory, called the C-LIST, which the generatcr accesses in an iterative process of lOoking~ words to express the meaning of a concept currently at the focus of attention (the "front" of the c-LIST); and of inserting left-over subconcepts, perhaps with as sociated function words, in appropriate places on the C-LIST. Initially, the c-LIST contains a con ceptualization which has survived the pruning pro cess the KS-level sketchifiers apply to a feature
script,
English has various conventions which govern the order in which words should be said. These conventions are stored in CGEN' s dictionary as oosi tiona! constraints on where the constituents expressing sub-conceptualizations must appear with respect to a word which spans part of t he current concept. Consider the following simplified dic tionarY definition for the word "move," as in
"move the stylus to the tablet : "
move: (PTRANS ACTOR (NIL) OBJECT (NIL) TO (NIL))
ACTOR-- (PRECEDES PARENT)
OBJECT -- (FOLLOWS PARENT)
(PRECEDES TQ-SLOT-FILLER )
TO -- (FOLLOWS PARENT) (FOLLOWS OBJECT-SLOT-FILLER)
(FOLLOWS FUNCTION/WORD:TO)
This definition states that "move" spans a concept based on a physical transfer of loca t ion (a PTRANS) which an ACTOR makes an OBJECT undergo.
V. Generating English
The predicates PRECEDES and FOLLOWS are used to indicate where on the C-LIST the associated con ceptual case fillers are to be inserted. Here, the predicates specify a default ordering of ACTOR, the word "move", OBJECT, then the filler of the TO slot, following the function word "to". This ap proach to handling the details of English syntax is admittedly oversimplified. It has the great benefits of simplicity and uniformity, however, and thus has allowed a progressive approach to the addition of new language structure knowledge. For example, handling the active and passive forms of a verb turned out to require straightforward addi tions to the generator once a notion of "conceptu al focus" was worked out.
CGEN' s basic generation cycle can be described by four rules:
1) If the front of the CLIST is empty,
then there is nothing to generate; return.
- If there is a word on the front of the CLIST then "say" the word by saving it on a special list to be returned when the generation cycle is complete.
- If there is a concept on the front of the CLIST then remove the concept and try to find a word in the dictionary to express that concept. The look-up process is similar to the discr imina tion-ne t approach used in BABEL.
- If the current concept is completely spanned by the word(s) found, replace it with those words. Otherwise, insert the leftover fillers into the C-LIST using the positional constraints stored with the word found.
There is a fifth rule which concerns the decision not to say something. This decision is embodied in the actions of the collection of concept-level sketchifiers which continuously monitor the front of the C-LIST for concepts which can be expressed more economically than Rules 1-4 above would prescribe. Thus, the basi.c model of generation contained in CADHELP is that of an "exhaustive" algorithm (Rules 1-4) being restrained by sketchi fying rules.
VI. An Extended Example
Here we illustrate the generation process with computer output, edited for readability, showing the generator CGEN expressing the same concept at several levels of sketchiness. The con cept is one that is selected repeatedly by the ex planation mechanism (in a process not shown here) as it applies user-phenomenological summarization to produce prompts for the user as he selects a graphical feature.
First, we show what CGEN produces if most of the concept-level sketchifiers are turned off, and the system is run in a special "verbose" mode. Comments are indicated by n-n:
ULISP V1.4 Copyright,1978,R.L.Kirby Eval: (genverbose 'selcmdpD)
- -The current top of c-list is the input concept
- which states that the user is transferring
- to the system the information that he has the
- goal that the system instantiate one of the
- graphical features ($cadfeat), and the inst
rument of the transfer is the user applying
- a force to a command block with the stylus.
CGEN: top of c-list is cO:
(mtrans actor (#person role (·user)) mode (t)
from (*cp· part ·user) to (*cp· part (#person role (*sys))) mobj (s-goal actor ·user mode (t) goal ($cadfeat actor ·sys featname (nil) mode (t))) inst (propel actor ·user obj (#inst role (·stylus)) to (*Perpto· part (#lac role (&cmdblk) locname (nil)))
mode (t) manner (forceful)))
-cGEN finds "tell" in its dictionary as spanning -part of the input concept CGEN: using (tell)
-Following the instructions found under the word, -cGEN rebuilds the c-list:
CGEN: current c-list
(cO actor) -the actor of the mtrans should be -said first (the user)
(tell)
-then the lexical item "tell"
(cO to part) -then the concept in the (to part) -or the mtrans (the system)
(that) -then "that"
(c18 mobj) -then the concept in the mobj slot (by the action that) -then "by the action that" (cO inst) -then the instrumental concept
CGEN: top of c-list is c50: (#person role (*user)) -the actor of the mtrans
CGEN: using
(you)
CGEN: current c-list -now the c-list has two (you) -lexical items on top which can be (tell) -popped off
CGEN: top of c-list is c55: -mtrans to part
(#person role (*sys))
-concept is next
CGEN: using
(cadhelp)
CGEN: current c-list
(cadhelp)
(that)
-realized by "cadhelp"
-contains two more
-words to be said
-Now the goal stative in the mtrans mobj slot -reaches the top CGEN: top of c-list is c29: (s-goal actor (#person role (*user)) mode (t) goal ($cadfeat actor (#person role (*sys))
featname (nil) mode (t)))
| CGEN: using | -expressed with | Eval: (gen •selcmdpO) |
| (want) | "want" -The inst sketchifier looks at the concept and notes that its actor | instrumental is the same as the input concept's. Therefore, a gerund |
| c-list CGEN: current -whose | actor goes first | form can be used to express the instrument |
| (c29 actor) (want) | economically •.• | |
| (that) | -then want itself | |
| -then "that" | inst: examining inst concept c12 | |
| (c29 goal) | -then the goal concept | |
| {by the action (cO inst) | that) -then the mtrans inst | -The imP sketchifier notes that user-phenom summarization is going on (as is normal in prompts), and that the actor is the |
| CGEN: top of c-list is c72 | user; therefore | the imperative is ok ••• |
| (#person role (•user}) -the user | reappears imp: squashing actor | •user in cO |
| CGEN: using | word. "Select" takes | -The dictionary returns "select" as the mapping care of more of the input concept than "tell" does, |
| (you) | concept so this is | chosen CGEN: using |
| -Now the "execute a | (select) | |
| -reaches the top c-list | cad feature" script is c42: | |
| CGEN: top of ($cadfeat focus | (actor) actor (#person role (•sys)) mode (t)) not been able to find a -rn | the c-list as rebuilt by "select", the actor has disappeared because of imp, "sele~t" only requires expression of the (mobj goal) subconcept, and inst has set up a special |
| featname CGEN: using | (nil) -cGEN has -word which expresses the concept -directly so it uses the generic | form for the expression of the instrumental CGEN: current c-list |
| (execute) CGEN: top of (#person role | -verb "execute" | concept (select) -the lexical form "select" (cO mobj goal) -the $cadfeature concept nominalized |
| CGEN: using (cadhelp) -Now the nominalized form of the -concept bubbles CGEN: top of ($cadfeat nomform actor CGEN: using (feature) CGEN: top of | c-list is c48: -system appears (•sys)) -again "feature script" CGEN: ($cadfeat CGEN: | -which "select" has (by) -nby" (cO inst) -a nominalized form of the -propel concept top of c-list is c44: actor (#person role (•sys)) featname (nil) mode (nom)) using |
| featname ( indef) CGEN: | up from where "execute" put it ••• c-list is c102: (nil) focus (actor) (#person role (•sys)) (nil) mode (nom)) -dictionary has a word for this form (feature) CGEN: | -concept is expressed as "a feature" using (a) -as before -The instrumental concept reaches the top. Note the syninstr marker which the inst ske tchifier added to get the gerund form CGEN: top of c-list is c72: |
| using {a) | refer- comes up for (propel | syninstr ($prog) actor (nil) |
| -Finally the -expression | obj to mode | |
| c107: -indefinite -ence | ||
| c-list is | ||
| (#inst role (•stylus)) | ||
| propel concept | (•perpto• (t) CGEN: using -the | part (#loc role (&cmdblk) |
| of c-list is c148: (#person role (•user)) | (pressing) -the cycle continues, | locname (nil) ) ) manner (forceful)} progressive realization |
| CGEN: top (propel actor obj (#inst role (•stylus)) to (•perpto• part (#loc role {&cmdblk) (t) manner | locname (nil))) (forceful)) "press" Value: (select a on a command | with the result ••• feature by pressing the stylus |
| mode CGEN: using -the act (press) cycles, | itself is the result ••• that cadhelp -Now express Eval: (gen -This time the | block) the concept again |
| -after several Value: (you tell | you press - disqualifies a shot at this | 'selcmdpO) standard inst sketchifier itself because it's already |
| more execute a | the standard gets a chance is: is an | concept. Thus to modifY the concept. Its |
| the stylus on a | had | |
| that to | instrumental object being used in | |
| Each time | ||
| feature Next, we hand the | block) | |
| succession. | "normal" function in an instrumental concept? | |
| above generator three times | concept in | |
| entinst: examining inst concept in cO | ||
| the realization returned is shorter. | ||
| command | ||
| by the action | ||
| cadhelp that you want | ||
| entity-instrument | ||
| test | ||
| a | ||
-imp does its usual dirty work: imp: squashing actor ·user in cO
-with the result: Value:
(select a feature with the stylus)
-once more into the breach ··· Eval: (gen 'selcmdpO) -Both the standard inst and entity-inst ske tchif iers disqualify themselves because they've already had a shot at this concept. Thus kill-instrument gets in and erases the instrumental concept altogether ··· killinst: squashing inst concept in cO
imp: squashing actor ·user in cO
-with the result: Value: (select a feature)
VII. Implementation Note
The natural-language and control modules of CADHELP are programmed in Franz LISP. The high level graphics component was designed using the facilities of the University of Toronto GPAC [REEV77]. These parts of CADHELP currently run under UNIX on a VAX-11/780 computer. The graphics dis play itself is generated by a DEC VT-11 vect cr dis play device controlled by a PDP-11/04 computer. The graphics, natural language and explanation modules are coordinated by a general-purpose in tegration package called a hierarchical task manager [CULL81].
To give a feeling for run-time, CGEtl produoes the verbose expression of the command-select con cept discussed in Section VI in about 5 seconds when it is used alone; and in about 15 seconds when it is part of the complete CADHELP system.
VIII. Conclusions
This paper describes research into the mechanisms that appear to be needed for generating explanations intelligently. The micro-world chosen, that of interactive graphics in support of CAD, is a particularly attractive one because the needed know ledge structures can be designed by ex tending existing representational formalisms: scripts and mechanism-simulation causal relations. Within this domain, methods of summarization have been developed which can be coupled to the level of detail requested by the user, and the demands of local context. Summarization is based upon the notion of wsketchification," a multilevel process of selecting conceptual items for expression, then suppressing components of an item based upon whether the user should be able to infer them. A col lection of concept-level sketchifiers interacts with a natural language generator, CGEN, of a nov el design, These sketchifiers prescribe syntactic constructions which are more economical than those which would normally be used by the generator.
@inproceedings{ijcai1981p71,
title = {Towards Automating Explanations},
author = {Cullingford, Richard E. and Krueger, Myron W. and Selfridge, Mallory and Bienkowski, Marie A.},
booktitle = {Proceedings of the Seventh International Joint Conference on
Artificial Intelligence, {IJCAI-81}},
publisher = {International Joint Conferences on Artificial Intelligence},
editor = {Patrick J. Hayes},
pages = {362--366},
year = {1981},
month = {8},
note = {INFERENCE and REASONING},
url = {https://ijcai.org/proceedings/1981/71},
}
TY - CPAPER TI - Towards Automating Explanations AU - Cullingford, Richard E. AU - Krueger, Myron W. AU - Selfridge, Mallory AU - Bienkowski, Marie A. T2 - Proceedings of the Seventh International Joint Conference on Artificial Intelligence, IJCAI-81 PB - International Joint Conferences on Artificial Intelligence PY - 1981 SP - 362 EP - 366 UR - https://ijcai.org/proceedings/1981/71 ER -Copied
Machine-readable versions of this paper, for tools and AI agents: