B4) Flags et poids decrémentaux

Le contrôle dynamique

Et si une grammaire pouvait compter, se souvenir et s’épuiser toute seule ?

Où se situe cet article ?

Les articles précédents ont posé les bases : les probabilités pour le hasard contrôlé, le vocabulaire pour les briques de construction, les règles de dérivation pour les cinq modes. Mais tout cela reste statique : les poids ne bougent pas, les règles s’appliquent aveuglément. Cet article introduit les deux mécanismes qui rendent BP3 (Bol Processor 3, I2) véritablement dynamique : les flags (compteurs conditionnels) et les poids décrémentaux. Ce sont eux qui permettent de modéliser l’épuisement d’une idée musicale, la fin progressive d’un développement, ou l’exécution conditionnelle d’un passage. La formalisation s’appuie sur les configurations et règles d’inférence de la sémantique opérationnelle structurelle.

Pourquoi c’est important ?

Imaginez un musicien qui improvise sur un raga indien (un cadre mélodique prescrivant les notes, les ornements et l’atmosphère d’une pièce). Il explore un motif mélodique, le répète, le varie — puis le laisse mourir naturellement pour passer à autre chose. Ce n’est pas aléatoire : le musicien compte mentalement, décide quand un motif a été assez exploré, et contrôle la transition. C’est précisément ce type de contrôle dynamique que Bernard Bel et James Kippen ont voulu modéliser en créant les flags et les poids de BP3 [BelKippen1992a], à partir de leur observation des maîtres tablistes du gharānā de Lucknow [Kippen1988].

Une grammaire probabiliste classique (PCFG — Probabilistic Context-Free Grammar, grammaire hors-contexte probabiliste) ne sait pas faire cela. Ses probabilités sont figées : la même règle a toujours la même chance d’être choisie, que ce soit la première ou la centième fois. C’est comme un dé ordinaire : il n’a pas de mémoire.

BP3 résout ce problème avec deux mécanismes complémentaires :

Les flags : des compteurs nommés qu’on peut tester, incrémenter, décrémenter. Ils permettent de dire « applique cette règle seulement si le compteur avart (cycles restants) est supérieur à 0, et décrémente-le ».
Les poids décrémentaux : des poids qui diminuent à chaque utilisation. Ils permettent de dire « cette règle est très probable au début, mais s’épuise progressivement ».

Les flags sont des gardes logiques (oui/non), les poids décrémentaux sont des gardes probabilistes (de plus en plus improbable). Ensemble, ils donnent à BP3 une expressivité qui dépasse largement les grammaires classiques.

L’idée en une phrase

Les flags sont des compteurs conditionnels qui contrôlent l’applicabilité des règles, et les poids décrémentaux sont des probabilités qui s’érodent à chaque utilisation, permettant à BP3 de modéliser l’épuisement progressif d’un motif musical.

Expliquons pas à pas

1. Les flags : des compteurs conditionnels

Qu’est-ce qu’un flag ?

Un flag est une variable nommée, attachée à une règle de grammaire, qui sert à deux choses : conditionner l’application de la règle et modifier l’état du système après application.

Encart : L’analogie du compteur de restaurant

Imaginez un restaurant qui propose un menu spécial « 20 premières commandes à moitié prix ». Le serveur tient un compteur :

Au début : compteur = 20

À chaque commande spéciale : compteur = compteur – 1

Quand compteur = 0 : « désolé, l’offre est terminée »

Les flags de BP3 fonctionnent exactement ainsi. Le compteur avart commence à 4 (nombre de cycles de tāla à jouer), chaque cycle le décrémente, et quand il atteint 0, les variations s’arrêtent.

Syntaxe BP3

Les flags apparaissent entre barres obliques / dans les règles :

gram#1[1] /avart=4/ |S| --> |A| |S|
gram#1[2]           |S| --> -
gram#1[3] /avart/   |A| --> dha dhin dhin dha /avart-1/
gram#1[4]           |A| --> tin ta -

Cette grammaire joue 4 cycles (āvart) du theka de tintāl (dha dhin dhin dha), puis s’arrête. Quand les cycles sont épuisés, seul le motif sec (tin ta -) reste disponible. Décomposons les flags :

