Embedded sentences in languages like Japanese pose more serious problems because they do not normally carry any sign to mark their beginning. As a result, the beginning of a deeply embedded sentence can look exactly like the beginning of a simple top-level sen­tence, as illustrated in (4).

(4) a. Mary-ga sotugyoo-si-ta. 'Mary was graduated (from school).' (sotugyoo-si- 'be graduated')

b. Mary-ga sotugyoo-si-ta kookoo-ga zensyoo-si-ta. 'The high school from which Mary was graduated was burnt down.' (kookoo 'high school', zensyoo-si- 'be burnt down')

c. Mary-ga sotugyoo-si-ta kookoo-ga zensyoo-si-ta to iw-ru. 'It is reported that the high school from which Mary was graduated was burnt down.' (to = END-OF-QUOTE, iw- 'say', -ru = NON-PAST)

d. Mary-ga sotugyoo-si-ta kookoo-ga zensyoo-si-ta to iw-ru sirase-o uke-ta. '(I/we/you/he/she/they) received news (which says) that the high school from which Mary was graduated was burnt down.' (sirase 'news', uke- 'receive')

e. Mary-ga sotugyoo-si-ta kookoo-ga zensyoo-si-ta to iw-ru sirase-o uke-ta Cindy-ga nak-te i-ru. 'Cindy, who received news that the high school from which Mary was graduated was burnt down, is crying.' (nak-te i- 'be crying, be weeping') a Common Parsing Scheme for Left- and Right-Branching Languages

In order to process sentences listed in (4), the NP network of an ATN-based parser must be expanded by prefixing to it another state with two arcs leaving from it: a PUSH SENTENCE arc that processes a relative clause, and a JUMP arc that processes noun phrases that do not include a relative clause.

However, as (4) illustrates, there is no systematic way to determine which of the two arcs leaving the first state of this expanded NP network should be taken when the parser encounters the first word of the input. The parser cannot predict the correct path until it has completed processing the entire sentence or the entire relative clause and has seen what followed it. Because there is theoretically no limit to the number of levels of relative clause embedding, the number of combinations of possible arcs to be traversed is theoretically infinite.

Our first example is (9).

(9) Did John buy a good book in Boston?

When PARSE-SENTENCE calls PARSE-WORD and the latter finds did in the LEXICON, it makes a copy of the matching lexical entry, (V <+PAST>), and pushes it to the STACK. The next word that PARSE-WORD finds in the INPUT BUFFER is John. There­fore, PARSE-WORD searches the LEXICON and gets a copy of the entry that matches this word, ("John"), which is a noun.

Whenever PARSE-WORD encounters a noun, it calls ASSEMBLE-NP with a copy of the lexical entry as its argument. ASSEMBLE-NP assembles a new noun phrase (NP1 "John"), and then it calls CHECK-PHP with the newly assembled NP1 as its argument. CHECK-PHP then examines the PHP data base, and returns NIL to ASSEMBLE-NP because it finds no pattern that matches the string {<V, +PAST> NP} (i.e., the TOS followed by the CWS). Because CHECK-PHP failed to find any matching entry of the PHP, ASSEMBLE-NP pushes NP1 to STACK without con­ducting any further assembling operation, and returns control to PARSE-WORD. The contents of the STACK at this time are shown in (10).

PARSE-WORD then removes John from the INPUT BUFFER, picks up buy there, searches the LEXICON, and gets a copy of a matching entry. This is a verb. The lexical entry of every verb or verbal derivational suffix contains an SNA (the SNP address of the sentence pattern associated with it). Therefore, ASSEMBLE-SENTENCE retrieves a copy of the sentence pattern from the address matching the verb's SNA and attaches the verb's remaining lexical entry to its first empty V node (i.e., the first node whose CAR is "*" and the second member is "V"). It then removes the "*" from that node. As mentioned in section 2, the SNP entry for the class of verbs like buy and sell is (6). Therefore, by attaching (V <"buy">) to the V node of its copy, ASSEMBLE-SENTENCE constructs (11).

After (11) is assembled, ASSEMBLE-SENTENCE pops the TOS, attaches it to the first empty node matching its specifications and removes the asterisk at the beginning of that node. The result is (12).

ASSEMBLE-SENTENCE pops TOS again. This time, it is (<V, +PAST>). ASSEMBLE-SENTENCE then examines the PHP and finds two entries (13) and (14) whose conditions match the current state.

(13) If the element popped is a V and if it contains no feature other than tense, number, and/or person, attach it to the V node of the S tree which ASSEMBLE-SENTENCE is currently building.

(14) If there is a tense feature in the element that is popped immediately after the AGNT node (or the OBJ node if the tree has no AGNT node) is filled, attach feature <Q> (i.e., "question") to the main verb of the matrix S.

ASSEMBLE-SENTENCE executes (13) and (14). The result is (15).

Pault.

This section illustrates how POP handles the problems of Japanese sentences discussed in section 1.

The ATN strategy for parsing w/i-questions and relative clauses in English attracted special attention of many linguists, including Bresnan (1978) and Fodor (1979), because it seemed to support the trace theory and the theory of wA-movement transformation. Therefore, we will conclude the illustration of POP by explaining how it handles them.

As illustrated in (2), the same postnominal suffixes mark different relations in Japanese, depending on the verbal derivational suffixes used in the verb complex. Tradi­tional generative grammarians (like Kuno (1973)) tried to explain this by means of a series of transformational rules such as agentive ni attachment, equi-NP deletion, Aux deletion, verb raising, subject marking, object marking, and galni conversion, which were applied cyclically. This transformational approach is still widely practiced by researchers of Japanese linguistics. How­ever, as demonstrated by Sato (1983b), this is unsuitable for application to parsing because many of the transfor­mational rules involved here are non-reversible.

