Transfer rules examples

This page is intended to supplement the page A long introduction to transfer rules. Examples used are taken from apertium-eo-fr pair. It is (at the beginning of 2013) a released pair for translating French to Esperanto. But Esperanto → French translation direction had not been implemented by the initial developer. It is another developer, full beginner for writing transfer rules who chose to do that. The examples given are the first rules written to translate a group of one, two or three Esperanto words into a group of two or three French words.

This page is only about writing the file with the suffix .t1x with rules intended to be used by the tool apertium-transfer. Writing tags used for chunking in a 3-stage transfer is not approached there.

Different steps for a translation with apertium

Let start by making a list of the different operations done for a translation.

Operation	Role	Concerned languages
Deformatting	Allows to mark zones of the source text not to be translated. For example, HTML tags must not be translated in another language, but only the text of the Web page.	The same software are used for every language pairs. It is the format of the data to be translated which will take to use a particular deformatter.
Analysis	Each word of the source text is decomposed into a lemma followed by the type of the word and its attributes (gender, number, person and time for a verb ...). For some words, several analyzes are possible. In this case, they all are sent on output.	Valid for every languages, it uses the morphological dictionary of the source language.
Disambiguation	When there are several analysis for a word, this step permits to keep only one.	Valid for every languages, it uses a file with .prob suffix For non ambiguous languages as Esperanto, this step stays necessary to take off the surface form of each analyzed word (pre-formatting for the transfer step).
Pre-transfer	Processing multiwords before transfer step.	All languages. Does not require a particular data file.
Transfer	Transforms analyzes from the source language into their translated version in the target language.	Valid for every languages, it uses the bilingual dictionary and the transfer file with .t1x suffix.
Interchunk processing	Allows processing on groups of words (the subject, a complement ...) As indicated above, we will not deal with this step (nor of the following).	Used a priori to make the transfer step more simple, it needs to add several tags during the transfer step. It uses a file with .t2x suffix and eventually other files if several pass of this kind are done.
Postchunk	End of interchunk processing(s)	Needed if one or more interchunk processing were done. It uses a file with .t3x suffix.
Generation	Generate the surface forms of the target language words from the decomposition in lemma + attributes obtained from the previous steps.	Valid for every languages, it uses the morphological dictionary of the target language.
Post-generation	Allows spelling corrections between following words when particular cases are not processed by the generation.	Used in a lot of target languages (including French), may be not for all.
Reformatting	Put the translated data back to the format of the source document.	The same software are used for every language pairs. There is a reformatter for each available deformatter even in every reformatter do a similar work.

The page Preparing to use apertium-transfer-tools gives an example about how a Spanish sentence is changed at every step of the process to lead finally to an English translation.

How to find what must be done

Basically, the transfer step starts from a disambiguated analysis of the source language text to provide an equivalent in the target language. The generation step then does the inverse processing as the analysis. It has a consequence : data given to generator must be exactly what a new analysis of the text translated in the target language would give. Otherwise, the generation will be only partial with some # appearing at the beginning of some words that will be written as lemmas.

Example :

We want to translate in French the 3 Esperanto words :

la aŭtomata traduko

After analysis and disambiguation, we get :

^la<det><def><sp>$ ^aŭtomata<adj><sg><nom>$ ^traduko<n><sg><nom>$

A lexical transfer step (using only the bilingual dictionary) will give :

^le<det><def><sp>$ ^automatique<adj><sg><nom>$ ^traduction<n><f><sg><nom>$

The part of sentence we want to get in French is :

la traduction automatique

When analyzing this part of sentence, we get :

^le<det><def><f><sg>$ ^traduction<n><f><sg>$ ^automatique<adj><mf><sg>$

which is the text we must give to the generator to get the desired translation.

So, during the structural transfer step, we will have to do the following changes :

Origin :

^le<det><def><sp>$ ^automatique<adj><sg><nom>$ ^traduction<n><f><sg><nom>$

Result :

^le<det><def><f><sg>$ ^traduction<n><f><sg>$ ^automatique<adj><mf><sg>$

For this, we write the transfer rules. Their goal is to add or remove several tags in words descriptions, and possibly to change the order of certain words.

Structure of a .t1x file

The file containing transfer rules has the suffix .t1x . This file is made of several mandatory sections and can also contain other optional sections. Each section will have to contain at least one element.

 <?xml version="1.0" encoding="UTF-8"?>
 <transfer>
    <section-def-cats>
       ..........
    </section-def-cats>

    <section-def-attrs>
       ..........
    </section-def-attrs>

    <section-def-vars>
       ..........
    </section-def-vars>

    <section-def-macros>
       ..........
    </section-def-macros>

    <section-rules>
       ..........
    </section-rules>
 </transfer>

Section def-cats

The def-cats section is mandatory. It allows to declare categories of word that we will fetch to apply a particular transfer rule. It can be simple words (a determinant, a noun, an adjective, a verb, ...) or a little more complicated things as a noun with in its description the tag <nom> (nominative) meaning it is part of the subject of the sentence.

This section contains one or more element with the following structure :

    <def-cat n="name_of_what_we_want_to_describe">
      <cat-item tags="its_description"/>
      .... (there can be one or more <cat-item .../> tags)
    </def-cat>

Section def-attrs

The def-attrs section is mandatory. It allows to put together by functionality attribute names for words defined in the section sdefs of a morphological dictionary. For example, we will put together in this section every tag corresponding to the :

• gender of a word
• number of a word (singular, plural, ...)
• person of a verb
• time of a verb
• ...

This section contains one or more element with the following structure :

    <def-attr n="name_of_a_list_of_attributes_with_a_common_rule">
      <attr-item tags="an_attribute_of_the_sdef_section_of_a_dictionary"/>
      .... (we have several tags <attr-item .../> as many as possible
            values for the attribute)
    </def-attr>

Section def-vars

The def-vars section is mandatory and must contain at least one element with the following syntax <def-var n="..."/> . It lists the global variables used in the transfer rules. However, for the rules described in this page, we will not need any of these variables.

Section def-macros

