<?xml version="1.0" standalone="yes"?>
<Paper uid="J81-1002">
  <Title>Computer Generation of Multiparagraph English Text 1</Title>
  <Section position="3" start_page="0" end_page="0" type="metho">
    <SectionTitle>
TALESPIN:
ONCE UPON A TIME GEORGE ANT LIVED NEAR A PATCH OF GROUND.
THERE WAS A NEST IN AN ASH TREE. WILMA BIRD LIVED IN THE
NEST. THERE WAS SOME WATER IN A RIVER. WILMA KNEW THAT
THE WATER WAS IN THE RIVER. GEORGE KNEW THAT THE WATER WAS
IN THE RIVER. ONE DAY WILMA WAS VERY THIRSTY. WILMA
WANTED TO GET NEAR SOME WATER. WILMA FLEW FROM HER NEST
ACROSS A MEADOW THROUGH A VALLEY TO THE RIVER. WILMA DRANK
THE WATER. WILMA WASN'T THIRSTY ANY MORE.
GEORGE WAS VERY THIRSTY. GEORGE WANTED TO GET NEAR SOME
WATER. GEORGE WALKED FROM HIS PATCH OF GROUND ACROSS THE
MEADOW THROUGH THE VALLEY TO A RIVER BANK. GEORGE FELL
INTO THE WATER. GEORGE WANTED TO GET NEAR THE VALLEY.
GEORGE COULDN'T GET NEAR THE VALLEY. GEORGE WANTED TO GET
NEAR THE MEADOW. GEORGE COULDN'T GET NEAR THE MEADOW.
WILMA WANTED TO GET NEAR GEORGE. WILMA GRABBED GEORGE WITH
HER CLAW. WILMA TOOK GEORGE FROM THE RIVER THROUGH THE
VALLEY TO THE MEADOW. GEORGE WAS DEVOTED TO WILMA. GEORGE
OWED EVERYTHING TO WILMA. WILMA LET GO OF GEORGE. GEORGE
FELL TO THE MEADOW. THE END.
</SectionTitle>
    <Paragraph position="0"> ent way, also based on a conceptual dependency representation \[8\].</Paragraph>
    <Paragraph position="1"> These systems share several features. First, the data structures that are the basis of the generation were designed for text processing; many of the special demands of text processing were anticipated and accommodated in the design of the knowledge structures themselves. Second, the sentence boundaries in these systems were direct correlates of internal features of 18 American Journal of Computational Linguistics, Volume 7, Number 1, January-March 1981 William C. Mann and James A. Moore Computer Generation of Multiparagraph English Text the data structures themselves. Often the sentence order arose in the same way. 4 Third, these systems had fixed generation goals, implicit in the code. Thus, the reader's needs were taken to be fixed and preknown by the system. Fourth, although goal-pursuit could sometimes be described in the material being generated, the systems themselves did not operate on a goal-pursuit algorithm. Finally, none of these systems chose the particular sentences to use in their output on the bases of quality assessment or comparisons among alternatives.</Paragraph>
    <Paragraph position="2"> In all five of these points, the KDS research contrasts with these previous efforts. We have worked with data structures not designed for text generation; the sentence boundaries we develop are not direct correlates of internal features of the data structures; there are explicit goals for the generation process to satisfy; the system itself pursues goals; and the final text is chosen through quality comparisons among alternative ways of saying things.</Paragraph>
    <Paragraph position="3"> The Task for the Knowledge Delivery System In the light of these considerations, the problem can be restated more specifically as follows: Given  1. An explicit goal of knowledge expression, 2. A computer-internal knowledge base adequate for some non-text purpose, and 3. Identification of the parts of the knowledge  base that are relevant to the goal, the task is to produce clean, multiparagraph text, in English, which satisfies the goal.</Paragraph>
    <Section position="1" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
