Précédent
Nada

1) Introduction

En formalisant ce qu'est un interpréteur, ce qu'est un processus, les schémas de circulation et de référencement de l'information, la topologie des entrées/sorties, on construit un langage de base, que l'on perfectionne par étape, où à chaque étape on ajoute un nouveau concept.

2) Algèbre libre

Le premier concept est l'algèbre libre vue précédement, qui permet de définir un langage algébrique, le langage d'une algèbre libre. Par exemple, considérons l'algèbre libre engendré par <a,b,f(.),g(.,.)>. Les symboles du langage comprennent les éléments générateurs a,bet les opérateurs générateurs f,g.

On associe pour chaque symbole un poid, qui vaut par défaut 1. Cela servira pour définir un ordre d'énumération des termes, ou pour définir une façon de générer un terme au hasard.

Nous avons définie un constructreur et une méthodes : idioma, acepta :

L= idioma("<a,b,f(.),g(.,.)>") 
L.acepta("g(a,b,a)")
Crée un langage L.
Teste si "g(a,b,a)" appartient à L.

Il existe 5 autres méthodes importantes ; pour énumérer les termes dans l'ordre de leur taille, ou de leur poids, ou de poids ou de taille fixe exacte, ou d'une manière aléatoire selon les poids. Voyons qu'est-ce que l'IA peut nous proposer comme mot-clef de norme hispano-latine pour ces 5 méthodes :

Pour rester cohérent avec idioma(...) et acepta(x), je vous conseille des noms verbaux, immédiatement lisibles en espagnol, sans accent, et construits de façon régulière.

Je proposerais ce noyau :

Fonction
Méthode
Lecture
Énumérer tous les termes par taille croissante
enumera_tamano() 
énumère selon la taille
Énumérer les termes de taille exactement n
enumera_tamano(n) 
énumère ceux de taille n
Énumérer tous les termes par poids croissant
enumera_peso() 
énumère selon le poids
Énumérer les termes de poids exactement n
enumera_peso(n) 
énumère ceux de poids n
Générer un terme aléatoire
genera_azar() 
génère au hasard

Cette solution a un avantage important : les méthodes 1–4 se réduisent en réalité à deux méthodes paramétrables.

L = idioma("<a,b,f(.),g(.,.)>")    # crée le langage L

L.acepta("f(a)")    # vérifie si "f(a)" appartient à L
L.enumera_tamano()    # tous les termes, par taille croissante
L.enumera_tamano(3)    # seulement les termes de taille 3
L.enumera_peso()    # tous les termes, par poids croissant
L.enumera_peso(7)    # seulement les termes de poids 7

L.genera_azar()    # un terme aléatoire

Pourquoi enumera ?

enumera me paraît particulièrement adapté à votre norme. Le mot espagnol enumerar vient du latin enumerare. Il est donc à la fois hispanique, latin et techniquement très précis.

Il exprime mieux le concept que des traductions de termes informatiques anglais comme list, iterate, walk ou generate.

Il faut aussi distinguer énumération et génération :

  • enumera... parcourt systématiquement un ensemble de termes ;
  • genera... produit un terme selon un procédé particulier.

Pourquoi tamano ?

En espagnol ce serait normalement tamaño. Puisqu'un mot-clef informatique gagne à rester facilement saisissable sur tous les claviers, je recommande : tamano plutôt que tamaño

Cela correspond à votre principe de romanisation sans signes diacritiques.

Pour le hasard : azar plutôt que aleatorio

On pourrait écrire : L.genera_aleatorio() mais grammaticalement ce serait plutôt genera aleatoriamente ou genera un término aleatorio. Je préfère :

L.genera_azar()

parce que azar est court et signifie directement « hasard ».

Une autre possibilité très élégante serait : L.genera_caso() au sens latin de casus, ce qui arrive fortuitement, mais caso a déjà un autre sens informatique important (case). Je l'écarterais donc.

Une variante encore plus régulière

On pourrait expliciter les prépositions :

L.enumera_por_tamano()
L.enumera_de_tamano(3)

L.enumera_por_peso()
L.enumera_de_peso(7)

C'est linguistiquement très clair :
- por_tamano = ordonné selon la taille ;
- de_tamano(n) = ayant la taille n.
Mais cela introduit quatre noms de méthodes alors que deux suffisent. Pour une API compacte, je préfère donc :

acepta(x)

enumera_tamano()
enumera_tamano(n)

enumera_peso()
enumera_peso(n)

genera_azar()

Je trouve que cela commence à former un vocabulaire assez cohérent : idioma désigne le langage, acepta exprime l'appartenance, enumera parcourt systématiquement ses termes et genera en produit un.