/avart=4/ : initialise le flag avart à 4 (nombre de cycles restants)
/avart/ : teste que le flag avart est non nul (> 0)
/avart-1/ : décrémente le flag avart de 1 après chaque cycle

Les six opérateurs

BP3 propose six opérateurs pour manipuler les flags :

Opérateur	Syntaxe BP3	Signification	Exemple
(vide)	`/avart/`	Teste si le flag est non nul (> 0)	Garde : appliquer seulement si `avart > 0`
`=`	`/avart=4/`	Assigne une valeur	Initialisation ou réinitialisation
`+`	`/cycle+1/`	Incrémente	Augmente le compteur
`-`	`/avart-1/`	Décrémente	Diminue le compteur
`>`	`/avart>2/`	Teste si strictement supérieur	Garde conditionnelle
`<`	`/phase<5/`	Teste si strictement inférieur	Garde conditionnelle

Les opérateurs se divisent en deux catégories :

Gardes (conditions) : "" (test de non-nullité), >, < — ils décident si la règle peut s’appliquer
Effets (opérations) : = , +, - — ils modifient l’état après application

Le noeud AST Flag

Dans l’AST (arbre de syntaxe abstraite — voir L4) du transpileur (compilateur source-à-source — voir B7) BP2SC (Bol Processor to SuperCollider), un flag est représenté par le noeud :

@dataclass
class Flag:
    name: str                    # "avart", "phrase", "reprise"
    op: str = ""                 # "", "=", "+", "-", ">", "<"
    value: str | None = None     # "20", "1", None (pour le test simple)

Le champ op est une chaîne vide pour le test de non-nullité (le cas /avart/ sans opérateur explicite). Le champ value est None quand aucune valeur n’est nécessaire (test simple).

Règle SOS : Flag-Cond

La sémantique formelle des flags s’exprime comme une règle d’inférence en SOS. Une configuration inclut désormais un environnement de flags φ (phi) qui associe chaque nom de flag à sa valeur entière courante.

Encart : Rappel SOS

En sémantique opérationnelle structurelle (SOS), on décrit le comportement d’un programme par des règles d’inférence de la forme :
    prémisse(s)
─────────────────── (Nom-Règle)
    conclusion

La conclusion ne s’applique que si toutes les prémisses sont satisfaites. Les configurations (σ, φ, t) représentent : la chaîne de travail σ (sigma), l’environnement de flags φ, et le temps t.

Voici la règle Flag-Cond pour un flag conditionnel avec décrément :

φ(avart) > 0    r = (/avart/ A → β /avart-1/)
─────────────────────────────────────────────────────── (Flag-Cond)
(σ₁ . A . σ₂, φ, t) ⟹ (σ₁ . β . σ₂, φ[avart ↦ φ(avart) - 1], t)

Lecture de cette règle :

Prémisse 1 : la valeur courante du flag avart dans l’environnement φ est strictement positive
Prémisse 2 : il existe une règle r qui a pour garde /avart/ et pour effet /avart-1/
Conclusion : on remplace A par β (bêta, le membre droit de la règle) dans la chaîne de travail, et on met à jour l’environnement en décrémentant avart de 1

La notation φ[avart ↦ φ(avart) - 1] signifie « le même environnement φ, sauf que la valeur de avart est remplacée par sa valeur actuelle moins 1 ». C’est une mise à jour fonctionnelle : l’ancien environnement n’est pas modifié, on en crée un nouveau.

Que se passe-t-il quand le flag atteint 0 ?

La prémisse φ(avart) > 0 n’est plus satisfaite. La règle ne peut plus s’appliquer. Si une autre règle pour le même non-terminal (symbole qui peut encore être dérivé, noté entre barres |A| en BP3 — voir B2) existe sans garde (comme la règle 4 dans notre exemple), c’est elle qui prend le relais. Sinon, la dérivation se bloque.

2. Les poids décrémentaux

Qu’est-ce qu’un poids décrémental ?

Un poids décrémental est un poids de règle (comme ceux vus dans B1) qui diminue à chaque fois que la règle est choisie. La notation BP3 est <N-M> : poids initial N, décrémenté de M à chaque utilisation.

Encart : L’analogie du soliste qui se lasse