A relatively recent approach to this problem is to use a set of rules like (61) which Kuroda (1976) calls Canonical Surface Structure Filters and Miyagawa (1980) calls Case Redundancy Rules.

These rules are invoked after applying all transforma­tional rules (Kuroda 1976) or all word formation rules (Miyagawa 1980), and they attach suffixes to noun phrases as specified in their output, without regard to the functions of the phrases to which they are attached. The selection of case suffixes and the order of their appearance in the surface structure are determined solely by the number of unmarked noun phrases in the sentence. This approach would work well if Japanese speakers always followed the "canonical word order". However, the so-called canonical word order is not always followed.

Contrary to the theories of Kuroda and Miyagawa which treat Japanese case suffixes as if they were useless appendages which have no syntactic role, POP uses them as integral parts of the input data and, as a result, it does not have to require the input sentences to conform to the "canonical word order". As illustrated in subsection 3.2.2, POP first constructs an expanded sentence tree frame using the SNP patterns that match the SNA's of the derivational suffixes. After this ex­panded frame is completed, arguments are popped from the STACK and attached to appropriate nodes in the usual manner. Note that the flag specifications on the tree frame are automatically adjusted in course of its expansion, so no further adjustment resorting to the "canonical word order" or scrambling is necessary.

Pault.

As illustrated in subsection 3.2.3, POP handles Japa­nese complex sentences with relative clauses without facing combinatorial explosion. Especially noteworthy is the similarity in the PHP instructions to assemble noun phrases with relative clause in Japanese (37) and in English (58), which are paraphrased in (62).

(62) PHP entries for assembling NP with a relative clause

1. Pop the TOS (which is a sentence with an empty NP node).

2. Attach a copy of the CWS (which is an NP) to the first matching empty node of the popped sentence tree.

3. Assemble a new NP tree with the CWS as its HEAD and the sentence tree assembled in step 2 as its MOD(ifier).

1. Pop the TOS (which is a sentence with a marked NP).

2. Assemble a new NP tree with the marked NP of the sentence popped in step 1 as its HEAD and the CWS (which is a sentence tree containing an NP node co-indexed with the marked NP according to (52)) as its MOD.

The only major difference between the two is that in Japanese (62a) the relative clause is in the STACK when the head NP is encountered, while in English (62b) the head NP is a branch of an S tree in the STACK when the relative pronoun is encountered. This difference is a natural consequence of the difference in word order between the two languages (i.e., left-branching vs. right-branching).

An important fact is that POP for Japanese does not have to know in advance whether the sentence fragment that it is processing is a matrix sentence like (4a) or an embedded sentence like (4b) through (4e).

The reader may have wondered if there is any direct relationship between POP and Marcus's PARSIFAL Marcus (1980): both are bottom-up parsers, where at­tachment can be made freely to any matching node in the ACTIVE NODE STACK (Marcus) or the CWS (POP). Therefore, a brief comparison of these two systems may be in order.

When I heard about Marcus's work for the first time, the development of POP was already well under way: its basic algorithm was already completed and coding had already started. Therefore, the similarity between PAR­SIFAL and POP, if any, is only accidental. Moreover, the basic philosophies of these two systems are differ­ent. Marcus's goal was to build a "strictly determinis­tic" parser for natural language; mine was to build a parser that can handle not only right-branching sen­tences but also left-branching sentences naturally and without facing a combinatorial explosion. POP does not have any back-tracking or parallel parsing mechanism, but the lack of such mechanism was a consequence of the parser's algorithm and not an intended goal.

In fact, the only significant similarity between PAR­SIFAL and POP is between the former's pattern/action rules and the latter's PHP entries. The latter can be rewritten using the format of the former. However, the similarity ends here. PARSIFAL's rules are partially ordered by a priority scheme; POP's PHP entries are not ordered nor do they have priority over any other entries in the PHP. In PARSIFAL, a grammar rule activates a packet by attaching it to the constituent at the bottom of the ACTIVE NODE STACK, and the packet of rules remains attached to the node even after the node is pushed up. Such rules remain dormant until the node to which they are attached comes at the bottom of the ACTIVE NODE STACK again. On the other hand, POP's PHP pattern does not remain with any node after a phrase tree (or an S tree) is assembled and pushed to the STACK. A copy of PHP pattern is retrieved from the data base each time it becomes necessary. This strategy saves the memory space in the STACK, although it requires a longer processing time.

POP lacks one of PARSIFAL's most significant characteristics: the distinction between the ACTIVE NODE STACK and the BUFFER. POP also distin­guishes the place where trees are actually constructed (which I informally call here the "work space") and the place where the results are stored (i.e., the STACK). However, the similarity again ends here. POP's "work space" is neither a stack nor a buffer, but a machine-dependent temporary memory space where the program (ASSEMBLE-NP, ASSEMBLE-SENTENCE, etc.) re­trieves and manipulates partial trees popped from the STACK or lexical entries copied from the LEXICON. Unlike PARSIFAL's ACTIVE NODE STACK, POP's "work space" cannot store any partially completed tree which is not "active". Such inactive partial trees are stored in the STACK.

PARSIFAL's BUFFER is primarily a facility for "look-ahead". Therefore, it contains unprocessed input words as well as phrase trees with no empty node. It contains no phrase tree which has empty nodes, be­cause such trees are stored in the ACTIVE NODE STACK. In contrast, the primary purpose of POP's STACK is to store tree fragments and tree frames. It is not a "look-ahead" facility and therefore does not contain any unprocessed input word. When POP's PROCESSOR looks at an input word, it must process it immediately.

POP can process sentences like (4) without back­tracking or any look-ahead mechanism, while such sentences would remain "garden path sentences" for Marcus's parser even with its limited look-ahead mech­anism.