<?xml version="1.0" standalone="yes"?>
<Paper uid="W97-0618">
  <Title>A Programmable Multi-Blackboard Architecture for Dialogue Processing Systems</Title>
  <Section position="6" start_page="101" end_page="104" type="evalu">
    <SectionTitle>
5 Interaction and Control
</SectionTitle>
    <Paragraph position="0"> The rules are the only means to specify the interaction between agents and blackboards and between blackboards and user. Consequently, only the rules have to be modified if the system should behave differently. null</Paragraph>
    <Section position="1" start_page="101" end_page="101" type="sub_section">
      <SectionTitle>
5.1 Variable substitutions
</SectionTitle>
      <Paragraph position="0"> If a rule contains variables, variable substitutions have to be calculated before evaluating the rule.</Paragraph>
      <Paragraph position="1"> This is done in the following manner. Let v be a variable of the form 0 : l@Tr. All possibly underspecified feature structures of type 0' with 0 E O' that have been added or non-monotonically modified since the last stop of the inference procedure are looked up in the discourse blackboard. If the signature of the function or the predicate requires the argument to be defined, all feature structures for which the path 7r is not defined are removed. From the remaining feature structures, an underspecified feature structure is generated. In the same way, the other variables in the rule are looked up. All possible combinations of instantiations form the set of substitutions. The only way to look up the data stored in the discourse blackboard is to generate variable substitutions.</Paragraph>
    </Section>
    <Section position="2" start_page="101" end_page="101" type="sub_section">
      <SectionTitle>
5.2 Evaluating a rule
</SectionTitle>
      <Paragraph position="0"> For each rule to be evaluated, the set of variable substitutions is calculated. For each substitution, the variables of the rules are instantiated and each predicate of the condition is evaluated until either one predicate fails or the condition yields true. Evaluation of a predicate or function means to pass the variable values to the procedure implementing the predicate or function and to leave control to the agent associated with the procedure. If the predicates that form the condition of the rule are verified, the remaining predicates are evaluated. If the evaluation of one of these predicates fails, the name of the failing predicate and the variable instantiations can be passed on to an error handling procedure. : IThe functionality is foreseen to allow interactive error recovery. If, for example, the answer to a clarification</Paragraph>
    </Section>
    <Section position="3" start_page="101" end_page="101" type="sub_section">
      <SectionTitle>
5.3 Evaluating a Set of Rules
</SectionTitle>
      <Paragraph position="0"> The rules are evaluated using a forward chaining inference procedure. The evaluation of the program consists of the subsequent evaluation of the rules, in the order in which they are specified. After termination, all feature structures in the blackboard are marked so as to prevent re-execution of an already applied rule.</Paragraph>
      <Paragraph position="1"> The forward-chaining inference procedure allows the system to react information-driven which means that, in essence, the information entered into the system determines which rules are evaluated. Consequently, there is no predetermined dialogue model that predicts the type or the information of the next utterance.</Paragraph>
      <Paragraph position="2"> The set of rules forms the program that directs the interaction of the different components given the users' input. Modifying the system's behavior requires modification of the program rather than hardcoding and recompiling. This allows for rapid prototyping. To provide output functionality that can easily be adapted to new domains, the predicates also offer the possibility to call Tcl scripts.</Paragraph>
    </Section>
    <Section position="4" start_page="101" end_page="104" type="sub_section">
      <SectionTitle>