3) Algorithme

La définition de la structure étant récurcive, elle induit sans effort des algorithmes récursifs pour générer un terme au hasard du langage, pour reconnaitre un terme du langage, et pour énumérer les termes du langage.

On définit un automate récursif qui génère les termes du langage `"<"a, b, f("."), g(".,.")">"`. L'automate est représenté par un ensemble de règles de production :

`{"⊢"a, "⊢"b, "⊢"f("."), "⊢"g(".,.")}`

Chaque élément de cet ensemble est une règle de production possible. Le symbole point désigne un terme quelconque du langage, et constitue un appel récursif de cet automate.

Cet algorithme peut fonctionner à l'envers pour reconnaitre un terme du langage. Il procède en selectionnant la règles de production qui possède le même opérateur racine que celui du terme à tester, et procède à l'unification où les "." désignent des variables libres isolées. Puis l'algorithme de reconnaissance fait des appels récurcifs pour reconnaitre chaqu'un des arguments ainsi récupéré.

Puis il peut fonctionner comme énumérateur selon la taille des termes (la taille étant le nombre d'opérateurs générateurs ou d'éléments générateurs dont il est constitués) en appliquant les règles de production dans l'ordre de leur taille.
Puis en appliquant l'algorithme de Dijkstra, il peut énumérer les termes selon leur poids (Le poids étant la sommes des poids de ses composants).

4) L'interpretation

Le second concept vue précédement, permet de piloter un système à l'aide d'un langage d'algèbre libre. Considérons par exemple le langage engendré par <a,b,f(.),g(.,.)>.

On associe à chaque symbole, une valeur ou d'une fonction d'arité égale à celle du symbole. Cela servira pour définir l'action du langage sur le système piloté.

Nous avons définie deux méthodes : interpreta, evalua :

L= idioma("<a,b,f(.),g(.,.)>")  
L.interpreta("a")
L.interpreta("f")
L.evalua("f(b)")
Crée un langage L.
La valeur qui interprète le symbole "a".
La fonction unaire qui interprète le symbole "f".
Exécute le programme "f(b)" implémenté par L.

5) Termes générateurs

La notation se complexifie en autorisant comme règle de production non seulement des éléments générateurs et des opérateurs générateur appliqué à des éléments générateurs ou a des variables isolée universelles symbolisées par un point, mais aussi en autorisant tout terme où les feuilles sont des éléments générateurs ou des variables isolée universelles, mais où les opérateurs n'apparaissent jamais avec deux arités distincts. Exemple : <a,b,f(.),g(.,f(.))> reconnait g(a,f(f(b))), mais ne reconnait pas g(a,b).

On n'autorise pas un opérateur à apparaître sous forme de deux appels d'arité distincte, pour garantire une reconnaissance simple de la syntaxe dès la première lecture. Il existe donc un espace de nom de la structure où chaque opérateur est associé à une arité.

5) Algèbre multi-sorte

Le troisième concept est l'algèbre multi-sorte qui permet d'enrichire la syntaxe en incorporant plusieurs langage algébrique, et donc plusieurs types, un type par langage algébrique.

Comme il y a plusieurs types, on utilise le nom du type pour indiquer le type de l'argument, le point désignant toujours n'importe quel élément de la structure en cours de construction. Ainsi, dans le méta-langage de définition des structure, r(A,B,.) désigne un opérateur ternaire r qui prend comme premier argument un terme du langage A, puis comme second argument un terme du langage B, puis comme troisième argument un terme quelconque de la structure, la multi-algèbre entrain d'être définie c'est à dire A∪B.

Par exemple considérons l'algèbre multisorte libre suivante : L = <a, b, f(H), g(.,L)>, H = <a, r(L)>. Elle comprend deux types L et H, et un type point qui correspond aux éléments de la structure c'est à dire à l'union de L et de H. L'algèbre multi-sorte est par définition L∪H. Mais il existe une structure mère associée qui regroupe tous les espaces de noms, <a,b,f(.),g(.,.),r(.)>

 

---- 17 novembre 2026 ----

 

 

 

L'algorithme d'énumération des termes du langage

Notre vision étant par essence récursive, on oriente notre IA dans cette vision d'un traitrement récurcif pour reconnaitre un terme du langage. On définit un automate récursif qui reconnaît les termes du langage L = <a, b, f(H), g(.,L)>, H = <a, r(L)>. L'automate comprend plusieurs sous-automates qui sont des ensembles de règles de production :

L={⊢a,⊢b,⊢f(L),⊢g(.,L)}, H={⊢a,⊢r(L)}

