Let Ci denot e; the hierarchy of languages gener­ated by the corresponding hierarchy of grammars (according to the usual hierarchy (Hopcroft and Ullman, 1979)). Tims, £0 denotes the class of lan­guages generated by type 0 grammars. They are characterized by unrestricted grammar production rules. £1 is the class of languages generated by context sensitive grammars—the sole restric­tion on production rules in this type of grammar is that the right hand side (RHS) of each rule is at least as long as the left hand side (LHS). £1.5 de­notes the class of languages generated by indexed grammars. Gazdar (1985) provides the most per­spicuous notation for the restricted forms that production rules may take in such grammars:

Indexed grammars incorporate a notion of stack­ing; rules of the form in (2) describe push opera­tions, and those of the form in (3) involve pops. Rules of the form (1) are copy operations. The elipses indicate that the remainder of the stack is passed on from the LHS to each nonterminal (and only the nonterminals) on the RHS. C2 is the class of context free languages generated by gram­mars whose productions are restricted such that the LHS of each is a single nonterminal symbol, and each RHS is a sequence of terminals and non­terminals. Finally, the regular languages, £3 are those produced by regular grammars, character­ized by rules that have a single nonterminal sym­bol on the LHS and on the RHS, either a terminal symbol or a terminal and a single nonterminal.

These classes of languages can be arranged into a hierarchy based on proper containment rela­tions among them: £3 c £2 c £1.5 C £1 C £0 (£0 is the least restrictive, the most expres­sive). Aho (1968) shows the existence of lan­guages that are a proper subset of the indexed languages and a proper superset of the context free. Joshi et al. (1989) conjecture that there is actually a convergence in expressive power among the 'mildly context sensitive' (MCS) lan­guages, but other work points out exceptions (Sav-itch, 1989; Vogel and Erjavec, 1994). Since the reduplication languages (Savitch, 1989) are cen­tral to the point of this paper we define them— the languages homomorphic to the set of strings {ww\w £ {a, b}*}. The string duplication lan­guages are not context free, although they are closely related to the string reversal languages ({wwR\w e {a, b}*}, where the R indicates the re­versal operator) which are context free. The two languages induce different dependency relation­ships which is best described as nesting in the con­text free case and cross-serial in the indexed case:

An important property of the each of the lan­guage classes is that it is closed under both in­tersection with regular languages (e.g., the inter­section of a context free language and a regular language is no more expressive than a context free language) and homomorphism (e.g., an or­der preserving map of each symbol in a language to a single element (possibly a string) of a context free language implies that the first language is also context free). It is convenient to refer to languages with homomorphisms to {wwR\w £ {a, b}*} and {ww\w 6 {a, b}*} as wwR and ww, respectively.

Corresponding to expressivity class and the as­sociated model of computation is the complex­ity of recognition for each class. Table 1 gives an informal ranking of the language classes with their corresponding worst case recognition com­plexity on the standard model of computation. Thus, given a context free grammar for wwR and a string of length n, then in the worst case it will take an amount of time proportional to the cube of the length of the string to determine whether the string is in wwR (and identify its structure). While the expressivity hierarchy is useful for dif­ferentiating classes of languages in precise terms like worst-case recognition complexity, it is easy to use the hierarchy incorrectly. For instance, it is not valid to conclude that because a lan­guage is in a particular language class all subsets of that language are also included that language class (e.g. wwR is a proper subset of w, yet w e£3 wwR g£2). Also, in most cases the structural de­scriptions that underlie strings of a language are of more interest than the string sets themselves. For this reason it is useful to distinguish weak and strong containment of a grammar in a language class: e.g., a grammar is weakly context free if its stringset is context free; a grammar- is strongly context free if its treeset is also context free.

Pullum and Gazdar (1982) survey the arguments up to the time they wrote for the non-corltext-freeness of natural language. The most interesting were those that considered idealizations of linguis­tic phenomena in terms of the string duplicating language, ww. In each case they found the ar­gument flawed: the phenomena in question did not yield languages whose stringsets were homo­morphic to the duplication language. Bresnan et al. (1982) argue that Dutch is not strongly con­text free. Shieber (1985) provides a stringset ar­gument about a dialect of Swiss-German, which has a class of verb phrases with cross-serial depen­dencies (through case marking) between NPs and their Vs, which establishes even the weak-non-context-freeness of natural language because of homomorphism to ww. Manaster-Ramer (1987) re-analyzes an argument considered by Pullum and Gazdar (1982) about Dutch and produces a corrected stringset argument that Dutch licences anbnc" constructions, which are MCS. No known syntactic phenomenon requires greater than in­dexed language expressivity.