Imaginez une jam session. Au début, un musicien lève la main à chaque tour pour prendre un solo — il est enthousiaste, presque certain d’être choisi (probabilité haute). Mais à chaque solo joué, son envie diminue : il lève la main moins souvent (probabilité basse), puis finit par rester assis (probabilité nulle). Le musicien est toujours là, et s’il était choisi il jouerait aussi bien qu’avant — mais il ne se propose plus.

C’est exactement ce que fait un poids décrémental : la règle produit toujours le même résultat quand elle est choisie, mais sa probabilité d’être choisie diminue jusqu’à atteindre zéro.

Syntaxe BP3

gram#1[1] |S| --> <50-12> |A| |S|
gram#1[2] |S| --> <1> fin

<50-12> : poids initial 50, décrémenté de 12 à chaque utilisation
<1> : poids fixe 1 (pas de décrément)

Le noeud AST Weight

@dataclass
class Weight:
    value: int                   # 50 (poids initial)
    decrement: int | None = None # 12 (décrément par utilisation), None si fixe

Quand decrement est None, le poids est statique (comme dans une PCFG classique). Quand il est défini, le poids évolue dynamiquement.

Règle SOS : Weight-Dec

Formalisons la sémantique des poids décrémentaux. La configuration s’enrichit d’une fonction de poids w qui associe à chaque règle son poids courant :

