Ajout générateur de l'annexe

.gitignore

+# Walnut
+Automata\ Library/
+Command\ Files/
+Custom\ Bases/
+Result/
+Word\ Automata\ Library/
+
+*-checkpoint.ipynb
+**/.idea
+**/.ipynb_checkpoints
+
+# VSCode
+.vscode/
+
+# Latex
+*.acn
+*.acr
+*.alg
+*.aux
+*.bak
+*.bbl
+*.bcf
+*.blg
+*.brf
+*.bst
+*.dvi
+*.fdb_latexmk
+*.fls
+*.glg
+*.glo
+*.gls
+*.idx
+*.ilg
+*.ind
+*.ist
+*.lof
+*.log
+*.lol
+*.lot
+*.maf
+*.mtc
+*.mtc1
+*.nav
+*.nlo
+*.nls
+*.out
+*.pdf
+*.pyg
+*.run.xml
+*.snm
+*.synctex.gz
+*.tex.backup
+*.tex~
+*.thm
+*.toc
+*.vrb
+*.xdy
+*.xml
+*blx.bib
+.bak 
+.mtc
+build/
\ No newline at end of file

annexe/fib.qmd

+---
+title: Complexité en Facteur de Fibonacci 
+date: '2025-06-16'
+format:
+  html:
+    code-fold: false
+    embed-resources: true
+    toc: true
+    toc-location: left
+    number-sections: true
+    syntax-definitions: 
+        - walnut.xml
+  ipynb: default 
+execute:
+  cache: true
+  keep-ipynb: true
+  allow_errors: true
+jupyter: walnut
+---
+
+## Construction du système de de numération
+
+On défini la substitution, le système de numération et le point fixe associé.
+
+```{walnut}
+%%python
+from licofage.kit import *
+import os
+setparams(False, False, os.environ["WALNUT_HOME"])
+
+s = subst('a->ab, b->a')
+ns = address(s, "fib")
+ns.gen_ns()
+ns.gen_word_automaton()
+```
+
+## Prédicats de base
+
+`feq_fib(i,j,n)` : accepte (i,j,n) si les facteurs (i,n) et (j,n)
+sont égaux  
+`first_fib(i,n)` : accepte (i,n) si c'est un facteur nouveau  
+`last_fib(i,n)` : accepte (i,n) si c'est un facteur nouveau et qu'aucun facteur nouveau ne se situe après lui  
+
+```{walnut}
+def cut_fib "?msd_fib i<=u & j<=v & u+j=v+i & u<n+i & v<n+j":
+def feq_fib "?msd_fib ~(Eu,v $cut_fib(i,j,n,u,v) & Fib[u]!=Fib[v])":
+def first_fib "?msd_fib Aj $feq_fib(i,j,n) => i<=j":
+def last_fib "?msd_fib $first_fib(i,n) & Ak k>i => ~$first_fib(k,n)": 
+```
+
+## Construction de la complexité en facteur par itération 
+
+`next_block_fib(i,j,n)` : (i,n) est un facteur non nouveau et (j,n) est le premier facteur nouveau qui suit. Si un tel facteur (j,n) n'existe pas, j=i  
+`block_max_right_fib(i,j,n,l)` : il y a un bloc de l facteurs nouveau entre (i,n) et (j,n) et il est maximal à droite  
+Suite d'automate / prédicat (j entier non nul) `compte_j_fib(e,n,p)` : entre (0,n) et (e,n), il y a p facteurs nouveau répartis dans j blocs ou moins  
+`compl_fact_fib_V1(n,p)` : complexité en facteur synchronisée
+
+```{walnut}
+%%python
+script = []
+
+script.append(f'def last_fib "?msd_fib $first_fib(i,n) & Ak k>i => ~$first_fib(k,n)";')
+script.append(f'''def block_max_right_fib "?msd_fib (~$first_fib(i,n) & k=0 & j=i) 
+        | ($first_fib(i,n) 
+            & (Ap (i<=p & p<=j) => $first_fib(p,n))    
+            & ~$first_fib(j+1,n) 
+            & (i+k = j+1))";''') 
+script.append(f'''def next_block_fib "?msd_fib (i<j & ~$first_fib(i,n) & $first_fib(j,n) & 
+    (Ap (i<p & p<j) => ~$first_fib(p,n)))
+    | (Ek $last_fib(k,n) & k<i & i=j)";''')                                
+script.append(f'def compte_0_fib "?msd_fib $block_max_right_fib(0,e,p,n)":')
+script.append(f'def compte_1_fib "?msd_fib Es,q $compte_0_fib(s,n,q)&(($next_block_fib(s+1,s+1,n) & p=q & s+1=e+1)|(Ek s+1<k & $next_block_fib(s+1,k,n) & El $block_max_right_fib(k,e,l,n) & p=q+l))";')
+script.append('eval test_egal_fib "?msd_fib Ae,n,p $compte_1_fib(e,n,p) <=> $compte_0_fib(e,n,p)";')
+j=1
+
+writefile(f"factcompl_via_iter", "\n".join(script))
+```
+
+```{walnut}
+load factcompl_via_iter.txt;
+```
+
+```{walnut}
+%%python
+script = []
+
+p_test = P(os.environ["WALNUT_HOME"])/"Result"/"test_egal_fib.txt"
+flag = 0
+with p_test.open("r") as f_test:
+    res = f_test.read()
+    if "false" in res :
+        flag = 1
+    elif "true" in res:
+        flag = 2
+    else :
+        print("Un problème est survenu")
+if flag == 1: 
+    j+=1
+    script.append(f'def compte_{j}_fib "?msd_fib Es,q $compte_{j-1}_fib(s,n,q)&(($next_block_fib(s+1,s+1,n) & p=q & s+1=e+1)|(Ek s+1<k & $next_block_fib(s+1,k,n) & El $block_max_right_fib(k,e,l,n) & p=q+l))";')
+    script.append(f'eval test_egal_fib "?msd_fib Ae,n,p $compte_{j-1}_fib(e,n,p) <=> $compte_{j}_fib(e,n,p)";')
+    print("Exécutez les deux dernières cellules une fois de plus.")
+elif flag == 2 :
+    script.append(f'def compl_fact_fib_V1 "?msd_fib Ee $compte_{j}_fib(e,n,p)";')
+    print("OK")
+writefile(f"factcompl_via_iter", "\n".join(script))
+```
+
+```{walnut}
+load factcompl_via_iter.txt;
+```
+
+## Vérification inductive de l'automate
+
+`new_first_fib(i,n)` : accepte le facteur (i,n) si il est nouvellement nouveau  
+`NEW_fib[n]` : nombre de facteur nouvellement nouveau de longueur n+1  
+
+```{walnut}
+
+def new_first_fib n "?msd_fib  ~$first_fib(i,n) & $first_fib(i,n+1)":
+
+```
+
+On applique le semigroup-trick.
+
+```{walnut}
+%SGT new_first_fib fib NEW_fib
+```
+
+```{walnut}
+
+eval check_zero "?msd_fib $compl_fact_fib_V1(0,1)":
+eval check_rec "?msd_fib An,p,q ($compl_fact_fib_V1(n,p) & $compl_fact_fib_V1(n+1,q)) => p+NEW_fib[n] = q":
+
+```
+
+## Construction de la complexité en facteur à l'aide de NEW
+### Récupérer le morphisme associé à NEW
+
+```{walnut}
+%%python
+
+from pathlib import Path as P
+import os
+from licofage.kit import subst, address
+
+def readDFAO(f):
+    # lecture de tous les états, de leurs transitions et sortie
+    l = f.readline()
+    dfa = dict()
+    outputs = dict()
+    while l != '':
+        etat_data = l.split()
+        etat = int(etat_data[0].strip()) #on récupère le nom de l'etat
+        outputs[etat] = int(etat_data[1].strip())
+        transition = dict()
+        l = f.readline()
+        while "->" in l:
+            tr = l.split("->")
+            transition[int(tr[0].strip())] = int(tr[1].strip())
+            l = f.readline()
+        dfa[etat] = transition
+        l = f.readline()
+
+    return (dfa,outputs)
+
+def DFAtoSubst(dfa):
+    subst = ""
+    for etat in sorted(dfa.keys()):
+        subst += chr(etat+97)+" -> "
+        for lect in sorted(dfa[etat].keys()):
+            subst += chr(dfa[etat][lect]+97)
+        subst += " , "
+    return subst[:-2] ## pour la virgule ajoutée en trop
+
+def DFAOtoMorph(dfa,outputs):
+    subst = DFAtoSubst(dfa)
+    w = dict()
+    for key in outputs.keys():
+        w[chr(key+97)] = outputs[key]
+    return subst, w
+
+def getSubst(p:P):
+    with p.open('r') as f:
+        # atteindre le premier état
+        l = f.readline()
+        while l != '\n':
+            l = f.readline()
+        (dfa, outputs) = readDFAO(f)
+    return DFAOtoMorph(dfa, outputs)
+
+```
+
+### Calculer la complexité en facteur à l'aide de NEW
+
+`sumNEW(n,s)` : s est la somme des n-1 premières valeurs de NEW
+`compl_fact_fib_V2(n,p) : complexité en facteur synchronisée (obtenue à l'aide de NEW)
+
+```{walnut}
+%%python
+
+new_subst, w = getSubst(P(os.environ["WALNUT_HOME"])/"Word Automata Library"/"NEW_fib.txt")
+new = subst(new_subst)
+new_w = address(new, 'fib',**w)
+(new_w-ns).gen_dfa("sumNEW_fib")
+
+```
+
+```{walnut}
+
+def compl_fact_fib_V2 "?msd_fib Eq $sumNEW_fib(n,q) & p=q+1":
+
+```
+
+### Vérification du résultat
+
+`compl_fact_fib_V2` est calculée à l'aide de `NEW`. On ne peut pas utiliser la technique précédente pour vérifier notre prédicat. Par contre, on peut confronter `compl_fact_fib_V1` et compl_fact_fib_V2 car elle sont issues de deux méthodes différentes.
+
+```{walnut}
+
+eval check_V2 "?msd_fib An,p $compl_fact_fib_V1(n,p) <=> $compl_fact_fib_V2(n,p)":
+
+```