The def-macros section is optional. Nevertheless, it will be very useful to write shorter transfer files avoiding to duplicate identical (or almost) operations done in several transfer rules.

This section contains one or more element with the following structure :

    <def-macro n="name_of_the_macro" npar="number_of_parameters">
      .... (the code of the macro)
    </def-macro>

Section rules

Finally, the rules section is mandatory. It is the longest of the transfer file and the one that justifies its existence. It indeed makes it possible to define the operations to be performed to translate groups of words (or sometimes single words, as we will see).

This section contains one or more element with the following structure :

    <rule>
      <pattern>
        <pattern-item n="name_defined_in_def-cat_corresponding_to_the_first_word_to_process"/>
        .... (as many tags <pattern-item ..../> as words we want to process together)
      </pattern>
      <action>
        .... (description of the transfer rule)
      </action>
    </rule>

Examples of transfer rules

Transferring two words making them agree

We will start to translate to French the Esperanto determinant la followed buy a common noun.

Search for modifications

In Esperanto, the definite determinant la is invariant, while in French, it has three forms: le, la, les according to gender and number of the noun to witch it agrees.

For the common noun, there are two forms in Esperanto depending on it belongs to the subject or the object complement in the sentence. In French, it is written the same in both cases.

Examples :

Esperanto	Esperanto analyzes	French	French analyzes
la tago la tagon	^la<det><def><sp>$ ^tago<n><sg><nom>$ ^la<det><def><sp>$ ^tago<n><sg><acc>$	le jour	^le<det><def><m><sg>$ ^jour<n><m><sg>$
la nokto la nokton	^la<det><def><sp>$ ^nokto<n><sg><nom>$ ^la<det><def><sp>$ ^nokto<n><sg><acc>$	la nuit	^le<det><def><f><sg>$ ^nuit<n><f><sg>$
la tagoj la tagojn	^la<det><def><sp>$ ^tago<n><pl><nom>$ ^la<det><def><sp>$ ^tago<n><pl><acc>$	les jours	^le<det><def><mf><pl>$ ^jour<n><m><pl>$
la noktoj la noktojn	^la<det><def><sp>$ ^nokto<n><pl><nom>$ ^la<det><def><sp>$ ^nokto<n><pl><acc>$	les nuits	^le<det><def><mf><pl>$ ^nuit<n><f><pl>$

Let examine what the lexical translation of the Esperanto analysis gives and compare it to the analysis in French we wants to submit to the generator:

Esperanto analyzes	Esperanto analyzes translated in French	The analyzes in French of what we want to get
^la<det><def><sp>$ ^tago<n><sg><nom>$ ^la<det><def><sp>$ ^tago<n><sg><acc>$	^le<det><def><sp>$ ^jour<n><m><sg><nom>$ ^le<det><def><sp>$ ^jour<n><m><sg><acc>$	^le<det><def><m><sg>$ ^jour<n><m><sg>$
^la<det><def><sp>$ ^nokto<n><sg><nom>$ ^la<det><def><sp>$ ^nokto<n><sg><acc>$	^le<det><def><sp>$ ^nuit<n><f><sg><nom>$ ^le<det><def><sp>$ ^nuit<n><f><sg><acc>$	^le<det><def><f><sg>$ ^nuit<n><f><sg>$
^la<det><def><sp>$ ^tago<n><pl><nom>$ ^la<det><def><sp>$ ^tago<n><pl><acc>$	^le<det><def><sp>$ ^jour<n><m><pl><nom>$ ^le<det><def><sp>$ ^jour<n><m><pl><acc>$	^le<det><def><m><pl>$ ^jour<n><m><pl>$
^la<det><def><sp>$ ^nokto<n><pl><nom>$ ^la<det><def><sp>$ ^nokto<n><pl><acc>$	^le<det><def><sp>$ ^nuit<n><f><sg><nom>$ ^le<det><def><sp>$ ^nuit<n><f><pl><acc>$	^le<det><def><f><pl>$ ^nuit<n><f><pl>$

We can note :

• for the determinant, the lexical translation always gives ^le<det><def><sp>$ . It will be necessary to replace the last tag <sp> (singular or plural) by tags used by the common noun giving its gender and number.
• for the common noun, the lexical translation found (in the bilingual dictionary) the gender of the noun translated to French. To know if this noun is singular or plural, it kept the number attribute of the original language. But the attribute <nom> or <acc> which is not needed in French was also kept and it can prevent to generate the word. So, this attribute will have to be removed by the transfer rule.

Writing the transfer rule

For this first rule, we start from a "empty" file with .t1x suffix having the structure described here.

As the def-macros section is optional and not used for the first transfer rules described in this page, we will not put it for the present.

The def-vars section is mandatory. Although it will never be used in the examples this page, we will just put a minimum content so that the file .t1x can be compiled:

  <section-def-vars>
    <def-var n="aucune_variable"/>
  </section-def-vars>

The other sections may contain useful information for our first transfer rule.

Section def-cats

In this section, we will define 2 word categories :

• determinants written as det which are identified in analysis by the tag <det> followed by anything.
• common noun written as nom_commun which are identified in analysis by the tag <n> followed by anything.

The def-cats section will be written as follow :

  <section-def-cats>
    <def-cat n="det">
      <cat-item tags="det.*"/>
    </def-cat>

    <def-cat n="nom_commun">
      <cat-item tags="n.*"/>
    </def-cat>
  </section-def-cats>

• names of word categories are in the attribute n of <def-cat n="..."> tags
• descriptions of what must be found into analysis to recognize the word category are in the attribute tags of <cat-item tags="..."/> tags.

Section def-attrs

Now we will define possible attributes to the various tags of words

  <section-def-attrs>
    <def-attr n="type_mot">
      <attr-item tags="n"/>
      <attr-item tags="det"/>
    </def-attr>

    <def-attr n="genre">
      <attr-item tags="m"/>
      <attr-item tags="f"/>
      <attr-item tags="mf"/>
    </def-attr>

    <def-attr n="nombre">
      <attr-item tags="sg"/>
      <attr-item tags="pl"/>
      <attr-item tags="sp"/>
    </def-attr>
  </section-def-attrs>