Soit w la fonction de poids, initialement w(r) = 50
Règle r choisie selon distribution catégorielle sur w
────────────────────────────────────────────────────── (Weight-Dec)
(σ, φ, t, w) ⟹ (σ', φ, t, w[r ↦ max(0, w(r) - 12)])

Lecture :

La règle r est choisie selon une distribution catégorielle (tirage pondéré) basée sur les poids courants
Après application, le poids de r est diminué de 12, avec un plancher à 0 (le poids ne devient jamais négatif)
Les flags φ et le temps t ne sont pas affectés

Encart : Distribution catégorielle

Une distribution catégorielle (aussi appelée distribution de Gibbs discrète) est la généralisation du lancer de dé à un nombre quelconque de faces avec des probabilités arbitraires. Si on a trois règles avec des poids [50, 10, 1], les probabilités sont :

P(règle 1) = 50 / (50 + 10 + 1) = 82%

P(règle 2) = 10 / 61 = 16%

P(règle 3) = 1 / 61 = 2%

Le point clé : les probabilités sont recalculées à chaque étape, car les poids changent. Ce n’est pas un calcul fait une seule fois, mais un recalcul permanent. C’est cette renormalisation continue qui distingue les poids décrémentaux d’une PCFG.

Evolution des probabilités : un exemple concret

Reprenons l’exemple :

gram#1[1] |S| --> <50-12> |A| |S|
gram#1[2] |S| --> <1> fin

Utilisation	Poids de r1	Poids de r2	P(continuer)	P(finir)
1	50	1	98.0%	2.0%
2	38	1	97.4%	2.6%
3	26	1	96.3%	3.7%
4	14	1	93.3%	6.7%
5	2	1	66.7%	33.3%
6	0	1	0.0%	100.0%

Observons le profil : les quatre premières utilisations sont quasi certaines (la règle récursive domine largement). Puis la cinquième utilisation bascule brutalement — la probabilité de continuer chute à 67%. Et à la sixième, la règle récursive est morte : le poids est tombé à 0.

Convergence et terminaison garantie : contrairement à une PCFG pure où la récursion peut théoriquement durer indéfiniment, les poids décrémentaux garantissent la terminaison. En au plus ceil(N/M) + 1 utilisations (ici ceil(50/12) + 1 = 6), la règle récursive atteint un poids de 0 et ne peut plus être choisie. C’est une propriété fondamentale pour la musique : le compositeur sait que son motif aura une longueur bornée.

Encart : Poids décrémentaux vs flags

Les deux mécanismes contrôlent la terminaison, mais de manière différente :

Aspect Flags Poids décrémentaux

Type de contrôle Logique (oui/non) Probabiliste (graduel)

Transition Brutale (actif -> inactif) Progressive (de probable à impossible)

Analogie musicale « Stop après 20 notes » « L’idée s’estompe naturellement »

Expressivité Structures déterministes Structures organiques

>
Les flags sont des interrupteurs, les poids décrémentaux sont des gradateurs.

Aspect	Flags	Poids décrémentaux
Type de contrôle	Logique (oui/non)	Probabiliste (graduel)
Transition	Brutale (actif -> inactif)	Progressive (de probable à impossible)
Analogie musicale	« Stop après 20 notes »	« L’idée s’estompe naturellement »
Expressivité	Structures déterministes	Structures organiques

3. Interactions flags et modes

Les flags interagissent de manière riche avec les cinq modes de dérivation. Les deux combinaisons les plus importantes sont RND + flags et ORD + flags.

RND avec flags : choix conditionnel

En mode RND (aléatoire pondéré — voir les cinq modes dans B3), les flags transforment le choix aléatoire en choix conditionnel : la règle n’est éligible que si ses gardes sont satisfaites.

-mo.RND
gram#1[1] /avart=8/ |S| --> |A| |S|
gram#1[2] /avart/   |A| --> dha dhin dhin dha /avart-1/
gram#1[3]           |A| --> tin ta -

Le flag /avart=8/ initialise un compteur à 8. Tant que avart > 0, la règle 2 est éligible et décrémente le compteur. Quand il atteint 0, seule la règle 3 (sans garde) reste disponible. Le transpileur BP2SC traduit cette combinaison en un Prout SuperCollider — voir la traduction détaillée dans B8 §1.

ORD avec flags : exécution conditionnelle séquentielle

En mode ORD (séquentiel), les flags permettent un contrôle déterministe : les règles sont essayées dans l’ordre, mais seulement si leurs gardes sont satisfaites. C’est l’équivalent d’une cascade de if/else if/else.

-mo.ORD
gram#1[1] /reprise=1/ |S| --> |A| |S|
gram#1[2]             |S| --> -
gram#1[3] /reprise>0/ |A| --> dha dhin /reprise-1/
gram#1[4]             |A| --> tin ta

Ici, le flag reprise contrôle si la règle 3 est disponible. Une fois reprise décrémenté à 0, la règle 4 (sans garde) prend le relais. En mode ORD, cette logique est purement séquentielle et déterministe.

Poids décrémentaux en mode RND

Les poids décrémentaux en mode RND sont traduits en SC par un Prout avec des variables de poids locales mutables et une sélection pondérée recalculée à chaque itération :

-mo.RND
gram#1[1] |S| --> <50-12> |A| |S|
gram#1[2] |S| --> <1> fin

À chaque itération, un tirage aléatoire est fait sur le total des poids courants. Le poids de la règle 1 diminue de 12 à chaque utilisation (borné à 0), tandis que le poids fixe de la règle 2 ne bouge pas — il finit par dominer. Voir la traduction SuperCollider détaillée dans B8 §1.

4. Exemples concrets

Exemple 1 : Mohanam — le raga à épuisement contrôlé

Le raga Mohanam est un raga pentatonique (à cinq notes) indien (Sa Ri Ga Pa Dha) utilisé dans de nombreuses compositions carnatiques (tradition classique du sud de l’Inde). Voici comment BP3 peut modéliser l’exploration progressive puis l’épuisement d’un motif :

-al.Mohanam
Sa Ri Ga Pa Dha

-mo.RND
gram#1[1] /phrase=20/ |S| --> |Phrase| |S|
gram#1[2]             |S| --> |Cadence|
gram#1[3] /phrase/    |Phrase| --> |Motif| |Motif| /phrase-1/
gram#1[4]             |Phrase| --> |Repos|
gram#1[5]             |Motif|  --> Sa Ri Ga
gram#1[6]             |Motif|  --> Pa Dha Pa
gram#1[7]             |Motif|  --> Ga Ri Sa
gram#1[8]             |Repos|  --> - - -
gram#1[9]             |Cadence| --> Dha Pa Ga Ri Sa

Analyse du comportement :

Le flag phrase commence à 20. Tant qu’il est positif, les phrases contiennent des motifs mélodiques (règle 3). Chaque phrase décrémente phrase de 1.
Quand phrase atteint 0, la règle 3 cesse de s’appliquer. Seule la règle 4 reste : des repos.
Finalement, la récursion de |S| finit par choisir la règle 2 (la cadence finale).

Le résultat musical : une exploration active pendant environ 20 phrases, puis un ralentissement avec des silences, puis une cadence conclusive. C’est un modèle de l’alapana (exploration introductive) d’un raga.

Encart : Vādi et samvādi — les notes dominantes du raga

Dans le raga Mohanam (Sa Ri Ga Pa Dha), les notes n’ont pas toutes le même poids. La note vādi (note dominante, la plus importante) est Pa et la note samvādi (note sous-dominante) est Sa. Un flag pourrait modéliser cette hiérarchie :
gram#1[10] /vadi/ |Motif| --> Pa |Ornement| Pa /vadi-1/

Le flag /vadi/ garantirait que Pa (la vādi) apparaisse régulièrement dans la mélodie — exactement comme un musicien indien revient naturellement vers la note dominante du raga. Cette contrainte structurelle, impossible dans une PCFG classique, est au cœur de ce que Bel et Kippen ont cherché à formaliser [BelKippen1992a].

Encart : L’ālāp — quand les flags atteignent leurs limites

L’ālāp (ouverture d’un raga où les notes sont introduites progressivement : d’abord Sa seul, puis Sa-Re, puis Sa-Re-Ga…) pose un défi intéressant. Peut-on le modéliser avec des flags ? Oui, mais laborieusement :
gram#1[1] /phase=1/ |Phrase| --> Sa Sa Sa /phase+1/
gram#1[2] /phase=2/ |Phrase| --> Sa Re Sa Re /phase+1/
gram#1[3] /phase=3/ |Phrase| --> Sa Re Ga Re Sa /phase+1/
gram#1[4] /phase=4/ |Phrase| --> Sa Re Ga Ma Ga Re Sa /phase+1/

Cela fonctionne, mais il faut une règle par note introduite — on énumère les cas au lieu de les générer. L’ālāp révèle que les flags sont des compteurs, pas des accumulateurs : ils savent combien de notes ont été introduites, mais pas lesquelles. Pour une solution plus élégante, les marqueurs de contexte de B6 permettent d’écrire « joue cette note seulement si les notes précédentes sont déjà présentes » — une contrainte d’accumulation que seules les extensions context-sensitive de BP3 peuvent exprimer naturellement.

Exemple 2 : épuisement progressif avec poids décrémentaux

Visualisons l’évolution des probabilités pour une grammaire plus riche :

gram#1[1] |S| --> <40-8>  |Thème| |S|
gram#1[2] |S| --> <10-2>  |Variation| |S|
gram#1[3] |S| --> <1>     |Coda|

Étape	w(Thème)	w(Variation)	w(Coda)	P(Thème)	P(Variation)	P(Coda)
1	40	10	1	78.4%	19.6%	2.0%
2	32	8	1	78.0%	19.5%	2.4%
3	24	6	1	77.4%	19.4%	3.2%
4	16	4	1	76.2%	19.0%	4.8%
5	8	2	1	72.7%	18.2%	9.1%
6	0	0	1	0.0%	0.0%	100.0%

Ce tableau révèle un comportement expressif :

Phase d’exposition (étapes 1-3) : le thème domine largement, les variations sont possibles mais rares, la coda est quasi impossible.
Phase de transition (étapes 4-5) : le thème s’affaiblit progressivement, les variations gardent leur proportion relative, la coda devient envisageable.
Phase de conclusion (étape 6) : les deux règles récursives sont mortes (poids 0). Seule la coda subsiste : elle est forcée.

C’est un modèle de la forme musicale classique Exposition-Développement-Conclusion, émergeant naturellement des poids décrémentaux sans aucune programmation explicite de la structure.

Encart : La beauté des poids décrémentaux

Notons que les deux règles récursives s’épuisent au même moment (étape 6), parce que 40/8 = 10/2 = 5 utilisations avant d’atteindre 0. Ce n’est pas une coïncidence : le compositeur a calibré les rapports N/M pour synchroniser les épuisements. Un rapport plus élevé (comme <40-4>) étendrait la vie du thème à 10 utilisations, créant une pièce plus longue.

Exemple 3 : Kayda avec contrôle par flags — les cycles de tāla

Un kayda est une composition de tabla structurée en cycles (āvart) de tāla. Le compositeur-interprète joue un nombre déterminé de cycles de variations avant de conclure par un tihāī (cadence). Les flags modélisent naturellement ce comptage de cycles :

-mo.RND
gram#1[1] /avart=4/ |S| --> |Cycle| |S|
gram#1[2]           |S| --> |Tihai|
gram#1[3] /avart/   |Cycle| --> |Variation| |Variation| /avart-1/
gram#1[4]           |Cycle| --> |Theka|
gram#1[5]           |Variation| --> dha tirakita dhin dhin dha
gram#1[6]           |Variation| --> dha dhin tirakita ta tirakita dhin
gram#1[7]           |Theka| --> dha dhin dhin dha dha dhin dhin dha
gram#1[8]           |Tihai| --> dha tirakita dhin - dha tirakita dhin - dha tirakita dhin

Le flag /avart=4/ autorise exactement 4 cycles (āvart) de variations (règle 3). Quand le compteur atteint 0, seule la règle 4 (theka simple) reste disponible, puis la grammaire converge vers le tihāī (règle 8). C’est une modélisation fidèle de la structure d’un kayda : thème → variations sur N cycles → cadence finale [BelKippen1992a].

Interaction flags + poids : contrôle à deux niveaux

Les flags et les poids peuvent coexister dans une même grammaire, offrant un contrôle à deux niveaux :

gram#1[1] /avart=15/ |S| --> <30-6> |A| |S| /avart-1/
gram#1[2]            |S| --> <1> -

Ici, la règle 1 a deux gardes :

Le flag avart doit être > 0 (garde logique)
Le poids décrémental <30-6> rend la règle de moins en moins probable (garde probabiliste)

Le premier des deux à s’épuiser arrête la récursion. Avec avart=15 (épuisement en 15 étapes) et <30-6> (épuisement en 5 étapes), c’est le poids qui gagne : la récursion s’arrêtera probablement autour de 5 itérations, bien avant que le flag n’atteigne 0.

Ce double contrôle permet de définir une borne dure (le flag : au maximum 15 itérations, jamais plus) et une tendance douce (le poids : en moyenne 4-5 itérations, avec variation).

5. Pouvoir expressif des poids décrémentaux

Les poids décrémentaux sont linéaires (<N-M> soustrait M à chaque pas) — il n’y a pas de déclin exponentiel ou logarithmique. Mais cette mécanique simple produit des comportements riches grâce à la renormalisation et à la combinatoire entre règles.

Incrément implicite par renormalisation

Le premier constat contre-intuitif : décrémenter une règle incrémente les autres. Si deux règles ont des poids [50, 1] et que seule la première décrémente, la seconde passe de P = 1/51 = 2% à P = 1/3 = 33% sans que son poids ait bougé. Les poids décrémentaux offrent donc le contrôle incrémental gratuitement — il suffit de décrémenter ce qu’on veut voir disparaître.

Tir unique : `<1-1>`

Un poids <1-1> s’annule après une seule utilisation. C’est un événement ponctuel : la règle peut se déclencher au plus une fois, puis disparaît. Utile pour une introduction, une surprise harmonique, ou un ornement qui ne doit pas se répéter :

gram#1[1] |S| --> <1-1> |Surprise| |S|
gram#1[2] |S| --> <5>   |Normal| |S|
gram#1[3] |S| --> <1>   -

La surprise a une chance de se produire au début (1/7 ≈ 14%), puis ne peut plus revenir.

Ancre immortelle : `<N>` sans décrément

Une règle à poids fixe ne meurt jamais. Quand toutes les autres s’épuisent, elle devient la seule survivante — un attracteur vers lequel la grammaire converge inévitablement. C’est le rôle de la Coda dans l’exemple Thème/Variation/Coda : son poids <1> ne bouge pas, mais sa probabilité croît jusqu’à 100%.

Mort synchronisée vs décalée

Le ratio N/M détermine la durée de vie d’une règle : ceil(N/M) étapes. En calibrant les ratios, on contrôle la forme temporelle de la pièce :

Stratégie	Ratios	Effet musical
Mort synchronisée	`<40-8>` et `<10-2>` (ratio 5 et 5)	Thème et variation meurent ensemble → coda brutale
Mort décalée	`<40-8>` et `<50-2>` (ratio 5 et 25)	Le thème meurt, la variation survit longtemps → transition graduelle
Succession	`<10-5>`, `<30-3>`, `<1>` (ratio 2, 10, ∞)	D’abord le motif A domine, puis B prend le relais, puis C hérite

La succession est particulièrement intéressante : elle crée une forme en relais où les comportements se passent le flambeau, sans aucune programmation explicite de la structure temporelle.

Rapport non-linéaire entre règles

Chaque poids décrémente linéairement, mais le rapport entre deux poids évolue non-linéairement. Si A a <100-10> et B a <50-2> :

Étape	w(A)	w(B)	Ratio A/B
1	100	50	2.0
3	80	46	1.7
5	60	42	1.4
7	40	38	1.05
9	20	34	0.59
11	0	30	0.0

Le ratio passe de 2.0 à 0 — A domine d’abord, puis B prend le dessus. La courbe du ratio est non-linéaire (elle s’accélère vers la fin) même si les décréments individuels sont constants. Deux lignes droites qui descendent à des vitesses différentes produisent un rapport courbe.

Transition de phase

Un ratio extrême entre le poids et le décrément crée une bascule brutale plutôt qu’un fondu progressif :

<100-99> : P ≈ 99% pendant 1 étape, puis 0% → interrupteur
<100-10> : P ≈ 90%+ pendant 9 étapes, puis chute → plateau + falaise
<100-1> : P décroît très lentement sur 100 étapes → fondu long

Le compositeur choisit la forme de la transition en calibrant le ratio N/M.

Limitation : profil linéaire uniquement

Malgré cette richesse combinatoire, le déclin de chaque règle individuelle reste strictement linéaire. Un vrai déclin exponentiel (division par 2 à chaque pas) ou logarithmique (déclin rapide puis plateau) n’est pas exprimable. Cette limitation ne change pas l’expressivité formelle (un poids exponentiel reste context-free), mais elle restreint la palette des profils temporels disponibles au compositeur.

Ce qu’il faut retenir

Les flags sont des compteurs conditionnels nommés, manipulés par six opérateurs : test (""), assignation ( = ), incrément (+), décrément (-), supérieur (>), inférieur (<).
Les flags se divisent en gardes (conditions d’applicabilité) et effets (modifications de l’état).
Les poids décrémentaux <N-M> diminuent de M à chaque utilisation, atteignant 0 en ceil(N/M) étapes, ce qui garantit la terminaison des récursions.
La distribution catégorielle est renormalisée à chaque étape : les probabilités sont recalculées dynamiquement, ce qui distingue fondamentalement BP3 des PCFG.
En SuperCollider, BP2SC traduit les flags en Prout avec des structures if/else et les poids décrémentaux en variables mutables locales — voir B8 pour les exemples de code SC.
Les flags offrent un contrôle logique (interrupteur), les poids décrémentaux un contrôle probabiliste (gradateur). Combinés, ils permettent un contrôle à deux niveaux.
Direction : cet article décrit flags et poids dans le sens de la production. En mode analytique (ANAL), les poids jouent un rôle inversé : chaque règle utilisée pour reconnaître une séquence voit son poids incrémenté, ce qui constitue un mécanisme d’apprentissage intégré. Les flags, eux, servent à tracer le parcours analytique. Voir B8.

Pour aller plus loin

Documentation BP3 : Bol Processor — Flags and Conditions
Poids dynamiques : Bol Processor — Grammar Control
PCFG et au-delà : Lari & Young (1990), « The estimation of stochastic context-free grammars using the Inside-Outside algorithm » — pour comprendre pourquoi les PCFG classiques ne suffisent pas pour le contrôle dynamique
Processus stochastiques non-markoviens : Feller, An Introduction to Probability Theory and Its Applications, vol. 2, chapitre sur les processus à mémoire
Raga et improvisation contrôlée : Subramanian (2007), « Generative Grammar of Carnatic Music » — un modèle grammatical de l’improvisation dans le raga
L’article fondateur : Bel, B. & Kippen, J. (1992), « Modelling Music with Grammars: Formal Language Representation in the Bol Processor » — les flags et poids appliqués au tabla
Le contexte ethnomusicologique : Kippen, J. (1988), The Tabla of Lucknow: A Cultural Analysis of a Musical Tradition, Cambridge University Press
Flags et poids en mode analytique : B8 — comment flags et poids fonctionnent dans les directions ANAL et TEMP de BP3

Glossaire

Ālāp : Ouverture d’un raga où les notes sont introduites progressivement (Sa, puis Sa-Re, puis Sa-Re-Ga…). Sa structure accumulative dépasse les capacités des flags (compteurs) et nécessite les extensions context-sensitive de BP3 (B6).
Catégorielle (distribution) : Distribution de probabilité discrète sur un ensemble fini de catégories, chacune avec son propre poids. Généralise le lancer de dé pipé à un nombre arbitraire de faces.
Configuration (SOS) : Tuple représentant l’état complet du système pendant la dérivation. Pour BP3 avec flags et poids : (σ, φ, t, w) — chaîne de travail, environnement de flags, temps, fonction de poids.
Āvart : Un cycle complet de tāla. Un kayda peut s’étendre sur plusieurs āvart avant de conclure par un tihāī.
Convergence : Propriété d’un processus qui tend vers un état final. Les poids décrémentaux convergent vers 0, forçant la terminaison.
Décrément : Diminution d’une valeur. Dans <50-12>, le décrément est 12 : le poids perd 12 à chaque utilisation.
Environnement de flags (φ) : Fonction qui associe à chaque nom de flag sa valeur entière courante. Notation : φ(avart) = 4.
Flag : Variable nommée attachée aux règles de BP3, servant de compteur conditionnel. Peut être testée, assignée, incrémentée ou décrémentée.
Garde : Condition qui doit être satisfaite pour qu’une règle puisse s’appliquer. Les flags en mode test (/avart/, /avart>2/) fonctionnent comme des gardes.
Mise à jour fonctionnelle : Opération qui crée un nouvel environnement identique à l’ancien sauf pour une variable. Notation : φ[avart ↦ 3] signifie « φ avec avart changé en 3 ».
Poids décrémental : Poids associé à une règle qui diminue après chaque utilisation de cette règle. Notation BP3 : <N-M> (poids initial N, décrément M).
Renormalisation : Recalcul des probabilités après modification des poids. Si les poids changent de [50, 1] à [38, 1], les probabilités sont recalculées de [98%, 2%] à [97.4%, 2.6%].
Kayda : Composition de tabla avec un thème fixe (mukhra) et des variations systématiques sur plusieurs cycles de tāla, concluant par un tihāī.
Terminaison garantie : Propriété d’un système qui atteint nécessairement un état final en un nombre fini d’étapes. Les poids décrémentaux garantissent ceil(N/M) + 1 étapes au maximum.
Tihāī : Cadence indienne où un motif est répété exactement trois fois pour atterrir sur sam (le premier temps du cycle).
Vādi : Note dominante d’un raga, la plus fréquente et importante. Sa présence régulière peut être modélisée par un flag BP3.

Prérequis : PCFG, Règles de dérivation, SOS
Temps de lecture : 12 min
Tags : #flags #poids #contrôle #BP3 #stochastique #SOS

B4) Flags et poids decrémentaux