The point of this paper is to emphasize that al­though a particular Swiss-German dialect renders natural language syntax non-context free, it does not entail that natural languages, including the ones that license cross-serial dependencies, incur the worst case recognition complexity costs for in­dexed languages. In fact, we argue in the next section that ww is fairly straightforward to pro­cess. Essentially, we consider languages xx homo-morphic to ww, where x can be either £3 or £2, and argue that the recognition for xx is no worse than worst case recognition for £3 if x e£3 and no worse than the worst case for £2 if x €£2, even though xx is itself indexed.

Trivially, the string duplication languages can be recognized with time complexity proportional to the length of the string — if the string is of even length, and its first half is identical to the sec­ond half, then this can be established in just lin­ear time. Though trivial in the sense of being about mere recognition, this is nonetheless inter­esting. In particular, under the reasonable hy­pothesis that humans are not in general reverse-wired it is easier to process serial orders than their reverse. In this trivial recognition model we could take the serial ordering as primitive, but to use the same model as a recognizer for the con­text free string reversal languages would require an additional step of reversing the second half of the string before checking equivalence, which means the recognition complexity is nlogn. Thus, for trivial recognition the string duplication lan­guages aie easier to process than the string rever­sal languages. This is a concrete illustration that not every language costs the worst case recogni­tion complexity for its expressivity class.

However, in the case of natural languages, pars­ing is of greater interest than mere recognition. A generalization of the recognizer method can be used inside a parsing approach as well. Suppose some i such that i > 2; suppose we want a rec­ognizer for {tuu)|to 6 {a,ft}*} where w € Ci, then we can use a parser that is no worse than cubic (if i = 2) and which can be linear (if i = 3) to determine if w €d. Thus, if we parse exactly half of the string using a processor designed for languages in Ci, and then ascertain whether the remaining half is identical, then we remain in the same processing complexity class, since the iden­tity check occurs after the parse and only requires linear time, but we also have structural informa­tion about the sentence as a whole. We know the structure of the first half of the string, and the sec­ond half of the string but not the structure of the second half (the grammar for w could be ambigu­ous), although we can assume that the second w was licensed by exactly the same tree structure as the first. This method also preserves a relative dif­ference between par sing ww and wwR, at least for £3. Since wwR can be represented directly within £2 it can be argued that we should not be required to use the metagrammatical method of parsing it, just to keep symmetry with the duplication lan­guages. Interestingly, if w is in £2 and we use the metagrammatical parsing method, then wwR also requires more processing time than ww for the same reason as the trivial case. Suppose instead that we allow wwR to be parsed without; using the metagrammatical method. In that case ww is relatively even easier to process since it costs \w\ato parse with the metagrammatical approach but wwR will cost (2|w|) in the direct approach. It might be claimed that just as we argue ww not to require the worst case complexity for its language-class (£1.5), neither need wwR for £2; but, the reversal language is a canonical example of a lan­guage that makes maximal use of the stack in the PDA. In any case, the metagrammatical method for parsing ww costs no more than just parsing strings in the characteristic language class of w.

If this were the complete st ory then we could only recognize languages homomorphic to the du­plication languages. Clearly even the Zürich di­alect of Swiss-German allows other constructions, all of which we can assume are context free (Pul­lum and Gazdar, 1982). Essentially we want to be able to write arbitrary £3 or £2 grammars and also be able to parse the string duplication lan­guage for whichever Ci we choose. The language defined by such a union is no longer Ci, but will not contain arbitrary £1.5 strings, and if i = 3 then the union will not even contain arbitrary con­text free strings. However, the situation is more involved than the basic approach since there needs to be a way to indicate where the metagrammat­ical approach is to be invoked. Add a single fea­ture to the grammar int erpreted by the processor as 'expect a copy'.

We allow context free productions of the form shown in (1), where A and B are nonterminals and W, Y are (possibly empty) sequences of terminals and nonterminals, B possibly occurring among the nonterminals of Y. For an ambiguous CFG, there is no guarantee that multiple instances of a nonterminal will rewrite to through the same sequence of productions to yield the same string.

