The correspondence between a string of a language and its abstract representation, usually a (decorated) tree, is not straightforward. however, it is desirable to maintain it, for example to build structured editors for texts written in natural language. As such correspondences must be compositional, we call them "Structured String-Tree Correspondences" (SSTC).

We argue that a SSTC is in fact composed of two interrelated correspondences, one between nodes and substrings, and the other between subtrees and substrings, the substrings being possibly discontinuous in both oases. We then proceed to show how to define a SSTC with a Structural Correspondence Static Grammar (SCSG), and which constraints to put on the rules of the SCSG to get a "natural" SSTC.

Keywords: linguistic descriptors, discontinuous constituents, discontinuous phrase structure grammars, structured string-tree correspondences, structural correspondence static grammars

Abréviations: OPSG, MT, NL, SSTC, STC6.

INTRODUCTION

Ordered trees, annotated with simple labels or complex "cecorations" (property lists), are widely used for representing natural language (NL) utterances. This corresponds to a hierarchical view: the utterance is decomposed into groups and subgroups. When the depth of linguistic analysis is such that a representation in terms or" graphs, networks or sets of formulas would be more direct, one often still prefers to use tree structures, at the price of encoding the desired information in the decorations (e.g., by "coindexing" two or more nodes). This is because trees are conceptually and a Igorithmically easier tc manipulate, and also because all usual interpretations based on the linguistic structure are more or less "compositional" in nature.

If a language is described by a classical Phrase Structure Grammar, or by a (projective) Dependency Grammar, the tree structure "contains" the associated string in some easily defined sense. In particular, the surface order of the string is derived from some ordered traversal of the tree ( left-to-right order of the leaves of a constituent tree, or infix order for a dependency tree).

However, if one wants to associate "natural" structures to strings, for example abstract trees for programs or predicate-argument structures for NL utterances, this is no longer true. Elements of the string may have been erased, or duplicated, some "discontinuous" groups may have been put together, and the surface order may not be reflected In the tree (e.g., for a normalized représentât ion). Such correspondences must be compositional: the complete tree corresponds to the complete string, then subtrees correspond to substrings, etc. Hence, we call them "Structured String-Tree Correspondences" (SSTC).

For some applications, like classical (batch) Machine Translation (MT), it is not necessary to keep the correspondence explicit: for revising a translation, it is enough to show the correspondence between two sentences or two paragraphs. However, if one wants to build structured editors for texts written in natural language, thereby using at the same time a string (the text) and a tree (its representation), it seems necessary to represent explicitly the associated SSTC.

In the first part, we briefly review the types of string-tree correspondences which are implied Py the most usual types of tree representations of NL utterances. We argue that a SSTC should in fact be composed of two interrelated correspondences, cne between nodes and substrings, and the other between subtrees and substrings, the substrings being possibly disoontinous in both cases. This is presented in more detail in the second part. In the last part, we show how to define a SSTC with a Structural Correspondence Static Grammar (SCSG), and which constraints to put on the rules of the SCSG to get a "natural" SSTC.

I. WHAT IS A CORRESPONDENCE BETWEEN A STRING AND A TREE?

I. PHRASE STRUCTURE TREES (C-STRUCTURES)

Classical Phrase Structure trees give rise to a very simple kind of SSTC. To each string w = al...an, let us associate the set of intervals i_j, 0<1<j<n. w(i_j) denotes the substring ai...aj of w if i<j, 6 otherwise.

