mitcho.com » Italian

Ubiquity in Italian!

mitcho — Mon, 18 May 2009 04:32:25 +0000

Thanks to the great work of Sandro Della Giustina, we now have a preliminary Italian parser for use with Ubiquity Parser 2. Sandro brought up a good point, however, about Italian prepositions which contract with the article and the head noun. For example,

traduci   dall'inglese     al     cinese
translate from=the=English to=the Chinese

One current solution is to add zero-width spaces after these contracted articles, all’ and dall’.¹ The appropriate way to add this to the parser is by defining a custom wordBreaker() method.

it._patternCache.contractionMatcher = new RegExp('(^| )(all\'|dall\')','g');
it.wordBreaker = function(input) {
  return input.replace(this._patternCache.contractionMatcher,'$1$2\u200b');
};

Grazie Sandro!

As John Daggett pointed out to me, in the future we may have to add an intermediate shallow parse instead of adding characters (in this case, the zero-width space) to the modified input. ↩

Related posts brought to you by Yet Another Related Posts Plugin.

Solving Another Romantic Problem: Weak Pronouns

mitcho — Tue, 12 May 2009 08:09:31 +0000

Yesterday I blogged on how to deal with portmanteau’ed prepositions in Ubiquity Parser 2, a common problem in various romance languages. Today I’ll propose an approach to another romantic problem.

The problem:

Weak pronouns in romance languages (as well as some other languages) have a special property where they cliticize to the verb, moving from its regular argument position to a position next to the verb. For example, in French, we have an imperative like (1) with gloss as (2):

1 2	Envoyez le lettre à Pierre! send.IMP the letter to Pierre

If we replace le lettre or à Pierre with a preposition (le, “it”, or lui, “to him”, respectively), those weak pronouns move next to the verb—in particular, (5) exemplifies the change in word order. Replacing both arguments with prepositions creates the stacked clitic form of (7).¹

Envoyez-la à  Pierre!
send   -it to Pierre
Envoyez-lui la  lettre!
send   -him the letter
Envoyez-le-lui!
send   -it-him

The fact that these weak pronouns are attached to the verb and lack separate delimiters mean that we will need a separate mechanism to parse these arguments: indeed, this functionality has been planned in Ubiquity Parser 2 as “step 3”. Here I’ll examine some data and discuss a strategy for the parsing of weak pronouns.

Weak pronouns in Ubiquity

In Ubiquity the only pronoun we currently deal with is the deictic object-role anaphor, like “it,” “this,” etc. in English.² In addition, as these weak pronoun clitics cannot by definition be embedded within a larger noun phrase, its referent would constitute the entire object argument. As such, it is most logical to place clitic handling before argument structure parsing and simply hand the argument parser the argument string without the clitic.

Marking the clitic

We can classify languages with cliticized weak pronouns into two cases based on their processing considerations: languages that overtly mark the clitic and those which do not.

Languages which delimit the clitic

Some languages such as French (see above) clearly mark the boundary between the verb and the clitic. It will be relatively easy to parse weak pronouns in such languages as we can simply insert a no-width space between the verb and the clitic. A list of clitics can then be designated in the parser (much like anaphora are now) and these weak pronouns can be interpreted as the selection (or “this”-referent).³

Portuguese: (from Cysouw 2003)

Come-o
eat -it

Catalan: (from Toni Hermoso Pulido)

Cerca-ho
search-it

Modern Greek: (from Rivero and Terzi 1995; I know, I know, Greek’s not a romance language, but it has weak pronoun clitics too… it’s all good.)

Modern Greek actually inserts a space between the verb and weak pronouns.

Diavase to
read   -it

Languages which do not delimit the clitic

Some languages do not insert any delimiter between the verb and the weak pronoun, essentially entering them as a single word (in the string sense, at least). These cases may be more difficult to parse, especially as there may be sound changes to the verb stem itself.

Italian: (first example from Kayne 1994)

Italian is a case where some verbs actually conjoin with the verb in imperatives, much like their prepositions which I noted yesterday have an elaborate system of portmanteau’ed forms.

Fallo
do-it
Mangialo
eat  -it

Spanish: (first example from Rivero and Terzi 1995, second from Toni Hermoso Pulido)

Spanish is the same way:

Léelo
read-it
Búscalo
search-it

Displaying the suggestion

The current Ubiquity handling of anaphora (aka “magic words”) involves a display of the selection (replacement) text in a stylized way. One problem with clitics may be how to visually present this replacement to the user.

For languages with a delimiter such as French we could simply present the selection as an object right after the verb, without the hyphen.

input:	traduisez-le (translate-it)
suggestion:	traduisez selection

Things may be more complicated, however, in languages where the clitic is not delimited from the verb, or where the verb form itself has changed due to the attachment of the clitic.