Chaque élément de ces ensembles est une règle de production possible. L'argument L désigne un terme quelconque du langage L, et constitue un appel récursif de ce sous-automate. L'argument H désigne un terme quelconque du langage H, et constitue un appel récursif de ce sous-automate. Le symbole point désigne un terme quelconque du langage L∪H, et constitue un appel récursif de cet automate.

6) Variables isolées

Dans ce méta-langage de définition récurcive des structures, les arguments des opértateurs sont des types et représentent des variables isolées c'est à dire, chacune quantifié universellement sur son type considéré.

 

---- 17 novembre 2026 ----

 

Le procédé de construction des algèbres fait qu'il est algorithmiquement intéressant de sintéresser au forme plus générale qu'un simple opérateurs générateurs appliqué à des variables isolées. On considère alors des termes générateurs, en donnant toujours des noms d'opérateurs appartenant à l'espace de noms courts associé au type.

Dans l'exemple L=<a, g(H,f(L))>, H=<a, g(f(H),H)>, l'espace de noms-courts de L est {a,g,f}

 

 

 

 

 

 

 

 

Pour des raisons évidentes de lisibilité, chaque sous-structure L et H a son propre espace de noms, faisant que l'élément a dans L est distinct de l'élément a dans H, et de même pour l'opérateur f. Le nom complet de l'élément générateur a est L.a ou H.a selon son type, et H.a ≠ L.a car la structure est libre. Dans une structure libre, deux termes distincts où les opérateurs générateurs sont désignés par leur nom complet désignent nécessairement deux éléments distincts de la structure.

L'algèbre multi-sorte libre est une partie de l'algèbre englobante libre :

(L∪H) ⊆ <L.a, L.b, L.f(.), L.g(.,.), H.a, H.f(.)>

On étend le constructeur idioma pour qu'il puissent construire les algèbres multi-sortes.

S= idioma("L=<a,b,f(H),g(.,L)>", "H=<a,f(L)>") 
Crée un langage algébrique avec deux types disjoints L et H.

 

 

 

au cas où les éléments générateurs et opérateurs générateurs peuvent être commun à plusieurs types.

 

 

5)

et deux écritures semblent pertinentes. Soit on écrit les générateurs avec leur nom complet, soit on définit chaque type avec son espace de nom.

S= idioma("L=<a,b,f(H),g(.,L)>", "H=<a,f(L)>") 
Crée un langage avec deux types L et H.
S= idioma("<L.a,L.b,L.f(.),L.g(.,.),H.a,H.f(.)>") Crée un langage typé par L et H.

Les crochets délimite un espace de nom c'est à dire définisse un type. Tandis que la désignation comme attribut d'un type, précise de quel type est le symbole c'est à dire à quel espace de nom appartient ce symbole.

4.1) Types

La notation se complexifie en autorisant l'imbrication de ces deux notations. Exemple : Considérons l'algèbre multisorte suivante :

L=<H.a,b,H.f(H),g(.,L)>
H=<a,b,f(L),g(H,H)>

L'élément a est de type H et également de type L puisqu'il est repris comme générateur de L. Autrement dit L.a=H.a.

Il y a deux éléments distincts b notés L.b et H.b.

L'opérateur `f` est de type L et également de type H. Autrement dit AAx, L.f(x)=H.f(x).

Il y a deux opérateurs distincts g notés L.g et H.g.

Autre exemple, l'expression A.B.C.s indiquera que le symbole s est de type C mais également de type B et également de type A. Autrement dit A.s=B.s=C.s.

Un type est un ensemble d'opérateurs ou de copies d'opérateur, mais tel qu'il n'y ait pas deux opérateurs distincts de même nom court dans le même type. En effet, l'inférence de type assure que si le type de l'opérateur est connu et vaut T, et que le nom court de l'opérateur est connu et vaut s, alors T.s désigne complétement l'opérateur en question.

Dans l'exemple suivant L=<a,f(L),g(L,L)>, H=<a,f(H),g(H,H)> le fait qu'il y est plusieurs types, c'est à dire plusieurs espaces de noms, entraine qu'une expression peut avoir plusieur sens. Une tel expression ambigüe est considérée comme une erreur de syntaxe. Dans l'exemple, f(a) n'est pas autorisé, parcontre H.f(a) ou f(H.a) sont autorisés. L'inférence de type permet alors de déterminé le type de toute expression.

4.2) Forme générale et numérotation des variables

La notation se complexifie en autorisant tout terme comme générateur et en autorisant la numérotation des variables. Jusqu'à présent, les arguments d'une fonction ne sont pas des termes mais des types qui jouent le rôle de variable. On autorise tous les termes où les feuilles sont des variables (type). Et on numérote ces variables pour les identifiées si une contrainte d'égalité existe. Cela permet de définir des diagonales. Exemple :