The root, or equivalently the whole tree, corresponds to w -• w(0_n). Each leaf corresponds to some substring w(i_j), of length 0 or 1 (we may extend this to any length if terminals are allowed to be themselves strings Then, the correspondence is such that any internal node of the tree, or equivalently each tree "complete" in breadth and depth, corresponds to w(i_J), iff its m daughters (or its m immediate subtrees), in order, correspond to a sequence w( i l_jl J,.. . , w( irn_jm), such that il=i, jm=j, and jk=ik»l for 0<k<m.

This type of correspondence is "projective". It has however been argued that classical phrase structure trees are inadequate for characterising syntactic representations in general, especially in the case of so-called "discontinuous'constituents. Here are some examples.

- (1) John talked, of course, about politics.

- (3) Je os le lui ai cas donné.

(I did not give it to him)

According to (McCawley 82), sentence (1) contains a verb phrase "talked about politics", which is divided by the adverbial phrase "of course", which modifies the whole sentence, and not only the verbal kernel (or the verbal phrase, 1n Chomsky's terminology). Sentence (2) contains the particle "up", which ts separated from its verb "picked" by "the ball". In sentence (3), the discontinuous negation "ne...pas" overlaps with the composed form of the verb "a1...donné". Moreover, if a sentence in active voice 1s to be represented in a standard order (subject verb object complement), this sentence contains two displaced elements, namely the object "le" and the complement "lut".

(McCawley 82) and later (Bunt 8. al 87) have argued that "meaningful" representations of sentences (2) and (3) should be the following phrase structure trees, (4) and (5), respectively.

In "predicate-argument structures", it is usual to construct a unique node for a compound predicate, in the same spirit as the "if_then_else" operator above. With sentences (1) and (2), for example, we could get trees (12) and (13) below. Beside the logical relation (argument place) or the semantic relation, the nodes must also contain some other information, like tense, person, etc., which is not shown here.

John of_course politics He

Figure 7; Examples of predicate-argument trees

We now come to situations where overlapping occurs, and whore 1t 1s natural to consider "incomplete" subtrees corresponding to "dlscontinous" groups.

This elision, occurs as in:

frequently in cases of coordination with

"John dresses. " and Mary give Paul and Ann trousers and

In order to simplify the trees, we abstract this by the formal language tan v bn cn 1 n>0), and propose the two trees (14) and (15) below for the string "a a v b b c c" (also written a.1 a.2 v b.1 b.2 c.1 c.2 to show the positions) as more "natural" representations than the syntactic tree derived from a context-sensitive grammar in normal form for this language (all rules are of the form "1 A r —> 1 u r", 1 and r being the left and right context, respectively).

Examples of p-structures for a1 a2 v bl b2 cl

On certain nodes, we have represented the sequence corresponding to the complete subtree rooted at the node, followed by the sequence corresponding to the node itself. For nodes A, B, C in tree (14), this "local" sequence is empty.

In both trees, It is clear that the sequence al V bl d corresponds to an "Incomplete" subtree, namely V(A(a1),B(b1),C(cD) in (14) and V(al,b1,cl) in (15).

In tree (14), the coordination is shown directly on the graph, and the verb (V) is not shown as elided. It is a matter of further analysis to accept or not the distributive interpretation ("respectively" may hold between the three groups, the last two ones, or nones).

On the contrary, tree (15), in a sense, is a more "abstract" representation. It shows directly the interpretation as a coordination of two sentences, and "restores" the elided V.

MULTILEVEL TREES (M-STRUCTURES)

Multilevel tree structures, or m-structures for short, have been introduced by B.VAUQUOIS in 1974 (see (Vauquois 78)) for the purposes of Machine Translation. On the same graph, three "levels of Interpretation" are described (constituents, syntactic dependencies, logical and semantic relations). As seen in other examples above, the nodes which refer directly to the string do not contain elements of the string, but rather representatives of (sequences of) elements of the string, called "lexical units" (LU), like "repair" for "reparation", plus some Information about the derivation used.

The graph is deduced by simple rules from a dependency tree: each Internal node is "lowered" in the "*" position and its syntactic function becomes "GOV" (for "governor", or head in some other terminology), discontinuous lexical elements (like "ne...pas" or "ai...donné" are represented by one node, coordination is represented by "vertical lists" as in tree (14), lexical units of referred element's are put in the nodes corresponding to the pronouns, an approximation of colndexlng, etc..

From the point of view of the associated correspondence between representation trees and represented strings, nothing new has to be mentioned.

II. A PROPOSAL : STRUCTURED STRING-TREE CORRESPONDENCES Our proposal 1s now almost complete.

a) The correspondence between a string and its representation tree Is made of two interrelated correspondences :

- between nodes and (possibly discontinuous) substrings;

- between (possibly Incomplete) subtrees and (possibly dlscontinous) substrings.

STREE(N) > STREE(Nl)*...'STREE(Nm) * SNODE(N). In case cf strict containment, the difference correspond to the elements of the string which are represented by the subtree but which are not explicitly represented, like "(" and ")" in "< b )".

c) The seauence SSUBT(X,N) corresponding to a given incomplete subtree X rooted at node N of the whole tree T is defined recursively by:

- SSUBT(X.N) = SSUBT(X1K . .+SSUBT(Xp) U SNODE(N), if N, the root of X, has p subtrees XI...Xp in T.

In other words, one takes the smallest sequence containing the biggest sequence corresponding to the leaves of x (STREE on the leaves) and compatible with tne monotony rules above.

Here are some interesting properties of SSTCs which may help to classify them.

A SSTC is non-over lapping if

- STREE(Ni) and STREE(N2) have an empty intersection if Nl and N2 are independent;

- SN0DE(N1) and STREE(N2) have an empty intersection if N2 is a daughter of Nl.

A SSTC is projective if - it is non-overlapping;

- for any two sister nodes Nl and N2, Nl to the left of N2, STREE(NI) is completely to the left of STREE(N2). This means that, if STREE(NI) = w(i1_jl)...w(ip jp) or 0 and STREE(N2) = w(k 1_11 ). .. w(kqjq) or 0, then jp<k1.

A SSTC is direct if, for each elementary interval w(i_i'lj, there is a node N such that SNODE(N) = w(i_t+1).

A SSTC is complete if each elementary interval 1s contained in SNODE(N) for some node N.

A SSTC is of the constituent type if SNODE(N) is empty for each non terminal node N

In the examples above, we have encoded the correspondence in the tree. However, this is in practice not always necessary, or even practical.

In the case of explicit and projective SSTCs, for instance, the string can be obtained directly from the tree, and there is no need to show the intervals.

Note that, in the process of generating a string from a tree, one naturally starts from the top, not knowing the final length of the string, and goes down recursively, dividing this interval into smaller intervals. Rather than to introduce variables representing the extremities of the created intervals, it may be more practical to start from a fixed interval, say 0_i or 0_100. Then, the positions between the elements of the string will be denoted by an increasing sequence of rational numbers (0, 1/3, 1/2, 5/7), etc.

In the case of "local" non-projectivlty, we have tried some devices using two relative Integers (POS,LEV) associated with each node N. POS(N) slows the relative order in the subtree rooted at mother(N), 1f l.EV(N)=0, or more generally at its LF.V(N*1) ancestor, if l.EV(N)>0. Unfortunately, all these schemes seem to work only for particular situations.

Also, if the SSTC is overlapping, or not complete, it may be computationally costly fo find the (smallest) subtree associated with a given (possibly discontinuous) substring. But this operation would be essential in a "structural" editor of NL texts. A possibility is thon to encode the correspondence both in thé tree and in the string.

Finally, take the example of tree (15) above. Suppose that the user of a NL editor wants to change b1 (Paul, in the corresponding NL example) in a way which may contradict some agreement constraint between a1, V, bl and cl. One should be able to find the smallest SSTC containing al and other elements, that is, the subtree V(a1,b1,c1) and the discontinuous substring al v bl cl (the notation a._.v.b._.c._. might be suitable, if one wants to avoid indices).

For these reasons, it may be worthwhile to consider the possibility of representing the SSTC independently of both the tree and the string. This Is actually the Idea behind the formalism of STCG (String-Tree Correspondence Grammar).

HI- EXTENDING THE..STCB .FORMALISM TO PffF|NE„_A SSIC 1- BAMLJNPJjm.AEM.S.ICB

The static grammars of (Vauquols & Chappuy 85) are devices to define string-tree correspondences. They have been formalized by the STCGs of (Zaharln 86).

Here, a context-free Hke apparatus of rules (also called "boards", for "planches" 1n French, because they are usually written with two-dimensional tree diagrams) 1s used to construct the set of "legal" SSTCs.

The axioms are all pairs <x,Y($F)), where x is an unbounded string variable, Y a starting node (standing for SENTENCE, or TITLE, for example), and SF is an unbounded forest variable.

The terminals are all pairs (x,x'), where x 1s an element of a string and x' a one-node tree which represents it.

The rules show how a SSTC is made up of smaller ones. The generated language is the set of all variable-free (<str1ng>,<tree>) pairs derivable from an axiom by the grammar rules.

In order to avoid undue formalism, let us give an example for the formal language <an bn en 1 n>0}.

Figure 9: A simple SCSG for an bn cn

X, Y and Z are string variables, $F a forest variable, and the Indices are Just there to distinguish elements with the same label.

Actually, the formalism is a bit more precise and powerful, because 1t is possible to express that a correspondence in the r.h.s. (right hand side) 1s obtained only by certain rules, and to restrict the possible unifications (rather, a special kind called "identifications" in (Zaharin 86)). To illustrate this, we may rewrite the last element of the r.h.s. as:

Figure 10 Example of with_.ref part in a r.h.s.

R2: X/aX,... means that the subcorrespondence (XY2,S.2($F)) may be generated by rule R2, thereby identifying X in XYZ with aX in aXbYcZ (in the l.h.s.).

In the version of (Zaharin 86), the correspondence is always of constituent type, because the only applications considered had been to »l-structures used for MT, where non-terminal nodes do not directly correspond to substrings.

But this is by no means necessary, as the next example illustrates, with the language (an v bn en 1 n>0).

! with ref

This STCG generates correspondences such as (aavbbcc, tree (15)). But something has to be added to distinguish the STREE and SNODE parts.

We simply associate to each constant or variable appearing in a STCG rule one or two expressions represern ing the STREE and SNODE sequences, separated by a "/" if necessary, with basic elements of the form "p_q", where p and q are constant or variable indices.

In any given (<string>,<tree>) pair, we associate one such expression to each element of <string>, and two to each node of <tree>, the first for STREE and the second for SNODE. The second may be omitted: by default, SNODE is taken to be empty on internal nodes and equal to STREE on leaves.

Our last example may now be rewritten as follows.

(a x v b Y c z

I with ref

Figure 12: Extended STCG for an v bn cn

We will now give examples of STCGs which give rise to unnatural correspondences and try to derive some constraints on the rules. Let us first slightly modify our first STCG for an bn cn.

Figure 13: Example of "unordered" STCG

In the first element of R2, XYZ has been replaced by ZYX. The following representation tree (16) would have been naturally associated with the string a1.a2.a3.b1.b2.b3.cl,cZ.c3 by our first STCG. With this modification, it becomes associated with a!.02.a3.b1.P2.b3.c1,a2.c3, as shown in the next diagram.

Figure 14: Example of STC6 "unordered" w.r.t. the strings

The problem here is that the subtree rooted at S.2, considered as a whole tree, should correspond to the string a2.c3.b2.b3.c2.a3, and that it corresponds to C2.a3.b2.b3.a2.c3 when embedded in the whole tree rooted at S. 1.

The STREE correspondences are not properly defined, because one should be able to distinguish between different permutations of the intervals, which is clearly impossible with our previous definitions and representations of SSTCs.

This is because the order of the elements of the strings is not compatible m the l.h.s. and in the r.h.s.: our first constraint will be to forbid this in STCS rules.

Our second constraint will be to forbid the use of auxiliary variables which do not correspond to substrings (subtrees) of the terminal (variable-free) pairs produced by the STCS.

Let us illustrate this with the following STCG, which constructs the representation tree S(A(u),B(v)) for each word w on (a,b,c) of even length such that w=uv and Mu=Hv,

Figure 15: Example of STCG with auxiliary variables

There is a natural SSTC between the representation tree and the string. For example, we get S(A(a,b,c),B(b,a,c)) for w=abcbao. But the construction of this final correspondence involves the construction of pairs such as (aboPPP,S(A(a,b,c),P,P,P)), which are just used for counting.

If we try to put sequence expressions on the P nodes and string elements, we notice that it would be necessary to extend the intervals of w, rather than to divide them. Otherwise, we would make the first P of abcPPP correspond to the second b of w=abcbac, which is quite natural, but what would we associate to the first P of bacPPP ?

If we represent explicitly (and separately) the structure of a given (<str1ng>,<tree>) element of the SSTC by its derivation tree in the STCG, the second constraint will allow us to instantiate all variables by substrings or subtrees of <string> and <tree>, without having to construct other auxiliary strings and trees. This, of course, ' would permit a more economical implementation, in terms of space.

Finally, note that the interesting properties of SSTCs mentioned in III.1 above have simple expressions as constraints on the rules of our extended STCG formalism.

CONCLUDING REMARKS

Trees have been widely used for the representation of natural language utterances. However, there have been arguments saying that they are not adequate for representing the so-called 'discontinuous' structures. This has led to various solutions, relying, for instance, or encoding the desired information in the nodes (e.g. 'coindexing'), or on defining trees with "discontinuous" constltuents.

we have presented here a proposal for representing discontinuous constituents, and, more generally, non-projective and uncomplete SSTCs with overlapping.

The proposal uses the ordinary definition of ordered trees. This is made possible by separating the representation tree from the surface utterance (which the tree is a representation of). The correspondence between the two may be represented explicitly by means of sequences of intervals attached to the nodes.

This opens up a discussion on (and definitions of) structured string-tree correspondences in general. This representation might also be used in syntactic editors for programs or in syntactico-semantic editors for NL texts.

Finally, the formalism of the String-Tree

Correspondence Grammar has been extended to give the means of representing the said structured correspondences.

An analogous problem is to define structured correspondences between representation trees, for Instance between source and target interface structures in transfer-based MT systems. We do not yet know of any satisfactory proposal.

A solution to this problem would give two very Interesting results:

- first, a way to specify structural transfers in a reasoned manner, Just as STCGs are used to specify structural analysers or generators,

- second, a way to put a text and its translation in a very fine-grained correspondence. This is quite easy with word-for-word approaches, of course, and also for approaches using classical (projective) PS trees or dependency trees, but has become quite difficult with more sophisticated approaches using p-structures or m-structures.