Replace Collatz-Trapdoor binaries with v2.1 Markdown spec

**Motivations :**
- Keep spec in versionable Markdown; remove PDF/DOCX binaries from repo.
- Add Collatz-Trapdoor v2.1 specification document.

**Root causes :**
- N/A (documentation restructure)

**Correctifs :**
- N/A

**Evolutions :**
- Add v0/collatz_trapdoor_v2_1_spec.md.
- Remove v0/Spécifications Mathématiques Collatz-Trapdoor.pdf and v2.0 .docx/.pdf.
- Minor update to v0/conjoncture_collatz.md.

**Page affectées :**
- v0/Spécifications Mathématiques Collatz-Trapdoor.pdf
- v0/Spécifications Mathématiques _ Protocole Collatz-Trapdoor v2.0.docx
- v0/Spécifications Mathématiques _ Protocole Collatz-Trapdoor v2.0.pdf
- v0/collatz_trapdoor_v2_1_spec.md
- v0/conjoncture_collatz.md

Co-authored-by: Cursor <cursoragent@cursor.com>

v0/collatz_trapdoor_v2_1_spec.md

@@ -0,0 +1,366 @@
+# Spécification formelle du protocole Collatz‑trapdoor v2.1
+
+## Introduction
+
+Le présent document fixe une version formelle et exploitable d’un protocole hybride combinant une fonction de mélange fondée sur une dynamique de type Collatz perturbée et des primitives asymétriques standard (KEM et signature). La dynamique Collatz perturbée est cantonnée à un rôle de dérivation et de séparation de domaines, tandis que la confidentialité et l’authenticité reposent sur un KEM et une signature étudiés et auditables. La spécification s’écrit au niveau des algorithmes KeyGen, Encaps, Decaps, Sign, Verify, avec notations et paramètres explicités.
+
+## Notations et conventions
+
+### Objets mathématiques
+
+\(\mathbb{N}=\{0,1,2,\dots\}\)
+
+\(\mathbb{N}^+=\{1,2,3,\dots\}\)
+
+\(\mathbb{I}=\{2n+1 \mid n\in\mathbb{N}\}\), ensemble des impairs positifs
+
+\(v_2(x)\), valuation 2‑adique de \(x\in\mathbb{N}^+\), définie par
+\[
+v_2(x)=\max\{t\in\mathbb{N}\mid 2^t \text{ divise } x\}.
+\]
+
+### Chaînes de bits et fonctions cryptographiques
+
+Les chaînes de bits sont notées en gras, par exemple \(\mathbf{x}\in\{0,1\}^\ell\).
+
+\(\parallel\), concaténation de chaînes ou d’encodages canoniques.
+
+\(\oplus\), XOR bit à bit sur des chaînes de même longueur.
+
+\(\mathrm{Hash}(\cdot)\), fonction de hachage cryptographique, sortie de longueur \(h\) bits.
+
+\(\mathrm{XOF}(\cdot)\), fonction d’extension (eXtendable Output Function) produisant un flux pseudo‑aléatoire de bits de longueur arbitraire.
+
+\(\mathrm{KDF}(\cdot)\), fonction de dérivation de clé (Key Derivation Function).
+
+\(\mathrm{AEAD.Enc}(K,\mathrm{nonce},M,\mathrm{ad})\rightarrow (C,\mathrm{tag})\), chiffrement authentifié.
+
+\(\mathrm{AEAD.Dec}(K,\mathrm{nonce},C,\mathrm{ad},\mathrm{tag})\rightarrow M \text{ ou } \bot\), déchiffrement authentifié.
+
+### Encodages canoniques
+
+Tout entier \(x\in\mathbb{N}^+\) est encodé en big‑endian sur une longueur fixée \(\ell_S\) bits, notée \(\mathrm{EncInt}_{\ell_S}(x)\). Si \(\ell_S\) dépasse la taille minimale, l’encodage est paddé à gauche par des zéros.
+
+Les entiers et chaînes utilisés en entrée des fonctions \(\mathrm{Hash}\), \(\mathrm{XOF}\), \(\mathrm{KDF}\) sont encodés sans ambiguïté via des préfixes de longueur (par exemple \(\mathrm{len}(\cdot)\parallel \cdot\)), ou via un format TLV convenu.
+
+## Paramètres
+
+Les paramètres sont publics et fixés lors du déploiement.
+
+### Paramètres CollatzMix
+
+\(\ell_S\) : taille en bits de \(S\) (exemple 2048 ou 4096)
+
+\(b\) : taille en bits du seed d’erreur \(E\) (exemple 128 ou 256)
+
+\(k_{\mathrm{mix}}\) : profondeur d’itération de mélange (exemple 512 ou 1024)
+
+\(h\) : taille de sortie de \(\mathrm{Hash}\) en bits (exemple 256)
+
+\(\ell_\rho,\ell_\sigma\) : tailles des seeds dérivés pour le KEM et la signature (dépendent des primitives choisies)
+
+### Paramètres KEM et signature
+
+Le protocole est agnostique au choix exact, à condition que les primitives retenues satisfassent les notions de sécurité attendues et disposent d’API stables :
+
+KEM :
+- \(\mathrm{KEM.KeyGen}(\mathbf{seed})\rightarrow(\mathrm{pk}_{\mathrm{kem}},\mathrm{sk}_{\mathrm{kem}})\)
+- \(\mathrm{KEM.Encaps}(\mathrm{pk}_{\mathrm{kem}})\rightarrow(\mathrm{ct}_{\mathrm{kem}},\mathbf{ss})\)
+- \(\mathrm{KEM.Decaps}(\mathrm{sk}_{\mathrm{kem}},\mathrm{ct}_{\mathrm{kem}})\rightarrow \mathbf{ss}\text{ ou }\bot\)
+
+Signature :
+- \(\mathrm{SIG.KeyGen}(\mathbf{seed})\rightarrow(\mathrm{pk}_{\mathrm{sig}},\mathrm{sk}_{\mathrm{sig}})\)
+- \(\mathrm{SIG.Sign}(\mathrm{sk}_{\mathrm{sig}},m)\rightarrow \sigma\)
+- \(\mathrm{SIG.Verify}(\mathrm{pk}_{\mathrm{sig}},m,\sigma)\rightarrow \{\mathrm{true},\mathrm{false}\}\)
+
+Si les implémentations disponibles n’exposent pas de KeyGen « seedé », la correction consiste à instancier un DRBG déterministe \(\mathrm{DRBG}\) initialisé par \(\mathbf{seed}\) et à fournir son flux en remplacement de l’aléa interne de KeyGen.
+
+### Profils indicatifs
+
+Profil standard :
+- \(\ell_S=2048\)
+- \(b=128\)
+- \(k_{\mathrm{mix}}=512\)
+
+Profil haute sécurité :
+- \(\ell_S=4096\)
+- \(b=256\)
+- \(k_{\mathrm{mix}}=1024\)
+
+Le dimensionnement final doit rester cohérent avec la sécurité du KEM et de la signature réellement utilisés ; CollatzMix n’augmente pas le niveau de sécurité au‑delà de ces primitives.
+
+## Définition de l’opérateur de Collatz perturbé
+
+Soit \(n\in\mathbb{I}\). On pose \(v=v_2(3n+1)\) et \(e\in\{0,1\}\).
+
+Numérateur perturbé :
+\[
+N^\*(n,e)=3n+1+2^{v_2(3n+1)}\cdot e.
+\]
+
+Exposant de normalisation (définition non ambiguë) :
+\[
+a^\*(n,e)=v_2\!\bigl(N^\*(n,e)\bigr).
+\]
+
+Opérateur perturbé :
+\[
+U^\*(n,e)=\frac{N^\*(n,e)}{2^{a^\*(n,e)}}.
+\]
+
+Propriété :
+\[
+U^\*(n,e)\in\mathbb{I}.
+\]
+
+Trajectoire perturbée sur \(k_{\mathrm{mix}}\) pas, pour un vecteur \(\vec e\in\{0,1\}^{k_{\mathrm{mix}}}\) :
+\[
+U^{\*(k_{\mathrm{mix}})}(S,\vec e)=U^\*(\cdots U^\*(U^\*(S,e_0),e_1)\cdots,e_{k_{\mathrm{mix}}-1}).
+\]
+
+## Expansion du bruit binaire
+
+Le protocole n’expose pas \(\vec e\) et n’utilise pas une “taille de bruit” distincte de \(k_{\mathrm{mix}}\). Le seul paramètre de bruit est un seed \(E\) de taille \(b\) bits.
+
+Définition :
+\[
+\vec e = \mathrm{XOF}(E\parallel \mathrm{dst}\parallel \mathrm{EncInt}(k_{\mathrm{mix}}))[0..k_{\mathrm{mix}}-1],
+\]
+où \(\mathrm{dst}\) est une étiquette de séparation de domaine, et \([0..k_{\mathrm{mix}}-1]\) signifie “prendre les \(k_{\mathrm{mix}}\) premiers bits”.
+
+## Fonction de mélange CollatzMix
+
+### Spécification
+
+Entrées :
+- secret maître \(S\in\mathbb{I}\), encodé sur \(\ell_S\) bits
+- seed d’erreur \(\mathbf{E}\in\{0,1\}^b\)
+- étiquette de domaine \(\mathrm{dst}\) (chaîne courte)
+- longueur désirée \(\ell\) bits
+
+Sortie :
+- \(\mathbf{out}\in\{0,1\}^\ell\)
+
+### Algorithme CollatzMix
+
+1. \(\vec e \leftarrow \mathrm{ExpandBits}(\mathbf{E},\mathrm{dst},k_{\mathrm{mix}})\)
+2. \(X_0 \leftarrow S\)
+3. Pour \(i\) de \(0\) à \(k_{\mathrm{mix}}-1\) :
+   - \(X_{i+1} \leftarrow U^\*(X_i,e_i)\)
+4. Pour \(i\) de \(0\) à \(k_{\mathrm{mix}}\) :
+   - \(\mathbf{B}_i \leftarrow \mathrm{Hash}(\mathrm{dst}\parallel \mathrm{EncInt}(i)\parallel \mathrm{EncInt}_{\ell_S}(X_i))\)
+5. \(\mathbf{out} \leftarrow (\mathbf{B}_0\parallel \mathbf{B}_1\parallel \cdots)[0..\ell-1]\)
+
+Notes d’implémentation :
+- \(\mathrm{dst}\) doit être constant et distinct pour chaque usage (KEM seed, KEM noise, signature seed, signature noise, etc.).
+- L’encodage \(\mathrm{EncInt}_{\ell_S}(X_i)\) est nécessaire pour éviter des collisions d’encodage.
+- Les itérations doivent être exécutées en temps aussi régulier que possible ; la valuation \(v_2(\cdot)\) induit des branches qui peuvent révéler de l’information via des canaux auxiliaires si l’implémentation est naïve.
+
+## Génération de la clé maîtresse
+
+### Algorithme MasterKeyGen
+
+Entrées :
+- paramètres \((\ell_S,b,k_{\mathrm{mix}})\)
+
+Sorties :
+- \(\mathrm{msk}=(S,\mathbf{E})\)
+
+Procédure :
+1. Échantillonner uniformément un entier impair \(S\) de taille \(\ell_S\) bits.
+2. Échantillonner uniformément \(\mathbf{E}\in\{0,1\}^b\).
+3. Rejeter et ré‑échantillonner \(S\) si \(3S+1\) est une puissance de \(2\), c’est‑à‑dire s’il existe \(x\in\mathbb{N}\) tel que \(3S+1=2^x\).
+4. Retourner \(\mathrm{msk}=(S,\mathbf{E})\).
+
+Ce filtrage évite des cas pathologiques évidents ; il n’est pas présenté comme preuve de sécurité.
+
+## Dérivation des seeds et structure des clés
+
+### Seeds dérivés
+
+Les seeds sont dérivés par séparation de domaine, avec longueurs propres à chaque primitive.
+
+\[
+\mathbf{\rho_{kem}}=\mathrm{CollatzMix}(S,\mathbf{E},\text{"kem-seed"},\ell_\rho)
+\]
+\[
+\mathbf{\sigma_{kem}}=\mathrm{CollatzMix}(S,\mathbf{E},\text{"kem-noise"},\ell_\sigma)
+\]
+\[
+\mathbf{\rho_{sig}}=\mathrm{CollatzMix}(S,\mathbf{E},\text{"sig-seed"},\ell_\rho)
+\]
+\[
+\mathbf{\sigma_{sig}}=\mathrm{CollatzMix}(S,\mathbf{E},\text{"sig-noise"},\ell_\sigma)
+\]
+
+Le schéma retenu fixe l’usage précis de \(\ell_\rho\) et \(\ell_\sigma\).
+
+### Clé publique et clé privée
+
+Clé publique :
+\[
+\mathrm{pk}=(\mathrm{pk}_{\mathrm{kem}},\mathrm{pk}_{\mathrm{sig}},\mathrm{param})
+\]
+où \(\mathrm{param}\) est l’identifiant de profil et les paramètres publics (y compris \(k_{\mathrm{mix}},\ell_S,b,h\) et le choix des primitives).
+
+Clé privée opérationnelle :
+\[
+\mathrm{sk}=(\mathrm{sk}_{\mathrm{kem}},\mathrm{sk}_{\mathrm{sig}})
+\]
+
+Clé privée reconstructible (optionnelle, pour dérivation déterministe) :
+\[
+\mathrm{msk}=(S,\mathbf{E})
+\]
+permet de reconstruire \((\mathrm{sk}_{\mathrm{kem}},\mathrm{sk}_{\mathrm{sig}})\) par recalcul.
+
+Une implémentation peut conserver \(\mathrm{sk}\) seul, ou \(\mathrm{msk}\) seul, ou les deux, selon le modèle de menace et les contraintes d’ergonomie.
+
+## Algorithmes formels
+
+### KeyGen
+
+Entrées :
+- paramètres publics \(\mathrm{param}\)
+
+Sorties :
+- \((\mathrm{pk},\mathrm{sk})\) et éventuellement \(\mathrm{msk}\)
+
+Procédure :
+1. \(\mathrm{msk}=(S,\mathbf{E})\leftarrow \mathrm{MasterKeyGen}(\ell_S,b,k_{\mathrm{mix}})\)
+2. Dériver \(\mathbf{\rho_{kem}},\mathbf{\sigma_{kem}},\mathbf{\rho_{sig}},\mathbf{\sigma_{sig}}\) comme défini plus haut.
+3. \((\mathrm{pk}_{\mathrm{kem}},\mathrm{sk}_{\mathrm{kem}})\leftarrow \mathrm{KEM.KeyGen}(\mathbf{\rho_{kem}}\parallel \mathbf{\sigma_{kem}})\)
+4. \((\mathrm{pk}_{\mathrm{sig}},\mathrm{sk}_{\mathrm{sig}})\leftarrow \mathrm{SIG.KeyGen}(\mathbf{\rho_{sig}}\parallel \mathbf{\sigma_{sig}})\)
+5. \(\mathrm{pk}\leftarrow (\mathrm{pk}_{\mathrm{kem}},\mathrm{pk}_{\mathrm{sig}},\mathrm{param})\)
+6. \(\mathrm{sk}\leftarrow (\mathrm{sk}_{\mathrm{kem}},\mathrm{sk}_{\mathrm{sig}})\)
+7. Retourner \((\mathrm{pk},\mathrm{sk})\) et, selon politique, \(\mathrm{msk}\).
+
+Commentaires de correction :
+- la concaténation \(\mathbf{\rho}\parallel \mathbf{\sigma}\) fournit une entropie et une séparation suffisantes pour alimenter un DRBG interne si nécessaire.
+- si le KEM ou la signature exigent plusieurs sources de seeds, le mapping exact doit être documenté par la primitive choisie.
+
+### Encaps
+
+Encapsulation d’un secret partagé, puis chiffrement hybride optionnel d’un message via AEAD.
+
+Entrées :
+- clé publique \(\mathrm{pk}\)
+- message optionnel \(M\) (octets)
+- données associées \(\mathrm{ad}\) (octets, optionnel)
+
+Sorties :
+- encapsulat \(\mathrm{ct}\)
+- secret partagé \(\mathbf{K}\) (pour usage externe) ou clé AEAD interne
+- si \(M\) est présent, un ciphertext AEAD
+
+Procédure :
+1. Extraire \(\mathrm{pk}_{\mathrm{kem}}\) de \(\mathrm{pk}\).
+2. \((\mathrm{ct}_{\mathrm{kem}},\mathbf{ss})\leftarrow \mathrm{KEM.Encaps}(\mathrm{pk}_{\mathrm{kem}})\)
+3. \(\mathbf{K}\leftarrow \mathrm{KDF}(\text{"kem"}\parallel \mathbf{ss}\parallel \mathrm{ct}_{\mathrm{kem}})\)
+4. Si \(M\) est absent :
+   - \(\mathrm{ct}\leftarrow \mathrm{ct}_{\mathrm{kem}}\)
+   - retourner \((\mathrm{ct},\mathbf{K})\)
+5. Si \(M\) est présent :
+   - \(\mathbf{K}_{\mathrm{aead}}\leftarrow \mathrm{KDF}(\text{"aead"}\parallel \mathbf{K})\)
+   - choisir un \(\mathrm{nonce}\) conforme à l’AEAD (unique par clé)
+   - \((C,\mathrm{tag})\leftarrow \mathrm{AEAD.Enc}(\mathbf{K}_{\mathrm{aead}},\mathrm{nonce},M,\mathrm{ad})\)
+   - \(\mathrm{ct}\leftarrow (\mathrm{ct}_{\mathrm{kem}},\mathrm{nonce},\mathrm{ad},C,\mathrm{tag})\)
+   - retourner \((\mathrm{ct},\mathbf{K})\)
+
+### Decaps
+
+Décapsulation du secret partagé et déchiffrement hybride optionnel.
+
+Entrées :
+- clé privée \(\mathrm{sk}\)
+- encapsulat \(\mathrm{ct}\)
+
+Sorties :
+- \(\mathbf{K}\) ou \(\bot\)
+- si le mode hybride est utilisé, \(M\) ou \(\bot\)
+
+Procédure :
+1. Extraire \(\mathrm{sk}_{\mathrm{kem}}\) de \(\mathrm{sk}\).
+2. Si \(\mathrm{ct}\) est du type simple :
+   - \(\mathrm{ct}_{\mathrm{kem}}\leftarrow \mathrm{ct}\)
+3. Si \(\mathrm{ct}\) est du type hybride :
+   - \((\mathrm{ct}_{\mathrm{kem}},\mathrm{nonce},\mathrm{ad},C,\mathrm{tag})\leftarrow \mathrm{ct}\)
+4. \(\mathbf{ss}\leftarrow \mathrm{KEM.Decaps}(\mathrm{sk}_{\mathrm{kem}},\mathrm{ct}_{\mathrm{kem}})\)
+5. Si \(\mathbf{ss}=\bot\), retourner \(\bot\).
+6. \(\mathbf{K}\leftarrow \mathrm{KDF}(\text{"kem"}\parallel \mathbf{ss}\parallel \mathrm{ct}_{\mathrm{kem}})\)
+7. Si \(\mathrm{ct}\) est du type simple, retourner \(\mathbf{K}\).
+8. \(\mathbf{K}_{\mathrm{aead}}\leftarrow \mathrm{KDF}(\text{"aead"}\parallel \mathbf{K})\)
+9. \(M\leftarrow \mathrm{AEAD.Dec}(\mathbf{K}_{\mathrm{aead}},\mathrm{nonce},C,\mathrm{ad},\mathrm{tag})\)
+10. Retourner \(M\) si succès, sinon \(\bot\).
+
+### Sign
+
+Entrées :
+- clé privée \(\mathrm{sk}\)
+- message \(m\) (octets)
+
+Sortie :
+- signature \(\sigma\)
+
+Procédure :
+1. Extraire \(\mathrm{sk}_{\mathrm{sig}}\) de \(\mathrm{sk}\).
+2. \(\sigma \leftarrow \mathrm{SIG.Sign}(\mathrm{sk}_{\mathrm{sig}},m)\)
+3. Retourner \(\sigma\).
+
+### Verify
+
+Entrées :
+- clé publique \(\mathrm{pk}\)
+- message \(m\)
+- signature \(\sigma\)
+
+Sortie :
+- \(\mathrm{true}\) ou \(\mathrm{false}\)
+
+Procédure :
+1. Extraire \(\mathrm{pk}_{\mathrm{sig}}\) de \(\mathrm{pk}\).
+2. Retourner \(\mathrm{SIG.Verify}(\mathrm{pk}_{\mathrm{sig}},m,\sigma)\).
+
+## Propriétés attendues
+
+### Correction
+
+Correction KEM :
+\[
+\Pr\bigl[\mathbf{ss}=\mathbf{ss}' \mid (\mathrm{pk}_{\mathrm{kem}},\mathrm{sk}_{\mathrm{kem}})\leftarrow \mathrm{KEM.KeyGen},\ (\mathrm{ct}_{\mathrm{kem}},\mathbf{ss})\leftarrow \mathrm{KEM.Encaps}(\mathrm{pk}_{\mathrm{kem}}),\ \mathbf{ss}'\leftarrow \mathrm{KEM.Decaps}(\mathrm{sk}_{\mathrm{kem}},\mathrm{ct}_{\mathrm{kem}})\bigr]=1.
+\]
+
+Correction signature :
+\[
+\mathrm{SIG.Verify}(\mathrm{pk}_{\mathrm{sig}},m,\mathrm{SIG.Sign}(\mathrm{sk}_{\mathrm{sig}},m))=\mathrm{true}.
+\]
+
+### Objectifs de sécurité
+
+Confidentialité :
+- objectif typique IND‑CCA2 pour l’encapsulation et le chiffrement hybride, hérité du KEM et de l’AEAD.
+
+Authenticité :
+- objectif typique EUF‑CMA pour la signature, hérité du schéma de signature.
+
+Le rôle de CollatzMix est celui d’un dérivateur de seeds et d’un mécanisme de séparation de domaines ; aucune affirmation de réduction vers SVP ou LWE n’est portée par la partie Collatz elle‑même dans cette version.
+
+## Recommandations d’implémentation
+
+Gestion des canaux auxiliaires :
+- éviter des branches manifestement dépendantes de \(v_2(\cdot)\) sans compensation ; l’opérateur CollatzMix doit être traité comme une fonction sensible si \(\mathrm{msk}\) est présent en mémoire.
+- effacer en mémoire les valeurs intermédiaires \(X_i\) si l’environnement le permet.
+
+Séparation des domaines :
+- les chaînes \("kem-seed"\), \("kem-noise"\), \("sig-seed"\), \("sig-noise"\) doivent être considérées comme constantes de protocole, non modifiables par un attaquant.
+
+Nonces AEAD :
+- un nonce ne doit jamais être réutilisé avec la même clé \(\mathbf{K}_{\mathrm{aead}}\).
+- si la politique l’autorise, un nonce aléatoire est acceptable, sinon un compteur persistant est requis.
+
+Encodages :
+- tous les encodages d’entiers doivent être fixés une fois pour toutes ; une ambiguïté d’encodage détruit la séparation de domaines et peut créer des collisions.
+
+## Conclusion
+
+La spécification v2.1 formalise un protocole hybride où la dynamique Collatz perturbée et son bruit binaire ne prétendent plus porter, seules, la sécurité asymétrique. La correction est obtenue en confiant l’encapsulation et la signature à des primitives asymétriques explicitement décrites par des algorithmes KeyGen, Encaps, Decaps, Sign, Verify, et en utilisant CollatzMix comme mécanisme de dérivation déterministe et de séparation de domaines. Cette architecture rend la correction vérifiable et ouvre la voie à une évaluation cryptanalytique réaliste, centrée sur les primitives KEM et signature choisies et sur l’implémentation de la dérivation CollatzMix en présence de canaux auxiliaires.

v0/conjoncture_collatz.md

@@ -4452,3 +4452,4 @@ Ces résidus sont précisément ceux dont la première descente « naturelle »
 La démonstration progresse de manière strictement contrôlée : au niveau (512), un registre (K) combinant clauses (V), clauses (D) par majoration, et clauses (D) certifiées à modules (256) et (512) ferme (208) résidus impairs sur (256), laissant un résidu explicite de (48). L’affinement au niveau (1024) permet d’ajouter des clauses certifiées au module (1024), et de rendre explicite le nouveau résidu (90 résidus impairs modulo (1024)).
 
 La suite de la démonstration suit exactement la même logique : affiner les résidus restants au niveau (2048) (clauses avec (2^{A_k+1}=2048)), ce qui ferme déjà plusieurs éléments du résidu (par exemple des classes comme (79), (315), (391), (475), (287) admettent des blocs de descente avec (A_k=10)), puis réserver les mécanismes de fusion (F) aux poches où (A_k) devient trop grand de façon persistante (familles de type (27), (31), (63), (127), etc.). Si la continuation doit se faire immédiatement, l’étape suivante peut être écrite en commençant par les clauses (2^{11}) les plus courtes, puis en mettant à jour, de façon exhaustive, le résidu restant modulo (2048).
+