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 


</p>
</details>