{
    "paper_id": "P99-1017",
    "header": {
        "generated_with": "S2ORC 1.0.0",
        "date_generated": "2023-01-19T09:31:37.566811Z"
    },
    "title": "Using aggregation for selecting content when generating referring expressions",
    "authors": [
        {
            "first": "John",
            "middle": [
                "A"
            ],
            "last": "Bateman",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "University of Bremen",
                "location": {
                    "settlement": "Bremen",
                    "country": "Germany"
                }
            },
            "email": ""
        },
        {
            "first": "Sprach-Und",
            "middle": [],
            "last": "Literaturwissenschaften",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "University of Bremen",
                "location": {
                    "settlement": "Bremen",
                    "country": "Germany"
                }
            },
            "email": ""
        }
    ],
    "year": "",
    "venue": null,
    "identifiers": {},
    "abstract": "Previous algorithms for the generation of referring expressions have been developed specifically for this purpose. Here we introduce an alternative approach based on a fully generic aggregation method also motivated for other generation tasks. We argue that the alternative contributes to a more integrated and uniform approach to content determination in the context of complete noun phrase generation.",
    "pdf_parse": {
        "paper_id": "P99-1017",
        "_pdf_hash": "",
        "abstract": [
            {
                "text": "Previous algorithms for the generation of referring expressions have been developed specifically for this purpose. Here we introduce an alternative approach based on a fully generic aggregation method also motivated for other generation tasks. We argue that the alternative contributes to a more integrated and uniform approach to content determination in the context of complete noun phrase generation.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Abstract",
                "sec_num": null
            }
        ],
        "body_text": [
            {
                "text": "When generating referring expressions (RE), it is generally considered necessary to provide sufficient information so that the reader/hearer is able to identify the intended referent. A number of broadly related referring expression algorithms have been developed over the past decade based on the natural metaphor of 'ruling out distractors' (Reiter, 1990; Dale and Haddock, 1991; Dale, 1992; Dale and Reiter, 1995; Horacek, 1995) . These special purpose algorithms constitute the 'standard' approach to determining content for RE-generation at this time; they have been developed solely for this purpose and have evolved to meet some specialized problems. In particular, it was found early on that the most ambitious RE goal-that of always providing the maximally concise referring expression necessary for the context ('full brevity')--is NP-haxd; subsequent work on RE-generation has therefore attempted to steer a course between computational tractability and coverage. One common feature of the favored algorithmic simplifications is their incrementality: potential descriptions are successively refined (usually non-destructively) to produce the final RE, which therefore may or may not be minimal. This is also often motivated on grounds of psychological plausibility.",
                "cite_spans": [
                    {
                        "start": 343,
                        "end": 357,
                        "text": "(Reiter, 1990;",
                        "ref_id": "BIBREF10"
                    },
                    {
                        "start": 358,
                        "end": 381,
                        "text": "Dale and Haddock, 1991;",
                        "ref_id": "BIBREF1"
                    },
                    {
                        "start": 382,
                        "end": 393,
                        "text": "Dale, 1992;",
                        "ref_id": "BIBREF4"
                    },
                    {
                        "start": 394,
                        "end": 416,
                        "text": "Dale and Reiter, 1995;",
                        "ref_id": "BIBREF2"
                    },
                    {
                        "start": 417,
                        "end": 431,
                        "text": "Horacek, 1995)",
                        "ref_id": "BIBREF6"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "In this paper, we introduce a completely different metaphor for determining RE-content that may be considered in contrast to, or in combination with, previous approaches. The main difference lies in an orientation to the organization of a data set as a whole rather than to individual components as revealed during incremental search. Certain opportunities for concise expression that may otherwise be missed are then effectively isolated. The approach applies results from the previously unrelated generation task of 'aggregation', which is concerned with the grouping together of structurally related information.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "Aggregation in generation has hitherto generally consisted of lists of more or less ad hoc, or case-specific rules that group together paxticulax pre-specified configurations (cf. Dalianis and Hovy (1996) and Shaw (1998) ); however Bateman et al. (1998) provide a more rigorous and generic foundation for aggregation by applying results from data-summarization originally developed for multimedia information presentation (Kamps, 1997) . Bateman et al. set out a general purpose method for constructing aggregation lattices which succinctly represent all possible structural aggregations for any given data set. 1 The application of the aggregationbased metaphor to RE-content determination is motivated by the observation that if something is a 'potential distractor' for some intended referent, then it is equally, under appropriate conditions, a candidate for aggregation together with the intended referent. That 1'Structural' aggregation refers to opportunities for grouping inherent in the structure of the data and ignoring additional opportunities for grouping that might be found by modifying the data inferentially.",
                "cite_spans": [
                    {
                        "start": 180,
                        "end": 204,
                        "text": "Dalianis and Hovy (1996)",
                        "ref_id": "BIBREF5"
                    },
                    {
                        "start": 209,
                        "end": 220,
                        "text": "Shaw (1998)",
                        "ref_id": "BIBREF11"
                    },
                    {
                        "start": 232,
                        "end": 253,
                        "text": "Bateman et al. (1998)",
                        "ref_id": "BIBREF0"
                    },
                    {
                        "start": 422,
                        "end": 435,
                        "text": "(Kamps, 1997)",
                        "ref_id": "BIBREF8"
                    },
                    {
                        "start": 438,
                        "end": 452,
                        "text": "Bateman et al.",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The aggregation-based metaphor",
                "sec_num": "2"
            },
            {
                "text": "is, what makes something a distractor is precisely the same as that which makes it a potential co-member of some single grouping created by structural aggregation. To see this, consider the following simple example discussed by Dale and Reiter (1995) consisting of three objects with various properties (re-represented here in a simple association list format): 2 (ol (type dog) (size small) (color (02 (type dog) (size large) (color (03 (type cat) (size small) (color To successfully refer to the first object ol, sufficient information must be given so as to 'rule out' the possible distractors: therefore, type alone is not sufficient, since this fails to rule out o2, nor is any combination of size or color sufficient, since these fail to rule out 03. Successful RE's are 'the small dog' or 'the black dog' and not 'the small one', 'the dog', or 'the black one'.",
                "cite_spans": [
                    {
                        "start": 228,
                        "end": 250,
                        "text": "Dale and Reiter (1995)",
                        "ref_id": "BIBREF2"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The aggregation-based metaphor",
                "sec_num": "2"
            },
            {
                "text": "Considering the data set from the aggregation perspective, we ask instead how to refer most succinctly to all of the objects ol, o2, o3. There are two basic alternatives, indicated by bracketing in the following: 3 1. (A (small black and a large white) dog) and",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The aggregation-based metaphor",
                "sec_num": "2"
            },
            {
                "text": "(a small black cat).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The aggregation-based metaphor",
                "sec_num": "2"
            },
            {
                "text": "2. (A small black (dog and cat)) and (a large white dog).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The aggregation-based metaphor",
                "sec_num": "2"
            },
            {
                "text": "The former groups together ol and o2 on the basis of their shared type, while the latter groups together ol and o3 on the basis of their shared size and color properties. Significantly, these are just the possible sources of distraction that Dale and Reiter discuss. The set of possible aggregations can be determined from an aggregation lattice corresponding to the data set. We construct the lattice using methods developed in Formal Concept Analysis (FCA) (Wille, 1982) . For the example at hand, the aggregation lattice is built up as follows. The set of objects is considered as a relation table where the columns represent the object attributes and their values, and the rows 2This style of presentation is not particularly perspicuous but space precludes providing intelligible graphics, especially for the more complex situations used as examples below. In case of difficulties, we recommend quickly sketching the portrayed situation as a memory aid.",
                "cite_spans": [
                    {
                        "start": 459,
                        "end": 472,
                        "text": "(Wille, 1982)",
                        "ref_id": "BIBREF13"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The aggregation-based metaphor",
                "sec_num": "2"
            },
            {
                "text": "3The exact rendering of these variants in English or any other language is not at issue here. black)) white)) black)) represent the individual objects. Since the attributes (e.g., 'color', 'size', etc.) can take multiple values (e.g., 'large', 'small'), this representation of the data is called a multivalued context. This is then converted into a one-valued context by comparing all rows of the table pairwise and, for each attribute (i.e., each column in the table) entering one distinguished value (e.g., T or 1) if the corresponding values of the attributes compared are identical, and another distinguished value (nil or 0) if they are not. The one-valued context for the objects ol-o3 is thus:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The aggregation-based metaphor",
                "sec_num": "2"
            },
            {
                "text": "object pairs type size color ol-o2 1 0 0 ol-o3 0 1 1 o2-o3 0 0 0",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The aggregation-based metaphor",
                "sec_num": "2"
            },
            {
                "text": "This indicates that objects ol and o2 have equal values for their type attribute but otherwise not, while ol and 03 have equal values for both their size and color attributes but not for their type attributes. The one-valued context readily supports the derivation of formal concepts. A formal concept is defined in FCA as an extension-intension pair (A,B), where the extension is a subset A of the set of objects and the intension is a subset B of the set of attributes. For any given concept, each element of the extension must accept all attributes of the intension. Visually, this corresponds to permuting any rows and columns of the one-valued context and noting all the maximally 'filled' (i.e., containing l's or T's) rectangles. A 'subconcept' relation, '<FCA', is defined over the set of formal concepts thus:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The aggregation-based metaphor",
                "sec_num": "2"
            },
            {
                "text": "(A, B) <FCA (A*, B*) iff A C A* ~=~ B* C B",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The aggregation-based metaphor",
                "sec_num": "2"
            },
            {
                "text": "The main theorem of FCA then shows that <FCA induces a complete lattice structure over the set of formal concepts. The resulting lattice for the present example is shown in Figure 1 . Each node is shown labeled with two pieces of information: the intension and the extension. The intensions consist simply of the sets of properties involved. The representations of the extensions emphasize the function of the nodes in the lattice--i.e., that the indicated objects (e.g., ol and o2 for the leftmost node) are equal with respect to all the attributes contained in the intension (e.g., type for the leftmost node). This lattice may be construed as an aggregation lattice because the functional redundancies that are captured are precisely those redundances that indicate opportunities for structurally-induced aggregation. The leftmost node shows that the attribute type may be aggregated if we describe ol together with o2, and the right-most node shows that {color, size} may be aggregated when describing ol and o3.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 173,
                        "end": 181,
                        "text": "Figure 1",
                        "ref_id": "FIGREF0"
                    }
                ],
                "eq_spans": [],
                "section": "The aggregation-based metaphor",
                "sec_num": "2"
            },
            {
                "text": "Now, given the equivalence between aggregation possibilities and 'distractors', we can also use the lattice to drive RE-content determination. Assume again that we wish to refer to object ol. In essence, a combination of attributes must be selected that is not subject to aggregation; any combination susceptible to aggregation will necessarily 'confuse' the objects for which the aggregation holds when only one of the objects, or co-aggregates, is mentioned. For example, the rightmost node shows that an RE with the content size&color(ol), e.g., 'the small black thing', confuses ol and o3. To select attributes that are appropriate, we first examine the minimal nodes of the lattice to see if any of these do not 'impinge' (i.e., have no aggregation consequences: we make this more precise below) on the intended referent. In this case, however, all these nodes do mention ol and so no strong preference for the RE-content is delivered by the data set itself. This appears to us to be the correct characterization of the reference situation: precisely which attributes are selected should now be determined by factors not attributable to 'distraction' but rather \u2022 by more general communicative goals involving discourse and the requirements of the particular language. The resulting attribute combinations are then checked against the aggregation lattice for their referential effectiveness in a manner reminiscent of the incremental approach of previous algorithms. Selection of type is not sufficient but the addition of either color or size is (type~zcolor = \u00b1 and type~size=l).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The aggregation-based metaphor",
                "sec_num": "2"
            },
            {
                "text": "The reference situation is quite different when we wish to refer to either o2 or o3. For both of these cases there exists a non-impinging node (the right and leftmost nodes respectively). This establishes immediate attribute preferences based on the organizational properties of the data. Content-determination for o2 should include at least size or color ('the white thing', 'the large thing') and for o3 at least type ('the cat'). These RE's are minimal.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The aggregation-based metaphor",
                "sec_num": "2"
            },
            {
                "text": "In this section, we briefly summarize some more significant examples of RE-content determination using aggregation. Length limitations will require some shortcuts to be taken in the discussion and we will not follow up all of the alternative RE's that can be motivated.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Examples of aggregation-driven RE-content determination",
                "sec_num": "3"
            },
            {
                "text": "Dale and Reiter (1995) consider a number of variant algorithms that deviate from full brevity in order to achieve more attractive computational behavior. The first variant they consider relies on a 'Greedy Heuristic' (Dale, 1989; Johnson, 1974) ; they illustrate that this algorithm sacrifices minimality by constructing an RE for object ol in the context of the following properties concerning a set of seven cups of varying size (large, small), color (red, green, blue) and material (paper, plastic):",
                "cite_spans": [
                    {
                        "start": 217,
                        "end": 229,
                        "text": "(Dale, 1989;",
                        "ref_id": "BIBREF3"
                    },
                    {
                        "start": 230,
                        "end": 244,
                        "text": "Johnson, 1974)",
                        "ref_id": "BIBREF7"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "(oi (size large)(color red)(material plastic)) (02 (size small)(color red)(material plastic)) (03 (size small)(color red)(material paper)) (04 (size medium)(color red)(material paper)) (05 (size large)(color green)(material paper)) (06 (size large)(color blue)(material paper)) (07 (size large)(color blue)(material plastic))",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "The greedy algorithm produces 'the large red plastic cup' although the true minimum description is 'the large red cup'. The aggregation-based approach to the same data set provides an interesting contrast in result. The aggregation lattice for the data is given in Figure 2 . The lattice is constructed as before: first by converting the multivalued context of the original data set to a one-valued context and then by imposing the subconcept",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 265,
                        "end": 273,
                        "text": "Figure 2",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "{COLOR} = 4~ m(ol)=m(o2)= m(o3)=rn(o4) m(ol )=m(o2) rn(o3)=m(o4} \"-....... m(o6)~m(o7! .-'\" {SIZE} m(ol )=m(o5)= m(o6)=m(o7) rn(ol )=m(o7} rn(o5)=m(o6)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "Figure 2: Aggregation lattice for the 'seven cups' example relation over the complete set of formal concepts. The nodes of the lattice are also labeled as before, although we rely here on the formal properties of the lattice to avoid redundant labeling. For example, the two sets of attribute equalities given for node 1 (one relating o2 and o3, the other relating o6 and o7) apply to both color (inherited from node 2) and size (inherited from node 4); we do not, therefore, repeat the labeling of properties for node 1. Similarly, and due to the bidirectionality inherent in the subconcept definition, the attribute equalities of node 1 are also 'inherited' upwards both to node 2 and to node 4. The attribute equalities of node 4 therefore include contributions from both node 1 and node 6. We will generally indicate in the labeling only the additional information arising from the structure of the lattice, and even then only when it is relevant to the discussion. So for node 4 we indicate that ol, o5, o6 and o7 now form a single attribute equality set made up of three contributions: one from node 1 (o6 and o7) and two from node 6. Their combination in a single set is only possible at node 4 because node 4 is a superconcept of both node 1 and node 6. The other attribute equality set for node 1 (o2 and o3) does not add further information at node 4 and so is left implicit in node 4's labeling. The labeling or non-labeling of redundant information has of course no formal consequences for the information contained in the lattice.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "To determine RE-content appropriate for referring to object ol, we again look for minimal (i.e., nearest the bottom) concepts, or aggregation sets, that do not 'impinge' on ol. The only node satisfying this requirement is node 1. This tells us that the set of possible co-aggregates for ol with respect to the properties {size & color} is empty, which is equivalent to stating that there are no objects in the data set which might be confused with ol if size&color(ol) forms the RE-content. Thus, 'the large red cuP' may be directly selected, and this is precisely the true minimal RE for this data set.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "3.2 Relational descriptions: restricting recursion One early extension of the original REalgorithms was the treatment of data sets involving relations (Dale and Haddock, 1991) . Subsequently, Horacek (1995) has argued that the extension proposed possesses several deficits involving both the extent of coverage and its behavior. In particular, Horacek notes that \"it is not always necessary that each entity directly or indirectly related to the intended referent and included in the description be identified uniquely\" (p49). Partially to handle such situations, Horacek provides a further related algorithm that is intended to improve on the original and which he illustrates in action with reference to a rather more complex situation involving two tables with a variety of cups and bottles on them. One table (tl) has two bottles and a cup on it, another (t2) has only a cup. Information is also given concerning the relative positions of the cups and bottles.",
                "cite_spans": [
                    {
                        "start": 151,
                        "end": 175,
                        "text": "(Dale and Haddock, 1991)",
                        "ref_id": "BIBREF1"
                    },
                    {
                        "start": 192,
                        "end": 206,
                        "text": "Horacek (1995)",
                        "ref_id": "BIBREF6"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "The situation that Horacek identifies as problematic occurs when the reference task is to refer to the table tl and the the RE-algorithm has decided to include the bottles that are on this table as part of its description. This is an appropriate decision since the presence of these bottles is the one distinguishing feature of the selected table. But it is sufficient for the identification of tl for bottles to be mentioned at all: there is no need for either or both of the bottles to be distinguished more specifically. An RE-algorithm should therefore avoid attempting this additional, unnecessary reference task.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "To form an aggregation lattice for this fact set, we extend our data representation to deal with relations as well as attributes. This is limited to 'reifying' the relations and labeling them with 'instance variables' as commonly done in input expressions for generation systems (Kasper, 1989) . For convenience, we also at this point fold in the type information di-(g7 (pred on)(argl bl)(argltype bottle)(arg2 tl)(arg2type table)) (g8 (pred on)(argl b2)(argltype bottle)(arg2 tl)(arg2type table)) (g9 (pred on)(argl cl)(argltype cup)(arg2 tl)(arg2type table)) (g10 (pred on)(argl c2)(argltype cup)(arg2 t2)(arg2type table)) (gli (pred left-of)(argl bl)(argltype bottle)(arg2 cl)(arg2type cup)) (g12 (pred left-of)(argl cl)(argltype cup)(arg2 b2)(arg2type bottle)) Figure 3 : Aggregation lattice for example from Horacek (1995) rectly as would be normal for a typed semantic representation. This gives the set of facts g7-g12 shown at the top of Figure 3 . 4 Once the data set is in this form, aggregation lattice construction may proceed as described above; the result is also shown in Figure 3 . This lattice reflects the more complex reference situation represented by the data set and its possible aggregations: for example, node 7 shows that the facts {g7, g8, gg, gl0} may be aggregated with respect to both arg2type ('table': node 5) and pred ('on': node 6). Node 3, in contrast, shows that the two distinct sets {g9, gl0} and {g7, g8} (again inherited upwards from node 2) may both individually (but not collectively) also be aggregated with pred, arg2type, and additionally with argltype ('cup': node 4).",
                "cite_spans": [
                    {
                        "start": 279,
                        "end": 293,
                        "text": "(Kasper, 1989)",
                        "ref_id": "BIBREF9"
                    },
                    {
                        "start": 814,
                        "end": 828,
                        "text": "Horacek (1995)",
                        "ref_id": "BIBREF6"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 766,
                        "end": 774,
                        "text": "Figure 3",
                        "ref_id": null
                    },
                    {
                        "start": 947,
                        "end": 955,
                        "text": "Figure 3",
                        "ref_id": null
                    },
                    {
                        "start": 1088,
                        "end": 1096,
                        "text": "Figure 3",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "{ARG2TYPE} \u2022 m(g7)=m(g8)=m(glO) II {ARC2} II m(g7)=m(g8)=m(g9) 'm(g9)=m(glO) m(g7)=m(g8) ............ {ARGITYPE} m(g8)=m(gl 1) m(g10)=m(g12) {ARGI} m(g7)=m(gl 1) m(g9)=m(g12)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "We first consider the reference task described by Horacek, i.e ., identifying the object tl. Now that we are dealing with relations, the ob-\u2022 jects to be referred to generally occur as values of 'attributes'--that is, as entries in the data table--rather than as entire rows. In order to construct an appropriate RE we need to find relations that describe the intended referent and which do not allow aggregation with other rela-4Note that this is then isomorphic to a set of SPL specifications of the form (g7 / on :argl (bl / bottle) :arg2 (tl / table)), etc. tions describing other conflicting referents. We also need to indicate explicitly that the REcontent should not avail itself of the literal instance variables: these are to remain internal to the lattice and to RE-construction so that individuals remain distinct. We therefore distinguish been 'public' and 'private' attributes: public attributes are available for driving linguistic expression, private attributes are not. If we were not to impose this distinction, then referring expressions such as 'the table tl' would be seen as appropriate and probably minimal descriptions! 5 An aggregation set that does hot involve a private attribute will be called a public concept.",
                "cite_spans": [
                    {
                        "start": 50,
                        "end": 62,
                        "text": "Horacek, i.e",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "The first step in constructing an RE is now to identify the relations/events in which the intended referent is involved--here {g7, g8, gg}-and to specify the positions (both private and public) that the referent holds in these. We call the set of potentially relevant relations, the reference information source set (ares). In the present case, the same argument position is held by the intended referent t l for all RISS-members, i.e., privately arg2 and publicly arg2type: Next, we proceed as before to 5Note that this might well be appropriate behavior in some context--in which case the variables would be declared public. find a non-impinging, minimal aggregate set. However, we can now define 'non-impinging' more accurately. A non-impinging node is one for which there is at least one public superconcept fulfilling the following condition: the required superconcept may not bring any RISSnon-member together as co-aggregate with any RISS-member drawn from the originating aggregation set with respect to the specified public attribute of the intended referent.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "By these definitions both the minimal nodes of the lattice are non-impinging. However, node 2 is more supportive of minimal RE's and we will only follow this path here; formal indications of minimality are given by the depth and number of paths leading from the node used for aggregation to the top of the aggregation lattice (since any resulting description then combines discriminatory power from each of its chains of superconcepts) and the number of additional facts that are taken over and above the original RISS-members. Node 2 is therefore the 'default' choice simply given a requirement of brevity, although the generation process is free to ignore this if other communicative goals so decide.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "There are two public superconcepts for node 2: both of nodes 7 and 3 inherit arg2type from node 5 but do not themselves contain a private attribute. Of these only node 7 brings one of the originating RIss-members (i.e., g7 and g8 from node 2) into an aggregation set with a RISS non-member (gl0). Node 2 is therefore non-impinging via node 3. The attributes that may be aggregated at node 2 are arg2 (node 2 <EVA 8), arg2type (2 <FCA 5), pred (2 <FCA 6) and argltype (2 <:FCA 4). Since this includes arg2, the private position of the intended referent, we know that the data set does not support aggregation for g7 and g8 with respect to any other distracting value for arg2, and so g7 and g8, both collectively and individually, are appropriate and sufficient RE's for tl.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "\u2022 Rendering these in English would give us: g7 or g8",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "'the table with a bottle on it' g? plus g8 'the table with some bottles on it'",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "The precise rendering of the bottles depends on other generator decisions; important here is only the fact that it is known that we do not need to uniquely identify which bottles are in question. More identifying information for argl (g8' (pred on) (argl b2) (argltype bottle) (arg2 t2) (arg2type table) (the bottles bl and b2) would be necessary only if an aggregation with other arg2's (e.g., other tables) were possible, but it is not, and so the type information is already sufficient to produce an RE with no unwanted aggregation possibilities. The aggregation-based approach will not, therefore, go on to consider further facts unless there is an explicit communicative intention to do so.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 287,
                        "end": 303,
                        "text": "(arg2type table)",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Minimal descriptions",
                "sec_num": "3.1"
            },
            {
                "text": "In this final example we show that the behavior above does not preclude information being added when it is in fact necessary. We show this by adapting Horacek's set of facts slightly to create a different aggregation lattice; we move one of the bottles (b2) over to the other table t2, placing it to the right of the cup. We show the modified facts and the new aggregation lattice in Figure 4 . Here a few concepts have moved in response to the revised reference situation: for example, arg2type (node 3) is now a direct subconcept of pred indicating that in the revised data set there is a functional relationship between the two attributes: all co-aggregates with respect to arg2type are necessarily also co-aggregates with respect to pred. In the previous example this did not hold because there were also facts with shared pred and non-shared arg2type (facts gll and g12: node 6).",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 384,
                        "end": 392,
                        "text": "Figure 4",
                        "ref_id": "FIGREF1"
                    }
                ],
                "eq_spans": [],
                "section": "Relational descriptions: when further information is necessary",
                "sec_num": "3.3"
            },
            {
                "text": "We will again attempt to refer to the table t 1 to compare the results with those of the previous subsection. To begin, we have a RISS of {gT, gg} with the intended referent in arg2 (private) and arg2type (public) as before. We then look for non-impinging, most-specific nodes. Here, nodes 4 and 5 are both impinging. Node 4 is impinging in its own right since it sanctions aggregation of both the RIss-members it mentions with non-members with respect to arg2type (node 3) and argltype (node 6); this deficit is then inherited upwards. Node 5 is impinging by virtue of its first and only available public superconcept, node 3, which sanctions as coaggregates {gT, g8 ~, gg, gl0} with respect to arg2type. Neither node 4 nor node 5 can therefore support appropriate RE's. Only node 2 is non-impinging, since it does not sanction aggregation involving arg2type or arg2, and is the only available basis for an effective RE with the revised data set.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Relational descriptions: when further information is necessary",
                "sec_num": "3.3"
            },
            {
                "text": "To construct the RE we take the RISS-member of node 2 (i.e., gT) and consider it and the aggregations it sanctions as candidate material. Node 2 indicates that g7 may be aggregated with gll with respect to argltype; such an aggregation is guaranteed not to invoke a false referent for argl because it is non-impinging. Moreover, we can infer that g? alone is insufficient since nodes 3 and 4 indicate that g7 is a co-aggregate with facts with non-equal argl values (e.g., gSr), and so aggregation is in fact necessary. The RE then combines:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Relational descriptions: when further information is necessary",
                "sec_num": "3.3"
            },
            {
                "text": "(g7 (pred on)(argl bl)(argltype bottle) (arg2 tl)(arg2type table)) (g11 (pred left-of)(argl bl)(argltype bottle) (arg2 cl)(arg2type cup))",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Relational descriptions: when further information is necessary",
                "sec_num": "3.3"
            },
            {
                "text": "to produce 'the table on which a bottle is to the left of a cup'. This is the only RE that will identify the required table in this highly symmetri-\u2022 cal context. No further information is sought because there are no further aggregations possible with respect to arg2 and so the reference is unique; it is also minimal.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Relational descriptions: when further information is necessary",
                "sec_num": "3.3"
            },
            {
                "text": "One important feature of the proposed approach is its open-nature with respect to the rest of the generation process. The mechanisms described attempt only to factor out one recurrent problem of generation, namely organizing instantial data to reveal the patterns of contrast and similarity. In this way, RE-generation is re-assimilated and seen in a somewhat more general light than previously.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Discussion and Conclusion",
                "sec_num": "4"
            },
            {
                "text": "In terms of the implementation and complexity of the approach, it is clear that it cuts the cake rather differently from previous algorithms/approaches. Some cases of efficient reference may be read-off directly from the lattice; others may require explicit construction and trial of RE-content more reminiscent of the previous algorithms. In fact, the aggregation lattice may in such cases be usefully considered in combination with those algorithms, providing an alternative method for checking the consistency of intermediate steps. Here one important difference between the current approach and previous attempts at maintaining consistency is the re-orientation from an incremental procedure to a more static 'overview' of the relationships present, thus providing a promising avenue for the exploration of referring strategies with a wider 'domain of locality'.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Discussion and Conclusion",
                "sec_num": "4"
            },
            {
                "text": "This re-orientation is also reflected in the differing computational complexity of the approaches: the run-time behavior of the previous algorithms is highly dependent on the final result (number of properties known true of the referent, number of attributes mentioned in the RE), whereas the run-time of the current approach is more closely tied to the data set as a whole, particularly to the number of facts (rid) and the number of attributes (ha).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Discussion and Conclusion",
                "sec_num": "4"
            },
            {
                "text": "Test runs involving lattice construction for random data sets ranging from 10 to 120 objects, with a number of attributes ranging from 5 to 15 (each with 5-7 possible values) showed that a simple experimental algorithm constructed for uncovering the formal concepts constituting the aggregation lattices had a typical runtime approximately proportional to nan2d . Although worst-case behavior for both this and the lattice construction component is substantially slower, there are now efficient standard algorithms and implementations available that mitigate the problem even when manipulating quite sizeable data sets. 6 For the sizes of data 6A useful summary and collection of pointers to complexity results and efficient algorithms is given by Vogt sets that occur when considering a RE, timecomplexity is not likely to present a problem.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Discussion and Conclusion",
                "sec_num": "4"
            },
            {
                "text": "Nevertheless, for larger data sets the approach given here is undoubtedly considerably slower than the simplified algorithms reported both by Dale and Reiter and by Horacek. However, in contrast to those approaches, it relies only on generic, non-RE specific methods. The approach also, as suggested above, appears under certain conditions to effectively deliver maximally concise RE's; just what these conditions are and whether they can be systematically exploited remain for future research. Finally, since the use of aggregation lattices has been argued for other generation tasks (Bateman et al., 1998) , some of the 'cost' of deployment may in fact turn out to be shared, making a direct comparison solely with the RE-task in any case inappropriate. Other generation constraints might then also naturally contribute to restricting the overall size of the data sets to be considered--perhaps even to within acceptable practical limits.",
                "cite_spans": [
                    {
                        "start": 585,
                        "end": 607,
                        "text": "(Bateman et al., 1998)",
                        "ref_id": "BIBREF0"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Discussion and Conclusion",
                "sec_num": "4"
            }
        ],
        "back_matter": [
            {
                "text": "This paper was improved by the anonymous comments of reviewers for both the ACL and the European Natural Language Generation Workshop (1999). Remaining errors and obscurities are my own.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Acknowledgements",
                "sec_num": null
            }
        ],
        "bib_entries": {
            "BIBREF0": {
                "ref_id": "b0",
                "title": "Communicative goal-driven NL generation and datadriven graphics generation: an architectural synthesis for multimedia page generation",
                "authors": [
                    {
                        "first": "John",
                        "middle": [],
                        "last": "Bateman",
                        "suffix": ""
                    },
                    {
                        "first": "Thomas",
                        "middle": [],
                        "last": "Kamps",
                        "suffix": ""
                    },
                    {
                        "first": "Jsrg",
                        "middle": [],
                        "last": "Kleinz",
                        "suffix": ""
                    },
                    {
                        "first": "Klaus",
                        "middle": [],
                        "last": "Reichenberger",
                        "suffix": ""
                    }
                ],
                "year": 1998,
                "venue": "Proceedings of the 1998 International Workshop on Natural Language Generation",
                "volume": "",
                "issue": "",
                "pages": "8--17",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "John Bateman, Thomas Kamps, JSrg Kleinz, and Klaus Reichenberger. 1998. Commu- nicative goal-driven NL generation and data- driven graphics generation: an architectural synthesis for multimedia page generation. In Proceedings of the 1998 International Work- shop on Natural Language Generation, pages 8-17. Niagara-on-the-Lake, Canada.",
                "links": null
            },
            "BIBREF1": {
                "ref_id": "b1",
                "title": "Generating referring expressions involving relations",
                "authors": [
                    {
                        "first": "Robert",
                        "middle": [],
                        "last": "Dale",
                        "suffix": ""
                    },
                    {
                        "first": "Nicholas",
                        "middle": [],
                        "last": "Haddock",
                        "suffix": ""
                    }
                ],
                "year": 1991,
                "venue": "Proceedings of the 1991 Meeting of the European Chapter of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "161--166",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Robert Dale and Nicholas Haddock. 1991. Gen- erating referring expressions involving rela- tions. In Proceedings of the 1991 Meeting of the European Chapter of the Association for Computational Linguistics, pages 161- 166, Berlin.",
                "links": null
            },
            "BIBREF2": {
                "ref_id": "b2",
                "title": "Formal techniques for minimizing the size of the data set that is used for further processing are also given. ims in the generation of referring expressions",
                "authors": [
                    {
                        "first": "Robert",
                        "middle": [],
                        "last": "Dale",
                        "suffix": ""
                    },
                    {
                        "first": "Ehud",
                        "middle": [],
                        "last": "Reiter",
                        "suffix": ""
                    }
                ],
                "year": 1995,
                "venue": "Cognitive Science",
                "volume": "19",
                "issue": "",
                "pages": "233--263",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Robert Dale and Ehud Reiter. 1995. Compu- tational interpretations of the Gricean max- (1996). Formal techniques for minimizing the size of the data set that is used for further processing are also given. ims in the generation of referring expressions. Cognitive Science, 19:233-263.",
                "links": null
            },
            "BIBREF3": {
                "ref_id": "b3",
                "title": "Cooking up referring expressions",
                "authors": [
                    {
                        "first": "Robert",
                        "middle": [],
                        "last": "Dale",
                        "suffix": ""
                    }
                ],
                "year": 1989,
                "venue": "Proceedings of the Twenty-Seventh Annual Meeting of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Robert Dale. 1989. Cooking up referring ex- pressions. In Proceedings of the Twenty- Seventh Annual Meeting of the Association for Computational Linguistics, Vancouver, British Columbia.",
                "links": null
            },
            "BIBREF4": {
                "ref_id": "b4",
                "title": "Generating referring expressions: constructing descriptions in a domain of objects and processes. Bradford Books",
                "authors": [
                    {
                        "first": "Robert",
                        "middle": [],
                        "last": "Dale",
                        "suffix": ""
                    }
                ],
                "year": 1992,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Robert Dale. 1992. Generating referring ex- pressions: constructing descriptions in a domain of objects and processes. Brad- ford Books, MIT Press, Cambridge, Mas- sachusetts.",
                "links": null
            },
            "BIBREF5": {
                "ref_id": "b5",
                "title": "Aggregation in natural language generation",
                "authors": [
                    {
                        "first": "Hercules",
                        "middle": [],
                        "last": "Dalianis",
                        "suffix": ""
                    },
                    {
                        "first": "Eduard",
                        "middle": [],
                        "last": "Hovy",
                        "suffix": ""
                    }
                ],
                "year": 1996,
                "venue": "Trends in natural language generation: an artificial intelligence perspective",
                "volume": "",
                "issue": "",
                "pages": "88--105",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Hercules Dalianis and Eduard Hovy. 1996. Ag- gregation in natural language generation. In Giovanni Adorni and Michael Zock, editors, Trends in natural language generation: an ar- tificial intelligence perspective, pages 88-105. Springer-Verlag.",
                "links": null
            },
            "BIBREF6": {
                "ref_id": "b6",
                "title": "More on generating referring expressions",
                "authors": [
                    {
                        "first": "Helmut",
                        "middle": [],
                        "last": "Horacek",
                        "suffix": ""
                    }
                ],
                "year": 1995,
                "venue": "Proceedings of the Fifth European Workshop on Natural Language Generation",
                "volume": "",
                "issue": "",
                "pages": "43--58",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Helmut Horacek. 1995. More on generating referring expressions. In Proceedings of the Fifth European Workshop on Natural Lan- guage Generation, pages 43-58, Leiden, The Netherlands.",
                "links": null
            },
            "BIBREF7": {
                "ref_id": "b7",
                "title": "Approximate algorithms for combinatorial problems",
                "authors": [
                    {
                        "first": "D",
                        "middle": [],
                        "last": "Johnson",
                        "suffix": ""
                    }
                ],
                "year": 1974,
                "venue": "Journal of Computer and Systems Sciences",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "D. Johnson. 1974. Approximate algorithms for combinatorial problems. Journal of Com- puter and Systems Sciences, 9.",
                "links": null
            },
            "BIBREF8": {
                "ref_id": "b8",
                "title": "A constructive theory for diagram design and its algorithmic implementation",
                "authors": [
                    {
                        "first": "Thomas",
                        "middle": [],
                        "last": "Kamps",
                        "suffix": ""
                    }
                ],
                "year": 1997,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Thomas Kamps. 1997. A constructive theory for diagram design and its algorithmic imple- mentation. Ph.D. thesis, Darmstadt Univer- sity of Technology, Germany.",
                "links": null
            },
            "BIBREF9": {
                "ref_id": "b9",
                "title": "A flexible interface for linking applications to PENMAN'S sentence generator",
                "authors": [
                    {
                        "first": "Robert",
                        "middle": [
                            "T"
                        ],
                        "last": "Kasper",
                        "suffix": ""
                    }
                ],
                "year": 1989,
                "venue": "Proceedings of the DARPA Workshop on Speech and Natural Language",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Robert T. Kasper. 1989. A flexible interface for linking applications to PENMAN'S sentence generator. In Proceedings of the DARPA Workshop on Speech and Natural Language.",
                "links": null
            },
            "BIBREF10": {
                "ref_id": "b10",
                "title": "Generating descriptions that exploit a user's domain knowledge",
                "authors": [
                    {
                        "first": "Ehud",
                        "middle": [],
                        "last": "Reiter",
                        "suffix": ""
                    }
                ],
                "year": 1990,
                "venue": "Current Research in Natural Language Generation",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Ehud Reiter. 1990. Generating descriptions that exploit a user's domain knowledge. In R. Dale, C. Mellish, and M. Zock, editors, Current Research in Natural Language Gen- eration. Academic Press, London.",
                "links": null
            },
            "BIBREF11": {
                "ref_id": "b11",
                "title": "Clause aggregation using linguistic knowledge",
                "authors": [
                    {
                        "first": "James",
                        "middle": [],
                        "last": "Shaw",
                        "suffix": ""
                    }
                ],
                "year": 1998,
                "venue": "Proceedings of the 1998 International Workshop on Natural Language Generation",
                "volume": "",
                "issue": "",
                "pages": "138--147",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "James Shaw. 1998. Clause aggregation us- ing linguistic knowledge. In Proceedings of the 1998 International Workshop on Nat- ural Language Generation, pages 138-147. Niagara-on-the-Lake, Canada.",
                "links": null
            },
            "BIBREF12": {
                "ref_id": "b12",
                "title": "Formale Begriffsanalyse mit C++. Datenstrukturen und Algorithmen",
                "authors": [
                    {
                        "first": "Frank",
                        "middle": [],
                        "last": "Vogt",
                        "suffix": ""
                    }
                ],
                "year": 1996,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Frank Vogt. 1996. Formale Begriffsanalyse mit C++. Datenstrukturen und Algorithmen. Springer-Verlag.",
                "links": null
            },
            "BIBREF13": {
                "ref_id": "b13",
                "title": "Restructuring lattice theory: an approach based on hierarchies of concept",
                "authors": [
                    {
                        "first": "R",
                        "middle": [],
                        "last": "Wille",
                        "suffix": ""
                    }
                ],
                "year": 1982,
                "venue": "Ordered Sets",
                "volume": "",
                "issue": "",
                "pages": "445--470",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "R. Wille. 1982. Restructuring lattice theory: an approach based on hierarchies of concept. In I. Rival, editor, Ordered Sets, pages 445-470. Reidel, Dordecht/Boston.",
                "links": null
            }
        },
        "ref_entries": {
            "FIGREF0": {
                "text": "{TYPE} m(ol )=m(o2) C> {COLOR, SIZE} m(ol )=m(o3) Simple aggregation lattice",
                "uris": null,
                "type_str": "figure",
                "num": null
            },
            "FIGREF1": {
                "text": "Aggregation lattice for modified example situation from Horacek",
                "uris": null,
                "type_str": "figure",
                "num": null
            }
        }
    }
}