• In the n attribute of tags <def-attr n="...">, we give a name to the various characteristics of the words we want to process
• for each of these characteristics, <attr-item tags="..."/> tags indicate the different possible values ​​of this characteristic.

For the rule we want to write, we defined 3 characteristics :

• type_mot (may be mandatory, but there is no documented alternative solution). Presently, the available types are:
  • n (common noun)
  • det (determinant)

We will add some others later when we will write other rules.

• genre with the possible values
  • m (masculine)
  • f (feminine)
  • mf (masculine or feminine)

• nombre with the possible values
  • sg (singular)
  • pl (plural)
  • sp (singular or plural)

Section rules

A section rules containing only the rule we want to write will contain:

  <section-rules>
    <rule>
      <pattern>
        <pattern-item n="det"/>
        <pattern-item n="nom_commun"/>
      </pattern>
      <action>
        <out>
          <lu>
            <clip pos="1" side="tl" part="lem"/>
            <clip pos="1" side="tl" part="type_mot"/>
            <lit-tag v="def"/>
            <clip pos="2" side="tl" part="genre"/>
            <clip pos="2" side="tl" part="nombre"/>
          </lu>
          <b />
          <lu>
            <clip pos="2" side="tl" part="lem"/>
            <clip pos="2" side="tl" part="type_mot"/>
            <clip pos="2" side="tl" part="genre"/>
            <clip pos="2" side="tl" part="nombre"/>
          </lu>
        </out>
      </action>
    </rule>
  </section-rules>

The rule is made of 2 sections :

      <pattern>
        <pattern-item n="det"/>
        <pattern-item n="nom_commun"/>
      </pattern>

In this part, we specifies which are the successive categories of words that must be found in the analysis of the source text so that the rule can apply. In this case, we will have to find a determinant, followed of a common noun. The attributes of <pattern-item n="..."/> tags must all have been defined in the def-cats section, otherwise the rule could never be applied.

The most interesting part of the rule is starting from the <action> tag. It has the following structure:

      <action>
        <out>
          <lu>
            ... (generation of the lexical unit for the first word)
          </lu>
          <b />
          <lu>
            ... (generation of the lexical unit for the second word)
          </lu>
        </out>
      </action>

In this rule, we only generate data that we send on output. The contents of <action> tag is therefore limited to the generation of the text that is indicated in <out> tag.

We will have to generate the analysis of 2 words in the target language. Analysis of each word is a lexical unit]] (<lu> tag) which on output will be symbolized by the characters ^...$ where the description of the lexical unit will replace the dotted lines.

Between the two lexical units, we will leave a space ( tag) otherwise, the two words generated would be stick.

Let us examine how lexical units are written :

The first tag <clip pos="1" side="tl" part="lem"/> has element by element the following meaning:

Part	Meaning
clip	This is a keyword which can be translated by "get"
pos="1"	It is the number of the pattern-item in the list <pattern>...</pattern> of the rule. Here, pos="1" corresponds to the analysis of the determinant
side="tl"	We get the information from the target language. To access to the source language, we would write side="sl"
part="lem"	This is a reserved keyword corresponding to the lemma.

The third <lit-tag v="def"/> tag has element by element the following meaning:

Part	Meaning
lit-tag	This is a keyword which can be translated by "generate a tag"
v="def"	Here we specify the contents of the tag. In this case, <def> will be generated.

The 5 instruction necessary to generate the analysis of the determinant have the following meaning:

Instruction	Meaning
<clip pos="1" side="tl" part="lem"/>	Get the lemma of the first word of the pattern in the target language. It will always be French article "le".
<clip pos="1" side="tl" part="type_mot"/>	Get the type of the first word of the pattern in the target language. It will be det.
<lit-tag v="def"/>	Generate a def tag, i.e. the text <def> which specifies that the determinant is defined.
<clip pos="2" side="tl" part="genre"/>	Get the gender of the second word of the pattern in the target language, ie the gender of the common noun.
<clip pos="2" side="tl" part="nombre"/>	Get the number of the second word of the pattern in the target language, ie the number of the common noun.

The 5 elements we got constitute constitutes the lexical unit <lu>...</lu> that will be sent on output using the tag <out>...</out>

For the second lexical unit corresponding to the common noun translation, we can notice that we have on each line : pos="2" side="tl" meaning that we will simply copy several tags of the common noun (2nd word of the rule).

Detailed explanation of the four instructions:

Instruction	Meaning
<clip pos="2" side="tl" part="lem"/>	Get the lemma of the second word of the pattern in the target language (the common noun in French).
<clip pos="2" side="tl" part="type_mot"/>	Get the type of the second word. That will be n.
<clip pos="2" side="tl" part="genre"/>	Get the gender of the common noun.
<clip pos="2" side="tl" part="nombre"/>	Get the number of the common noun.

Note

If we send to the generator the result of the of the transfer, we don't get exactly what is needed :

French analysis	Result of the generation	What is needed
^le<det><def><m><sg>$ ^jour<n><m><sg>$	~le jour	le jour
^le<det><def><f><sg>$ ^nuit<n><f><sg>$	~la nuit	la nuit
^le<det><def><mf><pl>$ ^jour<n><m><pl>$	~les jours	les jours
^le<det><def><mf><pl>$ ^nuit<n><f><pl>$	~les nuits	les nuits
^le<det><def><m><sg>$ ^arbre<n><m><sg>$	~le arbre	l'arbre
^le<det><def><f><sg>$ ^histoire<n><f><sg>$	~la histoire	l'histoire
^le<det><def><m><pl>$ ^arbre<n><m><pl>$	~les arbres	les arbres
^le<det><def><f><pl>$ ^histoire<n><f><pl>$	~les histoires	les histoires

The replacement of the determinant le/la by l' according to the first letter of the following word is not done during the generation but just after during the post-generation step which process the words marked by a ~ . This remark being done, the post-generation will not be mentioned again in this page.

Adding a word in the target language text

Esperanto does not have any indefinite determinant. To translate un, une, des, we simply do not put the definite determinant la before the common noun. A common noun written alone in Esperanto will have to be preceded by the correct indefinite determinant un, une or des, if it is translated in French.