L = <a, b, g(L1,f(L1))>

 

5) Les syntaxes alternatives

L'usage des chaines de caractères comme stockage de données constitue un compromis pertinent entre densité des données et lisibilité par un humain.

Le termes ne sert plus seulement d'instruction, il peut ainsi constituer une donnée pour un stockage suffisament dense.

C'est pourquoi on s’intéresse à différentes syntaxe permettant de densifier le terme. Mais cela ne change pas l'arborescence des emboitements d'opérateurs. C'est un sucre syntaxique qui permet de condenser l'écriture, et qui va être utilisé davantage encore pour augmenter sa lisibilité, en permettant par exemple de mettre moins de parenthèses et de virgules.

Dans un premier temps, comme la prudence nous invite à séparer les traitements, la syntaxe alternative est utilisé que pour l'entré et la sortie des termes, le terme est mémorisé en mémoire sous sa forme décompressée. Ce n'est qu'au moment de l'affichage qu'il applique la syntaxe alternative, et au moment de la saisie qu'il interprète la syntaxe altérnative pour mémoriser le terme décompressé.

Cette syntaxe alternative s'applique identiquement à tous les opérateurs de même nom cours même s'ils sont utilisés dans des espace de noms différents. Cela permet de maintenir un controle simple de la syntaxe en une seule lecture suivi du procédé d'inférence de type lorsqu'un terme comprend des arguments de différents langages.

Cela a pour conséquence que les opérateurs de même nom court doivent avoir la même arité. Délors, l'arité des opérateurs peut être déclarée globalement selon leur noms courts.

On ajoute pour chaque nom court un argument facultatif supplémentaire qui va indiquer la syntaxe alternative. Voici les différentes syntaxes altérnatives :

Une gestion des priorités des opérateurs lève les ambiguités de la façon suivante :

  1. Les opérateurs postfixes sont prioritaires aux opérateurs préfixes et infixes.
     
  2. Les opérateurs infixes ne sont jamais à la fois d'égale priorité et de priorité de sens différent. Lorsque des opérateurs infixes d'égale priorité sont limitrophes on applique la priorité de sens qui est la même pour les deux opérateurs.

 

 

---- 16 novembre 2026 ----

 

 

 

7) Les opérateurs d'arité variable

 

 

 

 

 

 

 

 

Puis on ajoute une syntaxe alternative, la syntaxe délimité, pour les opérateurs d'arité variable. Cette syntaxe comprend un symbole de début et un symbole de fin non déjà utilisé ni utilisé comme nom d'opérateur dans un même langage. Exemple :

  Idioma( "L=<a,b,f(...)>", "H=<c,d,f(...)>", syntaxes={ "f": ("delimite", "|", "">"), } )

Dans `L` nous avons `f(a,b,a,b) = |abab>`
Dans `H` nous avons `f(c,d,c,d) = |cdcd>`

1- Une autre syntaxe délimitée peut se différentier par seulement le délimiteur de début, le délimiteur de fin étant identique dans les deux syntaxes délimitées.

2- Juste une exception, le délimiteur de début peut correspondre au nom de l'opérateur. Exemple :

     syntaxes={ "f": ("delimite", "f", ">"), "g": ("delimite", "g", ">") }

3- Juste une exception, le délimiteur de fin peut être le caractère blanc.

 

 

 

 

 

 

S.acepta("g(f(b),b)")

Teste si "g(f(b),b)" appartient à L∪H.

 

---- 15 novembre 2026 ----

 

 

 

 

 

8) Les syntaxes alternatives

adapté à l'utilisateur grace aux différentes syntaxe ; préfixe, postfixe, infixe et délimité.Une syntaxe alternative. (Par défaut c'est la syntaxe anglaise. Exemple g(x,y))

9) L'introduction des variables

Le troisième concept est celle de variable, consite à définir les variables

....

10) La notion de type

....

 

 

11) La notion de flux

Il existe de nombreuses possibilités pour enrichire le langage et en faire un langage de programmation évoluée. Mais l'une d'entre-elles prédomine largement quasi-toutes. Elle consiste à ne peut se rétreindre aux seuls valeurs d'évaluation, mais à considérer des flux de valeurs manipulables comme des simples variables.

Pour les distinguer des paramètres simple valeur, on notes les flux en majuscule. Et, ils ont deux modes possibles, synchrone ou asynchrone.

 

 

Répondre sur Communauté Reddit

 

Précédent
Nada


Dominique Mabboux-Stromberg
(Septembre 2026)