Principes de calcul

Dans ce chapitre, nous présenterons quelques principes généraux qui concernent le traitement des règles par le programme. Cela nous donnera l’occasion aussi de signaler quelques différences entre les deux versions.

Répétition des règles

Après avoir chargé un ensemble de n règles, ETYMO suit l’algorithme suivant pour les appliquer au mots :

1. Commence avec la règle x = 1

2. Tant que toutes les règles n’ont pas été traitées, répète les instructions (3) à (5)

3. Prend la règle x et vérifie la condition

4. Si la condition est remplie, applique la règle. Ensuite, répète (2) avec la même règle

5. Si la condition n’est pas remplie, répète (2) avec la règle x+1.

Chaque règle est donc appliquée autant de fois que sa condition est vraie. Cela a comme conséquence que dans un mot tel que @#ki|wi|ta|tem# la règle VtV > VdV s’applique aux deux t intervocaliques. Tandis que, dans la plupart des cas, ce principe fournit des résultats satisfaisants, il peut être problématique dans d’autres cas, notamment lorsque la règle comporte un phénomène de feeding.

Effets de feeding / bleeding

Chaque règle transforme un élément A (appelé input) en un élément B (appelé output). Lorsqu’on a plusieurs règles qui se suivent, il peut arriver que l’output de la règle x devienne l’input de la règle x+1. Ce phénomène s’appelle feeding(1).

	Rx  : x > y	l’output de Rx devient l’input de Rx+1
	Rx+1 : y > z

Tandis que le feeding entre R_x et R_x+1 rend possible l’application de R_x+1, le bleeding fait exactement l’inverse, c’est-à-dire qu’il empêche l’application de R_x+1 :

A part le feeding / bleeding, le rapport entre deux règles peut aussi être indifférent :

Lorsque ces rapports apparaissent entre deux (ou plusieurs) règles, ils peuvent être utilisés pour établir une « chronologie relative » de celles-ci(2). Il existe des cas, cependant, où des effets de feeding ou de bleeding apparaissent à l’intérieur d’une seule règle (nous parlons, dans ces cas, d’auto-feeding / auto-bleeding par opposition au trans-feeding / trans-bleeding) :

Notons que l’auto-feeding peut poser des problèmes en relation avec le principe de la répétition des règles : si on appliquait la règle e > ee au mot lem, le résultat serait lem > leem > leeem > leeeem > leeeeem .. et ainsi de suite, jusqu’à l’infini. Dans ces cas, il est donc important de créer un bleeding explicite :

      CeC > CeeC                    lem > leem

Il nous reste à signaler un cas particulier d’auto-feeding qui correspond à ce que l’on pourrait appeler la « règle zéro ». Celle-ci se caractérise par le fait qu’elle ne transforme rien, c’est-à-dire que l’input et l’output sont identiques :

En principe, une telle règle devrait créer une série infinie d’évolutions du type lem > lem > .. > lem. ETYMO, cependant, traite ces règles comme un cas particulier et ne l’applique qu’une seule fois. L’évolution zéro est notamment utilisée dans les conséquences multiples(3) :

Cette règle signifie donc que l’élément x peut SOIT ne pas évoluer SOIT passer à z.

Conséquences multiples

Selon l’algorithme de base(4), les règles sont appliquées de manière séquentielle de la première jusqu’à la dernière. Les évolutions multiples, cependant, viennent bouleverser cet ordre : du fait que seule une ligne évolutive peut être calculée à la fois, le programme est obligé de revenir plusieurs fois en arrière, afin de les calculer toutes. Voici un schéma qui peut illustrer la manière dont l’ordinateur traite ces évolutions :

Après l’application des règles r₁ .. r_x-1, le mot original m₁ s’est transformé en m_e. A ce moment, la règle r_x fait bifurquer l’évolution : elle donne naissance à n formes notées par m(1)_e+1, m(2)_e+1 .. m(n)_e+1. Le programme va maintenant continuer le calcul de la ligne L₁ en y appliquant les règles restantes. Ensuite, il va revenir en arrière pour continuer le calcul de la ligne L₂ et ainsi de suite jusqu’à atteindre la dernière ligne L_n.

Lorsque le programme reprend le calcul d’une ligne, il utilise la règle de reprise r_r qui se définit comme suit :

Etant donné que la règle de reprise peut être r_x, il faut à nouveau tenir compte des effets d’auto-feeding. Une règle telle que e > { e, ee } produirait donc des bifurcations à l’infini.

Traitement de la condition

Lors de l’exécution d’une règle, l’ordinateur doit commencer par vérifier la condition (et éventuellement le contexte) de celle-ci. Pour ce faire, il « scanne » le mot de gauche à droite jusqu’à trouver une correspondance :

     règle :        VtV > VdV

(1) k i w i t a t e     
    V t V

(2) k i w i t a t e
      V t V

(3) k i w i t a t e
        V t V

(4) k i w i t a t e
          V t V

Une fois qu’une correspondance a été trouvée, le scanning est arrêté et l’interpréteur applique la transformation décrite par la règle. Dans l’exemple susmentionné, cela signifie donc que seul un des deux t intervocaliques est remplacé par d. Le deuxième t nécessite une nouvelle application de la règle :

(1) k i w i d a t e     
            V t V

      :

(6) k i w i d a t e
              V t V

Le programme cherche donc toujours la première occurrence d’une séquence et la remplace par la séquence correspondante.

Le principe de la première occurrence, pourtant, n’est valable que pour la version MS-DOS. La version UNIX, quant à elle, remplace toutes les occurrences d’une séquence en une seule fois.

Application de la conséquence

Une fois que la position de la séquence recherchée a été déterminée à l’intérieur d’un mot m_n, le programme calcule le successeur immédiat m_n+1. Pour ce faire, il coupe le mot en trois parties :

De ces trois parties, c_n est celle qui subira la transformation tandis que i_n et f_n restent intactes c’est-à-dire que la nouvelle forme à calculer m_n+1 peut se définir comme

où T() désigne la transformation. Celle-ci se présente comme une reconstruction complète de la partie centrale. La méthode utilisée est ici la concaténation de phonèmes. Le nombre et la constitution de ces derniers dépend, pour l’essentiel, de deux facteurs : (1) de l’assignation ou de la non-assignation des jokers ou des termes, et (2) des traits supplémentaires ainsi que des frontières utilisés dans ceux-ci.

Lorsqu’un terme ou un joker est assigné, ETYMO copie le ou les phonème(s) du mot m_n. Au contraire, lorsqu’un terme n’est pas assigné (ce qui en principe ne fait sens qu’avec des termes littéraux), il insère le phonème décrit par le terme :

Après la copie ou l’insertion d’un phonème, celui-ci peut encore être modifié par des traits supplémentaires et/ou par des frontières :

Chaque transformation passe donc par ces deux phases, à savoir (1) copie ou insertion d’un phonème, et (2) modification subséquente de celui-ci.