The Partitioning Paradigm
</SectionTitle>
      <Paragraph position="0"> When we have stated this task to AI workers familiar with natural language processing, with no further specification, they have expected a particular kind of solution. They say, &amp;quot;Well, there are some sentence generators around, but the given information structures are too large to be expressed in single sentences. Therefore what we need is a method for dividing up the input structure into sentence-size pieces. Then we can give the pieces to a suitable sentence generator and get the desired text.&amp;quot; This is the expected solution, and people will simply presume that it is the line of development being taken.</Paragraph>
      <Paragraph position="1"> 4 This is not to say that sentence boundaries are always one for one with data structures, nor that the data structures always contain all the information used in making a sentence. But the forms of data structures in these systems have been shaped almost exclusively by natural language processing tasks, which tends to make sentence boundary determination easy. The content of those structures has often been filled in manually, leaving indeterminable the relative contributions of program and programmer.</Paragraph>
      <Paragraph position="2"> That approach, which we call the Partitioning paradigm for text generation, was used in all the systems described above. For the Partitioning paradigm to work, the generation task must be simplified by features of the knowledge base:  1. The knowledge base data structures have features that indicate appropriate sentence boundaries, and 2. The pieces of information appropriate to be expressed in an individual sentence are  adjacent. That is, a process can access all of the information appropriate to be expressed in a single sentence by following the data structure, without being required to traverse information to be expressed in other sentences.</Paragraph>
      <Paragraph position="3"> These conditions prevail (by design) in all of the systems described above, but they are not generally typical of information storage in computers. As we will see, KDS takes an entirely different approach to the problem.</Paragraph>
      <Paragraph position="4"> Several inherent difficulties become apparent when we attempt to use partitioning: 1. Missing adjacencies -- Since (by our problem definition) the knowledge comes from a structure not prestructured for the generation task, what is and what is not adjacent in the knowledge base may be quite arbitrary. We may wish to include several widely scattered items in a sentence, so that it is not possible to carve out a piece with those items in it at all. The adjacencies that we need in order to partition the structure into sentence-size parts may simply be absent.</Paragraph>
      <Paragraph position="5"> 2. Intractable residues -- Even though we may be able to find some way to start cutting out sentence-size objects from the data structure, there is no assurance at all that we will be able to run that method to completion and carve the entire structure into sentence-size pieces. Think of the comparable problem of carving statues from a block of marble. We may be able to get one statue or several, but if every part of the original block must end up looking like a statue, ordinary carving methods are insufficient. The residues left after carving out the first few statues may be intractable. A comparable sort of thing can happen in attempting to partition data structures.</Paragraph>
      <Paragraph position="6"> 3. Lack of boundary correlates -- In some ways the worst difficulty is that an arbitrary given data structure does not contain structural correlates of good sentence boundaries. American Journal of Computational Linguistics, Volume 7, Number 1, January-March 1981 19 William C. Mann and James A. Moore Computer Generation of Multiparagraph English Text One cannot inspect the data structure and tell in any way where the sentence boundaries ought to be. Along with the other difficulties, this has led us to reject the expected solution, the Partitioning paradigm, and to create another.</Paragraph>
      <Paragraph position="7"> The Fragment-and-Compose Paradigm Our solution comes in two steps: 1. Find methods for fragmenting the given data structure into little pieces, small propositional parts.</Paragraph>
      <Paragraph position="8"> 2. Find methods for composing good sentences and good paragraphs out of those little parts.</Paragraph>
      <Paragraph position="9"> We call this the Fragment-and-Compose paradigm.</Paragraph>
      <Paragraph position="10"> It is interesting to note that other systems employ a Fragment-and-Compose approach -- e.g., building construction, papermaking, and digestion. In each, one begins by producing small, easily manipulated objects much smaller than the desired end-product structures, and then assembles these into the desired end products in a planned, multistage way. For the block of marble, the comparable processes are crushing and casting.</Paragraph>
      <Paragraph position="11"> We may not be very encouraged in our text generation task by such precedents. However, there are precedents much closer to our actual task. The task of natural language translation resembles in many ways the task of translating from a computational knowledge source (although it has a comprehension subtask which we lack). Consider the (annotated) quotation below from Toward a Science of Translating \[9\]. The process by which one determines equivalence (faithfully translates) between source and receptor languages is obviously a highly complex one. However, it may be reduced to two quite simple procedures:  (1) &amp;quot;decomposition&amp;quot; of the message into the simplest semantic structure, with the most explicit statement of relationships; and (2) &amp;quot;recomposition&amp;quot; of the message into the  receptor language.</Paragraph>
      <Paragraph position="12"> The quotation is from Nida's chapter on translation procedures. Notice particularly the two steps: decomposition and recomposition, and the emphasis on simple, explicit semantic structures in the results of the decomposition.</Paragraph>
      <Paragraph position="13"> It turns out that this is the central procedural statement of Nida's book, and the remainder of the book can be seen as giving constraints and considerations on how this decomposition and recomposition ought to take place. We have very good reasons here for expecting that Fragment-and-Compose is an appropriate paradigm for natural language knowledge delivery.</Paragraph>
      <Paragraph position="14"> To give a sense of what can be done using Fragment-and-Compose, here is a piece of a machine-generated text (created by KDS) about what happens when fire breaks out in the computer room.</Paragraph>
      <Paragraph position="15"> Whenever there is a fire, the alarm system is started, which sounds a bell and starts a timer.</Paragraph>
      <Paragraph position="16"> Ninety seconds after the timer starts, unless the alarm system is cancelled, the system calls Wells Fargo. When Wells Fargo is called, they, in turn, call the Fire Department.</Paragraph>
      <Paragraph position="17"> Description of KDS Figure 2 is a block diagram of KDS, which simply says that KDS takes in an Expressive Goal (telling what the text should accomplish relative to its reader) and also a pre-identified body of Relevant Knowledge in the notation of its source. The output is multiparagraph text that is expected to satisfy the goal.  We will be carrying a single example through this description of KDS. It is the most complex example handled by KDS, and it incorporates many ideas from previous studies on description of computer message systems.</Paragraph>
      <Paragraph position="18"> A small contingency-plans data base contains knowledge about what happens in various circumstances, and about people's actions, responsibilities, authorities, and resources. The particular knowledge to be delivered concerns a computer room in which there may be some indication of fire and in which there is a computer operator who should know what to do if that happens. This operator is the nominal reader of the text.</Paragraph>
      <Paragraph position="19"> The general Expressive Goal is that the computer operator will know what to do in all of the predictable contingencies that can arise starting with an indication of fire. The contingencies are represented in the &amp;quot;Fire Alarm Scene,&amp;quot; part of the knowledge base. A schematic sketch of the Fire Alarm Scene is given in Figure 3. (The figure is expository and contains far less information than the actual Scene. The Scene is a &amp;quot;semantic net,&amp;quot; a collection of LISP expressions that refer to the same objects.)</Paragraph>
    </Section>
    <Section position="2" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
