| { |
| "paper_id": "P84-1048", |
| "header": { |
| "generated_with": "S2ORC 1.0.0", |
| "date_generated": "2023-01-19T08:20:31.974595Z" |
| }, |
| "title": "Combining Functionality and Ob]ec~Orientedness for Natural Language Processing", |
| "authors": [ |
| { |
| "first": "Toyoakl", |
| "middle": [], |
| "last": "Nishida", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "Kyoto University", |
| "location": { |
| "addrLine": "Sakyo-ku", |
| "postCode": "606", |
| "settlement": "Kyoto", |
| "country": "JAPAN" |
| } |
| }, |
| "email": "" |
| }, |
| { |
| "first": "Shuji", |
| "middle": [], |
| "last": "Doshita", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "Kyoto University", |
| "location": { |
| "addrLine": "Sakyo-ku", |
| "postCode": "606", |
| "settlement": "Kyoto", |
| "country": "JAPAN" |
| } |
| }, |
| "email": "" |
| } |
| ], |
| "year": "", |
| "venue": null, |
| "identifiers": {}, |
| "abstract": "This paper proposes a method for organizing linguistic knowledge in both systematic and flexible fashion. We introduce a purely applicative language (PAL) as an intermediate representation and an object-oriented computation mechanism for its interpretation. PAL enables the establishment of a principled and well-constrained method of interaction among lexicon-oriented linguistic modules. The object-oriented computation mechanism provides a flexible means of abstracting modules and sharing common knowledge.", |
| "pdf_parse": { |
| "paper_id": "P84-1048", |
| "_pdf_hash": "", |
| "abstract": [ |
| { |
| "text": "This paper proposes a method for organizing linguistic knowledge in both systematic and flexible fashion. We introduce a purely applicative language (PAL) as an intermediate representation and an object-oriented computation mechanism for its interpretation. PAL enables the establishment of a principled and well-constrained method of interaction among lexicon-oriented linguistic modules. The object-oriented computation mechanism provides a flexible means of abstracting modules and sharing common knowledge.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstract", |
| "sec_num": null |
| } |
| ], |
| "body_text": [ |
| { |
| "text": "The goal of this paper is to elaborate a domain-independent way of organizing linguistic knowledge, as a step forwards a cognitive processor consisting of two components: a linguistic component and a memory component.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1." |
| }, |
| { |
| "text": "In this paper we assume the existence of the latter component meeting the requirements described in [Schank 82] . Thus the memory component attempts to understand the input in terms of its empirical knowledge, predict what happens next, and reorganize its knowledge based on new observations.", |
| "cite_spans": [ |
| { |
| "start": 100, |
| "end": 111, |
| "text": "[Schank 82]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1." |
| }, |
| { |
| "text": "Additionally, we assume that the memory component can judge whether a given observation is plausible or not, by consulting its empirical knowledge.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1." |
| }, |
| { |
| "text": "The role of the linguistic component, on the other hand, is to supply \"stimulus\" to the memory component. More specifically, the linguistic component attempts to determine the propositional content, to supply missing constituents for elliptical expressions, to resolve references, to identify the focus, to infer the intention of the speaker, etc. In short, the role of the [iguistic component is to \"translate\" the input into an internal representation.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1." |
| }, |
| { |
| "text": "For example, the output of the linguistic component for an input:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1." |
| }, |
| { |
| "text": "When did you go to New York? is something like the following2:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1." |
| }, |
| { |
| "text": "There is an event e specified by a set of predicates: isa(e)=going A past(e) A agent(e)=the_hearer A destination(e)=New_York. The speaker is asking the hearer for the time when an event e took place. The hearer presupposes that the event e actually took place at some time in the past.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1." |
| }, |
| { |
| "text": "1Currently visiting Department of Computer Science, Yale University, New Haven, Connecticut 06520, USA.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1." |
| }, |
| { |
| "text": "If the presupposition contradicts what the memory component knows, then the memory component will recognize the input as a loaded question [Kaplan 82] . As a result, the memory component may change its content or execute a plan to informing the user that the input is inconsistent with what it knows.", |
| "cite_spans": [ |
| { |
| "start": 139, |
| "end": 150, |
| "text": "[Kaplan 82]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1." |
| }, |
| { |
| "text": "The primary concern of this paper is with the linguistic component. The approach we take in this paper is to combine the notion of eompositionality a and an object-oriented computational mechanism to explore a principled and flexible way of organizing linguistic knowledge.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1." |
| }, |
| { |
| "text": "Device for Interpretation", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Intermediate Representation and Computational", |
| "sec_num": "2." |
| }, |
| { |
| "text": "Effective use of intermediate representations is useful. We propose the use of a language which we call PAL (Purely Applicative Language).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "PAL (Purely Applicative Language)", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "In PAL, new composite expressions are constructed only with a binary form of function application. Thus, if z and I/ are well-formed formulas of PAL, so is a form z(y). Expressions of PAL are related to expressions of natural language as follows:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "PAL (Purely Applicative Language)", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "Generally, when a phrase consists of its immediate descendants, say z and y, a PAL expression for the phrase is one of the following forms:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "PAL (Purely Applicative Language)", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "<z>( <V>) or <p>( <z>)", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "PAL (Purely Applicative Language)", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "where ~a> stands for a PAL expression for a phrase ~*. Which expression is the case depends on which phrase modifies which. If a phrase z modifies V then the PAL expression for z takes the functor position, i.e., the form is ~z~(~y~).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "PAL (Purely Applicative Language)", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "big apple =* big~apple) ; adjectives modify .anne very big ~ very(big) ; adverbs modify adjectives very big apple ~ (very(big)Xapple) ; reeuesive composition 2As illustrated in this example, we assume a predicate notation a~ an output of the linguistic component. But this choice is only for descriptive purposes and is not significant. awe prefer the term *functionality\" to \"eompositionality\", reflecting a procedural view rather than a purely mathematicaJ view.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Simple examples are:", |
| "sec_num": null |
| }, |
| { |
| "text": "How about other cases? In principle, this work is based on Montague's observations [Montague 74 ]. Thus we take the position that noun phrases modify (are functions of, to be more precise) verb phrases. But unlike Montague grammar we do not use iambda expressions to bind case elements. Instead we use special functors standing for case markers. For example, he runs ~ (*subject(he)Xruns) he eats it ~ (*subject(he)X(*object(it)Xeats))", |
| "cite_spans": [ |
| { |
| "start": 83, |
| "end": 95, |
| "text": "[Montague 74", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Simple examples are:", |
| "sec_num": null |
| }, |
| { |
| "text": "Another example, involving a determiner, is illustrated below: a big apple ~ a(big(apple)) ; determiners modlf~l nouns Sometimes we assume \"null\" words or items corresponding to morphemes, such as, role indicators, nominalizer, null NP, etc. apple which he eats ~ (which ((*subject(he)) ((*object(*null))", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Simple examples are:", |
| "sec_num": null |
| }, |
| { |
| "text": "EQUATION", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [ |
| { |
| "start": 0, |
| "end": 8, |
| "text": "EQUATION", |
| "ref_id": "EQREF", |
| "raw_str": "(eats))))", |
| "eq_num": "(apple)" |
| } |
| ], |
| "section": "Simple examples are:", |
| "sec_num": null |
| }, |
| { |
| "text": "; restrictive relative clauses modif~ nouns, ; rdativizers modify sentences to make adjectives", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Simple examples are:", |
| "sec_num": null |
| }, |
| { |
| "text": "In the discussion above, the notion of modify is crucial. What do we mean when we say z modifies y? In the case of Montague grammar, this question is answered based on a predetermined set theoretical model. For example, a noun is interpreted as a set of entities; the noun \"penguin\", for instance, is interpreted as a set of all penguins. An adjective, on the other hand, is interpreted as a function from sets of entities to sets of entities; an adjective \"small\" is interpreted as a selector function which takes such a set of entities (interpretation of each noun) and picks up from it a set of \"small\" entities. Note that this is a simplified discussion; intension is neglected. Note also that different conception may lead to a different definition of the relation modifp, which will in turn lead to intermediate representations with different function-argument relationships.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Simple examples are:", |
| "sec_num": null |
| }, |
| { |
| "text": "After all, the choice of semantic representation is relative to the underlying model and how it is interpreted. A good choice of a semantic representation -interpretation pair leads to a less complicated system and makes it easier to realize.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Simple examples are:", |
| "sec_num": null |
| }, |
| { |
| "text": "The next section discusses a computational device for interpreting PAL expressions.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Simple examples are:", |
| "sec_num": null |
| }, |
| { |
| "text": "Domain The notion of object-orientedness is widely used in computer science. We employ the notion in LOOPS [Bobrow 81] . The general idea is as follows:", |
| "cite_spans": [ |
| { |
| "start": 107, |
| "end": 118, |
| "text": "[Bobrow 81]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Object-Oriented", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "We have a number of objects. Objects can be viewed as both data and procedures. They are data in the sense that they have a place (called a local variable) to store information. At the same time, they are procedures in that they can manipulate data. An object can only update local variables belonging to itself. When data belongs to another object, a message must be sent to request the update. A message consista of a label and its value. In order to send a message, the agent has to know the name of the receiver.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Object-Oriented", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "There is no other means for manipulating data. Objects can be classified into classes and instances. A class defines a procedure [called a method) for handling incoming messages of its instances. A class inherits methods of its superclasses.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Object-Oriented", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "A class is defined for each constant of PAL. A class object for a lexical item contains linguistic knowledge in a procedural form. In other words, a class contains information as to how a corresponding lexical item is mapped into memory structures.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Object-Oriented Domain", |
| "sec_num": null |
| }, |
| { |
| "text": "A PAL expression is interpreted by evaluating the form which results from replacing each constant of a given PAL expression by an instance of an object whose class name is the same as the label of the constant. The evaluation is done by repeating the following cycle:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Object-Oriented Domain", |
| "sec_num": null |
| }, |
| { |
| "text": "\u2022 an object in argument position sends to an object in functor position a message whose label is \"argument ~ and whose value is the object itself.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Object-Oriented Domain", |
| "sec_num": null |
| }, |
| { |
| "text": "\u2022 a corresponding method is invoked and an object is returned as a result of application; usually one object causes another object to modify its content and the result is a modified version of either a functor or an argument.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Object-Oriented Domain", |
| "sec_num": null |
| }, |
| { |
| "text": "Note that objects can interact only in a constrained way. This is a stronger claim than that allowing arbitrary communication. The more principled and constrained way modules of the linguistic component interact, the less complicated will be the system and therefore the better perspective we can obtain for writing a large grammar.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Object-Oriented Domain", |
| "sec_num": null |
| }, |
| { |
| "text": "Let's start by seeing how our simple example for a sentence \"he runs\" is interpreted in our framework. A PAL expression for this sentence is:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "a.1 A Simple Example", |
| "sec_num": null |
| }, |
| { |
| "text": "(*subject(he)Xruus)", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "a.1 A Simple Example", |
| "sec_num": null |
| }, |
| { |
| "text": "Class definitions for related objects are shown in figure 3.1.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "a.1 A Simple Example", |
| "sec_num": null |
| }, |
| { |
| "text": "The interpretation process goes as follows:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "a.1 A Simple Example", |
| "sec_num": null |
| }, |
| { |
| "text": "\u2022 lnstantiating '*subject': let's call the new instance *subject 0.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "a.1 A Simple Example", |
| "sec_num": null |
| }, |
| { |
| "text": "\u2022 lnstantiating 'he': a referent is looked for from the memory. The referent (let's call this i0) is set to the local variable den, which stands for 'denotation'. Let the new instance be he 0.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "a.1 A Simple Example", |
| "sec_num": null |
| }, |
| { |
| "text": "\u2022 Evaluating '*subject0(he0)': a message whose label is 'case' and whose value is 'subject' is sent to the object he 0. As a result, he0's variable case has a value 'subject'. The value of the evaluation is a modified version of he0, which we call he I to indicate a different version. ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "a.1 A Simple Example", |
| "sec_num": null |
| }, |
| { |
| "text": "One of the basic tasks of the linguistic component is to find out which constituent is linked explicitly or implicitly to which constituent. From the example shown in section 3.1, the reader can see at least three possibilities:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Linking Case Elements", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "Case linking by sending messages. Using conventional terms of case grammar, we can say that \"governer\" receives a message whose label is a surface ease and whose value is the \"dependant'. This implementation leads us to the notion of abstraction to be discussed in section 3.4.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Linking Case Elements", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "Lexleon-drlven methods of determining deep ease. Surface case is converted into deep case by a method defined for each governer. This makes it possible to handle this hard problem without being concerned with how many different meanings each function word has. Governers which have the same characteristics in this respect can be grouped together as a superclass. This enables to avoid duplication of knowledge by means of hierarchy. The latter issue is discussed in section 3.2.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Linking Case Elements", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "The use of implicit case markers. We call items such as *subject or *object implicit, as they do not appear in the surface form, as opposed to prepositions, which are explicit (surface} markers. The introduction of implicit case marker seems to be reasonable if we see a language like Japanese in which surface case is explicitly indicated by postpositions. Thus we can assign to the translation of our sample sentence a PAL expression with the same structure as its English version:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Linking Case Elements", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "KARE GA HASHIRU ~ (GA(KARE)XHASHIRU)", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Linking Case Elements", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "where, \"KARE\" means \"he\", \"GA\" postposition indicating surface subject, \"HASHIRU\" \"run ~, respectively.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Linking Case Elements", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "\u2022 Evaluating hel(runs0): a message whose label is 'subject' and whose value is he ! is sent to runs0, which causes a new proposition 'agent(e0)--i 0, to be asserted in the memory component. The final result of the evaluation is a new version of the object runs0, say runs 1.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Linking Case Elements", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "The above discussion is overly simplified for the purpose of explanation. The following sections discuss a number of other issues.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Linking Case Elements", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "Object-oriented systems use the notion of hierarchy to share common procedures. Lexical items with similar eharacterics can be grouped together as a class; we may, for example, have a class 'noun' as a superclass of lexicai items 'boy', 'girl', 'computer' and so forth. ~,Vhen a difference is recognized among objects of a class, the class may be subdivided; we may subcategorize a verb into static verbs, action verbs, achievement verbs, etc. Common properties can be shared at the supercla~s. This offers a flexible way for writing a large grammar; one may start by defining both most general classes and least general classes. The more observations are obtained, the richer will be the class-superclass network. Additionally, mechanisms for supporting a multiple hierarchy and for borrowing a method are useful in coping with sophistication of linguistic knowledge, e.g., introduction of more than one subcategorization.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Sharing Common Knowledge", |
| "sec_num": "3.2" |
| }, |
| { |
| "text": "By attaching a sort of a message controller in front of an object, we can have a new version of the object whose linguistic knowledge is essentially the same as the original one but whose input/output specification is different. As a typical example we can show how a passivizer *en is dealt with. An object *en can have an embedded object as a value of its local variable embedded. If an instance of *en receives a message with label '*subject', then it will send to the object pointed by embedded the message with its label replaced by '*object'; if it receives a message with label 'by', then it will transfer the message to the \"embedded\" object by replacing the label field by '*subject'.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstraction", |
| "sec_num": "3.4" |
| }, |
| { |
| "text": "Thus the object *en coupled with a transitive verb can be viewed as if they were a single intransitive verb. This offers an abstracted way of handling linguistic objects.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstraction", |
| "sec_num": "3.4" |
| }, |
| { |
| "text": "The effect can be seen by tracing how a PAL expression:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstraction", |
| "sec_num": "3.4" |
| }, |
| { |
| "text": "( *subject(this(sentence))) ((by(a~computer))) [*en{understand)))", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstraction", |
| "sec_num": "3.4" |
| }, |
| { |
| "text": "\"This sentence is understood by a computer.\"", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstraction", |
| "sec_num": "3.4" |
| }, |
| { |
| "text": "is interpreted 4.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstraction", |
| "sec_num": "3.4" |
| }, |
| { |
| "text": "4Notice how the method for a transitive verb \"understand\" is defined, by extending the definition for an intransitive verb ~run ~.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstraction", |
| "sec_num": "3.4" |
| }, |
| { |
| "text": "We can use a very similar mechanism to deal with case linking by causative verbs. Consider the following sentence: z wants It to do z.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Impiieit Case Linklng", |
| "sec_num": "3.5" |
| }, |
| { |
| "text": "This sentence implies that the subject of the infinitive is the grammatical object of the main verb \"wants ~.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Impiieit Case Linklng", |
| "sec_num": "3.5" |
| }, |
| { |
| "text": "Such a property can be shared by a number of other verbs such as \"allow ~, \"cause ~, \"leC, \"make\", etc. In the object-oriented implementation, this can be handled by letting the object defined for this class transfer a message from its subject to the infinitive.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Impiieit Case Linklng", |
| "sec_num": "3.5" |
| }, |
| { |
| "text": "Note that the object for the these verbs must pass the message from its subject to the infinitive when its grammatical object is missing.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Impiieit Case Linklng", |
| "sec_num": "3.5" |
| }, |
| { |
| "text": "Another example of implicit case linking can be seen in relative clauses.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Impiieit Case Linklng", |
| "sec_num": "3.5" |
| }, |
| { |
| "text": "In an object-oriented implementation, a relativizer transfers a message containing a pointer to the head noun to a null NP occupying the gap in the relative clause. Intermediate objects serve as re-transmitting nodes as in computer networks.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Impiieit Case Linklng", |
| "sec_num": "3.5" |
| }, |
| { |
| "text": "In building a practical system, the problem of distinguishing obligatory case and non-obligatory case is always controversial. The notion of hierarchy is useful in dealing with this problem in a \"lazy\" fashion. What we means by this is as follows:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Obligatory Case versus Non-Obligatory Case", |
| "sec_num": "3.6" |
| }, |
| { |
| "text": "In procedural approach, the distinction we make between obligatory and non-obligatory cases seems to be based on economical reason. To put this another way, we do not want to let each lexical item have cases such as locative, instrumental, temporal, etc. This would merely mean useless duplication of knowledge. We can use the notion of hierarchy to share methods for these cases. Any exceptional method can be attached to lower level items.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Obligatory Case versus Non-Obligatory Case", |
| "sec_num": "3.6" |
| }, |
| { |
| "text": "For example, we can define a class \"action verb\" which has methods for instrumental cases, while its superclass ~verb ~ may not. This is useful for not only reflecting linguistic generalization but also offering a grammar designer a flexible means for designing a knowledge base.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Obligatory Case versus Non-Obligatory Case", |
| "sec_num": "3.6" |
| }, |
| { |
| "text": "As is often pointed out, there are a lot of relationships which can be determined purely by examining linguistic structure. For example, presupposition, intra-sentential reference, focus, surface speech acts, etc. This eventually means that the linguistic component itself is domain independent.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "A Few Remarks", |
| "sec_num": "4." |
| }, |
| { |
| "text": "However, other issues such as, resolving ambiguity, resolving task-dependent reference, filling task-dependent ellipsis, or inferring the speaker's intention, cannot be solved solely by the linguistic component [Sehank 80 ]. They require interaction with the memory component. Thus the domain dependent information must be stored in the memory component.", |
| "cite_spans": [ |
| { |
| "start": 211, |
| "end": 221, |
| "text": "[Sehank 80", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "A Few Remarks", |
| "sec_num": "4." |
| }, |
| { |
| "text": "To go beyond the semantics-on-top-of-syntax paradigm, we must allow rich interaction between the memory and linguistic components. In particular, the memory component must be able to predict a structure, to guide the parsing process, or to give a low rating to a partial structure which is not plausible based on the experience, while the linguistic component must be able to explain what is going on and what it tries to see. To do this, the notion of object-orientedness provides a fairly flexible method of interaction.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "A Few Remarks", |
| "sec_num": "4." |
| }, |
| { |
| "text": "Finally, we would like to mention how this framework differs from the authors' previous work on machine translation [Nishida 83], which could be viewed as an instantiation of this framework. The difference is that in the previous work, the notion of lambda binding is used for linking cases.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "A Few Remarks", |
| "sec_num": "4." |
| }, |
| { |
| "text": "We directly used inteusional logic of Montague grammar as an intermediate language. Though it brought some advantages, this scheme caused a number of technical problems.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "A Few Remarks", |
| "sec_num": "4." |
| }, |
| { |
| "text": "First, using lambda forms causes difficulty in procedural interpretation. In the case of Montague grammar this is not so, because the amount of computation doet not cause any theoretical problem in a mathematical theory. Second, though lambda expressions give an explicit form of representing some linguistic relations, other relations remain implicit.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "A Few Remarks", |
| "sec_num": "4." |
| }, |
| { |
| "text": "Some sort of additional mechanism should be introduced to cope with those implicit relations. Such a mechanism, however, may spoil the clarity or explicitness of lambda forms. This paper has proposed an alternative to address these problems.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "A Few Remarks", |
| "sec_num": "4." |
| } |
| ], |
| "back_matter": [ |
| { |
| "text": "We appreciate the useful comments made by Margot Flowers and Lawrence Birnbanm of Yale University, Department of Computer Science.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Acknowledgements", |
| "sec_num": null |
| } |
| ], |
| "bib_entries": { |
| "BIBREF1": { |
| "ref_id": "b1", |
| "title": "Cooperative Responses from a Portable Natural Language Query System", |
| "authors": [ |
| { |
| "first": "S", |
| "middle": [ |
| "J" |
| ], |
| "last": "Kaplan", |
| "suffix": "" |
| } |
| ], |
| "year": null, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Kaplan, S. J. Cooperative Responses from a Portable Natural Language Query System.", |
| "links": null |
| }, |
| "BIBREF3": { |
| "ref_id": "b3", |
| "title": "Proper Treatment of Quantification in Ordinary English", |
| "authors": [ |
| { |
| "first": "R", |
| "middle": [], |
| "last": "Montague", |
| "suffix": "" |
| } |
| ], |
| "year": null, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Montague, R. Proper Treatment of Quantification in Ordinary English.", |
| "links": null |
| }, |
| "BIBREF4": { |
| "ref_id": "b4", |
| "title": "Formal Philosophy", |
| "authors": [], |
| "year": 1974, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "247--270", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "In Thompson (editor), Formal Philosophy, pages 247-270. Yale University, 1974. Nishida, T.", |
| "links": null |
| }, |
| "BIBREF5": { |
| "ref_id": "b5", |
| "title": "Studies on the Application of Formal Semantics to English-Japanese Machine Tran elation", |
| "authors": [], |
| "year": null, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Studies on the Application of Formal Semantics to English-Japanese Machine Tran elation.", |
| "links": null |
| }, |
| "BIBREF9": { |
| "ref_id": "b9", |
| "title": "Dynamic Memory: A Theory of Reminding and Learning in Computers and Peaple", |
| "authors": [], |
| "year": null, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Dynamic Memory: A Theory of Reminding and Learning in Computers and Peaple.", |
| "links": null |
| } |
| }, |
| "ref_entries": { |
| "FIGREF0": { |
| "text": "-1: Definitions of Sample Objects", |
| "uris": null, |
| "type_str": "figure", |
| "num": null |
| }, |
| "TABREF0": { |
| "html": null, |
| "text": "if a message with label 'argument' comes, this method will send to the object pointed to bll the variable rrtessage a message whose label is 'ease' and whose value is 'subject '. ; a variable rrteasage holds the value of an incoming message and a variable self points to the oSjeet itself.", |
| "type_str": "table", |
| "content": "<table><tr><td>class *subject:</td></tr><tr><td>argument: scndImcssage , case:subject];</td></tr><tr><td>return[sc/j~.</td></tr><tr><td>class he:</td></tr><tr><td>if instantiated then dcn*-'look for referent'.</td></tr><tr><td>; when a new instance is created, the referent is looked for and the</td></tr><tr><td>value is set to the local variable den.</td></tr><tr><td>ease: ease*-messagc; return[selJ].</td></tr><tr><td>; when a message comes whleh is labeled \"ease', the local variable ease</td></tr><tr><td>will be assigned the value the incoming message contains. The</td></tr><tr><td>value of this method is the object itself.</td></tr><tr><td>argument: return[send[message, case:sol,l;</td></tr><tr><td>; when this instance is applied to another object, this object will send</td></tr><tr><td>a message whose label is the value of the local variable cone and</td></tr><tr><td>whose value field is the object itself. The value of the message</td></tr><tr><td>processing is the value of this application.</td></tr><tr><td>class runs:</td></tr><tr><td>if instantiated then den.---ereate['event:run'];</td></tr><tr><td>assert[takes_ place(den)].</td></tr><tr><td>\u2022 Iustantiating 'runs': let's call the new instance</td></tr><tr><td>runs 0. An event node (of the memory component)</td></tr><tr><td>is created and its reference (let's call this e0) is set</td></tr><tr><td>to the local variable den. Then a new proposition</td></tr><tr><td>'takes_place(e0)' is asserted to the memory</td></tr><tr><td>component.</td></tr></table>", |
| "num": null |
| } |
| } |
| } |
| } |
