<?xml version="1.0" standalone="yes"?>
<Paper uid="P87-1031">
  <Title>Expressing Concern</Title>
  <Section position="4" start_page="222" end_page="223" type="metho">
    <SectionTitle>
5. An Example of the Use of Concerns
</SectionTitle>
    <Paragraph position="0"> The simplest use of concerns addresses the problem of specifying which conditions of a particular plan are important enough invoke the planner's concern. For example, suppose the user asks the following question: (e) How do I print out the file named george on the laser printer? KIP is passed the goal of printing the file named george on the laser printer. In this case, KIP's knowledge-base con- null rains a stored plan for the goal of printing a file, namely, the USE-LSPR-COI~gclAND plan. KIP creates an instance of this plan, which it calls USE-LSPR-COMMANDI. KIP must then evaluate the USE-LSPR-COMMAND1 plan in order to determine if the plan is appropriate for this particular planning situation. This process entails the examination of those conditions likely to cause failure of this plan.</Paragraph>
    <Paragraph position="1"> In order to examine these conditions, KIP looks at the stored concerns of the stored plan, USE-LSPR-COMMAND. For each of the stored concerns of the stored plan, it creates a dynamic concern in this individual plan, USE-LSPR-COMMANDI. KIP examines the USE-LSPR-COM~'IAND plan, and finds that two of its many conditions are cause for concern: null (i) the printer has paper (2) the printer is online The most likely cause of plan failure involves (1), since the paper runs out quite often. Therefore, (1) has a moderate degree of concern, and (2) has a low degree of concern. KIP considers the most likely concerns first. These concerns are called stored condition concerns, because the failure of these conditions&amp;quot; often causes the failure of USE-LSPR-COMMAND. KIP therefore creates dynamic concerns regarding the paper in the printer, and the printer being online.</Paragraph>
    <Paragraph position="2"> KIP then must evaluate each of these dynamic concerns.</Paragraph>
    <Paragraph position="3"> In this particular example, there is no explicit information about the paper in the printer or the printer being online. Therefore, KIP uses the default values for the concerns themselves. KIP's concern about paper in the printer is high enough to warrant further consideration. Therefore, this contern is temporarily overlooked. However, the concern about the printer being online is disregarded. Its degree of concern is low. It is not a very likely source of plan failure. Since there are no other dynamic concerns for this particular plan, KIP looks back at its overlooked concern. Since this is the only concern, and the degree of concern is moderate, KIP decides that this concern should not be elevated to a source of plan failure. Rather, KIP decides to express this concern to the user. KIP assumes that, except for this concern, the plan will execute successfully. The plan is then suggested to the user: (E) UC: To print the file george on the laser printer, type lpr -Plp george. This plan will not work if the printer is out of paper.</Paragraph>
    <Paragraph position="4"> There are many other conditions of the USE-LSPR-COMMAND plan that KIP might have considered. For example, the condition that the file exists is an important condition for the lpr command. However, KIP need not be concerned about this condition in most planning situations, since it is unlikely that this condition will cause plan failure. Hence such conditions are not stored in the long term memory of KIP as stored concerns.</Paragraph>
  </Section>
  <Section position="5" start_page="223" end_page="225" type="metho">
    <SectionTitle>