Our second rule will make this transformation.

Let examine what gives the lexical translation of the Esperanto analysis and compare it to the analysis in French we want to submit to the generator:

Esperanto analysis	Esperanto analysis translated to French	French analysis that we want to get
^tago<n><sg><nom>$ ^tago<n><sg><acc>$	^jour<n><m><sg><nom>$ ^jour<n><m><sg><acc>$	^un<det><ind><m><sg>$ ^jour<n><m><sg>$
^nokto<n><sg><nom>$ ^nokto<n><sg><acc>$	^nuit<n><f><sg><nom>$ ^nuit<n><f><sg><acc>$	^un<det><ind><f><sg>$ ^nuit<n><f><sg>$
^tago<n><pl><nom>$ ^tago<n><pl><acc>$	^jour<n><m><pl><nom>$ ^jour<n><m><pl><acc>$	^un<det><ind><m><pl>$ ^jour<n><m><pl>$
^nokto<n><pl><nom>$ ^nokto<n><pl><acc>$	^nuit<n><f><sg><nom>$ ^nuit<n><f><pl><acc>$	^un<det><ind><f><pl>$ ^nuit<n><f><pl>$

Compared to the previous rule, instead of generating ^le<det><def><gender><number>$ we will generate ^un<det><ind><gender><number>$. Everything else is unchanged.

To write the new rule, we already have all what we need in def-cats and def-attrs sections . So, we will just have to add the new rule in the rules section that will become:

  <section-rules>
    <rule>
      <pattern>
        <pattern-item n="det"/>
        <pattern-item n="nom_commun"/>
      </pattern>
      <action>
        ... (see the contents in the preceding paragraph)
      </action>
    </rule>

    <rule>
      <pattern>
        <pattern-item n="nom_commun"/>
      </pattern>
      <action>
        <out>
          <lu>
            <lit v="un"/>
            <lit-tag v="det.ind"/>
            <clip pos="1" side="tl" part="genre"/>
            <clip pos="1" side="tl" part="nombre"/>
          </lu>
          <b />
          <lu>
            <clip pos="1" side="tl" part="lem"/>
            <clip pos="1" side="tl" part="type_mot"/>
            <clip pos="1" side="tl" part="genre"/>
            <clip pos="1" side="tl" part="nombre"/>
          </lu>
        </out>
      </action>
    </rule>

In this new rule, we find for the first time the instruction lit that will generate a string, contrarily to lit-tag which includes the generated string inside < > so that it becomes a tag.

As in the text of the source language to be transferred, there is only one word (the common noun mentioned in the pattern), we can access its attributes by pos="1" whereas it was pos="2" in the first rule.

The 4 instructions needed to generate the analysis of the indefinite determinant have the following meaning:

Instruction	Meaning
<lit v="un">	Generate the lemma "un".
<lit-tag v="det.ind"/>	Generate a det tag followed by a ind tag, that is the text <det><ind> which makes it possible to specify that we generate a indefinite determinant.
<clip pos="1" side="tl" part="genre"/>	Get the gender of the common noun.
<clip pos="1" side="tl" part="nombre"/>	Get the number of the common noun.

The instructions to generate the translation in French of the common noun are the same ones as for the previous rule, except that now pos="1".

Interchange two words

the following part will have to be translated later

Nous allons voir à présent une règle pour changer l'ordre de deux mots lors d'une traduction.

En Esperanto, il est préconisé de mettre l'adjectif avant le nom mais ce n'est pas imposé. Le traducteur Apertium espagnol -> Esperanto conserve l'ordre des mots de la phrase espagnole alors que le traducteur Apertium French -> Esperanto met l'adjectif avant le nom.

En French, la plupart des adjectifs se placent après le nom qu'ils qualifient, mais certains adjectifs se placent avant.

La solution complète traiterait tous les cas possibles en Esperanto comme en French. Nous allons nous limiter au cas le plus fréquent en réalisant une règle qui a partir d'une forme "la" + adjectif + nom en Esperanto, fournit une traduction du type "le/la/les" + nom + adjectif en French.

Rajout dans la section def-cats

Dans cette section, nous allons rajouter une catégorie pour les adjectifs :

    <def-cat n="adj">
      <cat-item tags="adj.*"/>
    </def-cat>

Rajout dans la section def-attrs

Dans les types de mots, on rajoute les adjectifs :

    <def-attr n="type_mot">
      <attr-item tags="n"/>
      <attr-item tags="det"/>
      <attr-item tags="adj"/>
    </def-attr>

Rajout de la règle qui va intervertir l'adjectif et le nom

    <rule>
      <pattern>
        <pattern-item n="det"/>
        <pattern-item n="adj"/>
        <pattern-item n="nom_commun"/>
      </pattern>

      <action>
        <out>
          <lu>
            <clip pos="1" side="tl" part="lem"/>
            <clip pos="1" side="tl" part="type_mot"/>
            <lit-tag v="def"/>
            <clip pos="3" side="tl" part="genre"/>
            <clip pos="3" side="tl" part="nombre"/>
          </lu>
          <b />
          <lu>
            <clip pos="3" side="tl" part="lem"/>
            <clip pos="3" side="tl" part="type_mot"/>
            <clip pos="3" side="tl" part="genre"/>
            <clip pos="3" side="tl" part="nombre"/>
          </lu>
          <b />
          <lu>
            <clip pos="2" side="tl" part="lem"/>
            <clip pos="2" side="tl" part="type_mot"/>
            <clip pos="3" side="tl" part="genre"/>
            <clip pos="3" side="tl" part="nombre"/>
          </lu>
        </out>
      </action>
    </rule>

On constate dans cette règle qu'on génère d'abord le déterminant (pos = 1), puis le nom (pos = 3 dans le pattern) et enfin l'adjectif (pos = 2 dans le pattern). Pour intervertir deux mots, il a suffit de générer les lexical units <lu>...</lu> dans un ordre différent.

Dans cette règle, le déterminant et l'adjectif s'accordent en genre et en nombre avec le nom.

Changer des attributs en fonction de conditions