There are any number of ways that this basic notation can be used in a metagrammatical ap­proach. In the first instance, we take c to be a signal to the processor to generate an expectation for a duplicate of the terminal sequence that the nonterminal it is attached to gets rewritten to, and that this expectation must be satisfied by the next nonterminal of the same name and in the same local domain. This approach will require that the sequence of terminals rewritten from the first B in (1) will be duplicated by the terminal sequence rewritten from the first instance of B (if any) that occurs in Y. The restriction will not hold of subsequent instances of the nonterminal marked for copying in the same local domain nor at different levels in the analysis. A stronger in­terpretation could require an expectation for the same constituent analysis of the nonterminal as well. Since we do not allow the feature to stack, the string-based method does not yield the full expressive power of indexed languages. The point is just that it's possible to keep a CF (or regular) grammar, and supplement; the processor with a string-duplication operator which can be invoked at the subsentence level. This is sufficient to yield languages that more closely resemble the Zürich dialect in having other constructions besides the duplication construction, yet remaining efficiently processablc.

We have implemented the interpreter in a chart parser that can be used in cither top-down or bottom-up fashion. Edges in the chart are marked with a category (some nonterminal or preter­minal symbol from the grammar), constituents, substring span and expectations (along with a unique identifier for each edge). This is modi­fied to include a list, of constraints, which for the present purposes is presumed to be just duplica­tion checks. An edge with no expectations is in­active (saturated) and one with expectations is active. In the completer step, when active edges combine with adjacent, inactive edges whose cate­gory satisfies the current expectation of the ac­tive, the usual process of creating a new edge with one less expectation is augmented with an­other: if the current expectation has an associ­ated copy feature, then the new edge is marked with a constraint interpreted by the parser as in­dicated above — the nonterminal symbol and the string spanned by the inactive edge are noted so that the next inactive edge of the same category (if one is expect ed) will have; to span an identi­cal string. Constraints of this form are not passed on after satisfied once, and arc not, passed out of the local domain. Wit hin the same set of restric­tions the implemented constraint could have been 'expect a reversed copy'. This would require com-putafing the string's reverse before annotating the constraint list.

For efficient processing of ww to entail correspond­ing complexity for natural languages that license cross-serial dependencies hinges crucially on there being efficiently computable homomorphisms be­tween the natural language; and the string dupli­cation languages. This is an open que;stion. How­ever, give;n that, empirical work that compares pro­cessing of crossed and nested dependencies and concludes that the cross-serial dependencies are preferred to nested ones (Bach et, al., 198G), and give;n our argument, that, cross-serial dependencies are in theory easier to process, we feel it reason­able; to entertain the; assumption that something such exists. This does not require us to assume that people; actually use context-free! grammars and compute: homomorphisms in order to under­stand natural languages, just, that, the computa­tional model should be; at least, approximately as efficient, as pc;ople.

Our nietagrammatical approach to dealing with cross serial dependencies involves the; assumption of an operation for testing string duplication. We hinted earlier that we feel there to be sullicie;nf reason to believe that copy-checking is a basic; cog­nitive function, and although we don't, suppose that, people have built, in production systems and processors isomorphic to our chart parser and base: language, we: do think that this copy-checking is invoked in the processing of crossed dependencies. Our approach to accounting for the processing complexity that the string duplication languages should t ake does make empirical predictions and these can be tested. For instance, if it; is the case that such a rnee;hanism exists, then patterns of string-copy elisfluency should occur with different frequency in languages that license cross-serial de­pendencies than in those that, do not. A string-copy elisfluency is just one: that involves a repe:at of part; of the sentence: uttered so far:

1. We went to the to the store to buy some flour.

The idea is that speakers of languages with ww homomorphisms have a different, pattern of in­voking copy-checking than those who speak languages that do not admit cross serial dependen­cies. These differences should be manifest in speech corpora like those that are currently being accumulated (Anderson et al., 1992; Miller, 1995), but which need augmentation by a corpus derived from copy-language dialects. Verifying this would, for example, establish whether the copied strings need to be constituents, and this has a bearing on whether processing models designed for incremen­tal interpretation (Milward, 1992) are the best de­scriptors of human performance. We do not offer arguments that our metagrammatical approach is the best description of human processing of cross-serial dependencies, just that it is another theo­retical justification for the difference in process­ing nested dependencies and efficient processing of crossed dependencies.