File Information
File: 05-lr/acl_arc_1_sum/cleansed_text/xml_by_section/metho/85/e85-1007_metho.xml
Size: 32,186 bytes
Last Modified: 2025-10-06 14:11:41
<?xml version="1.0" standalone="yes"?> <Paper uid="E85-1007"> <Title>SAUMER: SENTENCE ANALYSIS USING METARULES</Title> <Section position="4" start_page="0" end_page="48" type="metho"> <SectionTitle> 2. THE SEMANTIC LOGICAL NOTATION </SectionTitle> <Paragraph position="0"> The logical notation associated with the gr~mm~r differs from. the usual notation of intensional logic_since it captures some intmtive aspects of natural language, l Thus. individuals and objects are treated as entities.</Paragraph> <Paragraph position="1"> instead of collections of prope'rties, and actions are n-ary relations between these entities. Many of the problems that the intensional notation would solve are handled by allowing ambiguity to be represented in the logical notation. Consequently. as is common in other approaches.</Paragraph> <Paragraph position="2"> (e.g.. Gawron. 1982). much of the processing is deferred to the pragmatic stage. The structure of the lexicon, and the appearance of post processing markers (sharp angle brackets) are designed to reflect this ambiguity. The lexicon is organised into two levels. For the semantic interpretation, the first level gives each word a tentative interpretation. During the pragmatic analysis, more complete processing information will result in the final interpretation being obtained from the second level of the lexicon. For e~mple, the sentence John misses John could be given an initial interpretation of: (2.1) \[ Johnl misa2 John3 \] with Johnl, miss2 and John3 obtained from the first level of the two level lexicon. The pragmatic stage will determine if Johal and John3 both refer to the same entry, say JOHN SMITH1. of the second level of the lexicon, or if they correspond to different entries, say JOHN_JONES1 and JOHN_EVANS1. During the pragmatic stage, the entry of MISS which is referred to by miss2 will be determined (if possible). For example, does John miss John because he has been away for a long time, or is it because he is a poor shot with a rifle? Any interpretation contained in sharp angle brackets.</Paragraph> <Paragraph position="3"> <...>. may require post processing. This is apparent in interpretations containing determiners and co-ordinators.</Paragraph> <Paragraph position="4"> The proverb: (2.2) every man loves some woman could be given the interpretation: (2.3) \[<everyl man2> love3 <some4 womanS>\] without explicitly stating whmh of the two readings is intended. During pragmatic analysis, the scope of every and some would presumably be determined.</Paragraph> <Paragraph position="5"> 111 should also be noted that. due Io the separabili'~y of the semantic component from &quot;,he grammar rule, * different semantic notation could easily be introduced at long as ~u~ app~priate ~.mantic proce~in8 rou~dne$ were replaced. The use of SAUMER with &quot;an &quot;Al-adap'md&quot; version of Mon~ue's Intensional Logic&quot; is being examined by Fawc(c)It (1984), The syntax of this logical notation can be b-~mmav~sed as follows. Sentences and compound predicate formulas are contained within square brackets. So. (2.4) states that These formulas can also be expressed equivalently in a more functional form according to the equivalence (2.5) \[ t n P t I . . . tad \] --- ( * . . ((P t l) t 2) . . . t n ) -- ( P t t . t. ) Consequently. (2.4) could also be represented as: (2.6) ((want2 ((kiss3 Mary4) Johnl)} Johnl) However. this notation is usually used for incomplete phrases, with the square brackets used to obtain a cortvent/ona/ final reading Modified predicate formulas are contained in braces. Thus. a little dog likes Fido could be expressed as: (2.7) \[<al {little2 dog3}> likes4 FidoS\] The lambda calculus operations of lambda abstraction and elimination are also allowed. When a variable is abstracted from an expression as in: (2.8) kx \[ * want2 \[ * love3 Mary4 \] \] application of this new expression to an argument, say dohnl: (2.9) ( kx \[ * want2 \[ * love3 l~u~J'4 \] \] Johnl ) will result in an int~,v,(c)tation of John wants to love Mary: (2.10) \[ Johnl want2 \[ Johnl love3 Mary4 \] \] Further details on this notation are available in (Schubert and Pelletier. 1982).</Paragraph> </Section> <Section position="5" start_page="48" end_page="50" type="metho"> <SectionTitle> 3. THE SAUMER SPECIFICATION LANGUAGE </SectionTitle> <Paragraph position="0"> The SAUMER Specification Language (SSL) is a programming language that allows the user to define a grammar of a natural language &quot;in ~ of rules, and metarules. Metarules operate on rules to produce new rules. The language is basically a GPSG realised in a DCG setting. Unlike GPSGs. the grammars defined by this system are not required to be context-free since procedure calls are allowed within the rules, and since logic variables are allowed in the grammar symbols.</Paragraph> <Paragraph position="1"> The basic objects of the language are atoms, variables.</Paragraph> <Paragraph position="2"> terms, and lists. Any word starting with a lower case letter, or enclosed in single quotes is an atom. Variables start with a capital letter or an underscore. A term is an atom. optionally followed by a series of objects (arguments), which are enclosed in parentheses and separated by commas. Lastly. a list is a series of one or more objects, separated by commas, that are enclosed in square brackets</Paragraph> <Section position="1" start_page="48" end_page="49" type="sub_section"> <SectionTitle> 3.1 Rules </SectionTitle> <Paragraph position="0"> The rules are presented in a variation of the DCG notation, augmented with a semantic rule corresponding to each syntactic rule. Each rule is of the form &quot;A --> B : ~,&quot; where A is a term which denotes a nonterminal symbol. B is either an atom list representing a terminal symbol or a conjunction of terms (separated by commas) corresponding to nonterminal symbols, and y is a semantic rule which may reference the interpretation of the components of ~ in determining the semantics of A.</Paragraph> <Paragraph position="1"> The rule arrow. -->. separates the two sides of the rule.</Paragraph> <Paragraph position="2"> with the colon. :. separating the syntactic component from the semantic component. If the rule is preceded by the word add, it can be subjected to the transformations described in section 3.2. The nonterminal symbols can possess arguments, which may be used to capture the flavour of the struaurad categor/~s of GPSGs. ~ may also possess arbitrary procedural restrictions contained in braces. T consists of expressions in the semantic notation.</Paragraph> <Paragraph position="3"> The different terms of this semantic expression are joined by the semantic connector, the ampersand &quot;&'. The ampersand differ, from the syntactic connector, the comma, sinc~ the former associates to the right while the latter associates to the left. The /og/col and symbol.</Paragraph> <Paragraph position="4"> which traditionally may also be denoted by the ampersand, must be entered as &quot;&&'. Due to constraints imposed by the current implementation, &quot;( exFr )&quot; must be entered as &quot;<\[ expr \]'. &quot;< expr >&quot; as &quot;< <\[ expr \]'. and &quot;k x expr&quot; as &quot;x lmda expr.&quot; An expression may contain references to the interpretations of the elements of 18 by stating the appropriate nonterminal followed by the left quote, &quot;. To prevent ambiguity in &quot;these references that may arise when two identical symbols appear in B. a nonterminal may be appended with a minus sign followed by a unique integer.</Paragraph> <Paragraph position="5"> Unlike standard Prolog implementations of DCGs. left recursion is allowed in rules, thus permitting more natural descriptions of certain phenomena (like co-ordination).</Paragraph> <Paragraph position="6"> Since the left recursive rules are interpreted, rather than converted into rules that are not left recursive, the number of rules in the database will not be affected.</Paragraph> <Paragraph position="7"> However. the efficiency of the sentence analysis may be affected due to the extra processing required. Rules of the form &quot;A --> A. A&quot; are not accepted.</Paragraph> <Paragraph position="8"> An example of a production that derives John from a proper noun. npr. is shown in (3.1): (3.1) npr --> \['John'\] : &quot;John'# The semantic interpretation of this npr will be John#.</Paragraph> <Paragraph position="9"> with &quot;#&quot; replaced by a unique integer during evaluation. (3.2) illustrates a verb phrase rule that could be used in sentences like John wants to wa/k:</Paragraph> <Paragraph position="11"> First nottce that a restriction on the verb appears within the w/th statement. In the GPSG formalism, this type of restriction would be obtained by naming the rules and associating a list of valid rule names with each lexical entry. Although the w/~h restriction may contain any valid in-ocedure, typically the in operation (for determining list membership) is used. The double pound. ##. is replaced by the same unique integer in the entire expression when the expression is evaluated. If &quot;#&quot; were used instead, each instance of x# would be different. For the above example, if v' is want2 and vp' is runJ. then the semantic expression could evaluate to: (3.3) x4 lmda \[x4 & want2 & \[x4 & run3\]\] Furthermore. if np&quot; is Johrtl. then: (3.4) \[np&quot; & vp'\] could result in: (3.5) \[Johnl & want2 & \[Johnl & run3\]\]</Paragraph> </Section> <Section position="2" start_page="49" end_page="50" type="sub_section"> <SectionTitle> 3.2 The Metarules </SectionTitle> <Paragraph position="0"> Traditional transformational grammars provide transformations that operate on parse trees, or similar structures, and often require the transformations to be used in sentence recognition rather than in generation (Radford. 1981). However. the approach suggested by (GaT~2r. 1981) uses the transformations generatively and applies them to the grammar. Thus. the grammar can remain contex:-free by compiling this transformational knowledge into the grammar. Transformations and rule schemata form the maazu/~s of SSI- 2 Rule schemata allow the user to specify entire classes of rules by permitting variables which range over a selection of categories to appear in the rule. To control the values of the variables, the fora// control structure can be used in the schema declaration. The schema fora// X ~n List, Body will execute Body for each element of Li~. with X instantiated to the current element. The use of this statement is illustrated in the following metarule that generates the terminal productions for proper nouns.&quot; (3.6) forall Terminal in \['Bob'.'Carol'.'red'.'Alice'\], (npr --> \[Terminal\] : Terminal#) .</Paragraph> <Paragraph position="1"> Transformations match with grammar rules in the database, using a rule pattern that may be augmented with arbitrary procedures, and produce new rules from the old rules. A transformation is of the form: (3.7) a --> /i : y ---> a' --> B&quot; : 7&quot; The metarule arrow. -- >, separates the pattern, a --> ~ : T. from the template, a&quot; --> /i&quot; : T'2Oflen. metarule~ are considered 1o consisl of transformations only, while schemata are pul inlo a category of their own. However. sinoe they can both be considered i~ part of * metagramma~, they are called me~trule~ in thl, distna~inn.</Paragraph> <Paragraph position="2"> The ~n~a~ pattern, Q --> /i. contains nonterminals.</Paragraph> <Paragraph position="3"> which correspond to symbols that must appear in the matched rule, and free variables, which represent don't ~r~regions of zero or more nonterminals. The pattern nontermmals may also possess arguments. For each rule symbol, a matching pattern symbol describes properties that must exist, but not all the properties that may exist. Thus. if vp appeared in the pattern, it would match any of vp. vp(Num), or vp(Nura2&quot;ype) with Type in /transl. However. pp(to) would not match pp or pp(frora), but it would match plMto,_). The matching conditions are summarised in Figures 3-1 and 3-2. In Figure 3-1. A and B are nonterminals. X is a free variable, and a and /i are conjunctions of one or more symbols, y and 8 of Figure 3-2 are also conjunctions of one or more symbols. &quot;=&quot; is defined as unification (Clocksin and Mellish, 1981). Parts of the rule contained in braces are ignored by the pattern matcher. The syntactic pattern may also contain arbitrary restrictions. 3 enclosed in braces, that are evaluated during the pattern match. The semant/c pattern, y, is very primitive, h may contain a free variable, which will bind to the entire semantics field of the matched rule, or it may contain the structure <\[? ~\]. which will bind to the entire structure containing the symbol x. If <\[? y\] then appears in y', the result will be the semantic component of the matched rule with x replaced by y.</Paragraph> <Paragraph position="4"> and a matches ~ a is a free variable (X. a) matches /i a matches B or a matches (B. ~) No A matches B yes Yes Figure 3-1: Pattern Matching for Conjunctions Pattern Rule b(/i\[ .... /I n) b(,/i I .... /in ) with 8 a(a I .... a m ) a(a I .... a=) with a=b. m~<n.</Paragraph> <Paragraph position="5"> ati=/i i, 1~<i~<m No a--b. m~n.</Paragraph> <Paragraph position="6"> ai=/i i, l~i~m a=b. m~n.</Paragraph> <Paragraph position="7"> ai=/i i. l~<i~<m. &quot; matches 8 The behaviour of patterns can be seen in the following examples. Consider the sentence rule:</Paragraph> <Paragraph position="9"> The patterns shown in (3.9a) will match (3.8). while those of (3.9b) will not match it.</Paragraph> <Paragraph position="10"> (3.9) (a) s(A) --> {not element(A,\[foo\])L X. vp : Sere s --> np(nom), X. vp(pass). Y : Sere (b) s(inter) --> np. vp : Seam s --> vp : Sere For the verb phrase rule shown in (3.10): (3.10) vp(active.\[MIN\]) --> v(\[MIN\],Root,Type,_) with (intrans in Type) : v&quot; the patterns of (3.11a) will result in a successful match. will those of (3.11b) will not: With external modification, any nonterminal, or variable instantiated to a nonterminal, may be followed by the sequence @rood. This will result in rood being inserted into the argument list following the specified arguments. Thus, mf N@junk appeared in a rule when N was instantiated to np(more), it would be expanded as rip(more,junk }. Similarly, if the pattern symbol vp matched v,v{NumS) in a rule, then the appearance of vp@foo in the template would result in vp(foo~Vumb) appearing in the new rule. This extra argument. introduced by the modifier, can be useful when dealing with the missing components of slash or derived categories (Gazdar, 1981).</Paragraph> <Paragraph position="11"> Internal modification allows the modifier to be put directly into the argument list. If an argument is followed by @rood. it will be replaced by rood. In the case where @rood appears as an argument by itself, rood is added as a new argument. For example, if v(Numb@pastpart) were contained in a template, it would IT-match v(Numb) in the pattern, and would result in the appearance of v(pastpart) in the new rule.</Paragraph> <Paragraph position="12"> (3.11) (a) vp-> v : <\[?v\] vp --> v( .... Type._) with (X, intrans in Type. Y).</Paragraph> <Paragraph position="13"> Z:Sem (b) vp --> v(..._.Type._) with (X. trans in Type) For every rule that matches the pattern, the template of the transformation is executed, resulting the creation of a new rule. Any nonterminal. N, that matches a symbol 8 i on the left side of the transformation, will appear in the new rule if there is a symbol ~i&quot; in 8&quot; that irura-transformation (IT) matches with ~i&quot; If there are several symbols in 8&quot; that IT-match ~i&quot; the leftmost symbol will be selected. No symbol on one side of the transformation may IT-match with more than one symbol on the other side. Two symbols will IT-match only if they have the same number of arguments, and those arguments are identical. Any w/th expressions and modifiers associated with symbols are ignored during ITmatching. 8&quot; may also contain extra symbols that do not correspond to anything in 8. In this case. they are inserted directly into the new rule. Once again, if the transformation is preceded by the command add. then the resulting rul~ can be subjected to subsequent transformations.</Paragraph> </Section> <Section position="3" start_page="50" end_page="50" type="sub_section"> <SectionTitle> 3.3 Modifiers </SectionTitle> <Paragraph position="0"> Both rules and metarules may contains modifiers that alter the ~tructure of the nonterminal symbols. There are two types of modification, which have been dubbed external and /nzerrud modification.</Paragraph> </Section> </Section> <Section position="6" start_page="50" end_page="52" type="metho"> <SectionTitle> 4. IMPLEMENTATION </SectionTitle> <Paragraph position="0"> The SAUMER system is currently implemented in highly portable C-Prolog (Pereira. 1984). and runs on a Motorola 68000 based SUN Workstation supporting UNIX 4.</Paragraph> <Paragraph position="1"> Calls to Prolog are allowed by the system, thus providing useful tools for debugging grsmmars, and tracing derivations. However. due to the highly declarative nature of SSL, it is not restricted to a Prolog ....... implementation. Implementations in other languages would differ externally only in the syntax of the procedure calls that may appear in each rule. Use of the system is described in detail in (Popowich, 1985).</Paragraph> <Paragraph position="2"> The current implementation converts the grammar as specified by the rules and metarules into Prolog clauses.</Paragraph> <Paragraph position="3"> This conversion can be examined in terms of how rules are processecl, and how the schemata and transformations are processed.</Paragraph> <Section position="1" start_page="50" end_page="51" type="sub_section"> <SectionTitle> 4.1 Rule Processing </SectionTitle> <Paragraph position="0"> The syntactic component of the rule processor is based on Clocksin and Mellish's definite clause grammar processor (Clocksin and Mellish. 1981) which has been implemented in C-Prolog. For a DCG rule. each nonterminal is converted into a Prolog predicate, with two additional arguments, that can be processed by a top-down parser. These ~tn arguments correspond to the list to be parsed, and the remainder of the list after the predicate has parsed the desired category. With the addition of semantics to each rule, another argument is required to represent the semantic interpretation of the current symbol. Thus. whenever a left quoted category name. x'.</Paragraph> <Paragraph position="1"> appears in the semantics of the rule. it'is'repla~gl by a variable bound to the semantic argument of the corresponding symbol, x. in the rule. The semantic expression is then evaluated by the eva/ routine with the result bound to the semantic argument of the nonterminal on the left hand side of the production. For ~ffiample. the sentence /ule:</Paragraph> <Paragraph position="3"> nlKSemNP.nom2qumb. 1.2).</Paragraph> <Paragraph position="4"> vp(SemVP, 2qumb. 2. 3).</Paragraph> <Paragraph position="5"> agreement(Numb).</Paragraph> <Paragraph position="6"> eval(\[SemNP & SemVP\],SemS). Consequently. to process the sentence John runs. one would try to satisfy: (4.3) :- s(Sem, Type. \['John'.runs\]. \[\]). The first argument returns the interpretation, the second argument returns the type of sentence, the third is the initial input list. and the final argument corresponds to the list rPmaining after finding a sentence. Any rule R, that is preceded by add will have the axiom r'ul~(R) inserted into the database. These axioms are used by the transformations during pattern matching.</Paragraph> <Paragraph position="7"> The eva/ routine processes the suffix symbols, # and ## along wlth the lambda .expressions, and may perform some- reorganisation of the given expression-- before returning a new semantic form. For each expression of the form name#, a unique integer N is ca-eared and nan~-N is returned. With &quot;##'. the procedure is the same except that the first occurrence of &quot;##&quot; will generate a unique integer that will be saved for all subsequent occurrences. To evaluate an expression of the form: (4.4) ( expr i Lmda e~Fj & X ) every subexpression of exprj is recursively searched for an occurrence of expr i. which is then replaced by X.</Paragraph> <Paragraph position="8"> Left recursion is removed with the aid of a gap predicate identical to the one defined to process gapping gr-ammarS (Dahl and Abramson. 1984) and unre~Lricte~ gapping grammars (Popowich. forthcoming). For any rule of the form: (4.5) A --> A. B. a where A does not equal B. the result of the translation is: (4.6) Af_I.N n) :- gap(G._l. 2). B(2.No). A(G,\[\]).</Paragraph> <Paragraph position="10"> According to (4.6). a phrase is processed by skipping over a region to find a B -- the first non-terminal that does not equal A. The skipped region is then examined to ensure that it corresponds to an A before the rest of the phrase is processed.</Paragraph> </Section> <Section position="2" start_page="51" end_page="51" type="sub_section"> <SectionTitle> 4.2 Schema Processing </SectionTitle> <Paragraph position="0"> To process the metarule control structures used by schemata, a fml predicate is inserted to force Prolog to try all possible alternatives. The simple recursive definition of /ore// X/~ /./rt:</Paragraph> <Paragraph position="2"> forall(X. Rest. Body).</Paragraph> <Paragraph position="3"> uses fa// to undo the binding of Y, the first element of the list. to X before calling fore// with the remainder of the list. The predicate C/.<d/l is used to evaluate Body since it will prevent the fa// predicate from causing backtracking into Body.</Paragraph> </Section> <Section position="3" start_page="51" end_page="52" type="sub_section"> <SectionTitle> 4.3 Transformation Processing </SectionTitle> <Paragraph position="0"> Execution of transformations requires the most complex processing of all of the metagrammatical operations. This processing can be divided into the three stages of transformation crY. pattern matching, and rule crem,/on. 5 During the rrar~fornuU/~n trot/on phase, the predicate rrarts(M,X,Y) is created for the metarule. M. This predicate will transform a list of elements. X: into another ILSL Y, according to the syntax specification of the metarule. Elements that IT-match will be represented by the same free variable in both lists. This binding will be one to one. since an element cannot match with more than one element on the other side. Symbols that appear on only one side will not have their free variable appearing on the opposite side. Expressions in braces are ignored during this stage. If a transformation like: (4.8) a --> b, c. X --> a@foo --> b. X. c(foo) appears, then a predicate of the form: (4.9) tr~s(M. L1._2._3.X\]. L1._2.X._4\]) will be created. Notice that the appearance of a modifier does not cause a@/oo to be distinguished from a. since all modifiers are removed before the pattern-template match is attempted. However. c and c(foo) are considered to be different symbols. M is a unique integer associated with the transformation.</Paragraph> <Paragraph position="1"> The pattern match phase determines if a rule matches the pattern, and produces a list for each successful match which will be transformed by the trans predicate. Each element of the list is either one of the matched symbols from the rule. or a list of symbols corresponding to the don't care region of the pattern. Any predicates that 5(Popowich, forthcoming) examines a method of transformalion ~ing that uses the transformations during ~3~e par~e, instead of Using them m L~me~te new ~.fle~.</Paragraph> <Paragraph position="2"> appear in braces in the pattern are evaluated during the pattern match. Consider the operation of an active-passive Notice that there was nothing in the rule to bind with X. Y or Z. Consequently. these variables were assigned the null list. \[\]. The pattern match of the semantics of the rule will result in an expression which lambda abswacts np&quot; out the of semantics: (4.13) <\[ np&quot; lmda <\[ v&quot; & np&quot; \] \] Finally. the ru/~ creaC//on phase applies the transformation to the list produced by the pattern match. and then uses the new list and the template to obtain a new rule. This phase includes conversion of the new list back into rule form. the application of modifiers, and the addition of any extra symbols that appear on the right hand side only. To continue with our *Tample. the trans predicate a.~ociated with (4.10) would be: (4.14) trans(N. \[_1._2._3.Z\]. \[_.3.4._21..5\]) Notice that the two vp's on opposite sides of the metarule do not match. So the transformed list would resemble: (4.15) \[ _3.</Paragraph> <Paragraph position="3"> 4, v(Numb.R.Type._) with \[\[\].trans in Type,\[\]\].</Paragraph> <Paragraph position="4"> \[3. _51 The rule generated by the rule creation phase would be: (4.16) vp(pass~lumb) --> v(Numb.be.T~)-I with aux in T.</Paragraph> <Paragraph position="5"> v(pastpart.R,Type._) with tnns in Type.</Paragraph> <Paragraph position="6"> pp(by._) : x## lmda \[ pp(by)&quot; & <\[ v&quot; & x## \] \] * Notice that the expression &quot;<\[ v&quot; & x## \]'. which is * contained in the semantics of (4.16) was obtained by the application of (4.13) to x##.</Paragraph> </Section> </Section> <Section position="7" start_page="52" end_page="54" type="metho"> <SectionTitle> 5. APPLICATIONS </SectionTitle> <Paragraph position="0"> To examine the usefulness of this type of grammar specification, as well as the adequacy of the implementation, a grammar was developed that uses the domain of the Automated Academic Advisor (AAA) (Cercone et.al.. 1984). The AAA is an interactive information system under development at Simon Fraser University. It is intended to act as an aid in &quot;curriculum planning and management', that accepts natural language queries and generates the appropriate responses. Routines for performing some morphological analysis, and for retrieving lexical information were also provided.</Paragraph> <Paragraph position="1"> The SSL grammar allows questions to be posed.</Paragraph> <Paragraph position="2"> permits some possessive forms, and allows auxiliaries to appear in the sentences. From the base of twenty six rules, eighty additional rules were produced by three metarules in about eighty-five seconds. Ten more rules were needed to link the lexicon and the grammar. A selection of the rules and metarules appears in Figure 5-1. The complete grammar and lexicon is provided in (Popowich. 1985).</Paragraph> <Paragraph position="3"> In the interpretations of some ~mple sentences, which can be found in Figure 5-2, some liberties are taken with the semantic notation. Variables of the form wN. where N is any integer, represent entities that are to be instantiated from some database. Thus. any interpretation containing wN will be a question. Possessives. like John's tab/e are represented as: (5.1) <table & \[John poss table\]> Although multiple possessives which associate from left to right are allowed, group possessives as seen in: (5.2) the man who passed the course's book and in phrases like: (5.3) John's driver's lice.ace can not be interpreted correctly by the grammar.</Paragraph> <Paragraph position="4"> Inverted sentences are preceded by the word Query in the output. Also. proper nouns are assumed to unambiguously refer to some object, and thus are no longer followed by a unique integer. Analysis times for obtaining an interpretation are give 9 in CPU seconds. The total time includes the time spent looking for all other possible parses.</Paragraph> <Paragraph position="5"> Results obtained with SAUMER compare favourably to those obtained from the ProGram system (Evans and Gazdar. 1984). ProGram operates on grammars defined according to the current GPSG formalism (Ga2dar and Pullum. 1982). but was not developed with efficiency as a major consideration. The grammar used with ProGram.</Paragraph> <Paragraph position="6"> which is given in (Popowich. 1985). is similar to the AAA grammar used by SAUMER. except that it has a much smaller lexicon, and allows neither relative clauses nor possessive forms. Running on the same machine as SAUMER. ProGram required about 35 seconds to parse the sentence does John take cmpelOl, with a total processing time of abo,.u 140 second.~ SAUMER required just over 2 seconds to parse this phrase, and had a total processing time of about 4 seconds.</Paragraph> <Paragraph position="7"> As it stands, the semantic notation used by SAUMER does &quot;not contain much of the relevant information that &quot;would be required by a real system. Tense. number and adverbial information, including concepts like location and time. would be required in the AAA. If the SSL description were to be extended, with the resulting system behaving as a natural language interface of the AAA. a more database directed semantic notation would prove invaluable.</Paragraph> </Section> <Section position="8" start_page="54" end_page="54" type="metho"> <SectionTitle> 6. PRESENT IXMITATIONS </SectionTitle> <Paragraph position="0"> Although this application of metarules allows succinct descriptions of a grammar, several problems have been observed.</Paragraph> <Paragraph position="1"> Since each metarule is applied to the rule base only once. the order of the metarules is very important. In our sample grammar, the passive verb phrases were generated before the sentence inversion transformation was processed, and then the slash category propagation transformations were executed. For the curreat implementation, if a rule generated by transformation T1 is to be subjected to transformation T2. then T1 must appear before T2. Moreover. no rule that is the result of .... T2-can be operated on by TI. It would be preferable to remove this restriction and impose one. that is less severe. such as the finite closure restriction which is described in (Thompson. 1982) and used by ProGram. With this improvement, the only restriction would be that a transformation could only be applied once in the derivation of a rule.</Paragraph> <Paragraph position="2"> The system can not currently process rules expressed in the Immediate Dominance/ Linear Precedence (ID/LP) format. (Gazdar and Pullum. 1982). With this format, a production rule is expressed with an unordered right hand side with the ordering determined by a separate declaration of //near precedence. For example, a passive verb phrase rule could appear something like&quot; (6.1) vp(pass.\[MIN\]) -- > v(\[MIN\], be .... ).</Paragraph> <Paragraph position="3"> v(_. Root. Type. _) with (Root in \[pass.carry.give\].</Paragraph> <Paragraph position="4"> indobj in Type.</Paragraph> <Paragraph position="5"> trans in Type).</Paragraph> <Paragraph position="6"> pp(to).</Paragraph> <Paragraph position="7"> optional(pp(by)) : x## Imda \[optional&quot; & <\[v&quot; & pp(to)&quot; & x##\]\] with the components having a linear precedence of: (6.2) v(_.be) < v < pp The result would be that the pp(by) could appear before or after the pp(to), since there is no restriction on 'their relative positions. If this format were implemented, only one passive metarule would have to be explicitly stated. The direct processing of ID/LP gremm~rs is discussed in (Shieber. 1982). (Evans and Gazdar. 1984). and (Popowich. forthcoming).</Paragraph> </Section> class="xml-element"></Paper>