A présent, nous allons examiner une règle permettant de traduire un pronom personnel suivi d'un verbe en appliquant les règles de conjugaison.

Recherche des modifications à apporter

• En Esperanto, le verbe est invariant par rapport au pronom personnel qui le précède (ou plus généralement par rapport au sujet)
• En French, le verbe s'accorde avec la personne et le nombre du pronom personnel (mais pas son genre)

De plus, certains pronoms personnel du French n'ont pas d'équivalent spécifique en Esperanto qui sur ce point est comme l'anglais :

• tu (2ème personne du singulier) et vous (2ème personne du pluriel) en French sont tous deux traduits par vi en Esperanto.
• ils et elles (les formes masculines et féminines de la 3ème personne du pluriel) sont traduites par ili en Esperanto.

pour passer de l'Esperanto au French, on fera donc des choix :

• vi → vous 2ème personne du pluriel ou forme de politesse pour s'adresser à une seule personne
• ili → ils on choisit le masculin pour la 3ème personne du pluriel en French.

De même, l'Esperanto ne dispose que d'un temps pour le passé là où le French en a quatre. En plus, dans une analyse, les dictionnaires Esperanto et French n'utilisent pas la même abréviation pour le présent de l'indicatif. Il faudra donc changer tout ça lors de la traduction.

Nous allons voir ce que tout cela donne pour le verbe kanti → chanter conjugué au présent de l'indicatif.

Esperanto	Esperanto analyzes	Esperanto analyzes traduite	L'analyse qu'on voudrait	French
mi kantas	^prpers<prn><subj><p1><mf><sg>$ ^kanti<vbtr_ntr><pres>$	^prpers<prn><p1><mf><sg>$ ^chanter<vblex><pres>$	^prpers<prn><p1><mf><sg>$ ^chanter<vblex><pri><p1><sg>$	je chante
vi kantas	^prpers<prn><subj><p2><mf><sp>$ ^kanti<vbtr_ntr><pres>$	^prpers<prn><p2><mf><sp>$ ^chanter<vblex><pres>$	^prpers<prn><p2><mf><pl>$ ^chanter<vblex><pri><p2><pl>$	tu chantes → vous chantez
li kantas	^prpers<prn><subj><p3><m><sg>$ ^kanti<vbtr_ntr><pres>$	^prpers<prn><p3><m><sg>$ ^chanter<vblex><pres>$	^prpers<prn><p3><m><sg>$ ^chanter<vblex><pri><p3><sg>$	il chante
ŝi kantas	^prpers<prn><subj><p3><f><sg>$ ^kanti<vbtr_ntr><pres>$	^prpers<prn><p3><f><sg>$ ^chanter<vblex><pres>$	^prpers<prn><p3><f><sg>$ ^chanter<vblex><pri><p3><sg>$	elle chante
ni kantas	^prpers<prn><subj><p1><mf><pl>$ ^kanti<vbtr_ntr><pres>$	^prpers<prn><p1><mf><pl>$ ^chanter<vblex><pres>$	^prpers<prn><p1><mf><pl>$ ^chanter<vblex><pri><p1><pl>$	nous chantons
vi kantas	^prpers<prn><subj><p2><mf><sp>$ ^kanti<vbtr_ntr><pres>$	^prpers<prn><p2><mf><sp>$ ^chanter<vblex><pres>$	^prpers<prn><p2><mf><pl>$ ^chanter<vblex><pri><p2><pl>$	vous chantez
ili kantas	^prpers<prn><subj><p3><mf><pl>$ ^kanti<vbtr_ntr><pres>$	^prpers<prn><p3><mf><pl>$ ^chanter<vblex><pres>$	^prpers<prn><p3><m><pl>$ ^chanter<vblex><pri><p3><pl>$	ils chantent (elles chantent)

Écriture de la règle de transfer

Rajouts dans la section def-cats

Dans cette section, nous allons rajouter une catégorie pour les pronoms et une catégorie pour les verbes :

    <def-cat n="prn">
      <cat-item tags="prn.*"/>
    </def-cat>

    <def-cat n="verbe">
      <cat-item tags="vbser.*"/>
      <cat-item tags="vblex.*"/>
      <cat-item tags="vbtr.*"/>
      <cat-item tags="vbntr.*"/>
      <cat-item tags="vbtr_ntr.*"/>
    </def-cat>

Comme il existe en Esperanto plusieurs formes pour les verbes, on a mis plusieurs cat-item pour les énumérer toutes.

Rajouts dans la section def-attrs

En ce qui concerne les verbes, différents mots clés sont utilisés en Esperanto, alors qu'en French, presque tous les verbes sont classés vblex.

