test mermaid

1-ComputationAndData/0Planning2025.md

@@ -31,18 +31,323 @@ L'objectif est de travailler en anglais (écouter, écrire, discuter) autour de
 
 ### séance du lundi 15/9. 
 
-Architecture : mémoire, processus etc.
+* Présentation de ce planning prévisionnel.
+* Survol des premiers cours (1 à 3): codage, binaire, ascii, utf-8, rôle d'un système d'exploitation.
+* Survol début cours architecture (cours 5): mémoire, processus, Circuit Booléen, ALU.
+* Introduction aux automates, exercices (cours 4).
+
+
 
 ### séance du lundi 29/9. 
 
-Modèle de calcul des automates finis.
+Modèle de calcul des automates finis (la suite).
+
+* Rappel du modèle des automates
+* Exemple du langage de a suivi du même nombre de b
+* Lemme de la pompe. Preuve par l'absurde que ce langage n'est pas reconnaissable par un automate
+* résultat qui montre les limitations des automates
+
+
+évocation d'autres résultats, plus faibles de séparation.
+
+* Ptime = efficace (sans définition)
+* NPTime = vérification efficace
+* Conjecture que les deux sont différents.
+
+Introduction du modèle de la machine de Turing
+
+* Exemples
+* évocation de l'universalité du modèle de Turing comme modèle de calcul (thèse de Church Turing).
+
+Discussion rapide des limites du modèle de Turing
+
+* Trop de problèmes par rapport aux nombres de machine de turing
+* Idée de la machine universelle
+* Problème de l'arrêt indécidable
+
+Retour sur le calcul modulaire en base 2 avec un automate.
+
+* Exemple pour tester si le reste vaut un en base deux dans la division par 3.
+
+Introduction informelle de la Machine Virtuelle à Pile comme modèle simplifié d'assembleur.
+
+
+
 
 ### séance du lundi 6/10. 
 
-Machine virtuelle à pile (MVàP).
+Un peu de background sur l'architecture, en particulier la hiérarchie de la mémoire d'une machine moderne. Illustration sur mon portable.
+
+* Registres : une dizaine 64 bits chaque.
+* Cache L1, L2, L3 : entre la RAM et les registres, quelques Mo (ma méchine 16 Mo Bytes).
+* RAM : plusieurs Giga (mémoire vive) 32 Ga sur ma machine
+* Disque : 1 Tera.
+
+à chaque étage, on fait en gros fois 1000. La vitesse d'accès (et le prix) est inversement proportionnel.
+
+Explication : assembleur pour chaque famille de processeur (dépend du fabriquant AMD ou Intel)
+
+En pratique: on a souvent un assembleur abstrait indépendant du matériel.
+La traduction d'un code de haut niveau se fait en deux temps. D'abord du langage de haut niveau vers cet assembleur, puis de cet assembleur vers le véritable assembleur du constructeur du processeur.
+
+Évocation Loi de Moore : doublement de la mémoire dans les années 80, 90, viser le bon bussiness plan car projet prend 10 ans entre début et livraison des premiers clients.
+
+Évocation: partage de la RAM entre chaque processus.
+Un processus a une pile (pour les choses petites) et un tas (pour les choses grandes). Sur la pile on indique l'adresse de quelque chose de gros dans le tas.
+
+Machine virtuelle à pile (MVàP). Un modèle académique simplifié.
+
+Rappel des instructions élémentaires pour faire des calculs sur la pile (pousser un entier, 4 opérations arithmétique). Exemple d'un calcul de moyenne avec deux notes et des coefficients différents.
+
+Présentation de l'intérêt d'avoir des variables dans la pile, et des entrées sorties avec l'utilisateur. Exemple avec le cacul de la moyenne précédent.
+
+Évolution du calcul de la moyenne, avec l'apparition d'un maximum. Il est nécessaire de pouvoir dépasser le stade d'instructions successives systématiques et d'avoir des blocs d'instructions, avec des sauts, en particuliers des sauts conditionnés ou résultat d'un test. 
+
+Formalisation d'un if-then-else avec la MVàP.
+
+Évocation de boucles. Formalisation d'une boucle while.
+
+
+
 
 ### séance du lundi 13/10. 
 
