test mermaid

modifié :         2-InformationTheory/4Brevet.md
	supprimé :        "Brevets/2023-24-R\303\251partition choix de brevets - th\303\251orie de l'information.xlsx"
	supprimé :        Brevets/Equipe1_EP01202556NWA1.pdf
	supprimé :        Brevets/Equipe2_EP 1761067 A1 .pdf
	supprimé :        Brevets/Equipe3_US5732138.pdf
	supprimé :        Brevets/Equipe4_WO2012006106A2.pdf
	supprimé :        Brevets/Equipe5_FR 3024006 A1 .pdf
	supprimé :        Brevets/Equipe6_FR 3044196 A1 .pdf
	supprimé :        Brevets/Equipe7_EP 3373509 A1 .pdf
	supprimé :        Brevets/Equipe8_FR 3057727 A1 .pdf
	supprimé :        Brevets/SupportsPresentation/Equipe1PhillipsBrevetEuropeCodeDetecteurEtCorrecteurPourVideoAdaptatifConnexion.pdf
	supprimé :        Brevets/SupportsPresentation/Equipe2_Script_Sony_CompressionPhoto.pdf
	supprimé :        Brevets/SupportsPresentation/Equipe2_Slides_Sony_CompressionPhoto.pdf
	supprimé :        Brevets/SupportsPresentation/Equipe3PseudoAleatoireLampeALave.pdf
	supprimé :        Brevets/SupportsPresentation/Equipe4_Slide_Intel_CompressionEtCorrectionDisqueSSD.pdf
	supprimé :        Brevets/SupportsPresentation/Equipe5_Slide_CompressionInterneImage.pdf
	supprimé :        Brevets/SupportsPresentation/Equipe6_Script_THALES_CompressionPresqueSansPerteImagesHauteResSatellite.docx
	supprimé :        Brevets/SupportsPresentation/Equipe6_Slides_THALES_CompressionPresqueSansPerteImagesHauteResSatellite.pptx
	supprimé :        Brevets/SupportsPresentation/Equipe8_Script_Enedis_CompressionEnTeteIPV6_ProtocoleReseau.pdf
	supprimé :        Brevets/SupportsPresentation/Equipe8_Slides_Enedis_CompressionEnTeteIPV6_ProtocoleReseau.pdf
	modifié :         python/2/0LoopOnWord.py
	modifié :         python/2/1LoopOnWord.py
	modifié :         python/2/2Rot13.py
	modifié :         python/2/3Rot13.py
	modifié :         python/2/4Rot13.py

1-ComputationAndData/0Planning2025.md