Conclusion

In this blog post I’ve tried to lay out some of the weak pronoun phenomena relevant to Ubiquity with some ideas on how to implement its parsing. I believe parsing weak pronouns should be relatively straightforward in languages with delimiters—for those which do not have delimiters, some creativity may be required in how building regular expressions or rules to detect the clitics and in presenting these suggestions to the user.

Does your language have weak pronoun clitics? What do you think will be the challenges in trying to parse these arguments?

Note that the reverse order of “Envoyez-lui-le” is ungrammatical… fortunately we most likely will not have to deal with multiple clitics… see footnote two below. ↩
This is not so much an informed decision that we should not do different kinds of anaphors but simply that we haven’t gotten around to implementing it. I personally am not sure, however, whether there is a real need for parsing for anaphors for roles other than object (for example, French lui as seen above which would be a goal anaphor). ↩
There is, however, a question of whether weak pronoun replacement should be obligatory or not: that is, if we see a regular anaphor right now such as “this,” we make two copies of the parse: one with the replacement, one without. In the case where we detect an anaphor, should the replacement be obligatory? I believe it should be, though, as with many other Parser 2 features, I believe we can continue to parse other options with no replacement but let the scoring system kill those parses off. If a verb has a clitic attached to it but we do not remove it, it most likely will do very poorly in scoring anyway. ↩

Related posts brought to you by Yet Another Related Posts Plugin.

Solving a Romantic Problem: Portmanteau’ed Prepositions

mitcho — Mon, 11 May 2009 05:19:17 +0000

The problem:

In many romance languages, prepositions and articles often form portmanteau morphs, combining to form a single word.¹ Some examples include (French) à + le > au, de + le > du, (Catalan) a + el > al, de + les > dels, per + el > pel. Italian has a particularly productive system of portmanteau’ed prepositions and articles… I refer you to the contraction article on Wikipedia.

As I noted a couple weeks ago, however, some combinations do not form portmanteaus.²

French:

à + le > au
à + la > à la

The problem with this is that if we use both à and au as delimiters, we may end up passing the definite article to the verb as part of the argument in some cases, but not in other cases.

“à la table” = “to the table”
“au chat” = “to the cat”

The solution:

The solution is a new step in the Parser 2 process which normalizes the form of arguments. Each language’s parser can now optionally define a normalizeArgument() method which takes an argument and returns a list of normalized alternates. Normalized arguments are returned in the form of {prefix: '', newInput: '', suffix: ''}. For example, if you feed “la table” to the French normalizeArgument(), it ought to return

[{prefix: 'la ', newInput: 'table', suffix: ''}]

If there are no possible normalizations, normalizeArgument() should simply return []. Each alternative returned by normalizeArgument() is substituted into a copy of the possible parses just before nountype detection. The prefixes and suffixes are stored in the argument (as inactivePrefix and inactiveSuffix) so they can be incorporated into the suggestion display.

Here, for example, is how the inactive prefix “l’” is displayed in the parser demo. This way the user is told that the “l’” prefix is being ignored, and the nountype detection and verb action can act on the argument “English”.³ (In the future, of course, we could teach this nountype to accept the Catalan “anglès”.)

The easiest way to produce this output is to use the String.match() method. For example normalizeArgument() code, I refer you to the Catalan and French parser files.

I hope that this solution will help make Ubiquity with Parser 2 feel more natural for many romance languages.

Thanks to Jeremy O’Brien for helping me figure out how to refer to this phenomenon. ↩
This also relates to the issue of parsing multi-word delimiters, though the argument normalization strategy covered here should reduce the necessity of multi-word delimiters. ↩
Thank you to contributor Toni Hermoso Pulido for our first attempt at a Catalan parser! ↩

Related posts brought to you by Yet Another Related Posts Plugin.

Ubiquity in Italian

mitcho — Mon, 09 Mar 2009 20:43:12 +0000

flod put up a nice blog post on thinking about Ubiquity in Italian. flod points out that what seems natural to him as a speaker is the use of the imperative form of the verbs, but that some verbs may not translate neatly, even following the overlord verbs proposal:

For example, the verb “make” is quite difficult to translate (too generic): “to make” could be “fare”, but “fare grassetto” (”make bold”) doesn’t make any sense, people would use more specific verbs:

make bold -> trasforma in grassetto (sounds like “change to bold”)
make page editable -> rendi pagina modificabile

This is a great point. Although the overlord verbs may naturally map into many languages, it may not be perfect for some commands in some languages. Where would English overlord verbs not translate well into your language?

I suggest on flod’s blog that a “synonym” system could be implemented to map single verbs to specific overlord’ed functionality, but these would definitely have to be done on a language-specific basis, unfortunately adding a little work to the localization process.

Related posts brought to you by Yet Another Related Posts Plugin.