-Fin MVàP + révisions
+Fin MVàP + révisions automates finis
+
+#### MVàP
+
+Exemple de génération de code pour l'expression
+
+$$[(a+b)(a-b)]+[(b+1)*(b-1)]$$
+
+Arbre syntaxique de l'expression pour générer le code à pile dans le bon ordre.
+
+On remarque que l'expression peut s'écrire plus simplement en
+
+$$ a^2 -1 $$.
+
+Arbre syntaxique de cette expression simplifiée pour générer le code à pile dans le bon ordre.
 
 
+#### Révisions automates finis
+
+Rappel vocabulaire automate. 
+
+* Alphabet formée d'un nombre fini de symboles lus par l'automate, 
+* états (initial un seul, acceptant plusieurs possibles) en un nombre fini
+* calcul dans l'automate pour un mot en entrée, succession de état initial, première lettre, un état, une lettre lue etc.
+* Si dernier état (après la dernière lettre) est acceptant, on accepte le mot, sinon on rejette.
+
+On peut donner l'automate de 2 manières équivalentes.
+
+* soit graphiquement
+* soit sous forme de table de transition
+
+Si un calcul s'arrête en cours de mot on rejette. Cette situation correspond à une case vide de la table de transition.
+On peut remédier à cet aspect en ajoutant un état poubelle non acceptant (nommons le KO) en dernière ligne de la table de transition (avec KO partout, c'est un puit, on y reste coincé). En jargon de théorie des langages, on dit qu'on complète l'automate.
+
+Exercices de révision.
+
+On se place sur l'alphabet a,b. 
+Proposez un automate en expliquant bien le rôle des états pour les langages ci-dessous.
+
+Pour chaque langage, proposez un mot accepté et un mot rejeté puis illustrer le fonctionnement de votre automate en donnant le chemin de calcul pour ces 2 exemples.
+
+1. Le langage qui contient juste le mot ab.
+2. Le langage formée des mots qui contient ab (de la forme n'importe quoi puis ab puis n'importe quoi, n'importe quoi pouvant être vide).
+3. Le langage formé de successions du mot ab (au moins une fois ce motif).
+4. Le langage des mots qui commencent par ab.
+5. Le langage des mots qui terminent par ab.
+
+
+
+##### Correction Indicative.
+
+###### Le langage qui contient juste le mot ab.
+
+Un exemple de mot accepté : ab
+
+Un exemple de mot rejeté :  a (mais aussi le mot vide, b, bb, aa, aba, n'importe quel mot différent de ab).
+
+Idée de l'automate en décrivant les état.
+
+* q0 Il faut un état initial (je n'ai rien lu).
+* qa Il faut un état qui se souvient qu'il vient de lire un a.
+* qab Il faut un état qui se souvient qu'on vient de lire a puis b.
+
+On peut ajouter un état poubelle (KO).
+
+| état            | a  | b   |
+|:----------------|:---|:----|
+| q0 (initial)    | qa |  KO   |
+| qa              | KO   | qab |
+| qab (acceptant) | KO   |  KO   |
+| KO                | KO   | KO    |
+
+Exemples de calcul.
+
+Pour le mot ab:
+$$q0 \xrightarrow{a}{} qa \xrightarrow{b}{} qab$$
+qab est acceptant donc le mot est accepté.
+
+Pour le mot a:
+$$q0 \xrightarrow{a}{} qa$$
+qa est non-acceptant donc le mot est rejeté.
+
+
+
+
+
+###### Le langage formé de successions du mot ab (au moins une fois ce motif).
+
+Un exemple de mot accepté : abab
+
+Un exemple de mot rejeté : aba
+
+Idée de l'automate en décrivant les état.
+
+* q0 Il faut un état initial (je n'ai rien lu).
+* qa Il faut un état qui se souvient qu'il vient de lire un a.
+* qab Il faut un état qui se souvient qu'on vient de lire a puis b.
+
+On peut ajouter un état poubelle (KO).
+
+| état            | a  | b   |
+|:----------------|:---|:----|
+| q0 (initial)    | qa | KO  |
+| qa              | KO | qab |
+| qab (acceptant) | qa | KO  |
+| KO              | KO | KO  |
+|                 |    |     |
+
+Exemples de calcul.
+
+Pour le mot abab :
+$$q0 \xrightarrow{a}{} qa \xrightarrow{b}{} qab \xrightarrow{a}{} qa \xrightarrow{b}{} qab $$
+qab est acceptant donc le mot abab est accepté.
+
+
+Pour le mot aba:
+$$q0 \xrightarrow{a}{} qa \xrightarrow{b}{} qab \xrightarrow{a}{} qa$$
+qa est non-acceptant donc le mot aba est rejeté.
+
+######  Le langage des mots qui commencent par ab.
+
+Exemple pour oui : aba
+Exemple pour non : a (ou b, ou ba, ou bb, aa, n'importe quoi qui ne commence pas par ab).
+
+On peut changer facilement l'automate qui accepte seulement le mot ab.
+Il suffit d'accepter ensuite.
+
+| état            | a  | b   |
+|:----------------|:---|:----|
+| q0 (initial)    | qa | KO  |
+| qa              | KO | qab |
+| qab (acceptant) | **qab** | **qab**  |
+| KO              | KO | KO  |
+
+Pour le mot aba :
+$$q0 \xrightarrow{a}{} qa \xrightarrow{b}{} qab \xrightarrow{a}{} qab $$
+qab est acceptant donc le mot abab est accepté.
+
+
+Pour le mot bab:
+$$q0 \xrightarrow{b}{} KO \xrightarrow{a}{} KO \xrightarrow{b}{} KO$$
+KO est non-acceptant donc le mot bab est rejeté.
+
+
+######  Le langage des mots qui terminent par ab.
+
+Exemple pour le oui : aaabab
+
+Exemple pour le non : aa
+
+On peut proposer un automate déterministe en utilisant le principe qui consiste à mémoriser dans les états les deux dernières lettres lues.
+Il est facile de mettre à jour les fenêtres quand on lit une nouvelle lettre à droite.
+
+Par exemple la fenêtre aa suivi de b devient la fenêtre ab.
+
+Pour le début du mot, il faut des fenêtres partielles pour le mot vite (état initial q0), la lettre a (état qa), la lettre b (état qb).
+
+| état            | a   | b   |
+|:----------------|:----|:----|
+| q0 (initial)    | qa  | qb  |
+| qa              | qaa | qab |
+| qb              | qba | qbb |
+| qaa             | qaa | qab |
+| qab (acceptant) | qba | qbb |
+| qba             | qaa | qab |
+| qbb             | qba | qbb |
+
+
+###### Le langage formée des mots qui contient ab (de la forme n'importe quoi puis ab puis n'importe quoi, n'importe quoi pouvant être vide).
+
+On peut reprendre l'automate déterministe précédent. Il suffit de transformer l'état qab en un puit acceptant (on a rencontré le motif ab on est content).
+
+| état            | a   | b   |
+|:----------------|:----|:----|
+| q0 (initial)    | qa  | qb  |
+| qa              | qaa | qab |
+| qb              | qba | qbb |
+| qaa             | qaa | qab |
+| qab (acceptant) | **qab** | **qab** |
+| qba             | qaa | qab |
+| qbb             | qba | qbb |
+
+
+**Retour sur le non déterministe.**
+
+Si on a quelque part dans la table de transition deux états ou plus dans une case, on a un choix.
+Dans ce cas un calcul peut en fait avoir plusieurs branches.
+On a un **arbre de calcul** plutôt qu'un chemin unique.
+
+On accepte un mot, si l'arbre de calcul a un chemin acceptant.
+
+On peut facilement produire par exemple un automate non déterministe pour les mots qui terminent par ab.
+
+![Automates non détermniniste pour les mots qui terminent par ab](JFLAP/NDFAendsInab.jpg)
+
+On a vu en cours l'arbre de calcul pour le mot abab.
+Il y a trois chemins acceptants dont un seul accepte en terminant dans l'état acceptant (le chemin du milieu ci-dessous).
+
+
+
+```mermaid
+
+graph TD;
+    R((q0))-->|a|R0((q0));
+	R0((q0))-->|b|R00((q0));
+    R00((q0))-->|a|R000((q0));
+    R000((q0))-->|b|R0000((q0));
+	R00((q0))-->|a|R001((q1));
+    R001((q1))-->|b|R0010(((q2)));
+	
+    R((q0))-->|a|R1((q1));
+    R1((q1))-->|b|R10(((q2)));
+	R10(((q2)))-->|a|R100(((q3)));
+    R100((q3))-->|a|R1000((q3));
+```
+
+
+
+Peut-on toujours trouver un automate déterministe?
+
+Oui. On peut fabriquer un automate qui simule en parralèle tous les chemins de calculs. JFLAP permet de faire la transformation. Par défaut il renomme les états mais indique dans un label les numéros des états correspondant dans l'automate initial. Par exemple, 1,0 veut dire que cet état correspond à la situation de chemins parallèles qui nous positionne à la fois en 0 et 1.
+
+Comme l'automate non déterministe accepte quand un chemin de calcul accepte, un état "multiple" de l'automate déterministe accepte si il contient un état acceptant de l'automate non déterministe de départ. Dans notre exemple tous les états qui contiennent q2.
+
+![Automates non détermniniste pour les mots qui terminent par ab](JFLAP/DFAendsInabViaDetermnisation.jpg)
+
+Le chemin de calcul de cet automate correspond à ce qui se passe quand on écrase l'arbre de calcul de l'automate original (en enlevant les répétitions éventuelles de noms d'états).
+
+```mermaid
+
+graph TD;
+    R((0))-->|a|R0((0,1));
+	R0 -->|b|R00(((0,2)));
+    R00 -->|a|R000((0,1,3));
+    R000-->|b|R0000(((0,2,3)));
+
+```
+
+C'est cette correspondance entre arbre de calcul et chemin de calcul pour n'importe quel mot qui permet de montrer que les deux automates reconnaissent le même langage.

1-ComputationAndData/1ComputationAndData.md

@@ -1,3 +1,4 @@
+Ce cours sera survolé.
 
 # Système de fichier, Codage et découverte du terminal. I/II
 

1-ComputationAndData/2ComputationAndData.md

@@ -1,3 +1,5 @@
+Ce cours ne sera pas traité
+
 # Système de fichier, Codage et découverte du terminal II/II
 
 ## Éditeur et fichier texte

1-ComputationAndData/3ComputationAndData.md

@@ -1,3 +1,5 @@
+Ce cours sera survolé.
+
 # Calculer en théorie et en pratique I/III
 
 Dans la prochaine séquence de cours, nous allons tenter de répondre à la question suivante.

1-ComputationAndData/4ComputationAndData.md

@@ -1,4 +1,4 @@
-Cours de Florent.
+Ce cours sera fait en détail
 
 # Calculer en théorie et en pratique II/III
 

1-ComputationAndData/5ComputationAndData.md

@@ -1,4 +1,4 @@
-Cours de Florent.
+Ce cours sera fait en détail.
 
 # Calculer en théorie et en pratique III/III
 

1-ComputationAndData/6ComputationAndData.md

@@ -1,3 +1,5 @@
+Ce cours sera vu de manière plus ou moins complète si le temps le permet.
+
 # Quelques constructions autour des automates.
 
 Nous avons vu le modèle des automates finis.

1-ComputationAndData/MVaP/CalculExpressionAvecvaraEtvarb.mvap

@@ -0,0 +1,61 @@
+#
+# Calcul de l'expression E = [(a+b)*(a-b)]+[(b+1)*(b-1)]
+# On commence par gérer les variables a et b et demander
+# des valeurs à l'utilisateur (avec READ) pour les affecter (avec STOREG).
+# Ensuite on utilise la valeur des variables dans le calcul (avec PUSHG)
+# L'ordre dans lequel on écrit le code MVàP pour calculer l'expression E
+# dépent de l'arbre syntaxique de cette expression.
+# Dans le code ci-dessous les commentaires indiquent cet ordre
+#
+#                                         +(1)
+#                *(2)                                  *(3)
+#       +(4)              -(5)                 +(6)          -(7)
+#   Var a   Var b     Var a     Var b      Var b Cons 1    Var b  Cons 1
+#
+#  Les feuilles sont de type Variable ou constantes.
+#  Les noeuds internes sont des opérations.
+#  On navigue dans l'arbre vers le bas, d'abord à gauche, puis on remonte,
+# on va explorer le fils droit, puis on remonte et on écrit le code du
+# noeud interne.
+# 
+#  gestion des variables a et b
+
+PUSHI 0 # a (habite à l'adresse 0)
+PUSHI 0 # b (habite à l'adresse 1)
+
+# demander à l'utilisateur les valeurs de a et b
+READ
+STOREG 0
+READ
+STOREG 1
+
+
+# gestion du calcul de l'expression.
+
+
+PUSHG 0 # met la valeur de a sur la pile (adresse 0)
+PUSHG 1 # idem pour b                    (adresse 1)
+ADD     # +(4) de mon dessin de l'arbre
+PUSHG 0 # met la valeur de a sur la pile
+PUSHG 1 # idem pour b
+SUB     # -(5) de mon dessin de l'arbre
+MUL     # *(2) de mon dessin de l'arbre
+
+PUSHG 1 # met la valeur de b sur la pile
+PUSHI 1 # la constante 1
+ADD     # +(6) de mon dessin de l'arbre
+PUSHG 1 # met la valeur de b sur la pile
+PUSHI 1 # la constante 1
+SUB     # -(7) de mon dessin de l'arbre
+MUL     # *(3) de mon dessin de l'arbre
+
+ADD    # Ajout des deux sous-arbres [(a+b)*(a-b)] et [(b+1)*(b-1)]
+       # +(1) de mon dessin de l'arbre
+
+WRITE # écrire le résultat de (a+b)*(a-b)
+POP   # effacer le résultat du calcul
+
+### suppression des variables
+POP
+POP
+HALT

1-ComputationAndData/MVaP/CalculExpressionAvecvaraEtvarbEnSimplifiantExperssion.mvap

@@ -0,0 +1,48 @@
+# Calcul de l'expression E = [(a+b)*(a-b)]+[(b+1)*(b-1)]
+#
+# On simplifie d'abord l'expression.
+#
+# The dreaded 'identités remarquables'...
+# (a+b)*(a-b) = a^2 - b^2
+# (b-1)*(b+1) = b^2 - 1^2 = b^2 - 1
+# En caculant on obtient au final pour E l'expression simplifiée suivante
+# a^2 - 1
+#
+#
+# Arbre syntaxique de l'expression simplifiée.
+#
+#                          -(1)
+#           *(2)                          Cons 1 (5)
+#      Var a(3)     Var a (4)          
+
+
+# gestion des variables a et b
+
+PUSHI 0 # a (habite à l'adresse 0)
+# PUSHI 0 # b est inutile maintenant 
+
+# demander à l'utilisateur les valeurs de a et pas de b qui ne sert à rien
+READ
+STOREG 0
+# READ
+# STOREG 1
+
+
+# gestion du calcul de l'expression.
+
+PUSHG 0 # (3)
+PUSHG 0 # (4)
+MUL     # (2)
+PUSHI 1 # (5)
+SUB     # (1)
+
+# écrire le résultat et enlever le résultat de la pile
+
+WRITE
+POP
+
+
+### suppression des variables
+
+POP
+HALT

1-ComputationAndData/MVaP/ExempleCalculMoyenneFetX.mvap

@@ -0,0 +1,68 @@
+#### Exemple vu en cours le 6/10/2025 (calcul de moyenne de F et X,
+### Max (1/3F+2/3 X; X)
+
+
+PUSHI  0 # F habite à l'adresse 0
+PUSHI  0 # X habite à l'adresse 1
+
+
+PUSHI  0 # R1 habite à l'adresse 2
+PUSHI  0 # R2 habite à l'adresse 3
+PUSHI  0  # R3 habite à l'adresse 4
+
+READ
+STOREG 0
+
+READ
+STOREG 1
+
+# PUSHG  adr # valeur sur la pile
+# STOREG adr # MàJ de la variable
+# 
+#
+# Je calcule F/3 et je le stocke dans R1
+PUSHG 0   # récupère valeur de F
+PUSHI 3
+DIV
+STOREG 2
+# Je calcule X*2/3 et je stocke dans R2
+PUSHG 1   # récupère la valeur de X
+PUSHI  2
+MUL
+PUSHI  3
+DIV
+STOREG 3
+# Je fais la somme des deux et je l'écris dans R3
+PUSHG 2 # valeur de R1
+PUSHG 3 # valeur de R2
+ADD
+STOREG 4 # affectation de R3
+
+
+
+### du code avec branchement ici : Max de X et R3.
+
+# Je veux récupérer R3 et X
+PUSHG 1 # X
+PUSHG 4 # R3
+SUP
+JUMPF 0 # si faux il faut écrire R3
+# si plus petit (test vrai pas de saut), je veux écrire X
+PUSHG 1 # X
+JUMP  1
+
+# sinon je veux écrire R3
+LABEL 0 # le cas 
+PUSHG 4 # R3
+JUMP 1
+# Je veux écrire la bonne valeur
+LABEL 1 # la partie du code qui écrit (la suite)
+WRITE
+POP
+# vider la mémoire
+POP
+POP
+POP
+POP
+POP
+HALT