Dans les types de mots, on rajoute les verbes (plusieurs possibilités) et les pronoms :

    <def-attr n="type_mot">
      .......... (ce qu'il y avait avant)
      <attr-item tags="prn"/>
      <attr-item tags="vblex"/>
      <attr-item tags="vbmod"/>
      <attr-item tags="vbser"/>
      <attr-item tags="vbhaver"/>
    </def-attr>

On rajoute aussi les 2 categories personne et temps pour la conjugaison des verbes:

    <def-attr n="personne">
      <attr-item tags="p1"/>
      <attr-item tags="p2"/>
      <attr-item tags="p3"/>
    </def-attr>

    <def-attr n="temps">
      <attr-item tags="pres"/>
      <attr-item tags="past"/>
      <attr-item tags="pri"/>
      <attr-item tags="pii"/>
      <attr-item tags="fti"/>
    </def-attr>

Avant d'écrire la section rules, certaines transformations sont nécessaires pour le temps des verbes et pour le genre et le nombre des pronoms.

Transformation du temps

Pour cet example, on se limitera aux temps de l'indicatif.

En Esperanto, il y a 3 temps pour l'indicatif :

• le passé : past
• le présent : pres
• le futur : fti

En French, il y a 6 temps plus ou moins courants pour l'indicatif :

• l'imparfait :pii
• le passé simple : ifi
• le passé composé qu'il faudrait fabriquer avec le verbe avoir + le participe passé.
• le plus que parfait (même problème que pour le passé composé)
• le présent : pri
• le futur : fti

Pour les verbes au futur, l'attribut fti peut être conservé sans changement

Pour les verbes au présent, il faudra remplacer l'attribut pres de l'Esperanto par pri.

Pour les verbes au passé, le passé composé serait pas mal pour une traduction, mais moins facile à générer. On va pour cet example remplacer l'attribut past de l'Esperanto par pii (imparfait).

Sous forme algorithmique, cela donne les transformations conditionnelles suivantes :

 SI temps = "pres" ALORS
     temps <- "pri"
 SINON SI temps = "past" ALORS
     temps <- "pii"
 FIN SI

Transformation des attributs du pronom

Pour le pronom, on fera les changements suivants :

 SI personne = "p2" ALORS
     nombre <- "pl"
 SINON SI (personne = "p3" ET nombre = "pl" ALORS
     genre <- "m"
 FIN SI

Section rules

La nouvelle règle a le contenu suivant :

    <rule>
      <pattern>
        <pattern-item n="prn"/>
        <pattern-item n="verbe"/>
      </pattern>

      <action>

        <choose>
          <when>
            <test>
               <equal>
                  <clip pos="2" side="sl" part="temps"/>
                  <lit-tag v="pres"/>
                </equal>
            </test>
            <let>
              <clip pos="2" side="tl" part="temps"/>
              <lit-tag v="pri"/>
            </let>
          </when>
          <when>
            <test>
               <equal>
                  <clip pos="2" side="sl" part="temps"/>
                  <lit-tag v="past"/>
                </equal>
            </test>
            <let>
              <clip pos="2" side="tl" part="temps"/>
              <lit-tag v="pii"/>
            </let>
          </when>
        </choose>

        <choose>    <!--  cas particuliers de transfers des pronoms  -->
          <when>    <!--  2ème personne toujours au pluriel : vi -> vous  -->
            <test>
               <equal>
                  <clip pos="1" side="sl" part="personne"/>
                  <lit-tag v="p2"/>
                </equal>
            </test>
            <let>
              <clip pos="1" side="tl" part="nombre"/>
              <lit-tag v="pl"/>
            </let>
          </when>
          <when>    <!--  3ème personne du pluriel toujours au masculin : ili -> ils  -->
            <test>
               <and>
                 <equal>
                    <clip pos="1" side="sl" part="personne"/>
                    <lit-tag v="p3"/>
                  </equal>
                 <equal>
                    <clip pos="1" side="sl" part="nombre"/>
                    <lit-tag v="pl"/>
                  </equal>
                </and>
            </test>
            <let>
              <clip pos="1" side="tl" part="genre"/>
              <lit-tag v="m"/>
            </let>
          </when>
        </choose>

        <out>
          <lu>
            <clip pos="1" side="tl" part="lem"/>
            <clip pos="1" side="tl" part="type_mot"/>
            <clip pos="1" side="tl" part="personne"/>
            <clip pos="1" side="tl" part="genre"/>
            <clip pos="1" side="tl" part="nombre"/>
          </lu>
          <b />
          <lu>
            <clip pos="2" side="tl" part="lem"/>
            <clip pos="2" side="tl" part="type_mot"/>
            <clip pos="2" side="tl" part="temps"/>
            <clip pos="1" side="tl" part="personne"/>
            <clip pos="1" side="tl" part="nombre"/>
          </lu>
        </out>
      </action>
    </rule>

Pour la première fois, la partie action de la règle ne se limite pas à un bloc <out>...</out>, mais commence par deux blocs choose ayant chacun la structure suivante :

        <choose>
          <when>
            <test>
               .... (une condition)
            </test>
            <let>
               .... (action si cette condition est réalisée)
            </let>
          </when>
          <when>
            <test>
               .... (condition alternative à la précédente)
            </test>
            <let>
               .... (action si la condition alternative est réalisée)
            </let>
          </when>
        </choose>

Examinons en détail le premier bloc <when>...</when>

          <when>
            <test>
               <equal>
                  <clip pos="2" side="sl" part="temps"/>
                  <lit-tag v="pres"/>
                </equal>
            </test>
            <let>
              <clip pos="2" side="tl" part="temps"/>
              <lit-tag v="pri"/>
            </let>
          </when>

Nous commençons par l'intérieur des balises, puis on remontera vers les balises englobantes.

Instruction	Meaning
<clip pos="2" side="sl" part="temps"/>	Récupère l'attribut "temps" du 2ème mot concerné par la règle (c'est à dire le verbe) du coté source language
<lit-tag v="pres"/>	Génère une balise pres
<equal>...</equal>	Vérifie si'il y a égalité entre les 2 valeurs précédentes
<test>...</test>	Décide si on doit exécuter le bloc d'instruction placé juste après.

Ensuite, voici ce qui est fait lorsque la condition du test est vérifiée :

Instruction	Meaning
<clip pos="2" side="tl" part="temps"/>	Récupère (ou accède à) l'attribut "temps" du 2ème mot concerné par la règle (c'est à dire le verbe) du coté target language
<lit-tag v="pri"/>	Génère une balise pri
<let>...</let>	Semble correspondre à une affectation de la 2ème valeur dans la première

De la même manière, le deuxième bloc <when>...</when>

          <when>
            <test>
               <equal>
                  <clip pos="2" side="sl" part="temps"/>
                  <lit-tag v="past"/>
                </equal>
            </test>
            <let>
              <clip pos="2" side="tl" part="temps"/>
              <lit-tag v="pii"/>
            </let>
          </when>

teste si le temps du verbe correspond au passé ("past") et dans ce cas lui donne la valeur "pii" pour la target language.

Dans les instructions conditionnelles qui concernent le pronom, on trouve un bloc test plus compliqué :

            <test>
               <and>
                 <equal>
                    <clip pos="1" side="sl" part="personne"/>
                    <lit-tag v="p3"/>
                  </equal>
                 <equal>
                    <clip pos="1" side="sl" part="nombre"/>
                    <lit-tag v="pl"/>
                  </equal>
                </and>
            </test>