Le contrôle dynamique

Où se situe cet article ?

Pourquoi c’est important ?

L’idée en une phrase

Expliquons pas à pas

1. Les flags : des compteurs conditionnels

Qu’est-ce qu’un flag ?

Syntaxe BP3

Les six opérateurs

Le noeud AST Flag

Règle SOS : Flag-Cond

2. Les poids décrémentaux

Qu’est-ce qu’un poids décrémental ?

Syntaxe BP3

Le noeud AST Weight

Règle SOS : Weight-Dec

Evolution des probabilités : un exemple concret

3. Interactions flags et modes

RND avec flags : choix conditionnel

ORD avec flags : exécution conditionnelle séquentielle

Poids décrémentaux en mode RND

4. Exemples concrets

Exemple 1 : Mohanam — le raga à épuisement contrôlé

Exemple 2 : épuisement progressif avec poids décrémentaux

Exemple 3 : Kayda avec contrôle par flags — les cycles de tāla

Interaction flags + poids : contrôle à deux niveaux

5. Pouvoir expressif des poids décrémentaux

Incrément implicite par renormalisation

Tir unique : <1-1>

Ancre immortelle : <N> sans décrément

Mort synchronisée vs décalée

Rapport non-linéaire entre règles

Transition de phase

Limitation : profil linéaire uniquement

Ce qu’il faut retenir

Pour aller plus loin

Glossaire

Tir unique : `<1-1>`

Ancre immortelle : `<N>` sans décrément