@@ -0,0 +1,353 @@
+# Planning 2025
+
+### Science du calcul et des données.
+
+* lundi 15/9. Architecture : mémoire, processus etc.
+* lundi 29/9. Modèle de calcul des automates finis.
+* lundi 6/10. Machine virtuelle à pile (MVàP).
+* lundi 13/10. Fin MVàP + révisions
+
+à planifier un examen sur table.
+
+Ce cours est un peu réduit par rapport aux autres années (moins de séances).
+Pas de détails sur le codage des fichiers dont le texte (ASCII, UTF-8), ni sur le système des fichiers (arborescence, comment c'est codé etc), ni sur les commandes unix.
+
+### Anglais
+
+L'objectif est de travailler en anglais (écouter, écrire, discuter) autour de sujets en lien avec l'informatique, soit historique, soit plus récents et en lien avec le droit.
+
+* lundi 17/11. Présentation de page du manuel unix en anglais.
+               Discussion d'articles de Alan Turing. 
+               Présentation de ressources en anglais pour continuer la suite du cours sous la forme d'un séminaire participatif.
+* lundi  8/12. à organiser selon choix sujets étudiants
+* lundi 15/12. à organiser selon choix sujets étudiants
+
+évaluation en cours: participation + présentation en petit groupes.
+
+'''
+
+## Détails des séances.
+
+
+### séance du lundi 15/9. 
+
+* 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 (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. 
+
+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 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.html

@@ -0,0 +1,153 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+
+<head>
+<title>3ComputationAndData.html</title>
+<meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>
+
+</head>
+
+<body>
+
+<h1>Calculer en théorie et en pratique I/III</h1>
+
+<p>Dans la prochaine séquence de cours, nous allons tenter de répondre à la question suivante.</p>
+
+<p>C'est quoi un ordinateur?</p>
+
+<p>Cette question s'apparente à celle que ce sont posés philosophes et mathématiciens de Leibnitz à Turing en passant par Hilbert.</p>
+
+<p>Qu'est-ce qu'une question à laquelle on peut répondre de manière mécanique par un calcul?</p>
+
+<p>Nous allons explorer rapidement ce sujet en évoquant à la fois des modèles théoriques et des explication sur l'architecture matérielle et le fonctionnement d'ordinateurs modernes.</p>
+
+<h2>Calcul Matériel.</h2>
+
+<p>Initialement, les "computer" sont des humains, qui s'aident de divers mécanisme pour faire des calculs rapidement en essayant de faire le moins d'erreurs possibles, par exemple avec un boulier ou des cordes nouées. </p>
+
+<p>Les premières machines à calculer sont mécaniques et peuvent être discrètes (nombre fini de position avec par exemple des roues crantées) ou continues (position continue sur un astrolabe ou une table à tracer pour calculer des intégrales). </p>
+
+<p>Les machines modernes possèdent différents composants electroniques et ce sont les transistors qui permettent de passer d'une information analogique/continue </p>
+
+<blockquote>
+  <p>quelle est la puissance du courant?</p>
+</blockquote>
+
+<p>à une information discrète, oui ou non, qu'on peut interpréter comme 0 ou 1.</p>
+
+<blockquote>
+  <p>est-ce-que le courant dépasse un certain seuil?</p>
+</blockquote>
+
+<p>On peut à l'aide de quelques composants de base faire des calculs sur ces valeurs 0 ou 1. On parle alors de calcul Booléen (du nom du logicien Boole).</p>
+
+<h3>circuit booléen</h3>
+
+<p>consiste en
+1. des entrées contenant des valeurs booléennes.
+1. des portes logiques permettant de calculer
+   * le ET binaire (&amp;) 
+   * le OU binaire (v)
+   * la négation NON unaire (-)
+1. des "cables" pour relier ces portes
+1. des sorties correspondant à la sortie du calcul.</p>
+
+<p>Au tableau
+* table du ET
+* table du OU
+* table du NON</p>
+
+<h3>exercices</h3>
+
+<ol>
+<li>Écrire la table de Non de x ou y.</li>
+<li>Décrire un circuit permettant de tester si deux entrée x et y sont égales.
+Le circuit doit renvoyer 1 si c'est le cas et 0 sinon.
+NB. on peut noter cette opération &lt;-> ou </li>
+<li>Même question pour le circuit qui permet de calculer le XOR (Ou eXclusif).</li>
+<li>Même question pour le circuit permettant de calculer la majorité de trois arguments</li>
+</ol>
+
+<h3>Digression : le schéma de chiffrement de Vernam</h3>
+
+<p>Il s'agit d'un schéma très simple et incassable à moins de connaître la clé secrète.
+L'inconvénient est qu'il faut fabriquer et partager avec son destinataire une clé secrète aussi longue que le message. On parle aussi de "one time pad" en anglais.</p>
+
+<p>Pendant la seconde guerre mondiale, à Bletchley Park, des opératrices fabriquaient de telles clés mais en quantité trop réduite. Une tentative de mécanisation pour pallier à ce soucis a permis de générer des clés rapidement mais qui avaient une différence avec les véritables clés.</p>
+
+<blockquote>
+  <p>"Enoch, why are you . . . here?"</p>
+  
+  <p>"Oh. I am here, in a larger sense, because Mrs. Tenney, the vicar’s wife, has become sloppy, and forgot>ten to close her eyes when she takes the balls out of the bingo machine."</p>
+  
+  <p>Neal Stephenson. Cryptonomicon.</p>
+</blockquote>
+
+<p><a href="https://crypto.stackexchange.com/questions/25214/has-human-generated-entropy-ever-been-a-real-problem">Discussion sur stackexchange</a></p>
+
+<p>Nous allons mettre en oeuvre ce chiffrement.
+1. Tout d'abord le message à chiffrer M, qu'on suppose encodable en ASCII est transformé en un séquence de 0 et de 1 qu'on note B.
+1. La clé secrète S est une série de 0 et de 1 de même longueur.
+1. On additionne "modulo 2" B à S pour obtenir le message chiffré C (c'est le XOR de tout à l'heure).
+1. On transmet le message chiffré C au destinataire.
+1. La destinataire reçoit C.
+1. Pour décoder, elle procède de même mais à l'envers.
+   * ajout de S à C
+   * découpage en bloc de 7 bits
+   * décodage ASCII</p>
+
+<p><a href="https://fr.wikipedia.org/wiki/American_Standard_Code_for_Information_Interchange">page du code ASCII</a></p>
+
+<p>NB. pour faire plus proche de la réalité, on préfixe le code ASCII d'un 0 pour obtenir un octet.</p>
+
+<h3>exercice</h3>
+
+<p>Nous allons mettre en oeuvre ce chiffrement pour le mot BINGO.
+Fabriquez au préalable une clé de la taille adapté
+(vous pouvez par exemple tirer à pile ou face successivement). </p>
+
+<p>Pour simplifier, vous pouvez le faire avec OK.</p>
+
+<p>Réfléchissez à une mise en oeuvre pratique sur papier.</p>
+
+<h2>Retour à nos circuits.</h2>
+
+<p>Nous allons maintenant mettre en oeuvre des circuits pour faire des opérations arithmétiques.</p>
+
+<ol>
+<li>Même question pour un circuit qui réalise une somme "modulo 2"
+NB. c'est le chiffrement de Vernam.</li>
+<li>Même question pour un circuit qui réalise une somme en binaire.
+Pour ce second circuit on s'autorise une porte de duplication notée D qui prend en entrée x et a deux sorties valant toutes deux x.</li>
+</ol>
+
+<h3>Indication.</h3>
+
+<p>Pour rappel en binaire 1+1 vaut 10; 1+0 comme 0+1 valent 1; et, 0+0 vaut 0.</p>
+
+<p><strong>Exemple</strong>
+```
+0110</p>
+
+<h1>0111</h1>
+
+<p>...1
+..01 retenue 1
+.101 retenue 1
+1101 Fin
+```</p>
+
+<h3>Indication 2</h3>
+
+<p>2 questions rhétoriques :</p>
+
+<ul>
+<li>Comment faire la retenue?</li>
+<li>Comment calcule la somme dans la même colonne?</li>
+</ul>
+
+</body>
+</html>

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/JFLAP/NDFAaabcc.jff

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?><!--Created with JFLAP 7.1.--><structure>
+	<type>fa</type>
+	<automaton>
+		<!--The list of states.-->
+		<state id="0" name="q0">
+			<x>417.0</x>
+			<y>289.0</y>
+			<initial/>
+		</state>
+		<state id="1" name="q1">
+			<x>616.0</x>
+			<y>259.0</y>
+		</state>
+		<state id="2" name="q2">
+			<x>736.0</x>
+			<y>256.0</y>
+		</state>
+		<state id="3" name="q3">
+			<x>741.0</x>
+			<y>341.0</y>
+		</state>
+		<state id="4" name="q4">
+			<x>625.0</x>
+			<y>342.0</y>
+		</state>
+		<state id="5" name="q5">
+			<x>510.0</x>
+			<y>403.0</y>
+			<final/>
+		</state>
+		<!--The list of transitions.-->
+		<transition>
+			<from>0</from>
+			<to>0</to>
+			<read>a</read>
+		</transition>
+		<transition>
+			<from>5</from>
+			<to>5</to>
+			<read>a</read>
+		</transition>
+		<transition>
+			<from>0</from>
+			<to>0</to>
+			<read>b</read>
+		</transition>
+		<transition>
+			<from>5</from>
+			<to>5</to>
+			<read>b</read>
+		</transition>
+		<transition>
+			<from>0</from>
+			<to>0</to>
+			<read>c</read>
+		</transition>
+		<transition>
+			<from>5</from>
+			<to>5</to>
+			<read>c</read>
+		</transition>
+		<transition>
+			<from>3</from>
+			<to>4</to>
+			<read>c</read>
+		</transition>
+		<transition>
+			<from>0</from>
+			<to>1</to>
+			<read>a</read>
+		</transition>
+		<transition>
+			<from>1</from>
+			<to>2</to>
+			<read>a</read>
+		</transition>
+		<transition>
+			<from>2</from>
+			<to>3</to>
+			<read>b</read>
+		</transition>
+		<transition>
+			<from>4</from>
+			<to>5</to>
+			<read>c</read>
+		</transition>
+	</automaton>
+</structure>

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

1-ComputationAndData/archive_24_25/1ComputationAndData.md

@@ -0,0 +1,57 @@
+
+# Système de fichier, Codage et découverte du terminal. I/II
+
+## Introduction
+
+Il existe une couche entre les logiciels qu'un utilisateur emploie et le matériel.
+Il s'agit d'un logiciel dédié, qu'on appelle système d'exploitation en français, *operationnel system* en anglais.
+D'où l'abbréviation OS.
+
+Cette couche particulière permet aux logiciels d'interagir de manière standardisée, indépendamment du choix concret du matériel.
+
+Elle est responsable en particulier : de gérer divers utilisateurs avec des droits différents, de permettre à ces derniers de stocker des données sous forme de fichier et de les organiser, et finalement de gérer l'exécution de calculs. C'est une brique essentielle en ce qui concerne la sécurité.
+
+Le système d'exploitation n'est pas vraiment l'interface graphique, qui est elle-même un logiciel particulier.
+
+Nous allons dans cette première séquence en fait plonger dans un version qui prédate l'interface graphique, qu'on appelle *la ligne de commande* en jargon.
+Jusqu'au milieu des année 80, cette forme d'interaction est essentiellement la seule possible.
+Progressivement, les usagers n'utilisent plus la ligne de commande pour utiliser logiciels qui passent par la couche graphique.
+
+La ligne de commande reste un mode d'interaction privilégié pour des experts, en particulier pour des informaticiens dont le travail consiste à installer, configurer et gérer un parc informatique et une architecture réseau. En jargon, on parle d'ingénieur système et réseaux.
+
+
+## Terminal à la linux
+
+Nous allons commencer par travailler en ligne de commande dans un (émulateur de) terminal.
+
+Vous pouvez soit le faire directement si vous avez un Mac car le système d'exploitation est basé sur une distribution de linux.
+
+Alternativement si vous avez un pc sous windows, comme le terminal du système d'exploitation windows est trop différent (power shell), vous pouvez installer WSL (Windows Subsystem for Linux)
+
+<details>
+<summary>Installer WSL</summary>
+Installation Ubuntu sous windows (WSL, ubuntu via couche machine virtuelle hyperV).
+[https://en.wikipedia.org/wiki/Windows_Subsystem_for_Linux](WSL)
+</details>
+
+<details>
+<summary>Linux windows dual boot</summary>
+Installation Ubuntu à côté de windows. Bien suivre les règles de sauveguarde de vos données au préalable.
+[https://help.ubuntu.com/community/WindowsDualBoot](dual boot)
+</details>
+
+Pour simplifier, vu que nous n'avons pas vraiment besoin de conserver des données dans le cadre de ce cours, nous allons travailler avec un service en ligne permettant de travailler sur une machine virtuelle Linux à distance dans un navigateur web. Ceci ne nécessite aucune installation.
+Je vais juste vous transmettre le lien à chaque cours ainsi que le login et mot de passe.
+
+[https://tel.marionnet.org](marionnet)
+
+## Codage
+Codage, en particulier binaire et ASCII.
+
+Exemple avec les salles de la fac de droit en binaire.
+
+Contraste base 10 et base 2.
+
+## Arborescence fichier
+répertoire (noeuds internes) vs
+Fichier (feuilles)

1-ComputationAndData/archive_24_25/2ComputationAndData.md

@@ -0,0 +1,360 @@
+# Système de fichier, Codage et découverte du terminal II/II
+
+## Éditeur et fichier texte
+
+Qu'on programme ou qu'on prépare un mail, il faut éditer un fichier texte.
+Ce texte va transiter sur le réseau ou être stocké dans un fichier selon un code bien choisi. 
+
+Le code ASCII est inspiré de code pour le télégraphe, comme le code Baudot (1870) : c'est un standard américain initialement pour teleprinter (Bell lab 1961). Il comporte en plus des codes pour des caractères imprimables (chiffres, lettres minuscules et majuscules latines, etc) de nombreux codes pour des opérations spécifiques au mécanisme de communication d'un teleprinter maintenant obsolètes.
+
+[Code Baudot](https://en.wikipedia.org/wiki/Baudot_code)
+[ASCII](https://en.wikipedia.org/wiki/ASCII)
+
+### digression
+L'ordre des charactères induit par la valeur de leur code ASCII est utilisé pour trier du texte ASCII.
+> ASCII-code order is also called ASCIIbetical order
+
+Trier, stocker, indexer et chercher de l'information sont des tâches essentielles qu'on automatise dès la fin du XIXe siècle.
+
+Pour automatiser le recensement américain (le census de 1880 a demandé 8 ans...), Herman Hollerith met au point une machine electro-mécanique manipulant des cartes perforées et flottant dans des bains de mercure. Son entreprise et 4 autres forment un conglomérat qui deviendra IBM en 1924.
+
+[Machines à tabuler](https://en.wikipedia.org/wiki/Tabulating_machine)
+
+### Et si notre alphabet est plus grand?
+Pour tester un clavier, ou exhiber une fonte, on peut en anglais écrire.
+> The quick brown fox jumps over the lazy dog
+
+En français, on pourra utiliser
+> Dès Noël, où un zéphyr haï me vêt de glaçons würmiens, je dîne d’exquis rôtis de bœuf au kir, à l’aÿ d’âge mûr, &cætera.
+
+[tester un clavier](https://fr.wikipedia.org/wiki/The_quick_brown_fox_jumps_over_the_lazy_dog)
+
+De nombreux pays vont donc étendre/changer le code ASCII pour y introduire leurs symboles (par exemple les accents en français) avec un soucis d'internationalisation.
+En effet, le code ascii ne peut pas facilement accommoder tous les alphabets même si on se restreint aux alphabets latins ou grecs car nous avons seulement 7 bits soit 2^7=128 codes.
+On ajoute donc un bit de plus pour permettre d'échanger des données textuelles "internationales".
+
+[ISO/IEC 8859](https://en.wikipedia.org/wiki/ISO/IEC_8859)
+
+Il y a en fait 15 variantes selon les besoins de langues avec des besoins proches.
+Un des plus connu, adapté pour le français, est la version 1
+
+[latin-1](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
+
+Ces systèmes restent trop limités car ni vraiment adapté pour de la typographie, ni applicable pour tous les alphabets en usage. 
+Depuis 2008, le standard est l'UTF-8 (sur le web initialement). 
+C'est une abbréviation de
+
+> Unicode Transformation Format – 8-bit
+
+où Unicode signifie
+
+> Universal Coded Character Set
+
+Une idée intéressante de ce code est qu'on va utiliser un **nombre variable de bytes** (entre 1 et 4). 
+Typiquement ce qu'on codait en ASCII prendra 1 byte, toutes les langues couvertes par la norme ISO 8859 pourront coder leurs caractères avec au plus 2 bytes, les caractères fréquents de CJK avec 3 bytes et le reste avec 4 permet de coder des symboles moins fréquents (de math, des emoji etc). 
+
+[UTF-8](https://en.wikipedia.org/wiki/UTF-8)
+
+## Discussion au tableau de UTF-8
+Calcul du nombre de symboles qu'on peut coder.
+Perte de place pour les symboles codés par 1 bloc, 2 blocs, 3 blocs, 4 blocs.
+
+évocation du changement de pratique autres systèmes de codage vs UTF-8 (graphiques sur wikipedia).
+
+### Détails techniques de WSL
+
+Le système de fichier linux WSL est monté dans le système windows.
+On peut a priori transférer des fichiers vers windows mais pas l'inverse.
+
+Linux ne permet a priori pas d'accéder au système de fichier windows.
+
+Attention. si vous réinstallez WSL vous allez écraser votre home et tout le travail fait sous linux.
+
+[Où est le home linux sous WSL](https://superuser.com/questions/1185033/what-is-the-home-directory-on-windows-subsystem-for-linux)
+
+Vous pouvez lancer dans l'explorateur de fichier windows le home linux en saisissant dans votre terminal linux la commande suivante.
+
+```bash
+explorer.exe .
+```
+
+Si vous avez installé WSL sans créer de compte utilisateur, vous êtes l'administrateur système linux, connu sous le nom de root. L'invite du terminal indique un dièse \#
+
+Pas de danger vous ne pouvez rien casser dans le système windows.
+
+Par contre par défaut vous êtes dans ... system32 le répertoire système de windows.
+Le système winos ne vous laisse pas écrire de fichier à cet endroit.
+Il faut vous placer ailleur, par exemple en saisissant la commande suivante.
+
+
+```bash
+cd
+```
+
+
+### explication au tableau de la navigation
+
+   _ .. pour revenir en arrière
+   _ . pour là où on est
+   _ ~ pour votre home linux
+   _ / pour la racine du système de fichier linux.
+
+Question ontologique de l'oeuf ou la poule: qui est le .. de / ?
+
+
+
+### exercice
+
+1. Ouvrez un terminal.
+1. Créer un répertoire folderA (commande mkdir).
+1. Placez vous dans ce répertoire (commande cd, pour change directory).
+1. Créer un fichier vide grapevine.txt (commande touch).
+1. Ouvrez le avec un éditeur de texte (par exemple gedit ou emacs voir nano ou vim).
+1. Copiez dans ce fichier un texte de votre choix avec de nombreux caractères qui ne sont pas codable en ascii.
+1. Sauvez le.
+1. Envoyez un mail avec en pièce jointe ce fichier à votre voisine ou voisin de table.
+1. Ouvrez le fichier de votre voisin, sauvez le sous le nom grapevine2.txt et testez si vous pouvez lire le fichier correctement avec votre éditeur.
+
+Parfois votre éditeur ne détectera pas correctement et automatiquement le codage.
+Vous pouvez dans certains cas forcer ce codage (e.g. dans emacs Options-Multilingual environment).
+
+### exercice
+la commande suivante permet de revenir dans le répertoire parent.
+```bash
+cd .. 
+```
+
+Complétez votre arborescence pour arriver à celle-ci.
+```
+folderA
+  grapevine.txt
+  grapevine2.txt
+  folderAA
+    toto.txt
+    titi.txt
+folderB
+    toto.txt
+folderC
+    tata.txt
+```
+
+NB. vous pouvez le faire sans utiliser un éditeur ni un logiciel de naviguation de fichier graphique. Seulement en ligne de commande.
+
+La commande 
+
+```bash
+man
+```
+permet d'avoir accès au manuel.
+
+testez par exemple
+
+```bash
+man ls
+```
+lisez cette documentation pour chercher l'option qui permet un affichage récursif.
+
+
+**Correction Indicative**
+
+```bash
+mkdir folderA
+mkdir folderB
+mkdir folderC
+cd folderA/
+touch grapevine.txt
+mkdir folderAA
+cd folderAA/
+touch toto.txt
+touch titi.txt
+cd ../
+cd ..
+cd folderB
+touch toto.txt
+cd ..
+cd folderC/
+touch tata.txt
+cd ..
+ls -R
+history | cut -c 8-
+```
+
+NB. la dernière commande permet d'enlever les numéros de l'historique. 
+    Le | (on dit pipe) permet d'envoyer le résultat de history dans la commande cut.
+    La commande cut avec ces options permet d'enlever le numéro de l'historique.
+    C'est d'ailleurs avec cette commande que j'ai fabriqué la correction indicative ci-dessus.
+    
+### exercice
+
+Dans un second temps vous pouvez créer un lien / ou créer un raccourci avec votre système de naviguation de fichier graphique (probablement nautilus sous ubuntu) de grapevine.txt dans le répertoire folderC.
+
+Vous pouvez aussi vous placer vous dans folderC et écrire en ligne de commande
+```bash
+ln -s ../folderA/grapevine.txt
+```
+
+Selon votre configuration en revenant en arrière et en faisant à nouveau un ls avec l'option permettant l'affichage récursif vous allez voir le nom du grapevin.txt sous une couleur différente de l'original.
+
+Nous allons d'abord chercher dans le manuel ce que fait l'option -l de ls
+```bash
+man ls
+```
+puis nous allons tester sur notre lien en faisant
+```bash
+ls -l
+```
+
+Je n'ai pas traité en cours les parties ci-dessous.
+Vous pouvez ouvrir chaque section en cliquant sur le triangle.
+
+<details><summary>Zoom sur les briques élémentaires du système de fichier</summary>
+<p>
+
+
+
+### exercice 
+
+L'arbre de notre système de fichier est fabriqué à partir de 2 éléments.
+    1. une feuille de l'arbre = des données stockées à une certaine adresse dans la mémoire
+    2. un noeud interne de l'arbre = des données stockées à une certaine adresse dans la mémoire qui associe un nom (de fichier ou de répertoire) à un élément de type 1. ou 2. identifiable par le système. En gros le fichier correspondant à un répertoire est une sorte de *livret de famille*.
+    
+En pratique, le système utilise une structure de donnée particulière à la fois pour les fichiers et les répertoires (puisqu'il s'agit dans les deux cas de fichiers) qui s'appelle un [inode](https://en.wikipedia.org/wiki/Inode).
+
+
+En pratique vous pouvez utiliser l'option suivante pour affichier les numéros des inode.
+```bash
+ls -i
+```
+
+### exercice pour aller encore plus loin
+Nous avons évoqué les liens symboliques qui sont des raccourcis.
+Littéralement c'est juste un fichier texte un peu spécial qui contient comme données la chaîne de caractère du fichier vers lequel on pointe.
+
+Donc quand on a fait ci-dessus.
+```bash
+ln -s ../folderA/grapevine.txt
+```
+On a fabriqué un fichier raccourci spécial qui contient essentiellement l'information
+```bash
+../folderA/grapevine.txt
+```
+Si vous utilisez la même commande mais en omettant l'option -s vous êtes en train de définir un nouveau nom pour l'inode du fichier grapevine.txt
+
+Donc la métaphore de l'arbre n'est pas tout à fait correcte puisque par plusieurs chemins dans les répertoires il est possible d'atteindre le même fichier.
+
+La commande de suppression de fichier rm (pour remove) ne supprime pas vraiment l'inode, elle va juste effacer le nom du fichier (et la référence vers l'inode associé à ce nom) dans le répertoire.
+
+[Détails sur stackoverflow](https://stackoverflow.com/questions/185899/what-is-the-difference-between-a-symbolic-link-and-a-hard-link)
+
+NB. Je n'ai pas testé sous WSL puisque je n'ai pas windows. Il serait amusant de regarder ce qui arrive aux fichiers linux avec plusieurs noms quand on les regarde en vue détaillée dans l'explorateur de fichier de windows. A priori NTFS a une notion compatible
+
+</p>
+</details>
+
+
+### Commandes utilisées jusqu'à présent
+```bash
+mkdir
+cd
+touch
+ls
+ln
+```
+
+<details><summary>Manipuler du texte avec la commande tr</summary>
+<p>
+
+## Manipulation de fichier
+
+Pour simplifier un texte, par exemple pour l'indexer ou pour normaliser un nom dans une base de données il est fréquent qu'on bascule un mot en majuscule.
+Nous allons travailler avec la commande tr qui permet de faire de tel changement caractère par caractère.
+Par exemple ceci permet de transformer les minuscules en majuscule.
+
+```bash
+tr '[a-z]' '[A-Z]' 
+```
+La commande tr attend un flux textuel en entrée et transmet un flux textuel en sortie. 
+On parle de filtre pour ce genre de commande.
+On ne peut pas a priori lui passer de fichier en paramètre.
+Il faut *rediriger* le contenu du fichier vers la commande.
+
+```bash
+tr '[a-z]' '[A-Z]' < grapevine.txt
+```
+Par défaut le résultat apparaît à l'écran.
+
+On peut rediriger ce résultat dans un fichier en utilisant >
+
+```bash
+tr '[a-z]' '[A-Z]' < grapevine.txt > grapevineUp.txt
+```
+Vous pouvez consulter le contenu d'un fichier directement en utilisant la commande more
+```bash
+more grapevineUp.txt
+```
+Attention toutefois avec > car le contenu du fichier si il existe est écrasé.
+
+Il existe une variante utile >> qui écrit à la fin du fichier.
+C'est utilisé par exemple pour créer des fichiers de log.
+
+### exercice
+
+Redirigez le résultat de la commande history dans un fichier de sauveguarde myFirstDayWithTheCommandLine.txt.
+
+
+```bash
+history > myFirstDayWithTheCommandLine.txt
+```
+Vous pouvez consulter ce fichier en utilisant more.
+
+Vous pouvez voir le haut du fichier en faisant head, la fin du fichier en faisant tail.
+
+## Code de césar
+
+Cherchez à appliquer le code de césar (rot13) à un fichier contenant du texte non accentué (i.e. ascii historique).
+
+Envoyez le par mail à votre voisin.
+
+Ce dernier doit le décoder.
+
+```bash
+tr '[A-Z]' '[N-ZA-M]'
+```
+</p>
+</details>
+
+
+## droit d'accès
+
+chmod
+
+Il s'agit de la commande permettant de changer les droits pour un fichier.
+
+
+## Bonus : jouons avec le pipe
+
+1. installer fortune
+1. installer cowsay
+
+```bash
+echo moooooo | cowsay
+```
+
+
+```bash
+fortune
+```
+
+
+```bash
+fortune | cowsay
+```
+
+## Bonus : sl
+
+1. installer sl (dans le terminal de votre collègue quand il va boire un café)
+1. demandez lui de vous montrer comment ls fonctionne très rapidement (il va probalement écrire sl au lieu de ls à un moment)
+
+
+
+

1-ComputationAndData/archive_24_25/3ComputationAndData.html

@@ -0,0 +1,153 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+
+<head>
+<title>3ComputationAndData.html</title>
+<meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>
+
+</head>
+
+<body>
+
+<h1>Calculer en théorie et en pratique I/III</h1>
+
+<p>Dans la prochaine séquence de cours, nous allons tenter de répondre à la question suivante.</p>
+
+<p>C'est quoi un ordinateur?</p>
+
+<p>Cette question s'apparente à celle que ce sont posés philosophes et mathématiciens de Leibnitz à Turing en passant par Hilbert.</p>
+
+<p>Qu'est-ce qu'une question à laquelle on peut répondre de manière mécanique par un calcul?</p>
+
+<p>Nous allons explorer rapidement ce sujet en évoquant à la fois des modèles théoriques et des explication sur l'architecture matérielle et le fonctionnement d'ordinateurs modernes.</p>
+
+<h2>Calcul Matériel.</h2>
+
+<p>Initialement, les "computer" sont des humains, qui s'aident de divers mécanisme pour faire des calculs rapidement en essayant de faire le moins d'erreurs possibles, par exemple avec un boulier ou des cordes nouées. </p>
+
+<p>Les premières machines à calculer sont mécaniques et peuvent être discrètes (nombre fini de position avec par exemple des roues crantées) ou continues (position continue sur un astrolabe ou une table à tracer pour calculer des intégrales). </p>
+
+<p>Les machines modernes possèdent différents composants electroniques et ce sont les transistors qui permettent de passer d'une information analogique/continue </p>
+
+<blockquote>
+  <p>quelle est la puissance du courant?</p>
+</blockquote>
+
+<p>à une information discrète, oui ou non, qu'on peut interpréter comme 0 ou 1.</p>
+
+<blockquote>
+  <p>est-ce-que le courant dépasse un certain seuil?</p>
+</blockquote>
+
+<p>On peut à l'aide de quelques composants de base faire des calculs sur ces valeurs 0 ou 1. On parle alors de calcul Booléen (du nom du logicien Boole).</p>
+
+<h3>circuit booléen</h3>
+
+<p>consiste en
+1. des entrées contenant des valeurs booléennes.
+1. des portes logiques permettant de calculer
+   * le ET binaire (&amp;) 
+   * le OU binaire (v)
+   * la négation NON unaire (-)
+1. des "cables" pour relier ces portes
+1. des sorties correspondant à la sortie du calcul.</p>
+
+<p>Au tableau
+* table du ET
+* table du OU
+* table du NON</p>
+
+<h3>exercices</h3>
+
+<ol>
+<li>Écrire la table de Non de x ou y.</li>
+<li>Décrire un circuit permettant de tester si deux entrée x et y sont égales.
+Le circuit doit renvoyer 1 si c'est le cas et 0 sinon.
+NB. on peut noter cette opération &lt;-> ou </li>
+<li>Même question pour le circuit qui permet de calculer le XOR (Ou eXclusif).</li>
+<li>Même question pour le circuit permettant de calculer la majorité de trois arguments</li>
+</ol>
+
+<h3>Digression : le schéma de chiffrement de Vernam</h3>
+
+<p>Il s'agit d'un schéma très simple et incassable à moins de connaître la clé secrète.
+L'inconvénient est qu'il faut fabriquer et partager avec son destinataire une clé secrète aussi longue que le message. On parle aussi de "one time pad" en anglais.</p>
+
+<p>Pendant la seconde guerre mondiale, à Bletchley Park, des opératrices fabriquaient de telles clés mais en quantité trop réduite. Une tentative de mécanisation pour pallier à ce soucis a permis de générer des clés rapidement mais qui avaient une différence avec les véritables clés.</p>
+
+<blockquote>
+  <p>"Enoch, why are you . . . here?"</p>
+  
+  <p>"Oh. I am here, in a larger sense, because Mrs. Tenney, the vicar’s wife, has become sloppy, and forgot>ten to close her eyes when she takes the balls out of the bingo machine."</p>
+  
+  <p>Neal Stephenson. Cryptonomicon.</p>
+</blockquote>
+
+<p><a href="https://crypto.stackexchange.com/questions/25214/has-human-generated-entropy-ever-been-a-real-problem">Discussion sur stackexchange</a></p>
+
+<p>Nous allons mettre en oeuvre ce chiffrement.
+1. Tout d'abord le message à chiffrer M, qu'on suppose encodable en ASCII est transformé en un séquence de 0 et de 1 qu'on note B.
+1. La clé secrète S est une série de 0 et de 1 de même longueur.
+1. On additionne "modulo 2" B à S pour obtenir le message chiffré C (c'est le XOR de tout à l'heure).
+1. On transmet le message chiffré C au destinataire.
+1. La destinataire reçoit C.
+1. Pour décoder, elle procède de même mais à l'envers.
+   * ajout de S à C
+   * découpage en bloc de 7 bits
+   * décodage ASCII</p>
+
+<p><a href="https://fr.wikipedia.org/wiki/American_Standard_Code_for_Information_Interchange">page du code ASCII</a></p>
+
+<p>NB. pour faire plus proche de la réalité, on préfixe le code ASCII d'un 0 pour obtenir un octet.</p>
+
+<h3>exercice</h3>
+
+<p>Nous allons mettre en oeuvre ce chiffrement pour le mot BINGO.
+Fabriquez au préalable une clé de la taille adapté
+(vous pouvez par exemple tirer à pile ou face successivement). </p>
+
+<p>Pour simplifier, vous pouvez le faire avec OK.</p>
+
+<p>Réfléchissez à une mise en oeuvre pratique sur papier.</p>
+
+<h2>Retour à nos circuits.</h2>
+
+<p>Nous allons maintenant mettre en oeuvre des circuits pour faire des opérations arithmétiques.</p>
+
+<ol>
+<li>Même question pour un circuit qui réalise une somme "modulo 2"
+NB. c'est le chiffrement de Vernam.</li>
+<li>Même question pour un circuit qui réalise une somme en binaire.
+Pour ce second circuit on s'autorise une porte de duplication notée D qui prend en entrée x et a deux sorties valant toutes deux x.</li>
+</ol>
+
+<h3>Indication.</h3>
+
+<p>Pour rappel en binaire 1+1 vaut 10; 1+0 comme 0+1 valent 1; et, 0+0 vaut 0.</p>
+
+<p><strong>Exemple</strong>
+```
+0110</p>
+
+<h1>0111</h1>
+
+<p>...1
+..01 retenue 1
+.101 retenue 1
+1101 Fin
+```</p>
+
+<h3>Indication 2</h3>
+
+<p>2 questions rhétoriques :</p>
+
+<ul>
+<li>Comment faire la retenue?</li>
+<li>Comment calcule la somme dans la même colonne?</li>
+</ul>
+
+</body>
+</html>

1-ComputationAndData/archive_24_25/3ComputationAndData.md

@@ -0,0 +1,125 @@
+# 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.
+
+C'est quoi un ordinateur?
+
+Cette question s'apparente à celle que ce sont posés philosophes et mathématiciens de Leibnitz à Turing en passant par Hilbert.
+
+Qu'est-ce qu'une question à laquelle on peut répondre de manière mécanique par un calcul?
+
+Nous allons explorer rapidement ce sujet en évoquant à la fois des modèles théoriques et des explication sur l'architecture matérielle et le fonctionnement d'ordinateurs modernes.
+
+## Calcul Matériel.
+
+Initialement, les "computer" sont des humains, qui s'aident de divers mécanisme pour faire des calculs rapidement en essayant de faire le moins d'erreurs possibles, par exemple avec un boulier ou des cordes nouées. 
+
+Les premières machines à calculer sont mécaniques et peuvent être discrètes (nombre fini de position avec par exemple des roues crantées) ou continues (position continue sur un astrolabe ou une table à tracer pour calculer des intégrales). 
+
+Les machines modernes possèdent différents composants electroniques et ce sont les transistors qui permettent de passer d'une information analogique/continue 
+
+> quelle est la puissance du courant?
+
+à une information discrète, oui ou non, qu'on peut interpréter comme 0 ou 1.
+
+> est-ce-que le courant dépasse un certain seuil?
+
+On peut à l'aide de quelques composants de base faire des calculs sur ces valeurs 0 ou 1. On parle alors de calcul Booléen (du nom du logicien Boole).
+
+### circuit booléen
+consiste en
+1. des entrées contenant des valeurs booléennes.
+1. des portes logiques permettant de calculer
+   * le ET binaire (&) 
+   * le OU binaire (v)
+   * la négation NON unaire (-)
+1. des "cables" pour relier ces portes
+1. des sorties correspondant à la sortie du calcul.
+
+Au tableau
+* table du ET
+* table du OU
+* table du NON
+
+### exercices 
+
+1. Écrire la table de Non de x ou y.
+1. Décrire un circuit permettant de tester si deux entrée x et y sont égales.
+Le circuit doit renvoyer 1 si c'est le cas et 0 sinon.
+NB. on peut noter cette opération <-> ou 
+2. Même question pour le circuit qui permet de calculer le XOR (Ou eXclusif).
+3. Même question pour le circuit permettant de calculer la majorité de trois arguments
+
+### Digression : le schéma de chiffrement de Vernam
+Il s'agit d'un schéma très simple et incassable à moins de connaître la clé secrète.
+L'inconvénient est qu'il faut fabriquer et partager avec son destinataire une clé secrète aussi longue que le message. On parle aussi de "one time pad" en anglais.
+
+Pendant la seconde guerre mondiale, à Bletchley Park, des opératrices fabriquaient de telles clés mais en quantité trop réduite. Une tentative de mécanisation pour pallier à ce soucis a permis de générer des clés rapidement mais qui avaient une différence avec les véritables clés.
+
+
+> 
+>
+>    "Enoch, why are you . . . here?"
+>
+>    "Oh. I am here, in a larger sense, because Mrs. Tenney, the vicar’s wife, has become sloppy, and forgot>ten to close her eyes when she takes the balls out of the bingo machine."
+>
+> Neal Stephenson. Cryptonomicon.
+
+[Discussion sur stackexchange](https://crypto.stackexchange.com/questions/25214/has-human-generated-entropy-ever-been-a-real-problem)
+
+
+Nous allons mettre en oeuvre ce chiffrement.
+1. Tout d'abord le message à chiffrer M, qu'on suppose encodable en ASCII est transformé en un séquence de 0 et de 1 qu'on note B.
+1. La clé secrète S est une série de 0 et de 1 de même longueur.
+1. On additionne "modulo 2" B à S pour obtenir le message chiffré C (c'est le XOR de tout à l'heure).
+1. On transmet le message chiffré C au destinataire.
+1. La destinataire reçoit C.
+1. Pour décoder, elle procède de même mais à l'envers.
+   * ajout de S à C
+   * découpage en bloc de 7 bits
+   * décodage ASCII
+   
+[page du code ASCII](https://fr.wikipedia.org/wiki/American_Standard_Code_for_Information_Interchange)
+   
+NB. pour faire plus proche de la réalité, on préfixe le code ASCII d'un 0 pour obtenir un octet.
+
+### exercice
+Nous allons mettre en oeuvre ce chiffrement pour le mot BINGO.
+Fabriquez au préalable une clé de la taille adapté
+(vous pouvez par exemple tirer à pile ou face successivement). 
+
+Pour simplifier, vous pouvez le faire avec OK.
+
+Réfléchissez à une mise en oeuvre pratique sur papier.
+
+## Retour à nos circuits.
+
+Nous allons maintenant mettre en oeuvre des circuits pour faire des opérations arithmétiques.
+
+
+1. Même question pour un circuit qui réalise une somme "modulo 2"
+   NB. c'est le chiffrement de Vernam.
+1. Même question pour un circuit qui réalise une somme en binaire.
+   Pour ce second circuit on s'autorise une porte de duplication notée D qui prend en entrée x et a deux sorties valant toutes deux x.
+
+### Indication.
+Pour rappel en binaire 1+1 vaut 10; 1+0 comme 0+1 valent 1; et, 0+0 vaut 0.
+
+**Exemple**
+```
+0110
+0111
+====
+...1
+..01 retenue 1
+.101 retenue 1
+1101 Fin
+```
+### Indication 2
+2 questions rhétoriques :
+
+  * Comment faire la retenue?
+  * Comment calcule la somme dans la même colonne?
+
+
+

1-ComputationAndData/archive_24_25/3correctionfinEnbab.txt

@@ -0,0 +1,28 @@
+        |  a   |   b   |  spécial?
+===================================        
+epsilon |  a   |   b   |  initial
+a       |  aa  |   ab  |
+b       |  ba  |   bb  |  
+aa      |  aaa |   aab |
+ab      |  aba |   abb |
+ba      |  baa |   bab |
+bb      |  bba |   bbb |
+aaa     |  aaa |   aab |
+aab     |  aba |   abb |
+aba     |  baa |   bab |
+abb     |  bba |   bbb |
+baa     |  aaa |   aab |
+bab     |  aba |   abb | acceptant
+bba     |  baa |   bab |
+bbb     |  bba |   bbb |
+
+Version optimisée avec moins d'états.
+
+        |  a       |   b   |  spécial?
+===================================        
+epsilon |  epsilon |   b   |  initial
+b       |  ba      |   b   |
+ba      |  epsilon |   bab |
+bab     |  ba      |   b   | acceptant
+
+

1-ComputationAndData/archive_24_25/4ComputationAndData.md

@@ -0,0 +1,260 @@
+Cours de Florent.
+
+# Calculer en théorie et en pratique II/III
+
+Dans cette séquence de cours, nous tentons de répondre à la question suivante.
+
+C'est quoi un ordinateur?
+
+Cette question s'apparente à celle que ce sont posés philosophes et mathématiciens de Leibnitz à Turing en passant par Hilbert.
+
+Qu'est-ce qu'une question à laquelle on peut répondre de manière mécanique par un calcul?
+
+Nous avons vu une approximation de calcul théorique basé sur le calcul booléen et des portes logiques qui sont implémentable avec des composants electroniques, permettant de réaliser divers opérations comme l'addition bit à bit (schéma de Vernam en cryptographie), la majorité ou encore l'addition avec retenue.
+
+Aujourd'hui nous poursuivons avec un modèle théorique, qui est celui de l'**automate fini**, un modèle assez restreint de machine. L'adjectif fini s'applique à la mémoire de la machine qui est finie.
+
+Nous verrons plus tard un modèle plus général avec une mémoire arbitrairement grande : la machine deTuring. 
+
+## Le modèle d'automate fini.
+
+* La machine va lire en entrée un mot sur un alphabet A de taille finie (on peut par exemple imaginer qu'il s'agit d'un mot en binaire et l'alphabet A serait par exemple composé des symboles 0 et 1).
+* La machine possède plusieurs états. Intuitivement, chaque état code pour ce qu'on stocke dans la mémoire finie de la machine.
+* Certains états sont dit **acceptant**.
+* Un état spécial est celui dans lequel la machine débute son calcul. C'est l'**état initial**.
+* La machine va "manger" le mot d'entrée lettre par lettre et passe d'un état à l'autre selon ce que son **programme** lui dicte.
+* Quand toutes les lettres sont lues, si l'état dans lequel la machine se trouve est acceptant, la machine répond OUI (elle **accepte** le mot) sinon elle répond NON (elle **rejette** le mot).
+* L'ensemble des mots sur l'alphabet A qui sont acceptés par la machine forme le *langage reconnu par l'automate*.
+
+### Le programme de l'automate.
+On peut l'écrire dans un tableur, sous forme d'une succession fini de lignes avec trois colonnes. 
+La première colonne est l'état actuel, la seconde colonne est la lettre lue, la troisième colonne est le nouvel état.
+
+Pour un état donné q et une lettre lue x, l'automate va se placer dans un état donné q' (il est possible que q et q' soit le même état).
+
+Si le programme est incomplet et que le tableur n'explique pas comment faire, on arrête le calcul et on rejette le mot.
+
+Si le tableur n'est pas ambigu et que on n'a jamais deux lignes indiquant pour la même paire de lettre lue et d'état un nouvel état différent, on dit que l'automate est **déterministe**.
+
+Sinon l'automate n'est pas déterministe -- on dit aussi **non-déterministe** -- et on considère que la machine peut choisir une action du tableur parmi celles qui sont listées.
+
+Pour un automate non déterministe, on considère qu'un mot est accepté si il existe un calcul qui accepte.
+
+Analogie : vous cherchez à sortir d'un labyrinthe, il y a de nombreux chemins possibles. Si il en existe un vers la sortie alors vous pouvez gagner au jeu du labyrinthe. 
+
+## Exemples avec JFLAP.
+
+JFLAP est un logiciel de simulation de machines théoriques qui permet de définir, manipuler, exécuter et transformer des machines. En pratique c'est une archive jar.
+
+Une archive jar est un programme codé dans le langage java que vous pouvez exécuter.
+L'archive se compose de divers fichiers, dont un fichier principal, des librairies etc.
+
+Pour utiliser le logiciel, vous devez commencer par installer java.
+Suivez les recommandations de votre système d'exploitation.
+
+Ensuite, il vous suffit souvent de double-cliquer sur l'archive jar.
+
+Vous pouvez aussi en ligne de commande sous linux écrire.
+
+```bash
+java -jar <nom de l'archive jar>
+```
+Sur les machines virtuelles, 
+
+### Prise en main de JFlap.
+
+1. Lancez JFLAP et ouvrez [l'automate sauvegardé ici](https://www.lacl.fr/fmadelaine/Download/M1Droit/Automates/TP2NDA.jff)
+2. Allez dans le menu *Input* et choisissez *Step by State*. Entrez le mot **babb** et observez la simulation des exécutions parallèles étape par étape en appuyant sur *step*. 
+3. Testez ensuite avec le mot **baaa**.
+4. Relancez les tests ci-dessus. Cette fois essayez les autres
+  options.
+  * *Reset* permet de revenir au début du calcul
+  *  *Trace* après sélection en bas d'une exécution permet
+    de montrer cette exécution depuis le début.
+  *  *Remove* élimine l'exécution sélectionnée
+  *  *Freeze*/*Thaw* permet de mettre en pause ou de
+    reprendre une exécution (on perd la synchronisation)
+5. Vous pouvez aussi tester sans les étapes avec *Fast Run*
+  voir plusieurs entrées en même temps avec
+  *Multiple Run*   (tous les deux dans le menu *Input*).
+  Faites le par exemple pour les deux mots précédents.
+6. Pour information, *Step with closure* fait la même chose
+  que *step by State* sauf pour les automates ayant des
+  transitions avec le mot-vide (mais on ne les considère pas dans
+  ce cours).
+
+### Hello World
+Votre but est de créer l'automate dessiné ci-dessous.
+
+    ![images/HelloWorldAutomate.jpg]
+
+1. Cliquez sur *File* puis *New*.
+2. JFLAP permet de gérer différents modèles de calcul. Nous allons
+  nous en tenir aux automates finis. Cliquez sur *Finite Automaton*.
+  Vous avez accès à une nouvelle fenêtre en mode éditeur.
+  * Cliquez sur le petit cercle avec un q à l'intérieur, puis sur
+    le canevas pour ajouter des états.
+  *  Les deux derniers boutons permettent de faire du undo/redo.
+  *  La flèche fine permet d'ajouter une transition entre 1 ou 2
+    états (ne pas oublier de mettre une lettre).
+  *  La flèche plus épaisse à gauche permet de sélectionner,
+    déplacer, éditer les propriétés des différents éléments (par
+    exemple de faire un état initial).
+  *  La tête de mort permet de détruire des états ou des transitions.
+
+### Exercices
+Dessinez les automates qui reconnaissent :
+
+(pour l'alphabet $\{a,b\}$) 
+
+1. les mots de 2 lettres;
+2. les mots contenant exactement 2 a;
+3. les mots contenant 2 a consécutifs;
+4. les mots commençant par b;
+5. les mots se terminant par bab;
+6. le langage réduit au mot vide;
+
+(pour l'alphabet $\{a,b,c\}$)
+
+7. les mots qui contiennent $aabcc$;
+8. les mots de taille multiple de 3;
+9. les mots de la forme abcabcabc... (une ou plusieurs successions des 3 lettres abc);
+10. les mots dont la première lettre est égale à la dernière. 
+
+<details><summary>Calcul modulaire en base 2</summary>
+<p>
+
+### Compter avec les automates
+On ne le verra pas dans ce cours, mais il est possible d'établir que le modèle des automates ne permet pas de compter. Par exemple, on ne peut pas lire une expression avec des parenthèses et vérifier qu'il y a autant de parenthèses ouvrantes que de parenthèses fermantes. On ne peut pas non plus vérifier que les parenthèses correspondent bien. Ainsi ce modèle n'est pas suffisant pour vérifier par exemple qu'une chaîne de caractères est un programme suivant un syntaxe fixée du C.
+
+Par contre, on peut compter facilement modulo N, puisque celà revient à se souvenir d'un nombre fini de cas.
+
+NB. modulo N veut dire qu'on manipule des nombres en faisant des sommes, des produits, etc mais en s'intéressant uniquement au reste de la division par N du résultat. Ça semble abstrait au premier abord, mais c'est ce que vous faites quand vous calculez le numéro d'un mois avec N=12.
+Par exemple 3 mois après novembre c'est février : soit 11+3 = 2 modulo 12.
+
+Imaginons que notre automate lise un mot sur l'alphabet 0,1 représentant en binaire un nombre et qu'on souhaite tester si ce nombre est un multiple de 3.
+
+#### Retour sur la notation binaire
+
+En décimal, si j'ajoute 0 à droite d'un mot décimal w qui représente le nombre n alors le mot décimal w0 (w suivi d'un 0) représente n fois 10.
+
+En binaire, c'est similaire mais en remplaçant 10 par 2 dans la phrase ci-dessus.
+Donc w0 représente 2n.
+
+Si j'écris w1 c'est le nombre représenté par w0 plus 1, soit 2n+1.
+
+On peut utiliser cette relation pour déduire des propriétés de divisibilité par trois des nombres représentés par w0 ou w1 en fonction de celle du nombre n représenté par w.
+
+Si n est divisible par trois, il s'écrit sous la forme 3k pour un certain k.
+    * 2n vaut dans ce cas 2*3k qui est encore divisible par 3 (reste nul, soit 0 modulo 3).
+    * 2n+1 vaut dans ce cas 2(3k)+1 (reste 1, soit 1 modulo 3).
+    
+On peut procéder de même pour les 2 autres cas.
+
+Si le reste de la division de n par trois vaut 1, il s'écrit sous la forme 3k+1 pour un certain k.
+    * 2n vaut dans ce cas 2(3k+1)=2.3k+2 (reste 2, soit 2 modulo 3).
+    * 2n+1 vaut dans ce cas 2(3k+1)+1=2.3k+3=3(2k+1) (reste 0, soit 0 modulo 3).
+
+##### Exercice
+Procédez de même lorsque le reste de la division de n par trois vaut 2.
+
+En déduire un automate qui lit un mot en binaire et accepte celui-ci exactement lorsque le nombre représenté est divisible par trois.
+(indication : il faut un état par reste possible).
+
+
+</p>
+</details>
+
+## Le modèle de la machine de Turing
+Nous allons maintenant nous pencher sur un modèle de machine qui
+semble au premier abord n'être que légèrement différent de celui des
+automates. D'une part, on va pouvoir revenir en arrière sur le mot, et
+d'autre part on va pouvoir écrire ce qui permet d'avoir une mémoire
+arbitrairement grande. 
+
+Ces deux changements permettent
+d'obtenir *in fine* un modèle très riche puisque *n'importe quelle
+procédure de calcul connue à l'heure actuelle* peut être traduite
+théoriquement par une machine de Turing.
+
+Il est important de noter que le programme reste fini.
+
+
+    ![images/turingMachine.png]
+
+Il y a beaucoup de ressources sur Alan Turing disponibles en ligne, en
+particulier depuis son centenaire en 2012. Vous pouvez trouver (ses
+articles originaux et ses brouillons)[http://www.turingarchive.org/].
+
+C'est un mathématicien qui a eu une influente forte en informatique,
+malgré une vie trop courte (1912-1954). En droit britannique, (une loi porte son nom)[https://en.wikipedia.org/wiki/Alan_Turing_law}] 
+
+### Turing avec JFLAP
+
+Dans le menu choisissez **Machine de Turing**. L'éditeur graphique vous permet de créer rapidement le programme d'une machine de Turing. Les cercles sont les états de la machine (comme pour les automates). Un clic droit permet de rendre initial un état, ou final des états. Un état final correspond ici en fait à un état acceptant. La machine s'arrête si il n'y a pas de transition appropriée (en
+rejetant si l'état dans laquelle elle se trouve n'est pas final).
+
+Dans la suite on utilise l'alphabet 0,1 en plus du blanc (ressemblant à un carré pour JFLAP).
+Notez que le ruban est infini à gauche et à droite pour JFLAP. Il y a
+de nombreuses variations possibles pour la machine de Turing qui ne
+font pas de différence notable, par exemple un ruban fini à gauche, un ruban à 2 dimensions etc.
+
+Un point technique avec JFLAP. Si vous voulez fabriquer une transition
+qui écrit un blanc (un carré) pour une transition, il suffit de ne rien
+saisir dans cette cellule pour la transition et d'appuyer sur entrée. 
+
+#### Exercice
+On suppose que l'alphabet est 0,1
+  1.  Écrire un programme qui lit les caractères du mot d'entrée de
+    la gauche vers la droite et s'arrête en acceptant.
+  1.  Même question pour un programme qui accepte si et seulement si
+    la première et la dernière lettre sont les mêmes.
+  1.  Même question pour les mots qui sont des \textsl{palindromes}
+    (exemple de palindrome en français KAYAK). On peut dans un premier
+    temps ne gérer correctement que les mots qui sont de longueur
+    paire.
+
+#### Indications + correction indicative
+Pour les palindromes pairs, de la forme w suivi de w renversé, *on ne peut pas se souvenir dans nos états* du début du mot w qui est arbitrairement grand et donc pour un mot
+assez grand forcément plus grand que le nombre (fini) d'états de notre
+machine.
+
+Si on disposez d'une machine de Turing à **2 rubans**, on pourrait :
+recopier le premier ruban sur le second; ramener la tête de lecture du
+premier ruban tout à gauche; puis décaler la tête du premier ruban
+vers la droite et celle du second ruban vers la gauche en vérifiant
+une par une que les lettres sont identiques.
+
+Comme nous ne disposons que d'un ruban, la seule mémoire non bornée à
+notre disposition est l'unique ruban. L'idée consiste donc à vérifier
+l'un après l'autre les couples de lettres suivantes : (première
+lettre, dernière lettre) puis (seconde lettre, avant-dernière lettre)
+etc.
+
+Si nous avions **deux têtes** il suffirait de placer notre seconde tête à
+la fin du mot et de procéder comme dans la version à 2 rubans.
+
+Puisqu'on a une seule tête, cette dernière va devoir faire des
+aller-retours. Il va falloir marquer d'une manière ou d'une autre les
+lettres qu'on a vu pour éviter de repasser au même endroit.
+L'exemple ci-dessous enlève tout simplement les lettres en cours de
+vérification.
+
+    ![images/TuringPalindromePair.jpg]
+
+## La thèse de Church Turing.
+**Pour tout modèle raisonnable de calcul, on obtient la même notion de ce qui est calculable.**
+
+
+Arguments en faveur de cette thèse
+* Théorie générales des fonctions récursives (Gödel, Herbrand
+  1933).
+*  lambda-calcul (Church, 1936).
+*  Machines de Turing (Turing, 1936).
+*  Trois modèles équivalents (Church 1936, Turing 1937).
+*  Machines de Post (1936).
+*  Machines de Turing avec plusieurs rubans (Minsky).
+*  Machines à compteurs.
+*  Machines à registre.
+*  etc.
+

1-ComputationAndData/archive_24_25/5ComputationAndData.md

@@ -0,0 +1,374 @@
+Cours de Florent.
+
+# Calculer en théorie et en pratique III/III
+
+Dans cette séquence de cours, nous tentons de répondre à la question suivante.
+
+C'est quoi un ordinateur?
+
+Cette question s'apparente à celle que ce sont posés philosophes et mathématiciens de Leibnitz à Turing en passant par Hilbert.
+
+Qu'est-ce qu'une question à laquelle on peut répondre de manière mécanique par un calcul?
+
+Nous avons vu une approximation de calcul théorique basé sur le calcul booléen et des portes logiques qui sont implémentable avec des composants electroniques, permettant de réaliser divers opérations comme l'addition bit à bit (schéma de Vernam en cryptographie), la majorité ou encore l'addition avec retenue.
+
+Nous avons poursuivi avec un modèle théorique, qui est celui de l'**automate fini**, un modèle assez restreint de machine : l'adjectif fini s'applique à la mémoire de la machine qui est finie.
+Nous avons entrevu le modèle plus général avec une mémoire arbitrairement grande **la machine de Turing** et évoqué la thèse de Church-Turing qui stipule que tout modèle de calcul raisonnable est équivalent à ce modèle de la machine de Turing.
+
+Toutefois, le modèle de la machine de Turing reste assez éloigné d'une machine réelle et nous allons maintenant présenter rapidement un modèle simplifié de machine basé sur le modèle de Von Neumann, puis pratiquer l'assembleur avec la Machine Virtuelle à Pile (MVàP).
+
+
+## Programme vs données
+
+Dans le modèle de Turing, le programme est externe et guide la machine qui travaille sur le contenu du ruban qu'on peut voir comme la donnée.
+Dès 1936, Turing montre qu'en fait on peut construire une machine **universelle** qui lit sur son ruban le programme et les données sur lesquelles il faut lancer le calcul de ce programme.
+
+C'est cette idée de "programme qu'on va charger" qu'on retrouve dans le modèle de Von Neumann.
+
+
+## Le modèle de Von Neumann
+
+* L'unité de Mémoire contient des *données* et *des insructions*
+* Le processeur se compose d'une *unité de contrôle* et d'une *unité arithmétique et logique*.
+* La communication avec l'extérieur se fait par des dispositifs d'entrée-sortie.
+
+Pour plus de détails, voir [wikipedia](https://en.wikipedia.org/wiki/Von_Neumann_architecture)
+
+## Zoom sur *l'unité arithmétique et logique*
+
+Essentiellement un circuit au sens de ce qu'on a évoqué lors du dernier cours.
+En pratique les entrées/sorties sont découpées en 2 dimensions : une partie **contrôle** et une partie **données**. 
+
+* [Image](https://commons.wikimedia.org/wiki/File:ALU_block.gif)
+* [wikipedia](https://en.wikipedia.org/wiki/Arithmetic_logic_unit)
+* [Symboles circuit](https://en.wikipedia.org/wiki/Electronic_symbol)
+
+
+## Zoom sur la mémoire
+
+La mémoire peut être vue comme une pyramide.
+
+* En haut très peu de place, mais de la mémoire très rapide, ce sont des *registres*.
+* Au milieu, de la mémoire assez rapide, c'est la *mémoire vive* (la RAM) qui n'est pas persistante et quand on étend la machine, le contenu de la mémoire n'est pas conservé.
+* En bas, de la mémoire plutôt lente, mais persistante, typiquement le *disque dur*.
+
+En pratique il existe des mécanismes de *cache*, en particulier entre les registres et la RAM.
+
+Il y a d'autres ingrédients qui permettent de limiter l'emprunte en mémoire d'un programme (adresses virtuelles, paging) voir de suspendre une exécution et de recopier le programme en train de calculer dans le disque (swapping).
+
+* [Image](images/4-hierarchy.jpg)
+* [Jeu du paging](https://en.wikisource.org/wiki/Paging)
+* [Cache vs paging](https://stackoverflow.com/questions/4429025/caches-vs-paging)
+
+## la Machine Virtuelle à Pile (MVàP).
+
+Normalement dans une machine il faudrait expliquer comment les calculs sont poussés vers les registres et l'ALU.
+Nous allons travailler avec un modèle simplifié qui cache cet aspect et dans laquelle la mémoire est une pile.
+
+Par ailleurs la machine possèdes deux registres. 
+* PC (pour Program counter) qui contient le numéro de la ligne d'instruction en cours
+* FC (pour frame pointer) qui est un mécanisme permettant de faire des appels de fonctions mais qu'on n'utilisera pas car c'est un peu plus technique à utiliser.
+
+La machine accepte plusieurs instructions.
+```
+PUSHI n # pousse l'entier n sur la pile et passe à l'instruction suivante
+POP     # décale le sommet de la pile d'un et passe à l'instruction suivante
+
+ADD     # ajoute les 2 entiers au sommet de la pile, décale le sommet de la pile de 2
+        # écrit le résultat en haut de la pile et passe à l'instruction suivante
+SUB     # même chose pour la soustraction
+MUL     # même chose pour la multiplication
+DIV     # même chose pour la division
+
+READ    # lecture d'un entier qui est poussé en haut de la pile
+WRITE   # écriture de l'entier en haut de la pile
+
+HALT    # fin du programme
+
+LABEL x # définition d'une ancre vers laquelle on peut sauter
+JUMP x  # Saut vers le label (prochaine instruction à la ligne du label)
+JUMPF x # Instruction suivante si le haut de la pile est différent de 0
+        # Instruction x sinon.
+        
+INF     # Mange deux entiers. 
+        # Remplace par l'entier 1 si le premier inférieur au second et par 0 sinon.
+        # Passe à l'instruction suivante
+INFEQ   # idem plus petit ou égal
+SUP     # idem plus grand
+SUPEQ   # idem plus grand ou égal
+EQUAL   # idem égal
+NEQ     # idem différent
+
+        # Autres instructions qu'on verra plus tard.
+PUSHG  a # empile en haut de la pile l'entier stocké à l'adresse a de la pile
+STOREG a # dépile et stocke à l'adresse a de la pile l'entier en haut de la pile
+
+        # Autres instructions qu'on ne verra probablement pas plus tard.
+CALL x   # Appel du code stocké au label x
+RETURN   # Retour dans le code appellant.
+PUSHL  a # analogue de PUSHG pour des variables locales (utilise FP)
+STOREL a # analogue de STOREG
+``` 
+
+L'ordre des opérations est naturel, si on voit la pile de côté, bas à gauche, haut à droite. Une opération qui mange deux arguments prendra l'avant dernier argument comme premier argument et le dernier comme second argument.
+
+### Un premier exemple
+
+``` 
+  PUSHI 11
+  PUSHI 6
+  PUSHI 15
+  MUL
+  SUB
+  PUSHI 5
+  ADD
+  PUSHI 12
+  ADD
+  PUSHI 9
+  PUSHI 4
+  MUL
+  PUSHI 7
+  MUL
+  ADD
+  WRITE
+  POP
+  HALT
+``` 
+
+Une fois assemblé, le code devient :
+```
+ Adr |  Instruction
+-----+---------------
+   0 | PUSHI 11
+   2 | PUSHI 6
+   4 | PUSHI 15
+   6 | MUL
+   7 | SUB
+   8 | PUSHI 5
+  10 | ADD
+  11 | PUSHI 12
+  13 | ADD
+  14 | PUSHI 9
+  16 | PUSHI 4
+  18 | MUL
+  19 | PUSHI 7
+  21 | MUL
+  22 | ADD
+  23 | WRITE
+  24 | POP
+  25 | HALT
+``` 
+La MVàP, en mode debug,  écrit à chaque pas :
+
+* la valeur du compteur de programme (pc) ;
+* l'instruction à cette adresse ;
+* la valeur du « frame pointer » (toujours 0, quand il n'y a pas d'appel de fonction) ; 
+* le contenu de la pile ;
+* la hauteur de la pile. 
+
+Le début de l'exécution donne la trace suivante :
+
+``` 
+  pc |               |    fp   pile
+====================================================
+   0 | PUSHI      11 |     0 [ ] 0          # On empile 11
+   2 | PUSHI       6 |     0 [ 11 ] 1       # On empile 6
+   4 | PUSHI      15 |     0 [ 11 6 ] 2     # On empile 15
+   6 | MUL           |     0 [ 11 6 15 ] 3  # On dépile et multiplie 6*15, on empile le résultat 
+   7 | SUB           |     0 [ 11 90 ] 2    # On dépile et soustrait 90 à 11, on empile le résultat.
+   8 | PUSHI       5 |     0 [ -79 ] 1      # On empile 5.
+   etc
+``` 
+### Exercice
+
+Continuez l'exécution.
+
+### Exercice
+
+Vérifier votre calcul manuel en lançant la machine.
+
+Vous devez commencer par cloner le répo de ce cours.
+
+Puis soit utiliser java, soit utiliser javascript. Le plus simples est la seconde solution.
+
+<details>
+<summary>Avec java</summary>
+Il faut avoir java installé sur votre machine ou utiliser proxmox.
+Il faut utiliser les deux fichiers jar qui sont dans le répertoire MVaP
+Le fichier ```MVaP/ALIRE``` contient la marche à suivre.
+</details>
+
+
+Avec Javascript : naviguer dans le répertoire intitulé MVàP puis MVaP-1.0. Trouvez le fichier index.html. 
+ouvrez le acvec votre navigateur.
+
+
+
+### Variables globales
+On peut réserver de l'espace en bas de la pile et associer à une variable sa position pour mémoriser des valeurs.
+
+```
+  PUSHI 1  # Il faut initialement pousser une valeur ( par exemple 1)
+  ...      # Du code qui génère des choses dans la pile et une valeur en haut de la pile, par exemple 42
+  STOREG 0 # stocke 42 à l'adresse 0 de la pile (le 1 est remplacé par 42)
+  ...      # Du code qui fait des choses et qui tout à coup a besoin de connaître la valeur stockée
+  PUSHG 0  # empile 42 en haut de la pile.
+```
+
+### Exemple
+
+Imaginons qu'on souhaite faire du code qui :
+* déclare une variable i
+* lui affecte la valeur 6
+* plus tard souhaite l'incrémenter.
+
+```
+PUSHI 1 # i habite à l'adresse 0
+...
+PUSHI  6
+STOREG 0
+...
+PUSHI 1
+PUSHG 0
+ADD
+STOREG 0
+```
+
+### Boucles
+
+Imaginons qu'on souhaite faire une boucle tant que
+```
+Tant que test :
+   quelque chose
+La suite
+```
+Il faut utiliser des labels pour délimiter
+* la partie test suivie de la décision de rentrer dans la boucle ou de sortir
+* la partie interne à la boucle (quelque chose)
+* la partie qui suit la boucle (La suite).
+
+```
+LABEL 0 
+# le test qui va laisser une valeur 0 ou 1 en haut de la pile
+JUMPF 1 # saut conditionnel vers le label 1 si le test est Faux sinon continue
+# quelque chose
+JUMP 0
+LABEL 1 
+#La suite
+```
+
+### Exercice
+
+Produire du code MVàP qui correspond au code python suivant.
+```python
+j = 1
+i = 0
+i = j
+while i < 10:
+  i += 1
+print(i)
+```
+Testez votre code avec la MVàP.
+
+
+### Exercice
+Produire du code MVàP qui s'inspire du code suivant et simule la lecture et le stockage d'un tableau avant de vider la pile.
+La version ci-dessous ne vide pas la pile.
+```
+# Boucle While
+LABEL 19 
+# le test qui va laisser une valeur 0 ou 1 en haut de la pile
+# PUSHI 0 # pour faux, donc je saute après
+# PUSHI 1 # pour vrai, donc je ne saute pas.
+READ # on demande à l'utilisateur
+JUMPF 18 # saut conditionnel vers le label 1 si le test est Faux sinon continue
+# quelque chose
+READ
+# Fin du quelque chose
+JUMP 19
+LABEL 18 
+#La suite
+PUSHI 666
+WRITE
+POP
+# Fin de la suite.
+HALT
+```
+
+### Exercice
+Produire du code MVàP qui correspond au code python suivant.
+
+```python
+# integer inputs (input returns a string that needs casting as an int)
+m = int(input())
+n = int(input())
+if (m < n) : 
+    m = n
+else :
+    n = m
+print m
+print n
+```
+
+### Réutiliser du code.
+
+Si on a du code qu'on veut réutiliser plusieurs fois, 
+* on peut l'isoler entre un label et un jump
+* on peut sauter vers le label
+* malheureusement on ne peut pas sauter à la fin vers plusieurs endroits différents
+* on pourrait faire des tests successifs avec des JUMP et des JUMPF pour sauter au bon endroit
+* par contre on ne peut pas réutiliser le code un nombre arbitraire de fois.
+
+Solution : on sauve dans un registre l'endroit dans lequel on doit retourner
+Le plus simple consiste à utiliser le haut de la pile.
+
+Par contre il faut dans ce cas une instruction pour la MVàP qui permette d'écrire en haut de la pile la position actuelle du pc (c'est une partie du rôle de CALL) et il faut une instruction qui soit l'analogue de HALT pour un bloc et permette de retourner le pc à la valeur antérieure à l'appel (c'est une partie du rôle de RETURN).
+
+Avec cette idée on peut faire un appel à une fonction qui ne prend pas de paramètre et ne retourne pas de valeur.
+
+On peut communiquer avec le reste du programme via une variable globale.
+
+### Exemple 
+On peut ainsi par exemple faire une fonction qui mutliplie par 2 une variable globale.
+On appelle 3 fois la fonction et on affiche le résultat à chaque fois.
+
+```
+PUSHI 1 # variable globale i habite à l'adresse 0
+JUMP 1
+LABEL 0 # Notre Fonction
+PUSHG 0
+PUSHI 2
+MUL
+STOREG 0
+RETURN  # Fin de Notre Fonction
+...
+LABEL 1 # Main
+CALL 0  # appel 1
+PUSHG 0
+WRITE
+CALL 0  # appel 2
+PUSHG 0
+WRITE
+CALL 0 # appel3
+PUSHG 0
+WRITE
+```
+
+## Autres Exercices
+Il faut pour chaque exercice produire et tester du code MVàP qui réaliser le calcul ou le programme demandé.
+
+### Exercice
+Lire un entier n et calculez n*4+5*6-2
+
+### Exercice
+Lire un entier n et calculez 2*4+n*6-2
+
+### Exercice
+Même chose que ci-dessus mais avec un programme optimisé (qui donne le même résultat mais avec un minimum d'instructions).
+
+### Exercice
+Lire un entier n. Si n est nul le programme écrit 20 sinon 10.
+
+### Exercice
+Et parce qu'il faut bien une question un peu plus difficile.
+Lire un entier n. Le programme écrit 2^n. 

1-ComputationAndData/archive_24_25/5correctionExoMVAP.txt

@@ -0,0 +1,143 @@
+
+Code en pseudo python à traduire en MVàP   
+j = 1
+i = 0
+i = j
+while i < 10:
+  i += 1
+print(i)
+
+
+Pour le début (affectation des variables)
+j = 1
+i = 0
+i = j
+
+PUSHI 1 # j adresse 0 
+PUSHI 0 # i adresse 1
+PUSHG 0 # récupère j
+STOREG 1 # affecte à i
+
+Pour la structure de la boucle While, il suffit de recopier l'exemple du cours.
+
+LABEL 0 
+# le test qui va laisser une valeur 0 ou 1 en haut de la pile
+JUMPF 1 # saut conditionnel vers le label 1 si le test est Faux sinon continue
+# quelque chose
+JUMP 0
+LABEL 1 
+#La suite
+
+Il faut qu'on traduise les 3 morceaux de code :
+test,
+corps de la boucle,
+la suite.
+
+Le test.
+i < 10
+
+PUSHG 1  # valeur de i
+PUSHI 10
+INF
+
+Le corps de la boucle.
+i += 1 # même chose que i = i+1
+
+PUSHG adresse de i
+PUSHI 1
+ADD
+STOREG adresse de i
+
+Comme i habite à l'adresse 1 ça donne ce code.
+
+PUSHG 1
+PUSHI 1
+ADD
+STOREG 1
+
+la suite.
+print(i)
+
+en pratique on récupère i, on utilise WRITE, on fait POP pour nettoyer la pile.
+
+PUSHG 1 # adresse de i vaut 1
+WRITE
+POP
+
+Solution complète.
+
+
+PUSHI 1 # j adresse 0 
+PUSHI 0 # i adresse 1
+PUSHG 0 # récupère j
+STOREG 1 # affecte à i
+
+LABEL 0
+# test
+PUSHG 1 
+PUSHI 10
+INF
+JUMPF 1
+#corps boucle
+PUSHG 1
+PUSHI 1
+ADD
+STOREG 1
+JUMP 0
+LABEL 1 
+#La suite
+PUSHG 1 
+WRITE
+POP
+# Effacer les variables
+POP
+POP
+HALT
+    
+
+
+### Autre exercice donné au tableau
+
+Expression avec deux variables x et y qu'on demande à l'utilisateur
+
+PUSHI 0 # x adresse 0
+PUSHI 0 # y adresse 1
+# demande user val x
+# READ
+PUSHI 10
+STOREG 0
+# demande user val y
+# READ
+PUSHI 3
+STOREG 1
+# calcul de 
+# (x+3)*y+4*x
+# Parenthesage egal arbre de syntaxe comme au tableau
+# de base en haut et de gauche à droite on écrit le code MVàP
+# x+3
+PUSHG 0
+PUSHI 3
+ADD
+PUSHG 1
+MUL
+PUSHI 4
+PUSHG 0
+MUL
+ADD
+WRITE
+POP
+# effacer var x et y
+POP
+POP
+HALT
+
+
+
+
+
+
+
+
+
+
+   

1-ComputationAndData/archive_24_25/6ComputationAndData.md

@@ -0,0 +1,86 @@
+# Quelques constructions autour des automates.
+
+Nous avons vu le modèle des automates finis.
+Nous explorons ici trois techniques.
+
+
+## Complétez l'automate.
+
+Un automate est incomplet si il peut arriver qu'au cours d'un calcul on ne sache pas quoi faire.
+Ceci correspond dans la table de transition à une case sans prochain état pour une lettre donnée.
+
+Pour le compléter, on ajoute un état poubelle à notre automate.
+Cet état est un puits dans lequel on reste coincé (toutes transitions sortante reste dans cet été poubelle); et, toute transition manquante devient une transition vers cet état poubelle.
+
+
+## Déterminisation
+
+* Exemple d-un automate non déterministe à 3 état qui calcule les mots qui commencent et terminent par a et ont au moins deux lettres.
+* Calcul sous forme d'un arbre pour aaa, et aaab
+* Table de transition
+* digression parralèlisme (multi coeurs)
+* digression préemption plusieurs processus (commande top)
+* digression problème mémoire partagée etc
+* retour exemple automate. Super-état. Déterminisation.
+
+### Méthode.
+* On part de l'état initial, on note les états accessibles depuis cet état.
+* Si un état n'existe pas, on ajoute le super état correspondant.
+* Un super-état est acceptant ssi il contient un état acceptant.
+* On arrête la construction quand on ne recontre pas de nouvel état.
+
+### Exercice.
+On déterminise l'automate non déterministe à 5 états qui acceptent les mots (y compris d'une lettre) qui commencent et terminent par la même lettre.
+
+Donnée du problème : Dessin au tableau
+1. Donnez table de transition
+2. Pourquoi l'automate n'est pas déterministe
+3. Déterminisez l'automate avec la méthode vue en cours.
+
+Correction.
+
+1. la table de transition
+|                | a    | b    | c    |
+|:---------------|:-----|:-----|:-----|
+| 0 (initial)    | 1,OK | 2,OK | 3,OK |
+| 1              | 1,OK | 1    | 1    |
+| 2              | 2    | 2,OK | 2    |
+| 3              | 3    | 3    | 3,OK |
+| OK (acceptant) |      |      |      |
+
+2. Non déterminisme visible quand une cas contient au moins 2 états successeurs.
+   Par exemple depuis 0 en lisant a je peux aller vers l'état 1 et l'état OK.
+   
+3. Déterminisation
+   
+   |                   | a    | b    | c    |
+   |:------------------|:-----|:-----|:-----|
+   | 0 (initial)       | 1,OK | 2,OK | 3,OK |
+   | 1, OK (acceptant) | 1,OK | 1    | 1    |
+   | 2, OK (acceptant) | 2    | 2,OK | 2    |
+   | 3, OK (acceptant) | 3    | 3    | 3,OK |
+   | 1                 | 1,OK | 1    | 1    |
+   | 2                 | 2    | 2,OK | 2    |
+   | 3                 | 3    | 3    | 3,OK |
+
+
+## Équivalence.
+
+Méthode pour tester si deux automates sont équivalents (acceptent et rejettent exactement les mêmes mots).
+
+
+Provisio : il faut que la machine soit déterministe (hypothèse nécessaire pour la preuve) et complète (hypothèse simplificatrice pour la preuve).
+
+* On regarde tous les mots jusqu'à une taille qui est le produit du nombre d'état des automates.
+* Il faut que les deux automates disent la même chose (accepter ou rejeter) sinon on a trouvé un contre-exemple et on répond non, ils ne sont pas équivalents.
+* Si c'est le cas on répond oui, ils sont équivalents.
+
+La méthode de la machine bi-coeur (similarité avec la construction précédente de déterminisation) permet de démontrer que cette méthode fonctionne et donner soit un contre-exemple, soit une preuve que les deux machines sont équivalentes.
+
+L'idée consiste à simuler de manière synchrone les deux automates en parallèle.
+La machine bi-coeur a une paire d'état au début correspondant à la paire des états initiaux.
+Il faut que à chaque étape de construction de son programme, les deux coeurs disent la même chose.
+
+Détails dans transparents.
+
+

2-InformationTheory/0Dates.md

@@ -0,0 +1,11 @@
+# Information Theory
+
+Les dates importantes.
+* 3 mars.   cours brevet + lecture collective du début de quelques brevets.
+* 10 mars.  choix de brevet. 
+* 31 mai. ludique grep ou brevet
+* 3 avril. Après-midi, Atelier Brevet.
+* 7 avril. ludique grep ou brevet
+* 28 avril. Matin Révisions collective pour examen (il faut réviser avant svp sinon ça ne sert à rien) 
+* 5 mai. Matin Examen Information Theory
+* 12 mai 2025. Après-midi Soutenance brevets

2-InformationTheory/4Brevet.md

@@ -1,35 +1,165 @@
-Cours de Florent.
-
 # Information Theory / Brevet
 
+Dans cette partie du cours, nous nous intéressons à la protection juridique de travail ou d'invention en lien avec l'informatique.
 
-## Point rapide de Droit
+## Licences.
+
+Nous avons déjà abordé rapidement l'existence de divers licences originales pour protéger un programme informatique qui sont le dual des licences avec copy-right et sont dites copy-left.
+
+Un aspect central consiste à demander à pouvoir disposer des sources du code sous licence et à autoriser sa réutilisation et les changements ultérieurs de celui-ci.
+
+Le mouvement autour du logiciel libre s'officialise en particulier avec la création du free software foundation (FSF) aux états-unis en 1985, qui propose la licence GPL (General Public License).
+
+* [GNU GPL](https://en.wikipedia.org/wiki/GNU_General_Public_License)
+
+Le noyaux Linux est traditionnellement protégé par cette licence GPL.
+
+D'autres système d'exploitation libres basés sur unix, comme FreeBSD sont protégés par leur propre licence (licence BSD) plus permissive pour une intégration avec du lociel non-libre.
+
+Il existe de facto un foisonnement de licences plus ou moins libres au sens qu'elles sont plus ou moins copy-left. La FSF elle-même propose une version plus permissive de sa licence GPL, particulièrement adaptée pour des librairies qui pourraient être compatibles avec des logiciels pourtant sous licence copy-right.
+
+* [GNU Lesser GPL](https://en.wikipedia.org/wiki/GNU_Lesser_General_Public_License)
+
+En France, une licence libre est proposée par plusieurs organismes de recherche.
+
+* [CeCILL](https://fr.wikipedia.org/wiki/Licence_CeCILL)
+
+De manière générale, le militantisme tel que porté par la FSF trouve un terreau assez fertile dans de nombreuses universités dans les département d'informatique, ce qui va contribuer à faire évoluer les mentalités dans l'industrie assez rapidement.
+* [Foisonnement de licences](https://en.wikipedia.org/wiki/Free-software_license)
+
+Un autre aspect plus restreint consiste à promouvoir des API ouvertes.
+Une APi consiste à promouvoir la modularité et à documenter la manière d'interagir avec un composant, sans pour autant nécessairement rendre open source ce composant.
+* [API](https://en.wikipedia.org/wiki/API)
+* [open API](https://en.wikipedia.org/wiki/Open_API)
+
+Un précurseur en terme d'API ouverte est par exemple la norme POSIX pour les systèmes unix en 1988 (en fait un standard pour unix).
+
+L'archétype de l'entreprise initialement totalement opposée à la culture du logicel libre et de la transparence est Microsoft qui va pendant toutes les années 90 continuer à s'appuyer sur un copyright traditionnel, des sources non disponibles, deslogiciels qu'il faut acheter, et un système d'API peu documenté qui rend très difficile de faire un logiciel pour le système d'exploitation windows pour une entreprise tierce. En particulier, Microsoft a tout fait pour entraver l'adoption de standard du web et pour favoriser son propre navigateur Internet Explorer. L'entreprise a même poussé le vice jusqu'à faire semblant de suivre des standards en construction pour mieux les saborder (Embrace, extend and extinguish).
+
+* [Monopole](https://en.wikipedia.org/wiki/Microsoft_litigation)
+* [Saborder les standards](https://en.wikipedia.org/wiki/Embrace,_extend,_and_extinguish)
+* [le jeu XBill](https://en.wikipedia.org/wiki/XBill)
+
+On assiste in fine à une transformation de la manière dont les gros projet logiciels sont vendus et organisées depuis des logiciels des années 1980/90 comme ceux vendus par une entreprise comme Microsoft  avec une industrie qui va s'approprier certaines pratiques promus par la mouvance du logiciel libre.
+
+Par exemple, en 1998, Netscape entame le projet open source Mozilla et livre le code de son browser Netscape sous licence GPL. C'est ce projet qui distribue Firefox.
+
+En 2001, même Microsoft fini par ouvrir les sources de son système d'exploitation.
+
+* [Shared Source Initiative](https://en.wikipedia.org/wiki/Shared_Source_Initiative)
+
+En 2001, Apple propose Mac OS X qui est basé sur FreeBSD (sous Apple Public Source License); et, en 2005, Android alors racheté par Google développe son système d'exploitation basé sur linux (sous licence Apache) avec initialement une réimplémentation plus ou moins partielle de l'API du langage java.
+
+Ceci n'a pas empêché les mastodontes d'abuser de leur position dominante sous couvert de veiller à la sécurité de leurs usagers et à la qualité des produits de prélever des frais fixe de 30 pour cent (apple store, google play)
+
+Le fait que Android soit open source permet par exemple de réaliser des forks qui permettent une meilleure protection des données personnelles.
+
+* [CalyxOS](https://en.wikipedia.org/wiki/CalyxOS)
+* [custom Android OS](https://en.wikipedia.org/wiki/List_of_custom_Android_distributions)
+
+Quelques affaires.
+
+* [google vs Oracle](https://en.wikipedia.org/wiki/Google_LLC_v._Oracle_America,_Inc)
+* [Epic Game vs Apple](https://en.wikipedia.org/wiki/Epic_Games_v._Apple)
+* [Epic Game vs Google](https://en.wikipedia.org/wiki/Epic_Games_v._Google)
+
+
+## Patent in the US.
+
+Aux états-unis, on peut déposer un brevet sur un algorithme (avec un contenu mathématique important et novateur ou pas).
+
+Exemples de 3 brevets.
+1. LZW compression et le format GIF
+2. RSA Public Key encryption
+3. Amazon One click Shopping
+
+Nous avons déjà évoqué l'algorithme de compression LZW et son lien avec le format GIF.
+
+Un autre exemple intéressant est le travail sur la crypto à clé publique avec RSA (papier en 76, RSA est l'initiale des trois auteurs, brevet en 1983) et peu d'alternatives pendant plusieurs années. RSA était utilisé au début des années 90 dans le programme PGP (pretty good privacy) ainsi que dans des protocoles comme SSL ou SSH.
+
+Un exemple qui peut sembler un peu plus ridicule est l'achat en un clic d'amazon (plutôt pour se défendre de ces concurrents directs à l'époque dans la vente en ligne de livres), la demande est rejettée en 2007 pour un brevet européen (pas original) et au Canada (effet physique).
+
+
+* [source un peu datée mais intéressante vieux projet à Stanford en 2000](https://cs.stanford.edu/people/eroberts/courses/cs181/projects/1999-00/software-patents/)
+
+* [one click](https://en.wikipedia.org/wiki/1-Click)
+
+Les trois brevets discutés dans cette section sont disponibles sur le git.
+
+* [brevet Compression LZW US](../Brevets/BrevetsHistoriques/US_4558302_A.pdf)
+* [brevet RSA US](../Brevets/BrevetsHistoriques/US4405829.pdf)
+* [brevet One click US](../Brevets/BrevetsHistoriques/US5960411.pdf)
+
+Un peu d'histoire des brevets aux US avec les évolutions en particulier politique lorsque l'administration Clinton nomme à la tête de l'USPTO un ancien lobbyiste de l'industrie du logiciel.
+
+* [software patent in the US](https://en.wikipedia.org/wiki/Software_patents_under_United_States_patent_law)
+
+## Brevets en Europe
+
+Il y a une différence fondamentale entre le droit aux US et en Europe qui limite plus lourdement la brevetabilité d'un algorithme.
+
+
+En France, depuis 2007, c'est la convention sur le brevet Européen (CBE) et ces directives qui sont applicables.
+* [intro vulgarisée](https://www.epo.org/fr/news-events/in-focus/ict/hardware-and-software)
+
+En général en europe, on peut poser un brevet sur n'importe quelle technologie (article 52) à condition d'avoir 3 ingrédients : être novateur (détails à l'article 53), ne pas être évident (détails à l'article 56), être susceptible d'une application industrielle (détails à l'article 57).
+
+Il y toutefois des exceptions. En particulier l'Article 52.2.a stipule qu'on ne peut pas poser un brevet sur
+
+> les découvertes, les théories scientifiques et les méthodes mathématiques".
+
+* [Article 52](https://www.epo.org/fr/legal/epc/2020/a52.html)
+
+On ne peut pas non plus poser de brevet sur du code qui lui relève du droit d'auteur.
+
+Au final il semble qu'un ingrédient typique permettant de poser un brevet sur une idée informatique consiste à l'expliquer dans un contexte physique.
+Par exemple de la compression dans le cadre d'un usage en télécommunication, de la cryptographie embarqué, ou encore de l'indexation dans le cadre d'un cache.
+
+Dans les directives il faut plus spécifiquement regarder les articles en lien avec une invention mise en oeuvre par ordinateur (IMO, en anglais et en allemand CII). 
+La définition est reproduite ci-dessous.
+
+> Une invention mise en œuvre par ordinateur (IMO) est une invention qui implique l'utilisation d'un ordinateur, 
+> d'un réseau informatique ou d'un autre appareil programmable et dont une ou plusieurs caractéristiques sont 
+> réalisées totalement ou en partie par un programme d'ordinateur.
+
+> A computer-implemented invention (CII) is one which involves the use of a computer, 
+> computer network or other programmable apparatus, where one or more features 
+> are realised wholly or partly by means of a computer program.
+
+Pour plus de détails une annexe propose
+* [index IMO](https://www.epo.org/fr/legal/guidelines-epc/2024/j.html#)
+
+## Stratégie pour permettre de poser un brevet sur un algorithme
+
+De manière générale, il est intéressant de mettre en avant la stratégie permettant de poser un brevet sur un algorithme.
+
+Un aspect très fréquent semble consister à mettre en avant les aspects matériels.
+
+Une autre technique consiste à rendre l'algorithme tellement flou qu'on peut mettre en avant d'autres aspects.
 
-TO DO.
 
 ## Recherche de Brevets
 
 Exemples de sites pour trouver des brevets :
 
-* (en local)[../Brevets/]
+* [en local](../Brevets/)
-* (inpi)[https://data.inpi.fr/recherche_avancee/brevets?advancedSearch=%257B%2522checkboxes%2522%253A%257B%2522bases_choice%2522%253A%257B%2522order%2522%253A0%252C%2522searchField%2522%253A%255B%2522origin%2522%255D%252C%2522values%2522%253A%255B%257B%2522value%2522%253A%2522FR%2522%252C%2522checked%2522%253Atrue%257D%252C%257B%2522value%2522%253A%2522CCP%2522%252C%2522checked%2522%253Atrue%257D%252C%257B%2522value%2522%253A%2522EP%2522%252C%2522checked%2522%253Atrue%257D%252C%257B%2522value%2522%253A%2522WO%2522%252C%2522checked%2522%253Atrue%257D%255D%257D%257D%252C%2522texts%2522%253A%257B%2522cpc%2522%253A%257B%2522order%2522%253A5%252C%2522searchField%2522%253A%255B%2522patentClassifications.classificationSymbol%2522%255D%252C%2522checkedSearchField%2522%253A%255B%255D%252C%2522value%2522%253A%2522H03M%25207%252F40%2522%257D%257D%252C%2522multipleSelects%2522%253A%257B%257D%252C%2522dates%2522%253A%257B%257D%257D]
+* [inpi](https://data.inpi.fr/recherche_avancee/brevets?advancedSearch=%257B%2522checkboxes%2522%253A%257B%2522bases_choice%2522%253A%257B%2522order%2522%253A0%252C%2522searchField%2522%253A%255B%2522origin%2522%255D%252C%2522values%2522%253A%255B%257B%2522value%2522%253A%2522FR%2522%252C%2522checked%2522%253Atrue%257D%252C%257B%2522value%2522%253A%2522CCP%2522%252C%2522checked%2522%253Atrue%257D%252C%257B%2522value%2522%253A%2522EP%2522%252C%2522checked%2522%253Atrue%257D%252C%257B%2522value%2522%253A%2522WO%2522%252C%2522checked%2522%253Atrue%257D%255D%257D%257D%252C%2522texts%2522%253A%257B%2522cpc%2522%253A%257B%2522order%2522%253A5%252C%2522searchField%2522%253A%255B%2522patentClassifications.classificationSymbol%2522%255D%252C%2522checkedSearchField%2522%253A%255B%255D%252C%2522value%2522%253A%2522H03M%25207%252F40%2522%257D%257D%252C%2522multipleSelects%2522%253A%257B%257D%252C%2522dates%2522%253A%257B%257D%257D)
-* (recherche par code CDC)[https://worldwide.espacenet.com/classification?locale=fr_EP#!/CPC=H03M7/00]
+* [recherche par code CDC](https://worldwide.espacenet.com/classification?locale=fr_EP#!/CPC=H03M7/00)
+* [google patent](https://patents.google.com/)
 
+## Exercice de compréhension et restitution d'un brevet
 
-## Exercice de compréhension et restitution d'un brevet (pour les M1DN)
+objectif : lire un brevet avec un aspect technique qui présente un contenu algorithmique. Le restituer en vulgarisant les aspects techniques et en mettant en avant les points juridiques saillants.
 
-objectif : lire un brevet avec un aspect technique, qui présente au moins un algorithme.
+Soit dans la liste présenté, soit un de votre choix mais à faire valider par mes soins avant.
 
-Soit dans la liste présenté, soit un de votre choix mais à faire vazlider par mes soins avant.
+* restitution devantr un jury composé de Florent et Maïté
-
+* 15 minutes environ par groupe
-* restitution le 25 mars.
-* 15 minutes environ pare groupe
 * groupe de 2 ou 3
-* Préparer un support de présentation de 3 à 5 pages maximum : e.g. 1 page pour présenter le brevet très rapidement, 1 ou 2 pages pour présenter tout ou partie de l'aspect algorithmique (un ou plusieurs dessins du brevet, ou des versions simplifiées), 1 ou 2 pages pour parler plutôt de votre perception en temps que juriste. Si l'algorithme est très complioqué, vous pouvez présenter grossièrement l'algorithme général puis zoomer sur un point particulier.
+* Préparer un support de présentation de 3 à 5 pages maximum : e.g. 1 page pour présenter le brevet très rapidement, 1 ou 2 pages pour présenter tout ou partie de l'aspect algorithmique (un ou plusieurs dessins du brevet, ou des versions simplifiées), 1 ou 2 pages pour parler plutôt de votre perception en temps que juriste. Si l'algorithme est très compliqué, vous pouvez présenter grossièrement l'algorithme général puis zoomer sur un point particulier.
 
-Notation. Bienveillante. L'important est de faire l'exercice et de voir à quoi ressemble un brevet sur un sujet technique car ceci pourrait vous concerner dans votre travail à court ou moyen terme. 
+Notation. Bienveillante. 
-
+L'important est de faire l'exercice et de voir à quoi ressemble un brevet sur un sujet technique car ceci pourrait vous concerner dans votre travail à court ou moyen terme. 
-Autre aspect. Expliquer de manière vulgarisée un algorithme.
 
 
 Cas d'usage qu'on ne verra pas pour aller au delà de l'exercice.
@@ -38,5 +168,15 @@ Cas d'usage qu'on ne verra pas pour aller au delà de l'exercice.
 
 
 
+## Etc
 
+Quelques domaines évoqués à l'oral qui peuvent faire l'objet de brevets que j'ai pré-selectionné.
+
+### Contre-mesure contre une attaque par canal caché.
+
+En cryptographie, que ce soit dans le contexte de méthodes de chiffrement symétriques comme DES ou AES (clé de chiffrement et de déchiffrement secrètes) ou asymétriques comme RSA (clé de chiffrement publique, clé de déchiffrement secrète), il est possible d'obtenir une information secrète importante en utilisant des informations physiquement observables pendant le processus de chiffrement ou de déchiffrement.
+
+Par exemple pendant le calcul de chiffrement de RSA, l'étape centrale consiste à faire un calcul d'exponentielle modulaire dite rapide, en transcrivant la clé en base 2
+
+* [Side channel attack](https://en.wikipedia.org/wiki/Side-channel_attack)
 

2-InformationTheory/5Choix-social.md

@@ -0,0 +1,148 @@
+# Théorie du choix social
+
+Plusieurs résultats d'économistes résonnent en math et en informatique par les aspects algorithmiques qui sous-tendent ces résultats.
+
+* 1950 [Théorème d'impossibilité d'Arrow](https://en.wikipedia.org/wiki/Arrow%27s_impossibility_theorem)
+* 1950 [stratégies dans des jeux et équilibre de Nash](https://en.wikipedia.org/wiki/Nash_equilibrium)
+* 1962 [algorithme de Gale et Shapley pour calculer un mariage stable](https://en.wikipedia.org/wiki/Gale%E2%80%93Shapley_algorithm)
+
+Vous avez évoqué le dernier résultat sur le calcul d'un mariage stable avec Luc Pelissier, algorithme qui est essentiellement simulé par Parcoursup.
+
+Nous allons expliquer dans ce cours le premier théorème.
+
+## introduction.
+
+Derrière le mot "voter" se cache un corpus vaste.
+
+En tant que juriste vous avez probablement une sensibilité naturelle à la question, et vous n'êtes pas sans savoir que même si c'est un [droit fondamental en France](https://www.elections.interieur.gouv.fr/comprendre-elections/pourquoi-je-vote/limportance-du-droit-de-vote), les problèmes de représentativité réel ou perçus peuvent [détourner les électeurs des urnes](https://fr.wikipedia.org/wiki/Abstention_%C3%A9lectorale_en_France).
+
+On peut s'intéresser à l'usage et au fonctionnement de [machines electroniques](https://en.wikipedia.org/wiki/Voting_machine) voir de machines mécaniques, y compris avec un élément de hasard [déjà en usage en Grèce antique](https://en.wikipedia.org/wiki/Kleroterion). Ces machines influencent d'ailleurs le langage comme dans l'expression anglaise [blackballing](https://en.wikipedia.org/wiki/Blackballing).
+
+De manière générale la [fraude](https://en.wikipedia.org/wiki/Electoral_fraud) présente dans un système classique sur papier, est encore possible voir encore plus prévalente dans un système de vote dématérialisé. L'acceptabilité du résultat de l'élection est également influencé par la capacité de vérifier le résultat facilement. Une procédure claire standardisée [comme employée en France](https://mobile.interieur.gouv.fr/Archives/Archives-elections/Comment-voter/Fonctionnement-d-un-bureau-de-vote) offre de nombreux avantages. Le taux d'erreur d'une telle procédure manuelle n'est pas forcément plus mauvais d'ailleurs qu'un recomptage automatisé, même si dans le second cas une fraude est peut-être plus simple à organiser.
+
+Il existe tout de même des procotoles permettant aux électeurs de vérifier la présence de leur bulletin tout en préservant une certaine anonymité.
+* [reçus et résistance aux manipulations](https://en.wikipedia.org/wiki/End-to-end_auditable_voting_systems)
+Ce genre de méthode est proposé par exemple dans un service gratuit de l'INRIA.
+* [électronique et en ligne](https://www.belenios.org/howitworks.html)
+
+Dans ce cours, je souhaite faire un pas de côté et me concentrer sur l'aspect purement mathématique de la méthode utilisée pour désigner un choix collectif à partir des choix individuels des citoyens.
+
+En effet, on peut considérer des systèmes de vote et les comparer en s'intéressant à ces systèmes en tant qu'objet d'étude mathématique. On peut proposer divers propriétés souhaitables d'un système de vote pour le bon fonctionnement d'une démocratie et indiquer pour chaque système de vote s'il satisfait ou non une propriété souhaitable.
+
+Cette approche remonte aux alentours de la révolution française, quand des mathématiciens comme Condorcet et Borda ont montré les défauts du système de vote majoritaire et proposé des méthodes concurrentes pour y remédier.
+
+On verra en particulier le [théorème dû à Arrow](https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_d%27impossibilit%C3%A9_d%27Arrow) publié en 1950 qui value à Arrow de recevoir le prix Nobel d'économie en 1972. Ce résultat appartient à un champs d'étude pluridisciplinaire, la [théorie du choix social](https://fr.wikipedia.org/wiki/Th%C3%A9orie_du_choix_social).
+On discutera si le temps le permet des variantes de ce théorème.
+
+
+## Flashback : Le paradoxe de Condorcet
+
+Condorcet remarque qu'on peut parfois obtenir si on a 3 alternatives (A, B et C), et plusieurs choix "rationnels" et "transitifs" exprimés (les individus classent A, B et C strictement), un résultat qui n'est pas transitif si on utilise la majorité pour comparer 2 à 2 des éléments parmi A,B,C en terme de choix "consensuel global".
+
+Exemple tiré de la page wikipedia du [paradoxe de Condorcet](https://fr.wikipedia.org/wiki/Paradoxe_de_Condorcet)
+
+Considérons par exemple une assemblée de 60 votants ayant le choix entre trois propositions A, B et C. Les préférences se répartissent ainsi (en notant A > B, le fait que A est préféré à B) :
+
+        23 votants préfèrent : A > B > C
+        17 votants préfèrent : B > C > A
+        2 votants préfèrent :  B > A > C
+        10 votants préfèrent : C > A > B
+        8 votants préfèrent :  C > B > A
+
+Dans les comparaisons majoritaires par paires, on obtient :
+
+        33 préfèrent A > B contre 27 pour B > A
+        42 préfèrent B > C contre 18 pour C > B
+        35 préfèrent C > A contre 25 pour A > C
+
+Ce qui conduit à la contradiction interne A > B > C > A . 
+
+Quand ce paradoxe ne se produit pas, Condorcet propose d'élire ce vainqueur.
+
+## Théorème d'Arrow
+Ce résultat vient confirmer l'intuition de Condorcet et démontrer que l'on ne peut pas dès qu'on a au moins 3 alternatives proposer de système de vote qui permette de garantir 3 propriétés simultanées pourtant en apparence fortement souhaitables.
+
+Il s'agit donc d'un résultat d'**impossibilité**.
+
+On part d'une collection de préférences des individus.
+(En pratique beaucoup plus d'électeurs que d'alternatives).
+Une **fonction de choix social** est une fonction d'agrégat qui à partir des préférences individuelles va construire une préférence collective.
+
+Une seconde hypothèse de travail.
+* universalité. La fonction de choix totale est toujours définie et n'utilise pas de hasard (elle est déterministe, si on recompte alors les résultat est le même).
+
+Les propriétés.
+* pas de dictateur.
+* unanimité (optimum de Pareto) : si tout le monde a une préférence alors l'agrégat également.
+* indépendances des options non pertinentes ;
+
+Cette dernière propriété n'est pas spécialement la plus facile à expliquer.
+Sa [page wikipedia anglaise](https://en.wikipedia.org/wiki/Independence_of_irrelevant_alternatives) présente une histoire humoristique qui donne une première intuition.
+
+> Morgenbesser, ordering dessert, is told by a waitress that he can choose between blueberry or apple pie. He orders apple. Soon the waitress comes back and explains cherry pie is also an option. Morgenbesser replies "In that case, I'll have blueberry."
+
+
+## Les propriétés plus formellement.
+
+Il est utile de lire formellement les propriétés pour mieux comprendre leur signification.
+
+Voir [ici](https://en.wikipedia.org/wiki/Arrow%27s_impossibility_theorem#Formal_statement_of_the_theorem)
+
+## Une preuve simplifiée
+Voir [ici](https://en.wikipedia.org/wiki/Arrow%27s_impossibility_theorem#Proof_by_the_pivotal_voter)
+
+Cette preuve suppose un ordre strict pour les préférence.
+Le théorème reste correct pour un ordre partiel.
+
+## Dépasser le paradoxe d'Arrow
+
+Certaines méthodes sont concernés par le théorème d'Arrow, mais sont plébiscités par certaines chercheurs, comme par exemple une méthode utilisée en Irlande et aux US :
+* [instant runoff ou alternative vote](https://en.wikipedia.org/wiki/Instant-runoff_voting)
+Cette méthode est relativement complexe pour compter les votes manuellement, mais permet d'indiquer des préférences nuancés et de se passer d'un second tour.
+
+
+Plus généralement, on peut se pencher sur des méthodes qui tentent d'apporter un élément quantitatif pour préciser les préférences. On parle de vote par valeurs (cardinal voting ou rated voting en anglais).
+Ceci est par opposition à la méthode de classement (ordinal voting en anglais).
+
+
+Il existe divers méthodes proposées par des chercheurs en théorie du choix social comme par exemple :
+* [Le jugement majoritaire](https://en.wikipedia.org/wiki/Majority_judgment)
+
+
+* [Comparaison de différentes méthodes, en particulier en terme d'acceptabilité sociale](https://www.gate.cnrs.fr/vote/)
+
+## Survol d'autres résultats du domaine.
+
+L'article suivant présente d'autres résultats en les expliquant sans trop rentrer dans les détails mathématiques.
+* [article cairn](https://www.cairn.info/revue-cahiers-d-economie-politique-1-2004-2-page-53.htm)
+
+L'article suivant est beaucoup plus large que le précédent si vous souhaitez creuser le sujet.
+* [Choix social dans l'encyclopédie de Stanford](https://plato.stanford.edu/entries/social-choice/)
+
+Cet article récent donne une version quantitative du théorème d'Arrow.
+* [arrow quantitatif](https://arxiv.org/pdf/0903.2574.pdf)
+
+
+## Liens
+
+* [Paradoxe de Condorcet](https://fr.wikipedia.org/wiki/Paradoxe_de_Condorcet)
+* [Théorème d'Arrow (encyclopédie de philosophie de Stanford)](https://plato.stanford.edu/entries/arrows-theorem/)
+* [Gibbard–Satterthwaite theorem](https://en.wikipedia.org/wiki/Gibbard%E2%80%93Satterthwaite_theorem))
+* [Paradoxe de Sen](https://fr.wikipedia.org/wiki/Paradoxe_de_Sen)
+
+* [Système de votes](https://fr.wikipedia.org/wiki/Syst%C3%A8me_%C3%A9lectoral)
+* [Comme au Royaume-uni Majoritaire un tour (first pas the post)](https://fr.wikipedia.org/wiki/Scrutin_uninominal_majoritaire_%C3%A0_un_tour)
+* [Comme la présidentielle française](https://fr.wikipedia.org/wiki/Scrutin_uninominal_majoritaire_%C3%A0_deux_tours)
+* [Méthode de Borda](https://fr.wikipedia.org/wiki/M%C3%A9thode_Borda)
+* [Méthode de Condorcet](https://fr.wikipedia.org/wiki/M%C3%A9thode_de_Condorcet)
+* [instant runoff ou alternative vote](https://en.wikipedia.org/wiki/Instant-runoff_voting)
+* [Vote par valeurs](https://en.wikipedia.org/wiki/Rated_voting)
+* [Le jugement majoritaire](https://en.wikipedia.org/wiki/Majority_judgment)
+
+* [Article vulgarisé inspiré élection 2017](https://www.lamsade.dauphine.fr/~lang/runoff.pdf)
+* [Vote tactique pour le perdant d'une élection tripartite qui veut faire barrage](https://www.lamsade.dauphine.fr/~lang/grand-est.pdf)
+
+* [Comparaison de différentes méthodes, en particulier en terme d'acceptabilité sociale](https://www.gate.cnrs.fr/vote/)
+
+* [Gerrymandering](https://en.wikipedia.org/wiki/Gerrymandering)
+* [blackballing](https://en.wikipedia.org/wiki/Blackballing)

3-GrapheSocial/4CM-M2TNT-Choix-social.html

@@ -0,0 +1,67 @@
+<h1 id="théorie-du-choix-social">Théorie du choix social</h1>
+<p>M2 TNT Graphe social</p>
+<p>## introduction.</p>
+<p>Derrière le mot “voter” se cache un corpus vaste.</p>
+<p>En tant que politiste vous avez probablement une sensibilité naturelle à la question, et vous n’êtes pas sans savoir que même si c’est un <a href="https://www.elections.interieur.gouv.fr/comprendre-elections/pourquoi-je-vote/limportance-du-droit-de-vote">droit fondamental en France</a>, les problèmes de représentativité réel ou perçus peuvent <a href="https://fr.wikipedia.org/wiki/Abstention_%C3%A9lectorale_en_France">détourner les électeurs des urnes</a>.</p>
+<p>On peut s’intéresser à l’usage et au fonctionnement de <a href="https://en.wikipedia.org/wiki/Voting_machine">machines electroniques</a> voir de machines mécaniques, y compris avec un élément de hasard <a href="https://en.wikipedia.org/wiki/Kleroterion">déjà en usage en grèce antique</a>. Ces machines influencent d’ailleurs le langage comme dans l’expression anglaise <a href="https://en.wikipedia.org/wiki/Blackballing">blackballing</a>.</p>
+<p>De manière générale la <a href="https://en.wikipedia.org/wiki/Electoral_fraud">fraude</a> présente dans un système classique sur papier, est encore possible voir encore plus prévalente dans un système de vote dématérialisé. L’acceptabilité du résultat de l’élection est également influencé par la capacité de vérifier le résultat facilement. Une procédure claire standardisée <a href="https://mobile.interieur.gouv.fr/Archives/Archives-elections/Comment-voter/Fonctionnement-d-un-bureau-de-vote">comme employée en France</a> offre de nombreux avantages. Le taux d’erreur d’une telle procédure manuelle n’est pas forcément plus mauvais d’ailleurs qu’un recomptage automatisé, même si dans le second cas une fraude est peut-être plus simple à organiser.</p>
+<p>Il existe tout de même des procotoles permettant aux électeurs de vérifier la présence de leur bulletin tout en préservant une certaine anonymité. * <a href="https://en.wikipedia.org/wiki/End-to-end_auditable_voting_systems">reçus et résistance aux manipulations</a> Ce genre de méthode est proposé par exemple dans un service gratuit de l’INRIA. * <a href="https://www.belenios.org/howitworks.html">électronique et en ligne</a></p>
+<p>Dans ce cours, je souhaite faire un pas de côté et me concentrer sur l’aspect purement mathématique de la méthode utilisée pour désigner un choix collectif à partir des choix individuels des citoyens. En effet, on peut considérer des systèmes de vote et les comparer en s’intéressant à ces systèmes en tant qu’objet d’étude mathématique. On peut proposer divers propriétés souhaitables d’un système de vote pour le bon fonctionnement d’une démocratie et indiquer pour chaque système de vote s’il satistait ou non une propriété souhaitable. Cette approche remonte aux alentours de la révolution française, quand des mathématiciens comme Condorcet et Borda ont montré les défauts du système de vote majoritaire et proposé des méthodes concurrentes pour y remédier.</p>
+<p>On verra en particulier un <a href="https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_d%27impossibilit%C3%A9_d%27Arrow">théorème dû à Arrow</a> publié en 1950 qui value à Arrow de recevoir le prix Nobel d’économie en 1972. Ce résultat appartient à un champs d’étude pluridisciplinaire, la <a href="https://fr.wikipedia.org/wiki/Th%C3%A9orie_du_choix_social">théorie du choix social</a>. On discutera si le temps le permet des variantes de ce théorème.</p>
+<h2 id="flashback-le-paradoxe-de-condorcet">Flashback : Le paradoxe de Condorcet</h2>
+<p>Condorcet remarque qu’on peut parfois obtenir si on a 3 alternatives (A, B et C), et plusieurs choix “rationnels” et “transitifs” exprimés (les individus classent A, B et C strictement), un résultat qui n’est pas transitif si on utilise la majorité pour comparer 2 à 2 des éléments parmi A,B,C en terme de choix “consensuel global”.</p>
+<p>Exemple tiré de la page wikipedia du <a href="https://fr.wikipedia.org/wiki/Paradoxe_de_Condorcet">paradoxe de Condorcet</a></p>
+<p>Considérons par exemple une assemblée de 60 votants ayant le choix entre trois propositions A, B et C. Les préférences se répartissent ainsi (en notant A &gt; B, le fait que A est préféré à B) :</p>
+<pre><code>    23 votants préfèrent : A &gt; B &gt; C
+    17 votants préfèrent : B &gt; C &gt; A
+    2 votants préfèrent :  B &gt; A &gt; C
+    10 votants préfèrent : C &gt; A &gt; B
+    8 votants préfèrent :  C &gt; B &gt; A</code></pre>
+<p>Dans les comparaisons majoritaires par paires, on obtient :</p>
+<pre><code>    33 préfèrent A &gt; B contre 27 pour B &gt; A
+    42 préfèrent B &gt; C contre 18 pour C &gt; B
+    35 préfèrent C &gt; A contre 25 pour A &gt; C</code></pre>
+<p>Ce qui conduit à la contradiction interne A &gt; B &gt; C &gt; A .</p>
+<p>Quand ce paradoxe ne se produit pas, Condorcet propose d’élire ce vainqueur.</p>
+<h2 id="théorème-darrow">Théorème d’Arrow</h2>
+<p>Ce résultat vient confirmer l’intuition de Condorcet et démontrer que l’on ne peut pas dès qu’on a au moins 3 alternatives proposer de système de vote qui permette de garantir 3 propriétrés simultanées pourtant en apparence fortement souhaitables.</p>
+<p>Il s’agit donc d’un résultat d’<strong>impossibilité</strong>.</p>
+<p>On part d’une collection de préférences des individus. (En pratique beaucoup plus d’électeurs que d’alternatives). Une <strong>fonction de choix social</strong> est une fonction d’aggrégat qui à partir des préférences individuelles va construire une préférence collective.</p>
+<p>Les propriétés. * universalité. La fonction de choix totale est toujours définie et n’utilise pas de hasard (elle est déterministe, si on “reconte” alores les résultat est le même). * pas de dictateur. * unanimité (optimum de Pareto) : si tout le monde a une préférence alors l’agrégat également. * indépendances des options non pertinentes ;</p>
+<p>Cette dernière propriété n’est pas spécialement la plus facile à expliquer. Sa <a href="https://en.wikipedia.org/wiki/Independence_of_irrelevant_alternatives">page wikipedia anglaise</a> présente une histoire humoristique qui donne une première intuition.</p>
+<blockquote>
+<p>Morgenbesser, ordering dessert, is told by a waitress that he can choose between blueberry or apple pie. He orders apple. Soon the waitress comes back and explains cherry pie is also an option. Morgenbesser replies “In that case, I’ll have blueberry.”</p>
+</blockquote>
+<h2 id="les-propriétés-plus-formellement.">Les propriétés plus formellement.</h2>
+<p>Il est utile de lire formellement les propriétés pour mieux comprendre leur signification.</p>
+<p>Voir <a href="https://en.wikipedia.org/wiki/Arrow%27s_impossibility_theorem#Formal_statement_of_the_theorem">ici</a></p>
+<h2 id="une-preuve-simplifiée">Une preuve simplifiée</h2>
+<p>Voir <a href="https://en.wikipedia.org/wiki/Arrow%27s_impossibility_theorem#Proof_by_the_pivotal_voter">ici</a></p>
+<p>Cette preuve suppose un ordre strict pour les préférence. Le théorème reste correct pour un ordre partiel.</p>
+<h2 id="dépasser-le-paradoxe-darrow">Dépasser le paradoxe d’Arrow</h2>
+<p>Certaines méthodes sont concernés par le théorème d’Arrow, mais sont plébiscités par certaines chercheurs, comme par exemple une méthode utilisée en Irlande et aux US : * <a href="https://en.wikipedia.org/wiki/Instant-runoff_voting">instant runoff ou alternative vote</a> Cette méthode est relativement complexe pour compter les votes manuellement, mais permet d’indiquer des préférences nuancés et de se passer d’un second tour.</p>
+<p>Plus généralement, on peut se pencher sur des méthodes qui tentent d’apporter un élément quantitatif pour précisser les préférences. On parle de vote par valeurs (cardinal voting ou rated voting en anglais). Ceci est par opposition à la méthode de classement (ordinal voting en anglais).</p>
+<p>Il existe divers méthodes proposées par des chercheurs en théorie du choix social comme par exemple : * <a href="https://en.wikipedia.org/wiki/Majority_judgment">Le jugement majoritaire</a></p>
+<ul>
+<li><a href="https://www.gate.cnrs.fr/vote/">Comparaison de différentes méthodes, en particulier en terme d’acceptabilité sociale</a></li>
+</ul>
+<h2 id="liens">Liens</h2>
+<ul>
+<li><p><a href="https://fr.wikipedia.org/wiki/Paradoxe_de_Condorcet">Paradoxe de Condorcet</a></p></li>
+<li><p><a href="https://plato.stanford.edu/entries/arrows-theorem/">Théorème d’Arrow (encyclopédie de philosophie de Stanford)</a></p></li>
+<li><p><a href="https://en.wikipedia.org/wiki/Gibbard%E2%80%93Satterthwaite_theorem">Gibbard–Satterthwaite theorem</a>)</p></li>
+<li><p><a href="https://fr.wikipedia.org/wiki/Paradoxe_de_Sen">Paradoxe de Sen</a></p></li>
+<li><p><a href="https://fr.wikipedia.org/wiki/Syst%C3%A8me_%C3%A9lectoral">Système de votes</a></p></li>
+<li><p><a href="https://fr.wikipedia.org/wiki/Scrutin_uninominal_majoritaire_%C3%A0_un_tour">Comme au Royaume-uni Majoritaire un tour (first pas the post)</a></p></li>
+<li><p><a href="https://fr.wikipedia.org/wiki/Scrutin_uninominal_majoritaire_%C3%A0_deux_tours">Comme la présidentielle française</a></p></li>
+<li><p><a href="https://fr.wikipedia.org/wiki/M%C3%A9thode_Borda">Méthode de Borda</a></p></li>
+<li><p><a href="https://fr.wikipedia.org/wiki/M%C3%A9thode_de_Condorcet">Méthode de Condorcet</a></p></li>
+<li><p><a href="https://en.wikipedia.org/wiki/Instant-runoff_voting">instant runoff ou alternative vote</a></p></li>
+<li><p><a href="https://en.wikipedia.org/wiki/Rated_voting">Vote par valeurs</a></p></li>
+<li><p><a href="https://en.wikipedia.org/wiki/Majority_judgment">Le jugement majoritaire</a></p></li>
+<li><p><a href="https://www.lamsade.dauphine.fr/~lang/runoff.pdf">Article vulgarisé inspiré élection 2017</a></p></li>
+<li><p><a href="https://www.lamsade.dauphine.fr/~lang/grand-est.pdf">Vote tactique pour le perdant d’une élection tripartite qui veut faire barrage</a></p></li>
+<li><p><a href="https://www.gate.cnrs.fr/vote/">Comparaison de différentes méthodes, en particulier en terme d’acceptabilité sociale</a></p></li>
+<li><p><a href="https://en.wikipedia.org/wiki/Gerrymandering">Gerrymandering</a></p></li>
+<li><p><a href="https://en.wikipedia.org/wiki/Blackballing">blackballing</a></p></li>
+</ul>

Brevets/AtelierBrevet/introAtelierBrevet.md

@@ -0,0 +1,37 @@
+# M1DN Atelier Brevet
+# jeudi 3 avril 2025
+
+# Programme
+
+* 14h intro
+Bienvenue + présentation de quelques minutes de chaque orateur (15 minutes)
+
+* 14h15 à 15h.
+Daniele Varacca (professeur en informatique, LACL, UPEC). Dépôt d'un brevet en italie.
+30 minutes + 15 minutes discussion et questions.
+
+* Clara Cuvelier (étudiant M2 DN, alternante à ...). ...
+
+# Introduction
+
+	
+* Daniele Varacca
+
+	Amateur de parmesan depuis 1971 et polyglotte en langues naturelles et en langage informatique, Daniele a fait un beau voyage académique en Europe avant de devenir professeur au LACL dans l'équipe **spécification et vérification de systèmes**.
+  
+  Il obtient un Master en mathématiques en 1998 à l'université de Pise puis un PhD en informatique à l'université de Aarhus en 2003 sous la direction de Glynn Winskel pourtant de Cambridge.
+  
+  Dans sa thèse intitulée **Two Denotational Models for Probabilistic Computation** il contribue au domaine d'informatique théorique dit de **la sémantique**, dont le but est de mieux comprendre la nature d'un traitement en informatique. Contrairement aux modèles de calcul que nous avons étudiés ensemble (automate, machine de Turing) pour lesquels c'est principalement le calcul ou des questions autour du calcul qui priment, il s'agit plutôt dans le cadre de la sémantique d'associer à un programme un modèle, qui est un objet mathématique bien choisi et qui permet de mieux expliquer et comprendre le programme. Idéalement, le modèle est assez intéressant pour permettre de refléter des propriétés intéressantes du programme, mais restent assez simple pour qu'on puisse l'étudier formellement.
+  Par ailleurs, il est souhaitable que l'association programme vers modèle puisse être combinée morceaux par morceaux : une technique qui offre nativement cette compositionalité consiste à utiliser des modèles de la théorie des catégories.
+  Dans ce cadre, Daniele s'est intéressé par exemple à étudier la sémantique de programmes concurrents par des catégories adéquates.
+  
+  Il travaille ensuite un an et demi au département informatique de l'ENS Paris avec Giuseppe Castagna sur la sémantique du pi-calcul, qui permet de modéliser des programmes concurrents.
+  
+  Il poursuit ses travaux à Imperial avec Nobuko Yoshida pour travailler par exemple sur un modèle de concurrence mettant en avant un typage des événements dans la lignée de travaux de Millner.
+  
+  Il travaille ensuite comme maître de conférence au laboratoire PPS de 2006 à 2014.
+ 
+ 
+ Daniele va vous présenter son expérience de dépôt d'un brevet en italie en 2017.
+ 
+