5.4 Examples
</SectionTitle>
      <Paragraph position="0"> Our first example is taken from the map application. The task of the rule shown in figure 5.4 is to completely disambiguate the representation of the destination of a path.</Paragraph>
      <Paragraph position="1"> --).</Paragraph>
      <Paragraph position="2">  pletely an underspecified feature structure. The condition of the rule yields true if the semantic representation of the destination describes more than one object. If so, the remaining predicates are evaluated. In this particular case, a clarification question is generated. The predicate translatedifferences() determines the relevant feature paths question is incompatible with the expected value, an appropriate message should be communicated to the user, along with the possibility to provide complementary information as well as to cancel the dialogue. However, in the current implementation, only the message is displayed on the screen.</Paragraph>
      <Paragraph position="3">  and types for generating a clarification question and maps them to strings as shown in section 2.3. 2 It also determines the top level slots corresponding to the expected answers which are accessed with the predicate gettranstoplevelslots0. The question is displayed on the screen and the execution halts until some text has been entered (either via keyboard or via speech recognizer). The variable %eti_text is assigned to the event EVENT_TEXTINPUT and contains the entered text. The text is then added to the orthographic level of the discourse blackboard. If the semantic representation of the text is compat* ible with the underspecified feature structure, the representations are unified to reduce ambiguity. If the iscompatible0 predicate fails, the evaluation of this rule is aborted, and other rules apply to process the text entered on the orthographic level. This allows the processing of answers that do not convey the expected information. Finally, the predicate reevaluate() forces the rule to be re-evaluated with the same substitution until the destination is disambiguated completely or an incompatible answer is given.</Paragraph>
      <Paragraph position="4"> Note that the formulation of this rule does not make any domain-specific assumptions except that there is a type obj_path that carries a feature \[DST\]. In another application that provides functionality to order items, the same rule may apply to disambiguate the items. In order to adapt the rule, one would only have to replace {Obj_path} : 0@\[DST\] with {Speechact.orderobject} : 0@\[OBJECT\] where the request to order an item is represented in a feature structure subsumed by speechacLorderobject\] OBJECT obj J Our next example is also taken from the map application. It demonstrates how database access and rule application interact. Suppose the user utters show me how I;o get to the museum. We assume for the sake of example that zoom in was recognized instead of the museum, and that the semantic parser skips zoom in . The representations that are stored on the semantic level after the input has been parsed and processed are shown in figure 6.</Paragraph>
      <Paragraph position="5"> We consider the rules shown in figure 5.4. In this example, the second part of the first rule will be evaluated in the case of a missing the destination of the path. The rule is repeated until the feature \[DST\] carries a value or the user enters information that causes the unification to fail (well-typed unification). After unification, another procedure ensures that the new information is inserted correctly in the discourse blackboard. If, e.g., the user entered the museum, 2At this time, a very restricted language model is generated on the fly. Basically, it consists of all expected answers and some standard words that are always active. The next speech input is rescored using this language model. However, at the time being, there is no possibility to determine if the input corresponds to the language model or not.</Paragraph>
      <Paragraph position="6"> speechact_showpath \]  after having processed the utterance show me how to get to the museum with a misrecognition on the museum.</Paragraph>
      <Paragraph position="7">  after the first question has been answered the semantic level looks like the one shown in figure 7.</Paragraph>
      <Paragraph position="8"> Now, since a new object has been entered on the semantic level and since there is a blackboard that provides a database access procedure for all objects that are subsumed by obj_concrete (the object database), a database lookup is executed. The noun phrase the museum does not refer uniquely to one object, as shown in figure 2, thus, an underspecified feature structure is generated on the object level. Now, the disambiguation rule explained above will initiate a clarification dialogue to disambiguate the object. Once this is achieved, the index of the intersection of the destination is stored in the path object by the following rule. The following rule copies the index of the intersection of the current position into the path object, if the source of the path is not specified. If the source of the path is specified, the index of the source intersection is calculated using rules similar to those calculating the destination index (not shown in this example for brevity). Finally, the shortest path is calculated and the result is stored in the path object as a list of line segments. Depending on the speech act type the path is an object of, there may be subsequent rules that may perform complementary operations on the data such as calculating the path length or travel time, generating a path description, or highlighting the street segments belonging to the path.</Paragraph>
      <Paragraph position="9"> To illustrate the behavior of the rules, we show the complete dialogue:  -+ ADD_PATH_DST : isundefined(Obj_path : 0~\[DST\]) settclvar(&amp;quot;textl&amp;quot;,&amp;quot;Where do you want to go today?&amp;quot;), tcleval(&amp;quot; DisplayQuestionStextl&amp;quot; 1, setnewtoplevelslots( obj_concrete ), waitforevent (EVENT_TEXTINP UT), tcleval(&amp;quot; UndisplayQuestion&amp;quot; ), setoldtoplevelslots0, set( { Obj_path } : I~\[DST\], parse(%eti..text ) ), reevaluate().</Paragraph>
      <Paragraph position="10"> DISAMBIGUATE : as above ADD_PATH_SRC : isundefined({Obj.path} : 0~\[SRC\]) set( Obj_path } : OH\[SaC\], Current..position~INDEX),</Paragraph>
      <Paragraph position="12"> U: Show me how to get to the museum S: Where do you want to go? U: To the museum.</Paragraph>
      <Paragraph position="13"> S: Do you mean carnegie museum of natural history, andy wartiol museum or fort pitt museum? U: the andy warhol museum.</Paragraph>
      <Paragraph position="14"> S: displays path to and icon of the museum In our next example, we consider an information system in which the user can query prices and characteristics of items, place orders, and obtain a bill for the the ordered items. We suppose a price request to be represented by a feature structure more specific than the following : speechact_requestprice\] OBJECT obj J Now, the description of the objects may vary in specificity which makes it refer to many different objects. The desired behavior of the system is to enumerate the prices if the description refers to few (e.g., three) objects , or to display a price range if the description refers to many objects. The rules shown in figure 9 calculate the text containing the price information.</Paragraph>
      <Paragraph position="15"> Remember that the variable Speechact_requestprice : IS\[OBJECT\] is instantiated with the semantic representation of the description as uttered by the user, the variable Speechact_requestprice : 0R\[OBJECT\]  is instantiated with one object that is adequately described by the description and {Speechact_requestprice} : 0R\[OBJECT\] is instantiated with the underspecified representation of all objects fitting the description. The rules are shown in figure 9.</Paragraph>
      <Paragraph position="16"> The condition of the first rule yields true if the description refers to more than three objects. For this reason, the system paraphrased the noun phrase conveyed by the user to refer to the objects and the minimum and maximum prices are filled in a template. If there are less than four objects, the second rule will be evaluated. Since the rule will be instantiated for each item represented in the underspecified feature structure, the prices of all objects will be appended to the text variable.</Paragraph>
      <Paragraph position="17"> It is important to note that the system paraphrases the noun phrase it understood, using the translate predicate. In this manner, feedback can be conveyed to the user without explicitly asking a questions.</Paragraph>
    </Section>
  </Section>
class="xml-element"></Paper>