à l'intérieur du bloc <and>...</and>, il y a deux blocs <equal>...</equal> (il pourrait y en avoir davantage) et la condition est vraie si des deux égalités sont vérifiées simultanément : dans le cas présent "p3" pour l'attribut personne et "pl" pour l'attribut nombre.

Dans d'autres règles, on pourrait aussi trouver des blocs <or>...</or> pour lesquels la condition est vraie si au moins l'une des conditions présentes dans le bloc l'est.

De même, il existe des balises <not> et </not> pour prendre l'opposé d'une condition. Si deux choses qu'on compare doivent être différentes, on écrira :

     <not>
       <equal>
          ......
       </equal>
     </not>

Pour terminer, on pourrait se demander si les deux blocs choose de la règle qu'on vient d'étudier pourrait être regroupés en un seul.

Un essai montre que non. Lorsqu'à l'intérieur d'un bloc <choose>...</choose> on trouve plusieurs blocs <when>...</when>, le premier de ces blocs pour lequel la condition est réalisée voit les instructions du bloc <let>...</let> exécutées, et ensuite, les autres blocs <when>...</when> qui suivent ne sont pas traités. Les différents tests à l'intérieur des blocs <when>...</when> concernent des conditions exclusives que l'on traduit en langage algorithmique par SINON SI. Il existe d'ailleurs la possibilité de mettre un bloc <otherwise>...</otherwise> pour préciser ce qui doit être fait lorsqu'aucune des conditions des différents blocs <when>...</when> n'est réalisée. Ce qui correspond en langage algorithmique au mot-clé SINON.

La fin de la règle :

       ......
        <out>
          <lu>
            <clip pos="1" side="tl" part="lem"/>
            <clip pos="1" side="tl" part="type_mot"/>
            <clip pos="1" side="tl" part="personne"/>
            <clip pos="1" side="tl" part="genre"/>
            <clip pos="1" side="tl" part="nombre"/>
          </lu>
          <b />
          <lu>
            <clip pos="2" side="tl" part="lem"/>
            <clip pos="2" side="tl" part="type_mot"/>
            <clip pos="2" side="tl" part="temps"/>
            <clip pos="1" side="tl" part="personne"/>
            <clip pos="1" side="tl" part="nombre"/>
          </lu>
        </out>
      </action>
    </rule>

ne présente pas de nouvelle difficulté de compréhension. On va envoyer en sortie deux lexical units correspondants chacune à la traduction of a word, et pour le faire, on va utiliser les nouvelles valeurs des attributs que l'on a modifiés.

N'écrire qu'une fois des traitements communs à plusieurs règles

Après avoir écrit une règle pour un pronom personnel suivi d'un verbe, nous allons en rajouter 2 autres pour un nom (sujet dans la phrase) suivi d'un verbe et pour un article (déterminant), suivi d'un nom (sujet), puis d'un verbe.

Une première nouveauté est qu'on ne va pas se contenter de chercher des groupes de mots (déterminant, nom, verbe, adjectif, ...) mais qu'on rajoute une contrainte : le nom doit faire partie du sujet de la phrase. En Esperanto, un nom qui sert de sujet n'est pas terminé par la lettre n et dans son analyse, on trouvera la balise <nom> (nominatif) alors que pour un complément d'objet, on a la balise <acc> (accusatif).

Par ailleurs, les deux nouvelles règles ont un point commun avec la règle précédente : il faudra faire des transformations sur le temps du verbe qui ne s'écrit pas pareil dans tous les cas en Esperanto et en French. Mais cette transformation va être le même dans toutes les règles comprenant un verbe conjugué. Donc, autant ne l'écrire qu'à un seul endroit et l'utiliser autant de fois que nécessaire. Outre l'économie de code, un seul exemplaire sera plus facile à compléter pour rajouter les temps du conditionnel et du subjonctif ou n'importe quelle autre correction. En programmation, on utilise des fonctions pour définir des morceaux de codes utilisés à plusieurs endroits du programme. Pour les transfer rules, ce sont des macros.

Définition d'un type de mot avec des attributs

Pour définir un nom possédant l'attribut <nom> dans ses balises, il suffit de rajouter une catégorie :

    <def-cat n="nom_sujet">
      <cat-item tags="n.*.nom"/>
    </def-cat>

La page Introduction aux transfer rules précise que le .* lorsqu'il n'est pas placé à la fin signifie "une seule balise". C'est la cas pour les analyses de la plupart des noms Esperanto qui n'ont pas de genre. Toutefois, il semble que cette définition fonctionne aussi avec 2 balises entre le n et le <nom>. Sinon, au pire, pour les noms possédant un genre (humains et animaux), on pourrait rajouter un deuxième cat-item :

      <cat-item tags="n.*.*.nom"/>

pour spécifier 2 balises intermédiaires.

Écriture d'une macro

Maintenant, nous allons mettre dans une macro les opérations nécessaires au transfer du temps d'un verbe. Comme c'est notre première macro, il va falloir créer la section def-macros (qui est une section facultative) avec le contenu suivant :

  <section-def-macros>
    <def-macro n="set_temps" npar="1">    <!--  concordance des temps  -->
      <choose>
        <when>
          <test>
             <equal>
                <clip pos="1" side="sl" part="temps"/>
                <lit-tag v="pres"/>
              </equal>
          </test>
          <let>
            <clip pos="1" side="tl" part="temps"/>
            <lit-tag v="pri"/>
          </let>
        </when>
        <when>
          <test>
             <equal>
                <clip pos="1" side="sl" part="temps"/>
                <lit-tag v="past"/>
              </equal>
          </test>
          <let>
            <clip pos="1" side="tl" part="temps"/>
            <lit-tag v="pii"/>
          </let>
        </when>
      </choose>
    </def-macro>
  </section-def-macros>

La seule vrai nouveauté est l'instruction : <def-macro n="set_temps" npar="1"> :

Elle contient 2 informations :

Paramètre	Meaning
n="set_temps"	le nom qu'on donne à la macro
npar="1"	le nombre de paramètres de la macro