6. KIP's Concern Treatment Algorithm
</SectionTitle>
    <Paragraph position="0"> In the following section, we describe the part of KIP's algorithm that decides what to do with concerns once they have been evaluated. KIP's entire algorithm for determining the concerns of a particular plan is fully described in (Luria86) and CLuria87ab).</Paragraph>
    <Paragraph position="1"> Once KIP has evaluated a particular dynamic concern of a particular plan, it can proceed in one of three ways, depending on the degree of that particular concern. If the degree of concern is low, KIP can choose to disregard the concern.</Paragraph>
    <Paragraph position="2"> Disregard means that the concern is no longer considered at all. KIP can u'y to modify other parts of the plan, and suggest the plan to the user with no reference to this particular contern. null If the degree of concern is high, KIP can choose to elevate the concern to a source of plan failure. In this case, KIP determines that it is very likely that the plan will fail. KIP tries to fix this plan in order to change the value of this condition, or tries to find another plan.</Paragraph>
    <Paragraph position="3"> The most complex case is when the degree of concern is moderate. In this case, KIP can choose to disregard the concern, or elevate it to a source of plan failure. KIP can also choose to overlook the concern.</Paragraph>
    <Paragraph position="4"> KIP then evaluates each of the concerns of a particular plan. It addresses all of the concerns which have been elevated to a a source of plan failure. KIP thus develops a complete plan for the problem by satisfying conditions about which it was concerned, and resolving goal conflicts about which it was concerned. Once KIP has developed a complete plan, it is once again faced with the need to deal with the overlooked concerns. If the plan will work, except for the overlooked concerns, KIP can again choose to disregard the concern. If there are a number of overlooked concerns KIP may choose to elevate one or more of these overlooked concerns to a source of plan failure. The plan is then modified accordingly, or a new plan is selected.</Paragraph>
    <Paragraph position="5"> At this point, KIP can also choose to suggest an answer to the user. Any, overlooked concerns are then expressed to the user in the answer.</Paragraph>
    <Paragraph position="6"> Furthermore, if the concern has been elevated to a source of plan failure, and no other acceptable plan has been found, KIP can choose to suggest the faulty plan to the user, along with the potential caveats. The concern information is based on default knowledge that assumed by KIP. Therefore, the plans may work if these defaults are not correct even if there are concerns in the particular planning situation. Also, the user may decide that he is not concerned about particular plan failure. For example, KIP may have mid the user about a potential deleterious side effect. The user may decide that this side effect is not that important if it occurs. This corresponds to a human consultant, who, when faced with a problem he cannot solve, gives the user a potentially faulty plan with the explanation of the potential caveats. This is more informative ' 224 for the user than just saying that he doesn't know.</Paragraph>
    <Paragraph position="7"> 7. Advantages of Concerns Thus, concerns are used by KIP to decide how the planning process should proceed and how to decide which answer is expressed. In this section, we describe a few more exampies of KIP's behavior In these examples, we also refer to a new type of concern called a violated default concern. These concerns are accessed by KIP whenever it realizes that a default has been violated. In this way, KIP can use knowledge from default concerns when there is no knowledge that defaults have been violated. However, when planning in novel situations, general violated default concerns are accessed.</Paragraph>
    <Paragraph position="8"> Consider the following examples: (f) How do I edit the file anyfile? (g) How do I edit Jim's file jimfile? (h) How do I edit the file groupfile which is shared by my group? One of KIP's main concerns in any of the possible editing plans is the write permission of the file. If the user tries to edit a file on which he does not have write permission, the plan will fall. In (f), this concern is inherited from the edit plan with a relatively low degree of concern. According to the default case, the file belongs to the user and he has write permission on the file. Since there is no infortnation about the write permission of the file, the default must be assumed and this concern is disregarded. KIP would therefore return a plan of (F) To edit the file named anyfile, use vi anyfile.</Paragraph>
    <Paragraph position="9"> In (g), KIP realizes that the default of the file belonging to the user is violated. Due to this default violation, a violated default concern of having write permission on the file is created. This concern of write permission is therefore evaluated by the default mechanism. Since there is a very good chance that the plan will not work, this concern about write permission of the file is elevated to a cause of plan failure. Once a condition is a cause of plan failure, KIP must deal with the plan failure. KIP c/n suggest a plan for changing the condition or try some new plan. In this case, since there is no way to change the write permission of Jim's file, another plan is chosen.</Paragraph>
    <Paragraph position="10"> (G) In order to edit Jim's file, copy the file to your directory and then use vi filename to edit the file.</Paragraph>
    <Paragraph position="11"> In (h), KIP also realizes that the default of the file belonging to the user has been violated. However, the default value for write permission of this file is different because the file belongs to the user's group. There is a good chance that the user does have write permission on the file. However, since there still is some chance that he does not have group write permission, there is still some concern about the condition. In this case, since the degree of concern is moderate, KIP can choose to overlook the concern, and suggest the plan to the user. However, the concern is sdli high enough that the answer expression mechanism (Luria 82ab), might choose to express the concern to the user. The answer to (h) would therefore be: (H) To edit the file groupfile, use vi groupfile. However, it might not work, if you don't have write permission on this particular group file.</Paragraph>
    <Paragraph position="12"> KIP can therefore use concerns to select a potential plan which has a moderate likelihood of success. KIP can express the plan and its reservations regarding the plan to the user. By temporarily overlooking a concern, KIP may search for other plan failures of a particular plan or other potential plans. KIP can accomplish this without completely disregarding a concern or elevating the concern to a source of certain plan failure.</Paragraph>
    <Paragraph position="13"> 8. Implementation and Representation KIP is implemented in Zetalisp on a Symbolics 3670.</Paragraph>
    <Paragraph position="14"> Concepts are represented in the KODIAK knowledge representation language (Wilensky84b). In particular, knowledge about UNIX commands has been organized in complex hierarchies using multiple inheritance. Therefore, when searching for stored default concerns of a particular plan that uses a particular UNIX command, KIP must search through a hierarchy of these commands. This is also true when looking for default violations. KIP searches up the hierarchy, and retrieves the stored concerns or default violations in this hierarchy.</Paragraph>
    <Paragraph position="15"> Stored condition concerns are presently implemented by creating a different CONCERN concept for each concern. Also, a HAS-CONCER~ relation is added between each concern and those conditions which are cause for concern. Degrees of concern are implemented by creating a HAS-CONCERN-LEVEL relation between the particular concern and the degree of concern. Degrees of concerns are presently implemented as numbers from one to ten. Dynamic condition concerns are implemented as instances of these stored concerns.</Paragraph>
    <Paragraph position="16"> Stored goal conflict concerns are presendy implemented by creating a different CONCERN concept for each concern.</Paragraph>
    <Paragraph position="17"> Also, a 3-way HAS-CONCERN relation is created between each concern, the conflicting effect and the threatened interest or goal which are cause for concern.</Paragraph>
    <Paragraph position="18"> Defaults are implemented in the current version of KIP by attaching default values of conditions to the plans themselves. Context-dependent defaults are implemented by exploiting the concretion mechanism of UC, which tries to find the most specific concept in the hierarchy. Therefore, since KIP retrieves the most specific plan in the knowledge-base, it automatically retrieves the most specific defaults.</Paragraph>
    <Paragraph position="19"> Violated default concerns are implemented by creating a different VIOLATED-DEFAULT-CONCERN concept for each violated default concern. A HAS-VIOLATED-DEFAULT- null CONCERN relation is added between the concern and the stored default which is violated. Therefore, when KIP has found the default that has been violated, it looks for the violated default concerns that are referenced by this default. Particular concerns have been entered into the database of UNIX plans through a KODIAK knowledge representation acquisition language called DEFABS. These concerns are all based on my experience using UNIX and on discussions I have had with other UNIX users in our research group. We are currently investigating a way to enter this concern information, using the UCTeacher program (Martin, 1985) a natural language knowledge acquisition system. Eventually, KIP may incorporate a learning component that would allow KIP to detect the frequency of certain plan failures and to store these as concerns.</Paragraph>
  </Section>
class="xml-element"></Paper>