20 American Journal of Computational Linguistics, Volume 7, Number 1, January-March 1981
</SectionTitle>
      <Paragraph position="0"> William C. Mann and James A. Moore Computer Generation of Multiparagraph English Text I INIT I (bell sounds or fire detected; timer starts) i T,Mo0T I I ATTENO I (~ (evaluate situation) (Wells Fargo called) (don't cancel) (cancel alarm) iR~SPONSEI I FL'OHT I (Fire Dept. responds) (evacuate) I~,~,~, ! I~o~o~1 (Fire Dept. fights fire) (Fire Dept.</Paragraph>
      <Paragraph position="1"> goes home) I , (end of scene) I ~ Icae~ / I ~A~OWO~I ,r sumewo k,</Paragraph>
    </Section>
  </Section>
  <Section position="4" start_page="0" end_page="0" type="metho">
    <SectionTitle>
KDS MODULES MODULE RESPONSIBILITIES
FRAGMENTER
PROBLEM SOLVER
KNOWLEDGE FILTER
HILL CLIMBER
SURFACE SENTENCE MAKER
</SectionTitle>
    <Paragraph position="0"> The knowledge identified as relevant includes not only the events of this scene but also enough information to support another computational task. In this example the knowledge is sufficient to support an alternate task, which we call the Motivation Exhibit task, i.e., to exhibit, for each action in the scene, the actor's reasons for performing the action. So, for example, the relevant knowledge includes the knowledge that fires destroy property, that destroying prop-erty is bad, that the amount of property destroyed increases with the duration of the fire, and that the Fire Department is able to employ methods for stopping fires. This is sufficient to be able to explain why the Fire Department attempts to stop fires. KDS does not perform the Motivation Exhibit task, but its knowledge is sufficient for it. We generate from a knowledge base sufficient for multiple tasks in order to explore the problems created when the knowledge representation is not designed for text processing.</Paragraph>
    <Paragraph position="1"> The content of the scene is as follows: In the beginning state, INIT, the fire alarm sounds a bell. As we follow down the left side of the figure, we see that the fire alarm starts an interval timer, and at the end of the interval, the timer automatically phones Wells Fargo Company, the alarm system manager. Wells Fargo phones the Fire Department, and the Fire Department comes.</Paragraph>
    <Paragraph position="2"> The Fire Department fights the fire if there is one, and otherwise goes home.</Paragraph>
    <Paragraph position="3"> Meanwhile, the computer operator must pay attention to the alarm and decide what to do. He can block the alarm system's action, cancelling the alarm, or he can let the alarm system take its course. In the latter case, his next duty is to call the Fire Department himself, which has the same effect as Wells Fargo calling it. After that, his next duty is to flee. If he blocks the alarm then he is to go back to his previous task.</Paragraph>
    <Paragraph position="4">  the relevant knowledge from the notation given to it and dividing that knowledge into small expressible units, which we call fragments or protosentences. A Problem Solver, a goal-pursuit engine in the AI tradition, is responsible for selecting the presentational style of the text and also for imposing the gross organization onto the text according to that style. A Knowledge Filter removes protosentences that need not be expressed because they would be redundant to the reader.</Paragraph>
    <Paragraph position="5"> The largest and most interesting module is the Hill Climber, which has three responsibilities: to compose 22 American Journal of Computational Linguistics, Volume 7, Number 1, January-March 1981 William C. Mann and James A. Moore Computer Generation of Multiparagraph English Text complex protosentences from simple ones, to judge relative quality among the units resulting from composition, and to repeatedly improve the set of protosentences on the basis of those judgments so that it is of the highest overall quality. Finally, a very simple Surface Sentence Maker creates the sentences of the final text out of protosentences.</Paragraph>
    <Paragraph position="6"> The data flow of these modules can be thought of as a simple pipeline, each module processing the relevant knowledge in turn. We will describe each of these modules individually.</Paragraph>
    <Paragraph position="7"> Fragmenter Module The Fragmenter (Figure 5) takes in the relevant knowledge as it exists externally and produces a set of independent protosentences, called the Sayset. These primitive fragments, the protosentences, have no intended order. (In our final tests, they are presented in a list that is immediately randomized.) Each primitive protosentence can, if necessary, be expressed by an  To help the reader understand the level of these fragments, were they to be expressed in English, they would look like: &amp;quot;Fire destroys objects.&amp;quot; &amp;quot;Fire causes death.&amp;quot; &amp;quot;Death is bad.&amp;quot; &amp;quot;Destroying objects is bad.&amp;quot; etc.</Paragraph>
    <Paragraph position="8"> So the problem for the remainder of the system is to express well what can surely be expressed badly. It is important to note that this is an improvement problem rather than a problem of making expression in English feasible.</Paragraph>
    <Paragraph position="9"> The protosentences the Fragmenter produces are propositional and typically carry much less information than a sentence of smooth English text. In our example, the fragmenter produces the list structures shown in part below for two of its fragments.</Paragraph>
  </Section>
  <Section position="5" start_page="0" end_page="0" type="metho">
    <SectionTitle>
((CONSTIT (WHEN (CALLS NIL WELLS-FARGO)
(CALLS WELLS-FARGO FIRE-DEPT)))...)
((CONSTIT (WHENEVER (STARTS NIL ALARM-SYSTEM)
(PROB (SOUNDS ALARM-SYSTEM BELL)...)
</SectionTitle>
    <Paragraph position="0"> These fragments encode: &amp;quot;When {unspecified} calls Wells Fargo, Wells Fargo calls the Fire Department.&amp;quot; and &amp;quot;Whenever {unspecified} starts the alarm system, the alarm system probably sounds the bell.&amp;quot;  The second major module is the Problem Solver (Figure 6). The primary responsibilities of the Problem Solver are to select a text presentation style and to organize the text content according to the selected style. For this purpose, it has a built-in taxonomy of styles from which it selects. Although the taxonomy and selection processes are very rudimentary in this particular system, they are significant as representatives of the kinds of structures needed for style selection and style imposition.</Paragraph>
    <Paragraph position="1">  We believe that text style should be selected on the basis of the expected effects. In simple cases this is so obvious as to go unrecognized; in more complex cases, which correspond to complex texts, there are many stylistic choices. In order to select a style, one needs:  1. A description of the effect the text should have on the reader, 2. Knowledge of how to apply stylistic choices, and 3. A description of the effects to be expected  from each stylistic choice.</Paragraph>
    <Paragraph position="2"> Note that these are required whether stylistic choices are distributed or holistic, i.e., whether they are made in terms of attributes of the final text or in terms of particular methods for creating or organizing the text.</Paragraph>
    <Paragraph position="3"> The first requirement above, a description of desired effects, is (more or less by definition) a goal. The second item is the set of applicable methods, and the third is the knowledge of their effects. The Problem Solk, er is a goal-pursuit process that performs means-ends analysis in a manner long familiar in AI. The information organization is significant partly because of the demand it puts on the knowledge of style: Knowledge of style must be organized according to expected effect. Otherwise, the program has no adequate basis for selecting style.</Paragraph>
    <Paragraph position="4"> American Journal of Computational Linguistics, Volume 7, Number 1, January-March 1981 23 William C. Mann and James A. Moore Computer Generation of Multiparagraph English Text The Problem Solver takes in the Sayset produced by the Fragmenter and the Expressive Goal given to the system and produces a Saylist, which is an ordered list of the protosentences, some of which have been marked with Advice. The Problem Solver pursues given goals. It has several submodules that specialize in particular kinds of goals, including modules Tell and Instructional-narrate, which are active on this example. The Problem Solver can operate on the current Saylist  with three kinds of actions in any of its modules: 1. It can Factor the Saylist into two sublists separated by a paragraph break. It ex- null tracts all protosentences with a particular character or attribute and places them above the paragraph break, which is above all those that lack that attribute.</Paragraph>
    <Paragraph position="5"> Order within each sublist is retained.</Paragraph>
    <Paragraph position="6">  2. It can impose an order on some or all of the elements of the Saylist.</Paragraph>
    <Paragraph position="7"> 3. It can mark protosentences with Advice.</Paragraph>
    <Paragraph position="8">  Sometimes the Problem Solver knows some attribute of the final text that ought to be achieved, perhaps because of a demand of the chosen style, but it has no way to effect this directly. In this case it marks all the affected protosentences with Advice, which will be acted on after the  These represent: &amp;quot;(Put a paragraph break here because the actions of agents other than the hearer end here)&amp;quot; and &amp;quot;If possible, call the Fire Department; then, in either case, evacuate. (Advised by FRAG and INST-NARRATE Modules) (Advised that YOU is GOOD)&amp;quot;.</Paragraph>
    <Paragraph position="9"> Knowledge Filter Module The Knowledge Filter is a necessary part of KDS because as soon as we attempt to create text from a knowledge base suitable to support some other computational purpose, we find a great deal of information there that ought not to be expressed, because the reader already knows it.</Paragraph>
    <Paragraph position="10"> This is a general phenomenon that will be encountered whenever we generate from an ordinary computational knowledge base. As an illustration, consider Badler's work on getting a program to describe a  Solver that carry out these three kinds of actions. In this example, the Tell module acts before Instructional-narrate. The Factoring rules are applied sequentially, so that the last one prevails over previous ones.</Paragraph>
    <Paragraph position="11"> The first Tell rule corresponds to the heuristic that the existence of something ought to be mentioned before its involvement with other things is described. The third rule corresponds to the heuristic that the writer (KDS) ought to reveal its own goals of writing before pursuing those goals.</Paragraph>
    <Paragraph position="12"> Instructional-narrate uses a presentational technique that makes the reader a participant in the text. So, for example, the final text says, &amp;quot;When you hear the alarm bell ...,&amp;quot; rather than &amp;quot;When the operator hears the alarm bell...,&amp;quot; Instructional-narrate knows that the role of &amp;quot;you&amp;quot; should be emphasized in the final text, but it has no direct way to achieve this. To every protosentence that refers to &amp;quot;you,&amp;quot; it attaches advice saying that explicit reference to the reader, which is done by mentioning &amp;quot;you&amp;quot; in the final text, has positive value. This advice is taken inside the Hill-climber.</Paragraph>
    <Paragraph position="13"> In our example the Problem Solver creates the  Factoring Rules: TELL 1. Place all (EXISTS ...) propositions in an upper section.</Paragraph>
    <Paragraph position="14"> 2. Place all propositions involving anyone's goals in an upper section.</Paragraph>
    <Paragraph position="15"> 3. Place all propositions involving the author's goals in an upper section.</Paragraph>
    <Paragraph position="16"> INSTRUCTIONAL-NARRATE 1. Place all propositions with non-reader actor in an upper section.</Paragraph>
    <Paragraph position="17"> 2. Place all time dependent propositions in a lower section.</Paragraph>
    <Paragraph position="18">  successive scenes from a short computer-generated movie. The graphics system that generates the movie provides a stock of propositional knowledge about it. The objects in the scene are known to the machine unambiguously and in sufficient detail to generate the movie. The research task is to create a computer program that will describe in English the physical activities in this and similar movies. The detail is voluminous, and so Badler is faced with a serious information suppression problem. After several stages of applying various filtering heuristics, such as &amp;quot;Don't describe directly anything that doesn't move,&amp;quot; he can represent the movie by the five statements below.</Paragraph>
    <Paragraph position="19">  ing, moves toward the observer and-eastward, then northward-and-eastward, then from the driveway and out-of the driveway, then off-of the driveway.</Paragraph>
    <Paragraph position="20"> 4. The car, while going forward, moves northward-and-eastward, then northward, then around the house and away-from the driveway, then away-from the house and stops turning.</Paragraph>
    <Paragraph position="21"> 5. The car, while going forward, moves northward, then away.</Paragraph>
    <Paragraph position="22"> These are still too cumbersome, so additional stages of reduction are applied, yielding the single statement: The car approaches, then moves onto the road, then leaves the driveway, then turns around the house, then drives away from the house, then stops turning, then drives away.</Paragraph>
    <Paragraph position="23"> Even the longer text above contains only a fraction of the available information about the car and the other objects. Information on their types, their subparts, visibility, mobility, location, orientation and size are available from Badler's source. He also develops a sequence of events to describe the movie, based on certain indicators of continuity and discontinuity. The volume of information available, the predictability of its parts, and the insignificance of some of its details are such that all of it could not have been expressed in a smooth text.</Paragraph>
    <Paragraph position="24"> American Journal of Computational Linguistics, Volume 7, Number 1, January-March 1981 25 William C. Mann and James A. Moore Computer Generation of Multiparagraph English Text One of the principal activities of Badler's system is selection of information to be removed from the set of ideas to be expressed. Some things need not be expressed because they follow from the reader's general knowledge about motion of objects; others are removed because they represent noise, rather than significant events, generated by the processes that discern motion.</Paragraph>
    <Paragraph position="25"> The point for us is simply that the demands of smooth text production are incompatible with expression of all of the available information. Text production requires condensation and selectivity, the process we call knowledge filtering, on any reasonably complete body of knowledge. Knowledge filtering is a significant intellectual task. It requires coordinated use of a diversity of knowledge about the reader, the knowledge to be delivered, and the World in which all reside. We now recognize the necessity of sophisticated knowledge filtering as part of the process of producing quality text.</Paragraph>
    <Paragraph position="26"> KDS's Knowledge Filter (Figure 9) inputs the Saylist, including Advice, from the Problem Solver, and outputs the Saylist with additional Advice, called &amp;quot;Don't Express&amp;quot; advice, on some of the protosentences. So some of the items have been marked for omission from the final text. (They are marked rather than deleted so that they are available for use if needed as transitional material or to otherwise make the resulting text coherent.) The knowledge filter decides which protosentences to mark by consulting its internal model of the reader to see whether the propositional content is known or obvious. The model of the reader, in this implementation, is very simple: a collection of propositions believed to be known by him. Although KDS's reader model does not contain any inference capabilities about what is obvious, a more robust model certainly would. We recognize that the work of the Knowledge Filter is a serious intellectual task, and we expect that such a filter will be an identifiable part of future text creation programs.</Paragraph>
    <Paragraph position="27"> In our example the Knowledge Filter produces the DON'T-EXPRESS advice in the following element of  three parts: 1. A somewhat unconventional hill-climbing algorithm that repeatedly selects which one of an available set of changes to make on the Saylist.</Paragraph>
    <Paragraph position="28"> 2. A set of Aggregation rules (with an inter- null preter) telling how the protosentences may legally be combined. These correspond roughly to the clause-combining rules of English, and the collection represents something similar to the writer's competence at clause coordination. Each Aggregation rule consumes one or more protosentences and produces one protosentence. Advice propagates onto the protosentences produced.</Paragraph>
    <Paragraph position="29"> 3. A set of Preference rules (with an interpreter) able to assign a numerical quality score to any protosentence. The score computation is sensitive to Advice.</Paragraph>
    <Paragraph position="30"> The algorithm is equivalent to the following: Scores are assigned to all of the primitive protosentences; then the Aggregation rules are applied to the Saylist in all possible ways to generate potential next steps up the hill. The resultant protosentences are also evaluated, and the Hill Climber algorithm then compares the scores of units consumed and produced and calculates a net gain or loss for each potential application of an Aggregation rule. The best one is executed, which means that the consumed units are removed from the Saylist, and the new unit is added (in one of the positions vacated, which one being specified in the Aggregation rule).</Paragraph>
    <Paragraph position="31"> This process is applied repeatedly until improvement ceases. The output of the Hill Climber is a Say- null list for which there are no remaining beneficial poten- 1. tial applications of Aggregation rules.</Paragraph>
    <Paragraph position="32"> The selection algorithm of the Hill Climber is somewhat unconventional in that it does not select the Aggregation rule application with the largest increase 2. in collective score, which would be the usual practice. The hill of collective scores has many local maxima, which can be traced to the fact that one application of an aggregation rule will preclude several others. Be- 3. cause protosentences are consumed, the various applications are in competition, and so a rule that produces a large gain may preclude even more gain.</Paragraph>
    <Paragraph position="33"> The Hill Climber selects the rule application to use based on an equation that includes competitive terms. It computes the amount of gain surely precluded by each application and makes its selection on the basis of maximum net gain, with the precluded gain subtracted. null The use of hill climbing avoids the combinatorial explosion involved in searching for the best of all pos- 6. sible ways to express the content. In general only a tiny fraction of the possibilities are actually examined. This Saylist improvement activity is the technical heart of the text production process; it develops the final sentence boundaries and establishes the smoothness of the text.</Paragraph>
    <Paragraph position="34"> Figure 11 shows a few of the Aggregation rules.</Paragraph>
    <Paragraph position="35"> (Each of them has been rewritten into an informal notation suggesting its content.) Aggregation rules are intended to be meaning-preserving in the reader's</Paragraph>
    <Paragraph position="37"> If not P then R.</Paragraph>
  </Section>
class="xml-element"></Paper>