Ensuite, le code est identique à celui qu'on avait écrit pour la règle pronom personnel + verbe, à part que dans cette règle, on précisait pos="2" (le verbe était le 2ème mot du pattern), alors qu'ici, on a pos="1" qui est le numéro du paramètre de la macro. Or cette macro n'a besoin que d'un paramètre de type verbe pour fonctionner.

Règles de transfer utilisant la macro

Voyons donc comment est utilisée la macro dans la règle précédente (transformée) et les deux nouvelles règles :

    <rule>
      <pattern>
        <pattern-item n="prn"/>
        <pattern-item n="verbe"/>
      </pattern>

      <action>
        <choose>    <!--  cas particuliers de transfers des pronoms  -->
          <when>    <!--  2ème personne toujours au pluriel : vi -> vous  -->
            <test>
               <equal>
                  <clip pos="1" side="sl" part="personne"/>
                  <lit-tag v="p2"/>
                </equal>
            </test>
            <let>
              <clip pos="1" side="tl" part="nombre"/>
              <lit-tag v="pl"/>
            </let>
          </when>
          <when>    <!--  3ème personne du pluriel toujours au masculin : ili -> ils  -->
            <test>
               <and>
                 <equal>
                    <clip pos="1" side="sl" part="personne"/>
                    <lit-tag v="p3"/>
                  </equal>
                 <equal>
                    <clip pos="1" side="sl" part="nombre"/>
                    <lit-tag v="pl"/>
                  </equal>
                </and>
            </test>
            <let>
              <clip pos="1" side="tl" part="genre"/>
              <lit-tag v="m"/>
            </let>
          </when>
        </choose>

        <call-macro n="set_temps">
          <with-param pos="2"/>
        </call-macro>

        <out>
          <lu>
            <clip pos="1" side="tl" part="lem"/>
            <clip pos="1" side="tl" part="type_mot"/>
            <clip pos="1" side="tl" part="personne"/>
            <clip pos="1" side="tl" part="genre"/>
            <clip pos="1" side="tl" part="nombre"/>
          </lu>
          <b />
          <lu>
            <clip pos="2" side="tl" part="lem"/>
            <clip pos="2" side="tl" part="type_mot"/>
            <clip pos="2" side="tl" part="temps"/>
            <clip pos="1" side="tl" part="personne"/>
            <clip pos="1" side="tl" part="nombre"/>
          </lu>
        </out>
      </action>
    </rule>

    <rule>
      <pattern>
        <pattern-item n="nom_sujet"/>
        <pattern-item n="verbe"/>
      </pattern>

      <action>
        <call-macro n="set_temps">
          <with-param pos="2"/>
        </call-macro>

        <out>
          <lu>
            <lit v="un"/>
            <lit-tag v="det.ind"/>
            <clip pos="1" side="tl" part="genre"/>
            <clip pos="1" side="tl" part="nombre"/>
          </lu>
          <b />
          <lu>
            <clip pos="1" side="tl" part="lem"/>
            <clip pos="1" side="tl" part="type_mot"/>
            <clip pos="1" side="tl" part="genre"/>
            <clip pos="1" side="tl" part="nombre"/>
          </lu>
          <b />
          <lu>
            <clip pos="2" side="tl" part="lem"/>
            <clip pos="2" side="tl" part="type_mot"/>
            <clip pos="2" side="tl" part="temps"/>
            <lit-tag v="p3"/>
            <clip pos="1" side="tl" part="nombre"/>
          </lu>
        </out>
      </action>
    </rule>

    <rule>
      <pattern>
        <pattern-item n="det"/>
        <pattern-item n="nom_sujet"/>
        <pattern-item n="verbe"/>
      </pattern>

      <action>
        <call-macro n="set_temps">
          <with-param pos="3"/>
        </call-macro>

        <out>
          <lu>
            <clip pos="1" side="tl" part="lem"/>
            <clip pos="1" side="tl" part="type_mot"/>
            <lit-tag v="def"/>
            <clip pos="2" side="tl" part="genre"/>
            <clip pos="2" side="tl" part="nombre"/>
          </lu>
          <b />
          <lu>
            <clip pos="2" side="tl" part="lem"/>
            <clip pos="2" side="tl" part="type_mot"/>
            <clip pos="2" side="tl" part="genre"/>
            <clip pos="2" side="tl" part="nombre"/>
          </lu>
          <b />
          <lu>
            <clip pos="3" side="tl" part="lem"/>
            <clip pos="3" side="tl" part="type_mot"/>
            <clip pos="3" side="tl" part="temps"/>
            <lit-tag v="p3"/>
            <clip pos="2" side="tl" part="nombre"/>
          </lu>
        </out>
      </action>
    </rule>

Dans les deux premières règles correspondant aux patterns suivant :

      <pattern>
        <pattern-item n="prn"/>
        <pattern-item n="verbe"/>
      </pattern>

et

      <pattern>
        <pattern-item n="nom_sujet"/>
        <pattern-item n="verbe"/>
      </pattern>

on appelle la macro ainsi :

        <call-macro n="set_temps">
          <with-param pos="2"/>
        </call-macro>

alors que pour la dernière règle correspondant au pattern :

      <pattern>
        <pattern-item n="det"/>
        <pattern-item n="nom_sujet"/>
        <pattern-item n="verbe"/>
      </pattern>

l'appel de la macro devient :

        <call-macro n="set_temps">
          <with-param pos="3"/>
        </call-macro>

Dans chacun des 3 cas, la valeur de pos de la balise with-param correspond à la position du verbe dans le pattern. En procédant ainsi, on va transmettre à la macro toutes les informations concernant le verbe dans la source language et la target language.

Et si on voulait faire une macro avec plusieurs paramètres, il y aurait autant de balises with-param que de paramètres dans l'appel de cette nouvelle macro.

Le reste des deux dernières transfer rules n'offre pas de difficulté particulière :

• on génère l'analyse d'un déterminant accordé au nom
• puis celle du nom

comme on le faisait dans les règles qui n'avaient pas de verbe.

Ensuite, on génère l'analyse du verbe, utilisant l'attribut temps mis à jour dans la macro. Ce verbe est conjugué à la 3ème personne avec le nombre (singulier ou pluriel) du nom sujet dans la phrase.