Wiki du LAMA (UMR 5127) - Contributions [fr]

Structures de données purement fonctionnelles

2020-05-29T09:02:22Z

Dornel :

== Présentation du problème ==

Lorsque l'on souhaite coder une structure de données dans un langage impératif comme C, Ada, Pascal ou Perl, il est très facile de trouver des livres sur le sujet. En revanche, si l'on souhaite utiliser le paradigme fonctionnel, que ce soit Lisp, Haskell ou OCaml, le choix est nettement plus restreint.

<q>Un programmeur peut choisir le paradigme de son langage, pourvu que ce soit impératif.</q>
- Chris Okasaki, pastiche d'une citation de Ford, ''Purely functional data structures'', 1996

Ainsi, Chris Okasaki a voulu explorer à travers sa thèse (et son livre la développant) diverses structures de données adaptées au paradigme fonctionnel.

Mais avant d'étudier les solutions proposées, il est nécessaire de définir quelques contraintes et termes.

=== Problèmes liés au paradigme fonctionnel ===

[[Fichier:Schema_1.png|300px|thumb|right|Différence entre structure éphémère et persistante illustrée par une liste chaînée dont on supprime le dernier élément.]]

Le paradigme fonctionnel est principalement basé sur l'évaluation de fonctions et d'expressions mathématiques, et tout ce qui ne peut être représenté ainsi n'est pas admis.

De ce fait naît le premier obstacle à la création de structures de données purement fonctionnelles : Le changement d'état étant banni, '''on ne peut pas réaliser d'assignation de variable'''.
 
Là où les langages impératifs font fréquemment usage de l'assignation de variable et de la modification de valeurs, il faut trouver d'autres solutions en fonctionnel pour contourner ce problème. Okasaki compare le lien entre l'assignation et le programmeur à celui entre les couteaux et un chef cuisinier. Dans les deux cas, un mauvais usage peut être dangereux et destructeur, mais extrêmement efficace avec un usage intelligent.

Une deuxième difficulté liée à l'absence d'assignation provient du fait que l'on attende davantage une '''persistance''' d'une structure de données fonctionnelle. En effet, là où il est admis que l'actualisation d'une structure impérative détruit l'ancienne version pour ne garder que la nouvelle (ce genre de structure de données est dit "éphémère"), on s'attend que l'actualisation d'une structure fonctionnelle donne l'accès aux deux versions (d'où la notion de structure "persistante"). Il est possible d'avoir des structures persistantes en impératif, mais on associera ici la notion d'éphémérité au paradigme impératif tandis que la persistance sera liée au paradigme fonctionnel.

Enfin, un troisième problème lié au paradigme fonctionnel relève du temps d'exécution, le fonctionnel étant généralement considéré comme étant '''moins efficace que l'impératif'''. Ainsi, il est nécessaire de trouver des structures de données qui soient aussi efficaces que celles utilisées en impératif.

=== Évaluation stricte et évaluation paresseuse ===

On appelle '''évaluation stricte''' une technique d'implémentation d'un programme récursif où les arguments sont évalués avant le corps de la fonction.
L'évaluation est dite '''paresseuse''' quand les arguments sont évalués lors du premier appel par la fonction avant d'être mis en cache pour un autre usage ultérieur.

Chaque type d'évaluation a ses avantages et inconvénients. Une évaluation stricte permettra de gérer le cas "Pire scénario" tandis qu'une évaluation paresseuse sera plus à l'aise avec les structures dites amorties.

Un avantage indéniable qu'a cependant l'évaluation stricte sur l'évaluation paresseuse est que l'on peut calculer le temps d'évaluation plus facilement (notion de [https://fr.wikipedia.org/wiki/Comparaison_asymptotique comparaison asymptotique], notamment du grand O de Landau).

=== Vocabulaire ===

Avant de commencer à étudier les solutions proposées par Okasaki, il est nécessaire de poser quelques termes de vocabulaire.

; Abstraction
: Un type de données abstrait, autrement dit un type et un ensemble de fonctions agissant sur ce type.

Exemple : Le premier bloc de code de liste chaînée (voir ci-dessous) est une abstraction de cette structure, avec le type élément et les divers constructeurs, destructeurs et méthodes sur cette structure.

; Implémentation
: Une réalisation concrète d'une abstraction. Il est important de noter qu'une implémentation ne correspond pas nécessairement à du code, un modèle concret suffit.

Exemple : Posons qu'un élément est soit null, soit le couplet liant un entier et un pointeur vers l'élément suivant. Ceci correspond à l'implémentation de l'abstraction de la structure liste chaînée.

; Objet / Version
: Une instance d'un type de données, telle une variante spécifique de liste ou d'arbre.

Exemple : Soit une liste chaînée d'entiers. Il s'agit d'une version d'une liste chaînée.

; Identité persistante
: Une identité unique et invariante malgré les changements. Par exemple, "la pile" en parlant de toutes ses différentes versions correspond à son identité persistante.

Maintenant que nous avons posé des bases solides, nous pouvons commencer à étudier les diverses structures de données proposées par Okasaki. Le langage utilisé est OCaml.

== Solutions proposées ==

En se basant sur la présentation, on peut faire remarquer deux points :
* Afin d'avoir des structures persistantes, il est nécessaire de travailler sur une copie de l'argument plutôt que l'argument lui-même
* À l'exception de la liste chaînée, toutes les structures évoquées ci-après ne fonctionnent qu'avec des types ordonnés.

<pre lang="OCaml">module type ORDERED = sig
type t
val eq: t -> t -> bool
val lt: t -> t -> bool
val leq: t -> t -> bool
end;;</pre>
''Code permettant d'implémenter un type polymorphe ordonné. On admet que ce type est défini pour toutes les structures ci-dessous.''

=== Liste chaînée ===

Cette structure basique sert d'introduction à la persistance, ce qui nous permet de présenter les différences d'implémentation de cette structure dans un paradigme impératif comparé à un paradigme fonctionnel.

''Abstraction de la structure liste chaînée''
<pre lang="OCaml">module type LIST = sig
type 'a t

(* Constructeurs *)
val nil: 'a t
val cons: 'a -> 'a t -> 'a t
val is_empty: 'a t -> bool

(* Destructeurs *)
val head: 'a t -> 'a
val tail: 'a t -> 'a t

(* Méthodes *)
val append: 'a t -> 'a t -> 'a t
val update: 'a t -> int -> 'a -> 'a t
val suffixes: 'a t -> 'a t t
end;;</pre>

Ici, nous allons observer les méthodes, à savoir append, update et suffixes.

* '''append - Concaténation de deux listes'''

Soient xs et ys deux listes et zs la concaténation de xs et ys.

En impératif, une structure de données efficace basée sur la liste chaînée peut comporter deux pointeurs globaux, un sur le premier élément et un sur le dernier. Ainsi, pour concaténer xs et ys, il suffit de modifier le dernier élément de xs pour qu'il pointe vers le premier de ys. L'avantage, c'est que le temps d'exécution est d'ordre O(1), donc constant. Cependant, en obtenant zs, on garde ys mais on perd xs.

En fonctionnel, zs est une reconstruction de xs à laquelle on accole ys. Si on note n la longueur de xs, la fonction a un temps d'exécution d'ordre O(n), mais on garde toujours xs et ys.

<pre lang="OCaml">let rec append = fun xs ys ->
if is_empty xs
then ys
else cons (head xs) (append (tail xs) ys)</pre>

L'idée est de "déconstruire" xs afin de se retrouver avec une liste vide. Au fur et à mesure, on reconstruit xs élément par élément avant d'y accoler ys lorsque cet objectif est atteint.

* '''update - Mise à jour d'un nœud'''

On cherche à changer la valeur x au rang i dans xs par la valeur y.

En impératif, on cherche le nœud concerné et on change la valeur. Le temps d'exécution est d'ordre O(n) dans le pire des cas, mais le xs original est perdu.

En fonctionnel, la méthode de recherche est la même. Le temps d'exécution est toujours d'ordre O(n) dans le pire des cas, mais on récupère ys, reconstruction altérée de xs tout en conservant l'original.

<pre lang="OCaml">let rec update = fun xs i y ->
if is_empty xs
then raise Index_out_of_bounds (* Si la liste est vide, il n'y a rien à remplacer ! *)
else if i = 0
then cons y (tail xs)
else cons (head xs) (update (tail xs) (i - 1) y)</pre>

Comme pour append, on déconstruit puis reconstruit xs, sauf que l'on a un compteur qui est décrémenté de 1 par élément reconstruit. S'il atteint 0, la valeur de l'élément actuel est replacé par y. Si on reconstruit xs dans son intégralité (donc qu'il ne reste que la liste vide) avant que le compteur ait atteint 0, on lève une exception.

* '''suffixes - Afficher tous les suffixes d'une liste par ordre décroissant de taille'''

Par exemple, la liste [1, 2, 3, 4] doit retourner [[1, 2, 3, 4], [2, 3, 4], [3, 4], [4], []].

Le temps d'exécution de cette fonction est d'ordre O(n).

<pre lang="OCaml">let rec suffixes = fun xs ->
if is_empty xs
then nil
else cons xs (suffixes (tail xs))</pre>

Ici, on utilise le fait que la fonction tail renvoie toute la liste sauf la tête. Ainsi, on peut accoler tous les suffixes un par un, jusqu'à s'arrêter avec la liste vide.

=== Arbre de recherche binaire ===

Il est possible d'utiliser des méthodes de recherche plus complexes lorsque l'on utilise une structure où un élément pointe vers plus qu'un seul autre élément. Prenons par exemple les arbres de recherche binaires.

Un arbre de recherche binaire est un arbre dont les valeurs stockées dans chaque élément sont rangées par ''ordre symétrique'', c'est-à-dire que pour un nœud donné, sa valeur est supérieure à toutes les valeurs stockées dans le sous-arbre de gauche et inférieure à celles dans le sous-arbre de droite.

Dans le code ci-dessous, BalancedTree est un foncteur, autrement dit une fonction qui prendre comme paramètre un module O de type ORDERED.

<pre lang="OCaml">module BalancedTree(O: ORDERED)= struct
type elem = O.t

type tree = E | T of (tree * elem * tree)

let rec member...

let rec insert...
end;;</pre>

Penchons-nous sur les méthodes member et insert.

* '''member - Vérifie si une valeur est présente dans l'arbre'''

En reprenant notre type ordonné, on remarque que l'on ne dispose que de 3 fonctions de test, à savoir l'égalité (O.eq), l'infériorité stricte (O.lt) et l'infériorité (O.leq).

Pour construire cette fonction, on serait tenté d'écrire :

<pre lang="OCaml">let rec member = fun xs x ->
match xs with
| E -> false
| T(e1, y, e2) -> if (O.lt x y)
then member e1 x
else if (O.lt y x)
then member e2 x
else true</pre>

On regarde si la valeur du nœud est strictement plus grande que celle recherchée. Si oui, on continue à chercher à gauche. Sinon, on regarde si la valeur du nœud est strictement inférieure à celle recherchée. Si c'est le cas, on poursuit la recherche à gauche. Sinon, il y a égalité et la valeur est bien membre de l'arbre. Si on atteint une feuille sans avoir eu d'égalité, alors la valeur n'appartient pas à l'arbre.

En effet, le pire scénario, ici la branche qui tourne toujours à droite jusqu'au bout de l'arbre, exigerait '''2n comparaisons''' (avec n la profondeur de l'arbre) pour retourner un résultat, étant donné qu'il effectue deux comparaisons par nœud.

<pre lang="OCaml">let rec member =
let rec member_aux = fun xs aux x ->
match xs with
| E -> O.eq aux x
| T(e1, y, e2) -> if (O.lt x y)
then member_aux e1 aux x
else member_aux e2 y x
in fun xs x ->
match xs with
| E -> false
| T(e1, y, e2) -> if(O.lt x y)
then member e1 x
else member_aux e2 y x</pre>

Ici, on fait appel à une fonction auxiliaire itérative stockant une valeur intermédiaire. Cette fonction fait appel au fait que si x n'est pas strictement inférieur à y, alors x est supérieur ''ou égal'' à y. Ainsi, on parcourt la branche correspondante comme précédemment, mais on garde ce candidat potentiel jusqu'à ce que l'on atteigne une feuille. Ainsi, on ne réalise dans le pire des cas que '''n + 1 comparaisons''', une par niveau de profondeur et une supplémentaire pour vérifier l'égalité une fois arrivé aux feuilles.

* '''insert - Insère une valeur dans l'arbre'''

Pour l'insertion, on procède similairement pour atteindre la feuille correspondante.

<pre lang="OCaml">let rec insert = fun xs x ->
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) as s -> if (O.lt x y)
then T((insert e1 x), y, e2)
else if (O.lt y x)
then T(e1, y, (insert e2 x))
else s</pre>

Comme précédemment, on regarde s'il faut continuer à gauche ou à droite en reconstruisant une copie de l'arbre au fur et à mesure. Cependant, si la valeur à ajouter est déjà présente dans l'arbre, on recopie également ce nœud, ce qui fait que '''la branche de recherche est testée de la racine à la feuille''' sans aucun changement à appliquer. En levant une exception si l'on trouve la valeur à ajouter dans l'arbre, on optimise le temps d'exécution en ne faisant pas de copie inutile.

<pre lang="OCaml">exception Already_there

let rec insert = fun xs x ->
try begin
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) -> if(O.lt x y)
then T((insert e1 x), y, e2)
else if (O.lt y x)
then T(e1, y, (insert e2 x))
else raise Already_there
end with Already_there -> xs</pre>

Ainsi, on s'arrête si l'on trouve la valeur à ajouter et l'on retourne une copie de l'arbre tel quel.
Et comme pour member, il est possible d'optimiser le nombre de comparaisons, ce qui donne au final une fonction qui ressemble à ceci :

<pre lang="OCaml">let rec insert =
let rec insert_aux = fun xs aux x ->
match xs with
| E -> if (O.eq aux x)
then raise Already_there
else T(E, x, E)
| T(e1, y, e2) -> if (O.lt x y)
then T((insert_aux e1 aux x), y, e2)
else T(e1, y, (insert_aux e2 y x))
in fun xs x ->
try begin
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) -> if (O.lt x y)
then T((insert e1 x), y, e2)
else T(e1, y, (insert_aux e2 y x))
end with Already_there -> xs</pre>

On se retrouve donc avec une fonction d'insertion qui '''ne copie pas inutilement''' et qui ne réalise pas plus que '''n + 1 comparaisons'''.

=== Tas gaucher ===

[[Fichier:Schema_2.png|150px|thumb|right|Exemple de tas gaucher et illustration de la notion de rang.]]

Un tas est une version d'arbre particulière. En effet, elle se caractérise par le fait que la valeur de chaque nœud ne peut être plus grand que n'importe laquelle de ses enfants. Cette caractéristique fait que l'élément le plus petit se trouve toujours à la racine.

Un tas est dit gaucher si le rang de n'importe quel enfant de gauche est supérieur ou égal à celui de l'enfant de droit qui lui est associé. On appelle rang d'un nœud la longueur de sa ''colonne vertébrale droite'', c'est-à-dire le chemin le plus à droite qui va de ce nœud à une feuille. Une conséquence simple de cette propriété est que la colonne vertébrale droite d'un nœud constitue le chemin le plus court de ce nœud à une feuille.

Soit r le rang de la racine d'un tas gaucher de taille n. On peut en déduire que chaque nœud de profondeur inférieure ou égale à r-1 a exactement deux enfants, car sinon r aurait une valeur plus faible ou la propriété gauchère ne serait pas respectée. Ainsi, on peut affirmer que la taille d'un tas est donc d'au moins 2r - 1. De ce fait, on peut en déduire que le rang de la racine vaut au plus log(n + 1). Par conséquent, la colonne vertébrale droite d'un tas gaucher de taille n comporte au plus ⌊log(n + 1)⌋ éléments.

''Code de la structure tas gaucher''
<pre lang="OCaml">module LeftistHeap (O: ORDERED) = struct
type elem = O.t

type heap = Nil | Cons of (int * heap * elem * heap)

let rank = fun h ->
match h with
| Nil -> 0
| Cons(r, _, _, _) -> r

let makeH...

let merge...

let insert...

exception EmptyHeap

let findMin...

let deleteMin...
end;;</pre>

Ici, nous allons étudier les fonctions merge, insert, findMin et deleteMin.

* '''merge - Fusionne deux tas'''

Afin de simplifier l'opération, on remarque que la colonne vertébrale droite d'un tas gaucher est ordonnée. On en déduit que le concept clé est de fusionner les colonnes vertébrales des deux tas comme on fusionnerait deux listes triées avant d'échanger les enfants le long de la branche afin de restaurer la propriété gauchère.

Comme il a été démontré précédemment que la longueur de la colonne vertébrale est au plus logarithmique, on peut en déduire que merge a un temps d'exécution d'ordre O(log n).

<pre lang="OCaml">let makeH = fun v a b ->
if rank a >= rank b
then Cons(rank b + 1, a, v, b)
else Cons(rank a + 1, b, v, a)

let rec merge = fun x y ->
match x, y with
| Nil, _ -> y
| _, Nil -> x
| Cons(_, e11, v1, e12), Cons(_, e21, v2, e22) -> if (O.leq v1 v2)
then makeH v1 e11 (merge e12 y)
else makeH v2 e21 (merge x e22)</pre>

Ici, on fait appel à une fonction intermédiaire : makeH.

Cette fonction compare le rang des deux tas et échange les enfants si besoin afin de respecter la propriété gauchère.

Ensuite, concernant merge en elle-même, on compare les valeurs des deux racines et on fait appel à makeH pour combiner et potentiellement échanger les enfants.

* '''insert - Insère une valeur dans l'arbre'''

Une fois merge défini, il suffit d'établir que l'on veut fusionner le tas avec un tas d'une seule valeur. Et puisque le temps d'exécution de merge est d'ordre O(log n), il en va de même pour insert.

<pre lang="OCaml">let insert = fun v h -> (merge (Cons(1, Nil, v, Nil)) h)</pre>

* '''findMin - Récupère le minimum'''

Comme le minimum est par définition à la racine, le temps d'exécution de findMin est d'ordre O(1), donc constant.

<pre lang="OCaml">let findMin = fun h ->
match h with
| Nil -> raise EmptyHeap
| Cons(_, _, v, _) -> v</pre>

* '''deleteMin - Supprime le minimum'''

Similairement, le minimum étant à la racine, on peut établir que le supprimer revient à fusionner ses enfants. De plus, merge ayant un temps d'exécution d'ordre O(log n), celui de deleteMin est le même.

<pre lang="OCaml">let deleteMin = fun h ->
match h with
| Nil -> raise EmptyHeap
| Cons(_, a, _, b) -> merge a b</pre>

=== Tas binomial ===

[[File:Schema_3.png|300px|thumb|right|Représentation des arbres binaires de rangs 0 à 3]]

Les tas binomiaux sont des tas composés d'un type plus primitif appelé arbre binomial. Les arbres binomiaux sont défini inductivement comme suit :

* Un arbre binomial de rang 0 est un singleton de nœud ;
* Un arbre binomial de rang r est formé en liant deux arbres binomiaux de rang r-1 tel qu'un des arbres devient l'enfant le plus à gauche de l'autre.

De cette définition, on comprend qu'un arbre binomial de rang r contient exactement 2r nœuds.

Il existe une deuxième définition équivalente des arbres binomiaux :

* Un arbre binomial de rang r est un nœud ayant r enfants t1 à tr où chaque enfant ti est un arbre binomial de rang r - i.

Dans le code ci-dessous, on représente un nœud dans un arbre binomial comme un élément avec une liste de ses enfants. Par commodité, on note aussi le rang de chaque nœud.

De plus, un tas binomial étant une liste d'arbres binomiaux ne pouvant comporter qu'un seul arbre d'un rang donné et un arbre binomial de rang r comportant 2r éléments, on constate alors que les arbres d'un tas binomial de taille n correspondent à la représentation binaire de n.

Par exemple, la représentation binaire de 13 est 1101, donc un tas binomial de taille 13 contient un arbre de rang 0, un de rang 2 et un de rang 3 (de taille respective 1, 4 et 8).
De plus, comme la représentation binaire de n contient au plus ⌊log(n + 1)⌋ bits à 1, un tas binomial de taille n contient au plus ⌊log(n + 1)⌋ arbres.

<pre lang="OCaml">module BinomialHeap (O: ORDERED) = struct
type elem = O.t

type tree = Node of (int * elem * tree list)
type heap = tree list

exception EmptyHeap

let rank (Node(r, _, _)) = r
let root (Node(_, x, _)) = x

let link = ...

let rec insTree...

let insert = ...

let rec merge...

let rec removeMinTree...

let findMin = ...

let deleteMin = ...
end;;</pre>

Les fonctions que nous allons étudier ici sont link, insert, merge, findMin et deleteMin.

* '''link - Lie deux arbres de même rang pour en construire un de rang supérieur'''

Les arbres étant triés en respectant la propriété du tas, il suffit de comparer les racines pour voir lequel reste au sommet en les liant, l'autre étant ajouté à la liste des enfants.

<pre lang="OCaml">let link = fun (Node(r, x1, c1) as t1) (Node(_, x2, c2) as t2) ->
if (O.leq x1 x2)
then Node(r + 1, x1, t2 :: c1)
else Node(r + 1, x2, t1 :: c2)</pre>

* '''insert - Insertion d'un élément'''

Les fonctions insert et merge sont toutes deux vaguement comparables à l'addition de deux nombres binaires. Pour insérer un nouvel élément, on crée un singleton d'arbre (donc de rang 0) puis on parcourt tous les arbres du tas par ordre croissant de rang jusqu'à trouver un rang manquant en liant les arbres de rang égal en chemin. On peut comparer le lien à une retenue arithmétique.

<pre lang="OCaml">let rec insTree = fun t ls ->
match ls with
| [] -> [t]
| t' :: ts' as ts -> if rank t < rank t'
then t :: ts
else insTree (link t t') ts'

let insert = fun x ts -> insTree (Node(0, x, [])) ts</pre>

Le pire scénario étant dans un tas de taille n = 2k - 1 qui nécessiterait k liens, donnant un temps d'exécution d'ordre O(log n).

* '''merge - Fusion de deux tas'''

Comme précédemment, merge parcourt la liste d'arbres de chaque tas par ordre croissant de rang en liant les arbres de rang égal.

<pre lang="OCaml">let rec merge = fun ts1 ts2 ->
match ts1, ts2 with
| _, [] -> ts1
| [], _ -> ts2
| t1 :: ts1', t2 :: ts2' -> if rank t1 < rank t2
then t1 :: (merge ts1' ts2)
else if rank t2 < rank t1
then t2 :: (merge ts1 ts2')
else insTree (link t1 t2) (merge ts1' ts2')</pre>

* '''findMin et deleteMin - Trouve et supprime le minimum respectivement'''

Ces deux fonctions ont besoin de la même fonction auxiliaire, à savoir removeMinTree, qui trouve l'arbre avec la plus petite valeur et l'extrait de la liste, retournant à la fois l'arbre et le reste de la liste.

<pre lang="OCaml">let rec removeMinTree = fun ls ->
match ls with
| [] -> raise EmptyHeap
| [t] -> (t, [])
| t :: ts -> let (t', ts') = removeMinTree ts in
if (O.leq (root t) (root t'))
then (t, ts)
else (t', t :: ts')

let findMin = fun ts -> let (t, _) = removeMinTree ts in root t

let deleteMin = fun ts -> let (Node(_, x, ts1), ts2) = removeMinTree ts in merge (rev ts1) ts2</pre>

À partir de là, findMin retourne juste la racine de l'arbre. Cependant, deleteMin est plus complexe. En effet, après avoir retiré la racine de l'arbre, il faut remettre la liste d'enfants de l'arbre avec le reste de la liste des arbres. Cela dit, bien que chaque liste d'enfants est une collection d'arbres binomiaux de rang unique, ceux-ci sont triés ''par ordre décroissant de rang et non par ordre croissant''. Afin de convertir cette liste en tas binomial valide, on l'inverse à l'aide de la fonction rev avant de la fusionner avec les arbres restants.

=== Arbre rouge / noir ===

[[File:Schema_4.png|300px|thumb|right|Illustration des invariants]]

Précédemment, nous avons vu les arbres de recherche binaires. Bien que cette structure fonctionne bien avec des données aléatoires ou désordonnées, leur performance est grandement réduite avec des données ordonnées car toutes les opérations ont un temps d'exécution d'ordre allant jusqu'à O(n). Une solution à ce problème est de garder chaque arbre relativement équilibré. Ainsi, aucune opération n'a de temps d'exécution d'ordre excédant O(log n). Une famille d'arbres de recherche binaires équilibrés populaire est celle des '''arbres bicolores, ou arbres rouge-noir'''.

Un arbre bicolore est un arbre binaire dont chaque nœud a une couleur, rouge ou noir. On considère qu'un nœud vide est noir.
De plus, un arbre bicolore doit respecter deux invariants :
# '''Aucun nœud rouge ne peut avoir d'enfant rouge.'''
# '''Toutes les branches allant de la racine à une feuille doivent avoir le même nombre de nœuds noirs.'''

De ces deux invariants, on peut extraire que le chemin le plus long - alternant nœuds noirs et rouge - est au plus deux fois plus long que le chemin le plus court - composé uniquement de nœuds noirs.
En reprenant la démonstration faite sur la longueur de la colonne vertébrale d'un tas gaucher, on sait que le chemin le plus court d'un arbre de profondeur n contient au plus ⌊log(n + 1)⌋ éléments. Par conséquent, on peut en déduire que le chemin le plus long contient au plus 2⌊log(n + 1)⌋ éléments.

<pre lang="OCaml">module RedBlackTree(O: ORDERED)= struct
type elem = O.t

type color = R | B
type tree = E | T of (color * tree * elem * tree)

let balance...

let rec member = fun x t ->
match t with
| E -> false
| T(_, e1, y, e2) -> if (O.lt x y)
then member x a
else if (O.lt y x)
then member x b
else true

let rec insert...
end;;</pre>

Ici, nous allons étudier les fonctions insert et balance. Mis à part le caractère générique pour la couleur, member fonctionne comme pour les arbres binaires non équilibrés.

* '''insert - Insertion d'une nouvelle valeur dans l'arbre'''

La différence majeure entre cette fonction et sa variante pour les arbres non équilibrés relève du respect des invariants.

<pre lang="OCaml">let insert = fun x t ->
let fun ins = function E -> T(R, E, x, E)
| T(color, e1, y, e2) as t' -> if (O.lt x y)
then balance (color, ins a, y, b)
else if (O.lt y x)
then balance (color, a, y, ins b)
else t'
in let T(_, e1, y, e2) = ins t
in T(B, e1, y, e2)</pre>

Cette fonction étend la variante non équilibrée sur trois axes majeurs :
Premièrement, quand on crée un nouveau nœud, on le colore initialement en rouge. Deuxièmement, on force le nœud final à être noir, indépendamment de la couleur retournée par la fonction ins. Enfin, on replace les appels au constructeur T par des appels à la fonction balance, chargée de construire un nœud tout en modifiant l'arbre pour respecter les invariants d'équilibre.

* '''balance - Équilibrage de l'arbre selon les invariants'''

En donnant la couleur rouge à un nouveau nœud, on maintient l'invariant 2 mais viole l'invariant 1 à chaque fois que le parent est rouge. Pour ce faire, on autorise une violation rouge-rouge à la fois que l'on fait remonter le long de la branche de recherche vers la racine en équilibrant.
La fonction balance détecte une violation rouge-rouge quand il voit une suite noir-rouge-rouge et la corrige (voir figure ci-dessous).

[[File:Schema_5.png|none|500px|thumb|left|Fonctionnement de la fonction balance]]

Ici, le code essaie de trouver l'un des quatre cas noir-rouge-rouge ne respectant pas l'invariant 1, puis de le corriger. Si aucun cas n'est trouvé, alors on construit le sous-arbre tel quel.

<pre lang="OCaml">let balance = function
(B,T (R,T (R,a,x,b),y,c),z,d) -> T (R,T (B,a,x,b),y,T (B,c,z,d))
| (B,T (R,a,x,T (R,b,y,c)),z,d) -> T (R,T (B,a,x,b),y,T (B,c,z,d))
| (B,a,x,T (R,T (R,b,y,c),z,d)) -> T (R,T (B,a,x,b),y,T (B,c,z,d))
| (B,a,x,T (R,b,y,T(R,c,z,d))) -> T (R,T (B,a,x,b),y,T (B,c,z,d))
| (c,a,x,b) -> T (c,a,x,b)</pre>

== Évolution du domaine de recherche ==

Après s'être penché en détail sur la thèse d'Okasaki, voici quelques articles plus récents en rapport avec le sujet permettant d'élargir la question.

* '''Manufacturing Datatypes''' par Ralf Hinze, publié en 1999 et édité par Okasaki traitant d'une structure générale pour construire des structures de données purement fonctionnelles permettant de satisfaire des contraintes de taille ou de forme, notamment pour l'implémentation de matrices et de certains types d'arbres.

* '''Scrap your boilerplate: a practical design pattern for generic programming''' de Ralf Lämmel et Simon Peyton-Jones proposant un modèle de métastructure, c'est-à-dire (une structure permettant de générer du code ?), afin de remédier à l'usage de code passe-partout, autrement dit du code répété à plusieurs reprises avec très peu de modifications.

* '''Finger trees: a simple general-purpose data structure''' de Ralf Hinze et Ross Paterson introduisant une nouvelle structure : les arbres pointés 2-3 permettant d'accéder aux feuilles dans un laps de temps amorti constant. Cette structure peut servir de base pour plusieurs autres structures de données.

* '''Parallel Concurrent ML''' de John Reppy, Claudio V. Russo et Yingqi Xiao présentant le langage fonctionnel concurrent CML (pour Concurrent ML), c'est-à-dire que le programme peut utiliser plusieurs processus simultanément, réduisant le temps d'exécution.

== Sources et annexes ==

'''Sources'''

* [https://www.cs.cmu.edu/~rwh/theses/okasaki.pdf Thèse d'Okasaki]

* [https://doc.lagout.org/programmation/Functional%20Programming/Chris_Okasaki-Purely_Functional_Data_Structures-Cambridge_University_Press%281998%29.pdf Purely functional data structures, Chris Okasaki]

* [https://fr.wikipedia.org/wiki/Programmation_fonctionnelle Programmation fonctionnelle (Wikipédia FR)]

* [https://en.wikipedia.org/wiki/Leftist_tree Tas gaucher (Wikipédia EN)]

'''Annexes'''

* [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.39.5334&rep=rep1&type=pdf#page=7 Manufacturing Datatypes]

* [https://www.researchgate.net/publication/221282345_Scrap_Your_Boilerplate_A_Practical_Design_Pattern_for_Generic_Programming Scrap your boilerplate: a practical design pattern for generic programming]

* [https://archive.alvb.in/msc/03_infoafp/papers/2012-12-18_WerkCollege_FingerTreesRalfHinze.pdf Finger trees: a simple general-purpose data structure]

* [https://www.microsoft.com/en-us/research/wp-content/uploads/2009/09/Parallel-Concurrent-ML.pdf Parallel Concurrent ML]

Fichier:Schema 5.png

2020-05-29T08:55:55Z

Dornel : Illustration du fonctionnement de la fonction balance

Illustration du fonctionnement de la fonction balance

Fichier:Schema 4.png

2020-05-29T08:03:51Z

Dornel : Illustration des invariants des arbres bicolores

Illustration des invariants des arbres bicolores

Structures de données purement fonctionnelles

2020-05-29T07:45:06Z

Dornel : /* Arbre rouge / noir */

== Présentation du problème ==

Lorsque l'on souhaite coder une structure de données dans un langage impératif comme C, Ada, Pascal ou Perl, il est très facile de trouver des livres sur le sujet. En revanche, si l'on souhaite utiliser le paradigme fonctionnel, que ce soit Lisp, Haskell ou OCaml, le choix est nettement plus restreint.

<q>Un programmeur peut choisir le paradigme de son langage, pourvu que ce soit impératif.</q>
- Chris Okasaki, pastiche d'une citation de Ford, ''Purely functional data structures'', 1996

Ainsi, Chris Okasaki a voulu explorer à travers sa thèse (et son livre la développant) diverses structures de données adaptées au paradigme fonctionnel.

Mais avant d'étudier les solutions proposées, il est nécessaire de définir quelques contraintes et termes.

=== Problèmes liés au paradigme fonctionnel ===

[[Fichier:Schema_1.png|300px|thumb|right|Différence entre structure éphémère et persistante illustrée par une liste chaînée dont on supprime le dernier élément.]]

Le paradigme fonctionnel est principalement basé sur l'évaluation de fonctions et d'expressions mathématiques, et tout ce qui ne peut être représenté ainsi n'est pas admis.

De ce fait naît le premier obstacle à la création de structures de données purement fonctionnelles : Le changement d'état étant banni, '''on ne peut pas réaliser d'assignation de variable'''.
 
Là où les langages impératifs font fréquemment usage de l'assignation de variable et de la modification de valeurs, il faut trouver d'autres solutions en fonctionnel pour contourner ce problème. Okasaki compare le lien entre l'assignation et le programmeur à celui entre les couteaux et un chef cuisinier. Dans les deux cas, un mauvais usage peut être dangereux et destructeur, mais extrêmement efficace avec un usage intelligent.

Une deuxième difficulté liée à l'absence d'assignation provient du fait que l'on attende davantage une '''persistance''' d'une structure de données fonctionnelle. En effet, là où il est admis que l'actualisation d'une structure impérative détruit l'ancienne version pour ne garder que la nouvelle (ce genre de structure de données est dit "éphémère"), on s'attend que l'actualisation d'une structure fonctionnelle donne l'accès aux deux versions (d'où la notion de structure "persistante"). Il est possible d'avoir des structures persistantes en impératif, mais on associera ici la notion d'éphémérité au paradigme impératif tandis que la persistance sera liée au paradigme fonctionnel.

Enfin, un troisième problème lié au paradigme fonctionnel relève du temps d'exécution, le fonctionnel étant généralement considéré comme étant '''moins efficace que l'impératif'''. Ainsi, il est nécessaire de trouver des structures de données qui soient aussi efficaces que celles utilisées en impératif.

=== Évaluation stricte et évaluation paresseuse ===

On appelle '''évaluation stricte''' une technique d'implémentation d'un programme récursif où les arguments sont évalués avant le corps de la fonction.
L'évaluation est dite '''paresseuse''' quand les arguments sont évalués lors du premier appel par la fonction avant d'être mis en cache pour un autre usage ultérieur.

Chaque type d'évaluation a ses avantages et inconvénients. Une évaluation stricte permettra de gérer le cas "Pire scénario" tandis qu'une évaluation paresseuse sera plus à l'aise avec les structures dites amorties.

Un avantage indéniable qu'a cependant l'évaluation stricte sur l'évaluation paresseuse est que l'on peut calculer le temps d'évaluation plus facilement (notion de [https://fr.wikipedia.org/wiki/Comparaison_asymptotique comparaison asymptotique], notamment du grand O de Landau).

=== Vocabulaire ===

Avant de commencer à étudier les solutions proposées par Okasaki, il est nécessaire de poser quelques termes de vocabulaire.

; Abstraction
: Un type de données abstrait, autrement dit un type et un ensemble de fonctions agissant sur ce type.

Exemple : Le premier bloc de code de liste chaînée (voir ci-dessous) est une abstraction de cette structure, avec le type élément et les divers constructeurs, destructeurs et méthodes sur cette structure.

; Implémentation
: Une réalisation concrète d'une abstraction. Il est important de noter qu'une implémentation ne correspond pas nécessairement à du code, un modèle concret suffit.

Exemple : Posons qu'un élément est soit null, soit le couplet liant un entier et un pointeur vers l'élément suivant. Ceci correspond à l'implémentation de l'abstraction de la structure liste chaînée.

; Objet / Version
: Une instance d'un type de données, telle une variante spécifique de liste ou d'arbre.

Exemple : Soit une liste chaînée d'entiers. Il s'agit d'une version d'une liste chaînée.

; Identité persistante
: Une identité unique et invariante malgré les changements. Par exemple, "la pile" en parlant de toutes ses différentes versions correspond à son identité persistante.

Maintenant que nous avons posé des bases solides, nous pouvons commencer à étudier les diverses structures de données proposées par Okasaki. Le langage utilisé est OCaml.

== Solutions proposées ==

En se basant sur la présentation, on peut faire remarquer deux points :
* Afin d'avoir des structures persistantes, il est nécessaire de travailler sur une copie de l'argument plutôt que l'argument lui-même
* À l'exception de la liste chaînée, toutes les structures évoquées ci-après ne fonctionnent qu'avec des types ordonnés.

<pre lang="OCaml">module type ORDERED = sig
type t
val eq: t -> t -> bool
val lt: t -> t -> bool
val leq: t -> t -> bool
end;;</pre>
''Code permettant d'implémenter un type polymorphe ordonné. On admet que ce type est défini pour toutes les structures ci-dessous.''

=== Liste chaînée ===

Cette structure basique sert d'introduction à la persistance, ce qui nous permet de présenter les différences d'implémentation de cette structure dans un paradigme impératif comparé à un paradigme fonctionnel.

''Abstraction de la structure liste chaînée''
<pre lang="OCaml">module type LIST = sig
type 'a t

(* Constructeurs *)
val nil: 'a t
val cons: 'a -> 'a t -> 'a t
val is_empty: 'a t -> bool

(* Destructeurs *)
val head: 'a t -> 'a
val tail: 'a t -> 'a t

(* Méthodes *)
val append: 'a t -> 'a t -> 'a t
val update: 'a t -> int -> 'a -> 'a t
val suffixes: 'a t -> 'a t t
end;;</pre>

Ici, nous allons observer les méthodes, à savoir append, update et suffixes.

* '''append - Concaténation de deux listes'''

Soient xs et ys deux listes et zs la concaténation de xs et ys.

En impératif, une structure de données efficace basée sur la liste chaînée peut comporter deux pointeurs globaux, un sur le premier élément et un sur le dernier. Ainsi, pour concaténer xs et ys, il suffit de modifier le dernier élément de xs pour qu'il pointe vers le premier de ys. L'avantage, c'est que le temps d'exécution est d'ordre O(1), donc constant. Cependant, en obtenant zs, on garde ys mais on perd xs.

En fonctionnel, zs est une reconstruction de xs à laquelle on accole ys. Si on note n la longueur de xs, la fonction a un temps d'exécution d'ordre O(n), mais on garde toujours xs et ys.

<pre lang="OCaml">let rec append = fun xs ys ->
if is_empty xs
then ys
else cons (head xs) (append (tail xs) ys)</pre>

L'idée est de "déconstruire" xs afin de se retrouver avec une liste vide. Au fur et à mesure, on reconstruit xs élément par élément avant d'y accoler ys lorsque cet objectif est atteint.

* '''update - Mise à jour d'un nœud'''

On cherche à changer la valeur x au rang i dans xs par la valeur y.

En impératif, on cherche le nœud concerné et on change la valeur. Le temps d'exécution est d'ordre O(n) dans le pire des cas, mais le xs original est perdu.

En fonctionnel, la méthode de recherche est la même. Le temps d'exécution est toujours d'ordre O(n) dans le pire des cas, mais on récupère ys, reconstruction altérée de xs tout en conservant l'original.

<pre lang="OCaml">let rec update = fun xs i y ->
if is_empty xs
then raise Index_out_of_bounds (* Si la liste est vide, il n'y a rien à remplacer ! *)
else if i = 0
then cons y (tail xs)
else cons (head xs) (update (tail xs) (i - 1) y)</pre>

Comme pour append, on déconstruit puis reconstruit xs, sauf que l'on a un compteur qui est décrémenté de 1 par élément reconstruit. S'il atteint 0, la valeur de l'élément actuel est replacé par y. Si on reconstruit xs dans son intégralité (donc qu'il ne reste que la liste vide) avant que le compteur ait atteint 0, on lève une exception.

* '''suffixes - Afficher tous les suffixes d'une liste par ordre décroissant de taille'''

Par exemple, la liste [1, 2, 3, 4] doit retourner [[1, 2, 3, 4], [2, 3, 4], [3, 4], [4], []].

Le temps d'exécution de cette fonction est d'ordre O(n).

<pre lang="OCaml">let rec suffixes = fun xs ->
if is_empty xs
then nil
else cons xs (suffixes (tail xs))</pre>

Ici, on utilise le fait que la fonction tail renvoie toute la liste sauf la tête. Ainsi, on peut accoler tous les suffixes un par un, jusqu'à s'arrêter avec la liste vide.

=== Arbre de recherche binaire ===

Il est possible d'utiliser des méthodes de recherche plus complexes lorsque l'on utilise une structure où un élément pointe vers plus qu'un seul autre élément. Prenons par exemple les arbres de recherche binaires.

Un arbre de recherche binaire est un arbre dont les valeurs stockées dans chaque élément sont rangées par ''ordre symétrique'', c'est-à-dire que pour un nœud donné, sa valeur est supérieure à toutes les valeurs stockées dans le sous-arbre de gauche et inférieure à celles dans le sous-arbre de droite.

Dans le code ci-dessous, BalancedTree est un foncteur, autrement dit une fonction qui prendre comme paramètre un module O de type ORDERED.

<pre lang="OCaml">module BalancedTree(O: ORDERED)= struct
type elem = O.t

type tree = E | T of (tree * elem * tree)

let rec member...

let rec insert...
end;;</pre>

Penchons-nous sur les méthodes member et insert.

* '''member - Vérifie si une valeur est présente dans l'arbre'''

En reprenant notre type ordonné, on remarque que l'on ne dispose que de 3 fonctions de test, à savoir l'égalité (O.eq), l'infériorité stricte (O.lt) et l'infériorité (O.leq).

Pour construire cette fonction, on serait tenté d'écrire :

<pre lang="OCaml">let rec member = fun xs x ->
match xs with
| E -> false
| T(e1, y, e2) -> if (O.lt x y)
then member e1 x
else if (O.lt y x)
then member e2 x
else true</pre>

On regarde si la valeur du nœud est strictement plus grande que celle recherchée. Si oui, on continue à chercher à gauche. Sinon, on regarde si la valeur du nœud est strictement inférieure à celle recherchée. Si c'est le cas, on poursuit la recherche à gauche. Sinon, il y a égalité et la valeur est bien membre de l'arbre. Si on atteint une feuille sans avoir eu d'égalité, alors la valeur n'appartient pas à l'arbre.

En effet, le pire scénario, ici la branche qui tourne toujours à droite jusqu'au bout de l'arbre, exigerait '''2n comparaisons''' (avec n la profondeur de l'arbre) pour retourner un résultat, étant donné qu'il effectue deux comparaisons par nœud.

<pre lang="OCaml">let rec member =
let rec member_aux = fun xs aux x ->
match xs with
| E -> O.eq aux x
| T(e1, y, e2) -> if (O.lt x y)
then member_aux e1 aux x
else member_aux e2 y x
in fun xs x ->
match xs with
| E -> false
| T(e1, y, e2) -> if(O.lt x y)
then member e1 x
else member_aux e2 y x</pre>

Ici, on fait appel à une fonction auxiliaire itérative stockant une valeur intermédiaire. Cette fonction fait appel au fait que si x n'est pas strictement inférieur à y, alors x est supérieur ''ou égal'' à y. Ainsi, on parcourt la branche correspondante comme précédemment, mais on garde ce candidat potentiel jusqu'à ce que l'on atteigne une feuille. Ainsi, on ne réalise dans le pire des cas que '''n + 1 comparaisons''', une par niveau de profondeur et une supplémentaire pour vérifier l'égalité une fois arrivé aux feuilles.

* '''insert - Insère une valeur dans l'arbre'''

Pour l'insertion, on procède similairement pour atteindre la feuille correspondante.

<pre lang="OCaml">let rec insert = fun xs x ->
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) as s -> if (O.lt x y)
then T((insert e1 x), y, e2)
else if (O.lt y x)
then T(e1, y, (insert e2 x))
else s</pre>

Comme précédemment, on regarde s'il faut continuer à gauche ou à droite en reconstruisant une copie de l'arbre au fur et à mesure. Cependant, si la valeur à ajouter est déjà présente dans l'arbre, on recopie également ce nœud, ce qui fait que '''la branche de recherche est testée de la racine à la feuille''' sans aucun changement à appliquer. En levant une exception si l'on trouve la valeur à ajouter dans l'arbre, on optimise le temps d'exécution en ne faisant pas de copie inutile.

<pre lang="OCaml">exception Already_there

let rec insert = fun xs x ->
try begin
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) -> if(O.lt x y)
then T((insert e1 x), y, e2)
else if (O.lt y x)
then T(e1, y, (insert e2 x))
else raise Already_there
end with Already_there -> xs</pre>

Ainsi, on s'arrête si l'on trouve la valeur à ajouter et l'on retourne une copie de l'arbre tel quel.
Et comme pour member, il est possible d'optimiser le nombre de comparaisons, ce qui donne au final une fonction qui ressemble à ceci :

<pre lang="OCaml">let rec insert =
let rec insert_aux = fun xs aux x ->
match xs with
| E -> if (O.eq aux x)
then raise Already_there
else T(E, x, E)
| T(e1, y, e2) -> if (O.lt x y)
then T((insert_aux e1 aux x), y, e2)
else T(e1, y, (insert_aux e2 y x))
in fun xs x ->
try begin
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) -> if (O.lt x y)
then T((insert e1 x), y, e2)
else T(e1, y, (insert_aux e2 y x))
end with Already_there -> xs</pre>

On se retrouve donc avec une fonction d'insertion qui '''ne copie pas inutilement''' et qui ne réalise pas plus que '''n + 1 comparaisons'''.

=== Tas gaucher ===

[[Fichier:Schema_2.png|150px|thumb|right|Exemple de tas gaucher et illustration de la notion de rang.]]

Un tas est une version d'arbre particulière. En effet, elle se caractérise par le fait que la valeur de chaque nœud ne peut être plus grand que n'importe laquelle de ses enfants. Cette caractéristique fait que l'élément le plus petit se trouve toujours à la racine.

Un tas est dit gaucher si le rang de n'importe quel enfant de gauche est supérieur ou égal à celui de l'enfant de droit qui lui est associé. On appelle rang d'un nœud la longueur de sa ''colonne vertébrale droite'', c'est-à-dire le chemin le plus à droite qui va de ce nœud à une feuille. Une conséquence simple de cette propriété est que la colonne vertébrale droite d'un nœud constitue le chemin le plus court de ce nœud à une feuille.

Soit r le rang de la racine d'un tas gaucher de taille n. On peut en déduire que chaque nœud de profondeur inférieure ou égale à r-1 a exactement deux enfants, car sinon r aurait une valeur plus faible ou la propriété gauchère ne serait pas respectée. Ainsi, on peut affirmer que la taille d'un tas est donc d'au moins 2r - 1. De ce fait, on peut en déduire que le rang de la racine vaut au plus log(n + 1). Par conséquent, la colonne vertébrale droite d'un tas gaucher de taille n comporte au plus ⌊log(n + 1)⌋ éléments.

''Code de la structure tas gaucher''
<pre lang="OCaml">module LeftistHeap (O: ORDERED) = struct
type elem = O.t

type heap = Nil | Cons of (int * heap * elem * heap)

let rank = fun h ->
match h with
| Nil -> 0
| Cons(r, _, _, _) -> r

let makeH...

let merge...

let insert...

exception EmptyHeap

let findMin...

let deleteMin...
end;;</pre>

Ici, nous allons étudier les fonctions merge, insert, findMin et deleteMin.

* '''merge - Fusionne deux tas'''

Afin de simplifier l'opération, on remarque que la colonne vertébrale droite d'un tas gaucher est ordonnée. On en déduit que le concept clé est de fusionner les colonnes vertébrales des deux tas comme on fusionnerait deux listes triées avant d'échanger les enfants le long de la branche afin de restaurer la propriété gauchère.

Comme il a été démontré précédemment que la longueur de la colonne vertébrale est au plus logarithmique, on peut en déduire que merge a un temps d'exécution d'ordre O(log n).

<pre lang="OCaml">let makeH = fun v a b ->
if rank a >= rank b
then Cons(rank b + 1, a, v, b)
else Cons(rank a + 1, b, v, a)

let rec merge = fun x y ->
match x, y with
| Nil, _ -> y
| _, Nil -> x
| Cons(_, e11, v1, e12), Cons(_, e21, v2, e22) -> if (O.leq v1 v2)
then makeH v1 e11 (merge e12 y)
else makeH v2 e21 (merge x e22)</pre>

Ici, on fait appel à une fonction intermédiaire : makeH.

Cette fonction compare le rang des deux tas et échange les enfants si besoin afin de respecter la propriété gauchère.

Ensuite, concernant merge en elle-même, on compare les valeurs des deux racines et on fait appel à makeH pour combiner et potentiellement échanger les enfants.

* '''insert - Insère une valeur dans l'arbre'''

Une fois merge défini, il suffit d'établir que l'on veut fusionner le tas avec un tas d'une seule valeur. Et puisque le temps d'exécution de merge est d'ordre O(log n), il en va de même pour insert.

<pre lang="OCaml">let insert = fun v h -> (merge (Cons(1, Nil, v, Nil)) h)</pre>

* '''findMin - Récupère le minimum'''

Comme le minimum est par définition à la racine, le temps d'exécution de findMin est d'ordre O(1), donc constant.

<pre lang="OCaml">let findMin = fun h ->
match h with
| Nil -> raise EmptyHeap
| Cons(_, _, v, _) -> v</pre>

* '''deleteMin - Supprime le minimum'''

Similairement, le minimum étant à la racine, on peut établir que le supprimer revient à fusionner ses enfants. De plus, merge ayant un temps d'exécution d'ordre O(log n), celui de deleteMin est le même.

<pre lang="OCaml">let deleteMin = fun h ->
match h with
| Nil -> raise EmptyHeap
| Cons(_, a, _, b) -> merge a b</pre>

=== Tas binomial ===

[[File:Schema_3.png|500px|thumb|right|Représentation des arbres binaires de rangs 0 à 3]]

Les tas binomiaux sont des tas composés d'un type plus primitif appelé arbre binomial. Les arbres binomiaux sont défini inductivement comme suit :

* Un arbre binomial de rang 0 est un singleton de nœud ;
* Un arbre binomial de rang r est formé en liant deux arbres binomiaux de rang r-1 tel qu'un des arbres devient l'enfant le plus à gauche de l'autre.

De cette définition, on comprend qu'un arbre binomial de rang r contient exactement 2r nœuds.

Il existe une deuxième définition équivalente des arbres binomiaux :

* Un arbre binomial de rang r est un nœud ayant r enfants t1 à tr où chaque enfant ti est un arbre binomial de rang r - i.

Dans le code ci-dessous, on représente un nœud dans un arbre binomial comme un élément avec une liste de ses enfants. Par commodité, on note aussi le rang de chaque nœud.

De plus, un tas binomial étant une liste d'arbres binomiaux ne pouvant comporter qu'un seul arbre d'un rang donné et un arbre binomial de rang r comportant 2r éléments, on constate alors que les arbres d'un tas binomial de taille n correspondent à la représentation binaire de n.

Par exemple, la représentation binaire de 13 est 1101, donc un tas binomial de taille 13 contient un arbre de rang 0, un de rang 2 et un de rang 3 (de taille respective 1, 4 et 8).
De plus, comme la représentation binaire de n contient au plus ⌊log(n + 1)⌋ bits à 1, un tas binomial de taille n contient au plus ⌊log(n + 1)⌋ arbres.

<pre lang="OCaml">module BinomialHeap (O: ORDERED) = struct
type elem = O.t

type tree = Node of (int * elem * tree list)
type heap = tree list

exception EmptyHeap

let rank (Node(r, _, _)) = r
let root (Node(_, x, _)) = x

let link = ...

let rec insTree...

let insert = ...

let rec merge...

let rec removeMinTree...

let findMin = ...

let deleteMin = ...
end;;</pre>

Les fonctions que nous allons étudier ici sont link, insert, merge, findMin et deleteMin.

* '''link - Lie deux arbres de même rang pour en construire un de rang supérieur'''

Les arbres étant triés en respectant la propriété du tas, il suffit de comparer les racines pour voir lequel reste au sommet en les liant, l'autre étant ajouté à la liste des enfants.

<pre lang="OCaml">let link = fun (Node(r, x1, c1) as t1) (Node(_, x2, c2) as t2) ->
if (O.leq x1 x2)
then Node(r + 1, x1, t2 :: c1)
else Node(r + 1, x2, t1 :: c2)</pre>

* '''insert - Insertion d'un élément'''

Les fonctions insert et merge sont toutes deux vaguement comparables à l'addition de deux nombres binaires. Pour insérer un nouvel élément, on crée un singleton d'arbre (donc de rang 0) puis on parcourt tous les arbres du tas par ordre croissant de rang jusqu'à trouver un rang manquant en liant les arbres de rang égal en chemin. On peut comparer le lien à une retenue arithmétique.

<pre lang="OCaml">let rec insTree = fun t ls ->
match ls with
| [] -> [t]
| t' :: ts' as ts -> if rank t < rank t'
then t :: ts
else insTree (link t t') ts'

let insert = fun x ts -> insTree (Node(0, x, [])) ts</pre>

Le pire scénario étant dans un tas de taille n = 2k - 1 qui nécessiterait k liens, donnant un temps d'exécution d'ordre O(log n).

* '''merge - Fusion de deux tas'''

Comme précédemment, merge parcourt la liste d'arbres de chaque tas par ordre croissant de rang en liant les arbres de rang égal.

<pre lang="OCaml">let rec merge = fun ts1 ts2 ->
match ts1, ts2 with
| _, [] -> ts1
| [], _ -> ts2
| t1 :: ts1', t2 :: ts2' -> if rank t1 < rank t2
then t1 :: (merge ts1' ts2)
else if rank t2 < rank t1
then t2 :: (merge ts1 ts2')
else insTree (link t1 t2) (merge ts1' ts2')</pre>

* '''findMin et deleteMin - Trouve et supprime le minimum respectivement'''

Ces deux fonctions ont besoin de la même fonction auxiliaire, à savoir removeMinTree, qui trouve l'arbre avec la plus petite valeur et l'extrait de la liste, retournant à la fois l'arbre et le reste de la liste.

<pre lang="OCaml">let rec removeMinTree = fun ls ->
match ls with
| [] -> raise EmptyHeap
| [t] -> (t, [])
| t :: ts -> let (t', ts') = removeMinTree ts in
if (O.leq (root t) (root t'))
then (t, ts)
else (t', t :: ts')

let findMin = fun ts -> let (t, _) = removeMinTree ts in root t

let deleteMin = fun ts -> let (Node(_, x, ts1), ts2) = removeMinTree ts in merge (rev ts1) ts2</pre>

À partir de là, findMin retourne juste la racine de l'arbre. Cependant, deleteMin est plus complexe. En effet, après avoir retiré la racine de l'arbre, il faut remettre la liste d'enfants de l'arbre avec le reste de la liste des arbres. Cela dit, bien que chaque liste d'enfants est une collection d'arbres binomiaux de rang unique, ceux-ci sont triés ''par ordre décroissant de rang et non par ordre croissant''. Afin de convertir cette liste en tas binomial valide, on l'inverse à l'aide de la fonction rev avant de la fusionner avec les arbres restants.

=== Arbre rouge / noir ===

Précédemment, nous avons vu les arbres de recherche binaires. Bien que cette structure fonctionne bien avec des données aléatoires ou désordonnées, leur performance est grandement réduite avec des données ordonnées car toutes les opérations ont un temps d'exécution d'ordre allant jusqu'à O(n). Une solution à ce problème est de garder chaque arbre relativement équilibré. Ainsi, aucune opération n'a de temps d'exécution d'ordre excédant O(log n). Une famille d'arbres de recherche binaires équilibrés populaire est celle des arbres bicolores, ou arbres rouge-noir.

== Évolution du domaine de recherche ==

Après s'être penché en détail sur la thèse d'Okasaki, voici quelques articles plus récents en rapport avec le sujet permettant d'élargir la question.

* '''Manufacturing Datatypes''' par Ralf Hinze, publié en 1999 et édité par Okasaki traitant d'une structure générale pour construire des structures de données purement fonctionnelles permettant de satisfaire des contraintes de taille ou de forme, notamment pour l'implémentation de matrices et de certains types d'arbres.

* '''Scrap your boilerplate: a practical design pattern for generic programming''' de Ralf Lämmel et Simon Peyton-Jones proposant un modèle de métastructure, c'est-à-dire (une structure permettant de générer du code ?), afin de remédier à l'usage de code passe-partout, autrement dit du code répété à plusieurs reprises avec très peu de modifications.

* '''Finger trees: a simple general-purpose data structure''' de Ralf Hinze et Ross Paterson introduisant une nouvelle structure : les arbres pointés 2-3 permettant d'accéder aux feuilles dans un laps de temps amorti constant. Cette structure peut servir de base pour plusieurs autres structures de données.

* '''Parallel Concurrent ML''' de John Reppy, Claudio V. Russo et Yingqi Xiao présentant le langage fonctionnel concurrent CML (pour Concurrent ML), c'est-à-dire que le programme peut utiliser plusieurs processus simultanément, réduisant le temps d'exécution.

== Sources et annexes ==

'''Sources'''

* [https://www.cs.cmu.edu/~rwh/theses/okasaki.pdf Thèse d'Okasaki]

* [https://doc.lagout.org/programmation/Functional%20Programming/Chris_Okasaki-Purely_Functional_Data_Structures-Cambridge_University_Press%281998%29.pdf Purely functional data structures, Chris Okasaki]

* [https://fr.wikipedia.org/wiki/Programmation_fonctionnelle Programmation fonctionnelle (Wikipédia FR)]

* [https://en.wikipedia.org/wiki/Leftist_tree Tas gaucher (Wikipédia EN)]

'''Annexes'''

* [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.39.5334&rep=rep1&type=pdf#page=7 Manufacturing Datatypes]

* [https://www.researchgate.net/publication/221282345_Scrap_Your_Boilerplate_A_Practical_Design_Pattern_for_Generic_Programming Scrap your boilerplate: a practical design pattern for generic programming]

* [https://archive.alvb.in/msc/03_infoafp/papers/2012-12-18_WerkCollege_FingerTreesRalfHinze.pdf Finger trees: a simple general-purpose data structure]

* [https://www.microsoft.com/en-us/research/wp-content/uploads/2009/09/Parallel-Concurrent-ML.pdf Parallel Concurrent ML]

Structures de données purement fonctionnelles

2020-05-28T14:43:35Z

Dornel : /* Sources et annexes */

== Présentation du problème ==

Lorsque l'on souhaite coder une structure de données dans un langage impératif comme C, Ada, Pascal ou Perl, il est très facile de trouver des livres sur le sujet. En revanche, si l'on souhaite utiliser le paradigme fonctionnel, que ce soit Lisp, Haskell ou OCaml, le choix est nettement plus restreint.

<q>Un programmeur peut choisir le paradigme de son langage, pourvu que ce soit impératif.</q>
- Chris Okasaki, pastiche d'une citation de Ford, ''Purely functional data structures'', 1996

Ainsi, Chris Okasaki a voulu explorer à travers sa thèse (et son livre la développant) diverses structures de données adaptées au paradigme fonctionnel.

Mais avant d'étudier les solutions proposées, il est nécessaire de définir quelques contraintes et termes.

=== Problèmes liés au paradigme fonctionnel ===

[[Fichier:Schema_1.png|300px|thumb|right|Différence entre structure éphémère et persistante illustrée par une liste chaînée dont on supprime le dernier élément.]]

Le paradigme fonctionnel est principalement basé sur l'évaluation de fonctions et d'expressions mathématiques, et tout ce qui ne peut être représenté ainsi n'est pas admis.

De ce fait naît le premier obstacle à la création de structures de données purement fonctionnelles : Le changement d'état étant banni, '''on ne peut pas réaliser d'assignation de variable'''.
 
Là où les langages impératifs font fréquemment usage de l'assignation de variable et de la modification de valeurs, il faut trouver d'autres solutions en fonctionnel pour contourner ce problème. Okasaki compare le lien entre l'assignation et le programmeur à celui entre les couteaux et un chef cuisinier. Dans les deux cas, un mauvais usage peut être dangereux et destructeur, mais extrêmement efficace avec un usage intelligent.

Une deuxième difficulté liée à l'absence d'assignation provient du fait que l'on attende davantage une '''persistance''' d'une structure de données fonctionnelle. En effet, là où il est admis que l'actualisation d'une structure impérative détruit l'ancienne version pour ne garder que la nouvelle (ce genre de structure de données est dit "éphémère"), on s'attend que l'actualisation d'une structure fonctionnelle donne l'accès aux deux versions (d'où la notion de structure "persistante"). Il est possible d'avoir des structures persistantes en impératif, mais on associera ici la notion d'éphémérité au paradigme impératif tandis que la persistance sera liée au paradigme fonctionnel.

Enfin, un troisième problème lié au paradigme fonctionnel relève du temps d'exécution, le fonctionnel étant généralement considéré comme étant '''moins efficace que l'impératif'''. Ainsi, il est nécessaire de trouver des structures de données qui soient aussi efficaces que celles utilisées en impératif.

=== Évaluation stricte et évaluation paresseuse ===

On appelle '''évaluation stricte''' une technique d'implémentation d'un programme récursif où les arguments sont évalués avant le corps de la fonction.
L'évaluation est dite '''paresseuse''' quand les arguments sont évalués lors du premier appel par la fonction avant d'être mis en cache pour un autre usage ultérieur.

Chaque type d'évaluation a ses avantages et inconvénients. Une évaluation stricte permettra de gérer le cas "Pire scénario" tandis qu'une évaluation paresseuse sera plus à l'aise avec les structures dites amorties.

Un avantage indéniable qu'a cependant l'évaluation stricte sur l'évaluation paresseuse est que l'on peut calculer le temps d'évaluation plus facilement (notion de [https://fr.wikipedia.org/wiki/Comparaison_asymptotique comparaison asymptotique], notamment du grand O de Landau).

=== Vocabulaire ===

Avant de commencer à étudier les solutions proposées par Okasaki, il est nécessaire de poser quelques termes de vocabulaire.

; Abstraction
: Un type de données abstrait, autrement dit un type et un ensemble de fonctions agissant sur ce type.

Exemple : Le premier bloc de code de liste chaînée (voir ci-dessous) est une abstraction de cette structure, avec le type élément et les divers constructeurs, destructeurs et méthodes sur cette structure.

; Implémentation
: Une réalisation concrète d'une abstraction. Il est important de noter qu'une implémentation ne correspond pas nécessairement à du code, un modèle concret suffit.

Exemple : Posons qu'un élément est soit null, soit le couplet liant un entier et un pointeur vers l'élément suivant. Ceci correspond à l'implémentation de l'abstraction de la structure liste chaînée.

; Objet / Version
: Une instance d'un type de données, telle une variante spécifique de liste ou d'arbre.

Exemple : Soit une liste chaînée d'entiers. Il s'agit d'une version d'une liste chaînée.

; Identité persistante
: Une identité unique et invariante malgré les changements. Par exemple, "la pile" en parlant de toutes ses différentes versions correspond à son identité persistante.

Maintenant que nous avons posé des bases solides, nous pouvons commencer à étudier les diverses structures de données proposées par Okasaki. Le langage utilisé est OCaml.

== Solutions proposées ==

En se basant sur la présentation, on peut faire remarquer deux points :
* Afin d'avoir des structures persistantes, il est nécessaire de travailler sur une copie de l'argument plutôt que l'argument lui-même
* À l'exception de la liste chaînée, toutes les structures évoquées ci-après ne fonctionnent qu'avec des types ordonnés.

<pre lang="OCaml">module type ORDERED = sig
type t
val eq: t -> t -> bool
val lt: t -> t -> bool
val leq: t -> t -> bool
end;;</pre>
''Code permettant d'implémenter un type polymorphe ordonné. On admet que ce type est défini pour toutes les structures ci-dessous.''

=== Liste chaînée ===

Cette structure basique sert d'introduction à la persistance, ce qui nous permet de présenter les différences d'implémentation de cette structure dans un paradigme impératif comparé à un paradigme fonctionnel.

''Abstraction de la structure liste chaînée''
<pre lang="OCaml">module type LIST = sig
type 'a t

(* Constructeurs *)
val nil: 'a t
val cons: 'a -> 'a t -> 'a t
val is_empty: 'a t -> bool

(* Destructeurs *)
val head: 'a t -> 'a
val tail: 'a t -> 'a t

(* Méthodes *)
val append: 'a t -> 'a t -> 'a t
val update: 'a t -> int -> 'a -> 'a t
val suffixes: 'a t -> 'a t t
end;;</pre>

Ici, nous allons observer les méthodes, à savoir append, update et suffixes.

* '''append - Concaténation de deux listes'''

Soient xs et ys deux listes et zs la concaténation de xs et ys.

En impératif, une structure de données efficace basée sur la liste chaînée peut comporter deux pointeurs globaux, un sur le premier élément et un sur le dernier. Ainsi, pour concaténer xs et ys, il suffit de modifier le dernier élément de xs pour qu'il pointe vers le premier de ys. L'avantage, c'est que le temps d'exécution est d'ordre O(1), donc constant. Cependant, en obtenant zs, on garde ys mais on perd xs.

En fonctionnel, zs est une reconstruction de xs à laquelle on accole ys. Si on note n la longueur de xs, la fonction a un temps d'exécution d'ordre O(n), mais on garde toujours xs et ys.

<pre lang="OCaml">let rec append = fun xs ys ->
if is_empty xs
then ys
else cons (head xs) (append (tail xs) ys)</pre>

L'idée est de "déconstruire" xs afin de se retrouver avec une liste vide. Au fur et à mesure, on reconstruit xs élément par élément avant d'y accoler ys lorsque cet objectif est atteint.

* '''update - Mise à jour d'un nœud'''

On cherche à changer la valeur x au rang i dans xs par la valeur y.

En impératif, on cherche le nœud concerné et on change la valeur. Le temps d'exécution est d'ordre O(n) dans le pire des cas, mais le xs original est perdu.

En fonctionnel, la méthode de recherche est la même. Le temps d'exécution est toujours d'ordre O(n) dans le pire des cas, mais on récupère ys, reconstruction altérée de xs tout en conservant l'original.

<pre lang="OCaml">let rec update = fun xs i y ->
if is_empty xs
then raise Index_out_of_bounds (* Si la liste est vide, il n'y a rien à remplacer ! *)
else if i = 0
then cons y (tail xs)
else cons (head xs) (update (tail xs) (i - 1) y)</pre>

Comme pour append, on déconstruit puis reconstruit xs, sauf que l'on a un compteur qui est décrémenté de 1 par élément reconstruit. S'il atteint 0, la valeur de l'élément actuel est replacé par y. Si on reconstruit xs dans son intégralité (donc qu'il ne reste que la liste vide) avant que le compteur ait atteint 0, on lève une exception.

* '''suffixes - Afficher tous les suffixes d'une liste par ordre décroissant de taille'''

Par exemple, la liste [1, 2, 3, 4] doit retourner [[1, 2, 3, 4], [2, 3, 4], [3, 4], [4], []].

Le temps d'exécution de cette fonction est d'ordre O(n).

<pre lang="OCaml">let rec suffixes = fun xs ->
if is_empty xs
then nil
else cons xs (suffixes (tail xs))</pre>

Ici, on utilise le fait que la fonction tail renvoie toute la liste sauf la tête. Ainsi, on peut accoler tous les suffixes un par un, jusqu'à s'arrêter avec la liste vide.

=== Arbre de recherche binaire ===

Il est possible d'utiliser des méthodes de recherche plus complexes lorsque l'on utilise une structure où un élément pointe vers plus qu'un seul autre élément. Prenons par exemple les arbres de recherche binaires.

Un arbre de recherche binaire est un arbre dont les valeurs stockées dans chaque élément sont rangées par ''ordre symétrique'', c'est-à-dire que pour un nœud donné, sa valeur est supérieure à toutes les valeurs stockées dans le sous-arbre de gauche et inférieure à celles dans le sous-arbre de droite.

Dans le code ci-dessous, BalancedTree est un foncteur, autrement dit une fonction qui prendre comme paramètre un module O de type ORDERED.

<pre lang="OCaml">module BalancedTree(O: ORDERED)= struct
type elem = O.t

type tree = E | T of (tree * elem * tree)

let rec member...

let rec insert...
end;;</pre>

Penchons-nous sur les méthodes member et insert.

* '''member - Vérifie si une valeur est présente dans l'arbre'''

En reprenant notre type ordonné, on remarque que l'on ne dispose que de 3 fonctions de test, à savoir l'égalité (O.eq), l'infériorité stricte (O.lt) et l'infériorité (O.leq).

Pour construire cette fonction, on serait tenté d'écrire :

<pre lang="OCaml">let rec member = fun xs x ->
match xs with
| E -> false
| T(e1, y, e2) -> if (O.lt x y)
then member e1 x
else if (O.lt y x)
then member e2 x
else true</pre>

On regarde si la valeur du nœud est strictement plus grande que celle recherchée. Si oui, on continue à chercher à gauche. Sinon, on regarde si la valeur du nœud est strictement inférieure à celle recherchée. Si c'est le cas, on poursuit la recherche à gauche. Sinon, il y a égalité et la valeur est bien membre de l'arbre. Si on atteint une feuille sans avoir eu d'égalité, alors la valeur n'appartient pas à l'arbre.

En effet, le pire scénario, ici la branche qui tourne toujours à droite jusqu'au bout de l'arbre, exigerait '''2n comparaisons''' (avec n la profondeur de l'arbre) pour retourner un résultat, étant donné qu'il effectue deux comparaisons par nœud.

<pre lang="OCaml">let rec member =
let rec member_aux = fun xs aux x ->
match xs with
| E -> O.eq aux x
| T(e1, y, e2) -> if (O.lt x y)
then member_aux e1 aux x
else member_aux e2 y x
in fun xs x ->
match xs with
| E -> false
| T(e1, y, e2) -> if(O.lt x y)
then member e1 x
else member_aux e2 y x</pre>

Ici, on fait appel à une fonction auxiliaire itérative stockant une valeur intermédiaire. Cette fonction fait appel au fait que si x n'est pas strictement inférieur à y, alors x est supérieur ''ou égal'' à y. Ainsi, on parcourt la branche correspondante comme précédemment, mais on garde ce candidat potentiel jusqu'à ce que l'on atteigne une feuille. Ainsi, on ne réalise dans le pire des cas que '''n + 1 comparaisons''', une par niveau de profondeur et une supplémentaire pour vérifier l'égalité une fois arrivé aux feuilles.

* '''insert - Insère une valeur dans l'arbre'''

Pour l'insertion, on procède similairement pour atteindre la feuille correspondante.

<pre lang="OCaml">let rec insert = fun xs x ->
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) as s -> if (O.lt x y)
then T((insert e1 x), y, e2)
else if (O.lt y x)
then T(e1, y, (insert e2 x))
else s</pre>

Comme précédemment, on regarde s'il faut continuer à gauche ou à droite en reconstruisant une copie de l'arbre au fur et à mesure. Cependant, si la valeur à ajouter est déjà présente dans l'arbre, on recopie également ce nœud, ce qui fait que '''la branche de recherche est testée de la racine à la feuille''' sans aucun changement à appliquer. En levant une exception si l'on trouve la valeur à ajouter dans l'arbre, on optimise le temps d'exécution en ne faisant pas de copie inutile.

<pre lang="OCaml">exception Already_there

let rec insert = fun xs x ->
try begin
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) -> if(O.lt x y)
then T((insert e1 x), y, e2)
else if (O.lt y x)
then T(e1, y, (insert e2 x))
else raise Already_there
end with Already_there -> xs</pre>

Ainsi, on s'arrête si l'on trouve la valeur à ajouter et l'on retourne une copie de l'arbre tel quel.
Et comme pour member, il est possible d'optimiser le nombre de comparaisons, ce qui donne au final une fonction qui ressemble à ceci :

<pre lang="OCaml">let rec insert =
let rec insert_aux = fun xs aux x ->
match xs with
| E -> if (O.eq aux x)
then raise Already_there
else T(E, x, E)
| T(e1, y, e2) -> if (O.lt x y)
then T((insert_aux e1 aux x), y, e2)
else T(e1, y, (insert_aux e2 y x))
in fun xs x ->
try begin
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) -> if (O.lt x y)
then T((insert e1 x), y, e2)
else T(e1, y, (insert_aux e2 y x))
end with Already_there -> xs</pre>

On se retrouve donc avec une fonction d'insertion qui '''ne copie pas inutilement''' et qui ne réalise pas plus que '''n + 1 comparaisons'''.

=== Tas gaucher ===

[[Fichier:Schema_2.png|150px|thumb|right|Exemple de tas gaucher et illustration de la notion de rang.]]

Un tas est une version d'arbre particulière. En effet, elle se caractérise par le fait que la valeur de chaque nœud ne peut être plus grand que n'importe laquelle de ses enfants. Cette caractéristique fait que l'élément le plus petit se trouve toujours à la racine.

Un tas est dit gaucher si le rang de n'importe quel enfant de gauche est supérieur ou égal à celui de l'enfant de droit qui lui est associé. On appelle rang d'un nœud la longueur de sa ''colonne vertébrale droite'', c'est-à-dire le chemin le plus à droite qui va de ce nœud à une feuille. Une conséquence simple de cette propriété est que la colonne vertébrale droite d'un nœud constitue le chemin le plus court de ce nœud à une feuille.

Soit r le rang de la racine d'un tas gaucher de taille n. On peut en déduire que chaque nœud de profondeur inférieure ou égale à r-1 a exactement deux enfants, car sinon r aurait une valeur plus faible ou la propriété gauchère ne serait pas respectée. Ainsi, on peut affirmer que la taille d'un tas est donc d'au moins 2r - 1. De ce fait, on peut en déduire que le rang de la racine vaut au plus log(n + 1). Par conséquent, la colonne vertébrale droite d'un tas gaucher de taille n comporte au plus ⌊log(n + 1)⌋ éléments.

''Code de la structure tas gaucher''
<pre lang="OCaml">module LeftistHeap (O: ORDERED) = struct
type elem = O.t

type heap = Nil | Cons of (int * heap * elem * heap)

let rank = fun h ->
match h with
| Nil -> 0
| Cons(r, _, _, _) -> r

let makeH...

let merge...

let insert...

exception EmptyHeap

let findMin...

let deleteMin...
end;;</pre>

Ici, nous allons étudier les fonctions merge, insert, findMin et deleteMin.

* '''merge - Fusionne deux tas'''

Afin de simplifier l'opération, on remarque que la colonne vertébrale droite d'un tas gaucher est ordonnée. On en déduit que le concept clé est de fusionner les colonnes vertébrales des deux tas comme on fusionnerait deux listes triées avant d'échanger les enfants le long de la branche afin de restaurer la propriété gauchère.

Comme il a été démontré précédemment que la longueur de la colonne vertébrale est au plus logarithmique, on peut en déduire que merge a un temps d'exécution d'ordre O(log n).

<pre lang="OCaml">let makeH = fun v a b ->
if rank a >= rank b
then Cons(rank b + 1, a, v, b)
else Cons(rank a + 1, b, v, a)

let rec merge = fun x y ->
match x, y with
| Nil, _ -> y
| _, Nil -> x
| Cons(_, e11, v1, e12), Cons(_, e21, v2, e22) -> if (O.leq v1 v2)
then makeH v1 e11 (merge e12 y)
else makeH v2 e21 (merge x e22)</pre>

Ici, on fait appel à une fonction intermédiaire : makeH.

Cette fonction compare le rang des deux tas et échange les enfants si besoin afin de respecter la propriété gauchère.

Ensuite, concernant merge en elle-même, on compare les valeurs des deux racines et on fait appel à makeH pour combiner et potentiellement échanger les enfants.

* '''insert - Insère une valeur dans l'arbre'''

Une fois merge défini, il suffit d'établir que l'on veut fusionner le tas avec un tas d'une seule valeur. Et puisque le temps d'exécution de merge est d'ordre O(log n), il en va de même pour insert.

<pre lang="OCaml">let insert = fun v h -> (merge (Cons(1, Nil, v, Nil)) h)</pre>

* '''findMin - Récupère le minimum'''

Comme le minimum est par définition à la racine, le temps d'exécution de findMin est d'ordre O(1), donc constant.

<pre lang="OCaml">let findMin = fun h ->
match h with
| Nil -> raise EmptyHeap
| Cons(_, _, v, _) -> v</pre>

* '''deleteMin - Supprime le minimum'''

Similairement, le minimum étant à la racine, on peut établir que le supprimer revient à fusionner ses enfants. De plus, merge ayant un temps d'exécution d'ordre O(log n), celui de deleteMin est le même.

<pre lang="OCaml">let deleteMin = fun h ->
match h with
| Nil -> raise EmptyHeap
| Cons(_, a, _, b) -> merge a b</pre>

=== Tas binomial ===

[[File:Schema_3.png|500px|thumb|right|Représentation des arbres binaires de rangs 0 à 3]]

Les tas binomiaux sont des tas composés d'un type plus primitif appelé arbre binomial. Les arbres binomiaux sont défini inductivement comme suit :

* Un arbre binomial de rang 0 est un singleton de nœud ;
* Un arbre binomial de rang r est formé en liant deux arbres binomiaux de rang r-1 tel qu'un des arbres devient l'enfant le plus à gauche de l'autre.

De cette définition, on comprend qu'un arbre binomial de rang r contient exactement 2r nœuds.

Il existe une deuxième définition équivalente des arbres binomiaux :

* Un arbre binomial de rang r est un nœud ayant r enfants t1 à tr où chaque enfant ti est un arbre binomial de rang r - i.

Dans le code ci-dessous, on représente un nœud dans un arbre binomial comme un élément avec une liste de ses enfants. Par commodité, on note aussi le rang de chaque nœud.

De plus, un tas binomial étant une liste d'arbres binomiaux ne pouvant comporter qu'un seul arbre d'un rang donné et un arbre binomial de rang r comportant 2r éléments, on constate alors que les arbres d'un tas binomial de taille n correspondent à la représentation binaire de n.

Par exemple, la représentation binaire de 13 est 1101, donc un tas binomial de taille 13 contient un arbre de rang 0, un de rang 2 et un de rang 3 (de taille respective 1, 4 et 8).
De plus, comme la représentation binaire de n contient au plus ⌊log(n + 1)⌋ bits à 1, un tas binomial de taille n contient au plus ⌊log(n + 1)⌋ arbres.

<pre lang="OCaml">module BinomialHeap (O: ORDERED) = struct
type elem = O.t

type tree = Node of (int * elem * tree list)
type heap = tree list

exception EmptyHeap

let rank (Node(r, _, _)) = r
let root (Node(_, x, _)) = x

let link = ...

let rec insTree...

let insert = ...

let rec merge...

let rec removeMinTree...

let findMin = ...

let deleteMin = ...
end;;</pre>

Les fonctions que nous allons étudier ici sont link, insert, merge, findMin et deleteMin.

* '''link - Lie deux arbres de même rang pour en construire un de rang supérieur'''

Les arbres étant triés en respectant la propriété du tas, il suffit de comparer les racines pour voir lequel reste au sommet en les liant, l'autre étant ajouté à la liste des enfants.

<pre lang="OCaml">let link = fun (Node(r, x1, c1) as t1) (Node(_, x2, c2) as t2) ->
if (O.leq x1 x2)
then Node(r + 1, x1, t2 :: c1)
else Node(r + 1, x2, t1 :: c2)</pre>

* '''insert - Insertion d'un élément'''

Les fonctions insert et merge sont toutes deux vaguement comparables à l'addition de deux nombres binaires. Pour insérer un nouvel élément, on crée un singleton d'arbre (donc de rang 0) puis on parcourt tous les arbres du tas par ordre croissant de rang jusqu'à trouver un rang manquant en liant les arbres de rang égal en chemin. On peut comparer le lien à une retenue arithmétique.

<pre lang="OCaml">let rec insTree = fun t ls ->
match ls with
| [] -> [t]
| t' :: ts' as ts -> if rank t < rank t'
then t :: ts
else insTree (link t t') ts'

let insert = fun x ts -> insTree (Node(0, x, [])) ts</pre>

Le pire scénario étant dans un tas de taille n = 2k - 1 qui nécessiterait k liens, donnant un temps d'exécution d'ordre O(log n).

* '''merge - Fusion de deux tas'''

Comme précédemment, merge parcourt la liste d'arbres de chaque tas par ordre croissant de rang en liant les arbres de rang égal.

<pre lang="OCaml">let rec merge = fun ts1 ts2 ->
match ts1, ts2 with
| _, [] -> ts1
| [], _ -> ts2
| t1 :: ts1', t2 :: ts2' -> if rank t1 < rank t2
then t1 :: (merge ts1' ts2)
else if rank t2 < rank t1
then t2 :: (merge ts1 ts2')
else insTree (link t1 t2) (merge ts1' ts2')</pre>

* '''findMin et deleteMin - Trouve et supprime le minimum respectivement'''

Ces deux fonctions ont besoin de la même fonction auxiliaire, à savoir removeMinTree, qui trouve l'arbre avec la plus petite valeur et l'extrait de la liste, retournant à la fois l'arbre et le reste de la liste.

<pre lang="OCaml">let rec removeMinTree = fun ls ->
match ls with
| [] -> raise EmptyHeap
| [t] -> (t, [])
| t :: ts -> let (t', ts') = removeMinTree ts in
if (O.leq (root t) (root t'))
then (t, ts)
else (t', t :: ts')

let findMin = fun ts -> let (t, _) = removeMinTree ts in root t

let deleteMin = fun ts -> let (Node(_, x, ts1), ts2) = removeMinTree ts in merge (rev ts1) ts2</pre>

À partir de là, findMin retourne juste la racine de l'arbre. Cependant, deleteMin est plus complexe. En effet, après avoir retiré la racine de l'arbre, il faut remettre la liste d'enfants de l'arbre avec le reste de la liste des arbres. Cela dit, bien que chaque liste d'enfants est une collection d'arbres binomiaux de rang unique, ceux-ci sont triés ''par ordre décroissant de rang et non par ordre croissant''. Afin de convertir cette liste en tas binomial valide, on l'inverse à l'aide de la fonction rev avant de la fusionner avec les arbres restants.

=== Arbre rouge / noir ===

== Évolution du domaine de recherche ==

Après s'être penché en détail sur la thèse d'Okasaki, voici quelques articles plus récents en rapport avec le sujet permettant d'élargir la question.

* '''Manufacturing Datatypes''' par Ralf Hinze, publié en 1999 et édité par Okasaki traitant d'une structure générale pour construire des structures de données purement fonctionnelles permettant de satisfaire des contraintes de taille ou de forme, notamment pour l'implémentation de matrices et de certains types d'arbres.

* '''Scrap your boilerplate: a practical design pattern for generic programming''' de Ralf Lämmel et Simon Peyton-Jones proposant un modèle de métastructure, c'est-à-dire (une structure permettant de générer du code ?), afin de remédier à l'usage de code passe-partout, autrement dit du code répété à plusieurs reprises avec très peu de modifications.

* '''Finger trees: a simple general-purpose data structure''' de Ralf Hinze et Ross Paterson introduisant une nouvelle structure : les arbres pointés 2-3 permettant d'accéder aux feuilles dans un laps de temps amorti constant. Cette structure peut servir de base pour plusieurs autres structures de données.

* '''Parallel Concurrent ML''' de John Reppy, Claudio V. Russo et Yingqi Xiao présentant le langage fonctionnel concurrent CML (pour Concurrent ML), c'est-à-dire que le programme peut utiliser plusieurs processus simultanément, réduisant le temps d'exécution.

== Sources et annexes ==

'''Sources'''

* [https://www.cs.cmu.edu/~rwh/theses/okasaki.pdf Thèse d'Okasaki]

* [https://doc.lagout.org/programmation/Functional%20Programming/Chris_Okasaki-Purely_Functional_Data_Structures-Cambridge_University_Press%281998%29.pdf Purely functional data structures, Chris Okasaki]

* [https://fr.wikipedia.org/wiki/Programmation_fonctionnelle Programmation fonctionnelle (Wikipédia FR)]

* [https://en.wikipedia.org/wiki/Leftist_tree Tas gaucher (Wikipédia EN)]

'''Annexes'''

* [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.39.5334&rep=rep1&type=pdf#page=7 Manufacturing Datatypes]

* [https://www.researchgate.net/publication/221282345_Scrap_Your_Boilerplate_A_Practical_Design_Pattern_for_Generic_Programming Scrap your boilerplate: a practical design pattern for generic programming]

* [https://archive.alvb.in/msc/03_infoafp/papers/2012-12-18_WerkCollege_FingerTreesRalfHinze.pdf Finger trees: a simple general-purpose data structure]

* [https://www.microsoft.com/en-us/research/wp-content/uploads/2009/09/Parallel-Concurrent-ML.pdf Parallel Concurrent ML]

Structures de données purement fonctionnelles

2020-05-28T14:41:44Z

Dornel : /* Évolution du domaine de recherche */

== Présentation du problème ==

Lorsque l'on souhaite coder une structure de données dans un langage impératif comme C, Ada, Pascal ou Perl, il est très facile de trouver des livres sur le sujet. En revanche, si l'on souhaite utiliser le paradigme fonctionnel, que ce soit Lisp, Haskell ou OCaml, le choix est nettement plus restreint.

<q>Un programmeur peut choisir le paradigme de son langage, pourvu que ce soit impératif.</q>
- Chris Okasaki, pastiche d'une citation de Ford, ''Purely functional data structures'', 1996

Ainsi, Chris Okasaki a voulu explorer à travers sa thèse (et son livre la développant) diverses structures de données adaptées au paradigme fonctionnel.

Mais avant d'étudier les solutions proposées, il est nécessaire de définir quelques contraintes et termes.

=== Problèmes liés au paradigme fonctionnel ===

[[Fichier:Schema_1.png|300px|thumb|right|Différence entre structure éphémère et persistante illustrée par une liste chaînée dont on supprime le dernier élément.]]

Le paradigme fonctionnel est principalement basé sur l'évaluation de fonctions et d'expressions mathématiques, et tout ce qui ne peut être représenté ainsi n'est pas admis.

De ce fait naît le premier obstacle à la création de structures de données purement fonctionnelles : Le changement d'état étant banni, '''on ne peut pas réaliser d'assignation de variable'''.
 
Là où les langages impératifs font fréquemment usage de l'assignation de variable et de la modification de valeurs, il faut trouver d'autres solutions en fonctionnel pour contourner ce problème. Okasaki compare le lien entre l'assignation et le programmeur à celui entre les couteaux et un chef cuisinier. Dans les deux cas, un mauvais usage peut être dangereux et destructeur, mais extrêmement efficace avec un usage intelligent.

Une deuxième difficulté liée à l'absence d'assignation provient du fait que l'on attende davantage une '''persistance''' d'une structure de données fonctionnelle. En effet, là où il est admis que l'actualisation d'une structure impérative détruit l'ancienne version pour ne garder que la nouvelle (ce genre de structure de données est dit "éphémère"), on s'attend que l'actualisation d'une structure fonctionnelle donne l'accès aux deux versions (d'où la notion de structure "persistante"). Il est possible d'avoir des structures persistantes en impératif, mais on associera ici la notion d'éphémérité au paradigme impératif tandis que la persistance sera liée au paradigme fonctionnel.

Enfin, un troisième problème lié au paradigme fonctionnel relève du temps d'exécution, le fonctionnel étant généralement considéré comme étant '''moins efficace que l'impératif'''. Ainsi, il est nécessaire de trouver des structures de données qui soient aussi efficaces que celles utilisées en impératif.

=== Évaluation stricte et évaluation paresseuse ===

On appelle '''évaluation stricte''' une technique d'implémentation d'un programme récursif où les arguments sont évalués avant le corps de la fonction.
L'évaluation est dite '''paresseuse''' quand les arguments sont évalués lors du premier appel par la fonction avant d'être mis en cache pour un autre usage ultérieur.

Chaque type d'évaluation a ses avantages et inconvénients. Une évaluation stricte permettra de gérer le cas "Pire scénario" tandis qu'une évaluation paresseuse sera plus à l'aise avec les structures dites amorties.

Un avantage indéniable qu'a cependant l'évaluation stricte sur l'évaluation paresseuse est que l'on peut calculer le temps d'évaluation plus facilement (notion de [https://fr.wikipedia.org/wiki/Comparaison_asymptotique comparaison asymptotique], notamment du grand O de Landau).

=== Vocabulaire ===

Avant de commencer à étudier les solutions proposées par Okasaki, il est nécessaire de poser quelques termes de vocabulaire.

; Abstraction
: Un type de données abstrait, autrement dit un type et un ensemble de fonctions agissant sur ce type.

Exemple : Le premier bloc de code de liste chaînée (voir ci-dessous) est une abstraction de cette structure, avec le type élément et les divers constructeurs, destructeurs et méthodes sur cette structure.

; Implémentation
: Une réalisation concrète d'une abstraction. Il est important de noter qu'une implémentation ne correspond pas nécessairement à du code, un modèle concret suffit.

Exemple : Posons qu'un élément est soit null, soit le couplet liant un entier et un pointeur vers l'élément suivant. Ceci correspond à l'implémentation de l'abstraction de la structure liste chaînée.

; Objet / Version
: Une instance d'un type de données, telle une variante spécifique de liste ou d'arbre.

Exemple : Soit une liste chaînée d'entiers. Il s'agit d'une version d'une liste chaînée.

; Identité persistante
: Une identité unique et invariante malgré les changements. Par exemple, "la pile" en parlant de toutes ses différentes versions correspond à son identité persistante.

Maintenant que nous avons posé des bases solides, nous pouvons commencer à étudier les diverses structures de données proposées par Okasaki. Le langage utilisé est OCaml.

== Solutions proposées ==

En se basant sur la présentation, on peut faire remarquer deux points :
* Afin d'avoir des structures persistantes, il est nécessaire de travailler sur une copie de l'argument plutôt que l'argument lui-même
* À l'exception de la liste chaînée, toutes les structures évoquées ci-après ne fonctionnent qu'avec des types ordonnés.

<pre lang="OCaml">module type ORDERED = sig
type t
val eq: t -> t -> bool
val lt: t -> t -> bool
val leq: t -> t -> bool
end;;</pre>
''Code permettant d'implémenter un type polymorphe ordonné. On admet que ce type est défini pour toutes les structures ci-dessous.''

=== Liste chaînée ===

Cette structure basique sert d'introduction à la persistance, ce qui nous permet de présenter les différences d'implémentation de cette structure dans un paradigme impératif comparé à un paradigme fonctionnel.

''Abstraction de la structure liste chaînée''
<pre lang="OCaml">module type LIST = sig
type 'a t

(* Constructeurs *)
val nil: 'a t
val cons: 'a -> 'a t -> 'a t
val is_empty: 'a t -> bool

(* Destructeurs *)
val head: 'a t -> 'a
val tail: 'a t -> 'a t

(* Méthodes *)
val append: 'a t -> 'a t -> 'a t
val update: 'a t -> int -> 'a -> 'a t
val suffixes: 'a t -> 'a t t
end;;</pre>

Ici, nous allons observer les méthodes, à savoir append, update et suffixes.

* '''append - Concaténation de deux listes'''

Soient xs et ys deux listes et zs la concaténation de xs et ys.

En impératif, une structure de données efficace basée sur la liste chaînée peut comporter deux pointeurs globaux, un sur le premier élément et un sur le dernier. Ainsi, pour concaténer xs et ys, il suffit de modifier le dernier élément de xs pour qu'il pointe vers le premier de ys. L'avantage, c'est que le temps d'exécution est d'ordre O(1), donc constant. Cependant, en obtenant zs, on garde ys mais on perd xs.

En fonctionnel, zs est une reconstruction de xs à laquelle on accole ys. Si on note n la longueur de xs, la fonction a un temps d'exécution d'ordre O(n), mais on garde toujours xs et ys.

<pre lang="OCaml">let rec append = fun xs ys ->
if is_empty xs
then ys
else cons (head xs) (append (tail xs) ys)</pre>

L'idée est de "déconstruire" xs afin de se retrouver avec une liste vide. Au fur et à mesure, on reconstruit xs élément par élément avant d'y accoler ys lorsque cet objectif est atteint.

* '''update - Mise à jour d'un nœud'''

On cherche à changer la valeur x au rang i dans xs par la valeur y.

En impératif, on cherche le nœud concerné et on change la valeur. Le temps d'exécution est d'ordre O(n) dans le pire des cas, mais le xs original est perdu.

En fonctionnel, la méthode de recherche est la même. Le temps d'exécution est toujours d'ordre O(n) dans le pire des cas, mais on récupère ys, reconstruction altérée de xs tout en conservant l'original.

<pre lang="OCaml">let rec update = fun xs i y ->
if is_empty xs
then raise Index_out_of_bounds (* Si la liste est vide, il n'y a rien à remplacer ! *)
else if i = 0
then cons y (tail xs)
else cons (head xs) (update (tail xs) (i - 1) y)</pre>

Comme pour append, on déconstruit puis reconstruit xs, sauf que l'on a un compteur qui est décrémenté de 1 par élément reconstruit. S'il atteint 0, la valeur de l'élément actuel est replacé par y. Si on reconstruit xs dans son intégralité (donc qu'il ne reste que la liste vide) avant que le compteur ait atteint 0, on lève une exception.

* '''suffixes - Afficher tous les suffixes d'une liste par ordre décroissant de taille'''

Par exemple, la liste [1, 2, 3, 4] doit retourner [[1, 2, 3, 4], [2, 3, 4], [3, 4], [4], []].

Le temps d'exécution de cette fonction est d'ordre O(n).

<pre lang="OCaml">let rec suffixes = fun xs ->
if is_empty xs
then nil
else cons xs (suffixes (tail xs))</pre>

Ici, on utilise le fait que la fonction tail renvoie toute la liste sauf la tête. Ainsi, on peut accoler tous les suffixes un par un, jusqu'à s'arrêter avec la liste vide.

=== Arbre de recherche binaire ===

Il est possible d'utiliser des méthodes de recherche plus complexes lorsque l'on utilise une structure où un élément pointe vers plus qu'un seul autre élément. Prenons par exemple les arbres de recherche binaires.

Un arbre de recherche binaire est un arbre dont les valeurs stockées dans chaque élément sont rangées par ''ordre symétrique'', c'est-à-dire que pour un nœud donné, sa valeur est supérieure à toutes les valeurs stockées dans le sous-arbre de gauche et inférieure à celles dans le sous-arbre de droite.

Dans le code ci-dessous, BalancedTree est un foncteur, autrement dit une fonction qui prendre comme paramètre un module O de type ORDERED.

<pre lang="OCaml">module BalancedTree(O: ORDERED)= struct
type elem = O.t

type tree = E | T of (tree * elem * tree)

let rec member...

let rec insert...
end;;</pre>

Penchons-nous sur les méthodes member et insert.

* '''member - Vérifie si une valeur est présente dans l'arbre'''

En reprenant notre type ordonné, on remarque que l'on ne dispose que de 3 fonctions de test, à savoir l'égalité (O.eq), l'infériorité stricte (O.lt) et l'infériorité (O.leq).

Pour construire cette fonction, on serait tenté d'écrire :

<pre lang="OCaml">let rec member = fun xs x ->
match xs with
| E -> false
| T(e1, y, e2) -> if (O.lt x y)
then member e1 x
else if (O.lt y x)
then member e2 x
else true</pre>

On regarde si la valeur du nœud est strictement plus grande que celle recherchée. Si oui, on continue à chercher à gauche. Sinon, on regarde si la valeur du nœud est strictement inférieure à celle recherchée. Si c'est le cas, on poursuit la recherche à gauche. Sinon, il y a égalité et la valeur est bien membre de l'arbre. Si on atteint une feuille sans avoir eu d'égalité, alors la valeur n'appartient pas à l'arbre.

En effet, le pire scénario, ici la branche qui tourne toujours à droite jusqu'au bout de l'arbre, exigerait '''2n comparaisons''' (avec n la profondeur de l'arbre) pour retourner un résultat, étant donné qu'il effectue deux comparaisons par nœud.

<pre lang="OCaml">let rec member =
let rec member_aux = fun xs aux x ->
match xs with
| E -> O.eq aux x
| T(e1, y, e2) -> if (O.lt x y)
then member_aux e1 aux x
else member_aux e2 y x
in fun xs x ->
match xs with
| E -> false
| T(e1, y, e2) -> if(O.lt x y)
then member e1 x
else member_aux e2 y x</pre>

Ici, on fait appel à une fonction auxiliaire itérative stockant une valeur intermédiaire. Cette fonction fait appel au fait que si x n'est pas strictement inférieur à y, alors x est supérieur ''ou égal'' à y. Ainsi, on parcourt la branche correspondante comme précédemment, mais on garde ce candidat potentiel jusqu'à ce que l'on atteigne une feuille. Ainsi, on ne réalise dans le pire des cas que '''n + 1 comparaisons''', une par niveau de profondeur et une supplémentaire pour vérifier l'égalité une fois arrivé aux feuilles.

* '''insert - Insère une valeur dans l'arbre'''

Pour l'insertion, on procède similairement pour atteindre la feuille correspondante.

<pre lang="OCaml">let rec insert = fun xs x ->
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) as s -> if (O.lt x y)
then T((insert e1 x), y, e2)
else if (O.lt y x)
then T(e1, y, (insert e2 x))
else s</pre>

Comme précédemment, on regarde s'il faut continuer à gauche ou à droite en reconstruisant une copie de l'arbre au fur et à mesure. Cependant, si la valeur à ajouter est déjà présente dans l'arbre, on recopie également ce nœud, ce qui fait que '''la branche de recherche est testée de la racine à la feuille''' sans aucun changement à appliquer. En levant une exception si l'on trouve la valeur à ajouter dans l'arbre, on optimise le temps d'exécution en ne faisant pas de copie inutile.

<pre lang="OCaml">exception Already_there

let rec insert = fun xs x ->
try begin
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) -> if(O.lt x y)
then T((insert e1 x), y, e2)
else if (O.lt y x)
then T(e1, y, (insert e2 x))
else raise Already_there
end with Already_there -> xs</pre>

Ainsi, on s'arrête si l'on trouve la valeur à ajouter et l'on retourne une copie de l'arbre tel quel.
Et comme pour member, il est possible d'optimiser le nombre de comparaisons, ce qui donne au final une fonction qui ressemble à ceci :

<pre lang="OCaml">let rec insert =
let rec insert_aux = fun xs aux x ->
match xs with
| E -> if (O.eq aux x)
then raise Already_there
else T(E, x, E)
| T(e1, y, e2) -> if (O.lt x y)
then T((insert_aux e1 aux x), y, e2)
else T(e1, y, (insert_aux e2 y x))
in fun xs x ->
try begin
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) -> if (O.lt x y)
then T((insert e1 x), y, e2)
else T(e1, y, (insert_aux e2 y x))
end with Already_there -> xs</pre>

On se retrouve donc avec une fonction d'insertion qui '''ne copie pas inutilement''' et qui ne réalise pas plus que '''n + 1 comparaisons'''.

=== Tas gaucher ===

[[Fichier:Schema_2.png|150px|thumb|right|Exemple de tas gaucher et illustration de la notion de rang.]]

Un tas est une version d'arbre particulière. En effet, elle se caractérise par le fait que la valeur de chaque nœud ne peut être plus grand que n'importe laquelle de ses enfants. Cette caractéristique fait que l'élément le plus petit se trouve toujours à la racine.

Un tas est dit gaucher si le rang de n'importe quel enfant de gauche est supérieur ou égal à celui de l'enfant de droit qui lui est associé. On appelle rang d'un nœud la longueur de sa ''colonne vertébrale droite'', c'est-à-dire le chemin le plus à droite qui va de ce nœud à une feuille. Une conséquence simple de cette propriété est que la colonne vertébrale droite d'un nœud constitue le chemin le plus court de ce nœud à une feuille.

Soit r le rang de la racine d'un tas gaucher de taille n. On peut en déduire que chaque nœud de profondeur inférieure ou égale à r-1 a exactement deux enfants, car sinon r aurait une valeur plus faible ou la propriété gauchère ne serait pas respectée. Ainsi, on peut affirmer que la taille d'un tas est donc d'au moins 2r - 1. De ce fait, on peut en déduire que le rang de la racine vaut au plus log(n + 1). Par conséquent, la colonne vertébrale droite d'un tas gaucher de taille n comporte au plus ⌊log(n + 1)⌋ éléments.

''Code de la structure tas gaucher''
<pre lang="OCaml">module LeftistHeap (O: ORDERED) = struct
type elem = O.t

type heap = Nil | Cons of (int * heap * elem * heap)

let rank = fun h ->
match h with
| Nil -> 0
| Cons(r, _, _, _) -> r

let makeH...

let merge...

let insert...

exception EmptyHeap

let findMin...

let deleteMin...
end;;</pre>

Ici, nous allons étudier les fonctions merge, insert, findMin et deleteMin.

* '''merge - Fusionne deux tas'''

Afin de simplifier l'opération, on remarque que la colonne vertébrale droite d'un tas gaucher est ordonnée. On en déduit que le concept clé est de fusionner les colonnes vertébrales des deux tas comme on fusionnerait deux listes triées avant d'échanger les enfants le long de la branche afin de restaurer la propriété gauchère.

Comme il a été démontré précédemment que la longueur de la colonne vertébrale est au plus logarithmique, on peut en déduire que merge a un temps d'exécution d'ordre O(log n).

<pre lang="OCaml">let makeH = fun v a b ->
if rank a >= rank b
then Cons(rank b + 1, a, v, b)
else Cons(rank a + 1, b, v, a)

let rec merge = fun x y ->
match x, y with
| Nil, _ -> y
| _, Nil -> x
| Cons(_, e11, v1, e12), Cons(_, e21, v2, e22) -> if (O.leq v1 v2)
then makeH v1 e11 (merge e12 y)
else makeH v2 e21 (merge x e22)</pre>

Ici, on fait appel à une fonction intermédiaire : makeH.

Cette fonction compare le rang des deux tas et échange les enfants si besoin afin de respecter la propriété gauchère.

Ensuite, concernant merge en elle-même, on compare les valeurs des deux racines et on fait appel à makeH pour combiner et potentiellement échanger les enfants.

* '''insert - Insère une valeur dans l'arbre'''

Une fois merge défini, il suffit d'établir que l'on veut fusionner le tas avec un tas d'une seule valeur. Et puisque le temps d'exécution de merge est d'ordre O(log n), il en va de même pour insert.

<pre lang="OCaml">let insert = fun v h -> (merge (Cons(1, Nil, v, Nil)) h)</pre>

* '''findMin - Récupère le minimum'''

Comme le minimum est par définition à la racine, le temps d'exécution de findMin est d'ordre O(1), donc constant.

<pre lang="OCaml">let findMin = fun h ->
match h with
| Nil -> raise EmptyHeap
| Cons(_, _, v, _) -> v</pre>

* '''deleteMin - Supprime le minimum'''

Similairement, le minimum étant à la racine, on peut établir que le supprimer revient à fusionner ses enfants. De plus, merge ayant un temps d'exécution d'ordre O(log n), celui de deleteMin est le même.

<pre lang="OCaml">let deleteMin = fun h ->
match h with
| Nil -> raise EmptyHeap
| Cons(_, a, _, b) -> merge a b</pre>

=== Tas binomial ===

[[File:Schema_3.png|500px|thumb|right|Représentation des arbres binaires de rangs 0 à 3]]

Les tas binomiaux sont des tas composés d'un type plus primitif appelé arbre binomial. Les arbres binomiaux sont défini inductivement comme suit :

* Un arbre binomial de rang 0 est un singleton de nœud ;
* Un arbre binomial de rang r est formé en liant deux arbres binomiaux de rang r-1 tel qu'un des arbres devient l'enfant le plus à gauche de l'autre.

De cette définition, on comprend qu'un arbre binomial de rang r contient exactement 2r nœuds.

Il existe une deuxième définition équivalente des arbres binomiaux :

* Un arbre binomial de rang r est un nœud ayant r enfants t1 à tr où chaque enfant ti est un arbre binomial de rang r - i.

Dans le code ci-dessous, on représente un nœud dans un arbre binomial comme un élément avec une liste de ses enfants. Par commodité, on note aussi le rang de chaque nœud.

De plus, un tas binomial étant une liste d'arbres binomiaux ne pouvant comporter qu'un seul arbre d'un rang donné et un arbre binomial de rang r comportant 2r éléments, on constate alors que les arbres d'un tas binomial de taille n correspondent à la représentation binaire de n.

Par exemple, la représentation binaire de 13 est 1101, donc un tas binomial de taille 13 contient un arbre de rang 0, un de rang 2 et un de rang 3 (de taille respective 1, 4 et 8).
De plus, comme la représentation binaire de n contient au plus ⌊log(n + 1)⌋ bits à 1, un tas binomial de taille n contient au plus ⌊log(n + 1)⌋ arbres.

<pre lang="OCaml">module BinomialHeap (O: ORDERED) = struct
type elem = O.t

type tree = Node of (int * elem * tree list)
type heap = tree list

exception EmptyHeap

let rank (Node(r, _, _)) = r
let root (Node(_, x, _)) = x

let link = ...

let rec insTree...

let insert = ...

let rec merge...

let rec removeMinTree...

let findMin = ...

let deleteMin = ...
end;;</pre>

Les fonctions que nous allons étudier ici sont link, insert, merge, findMin et deleteMin.

* '''link - Lie deux arbres de même rang pour en construire un de rang supérieur'''

Les arbres étant triés en respectant la propriété du tas, il suffit de comparer les racines pour voir lequel reste au sommet en les liant, l'autre étant ajouté à la liste des enfants.

<pre lang="OCaml">let link = fun (Node(r, x1, c1) as t1) (Node(_, x2, c2) as t2) ->
if (O.leq x1 x2)
then Node(r + 1, x1, t2 :: c1)
else Node(r + 1, x2, t1 :: c2)</pre>

* '''insert - Insertion d'un élément'''

Les fonctions insert et merge sont toutes deux vaguement comparables à l'addition de deux nombres binaires. Pour insérer un nouvel élément, on crée un singleton d'arbre (donc de rang 0) puis on parcourt tous les arbres du tas par ordre croissant de rang jusqu'à trouver un rang manquant en liant les arbres de rang égal en chemin. On peut comparer le lien à une retenue arithmétique.

<pre lang="OCaml">let rec insTree = fun t ls ->
match ls with
| [] -> [t]
| t' :: ts' as ts -> if rank t < rank t'
then t :: ts
else insTree (link t t') ts'

let insert = fun x ts -> insTree (Node(0, x, [])) ts</pre>

Le pire scénario étant dans un tas de taille n = 2k - 1 qui nécessiterait k liens, donnant un temps d'exécution d'ordre O(log n).

* '''merge - Fusion de deux tas'''

Comme précédemment, merge parcourt la liste d'arbres de chaque tas par ordre croissant de rang en liant les arbres de rang égal.

<pre lang="OCaml">let rec merge = fun ts1 ts2 ->
match ts1, ts2 with
| _, [] -> ts1
| [], _ -> ts2
| t1 :: ts1', t2 :: ts2' -> if rank t1 < rank t2
then t1 :: (merge ts1' ts2)
else if rank t2 < rank t1
then t2 :: (merge ts1 ts2')
else insTree (link t1 t2) (merge ts1' ts2')</pre>

* '''findMin et deleteMin - Trouve et supprime le minimum respectivement'''

Ces deux fonctions ont besoin de la même fonction auxiliaire, à savoir removeMinTree, qui trouve l'arbre avec la plus petite valeur et l'extrait de la liste, retournant à la fois l'arbre et le reste de la liste.

<pre lang="OCaml">let rec removeMinTree = fun ls ->
match ls with
| [] -> raise EmptyHeap
| [t] -> (t, [])
| t :: ts -> let (t', ts') = removeMinTree ts in
if (O.leq (root t) (root t'))
then (t, ts)
else (t', t :: ts')

let findMin = fun ts -> let (t, _) = removeMinTree ts in root t

let deleteMin = fun ts -> let (Node(_, x, ts1), ts2) = removeMinTree ts in merge (rev ts1) ts2</pre>

À partir de là, findMin retourne juste la racine de l'arbre. Cependant, deleteMin est plus complexe. En effet, après avoir retiré la racine de l'arbre, il faut remettre la liste d'enfants de l'arbre avec le reste de la liste des arbres. Cela dit, bien que chaque liste d'enfants est une collection d'arbres binomiaux de rang unique, ceux-ci sont triés ''par ordre décroissant de rang et non par ordre croissant''. Afin de convertir cette liste en tas binomial valide, on l'inverse à l'aide de la fonction rev avant de la fusionner avec les arbres restants.

=== Arbre rouge / noir ===

== Évolution du domaine de recherche ==

Après s'être penché en détail sur la thèse d'Okasaki, voici quelques articles plus récents en rapport avec le sujet permettant d'élargir la question.

* '''Manufacturing Datatypes''' par Ralf Hinze, publié en 1999 et édité par Okasaki traitant d'une structure générale pour construire des structures de données purement fonctionnelles permettant de satisfaire des contraintes de taille ou de forme, notamment pour l'implémentation de matrices et de certains types d'arbres.

* '''Scrap your boilerplate: a practical design pattern for generic programming''' de Ralf Lämmel et Simon Peyton-Jones proposant un modèle de métastructure, c'est-à-dire (une structure permettant de générer du code ?), afin de remédier à l'usage de code passe-partout, autrement dit du code répété à plusieurs reprises avec très peu de modifications.

* '''Finger trees: a simple general-purpose data structure''' de Ralf Hinze et Ross Paterson introduisant une nouvelle structure : les arbres pointés 2-3 permettant d'accéder aux feuilles dans un laps de temps amorti constant. Cette structure peut servir de base pour plusieurs autres structures de données.

* '''Parallel Concurrent ML''' de John Reppy, Claudio V. Russo et Yingqi Xiao présentant le langage fonctionnel concurrent CML (pour Concurrent ML), c'est-à-dire que le programme peut utiliser plusieurs processus simultanément, réduisant le temps d'exécution.

== Sources et annexes ==

'''Sources'''

* [https://www.cs.cmu.edu/~rwh/theses/okasaki.pdf Thèse d'Okasaki]

* [https://doc.lagout.org/programmation/Functional%20Programming/Chris_Okasaki-Purely_Functional_Data_Structures-Cambridge_University_Press%281998%29.pdf Purely functional data structures, Chris Okasaki]

* [https://fr.wikipedia.org/wiki/Programmation_fonctionnelle Programmation fonctionnelle (Wikipédia FR)]

* [https://en.wikipedia.org/wiki/Leftist_tree Tas gaucher (Wikipédia EN)]

'''Annexes'''

Structures de données purement fonctionnelles

2020-05-28T12:25:21Z

Dornel : /* Tas binomial */

== Présentation du problème ==

Lorsque l'on souhaite coder une structure de données dans un langage impératif comme C, Ada, Pascal ou Perl, il est très facile de trouver des livres sur le sujet. En revanche, si l'on souhaite utiliser le paradigme fonctionnel, que ce soit Lisp, Haskell ou OCaml, le choix est nettement plus restreint.

<q>Un programmeur peut choisir le paradigme de son langage, pourvu que ce soit impératif.</q>
- Chris Okasaki, pastiche d'une citation de Ford, ''Purely functional data structures'', 1996

Ainsi, Chris Okasaki a voulu explorer à travers sa thèse (et son livre la développant) diverses structures de données adaptées au paradigme fonctionnel.

Mais avant d'étudier les solutions proposées, il est nécessaire de définir quelques contraintes et termes.

=== Problèmes liés au paradigme fonctionnel ===

[[Fichier:Schema_1.png|300px|thumb|right|Différence entre structure éphémère et persistante illustrée par une liste chaînée dont on supprime le dernier élément.]]

Le paradigme fonctionnel est principalement basé sur l'évaluation de fonctions et d'expressions mathématiques, et tout ce qui ne peut être représenté ainsi n'est pas admis.

De ce fait naît le premier obstacle à la création de structures de données purement fonctionnelles : Le changement d'état étant banni, '''on ne peut pas réaliser d'assignation de variable'''.
 
Là où les langages impératifs font fréquemment usage de l'assignation de variable et de la modification de valeurs, il faut trouver d'autres solutions en fonctionnel pour contourner ce problème. Okasaki compare le lien entre l'assignation et le programmeur à celui entre les couteaux et un chef cuisinier. Dans les deux cas, un mauvais usage peut être dangereux et destructeur, mais extrêmement efficace avec un usage intelligent.

Une deuxième difficulté liée à l'absence d'assignation provient du fait que l'on attende davantage une '''persistance''' d'une structure de données fonctionnelle. En effet, là où il est admis que l'actualisation d'une structure impérative détruit l'ancienne version pour ne garder que la nouvelle (ce genre de structure de données est dit "éphémère"), on s'attend que l'actualisation d'une structure fonctionnelle donne l'accès aux deux versions (d'où la notion de structure "persistante"). Il est possible d'avoir des structures persistantes en impératif, mais on associera ici la notion d'éphémérité au paradigme impératif tandis que la persistance sera liée au paradigme fonctionnel.

Enfin, un troisième problème lié au paradigme fonctionnel relève du temps d'exécution, le fonctionnel étant généralement considéré comme étant '''moins efficace que l'impératif'''. Ainsi, il est nécessaire de trouver des structures de données qui soient aussi efficaces que celles utilisées en impératif.

=== Évaluation stricte et évaluation paresseuse ===

On appelle '''évaluation stricte''' une technique d'implémentation d'un programme récursif où les arguments sont évalués avant le corps de la fonction.
L'évaluation est dite '''paresseuse''' quand les arguments sont évalués lors du premier appel par la fonction avant d'être mis en cache pour un autre usage ultérieur.

Chaque type d'évaluation a ses avantages et inconvénients. Une évaluation stricte permettra de gérer le cas "Pire scénario" tandis qu'une évaluation paresseuse sera plus à l'aise avec les structures dites amorties.

Un avantage indéniable qu'a cependant l'évaluation stricte sur l'évaluation paresseuse est que l'on peut calculer le temps d'évaluation plus facilement (notion de [https://fr.wikipedia.org/wiki/Comparaison_asymptotique comparaison asymptotique], notamment du grand O de Landau).

=== Vocabulaire ===

Avant de commencer à étudier les solutions proposées par Okasaki, il est nécessaire de poser quelques termes de vocabulaire.

; Abstraction
: Un type de données abstrait, autrement dit un type et un ensemble de fonctions agissant sur ce type.

Exemple : Le premier bloc de code de liste chaînée (voir ci-dessous) est une abstraction de cette structure, avec le type élément et les divers constructeurs, destructeurs et méthodes sur cette structure.

; Implémentation
: Une réalisation concrète d'une abstraction. Il est important de noter qu'une implémentation ne correspond pas nécessairement à du code, un modèle concret suffit.

Exemple : Posons qu'un élément est soit null, soit le couplet liant un entier et un pointeur vers l'élément suivant. Ceci correspond à l'implémentation de l'abstraction de la structure liste chaînée.

; Objet / Version
: Une instance d'un type de données, telle une variante spécifique de liste ou d'arbre.

Exemple : Soit une liste chaînée d'entiers. Il s'agit d'une version d'une liste chaînée.

; Identité persistante
: Une identité unique et invariante malgré les changements. Par exemple, "la pile" en parlant de toutes ses différentes versions correspond à son identité persistante.

Maintenant que nous avons posé des bases solides, nous pouvons commencer à étudier les diverses structures de données proposées par Okasaki. Le langage utilisé est OCaml.

== Solutions proposées ==

En se basant sur la présentation, on peut faire remarquer deux points :
* Afin d'avoir des structures persistantes, il est nécessaire de travailler sur une copie de l'argument plutôt que l'argument lui-même
* À l'exception de la liste chaînée, toutes les structures évoquées ci-après ne fonctionnent qu'avec des types ordonnés.

<pre lang="OCaml">module type ORDERED = sig
type t
val eq: t -> t -> bool
val lt: t -> t -> bool
val leq: t -> t -> bool
end;;</pre>
''Code permettant d'implémenter un type polymorphe ordonné. On admet que ce type est défini pour toutes les structures ci-dessous.''

=== Liste chaînée ===

Cette structure basique sert d'introduction à la persistance, ce qui nous permet de présenter les différences d'implémentation de cette structure dans un paradigme impératif comparé à un paradigme fonctionnel.

''Abstraction de la structure liste chaînée''
<pre lang="OCaml">module type LIST = sig
type 'a t

(* Constructeurs *)
val nil: 'a t
val cons: 'a -> 'a t -> 'a t
val is_empty: 'a t -> bool

(* Destructeurs *)
val head: 'a t -> 'a
val tail: 'a t -> 'a t

(* Méthodes *)
val append: 'a t -> 'a t -> 'a t
val update: 'a t -> int -> 'a -> 'a t
val suffixes: 'a t -> 'a t t
end;;</pre>

Ici, nous allons observer les méthodes, à savoir append, update et suffixes.

* '''append - Concaténation de deux listes'''

Soient xs et ys deux listes et zs la concaténation de xs et ys.

En impératif, une structure de données efficace basée sur la liste chaînée peut comporter deux pointeurs globaux, un sur le premier élément et un sur le dernier. Ainsi, pour concaténer xs et ys, il suffit de modifier le dernier élément de xs pour qu'il pointe vers le premier de ys. L'avantage, c'est que le temps d'exécution est d'ordre O(1), donc constant. Cependant, en obtenant zs, on garde ys mais on perd xs.

En fonctionnel, zs est une reconstruction de xs à laquelle on accole ys. Si on note n la longueur de xs, la fonction a un temps d'exécution d'ordre O(n), mais on garde toujours xs et ys.

<pre lang="OCaml">let rec append = fun xs ys ->
if is_empty xs
then ys
else cons (head xs) (append (tail xs) ys)</pre>

L'idée est de "déconstruire" xs afin de se retrouver avec une liste vide. Au fur et à mesure, on reconstruit xs élément par élément avant d'y accoler ys lorsque cet objectif est atteint.

* '''update - Mise à jour d'un nœud'''

On cherche à changer la valeur x au rang i dans xs par la valeur y.

En impératif, on cherche le nœud concerné et on change la valeur. Le temps d'exécution est d'ordre O(n) dans le pire des cas, mais le xs original est perdu.

En fonctionnel, la méthode de recherche est la même. Le temps d'exécution est toujours d'ordre O(n) dans le pire des cas, mais on récupère ys, reconstruction altérée de xs tout en conservant l'original.

<pre lang="OCaml">let rec update = fun xs i y ->
if is_empty xs
then raise Index_out_of_bounds (* Si la liste est vide, il n'y a rien à remplacer ! *)
else if i = 0
then cons y (tail xs)
else cons (head xs) (update (tail xs) (i - 1) y)</pre>

Comme pour append, on déconstruit puis reconstruit xs, sauf que l'on a un compteur qui est décrémenté de 1 par élément reconstruit. S'il atteint 0, la valeur de l'élément actuel est replacé par y. Si on reconstruit xs dans son intégralité (donc qu'il ne reste que la liste vide) avant que le compteur ait atteint 0, on lève une exception.

* '''suffixes - Afficher tous les suffixes d'une liste par ordre décroissant de taille'''

Par exemple, la liste [1, 2, 3, 4] doit retourner [[1, 2, 3, 4], [2, 3, 4], [3, 4], [4], []].

Le temps d'exécution de cette fonction est d'ordre O(n).

<pre lang="OCaml">let rec suffixes = fun xs ->
if is_empty xs
then nil
else cons xs (suffixes (tail xs))</pre>

Ici, on utilise le fait que la fonction tail renvoie toute la liste sauf la tête. Ainsi, on peut accoler tous les suffixes un par un, jusqu'à s'arrêter avec la liste vide.

=== Arbre de recherche binaire ===

Il est possible d'utiliser des méthodes de recherche plus complexes lorsque l'on utilise une structure où un élément pointe vers plus qu'un seul autre élément. Prenons par exemple les arbres de recherche binaires.

Un arbre de recherche binaire est un arbre dont les valeurs stockées dans chaque élément sont rangées par ''ordre symétrique'', c'est-à-dire que pour un nœud donné, sa valeur est supérieure à toutes les valeurs stockées dans le sous-arbre de gauche et inférieure à celles dans le sous-arbre de droite.

Dans le code ci-dessous, BalancedTree est un foncteur, autrement dit une fonction qui prendre comme paramètre un module O de type ORDERED.

<pre lang="OCaml">module BalancedTree(O: ORDERED)= struct
type elem = O.t

type tree = E | T of (tree * elem * tree)

let rec member...

let rec insert...
end;;</pre>

Penchons-nous sur les méthodes member et insert.

* '''member - Vérifie si une valeur est présente dans l'arbre'''

En reprenant notre type ordonné, on remarque que l'on ne dispose que de 3 fonctions de test, à savoir l'égalité (O.eq), l'infériorité stricte (O.lt) et l'infériorité (O.leq).

Pour construire cette fonction, on serait tenté d'écrire :

<pre lang="OCaml">let rec member = fun xs x ->
match xs with
| E -> false
| T(e1, y, e2) -> if (O.lt x y)
then member e1 x
else if (O.lt y x)
then member e2 x
else true</pre>

On regarde si la valeur du nœud est strictement plus grande que celle recherchée. Si oui, on continue à chercher à gauche. Sinon, on regarde si la valeur du nœud est strictement inférieure à celle recherchée. Si c'est le cas, on poursuit la recherche à gauche. Sinon, il y a égalité et la valeur est bien membre de l'arbre. Si on atteint une feuille sans avoir eu d'égalité, alors la valeur n'appartient pas à l'arbre.

En effet, le pire scénario, ici la branche qui tourne toujours à droite jusqu'au bout de l'arbre, exigerait '''2n comparaisons''' (avec n la profondeur de l'arbre) pour retourner un résultat, étant donné qu'il effectue deux comparaisons par nœud.

<pre lang="OCaml">let rec member =
let rec member_aux = fun xs aux x ->
match xs with
| E -> O.eq aux x
| T(e1, y, e2) -> if (O.lt x y)
then member_aux e1 aux x
else member_aux e2 y x
in fun xs x ->
match xs with
| E -> false
| T(e1, y, e2) -> if(O.lt x y)
then member e1 x
else member_aux e2 y x</pre>

Ici, on fait appel à une fonction auxiliaire itérative stockant une valeur intermédiaire. Cette fonction fait appel au fait que si x n'est pas strictement inférieur à y, alors x est supérieur ''ou égal'' à y. Ainsi, on parcourt la branche correspondante comme précédemment, mais on garde ce candidat potentiel jusqu'à ce que l'on atteigne une feuille. Ainsi, on ne réalise dans le pire des cas que '''n + 1 comparaisons''', une par niveau de profondeur et une supplémentaire pour vérifier l'égalité une fois arrivé aux feuilles.

* '''insert - Insère une valeur dans l'arbre'''

Pour l'insertion, on procède similairement pour atteindre la feuille correspondante.

<pre lang="OCaml">let rec insert = fun xs x ->
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) as s -> if (O.lt x y)
then T((insert e1 x), y, e2)
else if (O.lt y x)
then T(e1, y, (insert e2 x))
else s</pre>

Comme précédemment, on regarde s'il faut continuer à gauche ou à droite en reconstruisant une copie de l'arbre au fur et à mesure. Cependant, si la valeur à ajouter est déjà présente dans l'arbre, on recopie également ce nœud, ce qui fait que '''la branche de recherche est testée de la racine à la feuille''' sans aucun changement à appliquer. En levant une exception si l'on trouve la valeur à ajouter dans l'arbre, on optimise le temps d'exécution en ne faisant pas de copie inutile.

<pre lang="OCaml">exception Already_there

let rec insert = fun xs x ->
try begin
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) -> if(O.lt x y)
then T((insert e1 x), y, e2)
else if (O.lt y x)
then T(e1, y, (insert e2 x))
else raise Already_there
end with Already_there -> xs</pre>

Ainsi, on s'arrête si l'on trouve la valeur à ajouter et l'on retourne une copie de l'arbre tel quel.
Et comme pour member, il est possible d'optimiser le nombre de comparaisons, ce qui donne au final une fonction qui ressemble à ceci :

<pre lang="OCaml">let rec insert =
let rec insert_aux = fun xs aux x ->
match xs with
| E -> if (O.eq aux x)
then raise Already_there
else T(E, x, E)
| T(e1, y, e2) -> if (O.lt x y)
then T((insert_aux e1 aux x), y, e2)
else T(e1, y, (insert_aux e2 y x))
in fun xs x ->
try begin
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) -> if (O.lt x y)
then T((insert e1 x), y, e2)
else T(e1, y, (insert_aux e2 y x))
end with Already_there -> xs</pre>

On se retrouve donc avec une fonction d'insertion qui '''ne copie pas inutilement''' et qui ne réalise pas plus que '''n + 1 comparaisons'''.

=== Tas gaucher ===

[[Fichier:Schema_2.png|150px|thumb|right|Exemple de tas gaucher et illustration de la notion de rang.]]

Un tas est une version d'arbre particulière. En effet, elle se caractérise par le fait que la valeur de chaque nœud ne peut être plus grand que n'importe laquelle de ses enfants. Cette caractéristique fait que l'élément le plus petit se trouve toujours à la racine.

Un tas est dit gaucher si le rang de n'importe quel enfant de gauche est supérieur ou égal à celui de l'enfant de droit qui lui est associé. On appelle rang d'un nœud la longueur de sa ''colonne vertébrale droite'', c'est-à-dire le chemin le plus à droite qui va de ce nœud à une feuille. Une conséquence simple de cette propriété est que la colonne vertébrale droite d'un nœud constitue le chemin le plus court de ce nœud à une feuille.

Soit r le rang de la racine d'un tas gaucher de taille n. On peut en déduire que chaque nœud de profondeur inférieure ou égale à r-1 a exactement deux enfants, car sinon r aurait une valeur plus faible ou la propriété gauchère ne serait pas respectée. Ainsi, on peut affirmer que la taille d'un tas est donc d'au moins 2r - 1. De ce fait, on peut en déduire que le rang de la racine vaut au plus log(n + 1). Par conséquent, la colonne vertébrale droite d'un tas gaucher de taille n comporte au plus ⌊log(n + 1)⌋ éléments.

''Code de la structure tas gaucher''
<pre lang="OCaml">module LeftistHeap (O: ORDERED) = struct
type elem = O.t

type heap = Nil | Cons of (int * heap * elem * heap)

let rank = fun h ->
match h with
| Nil -> 0
| Cons(r, _, _, _) -> r

let makeH...

let merge...

let insert...

exception EmptyHeap

let findMin...

let deleteMin...
end;;</pre>

Ici, nous allons étudier les fonctions merge, insert, findMin et deleteMin.

* '''merge - Fusionne deux tas'''

Afin de simplifier l'opération, on remarque que la colonne vertébrale droite d'un tas gaucher est ordonnée. On en déduit que le concept clé est de fusionner les colonnes vertébrales des deux tas comme on fusionnerait deux listes triées avant d'échanger les enfants le long de la branche afin de restaurer la propriété gauchère.

Comme il a été démontré précédemment que la longueur de la colonne vertébrale est au plus logarithmique, on peut en déduire que merge a un temps d'exécution d'ordre O(log n).

<pre lang="OCaml">let makeH = fun v a b ->
if rank a >= rank b
then Cons(rank b + 1, a, v, b)
else Cons(rank a + 1, b, v, a)

let rec merge = fun x y ->
match x, y with
| Nil, _ -> y
| _, Nil -> x
| Cons(_, e11, v1, e12), Cons(_, e21, v2, e22) -> if (O.leq v1 v2)
then makeH v1 e11 (merge e12 y)
else makeH v2 e21 (merge x e22)</pre>

Ici, on fait appel à une fonction intermédiaire : makeH.

Cette fonction compare le rang des deux tas et échange les enfants si besoin afin de respecter la propriété gauchère.

Ensuite, concernant merge en elle-même, on compare les valeurs des deux racines et on fait appel à makeH pour combiner et potentiellement échanger les enfants.

* '''insert - Insère une valeur dans l'arbre'''

Une fois merge défini, il suffit d'établir que l'on veut fusionner le tas avec un tas d'une seule valeur. Et puisque le temps d'exécution de merge est d'ordre O(log n), il en va de même pour insert.

<pre lang="OCaml">let insert = fun v h -> (merge (Cons(1, Nil, v, Nil)) h)</pre>

* '''findMin - Récupère le minimum'''

Comme le minimum est par définition à la racine, le temps d'exécution de findMin est d'ordre O(1), donc constant.

<pre lang="OCaml">let findMin = fun h ->
match h with
| Nil -> raise EmptyHeap
| Cons(_, _, v, _) -> v</pre>

* '''deleteMin - Supprime le minimum'''

Similairement, le minimum étant à la racine, on peut établir que le supprimer revient à fusionner ses enfants. De plus, merge ayant un temps d'exécution d'ordre O(log n), celui de deleteMin est le même.

<pre lang="OCaml">let deleteMin = fun h ->
match h with
| Nil -> raise EmptyHeap
| Cons(_, a, _, b) -> merge a b</pre>

=== Tas binomial ===

[[File:Schema_3.png|500px|thumb|right|Représentation des arbres binaires de rangs 0 à 3]]

Les tas binomiaux sont des tas composés d'un type plus primitif appelé arbre binomial. Les arbres binomiaux sont défini inductivement comme suit :

* Un arbre binomial de rang 0 est un singleton de nœud ;
* Un arbre binomial de rang r est formé en liant deux arbres binomiaux de rang r-1 tel qu'un des arbres devient l'enfant le plus à gauche de l'autre.

De cette définition, on comprend qu'un arbre binomial de rang r contient exactement 2r nœuds.

Il existe une deuxième définition équivalente des arbres binomiaux :

* Un arbre binomial de rang r est un nœud ayant r enfants t1 à tr où chaque enfant ti est un arbre binomial de rang r - i.

Dans le code ci-dessous, on représente un nœud dans un arbre binomial comme un élément avec une liste de ses enfants. Par commodité, on note aussi le rang de chaque nœud.

De plus, un tas binomial étant une liste d'arbres binomiaux ne pouvant comporter qu'un seul arbre d'un rang donné et un arbre binomial de rang r comportant 2r éléments, on constate alors que les arbres d'un tas binomial de taille n correspondent à la représentation binaire de n.

Par exemple, la représentation binaire de 13 est 1101, donc un tas binomial de taille 13 contient un arbre de rang 0, un de rang 2 et un de rang 3 (de taille respective 1, 4 et 8).
De plus, comme la représentation binaire de n contient au plus ⌊log(n + 1)⌋ bits à 1, un tas binomial de taille n contient au plus ⌊log(n + 1)⌋ arbres.

<pre lang="OCaml">module BinomialHeap (O: ORDERED) = struct
type elem = O.t

type tree = Node of (int * elem * tree list)
type heap = tree list

exception EmptyHeap

let rank (Node(r, _, _)) = r
let root (Node(_, x, _)) = x

let link = ...

let rec insTree...

let insert = ...

let rec merge...

let rec removeMinTree...

let findMin = ...

let deleteMin = ...
end;;</pre>

Les fonctions que nous allons étudier ici sont link, insert, merge, findMin et deleteMin.

* '''link - Lie deux arbres de même rang pour en construire un de rang supérieur'''

Les arbres étant triés en respectant la propriété du tas, il suffit de comparer les racines pour voir lequel reste au sommet en les liant, l'autre étant ajouté à la liste des enfants.

<pre lang="OCaml">let link = fun (Node(r, x1, c1) as t1) (Node(_, x2, c2) as t2) ->
if (O.leq x1 x2)
then Node(r + 1, x1, t2 :: c1)
else Node(r + 1, x2, t1 :: c2)</pre>

* '''insert - Insertion d'un élément'''

Les fonctions insert et merge sont toutes deux vaguement comparables à l'addition de deux nombres binaires. Pour insérer un nouvel élément, on crée un singleton d'arbre (donc de rang 0) puis on parcourt tous les arbres du tas par ordre croissant de rang jusqu'à trouver un rang manquant en liant les arbres de rang égal en chemin. On peut comparer le lien à une retenue arithmétique.

<pre lang="OCaml">let rec insTree = fun t ls ->
match ls with
| [] -> [t]
| t' :: ts' as ts -> if rank t < rank t'
then t :: ts
else insTree (link t t') ts'

let insert = fun x ts -> insTree (Node(0, x, [])) ts</pre>

Le pire scénario étant dans un tas de taille n = 2k - 1 qui nécessiterait k liens, donnant un temps d'exécution d'ordre O(log n).

* '''merge - Fusion de deux tas'''

Comme précédemment, merge parcourt la liste d'arbres de chaque tas par ordre croissant de rang en liant les arbres de rang égal.

<pre lang="OCaml">let rec merge = fun ts1 ts2 ->
match ts1, ts2 with
| _, [] -> ts1
| [], _ -> ts2
| t1 :: ts1', t2 :: ts2' -> if rank t1 < rank t2
then t1 :: (merge ts1' ts2)
else if rank t2 < rank t1
then t2 :: (merge ts1 ts2')
else insTree (link t1 t2) (merge ts1' ts2')</pre>

* '''findMin et deleteMin - Trouve et supprime le minimum respectivement'''

Ces deux fonctions ont besoin de la même fonction auxiliaire, à savoir removeMinTree, qui trouve l'arbre avec la plus petite valeur et l'extrait de la liste, retournant à la fois l'arbre et le reste de la liste.

<pre lang="OCaml">let rec removeMinTree = fun ls ->
match ls with
| [] -> raise EmptyHeap
| [t] -> (t, [])
| t :: ts -> let (t', ts') = removeMinTree ts in
if (O.leq (root t) (root t'))
then (t, ts)
else (t', t :: ts')

let findMin = fun ts -> let (t, _) = removeMinTree ts in root t

let deleteMin = fun ts -> let (Node(_, x, ts1), ts2) = removeMinTree ts in merge (rev ts1) ts2</pre>

À partir de là, findMin retourne juste la racine de l'arbre. Cependant, deleteMin est plus complexe. En effet, après avoir retiré la racine de l'arbre, il faut remettre la liste d'enfants de l'arbre avec le reste de la liste des arbres. Cela dit, bien que chaque liste d'enfants est une collection d'arbres binomiaux de rang unique, ceux-ci sont triés ''par ordre décroissant de rang et non par ordre croissant''. Afin de convertir cette liste en tas binomial valide, on l'inverse à l'aide de la fonction rev avant de la fusionner avec les arbres restants.

=== Arbre rouge / noir ===

== Évolution du domaine de recherche ==

== Sources et annexes ==

'''Sources'''

* [https://www.cs.cmu.edu/~rwh/theses/okasaki.pdf Thèse d'Okasaki]

* [https://doc.lagout.org/programmation/Functional%20Programming/Chris_Okasaki-Purely_Functional_Data_Structures-Cambridge_University_Press%281998%29.pdf Purely functional data structures, Chris Okasaki]

* [https://fr.wikipedia.org/wiki/Programmation_fonctionnelle Programmation fonctionnelle (Wikipédia FR)]

* [https://en.wikipedia.org/wiki/Leftist_tree Tas gaucher (Wikipédia EN)]

'''Annexes'''

Structures de données purement fonctionnelles

2020-05-28T12:22:57Z

Dornel : /* Tas binomial */

== Présentation du problème ==

Lorsque l'on souhaite coder une structure de données dans un langage impératif comme C, Ada, Pascal ou Perl, il est très facile de trouver des livres sur le sujet. En revanche, si l'on souhaite utiliser le paradigme fonctionnel, que ce soit Lisp, Haskell ou OCaml, le choix est nettement plus restreint.

<q>Un programmeur peut choisir le paradigme de son langage, pourvu que ce soit impératif.</q>
- Chris Okasaki, pastiche d'une citation de Ford, ''Purely functional data structures'', 1996

Ainsi, Chris Okasaki a voulu explorer à travers sa thèse (et son livre la développant) diverses structures de données adaptées au paradigme fonctionnel.

Mais avant d'étudier les solutions proposées, il est nécessaire de définir quelques contraintes et termes.

=== Problèmes liés au paradigme fonctionnel ===

[[Fichier:Schema_1.png|300px|thumb|right|Différence entre structure éphémère et persistante illustrée par une liste chaînée dont on supprime le dernier élément.]]

Le paradigme fonctionnel est principalement basé sur l'évaluation de fonctions et d'expressions mathématiques, et tout ce qui ne peut être représenté ainsi n'est pas admis.

De ce fait naît le premier obstacle à la création de structures de données purement fonctionnelles : Le changement d'état étant banni, '''on ne peut pas réaliser d'assignation de variable'''.
 
Là où les langages impératifs font fréquemment usage de l'assignation de variable et de la modification de valeurs, il faut trouver d'autres solutions en fonctionnel pour contourner ce problème. Okasaki compare le lien entre l'assignation et le programmeur à celui entre les couteaux et un chef cuisinier. Dans les deux cas, un mauvais usage peut être dangereux et destructeur, mais extrêmement efficace avec un usage intelligent.

Une deuxième difficulté liée à l'absence d'assignation provient du fait que l'on attende davantage une '''persistance''' d'une structure de données fonctionnelle. En effet, là où il est admis que l'actualisation d'une structure impérative détruit l'ancienne version pour ne garder que la nouvelle (ce genre de structure de données est dit "éphémère"), on s'attend que l'actualisation d'une structure fonctionnelle donne l'accès aux deux versions (d'où la notion de structure "persistante"). Il est possible d'avoir des structures persistantes en impératif, mais on associera ici la notion d'éphémérité au paradigme impératif tandis que la persistance sera liée au paradigme fonctionnel.

Enfin, un troisième problème lié au paradigme fonctionnel relève du temps d'exécution, le fonctionnel étant généralement considéré comme étant '''moins efficace que l'impératif'''. Ainsi, il est nécessaire de trouver des structures de données qui soient aussi efficaces que celles utilisées en impératif.

=== Évaluation stricte et évaluation paresseuse ===

On appelle '''évaluation stricte''' une technique d'implémentation d'un programme récursif où les arguments sont évalués avant le corps de la fonction.
L'évaluation est dite '''paresseuse''' quand les arguments sont évalués lors du premier appel par la fonction avant d'être mis en cache pour un autre usage ultérieur.

Chaque type d'évaluation a ses avantages et inconvénients. Une évaluation stricte permettra de gérer le cas "Pire scénario" tandis qu'une évaluation paresseuse sera plus à l'aise avec les structures dites amorties.

Un avantage indéniable qu'a cependant l'évaluation stricte sur l'évaluation paresseuse est que l'on peut calculer le temps d'évaluation plus facilement (notion de [https://fr.wikipedia.org/wiki/Comparaison_asymptotique comparaison asymptotique], notamment du grand O de Landau).

=== Vocabulaire ===

Avant de commencer à étudier les solutions proposées par Okasaki, il est nécessaire de poser quelques termes de vocabulaire.

; Abstraction
: Un type de données abstrait, autrement dit un type et un ensemble de fonctions agissant sur ce type.

Exemple : Le premier bloc de code de liste chaînée (voir ci-dessous) est une abstraction de cette structure, avec le type élément et les divers constructeurs, destructeurs et méthodes sur cette structure.

; Implémentation
: Une réalisation concrète d'une abstraction. Il est important de noter qu'une implémentation ne correspond pas nécessairement à du code, un modèle concret suffit.

Exemple : Posons qu'un élément est soit null, soit le couplet liant un entier et un pointeur vers l'élément suivant. Ceci correspond à l'implémentation de l'abstraction de la structure liste chaînée.

; Objet / Version
: Une instance d'un type de données, telle une variante spécifique de liste ou d'arbre.

Exemple : Soit une liste chaînée d'entiers. Il s'agit d'une version d'une liste chaînée.

; Identité persistante
: Une identité unique et invariante malgré les changements. Par exemple, "la pile" en parlant de toutes ses différentes versions correspond à son identité persistante.

Maintenant que nous avons posé des bases solides, nous pouvons commencer à étudier les diverses structures de données proposées par Okasaki. Le langage utilisé est OCaml.

== Solutions proposées ==

En se basant sur la présentation, on peut faire remarquer deux points :
* Afin d'avoir des structures persistantes, il est nécessaire de travailler sur une copie de l'argument plutôt que l'argument lui-même
* À l'exception de la liste chaînée, toutes les structures évoquées ci-après ne fonctionnent qu'avec des types ordonnés.

<pre lang="OCaml">module type ORDERED = sig
type t
val eq: t -> t -> bool
val lt: t -> t -> bool
val leq: t -> t -> bool
end;;</pre>
''Code permettant d'implémenter un type polymorphe ordonné. On admet que ce type est défini pour toutes les structures ci-dessous.''

=== Liste chaînée ===

Cette structure basique sert d'introduction à la persistance, ce qui nous permet de présenter les différences d'implémentation de cette structure dans un paradigme impératif comparé à un paradigme fonctionnel.

''Abstraction de la structure liste chaînée''
<pre lang="OCaml">module type LIST = sig
type 'a t

(* Constructeurs *)
val nil: 'a t
val cons: 'a -> 'a t -> 'a t
val is_empty: 'a t -> bool

(* Destructeurs *)
val head: 'a t -> 'a
val tail: 'a t -> 'a t

(* Méthodes *)
val append: 'a t -> 'a t -> 'a t
val update: 'a t -> int -> 'a -> 'a t
val suffixes: 'a t -> 'a t t
end;;</pre>

Ici, nous allons observer les méthodes, à savoir append, update et suffixes.

* '''append - Concaténation de deux listes'''

Soient xs et ys deux listes et zs la concaténation de xs et ys.

En impératif, une structure de données efficace basée sur la liste chaînée peut comporter deux pointeurs globaux, un sur le premier élément et un sur le dernier. Ainsi, pour concaténer xs et ys, il suffit de modifier le dernier élément de xs pour qu'il pointe vers le premier de ys. L'avantage, c'est que le temps d'exécution est d'ordre O(1), donc constant. Cependant, en obtenant zs, on garde ys mais on perd xs.

En fonctionnel, zs est une reconstruction de xs à laquelle on accole ys. Si on note n la longueur de xs, la fonction a un temps d'exécution d'ordre O(n), mais on garde toujours xs et ys.

<pre lang="OCaml">let rec append = fun xs ys ->
if is_empty xs
then ys
else cons (head xs) (append (tail xs) ys)</pre>

L'idée est de "déconstruire" xs afin de se retrouver avec une liste vide. Au fur et à mesure, on reconstruit xs élément par élément avant d'y accoler ys lorsque cet objectif est atteint.

* '''update - Mise à jour d'un nœud'''

On cherche à changer la valeur x au rang i dans xs par la valeur y.

En impératif, on cherche le nœud concerné et on change la valeur. Le temps d'exécution est d'ordre O(n) dans le pire des cas, mais le xs original est perdu.

En fonctionnel, la méthode de recherche est la même. Le temps d'exécution est toujours d'ordre O(n) dans le pire des cas, mais on récupère ys, reconstruction altérée de xs tout en conservant l'original.

<pre lang="OCaml">let rec update = fun xs i y ->
if is_empty xs
then raise Index_out_of_bounds (* Si la liste est vide, il n'y a rien à remplacer ! *)
else if i = 0
then cons y (tail xs)
else cons (head xs) (update (tail xs) (i - 1) y)</pre>

Comme pour append, on déconstruit puis reconstruit xs, sauf que l'on a un compteur qui est décrémenté de 1 par élément reconstruit. S'il atteint 0, la valeur de l'élément actuel est replacé par y. Si on reconstruit xs dans son intégralité (donc qu'il ne reste que la liste vide) avant que le compteur ait atteint 0, on lève une exception.

* '''suffixes - Afficher tous les suffixes d'une liste par ordre décroissant de taille'''

Par exemple, la liste [1, 2, 3, 4] doit retourner [[1, 2, 3, 4], [2, 3, 4], [3, 4], [4], []].

Le temps d'exécution de cette fonction est d'ordre O(n).

<pre lang="OCaml">let rec suffixes = fun xs ->
if is_empty xs
then nil
else cons xs (suffixes (tail xs))</pre>

Ici, on utilise le fait que la fonction tail renvoie toute la liste sauf la tête. Ainsi, on peut accoler tous les suffixes un par un, jusqu'à s'arrêter avec la liste vide.

=== Arbre de recherche binaire ===

Il est possible d'utiliser des méthodes de recherche plus complexes lorsque l'on utilise une structure où un élément pointe vers plus qu'un seul autre élément. Prenons par exemple les arbres de recherche binaires.

Un arbre de recherche binaire est un arbre dont les valeurs stockées dans chaque élément sont rangées par ''ordre symétrique'', c'est-à-dire que pour un nœud donné, sa valeur est supérieure à toutes les valeurs stockées dans le sous-arbre de gauche et inférieure à celles dans le sous-arbre de droite.

Dans le code ci-dessous, BalancedTree est un foncteur, autrement dit une fonction qui prendre comme paramètre un module O de type ORDERED.

<pre lang="OCaml">module BalancedTree(O: ORDERED)= struct
type elem = O.t

type tree = E | T of (tree * elem * tree)

let rec member...

let rec insert...
end;;</pre>

Penchons-nous sur les méthodes member et insert.

* '''member - Vérifie si une valeur est présente dans l'arbre'''

En reprenant notre type ordonné, on remarque que l'on ne dispose que de 3 fonctions de test, à savoir l'égalité (O.eq), l'infériorité stricte (O.lt) et l'infériorité (O.leq).

Pour construire cette fonction, on serait tenté d'écrire :

<pre lang="OCaml">let rec member = fun xs x ->
match xs with
| E -> false
| T(e1, y, e2) -> if (O.lt x y)
then member e1 x
else if (O.lt y x)
then member e2 x
else true</pre>

On regarde si la valeur du nœud est strictement plus grande que celle recherchée. Si oui, on continue à chercher à gauche. Sinon, on regarde si la valeur du nœud est strictement inférieure à celle recherchée. Si c'est le cas, on poursuit la recherche à gauche. Sinon, il y a égalité et la valeur est bien membre de l'arbre. Si on atteint une feuille sans avoir eu d'égalité, alors la valeur n'appartient pas à l'arbre.

En effet, le pire scénario, ici la branche qui tourne toujours à droite jusqu'au bout de l'arbre, exigerait '''2n comparaisons''' (avec n la profondeur de l'arbre) pour retourner un résultat, étant donné qu'il effectue deux comparaisons par nœud.

<pre lang="OCaml">let rec member =
let rec member_aux = fun xs aux x ->
match xs with
| E -> O.eq aux x
| T(e1, y, e2) -> if (O.lt x y)
then member_aux e1 aux x
else member_aux e2 y x
in fun xs x ->
match xs with
| E -> false
| T(e1, y, e2) -> if(O.lt x y)
then member e1 x
else member_aux e2 y x</pre>

Ici, on fait appel à une fonction auxiliaire itérative stockant une valeur intermédiaire. Cette fonction fait appel au fait que si x n'est pas strictement inférieur à y, alors x est supérieur ''ou égal'' à y. Ainsi, on parcourt la branche correspondante comme précédemment, mais on garde ce candidat potentiel jusqu'à ce que l'on atteigne une feuille. Ainsi, on ne réalise dans le pire des cas que '''n + 1 comparaisons''', une par niveau de profondeur et une supplémentaire pour vérifier l'égalité une fois arrivé aux feuilles.

* '''insert - Insère une valeur dans l'arbre'''

Pour l'insertion, on procède similairement pour atteindre la feuille correspondante.

<pre lang="OCaml">let rec insert = fun xs x ->
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) as s -> if (O.lt x y)
then T((insert e1 x), y, e2)
else if (O.lt y x)
then T(e1, y, (insert e2 x))
else s</pre>

Comme précédemment, on regarde s'il faut continuer à gauche ou à droite en reconstruisant une copie de l'arbre au fur et à mesure. Cependant, si la valeur à ajouter est déjà présente dans l'arbre, on recopie également ce nœud, ce qui fait que '''la branche de recherche est testée de la racine à la feuille''' sans aucun changement à appliquer. En levant une exception si l'on trouve la valeur à ajouter dans l'arbre, on optimise le temps d'exécution en ne faisant pas de copie inutile.

<pre lang="OCaml">exception Already_there

let rec insert = fun xs x ->
try begin
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) -> if(O.lt x y)
then T((insert e1 x), y, e2)
else if (O.lt y x)
then T(e1, y, (insert e2 x))
else raise Already_there
end with Already_there -> xs</pre>

Ainsi, on s'arrête si l'on trouve la valeur à ajouter et l'on retourne une copie de l'arbre tel quel.
Et comme pour member, il est possible d'optimiser le nombre de comparaisons, ce qui donne au final une fonction qui ressemble à ceci :

<pre lang="OCaml">let rec insert =
let rec insert_aux = fun xs aux x ->
match xs with
| E -> if (O.eq aux x)
then raise Already_there
else T(E, x, E)
| T(e1, y, e2) -> if (O.lt x y)
then T((insert_aux e1 aux x), y, e2)
else T(e1, y, (insert_aux e2 y x))
in fun xs x ->
try begin
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) -> if (O.lt x y)
then T((insert e1 x), y, e2)
else T(e1, y, (insert_aux e2 y x))
end with Already_there -> xs</pre>

On se retrouve donc avec une fonction d'insertion qui '''ne copie pas inutilement''' et qui ne réalise pas plus que '''n + 1 comparaisons'''.

=== Tas gaucher ===

[[Fichier:Schema_2.png|150px|thumb|right|Exemple de tas gaucher et illustration de la notion de rang.]]

Un tas est une version d'arbre particulière. En effet, elle se caractérise par le fait que la valeur de chaque nœud ne peut être plus grand que n'importe laquelle de ses enfants. Cette caractéristique fait que l'élément le plus petit se trouve toujours à la racine.

Un tas est dit gaucher si le rang de n'importe quel enfant de gauche est supérieur ou égal à celui de l'enfant de droit qui lui est associé. On appelle rang d'un nœud la longueur de sa ''colonne vertébrale droite'', c'est-à-dire le chemin le plus à droite qui va de ce nœud à une feuille. Une conséquence simple de cette propriété est que la colonne vertébrale droite d'un nœud constitue le chemin le plus court de ce nœud à une feuille.

Soit r le rang de la racine d'un tas gaucher de taille n. On peut en déduire que chaque nœud de profondeur inférieure ou égale à r-1 a exactement deux enfants, car sinon r aurait une valeur plus faible ou la propriété gauchère ne serait pas respectée. Ainsi, on peut affirmer que la taille d'un tas est donc d'au moins 2r - 1. De ce fait, on peut en déduire que le rang de la racine vaut au plus log(n + 1). Par conséquent, la colonne vertébrale droite d'un tas gaucher de taille n comporte au plus ⌊log(n + 1)⌋ éléments.

''Code de la structure tas gaucher''
<pre lang="OCaml">module LeftistHeap (O: ORDERED) = struct
type elem = O.t

type heap = Nil | Cons of (int * heap * elem * heap)

let rank = fun h ->
match h with
| Nil -> 0
| Cons(r, _, _, _) -> r

let makeH...

let merge...

let insert...

exception EmptyHeap

let findMin...

let deleteMin...
end;;</pre>

Ici, nous allons étudier les fonctions merge, insert, findMin et deleteMin.

* '''merge - Fusionne deux tas'''

Afin de simplifier l'opération, on remarque que la colonne vertébrale droite d'un tas gaucher est ordonnée. On en déduit que le concept clé est de fusionner les colonnes vertébrales des deux tas comme on fusionnerait deux listes triées avant d'échanger les enfants le long de la branche afin de restaurer la propriété gauchère.

Comme il a été démontré précédemment que la longueur de la colonne vertébrale est au plus logarithmique, on peut en déduire que merge a un temps d'exécution d'ordre O(log n).

<pre lang="OCaml">let makeH = fun v a b ->
if rank a >= rank b
then Cons(rank b + 1, a, v, b)
else Cons(rank a + 1, b, v, a)

let rec merge = fun x y ->
match x, y with
| Nil, _ -> y
| _, Nil -> x
| Cons(_, e11, v1, e12), Cons(_, e21, v2, e22) -> if (O.leq v1 v2)
then makeH v1 e11 (merge e12 y)
else makeH v2 e21 (merge x e22)</pre>

Ici, on fait appel à une fonction intermédiaire : makeH.

Cette fonction compare le rang des deux tas et échange les enfants si besoin afin de respecter la propriété gauchère.

Ensuite, concernant merge en elle-même, on compare les valeurs des deux racines et on fait appel à makeH pour combiner et potentiellement échanger les enfants.

* '''insert - Insère une valeur dans l'arbre'''

Une fois merge défini, il suffit d'établir que l'on veut fusionner le tas avec un tas d'une seule valeur. Et puisque le temps d'exécution de merge est d'ordre O(log n), il en va de même pour insert.

<pre lang="OCaml">let insert = fun v h -> (merge (Cons(1, Nil, v, Nil)) h)</pre>

* '''findMin - Récupère le minimum'''

Comme le minimum est par définition à la racine, le temps d'exécution de findMin est d'ordre O(1), donc constant.

<pre lang="OCaml">let findMin = fun h ->
match h with
| Nil -> raise EmptyHeap
| Cons(_, _, v, _) -> v</pre>

* '''deleteMin - Supprime le minimum'''

Similairement, le minimum étant à la racine, on peut établir que le supprimer revient à fusionner ses enfants. De plus, merge ayant un temps d'exécution d'ordre O(log n), celui de deleteMin est le même.

<pre lang="OCaml">let deleteMin = fun h ->
match h with
| Nil -> raise EmptyHeap
| Cons(_, a, _, b) -> merge a b</pre>

=== Tas binomial ===

[[File:Schema_3.png|300px|thumb|right|Représentation des arbres binaires de rangs 0 à 3]]

Les tas binomiaux sont des tas composés d'un type plus primitif appelé arbre binomial. Les arbres binomiaux sont défini inductivement comme suit :

* Un arbre binomial de rang 0 est un singleton de nœud ;
* Un arbre binomial de rang r est formé en liant deux arbres binomiaux de rang r-1 tel qu'un des arbres devient l'enfant le plus à gauche de l'autre.

De cette définition, on comprend qu'un arbre binomial de rang r contient exactement 2r nœuds.

Il existe une deuxième définition équivalente des arbres binomiaux :

* Un arbre binomial de rang r est un nœud ayant r enfants t1 à tr où chaque enfant ti est un arbre binomial de rang r - i.

Dans le code ci-dessous, on représente un nœud dans un arbre binomial comme un élément avec une liste de ses enfants. Par commodité, on note aussi le rang de chaque nœud.

De plus, un tas binomial étant une liste d'arbres binomiaux ne pouvant comporter qu'un seul arbre d'un rang donné et un arbre binomial de rang r comportant 2r éléments, on constate alors que les arbres d'un tas binomial de taille n correspondent à la représentation binaire de n.

Par exemple, la représentation binaire de 13 est 1101, donc un tas binomial de taille 13 contient un arbre de rang 0, un de rang 2 et un de rang 3 (de taille respective 1, 4 et 8).
De plus, comme la représentation binaire de n contient au plus ⌊log(n + 1)⌋ bits à 1, un tas binomial de taille n contient au plus ⌊log(n + 1)⌋ arbres.

<pre lang="OCaml">module BinomialHeap (O: ORDERED) = struct
type elem = O.t

type tree = Node of (int * elem * tree list)
type heap = tree list

exception EmptyHeap

let rank (Node(r, _, _)) = r
let root (Node(_, x, _)) = x

let link = ...

let rec insTree...

let insert = ...

let rec merge...

let rec removeMinTree...

let findMin = ...

let deleteMin = ...
end;;</pre>

Les fonctions que nous allons étudier ici sont link, insert, merge, findMin et deleteMin.

* '''link - Lie deux arbres de même rang pour en construire un de rang supérieur'''

Les arbres étant triés en respectant la propriété du tas, il suffit de comparer les racines pour voir lequel reste au sommet en les liant, l'autre étant ajouté à la liste des enfants.

<pre lang="OCaml">let link = fun (Node(r, x1, c1) as t1) (Node(_, x2, c2) as t2) ->
if (O.leq x1 x2)
then Node(r + 1, x1, t2 :: c1)
else Node(r + 1, x2, t1 :: c2)</pre>

* '''insert - Insertion d'un élément'''

Les fonctions insert et merge sont toutes deux vaguement comparables à l'addition de deux nombres binaires. Pour insérer un nouvel élément, on crée un singleton d'arbre (donc de rang 0) puis on parcourt tous les arbres du tas par ordre croissant de rang jusqu'à trouver un rang manquant en liant les arbres de rang égal en chemin. On peut comparer le lien à une retenue arithmétique.

<pre lang="OCaml">let rec insTree = fun t ls ->
match ls with
| [] -> [t]
| t' :: ts' as ts -> if rank t < rank t'
then t :: ts
else insTree (link t t') ts'

let insert = fun x ts -> insTree (Node(0, x, [])) ts</pre>

Le pire scénario étant dans un tas de taille n = 2k - 1 qui nécessiterait k liens, donnant un temps d'exécution d'ordre O(log n).

* '''merge - Fusion de deux tas'''

Comme précédemment, merge parcourt la liste d'arbres de chaque tas par ordre croissant de rang en liant les arbres de rang égal.

<pre lang="OCaml">let rec merge = fun ts1 ts2 ->
match ts1, ts2 with
| _, [] -> ts1
| [], _ -> ts2
| t1 :: ts1', t2 :: ts2' -> if rank t1 < rank t2
then t1 :: (merge ts1' ts2)
else if rank t2 < rank t1
then t2 :: (merge ts1 ts2')
else insTree (link t1 t2) (merge ts1' ts2')</pre>

* '''findMin et deleteMin - Trouve et supprime le minimum respectivement'''

Ces deux fonctions ont besoin de la même fonction auxiliaire, à savoir removeMinTree, qui trouve l'arbre avec la plus petite valeur et l'extrait de la liste, retournant à la fois l'arbre et le reste de la liste.

<pre lang="OCaml">let rec removeMinTree = fun ls ->
match ls with
| [] -> raise EmptyHeap
| [t] -> (t, [])
| t :: ts -> let (t', ts') = removeMinTree ts in
if (O.leq (root t) (root t'))
then (t, ts)
else (t', t :: ts')

let findMin = fun ts -> let (t, _) = removeMinTree ts in root t

let deleteMin = fun ts -> let (Node(_, x, ts1), ts2) = removeMinTree ts in merge (rev ts1) ts2</pre>

À partir de là, findMin retourne juste la racine de l'arbre. Cependant, deleteMin est plus complexe. En effet, après avoir retiré la racine de l'arbre, il faut remettre la liste d'enfants de l'arbre avec le reste de la liste des arbres. Cela dit, bien que chaque liste d'enfants est une collection d'arbres binomiaux de rang unique, ceux-ci sont triés ''par ordre décroissant de rang et non par ordre croissant''. Afin de convertir cette liste en tas binomial valide, on l'inverse à l'aide de la fonction rev avant de la fusionner avec les arbres restants.

=== Arbre rouge / noir ===

== Évolution du domaine de recherche ==

== Sources et annexes ==

'''Sources'''

* [https://www.cs.cmu.edu/~rwh/theses/okasaki.pdf Thèse d'Okasaki]

* [https://doc.lagout.org/programmation/Functional%20Programming/Chris_Okasaki-Purely_Functional_Data_Structures-Cambridge_University_Press%281998%29.pdf Purely functional data structures, Chris Okasaki]

* [https://fr.wikipedia.org/wiki/Programmation_fonctionnelle Programmation fonctionnelle (Wikipédia FR)]

* [https://en.wikipedia.org/wiki/Leftist_tree Tas gaucher (Wikipédia EN)]

'''Annexes'''

Structures de données purement fonctionnelles

2020-05-28T11:25:49Z

Dornel : /* Tas binomial */

== Présentation du problème ==

Lorsque l'on souhaite coder une structure de données dans un langage impératif comme C, Ada, Pascal ou Perl, il est très facile de trouver des livres sur le sujet. En revanche, si l'on souhaite utiliser le paradigme fonctionnel, que ce soit Lisp, Haskell ou OCaml, le choix est nettement plus restreint.

<q>Un programmeur peut choisir le paradigme de son langage, pourvu que ce soit impératif.</q>
- Chris Okasaki, pastiche d'une citation de Ford, ''Purely functional data structures'', 1996

Ainsi, Chris Okasaki a voulu explorer à travers sa thèse (et son livre la développant) diverses structures de données adaptées au paradigme fonctionnel.

Mais avant d'étudier les solutions proposées, il est nécessaire de définir quelques contraintes et termes.

=== Problèmes liés au paradigme fonctionnel ===

[[Fichier:Schema_1.png|300px|thumb|right|Différence entre structure éphémère et persistante illustrée par une liste chaînée dont on supprime le dernier élément.]]

Le paradigme fonctionnel est principalement basé sur l'évaluation de fonctions et d'expressions mathématiques, et tout ce qui ne peut être représenté ainsi n'est pas admis.

De ce fait naît le premier obstacle à la création de structures de données purement fonctionnelles : Le changement d'état étant banni, '''on ne peut pas réaliser d'assignation de variable'''.
 
Là où les langages impératifs font fréquemment usage de l'assignation de variable et de la modification de valeurs, il faut trouver d'autres solutions en fonctionnel pour contourner ce problème. Okasaki compare le lien entre l'assignation et le programmeur à celui entre les couteaux et un chef cuisinier. Dans les deux cas, un mauvais usage peut être dangereux et destructeur, mais extrêmement efficace avec un usage intelligent.

Une deuxième difficulté liée à l'absence d'assignation provient du fait que l'on attende davantage une '''persistance''' d'une structure de données fonctionnelle. En effet, là où il est admis que l'actualisation d'une structure impérative détruit l'ancienne version pour ne garder que la nouvelle (ce genre de structure de données est dit "éphémère"), on s'attend que l'actualisation d'une structure fonctionnelle donne l'accès aux deux versions (d'où la notion de structure "persistante"). Il est possible d'avoir des structures persistantes en impératif, mais on associera ici la notion d'éphémérité au paradigme impératif tandis que la persistance sera liée au paradigme fonctionnel.

Enfin, un troisième problème lié au paradigme fonctionnel relève du temps d'exécution, le fonctionnel étant généralement considéré comme étant '''moins efficace que l'impératif'''. Ainsi, il est nécessaire de trouver des structures de données qui soient aussi efficaces que celles utilisées en impératif.

=== Évaluation stricte et évaluation paresseuse ===

On appelle '''évaluation stricte''' une technique d'implémentation d'un programme récursif où les arguments sont évalués avant le corps de la fonction.
L'évaluation est dite '''paresseuse''' quand les arguments sont évalués lors du premier appel par la fonction avant d'être mis en cache pour un autre usage ultérieur.

Chaque type d'évaluation a ses avantages et inconvénients. Une évaluation stricte permettra de gérer le cas "Pire scénario" tandis qu'une évaluation paresseuse sera plus à l'aise avec les structures dites amorties.

Un avantage indéniable qu'a cependant l'évaluation stricte sur l'évaluation paresseuse est que l'on peut calculer le temps d'évaluation plus facilement (notion de [https://fr.wikipedia.org/wiki/Comparaison_asymptotique comparaison asymptotique], notamment du grand O de Landau).

=== Vocabulaire ===

Avant de commencer à étudier les solutions proposées par Okasaki, il est nécessaire de poser quelques termes de vocabulaire.

; Abstraction
: Un type de données abstrait, autrement dit un type et un ensemble de fonctions agissant sur ce type.

Exemple : Le premier bloc de code de liste chaînée (voir ci-dessous) est une abstraction de cette structure, avec le type élément et les divers constructeurs, destructeurs et méthodes sur cette structure.

; Implémentation
: Une réalisation concrète d'une abstraction. Il est important de noter qu'une implémentation ne correspond pas nécessairement à du code, un modèle concret suffit.

Exemple : Posons qu'un élément est soit null, soit le couplet liant un entier et un pointeur vers l'élément suivant. Ceci correspond à l'implémentation de l'abstraction de la structure liste chaînée.

; Objet / Version
: Une instance d'un type de données, telle une variante spécifique de liste ou d'arbre.

Exemple : Soit une liste chaînée d'entiers. Il s'agit d'une version d'une liste chaînée.

; Identité persistante
: Une identité unique et invariante malgré les changements. Par exemple, "la pile" en parlant de toutes ses différentes versions correspond à son identité persistante.

Maintenant que nous avons posé des bases solides, nous pouvons commencer à étudier les diverses structures de données proposées par Okasaki. Le langage utilisé est OCaml.

== Solutions proposées ==

En se basant sur la présentation, on peut faire remarquer deux points :
* Afin d'avoir des structures persistantes, il est nécessaire de travailler sur une copie de l'argument plutôt que l'argument lui-même
* À l'exception de la liste chaînée, toutes les structures évoquées ci-après ne fonctionnent qu'avec des types ordonnés.

<pre lang="OCaml">module type ORDERED = sig
type t
val eq: t -> t -> bool
val lt: t -> t -> bool
val leq: t -> t -> bool
end;;</pre>
''Code permettant d'implémenter un type polymorphe ordonné. On admet que ce type est défini pour toutes les structures ci-dessous.''

=== Liste chaînée ===

Cette structure basique sert d'introduction à la persistance, ce qui nous permet de présenter les différences d'implémentation de cette structure dans un paradigme impératif comparé à un paradigme fonctionnel.

''Abstraction de la structure liste chaînée''
<pre lang="OCaml">module type LIST = sig
type 'a t

(* Constructeurs *)
val nil: 'a t
val cons: 'a -> 'a t -> 'a t
val is_empty: 'a t -> bool

(* Destructeurs *)
val head: 'a t -> 'a
val tail: 'a t -> 'a t

(* Méthodes *)
val append: 'a t -> 'a t -> 'a t
val update: 'a t -> int -> 'a -> 'a t
val suffixes: 'a t -> 'a t t
end;;</pre>

Ici, nous allons observer les méthodes, à savoir append, update et suffixes.

* '''append - Concaténation de deux listes'''

Soient xs et ys deux listes et zs la concaténation de xs et ys.

En impératif, une structure de données efficace basée sur la liste chaînée peut comporter deux pointeurs globaux, un sur le premier élément et un sur le dernier. Ainsi, pour concaténer xs et ys, il suffit de modifier le dernier élément de xs pour qu'il pointe vers le premier de ys. L'avantage, c'est que le temps d'exécution est d'ordre O(1), donc constant. Cependant, en obtenant zs, on garde ys mais on perd xs.

En fonctionnel, zs est une reconstruction de xs à laquelle on accole ys. Si on note n la longueur de xs, la fonction a un temps d'exécution d'ordre O(n), mais on garde toujours xs et ys.

<pre lang="OCaml">let rec append = fun xs ys ->
if is_empty xs
then ys
else cons (head xs) (append (tail xs) ys)</pre>

L'idée est de "déconstruire" xs afin de se retrouver avec une liste vide. Au fur et à mesure, on reconstruit xs élément par élément avant d'y accoler ys lorsque cet objectif est atteint.

* '''update - Mise à jour d'un nœud'''

On cherche à changer la valeur x au rang i dans xs par la valeur y.

En impératif, on cherche le nœud concerné et on change la valeur. Le temps d'exécution est d'ordre O(n) dans le pire des cas, mais le xs original est perdu.

En fonctionnel, la méthode de recherche est la même. Le temps d'exécution est toujours d'ordre O(n) dans le pire des cas, mais on récupère ys, reconstruction altérée de xs tout en conservant l'original.

<pre lang="OCaml">let rec update = fun xs i y ->
if is_empty xs
then raise Index_out_of_bounds (* Si la liste est vide, il n'y a rien à remplacer ! *)
else if i = 0
then cons y (tail xs)
else cons (head xs) (update (tail xs) (i - 1) y)</pre>

Comme pour append, on déconstruit puis reconstruit xs, sauf que l'on a un compteur qui est décrémenté de 1 par élément reconstruit. S'il atteint 0, la valeur de l'élément actuel est replacé par y. Si on reconstruit xs dans son intégralité (donc qu'il ne reste que la liste vide) avant que le compteur ait atteint 0, on lève une exception.

* '''suffixes - Afficher tous les suffixes d'une liste par ordre décroissant de taille'''

Par exemple, la liste [1, 2, 3, 4] doit retourner [[1, 2, 3, 4], [2, 3, 4], [3, 4], [4], []].

Le temps d'exécution de cette fonction est d'ordre O(n).

<pre lang="OCaml">let rec suffixes = fun xs ->
if is_empty xs
then nil
else cons xs (suffixes (tail xs))</pre>

Ici, on utilise le fait que la fonction tail renvoie toute la liste sauf la tête. Ainsi, on peut accoler tous les suffixes un par un, jusqu'à s'arrêter avec la liste vide.

=== Arbre de recherche binaire ===

Il est possible d'utiliser des méthodes de recherche plus complexes lorsque l'on utilise une structure où un élément pointe vers plus qu'un seul autre élément. Prenons par exemple les arbres de recherche binaires.

Un arbre de recherche binaire est un arbre dont les valeurs stockées dans chaque élément sont rangées par ''ordre symétrique'', c'est-à-dire que pour un nœud donné, sa valeur est supérieure à toutes les valeurs stockées dans le sous-arbre de gauche et inférieure à celles dans le sous-arbre de droite.

Dans le code ci-dessous, BalancedTree est un foncteur, autrement dit une fonction qui prendre comme paramètre un module O de type ORDERED.

<pre lang="OCaml">module BalancedTree(O: ORDERED)= struct
type elem = O.t

type tree = E | T of (tree * elem * tree)

let rec member...

let rec insert...
end;;</pre>

Penchons-nous sur les méthodes member et insert.

* '''member - Vérifie si une valeur est présente dans l'arbre'''

En reprenant notre type ordonné, on remarque que l'on ne dispose que de 3 fonctions de test, à savoir l'égalité (O.eq), l'infériorité stricte (O.lt) et l'infériorité (O.leq).

Pour construire cette fonction, on serait tenté d'écrire :

<pre lang="OCaml">let rec member = fun xs x ->
match xs with
| E -> false
| T(e1, y, e2) -> if (O.lt x y)
then member e1 x
else if (O.lt y x)
then member e2 x
else true</pre>

On regarde si la valeur du nœud est strictement plus grande que celle recherchée. Si oui, on continue à chercher à gauche. Sinon, on regarde si la valeur du nœud est strictement inférieure à celle recherchée. Si c'est le cas, on poursuit la recherche à gauche. Sinon, il y a égalité et la valeur est bien membre de l'arbre. Si on atteint une feuille sans avoir eu d'égalité, alors la valeur n'appartient pas à l'arbre.

En effet, le pire scénario, ici la branche qui tourne toujours à droite jusqu'au bout de l'arbre, exigerait '''2n comparaisons''' (avec n la profondeur de l'arbre) pour retourner un résultat, étant donné qu'il effectue deux comparaisons par nœud.

<pre lang="OCaml">let rec member =
let rec member_aux = fun xs aux x ->
match xs with
| E -> O.eq aux x
| T(e1, y, e2) -> if (O.lt x y)
then member_aux e1 aux x
else member_aux e2 y x
in fun xs x ->
match xs with
| E -> false
| T(e1, y, e2) -> if(O.lt x y)
then member e1 x
else member_aux e2 y x</pre>

Ici, on fait appel à une fonction auxiliaire itérative stockant une valeur intermédiaire. Cette fonction fait appel au fait que si x n'est pas strictement inférieur à y, alors x est supérieur ''ou égal'' à y. Ainsi, on parcourt la branche correspondante comme précédemment, mais on garde ce candidat potentiel jusqu'à ce que l'on atteigne une feuille. Ainsi, on ne réalise dans le pire des cas que '''n + 1 comparaisons''', une par niveau de profondeur et une supplémentaire pour vérifier l'égalité une fois arrivé aux feuilles.

* '''insert - Insère une valeur dans l'arbre'''

Pour l'insertion, on procède similairement pour atteindre la feuille correspondante.

<pre lang="OCaml">let rec insert = fun xs x ->
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) as s -> if (O.lt x y)
then T((insert e1 x), y, e2)
else if (O.lt y x)
then T(e1, y, (insert e2 x))
else s</pre>

Comme précédemment, on regarde s'il faut continuer à gauche ou à droite en reconstruisant une copie de l'arbre au fur et à mesure. Cependant, si la valeur à ajouter est déjà présente dans l'arbre, on recopie également ce nœud, ce qui fait que '''la branche de recherche est testée de la racine à la feuille''' sans aucun changement à appliquer. En levant une exception si l'on trouve la valeur à ajouter dans l'arbre, on optimise le temps d'exécution en ne faisant pas de copie inutile.

<pre lang="OCaml">exception Already_there

let rec insert = fun xs x ->
try begin
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) -> if(O.lt x y)
then T((insert e1 x), y, e2)
else if (O.lt y x)
then T(e1, y, (insert e2 x))
else raise Already_there
end with Already_there -> xs</pre>

Ainsi, on s'arrête si l'on trouve la valeur à ajouter et l'on retourne une copie de l'arbre tel quel.
Et comme pour member, il est possible d'optimiser le nombre de comparaisons, ce qui donne au final une fonction qui ressemble à ceci :

<pre lang="OCaml">let rec insert =
let rec insert_aux = fun xs aux x ->
match xs with
| E -> if (O.eq aux x)
then raise Already_there
else T(E, x, E)
| T(e1, y, e2) -> if (O.lt x y)
then T((insert_aux e1 aux x), y, e2)
else T(e1, y, (insert_aux e2 y x))
in fun xs x ->
try begin
match xs with
| E -> T(E, x, E)
| T(e1, y, e2) -> if (O.lt x y)
then T((insert e1 x), y, e2)
else T(e1, y, (insert_aux e2 y x))
end with Already_there -> xs</pre>

On se retrouve donc avec une fonction d'insertion qui '''ne copie pas inutilement''' et qui ne réalise pas plus que '''n + 1 comparaisons'''.

=== Tas gaucher ===

[[Fichier:Schema_2.png|150px|thumb|right|Exemple de tas gaucher et illustration de la notion de rang.]]

Un tas est une version d'arbre particulière. En effet, elle se caractérise par le fait que la valeur de chaque nœud ne peut être plus grand que n'importe laquelle de ses enfants. Cette caractéristique fait que l'élément le plus petit se trouve toujours à la racine.

Un tas est dit gaucher si le rang de n'importe quel enfant de gauche est supérieur ou égal à celui de l'enfant de droit qui lui est associé. On appelle rang d'un nœud la longueur de sa ''colonne vertébrale droite'', c'est-à-dire le chemin le plus à droite qui va de ce nœud à une feuille. Une conséquence simple de cette propriété est que la colonne vertébrale droite d'un nœud constitue le chemin le plus court de ce nœud à une feuille.

Soit r le rang de la racine d'un tas gaucher de taille n. On peut en déduire que chaque nœud de profondeur inférieure ou égale à r-1 a exactement deux enfants, car sinon r aurait une valeur plus faible ou la propriété gauchère ne serait pas respectée. Ainsi, on peut affirmer que la taille d'un tas est donc d'au moins 2r - 1. De ce fait, on peut en déduire que le rang de la racine vaut au plus log(n + 1). Par conséquent, la colonne vertébrale droite d'un tas gaucher de taille n comporte au plus ⌊log(n + 1)⌋ éléments.

''Code de la structure tas gaucher''
<pre lang="OCaml">module LeftistHeap (O: ORDERED) = struct
type elem = O.t

type heap = Nil | Cons of (int * heap * elem * heap)

let rank = fun h ->
match h with
| Nil -> 0
| Cons(r, _, _, _) -> r

let makeH...

let merge...

let insert...

exception EmptyHeap

let findMin...

let deleteMin...
end;;</pre>

Ici, nous allons étudier les fonctions merge, insert, findMin et deleteMin.

* '''merge - Fusionne deux tas'''

Afin de simplifier l'opération, on remarque que la colonne vertébrale droite d'un tas gaucher est ordonnée. On en déduit que le concept clé est de fusionner les colonnes vertébrales des deux tas comme on fusionnerait deux listes triées avant d'échanger les enfants le long de la branche afin de restaurer la propriété gauchère.

Comme il a été démontré précédemment que la longueur de la colonne vertébrale est au plus logarithmique, on peut en déduire que merge a un temps d'exécution d'ordre O(log n).

<pre lang="OCaml">let makeH = fun v a b ->
if rank a >= rank b
then Cons(rank b + 1, a, v, b)
else Cons(rank a + 1, b, v, a)

let rec merge = fun x y ->
match x, y with
| Nil, _ -> y
| _, Nil -> x
| Cons(_, e11, v1, e12), Cons(_, e21, v2, e22) -> if (O.leq v1 v2)
then makeH v1 e11 (merge e12 y)
else makeH v2 e21 (merge x e22)</pre>

Ici, on fait appel à une fonction intermédiaire : makeH.

Cette fonction compare le rang des deux tas et échange les enfants si besoin afin de respecter la propriété gauchère.

Ensuite, concernant merge en elle-même, on compare les valeurs des deux racines et on fait appel à makeH pour combiner et potentiellement échanger les enfants.

* '''insert - Insère une valeur dans l'arbre'''

Une fois merge défini, il suffit d'établir que l'on veut fusionner le tas avec un tas d'une seule valeur. Et puisque le temps d'exécution de merge est d'ordre O(log n), il en va de même pour insert.

<pre lang="OCaml">let insert = fun v h -> (merge (Cons(1, Nil, v, Nil)) h)</pre>

* '''findMin - Récupère le minimum'''

Comme le minimum est par définition à la racine, le temps d'exécution de findMin est d'ordre O(1), donc constant.

<pre lang="OCaml">let findMin = fun h ->
match h with
| Nil -> raise EmptyHeap
| Cons(_, _, v, _) -> v</pre>

* '''deleteMin - Supprime le minimum'''

Similairement, le minimum étant à la racine, on peut établir que le supprimer revient à fusionner ses enfants. De plus, merge ayant un temps d'exécution d'ordre O(log n), celui de deleteMin est le même.

<pre lang="OCaml">let deleteMin = fun h ->
match h with
| Nil -> raise EmptyHeap
| Cons(_, a, _, b) -> merge a b</pre>

=== Tas binomial ===

[[File:Schema_3.png|300px|thumb|right|Représentation des arbres binaires de rangs 0 à 3]]

Les tas binomiaux sont des tas composés d'un type plus primitif appelé arbre binomial. Les arbres binomiaux sont défini inductivement comme suit :

* Un arbre binomial de rang 0 est un singleton de nœud ;
* Un arbre binomial de rang r est formé en liant deux arbres binomiaux de rang r-1 tel qu'un des arbres devient l'enfant le plus à gauche de l'autre.

De cette définition, on comprend qu'un arbre binomial de rang r contient exactement 2r nœuds.

Il existe une deuxième définition équivalente des arbres binomiaux :

* Un arbre binomial de rang r est un nœud ayant r enfants t1 à tr où chaque enfant ti est un arbre binomial de rang r - i.

Dans le code ci-dessous, on représente un nœud dans un arbre binomial comme un élément avec une liste de ses enfants. Par commodité, on note aussi le rang de chaque nœud.

De plus, un tas binomial étant une liste d'arbres binomiaux ne pouvant comporter qu'un seul arbre d'un rang donné et un arbre binomial de rang r comportant 2r éléments, on constate alors que les arbres d'un tas binomial de taille n correspondent à la représentation binaire de n.

Par exemple, la représentation binaire de 13 est 1101, donc un tas binomial de taille 13 contient un arbre de rang 0, un de rang 2 et un de rang 3 (de taille respective 1, 4 et 8).
De plus, comme la représentation binaire de n contient au plus ⌊log(n + 1)⌋ bits à 1, un tas binomial de taille n contient au plus ⌊log(n + 1)⌋ arbres.

<pre lang="OCaml">module BinomialHeap (O: ORDERED) = struct
type elem = O.t

type tree = Node of (int * elem * tree list)
type heap = tree list

exception EmptyHeap

let rank (Node(r, _, _)) = r
let root (Node(_, x, _)) = x

let link = fun (Node(r, x1, c1) as t1) (Node(_, x2, c2) as t2) ->
if (O.leq x1 x2)
then Node(r + 1, x1, t2 :: c1)
else Node(r + 1, x2, t1 :: c2)

let rec insTree...

let insert = fun x ts -> insTree (Node(0, x, [])) ts

let rec merge...

let rec removeMinTree...

let findMin = fun ts -> let (t, _) = removeMinTree ts in root t

let deleteMin = fun ts -> let (Node(_, x, ts1), ts2) = removeMinTree ts in merge (rev ts1) ts2
end;;</pre>

Les fonctions que nous allons étudier ici sont insTree, merge et removeMinTree.

* '''insTree -

=== Arbre rouge / noir ===

== Évolution du domaine de recherche ==

== Sources et annexes ==

'''Sources'''

* [https://www.cs.cmu.edu/~rwh/theses/okasaki.pdf Thèse d'Okasaki]

* [https://doc.lagout.org/programmation/Functional%20Programming/Chris_Okasaki-Purely_Functional_Data_Structures-Cambridge_University_Press%281998%29.pdf Purely functional data structures, Chris Okasaki]

* [https://fr.wikipedia.org/wiki/Programmation_fonctionnelle Programmation fonctionnelle (Wikipédia FR)]

* [https://en.wikipedia.org/wiki/Leftist_tree Tas gaucher (Wikipédia EN)]

'''Annexes'''

Structures de données purement fonctionnelles

2020-05-28T09:10:18Z

Dornel : /* Tas binomial */

Fichier:Schema 3.png

2020-05-28T07:54:54Z

Dornel : Représentation des arbres binomiaux de rang 0 à 3

Représentation des arbres binomiaux de rang 0 à 3

Structures de données purement fonctionnelles

2020-05-28T07:41:48Z

Dornel : /* Sources et annexes */

Structures de données purement fonctionnelles

2020-05-28T07:40:53Z

Dornel : /* Tas gaucher */

Structures de données purement fonctionnelles

2020-05-28T07:37:35Z

Dornel : /* Tas gaucher */

Structures de données purement fonctionnelles

2020-05-27T18:40:54Z

Dornel : /* Tas gaucher */

Structures de données purement fonctionnelles

2020-05-27T17:21:33Z

Dornel : /* Tas gaucher */

Structures de données purement fonctionnelles

2020-05-27T16:40:00Z

Dornel :

Fichier:Schema 2.png

2020-05-27T15:40:10Z

Dornel : Exemple de tas gaucher et illustration de la notion de rang

Exemple de tas gaucher et illustration de la notion de rang

Structures de données purement fonctionnelles

2020-05-27T15:16:59Z

Dornel :

Structures de données purement fonctionnelles

2020-05-27T08:36:26Z

Dornel : /* Arbre de recherche binaire */

Structures de données purement fonctionnelles

2020-05-27T08:35:28Z

Dornel : /* Liste chaînée */

Structures de données purement fonctionnelles

2020-05-27T08:31:54Z

Dornel : /* Évaluation stricte et évaluation paresseuse */

Structures de données purement fonctionnelles

2020-05-27T07:57:10Z

Dornel : /* Arbre de recherche binaire */

Structures de données purement fonctionnelles

2020-05-27T07:53:46Z

Dornel : /* Arbre de recherche binaire */

Structures de données purement fonctionnelles

2020-05-27T07:50:19Z

Dornel : /* Solutions proposées */

Structures de données purement fonctionnelles

2020-05-26T16:47:02Z

Dornel : /* Liste chaînée */

Structures de données purement fonctionnelles

2020-05-26T15:43:00Z

Dornel : /* Liste chaînée */

Structures de données purement fonctionnelles

2020-05-26T13:22:06Z

Dornel : Page créée avec « == Présentation du problème == Lorsque l'on souhaite coder une structure de données dans un langage impératif comme C, Ada, Pascal ou Perl, il est très facile de tro... »

Fichier:Schema 1.png

2020-05-26T11:13:04Z

Dornel : Dornel a téléversé une nouvelle version de Fichier:Schema 1.png

Illustration de la différence entre un schéma éphémère et persistant

Fichier:Schema 1.png

2020-05-26T10:47:38Z

Dornel : Illustration de la différence entre un schéma éphémère et persistant

Illustration de la différence entre un schéma éphémère et persistant

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-18T12:37:28Z

Dornel : /* Introduction */

== Introduction ==

Coq est un logiciel d'aide à la preuve mathématique développé par les équipes PI.R2 et Marelle d'Inria et l'équipe Systèmes Sûrs du Cnam. La première version a été publiée en 1984 et a été codée sous CAML.

Coq est fondé sur le calcul des constructions, une théorie concurrente à la théorie des ensembles de Zermelo-Fraenkel, et plus particulièrement la correspondance de Curry-Howard dont l'une des caractéristiques est que les propositions sont des types, tandis que les preuves dont des objets.

Parmi les théorèmes issus des mathématiques dont les preuves sont volumineuses et qui ont été démontrées à l'aide de Coq, on peut citer notamment :

* '''Théorème des quatre couleurs'''

Le théorème des quatre couleurs indique qu'il est possible en utilisant seulement quatre couleurs différentes de colorier n'importe quelle carte découpée en régions de sorte que deux régions ayant une frontière en commun ne soient pas de la même couleur. Le résultat fut initialement conjecturé en 1852, avec les deux premières preuves étant publiées en 1879 et 1880, celles-ci se révélant cependant fausses. La première preuve utilisant l'outil informatique date de 1976 et fut reprise et simplifiée par la suite. Enfin, en 2005, Georges Gonthier et Benjamin Werner ont réussi à formuler avec Coq une preuve formelle permettant à un ordinateur de complètement vérifier le théorème des quatre couleurs. À ce jour, aucune preuve qui ne fasse pas appel à un ordinateur n'a été découverte.

* '''Théorème de Feit-Thompson'''

Le théorème de Feit-Thompson énonce que tout groupe fini d'ordre impair est résoluble, ce qui équivaut à dire que tout groupe simple fini non commutatif est d'ordre pair. Le théorème fut conjecturé en 1911 par William Burnside et démontré en 1963 par Walter Feit et John Griggs Thompson. Une formalisation de la preuve en Coq a été achevée en 2012 par Georges Gonthier et son équipe du laboratoire commun Inria-Microsoft.

Coq sert également à la certification de logiciel. Parmi la multitude d'exemples, on peut mentionner :

* '''CompCert'''

CompCert est un projet ayant pour but de réaliser des compilateurs certifiés formellement. Ce projet développe notamment le compilateur CompCert C pour le langage C. Le projet est réalisé notamment en Coq.

* '''Iris Project'''

Iris Project utilise la logique de séparation (formalisée en Coq) pour certifier les propriétés de programmes concurrents.

== Types, fonctions et preuves basiques ==

=== Déclaration de types ===

Pour définir un type sur Coq, une première méthode est l'induction. Cela consiste à utiliser les différents cas particuliers pour définir le cas général.
<pre lang="coq">Inductive day : Type :=
| monday
| tuesday
| wednesday
| thursday
| friday
| saturday
| sunday.</pre>

Ici, pour le type ''day'', on énumère les différentes valeurs que peut adopter le type, à savoir les jours de la semaine. Cette méthode permet notamment de définir des types dont l'ensemble de valeurs possibles est fini, comme les booléens ou les bits. Cependant, tenter de représenter les nombres avec cette méthode est contre-indiqué, car il faudrait un temps et une capacité de stockage disproportionnellement élevés.

Pour définir les nombres ou d'autres types dont l'ensemble de valeurs possibles est infini, il est possible de définir un type par récurrence.
<pre lang="coq">Inductive nat : Type:=
| O
| S (n : nat).</pre>

Dans ce cas-là, par exemple, on définit le type ''nat'' (correspondant aux entiers naturels) par un cas initial, ici 0, modélisé par la lettre O, et une hérédité, ici le fait que pour tout n ∈ ℕ, il existe un n' appartenant à ce même intervalle tel que n corresponde à S n'. L'écriture mathématique équivalente de cette définition est :
<math>\forall n > 0, \exists n' \geqslant 0, n = n' + 1</math>

Enfin, il est également possible avec Coq de créer un type utilisant un autre type pour sa définition. Ainsi, si l'on définit comme suit les teintes RGB d'une couleur :
<pre lang="coq">Inductive rgb : Type :=
| red
| green
| blue.</pre>
Il est possible de définir les composantes d'une couleur en utilisant le type ''rgb'' préalablement créé :
<pre lang="coq">Inductive color : Type :=
| black
| white
| primary (p : rgb).</pre>
Ainsi, ''color'' possède trois composantes, à savoir black, white et primary, cette dernière ayant elle-même trois composantes, red, green et blue.

=== Fonctions ===

Il y a plusieurs manières de définir une fonction dans Coq. La première est d'utiliser la commande '''''Definition''''' et de spécifier au cas par cas quel résultat la fonction retourne selon la valeur de la variable d'entrée.
 
Ainsi, en reprenant le type ''day'', on peut définir la fonction next_weekday comme suit :
<pre lang="coq">Definition next_weekday (d:day) : day :=
match d with
| monday => tuesday
| tuesday => wednesday
| wednesday => thursday
| thursday => friday
| friday => saturday
| saturday => sunday
| sunday => monday
end.</pre>
Dans cet exemple, on introduit le nom de la fonction, on indique le nom utilisé en son sein pour désigner la variable ainsi que son type, puis le type du résultat.
 
L'instruction ''match d with'' sert à analyser la valeur de la variable d. La liste qui suit signifie que pour telle valeur de d (par exemple wednesday), on retourne le résultat indiqué par la flèche (ici thursday). Enfin, la commande ''end'' permet de délimiter la fin de la fonction.

Cependant, il est également possible de ne retenir que certains cas et de retourner une même réponse pour tous les cas non vérifiés, dans la même veine qu'un ''else'' dans d'autres langages.
 
Par exemple, en supposant que l'on a défini précédemment un type ''bool'' qui ne peut prendre que true et false comme valeurs, on peut établir la fonction suivante :
<pre lang="coq">Definition isred (c : color) : bool :=
match c with
| black => false
| white => false
| primary red => true
| primary _ => false
end.</pre>
Ici, si l'on voulait écrire la fonction en Python, on aurait :
<pre lang="python">def isred(c) :
if c == black :
return False
elif c == white :
return False :
elif c == primary[red] :
return True
else :
return False</pre>
On remarque donc que le caractère _ signifie "dans tous les autres cas possibles", ce qui permet de ne retenir que les situations particulières et de généraliser le reste.

Une autre manière d'écrire une fonction est d'utiliser la commande '''''Fixpoint'''''. La différence majeure entre Fixpoint et Definition est la possibilité d'appeler la fonction récursivement avec Fixpoint.

Par exemple, une fonction pour définir si un entier naturel est pair s'écrit :
<pre lang="coq">Fixpoint evenb(n:nat) : bool :=
match n with
| 0 => true
| S 0 => false
| S (S n') => evenb n'</pre>

Cela signifie que pour tout entier n, trois cas de figure se présentent :
# <math> n = 0 \rightarrow n\ pair </math>
# <math> n = 1 \rightarrow n\ non\ pair </math>
# <math> \exists n', n = n' + 2 </math>
Dans le troisième cas, on réitère l'étude, mais avec n'.

Enfin, une troisième méthode pour définir une fonction est la commande '''''Theorem''''' qui permet, comme son nom l'indique, de définir un théorème, généralement sous la forme d'une égalité ou d'une implication. S'il s'agit d'une implication A -> B, A peut être utilisé comme hypothèse lors de la preuve.

=== Preuves simples ===

==== Structure générale ====

Dans Coq, la structure d'une preuve suit toujours la même structure :
<pre lang="coq">Proof. (* On indique le début de la preuve... *)
(* On insère ici toutes les instructions nécessaires... *)
Qed. (* Quod erat demonstrandum, équivalent latin de C.Q.F.D., signifie que la preuve est finie *)</pre>

==== Tactiques ====

Les tactiques sont des instructions pour aider Coq à résoudre une preuve.

* simpl.

simpl. permet, comme son nom l'indique, de simplifier une formule.

* reflexivity.

reflexivity. permet de vérifier si une égalité est du type a = a. Si la réflexivité de l'égalité est prouvée, alors la proposition est vraie. Cette instruction permet généralement d'achever une preuve.

* intros n.

intros. s'utilise en début de preuve pour introduire les variables présentes dans un théorème ou une hypothèse. S'il y a plusieurs variables à introduire, il faut les séparer par des espaces

* unfold f.

unfold f. permet de développer l'expression à étudier selon la fonction f.

* rewrite <- / -> H.

Permet de réécrire l'expression en fonction de l'hypothèse H. La flèche <- indique que l'on souhaite passer du membre de droite à celui de gauche et inversement pour ->. Coq va ensuite essayer de trouver un membre de l'expression qui correspond au terme de départ et va le remplacer par le terme d'arrivée.

* destruct n as [n1 | n2 | ...] eqn:E.

destruct permet de décomposer une variable en plusieurs cas de figure qui sont traités séparément. destruct fonctionne différemment selon le type de la variable utilisée. Avec les booléens ou d'autres types binaires, on peut se passer du as [...] car il n'y a par définition que deux valeurs que peut prendre la variable. Avec les entiers, on va généralement décomposer sous la forme as [| n'], autrement dit, on établit une pseudo-récurrence en vérifiant pour n = 0 et ensuite pour tout n' tel que n = n' + 1. Il ne s'agit cependant pas d'une vraie récurrence car il n'y a pas de lien entre n et n'.

==== Séparation des cas ====

Dans Coq, certaines commandes comme destruct occasionnent une séparation de l'expression en plusieurs cas. Pour identifier ces cas, il y a deux méthodes.

# Commencer chaque cas par une puce (-, + et * dans cet ordre)
# Délimiter un cas par des astérisque {}, ce qui permet de réinitialiser la hiérarchie des puces

== Preuve par récurrence, preuves à l'intérieur de preuves, preuves formelles et informelles ==

=== Preuve par récurrence ===

Bien que les tactiques mentionnées dans la partie précédente permettent de résoudre une grande partie des preuves, certains cas requièrent une attention plus particulière. Si la situation s'y prête, on peut notamment utiliser la récurrence avec la syntaxe suivante :

<pre lang="coq">Proof.
intros n. induction n as [| n' IHn']. (* On décompose n en un cas initial, généralement 0, et on introduit l'hypothèse que la proposition est vérifiée pour un palier arbitraire n'. *)
- (* Initialisation. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée pour le cas initial. *)
- (* Hérédité. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée à un niveau n' + 1 si elle est vérifiée pour n'. *)
Qed.</pre>

Ben que la récurrence soit une tactique puissante, il vaut mieux la réserver aux situations qui le nécessitent. Il est également nécessaire d'utiliser à un moment l'hypothèse d'hérédité avec rewrite. S'il est possible de compléter la preuve sans l'utiliser, une autre tactique aurait été probablement plus appropriée.

=== Preuves à l'intérieur de preuves ===

Parfois, il n'est pas possible de démontrer une équation telle quelle. Il faut passer par un lemme qui est introduit en Coq par l'instruction '''''assert'''''. Par exemple, la preuve servant à démontrer que <math>\forall n,m \in \mathbb{R}, (0 + n) * m = n * m</math> se structure comme tel :

<pre lang="Coq">Proof.
intros n m. (* On introduit les deux variables n et m *)
assert (H: 0 + n = n). (* On définit le lemme H qui dit que 0 + n = n *)
{ reflexivity. } (* On vérifie que H est vrai *)
rewrite -> H. (* On reformule l'équation initiale en remplaçant 0 + n par n, maintenant que l'on sait que les deux sont égaux *)
reflexivity. (* Les deux membres de l'équation sont alors identiques, la preuve est achevée *)
Qed.</pre>

=== Preuves formelles et informelles ===

Le principe d'une preuve est de convaincre le lecteur de sa véracité. Cependant, tous les lecteurs n'ont pas la même capacité de compréhension.

Par exemple, en langage mathématique, le théorème de Taylor à l'ordre n en a pourrait s'écrire :

<math>f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</math>

Cette écriture peut être lue aisément par un humain, mais pas par une machine. Cependant, si l'on écrit :

<pre lang="latex">f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</pre>

Un humain aurait du mal à lire cette ligne de code, mais si un interpréteur LaTeX la lit, il affiche l'équation précédente. Il existe donc plusieurs façons de présenter la même information en fonction du lecteur visé. Il en est de même pour les preuves sur Coq.

* Preuves formelles

Les preuves formelles sont celles que Coq peut comprendre facilement et qui n'est pas prévue pour être facilement comprise par un humain. Par exemple, la preuve formelle de l'associativité de l'addition est structurée comme suit :

<pre lang="coq">Proof. intros n m p. induction n as [| n' IHn']. reflexivity. simpl. rewrite -> IHn'. reflexivity. Qed.</pre>

Le code est réduit à l'essentiel, mais la clarté pour le lecteur humain est moindre.

* Preuves informelles

Les preuves informelles sont celles que Coq accepte et qu'un humain peut comprendre facilement. Par exemple, la preuve informelle de l'associativité de l'addition est structurée comme tel :

<pre lang="coq">Proof.
intros n m p. induction n as [| n' IHn'].
- (* n = 0 *)
reflexivity.
- (* n = S n' *)
simpl. rewrite -> IHn'. reflexivity.
Qed.</pre>

Ici, on a éclaté le code pour notamment séparer les deux cas étudiés lors de la récurrence et on a ajouté des commentaires. Coq interprète toujours le code, mais un lecteur humain peut davantage comprendre ce qui se passe.

== Listes, sacs de nombres et opérations sur ces types ==

=== Listes de nombres ===

Dans Coq, on peut définir une liste de nombres sous le type '''''natlist''''' de façon récursive. Une liste est composée soit de l'élément vide, soit de la concaténation d'un entier naturel et d'une autre liste. Parmi les différentes opérations que l'on peut exécuter sur les listes, on peut évoquer :

* Créer une liste de longueur déterminée composée d'un seul élément

<pre lang="coq">Fixpoint repeat (n count : nat) : natlist :=
match count with (* Si count vaut... *)
| O => nil (* ... 0, on ferme la liste avec l'élément nul *)
| S count' => n :: (repeat n count') (* ... count' + 1, on concatène le nombre avec la liste de longueur count' répétant ce nombre *)
end.</pre>

* Calculer la longueur d'une liste

<pre lang="coq">Fixpoint length (l:natlist) : nat :=
match l with
| nil => O (* Cas 1, la liste n'est composée que de l'élément nul, sa longueur est donc nulle *)
| h :: t => S (length t) (* Cas 2, la liste est composée de la concaténation d'un entier et d'une liste, sa longueur vaut donc 1 + la longueur de cette deuxième liste *)
end.</pre>

* Joindre deux listes

<pre lang="coq">Fixpoint app (l1 l2 : natlist) : natlist :=
match l1 with
| nil => l2 (* Si la première liste est vide, le résultat de la jonction est donc la seule deuxième liste *)
| h :: t => h :: (app t l2) (* Si la première liste est composée d'un entier et d'une liste, on concatène cet entier avec la jonction de la liste et de la deuxième liste *)
end.</pre>

* Définir la tête et la queue d'une liste

<pre lang="coq">Definition hd (default:nat) (l:natlist) : nat :=
match l with
| nil => default (* Si la liste est vide, on retourne le nombre défini par défaut, l'élément vide n'ayant pas de premier élément *)
| h :: t => h (* Si la liste est composée d'un entier et d'une liste, on retourne l'entier, celui-ci étant le premier élément *)
end.</pre>

<pre lang="coq">Definition tl (l:natlist) : natlist :=
match l with
| nil => nil (* Si la liste est vide, on retourne l'ensemble vide *)
| h :: t => t (* Si la liste est composée d'un entier et d'une liste, on retourne la liste *)
end.</pre>

=== Sacs de nombres ===

Un sac de nombres ressemble à une liste, à l'exception prêt qu'un même élément peut apparaître plusieurs fois. Mis à part ce détail, le type '''''bag''''' est défini comme une liste de nombres. Parmi les opérations possibles sur ce type, on peut citer :

* Compter le nombre d'occurrence d'un nombre au sein d'un sac

<pre lang="coq">Fixpoint count (v:nat) (s:bag) : nat :=
match s with
| nil => 0 (* Si la liste est vide, l'élément recherché ne peut pas apparaître *)
| h :: t => match h =? v with (* Si la liste est composée d'un entier et d'une liste, on compare l'entier avec l'élément recherché *)
| true => S (count v t) (* S'ils sont égaux, on continue la recherche sur le reste de la liste en ajoutant 1 au nombre d'occurrences *)
| false => count v t (* S'ils ne sont pas égaux, on continue la recherche sur le reste de la liste *)
end
end.</pre>

* Vérifier qu'un nombre appartient à un sac

<pre lang="coq">Fixpoint member (v:nat) (s:bag) : bool :=
match s with
| nil => false
| h :: t => match h =? v with
| true => true
| false => member v t
end
end.</pre>

* Retirer un ou toutes les occurrences d'un nombre dans un sac

<pre lang="coq">Fixpoint remove_one (v:nat) (s:bag) : bag :=
match s with
| nil => nil (* Si la liste est vide, on n'a plus rien à enlever *)
| h :: t => match h =? v with (* Similairement à count, si la liste est composée d'un entier et d'une liste, on compare l'entier à l'élément recherché *)
| true => t (* S'ils sont égaux, on retourne le reste de la liste, car on a enlevé la première occurrence d'un élément *)
| false => h :: remove_one v t (* S'ils ne sont pas égaux, on concatène l'entier avec le résultat de la recherche au sein de la liste restante *)
end
end.</pre>

remove_all et remove_one fonctionne exactement de la même manière, excepté que remove_all continue la recherche dans tous les cas.

<pre lang="coq">Fixpoint remove_all (v:nat) (s:bag) : bag :=
match s with
| nil => nil
| h :: t => match h =? v with
| true => remove_all v t
| false => h :: remove_all v t
end
end.</pre>

* Vérifier qu'un sac est inclus dans un deuxième sac

<pre lang="coq">Fixpoint subset (s1:bag) (s2:bag) : bool :=
match s1 with
| nil => true (* Si le sac de référence est vide, il est forcément inclus dans le deuxième sac *)
| h :: t => match (member h s2) with (* Si le sac de référence est composée d'un entier et d'une liste, on regarde si cet entier est présent dans le deuxième sac *)
| true => subset t (remove_one h s2) (* S'il est présent, on continue la recherche avec le reste du sac de référence est en retirant une occurrence de l'élément dans le deuxième sac *)
| false => false (* S'il n'est pas présent, alors le sac de référence n'est pas inclus dans le deuxième sac *)
end
end.</pre>

== Sources et annexes ==

'''Sources'''

* Software Foundations volume 1 [https://softwarefoundations.cis.upenn.edu/lf-current/index.html]

* Page Wikipédia de Coq [https://fr.wikipedia.org/wiki/Coq_(logiciel)]

'''Annexe'''

* Théorème des quatre couleurs [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_des_quatre_couleurs]

* Théorème de Feit-Thompson [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_de_Feit-Thompson]

* Compcert [http://compcert.inria.fr/]

* Iris Project [https://iris-project.org/]

* Software Foundations [https://softwarefoundations.cis.upenn.edu/]

* Verified Software Toolchain [https://vst.cs.princeton.edu/]

* FSCQ [http://css.csail.mit.edu/fscq/]

* Bedrock [http://plv.csail.mit.edu/bedrock/]

* CFML [https://www.chargueraud.org/softs/cfml/]

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-17T14:17:51Z

Dornel : /* Introduction */

== Introduction ==

Coq est un logiciel d'aide à la preuve mathématique développé par les équipes PI.R2 et Marelle d'Inria et l'équipe Systèmes Sûrs du Cnam. La première version a été publiée en 1984 et a été codée sous CAML.

Coq est fondé sur le calcul des constructions, une théorie concurrente à la théorie des ensembles de Zermelo-Fraenkel, et plus particulièrement la correspondance de Curry-Howard dont l'une des caractéristiques est que les propositions sont des types, tandis que les preuves dont des objets.

Parmi les théorèmes issus des mathématiques dont les preuves sont volumineuses et qui ont été démontrées à l'aide de Coq, on peut citer notamment :

* '''Théorème des quatre couleurs'''

Le théorème des quatre couleurs indique qu'il est possible en utilisant seulement quatre couleurs différentes de colorier n'importe quelle carte découpée en régions de sorte que deux régions ayant une frontière en commun ne soient pas de la même couleur. Le résultat fut initialement conjecturé en 1852, avec les deux premières preuves étant publiées en 1879 et 1880, celles-ci se révélant cependant fausses. La première preuve utilisant l'outil informatique date de 1976 et fut reprise et simplifiée par la suite. Enfin, en 2005, Georges Gonthier et Benjamin Werner ont réussi à formuler avec Coq une preuve formelle permettant à un ordinateur de complètement vérifier le théorème des quatre couleurs. À ce jour, aucune preuve qui ne fasse pas appel à un ordinateur n'a été découverte.

* '''Théorème de Feit-Thompson'''

Le théorème de Feit-Thompson énonce que tout groupe fini d'ordre impair est résoluble, ce qui équivaut à dire que tout groupe simple fini non commutatif est d'ordre pair. Le théorème fut conjecturé en 1911 par William Burnside et démontré en 1963 par Walter Feit et John Griggs Thompson. Une formalisation de la preuve en Coq a été achevée en 2012 par Georges Gonthier et son équipe du laboratoire commun Inria-Microsoft.

Coq sert également à la certification de logiciel. Parmi la multitude d'exemples, on peut mentionner :

* '''CompCert'''

CompCert est un projet ayant pour but de réaliser des compilateurs certifiés formellement. Ce projet développe notamment le compilateur CompCert C pour le langage C. Le projet est réalisé notamment en Coq.

* '''Iris Project'''

Iris Project est un logiciel de séparation logique simultanée d'ordre supérieure (''demander informations complémentaires'')

== Types, fonctions et preuves basiques ==

=== Déclaration de types ===

Pour définir un type sur Coq, une première méthode est l'induction. Cela consiste à utiliser les différents cas particuliers pour définir le cas général.
<pre lang="coq">Inductive day : Type :=
| monday
| tuesday
| wednesday
| thursday
| friday
| saturday
| sunday.</pre>

Ici, pour le type ''day'', on énumère les différentes valeurs que peut adopter le type, à savoir les jours de la semaine. Cette méthode permet notamment de définir des types dont l'ensemble de valeurs possibles est fini, comme les booléens ou les bits. Cependant, tenter de représenter les nombres avec cette méthode est contre-indiqué, car il faudrait un temps et une capacité de stockage disproportionnellement élevés.

Pour définir les nombres ou d'autres types dont l'ensemble de valeurs possibles est infini, il est possible de définir un type par récurrence.
<pre lang="coq">Inductive nat : Type:=
| O
| S (n : nat).</pre>

Dans ce cas-là, par exemple, on définit le type ''nat'' (correspondant aux entiers naturels) par un cas initial, ici 0, modélisé par la lettre O, et une hérédité, ici le fait que pour tout n ∈ ℕ, il existe un n' appartenant à ce même intervalle tel que n corresponde à S n'. L'écriture mathématique équivalente de cette définition est :
<math>\forall n > 0, \exists n' \geqslant 0, n = n' + 1</math>

Enfin, il est également possible avec Coq de créer un type utilisant un autre type pour sa définition. Ainsi, si l'on définit comme suit les teintes RGB d'une couleur :
<pre lang="coq">Inductive rgb : Type :=
| red
| green
| blue.</pre>
Il est possible de définir les composantes d'une couleur en utilisant le type ''rgb'' préalablement créé :
<pre lang="coq">Inductive color : Type :=
| black
| white
| primary (p : rgb).</pre>
Ainsi, ''color'' possède trois composantes, à savoir black, white et primary, cette dernière ayant elle-même trois composantes, red, green et blue.

=== Fonctions ===

Il y a plusieurs manières de définir une fonction dans Coq. La première est d'utiliser la commande '''''Definition''''' et de spécifier au cas par cas quel résultat la fonction retourne selon la valeur de la variable d'entrée.
 
Ainsi, en reprenant le type ''day'', on peut définir la fonction next_weekday comme suit :
<pre lang="coq">Definition next_weekday (d:day) : day :=
match d with
| monday => tuesday
| tuesday => wednesday
| wednesday => thursday
| thursday => friday
| friday => saturday
| saturday => sunday
| sunday => monday
end.</pre>
Dans cet exemple, on introduit le nom de la fonction, on indique le nom utilisé en son sein pour désigner la variable ainsi que son type, puis le type du résultat.
 
L'instruction ''match d with'' sert à analyser la valeur de la variable d. La liste qui suit signifie que pour telle valeur de d (par exemple wednesday), on retourne le résultat indiqué par la flèche (ici thursday). Enfin, la commande ''end'' permet de délimiter la fin de la fonction.

Cependant, il est également possible de ne retenir que certains cas et de retourner une même réponse pour tous les cas non vérifiés, dans la même veine qu'un ''else'' dans d'autres langages.
 
Par exemple, en supposant que l'on a défini précédemment un type ''bool'' qui ne peut prendre que true et false comme valeurs, on peut établir la fonction suivante :
<pre lang="coq">Definition isred (c : color) : bool :=
match c with
| black => false
| white => false
| primary red => true
| primary _ => false
end.</pre>
Ici, si l'on voulait écrire la fonction en Python, on aurait :
<pre lang="python">def isred(c) :
if c == black :
return False
elif c == white :
return False :
elif c == primary[red] :
return True
else :
return False</pre>
On remarque donc que le caractère _ signifie "dans tous les autres cas possibles", ce qui permet de ne retenir que les situations particulières et de généraliser le reste.

Une autre manière d'écrire une fonction est d'utiliser la commande '''''Fixpoint'''''. La différence majeure entre Fixpoint et Definition est la possibilité d'appeler la fonction récursivement avec Fixpoint.

Par exemple, une fonction pour définir si un entier naturel est pair s'écrit :
<pre lang="coq">Fixpoint evenb(n:nat) : bool :=
match n with
| 0 => true
| S 0 => false
| S (S n') => evenb n'</pre>

Cela signifie que pour tout entier n, trois cas de figure se présentent :
# <math> n = 0 \rightarrow n\ pair </math>
# <math> n = 1 \rightarrow n\ non\ pair </math>
# <math> \exists n', n = n' + 2 </math>
Dans le troisième cas, on réitère l'étude, mais avec n'.

Enfin, une troisième méthode pour définir une fonction est la commande '''''Theorem''''' qui permet, comme son nom l'indique, de définir un théorème, généralement sous la forme d'une égalité ou d'une implication. S'il s'agit d'une implication A -> B, A peut être utilisé comme hypothèse lors de la preuve.

=== Preuves simples ===

==== Structure générale ====

Dans Coq, la structure d'une preuve suit toujours la même structure :
<pre lang="coq">Proof. (* On indique le début de la preuve... *)
(* On insère ici toutes les instructions nécessaires... *)
Qed. (* Quod erat demonstrandum, équivalent latin de C.Q.F.D., signifie que la preuve est finie *)</pre>

==== Tactiques ====

Les tactiques sont des instructions pour aider Coq à résoudre une preuve.

* simpl.

simpl. permet, comme son nom l'indique, de simplifier une formule.

* reflexivity.

reflexivity. permet de vérifier si une égalité est du type a = a. Si la réflexivité de l'égalité est prouvée, alors la proposition est vraie. Cette instruction permet généralement d'achever une preuve.

* intros n.

intros. s'utilise en début de preuve pour introduire les variables présentes dans un théorème ou une hypothèse. S'il y a plusieurs variables à introduire, il faut les séparer par des espaces

* unfold f.

unfold f. permet de développer l'expression à étudier selon la fonction f.

* rewrite <- / -> H.

Permet de réécrire l'expression en fonction de l'hypothèse H. La flèche <- indique que l'on souhaite passer du membre de droite à celui de gauche et inversement pour ->. Coq va ensuite essayer de trouver un membre de l'expression qui correspond au terme de départ et va le remplacer par le terme d'arrivée.

* destruct n as [n1 | n2 | ...] eqn:E.

destruct permet de décomposer une variable en plusieurs cas de figure qui sont traités séparément. destruct fonctionne différemment selon le type de la variable utilisée. Avec les booléens ou d'autres types binaires, on peut se passer du as [...] car il n'y a par définition que deux valeurs que peut prendre la variable. Avec les entiers, on va généralement décomposer sous la forme as [| n'], autrement dit, on établit une pseudo-récurrence en vérifiant pour n = 0 et ensuite pour tout n' tel que n = n' + 1. Il ne s'agit cependant pas d'une vraie récurrence car il n'y a pas de lien entre n et n'.

==== Séparation des cas ====

Dans Coq, certaines commandes comme destruct occasionnent une séparation de l'expression en plusieurs cas. Pour identifier ces cas, il y a deux méthodes.

# Commencer chaque cas par une puce (-, + et * dans cet ordre)
# Délimiter un cas par des astérisque {}, ce qui permet de réinitialiser la hiérarchie des puces

== Preuve par récurrence, preuves à l'intérieur de preuves, preuves formelles et informelles ==

=== Preuve par récurrence ===

Bien que les tactiques mentionnées dans la partie précédente permettent de résoudre une grande partie des preuves, certains cas requièrent une attention plus particulière. Si la situation s'y prête, on peut notamment utiliser la récurrence avec la syntaxe suivante :

<pre lang="coq">Proof.
intros n. induction n as [| n' IHn']. (* On décompose n en un cas initial, généralement 0, et on introduit l'hypothèse que la proposition est vérifiée pour un palier arbitraire n'. *)
- (* Initialisation. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée pour le cas initial. *)
- (* Hérédité. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée à un niveau n' + 1 si elle est vérifiée pour n'. *)
Qed.</pre>

Ben que la récurrence soit une tactique puissante, il vaut mieux la réserver aux situations qui le nécessitent. Il est également nécessaire d'utiliser à un moment l'hypothèse d'hérédité avec rewrite. S'il est possible de compléter la preuve sans l'utiliser, une autre tactique aurait été probablement plus appropriée.

=== Preuves à l'intérieur de preuves ===

Parfois, il n'est pas possible de démontrer une équation telle quelle. Il faut passer par un lemme qui est introduit en Coq par l'instruction '''''assert'''''. Par exemple, la preuve servant à démontrer que <math>\forall n,m \in \mathbb{R}, (0 + n) * m = n * m</math> se structure comme tel :

<pre lang="Coq">Proof.
intros n m. (* On introduit les deux variables n et m *)
assert (H: 0 + n = n). (* On définit le lemme H qui dit que 0 + n = n *)
{ reflexivity. } (* On vérifie que H est vrai *)
rewrite -> H. (* On reformule l'équation initiale en remplaçant 0 + n par n, maintenant que l'on sait que les deux sont égaux *)
reflexivity. (* Les deux membres de l'équation sont alors identiques, la preuve est achevée *)
Qed.</pre>

=== Preuves formelles et informelles ===

Le principe d'une preuve est de convaincre le lecteur de sa véracité. Cependant, tous les lecteurs n'ont pas la même capacité de compréhension.

Par exemple, en langage mathématique, le théorème de Taylor à l'ordre n en a pourrait s'écrire :

<math>f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</math>

Cette écriture peut être lue aisément par un humain, mais pas par une machine. Cependant, si l'on écrit :

<pre lang="latex">f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</pre>

Un humain aurait du mal à lire cette ligne de code, mais si un interpréteur LaTeX la lit, il affiche l'équation précédente. Il existe donc plusieurs façons de présenter la même information en fonction du lecteur visé. Il en est de même pour les preuves sur Coq.

* Preuves formelles

Les preuves formelles sont celles que Coq peut comprendre facilement et qui n'est pas prévue pour être facilement comprise par un humain. Par exemple, la preuve formelle de l'associativité de l'addition est structurée comme suit :

<pre lang="coq">Proof. intros n m p. induction n as [| n' IHn']. reflexivity. simpl. rewrite -> IHn'. reflexivity. Qed.</pre>

Le code est réduit à l'essentiel, mais la clarté pour le lecteur humain est moindre.

* Preuves informelles

Les preuves informelles sont celles que Coq accepte et qu'un humain peut comprendre facilement. Par exemple, la preuve informelle de l'associativité de l'addition est structurée comme tel :

<pre lang="coq">Proof.
intros n m p. induction n as [| n' IHn'].
- (* n = 0 *)
reflexivity.
- (* n = S n' *)
simpl. rewrite -> IHn'. reflexivity.
Qed.</pre>

Ici, on a éclaté le code pour notamment séparer les deux cas étudiés lors de la récurrence et on a ajouté des commentaires. Coq interprète toujours le code, mais un lecteur humain peut davantage comprendre ce qui se passe.

== Listes, sacs de nombres et opérations sur ces types ==

=== Listes de nombres ===

Dans Coq, on peut définir une liste de nombres sous le type '''''natlist''''' de façon récursive. Une liste est composée soit de l'élément vide, soit de la concaténation d'un entier naturel et d'une autre liste. Parmi les différentes opérations que l'on peut exécuter sur les listes, on peut évoquer :

* Créer une liste de longueur déterminée composée d'un seul élément

<pre lang="coq">Fixpoint repeat (n count : nat) : natlist :=
match count with (* Si count vaut... *)
| O => nil (* ... 0, on ferme la liste avec l'élément nul *)
| S count' => n :: (repeat n count') (* ... count' + 1, on concatène le nombre avec la liste de longueur count' répétant ce nombre *)
end.</pre>

* Calculer la longueur d'une liste

<pre lang="coq">Fixpoint length (l:natlist) : nat :=
match l with
| nil => O (* Cas 1, la liste n'est composée que de l'élément nul, sa longueur est donc nulle *)
| h :: t => S (length t) (* Cas 2, la liste est composée de la concaténation d'un entier et d'une liste, sa longueur vaut donc 1 + la longueur de cette deuxième liste *)
end.</pre>

* Joindre deux listes

<pre lang="coq">Fixpoint app (l1 l2 : natlist) : natlist :=
match l1 with
| nil => l2 (* Si la première liste est vide, le résultat de la jonction est donc la seule deuxième liste *)
| h :: t => h :: (app t l2) (* Si la première liste est composée d'un entier et d'une liste, on concatène cet entier avec la jonction de la liste et de la deuxième liste *)
end.</pre>

* Définir la tête et la queue d'une liste

<pre lang="coq">Definition hd (default:nat) (l:natlist) : nat :=
match l with
| nil => default (* Si la liste est vide, on retourne le nombre défini par défaut, l'élément vide n'ayant pas de premier élément *)
| h :: t => h (* Si la liste est composée d'un entier et d'une liste, on retourne l'entier, celui-ci étant le premier élément *)
end.</pre>

<pre lang="coq">Definition tl (l:natlist) : natlist :=
match l with
| nil => nil (* Si la liste est vide, on retourne l'ensemble vide *)
| h :: t => t (* Si la liste est composée d'un entier et d'une liste, on retourne la liste *)
end.</pre>

=== Sacs de nombres ===

Un sac de nombres ressemble à une liste, à l'exception prêt qu'un même élément peut apparaître plusieurs fois. Mis à part ce détail, le type '''''bag''''' est défini comme une liste de nombres. Parmi les opérations possibles sur ce type, on peut citer :

* Compter le nombre d'occurrence d'un nombre au sein d'un sac

<pre lang="coq">Fixpoint count (v:nat) (s:bag) : nat :=
match s with
| nil => 0 (* Si la liste est vide, l'élément recherché ne peut pas apparaître *)
| h :: t => match h =? v with (* Si la liste est composée d'un entier et d'une liste, on compare l'entier avec l'élément recherché *)
| true => S (count v t) (* S'ils sont égaux, on continue la recherche sur le reste de la liste en ajoutant 1 au nombre d'occurrences *)
| false => count v t (* S'ils ne sont pas égaux, on continue la recherche sur le reste de la liste *)
end
end.</pre>

* Vérifier qu'un nombre appartient à un sac

<pre lang="coq">Fixpoint member (v:nat) (s:bag) : bool :=
match s with
| nil => false
| h :: t => match h =? v with
| true => true
| false => member v t
end
end.</pre>

* Retirer un ou toutes les occurrences d'un nombre dans un sac

<pre lang="coq">Fixpoint remove_one (v:nat) (s:bag) : bag :=
match s with
| nil => nil (* Si la liste est vide, on n'a plus rien à enlever *)
| h :: t => match h =? v with (* Similairement à count, si la liste est composée d'un entier et d'une liste, on compare l'entier à l'élément recherché *)
| true => t (* S'ils sont égaux, on retourne le reste de la liste, car on a enlevé la première occurrence d'un élément *)
| false => h :: remove_one v t (* S'ils ne sont pas égaux, on concatène l'entier avec le résultat de la recherche au sein de la liste restante *)
end
end.</pre>

remove_all et remove_one fonctionne exactement de la même manière, excepté que remove_all continue la recherche dans tous les cas.

<pre lang="coq">Fixpoint remove_all (v:nat) (s:bag) : bag :=
match s with
| nil => nil
| h :: t => match h =? v with
| true => remove_all v t
| false => h :: remove_all v t
end
end.</pre>

* Vérifier qu'un sac est inclus dans un deuxième sac

<pre lang="coq">Fixpoint subset (s1:bag) (s2:bag) : bool :=
match s1 with
| nil => true (* Si le sac de référence est vide, il est forcément inclus dans le deuxième sac *)
| h :: t => match (member h s2) with (* Si le sac de référence est composée d'un entier et d'une liste, on regarde si cet entier est présent dans le deuxième sac *)
| true => subset t (remove_one h s2) (* S'il est présent, on continue la recherche avec le reste du sac de référence est en retirant une occurrence de l'élément dans le deuxième sac *)
| false => false (* S'il n'est pas présent, alors le sac de référence n'est pas inclus dans le deuxième sac *)
end
end.</pre>

== Sources et annexes ==

'''Sources'''

* Software Foundations volume 1 [https://softwarefoundations.cis.upenn.edu/lf-current/index.html]

* Page Wikipédia de Coq [https://fr.wikipedia.org/wiki/Coq_(logiciel)]

'''Annexe'''

* Théorème des quatre couleurs [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_des_quatre_couleurs]

* Théorème de Feit-Thompson [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_de_Feit-Thompson]

* Compcert [http://compcert.inria.fr/]

* Iris Project [https://iris-project.org/]

* Software Foundations [https://softwarefoundations.cis.upenn.edu/]

* Verified Software Toolchain [https://vst.cs.princeton.edu/]

* FSCQ [http://css.csail.mit.edu/fscq/]

* Bedrock [http://plv.csail.mit.edu/bedrock/]

* CFML [https://www.chargueraud.org/softs/cfml/]

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-17T13:35:54Z

Dornel : /* Introduction */

== Introduction ==

Coq est un logiciel d'aide à la preuve mathématique développé par les équipes PI.R2 et Marelle d'Inria et l'équipe Systèmes Sûrs du Cnam. La première version a été publiée en 1984 et a été codée sous CAML.

Coq est fondé sur le calcul des constructions, une théorie concurrente à la théorie des ensembles de Zermelo-Fraenkel dont l'une des particularités est que les formules logiques sont vues comme des cas particuliers d'ensemble ou de types, tandis que les preuves dont des éléments de cet ensemble.

Parmi les théorèmes issus des mathématiques dont les preuves sont volumineuses et qui ont été démontrées à l'aide de Coq, on peut citer notamment :

* '''Théorème des quatre couleurs'''

Le théorème des quatre couleurs indique qu'il est possible en utilisant seulement quatre couleurs différentes de colorier n'importe quelle carte découpée en régions de sorte que deux régions ayant une frontière en commun ne soient pas de la même couleur. Le résultat fut initialement conjecturé en 1852, avec les deux premières preuves étant publiées en 1879 et 1880, celles-ci se révélant cependant fausses. La première preuve utilisant l'outil informatique date de 1976 et fut reprise et simplifiée par la suite. Enfin, en 2005, Georges Gonthier et Benjamin Werner ont réussi à formuler avec Coq une preuve formelle permettant à un ordinateur de complètement vérifier le théorème des quatre couleurs. À ce jour, aucune preuve qui ne fasse pas appel à un ordinateur n'a été découverte.

* '''Théorème de Feit-Thompson'''

Le théorème de Feit-Thompson énonce que tout groupe fini d'ordre impair est résoluble, ce qui équivaut à dire que tout groupe simple fini non commutatif est d'ordre pair. Le théorème fut conjecturé en 1911 par William Burnside et démontré en 1963 par Walter Feit et John Griggs Thompson. Une formalisation de la preuve en Coq a été achevée en 2012 par Georges Gonthier et son équipe du laboratoire commun Inria-Microsoft.

Coq sert également à la certification de logiciel. Parmi la multitude d'exemples, on peut mentionner :

* '''CompCert'''

CompCert est un projet ayant pour but de réaliser des compilateurs certifiés formellement. Ce projet développe notamment le compilateur CompCert C pour le langage C. Le projet est réalisé notamment en Coq.

* '''Iris Project'''

Iris Project est un logiciel de séparation logique simultanée d'ordre supérieure (''demander informations complémentaires'')

== Types, fonctions et preuves basiques ==

=== Déclaration de types ===

Pour définir un type sur Coq, une première méthode est l'induction. Cela consiste à utiliser les différents cas particuliers pour définir le cas général.
<pre lang="coq">Inductive day : Type :=
| monday
| tuesday
| wednesday
| thursday
| friday
| saturday
| sunday.</pre>

Ici, pour le type ''day'', on énumère les différentes valeurs que peut adopter le type, à savoir les jours de la semaine. Cette méthode permet notamment de définir des types dont l'ensemble de valeurs possibles est fini, comme les booléens ou les bits. Cependant, tenter de représenter les nombres avec cette méthode est contre-indiqué, car il faudrait un temps et une capacité de stockage disproportionnellement élevés.

Pour définir les nombres ou d'autres types dont l'ensemble de valeurs possibles est infini, il est possible de définir un type par récurrence.
<pre lang="coq">Inductive nat : Type:=
| O
| S (n : nat).</pre>

Dans ce cas-là, par exemple, on définit le type ''nat'' (correspondant aux entiers naturels) par un cas initial, ici 0, modélisé par la lettre O, et une hérédité, ici le fait que pour tout n ∈ ℕ, il existe un n' appartenant à ce même intervalle tel que n corresponde à S n'. L'écriture mathématique équivalente de cette définition est :
<math>\forall n > 0, \exists n' \geqslant 0, n = n' + 1</math>

Enfin, il est également possible avec Coq de créer un type utilisant un autre type pour sa définition. Ainsi, si l'on définit comme suit les teintes RGB d'une couleur :
<pre lang="coq">Inductive rgb : Type :=
| red
| green
| blue.</pre>
Il est possible de définir les composantes d'une couleur en utilisant le type ''rgb'' préalablement créé :
<pre lang="coq">Inductive color : Type :=
| black
| white
| primary (p : rgb).</pre>
Ainsi, ''color'' possède trois composantes, à savoir black, white et primary, cette dernière ayant elle-même trois composantes, red, green et blue.

=== Fonctions ===

Il y a plusieurs manières de définir une fonction dans Coq. La première est d'utiliser la commande '''''Definition''''' et de spécifier au cas par cas quel résultat la fonction retourne selon la valeur de la variable d'entrée.
 
Ainsi, en reprenant le type ''day'', on peut définir la fonction next_weekday comme suit :
<pre lang="coq">Definition next_weekday (d:day) : day :=
match d with
| monday => tuesday
| tuesday => wednesday
| wednesday => thursday
| thursday => friday
| friday => saturday
| saturday => sunday
| sunday => monday
end.</pre>
Dans cet exemple, on introduit le nom de la fonction, on indique le nom utilisé en son sein pour désigner la variable ainsi que son type, puis le type du résultat.
 
L'instruction ''match d with'' sert à analyser la valeur de la variable d. La liste qui suit signifie que pour telle valeur de d (par exemple wednesday), on retourne le résultat indiqué par la flèche (ici thursday). Enfin, la commande ''end'' permet de délimiter la fin de la fonction.

Cependant, il est également possible de ne retenir que certains cas et de retourner une même réponse pour tous les cas non vérifiés, dans la même veine qu'un ''else'' dans d'autres langages.
 
Par exemple, en supposant que l'on a défini précédemment un type ''bool'' qui ne peut prendre que true et false comme valeurs, on peut établir la fonction suivante :
<pre lang="coq">Definition isred (c : color) : bool :=
match c with
| black => false
| white => false
| primary red => true
| primary _ => false
end.</pre>
Ici, si l'on voulait écrire la fonction en Python, on aurait :
<pre lang="python">def isred(c) :
if c == black :
return False
elif c == white :
return False :
elif c == primary[red] :
return True
else :
return False</pre>
On remarque donc que le caractère _ signifie "dans tous les autres cas possibles", ce qui permet de ne retenir que les situations particulières et de généraliser le reste.

Une autre manière d'écrire une fonction est d'utiliser la commande '''''Fixpoint'''''. La différence majeure entre Fixpoint et Definition est la possibilité d'appeler la fonction récursivement avec Fixpoint.

Par exemple, une fonction pour définir si un entier naturel est pair s'écrit :
<pre lang="coq">Fixpoint evenb(n:nat) : bool :=
match n with
| 0 => true
| S 0 => false
| S (S n') => evenb n'</pre>

Cela signifie que pour tout entier n, trois cas de figure se présentent :
# <math> n = 0 \rightarrow n\ pair </math>
# <math> n = 1 \rightarrow n\ non\ pair </math>
# <math> \exists n', n = n' + 2 </math>
Dans le troisième cas, on réitère l'étude, mais avec n'.

Enfin, une troisième méthode pour définir une fonction est la commande '''''Theorem''''' qui permet, comme son nom l'indique, de définir un théorème, généralement sous la forme d'une égalité ou d'une implication. S'il s'agit d'une implication A -> B, A peut être utilisé comme hypothèse lors de la preuve.

=== Preuves simples ===

==== Structure générale ====

Dans Coq, la structure d'une preuve suit toujours la même structure :
<pre lang="coq">Proof. (* On indique le début de la preuve... *)
(* On insère ici toutes les instructions nécessaires... *)
Qed. (* Quod erat demonstrandum, équivalent latin de C.Q.F.D., signifie que la preuve est finie *)</pre>

==== Tactiques ====

Les tactiques sont des instructions pour aider Coq à résoudre une preuve.

* simpl.

simpl. permet, comme son nom l'indique, de simplifier une formule.

* reflexivity.

reflexivity. permet de vérifier si une égalité est du type a = a. Si la réflexivité de l'égalité est prouvée, alors la proposition est vraie. Cette instruction permet généralement d'achever une preuve.

* intros n.

intros. s'utilise en début de preuve pour introduire les variables présentes dans un théorème ou une hypothèse. S'il y a plusieurs variables à introduire, il faut les séparer par des espaces

* unfold f.

unfold f. permet de développer l'expression à étudier selon la fonction f.

* rewrite <- / -> H.

Permet de réécrire l'expression en fonction de l'hypothèse H. La flèche <- indique que l'on souhaite passer du membre de droite à celui de gauche et inversement pour ->. Coq va ensuite essayer de trouver un membre de l'expression qui correspond au terme de départ et va le remplacer par le terme d'arrivée.

* destruct n as [n1 | n2 | ...] eqn:E.

destruct permet de décomposer une variable en plusieurs cas de figure qui sont traités séparément. destruct fonctionne différemment selon le type de la variable utilisée. Avec les booléens ou d'autres types binaires, on peut se passer du as [...] car il n'y a par définition que deux valeurs que peut prendre la variable. Avec les entiers, on va généralement décomposer sous la forme as [| n'], autrement dit, on établit une pseudo-récurrence en vérifiant pour n = 0 et ensuite pour tout n' tel que n = n' + 1. Il ne s'agit cependant pas d'une vraie récurrence car il n'y a pas de lien entre n et n'.

==== Séparation des cas ====

Dans Coq, certaines commandes comme destruct occasionnent une séparation de l'expression en plusieurs cas. Pour identifier ces cas, il y a deux méthodes.

# Commencer chaque cas par une puce (-, + et * dans cet ordre)
# Délimiter un cas par des astérisque {}, ce qui permet de réinitialiser la hiérarchie des puces

== Preuve par récurrence, preuves à l'intérieur de preuves, preuves formelles et informelles ==

=== Preuve par récurrence ===

Bien que les tactiques mentionnées dans la partie précédente permettent de résoudre une grande partie des preuves, certains cas requièrent une attention plus particulière. Si la situation s'y prête, on peut notamment utiliser la récurrence avec la syntaxe suivante :

<pre lang="coq">Proof.
intros n. induction n as [| n' IHn']. (* On décompose n en un cas initial, généralement 0, et on introduit l'hypothèse que la proposition est vérifiée pour un palier arbitraire n'. *)
- (* Initialisation. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée pour le cas initial. *)
- (* Hérédité. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée à un niveau n' + 1 si elle est vérifiée pour n'. *)
Qed.</pre>

Ben que la récurrence soit une tactique puissante, il vaut mieux la réserver aux situations qui le nécessitent. Il est également nécessaire d'utiliser à un moment l'hypothèse d'hérédité avec rewrite. S'il est possible de compléter la preuve sans l'utiliser, une autre tactique aurait été probablement plus appropriée.

=== Preuves à l'intérieur de preuves ===

Parfois, il n'est pas possible de démontrer une équation telle quelle. Il faut passer par un lemme qui est introduit en Coq par l'instruction '''''assert'''''. Par exemple, la preuve servant à démontrer que <math>\forall n,m \in \mathbb{R}, (0 + n) * m = n * m</math> se structure comme tel :

<pre lang="Coq">Proof.
intros n m. (* On introduit les deux variables n et m *)
assert (H: 0 + n = n). (* On définit le lemme H qui dit que 0 + n = n *)
{ reflexivity. } (* On vérifie que H est vrai *)
rewrite -> H. (* On reformule l'équation initiale en remplaçant 0 + n par n, maintenant que l'on sait que les deux sont égaux *)
reflexivity. (* Les deux membres de l'équation sont alors identiques, la preuve est achevée *)
Qed.</pre>

=== Preuves formelles et informelles ===

Le principe d'une preuve est de convaincre le lecteur de sa véracité. Cependant, tous les lecteurs n'ont pas la même capacité de compréhension.

Par exemple, en langage mathématique, le théorème de Taylor à l'ordre n en a pourrait s'écrire :

<math>f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</math>

Cette écriture peut être lue aisément par un humain, mais pas par une machine. Cependant, si l'on écrit :

<pre lang="latex">f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</pre>

Un humain aurait du mal à lire cette ligne de code, mais si un interpréteur LaTeX la lit, il affiche l'équation précédente. Il existe donc plusieurs façons de présenter la même information en fonction du lecteur visé. Il en est de même pour les preuves sur Coq.

* Preuves formelles

Les preuves formelles sont celles que Coq peut comprendre facilement et qui n'est pas prévue pour être facilement comprise par un humain. Par exemple, la preuve formelle de l'associativité de l'addition est structurée comme suit :

<pre lang="coq">Proof. intros n m p. induction n as [| n' IHn']. reflexivity. simpl. rewrite -> IHn'. reflexivity. Qed.</pre>

Le code est réduit à l'essentiel, mais la clarté pour le lecteur humain est moindre.

* Preuves informelles

Les preuves informelles sont celles que Coq accepte et qu'un humain peut comprendre facilement. Par exemple, la preuve informelle de l'associativité de l'addition est structurée comme tel :

<pre lang="coq">Proof.
intros n m p. induction n as [| n' IHn'].
- (* n = 0 *)
reflexivity.
- (* n = S n' *)
simpl. rewrite -> IHn'. reflexivity.
Qed.</pre>

Ici, on a éclaté le code pour notamment séparer les deux cas étudiés lors de la récurrence et on a ajouté des commentaires. Coq interprète toujours le code, mais un lecteur humain peut davantage comprendre ce qui se passe.

== Listes, sacs de nombres et opérations sur ces types ==

=== Listes de nombres ===

Dans Coq, on peut définir une liste de nombres sous le type '''''natlist''''' de façon récursive. Une liste est composée soit de l'élément vide, soit de la concaténation d'un entier naturel et d'une autre liste. Parmi les différentes opérations que l'on peut exécuter sur les listes, on peut évoquer :

* Créer une liste de longueur déterminée composée d'un seul élément

<pre lang="coq">Fixpoint repeat (n count : nat) : natlist :=
match count with (* Si count vaut... *)
| O => nil (* ... 0, on ferme la liste avec l'élément nul *)
| S count' => n :: (repeat n count') (* ... count' + 1, on concatène le nombre avec la liste de longueur count' répétant ce nombre *)
end.</pre>

* Calculer la longueur d'une liste

<pre lang="coq">Fixpoint length (l:natlist) : nat :=
match l with
| nil => O (* Cas 1, la liste n'est composée que de l'élément nul, sa longueur est donc nulle *)
| h :: t => S (length t) (* Cas 2, la liste est composée de la concaténation d'un entier et d'une liste, sa longueur vaut donc 1 + la longueur de cette deuxième liste *)
end.</pre>

* Joindre deux listes

<pre lang="coq">Fixpoint app (l1 l2 : natlist) : natlist :=
match l1 with
| nil => l2 (* Si la première liste est vide, le résultat de la jonction est donc la seule deuxième liste *)
| h :: t => h :: (app t l2) (* Si la première liste est composée d'un entier et d'une liste, on concatène cet entier avec la jonction de la liste et de la deuxième liste *)
end.</pre>

* Définir la tête et la queue d'une liste

<pre lang="coq">Definition hd (default:nat) (l:natlist) : nat :=
match l with
| nil => default (* Si la liste est vide, on retourne le nombre défini par défaut, l'élément vide n'ayant pas de premier élément *)
| h :: t => h (* Si la liste est composée d'un entier et d'une liste, on retourne l'entier, celui-ci étant le premier élément *)
end.</pre>

<pre lang="coq">Definition tl (l:natlist) : natlist :=
match l with
| nil => nil (* Si la liste est vide, on retourne l'ensemble vide *)
| h :: t => t (* Si la liste est composée d'un entier et d'une liste, on retourne la liste *)
end.</pre>

=== Sacs de nombres ===

Un sac de nombres ressemble à une liste, à l'exception prêt qu'un même élément peut apparaître plusieurs fois. Mis à part ce détail, le type '''''bag''''' est défini comme une liste de nombres. Parmi les opérations possibles sur ce type, on peut citer :

* Compter le nombre d'occurrence d'un nombre au sein d'un sac

<pre lang="coq">Fixpoint count (v:nat) (s:bag) : nat :=
match s with
| nil => 0 (* Si la liste est vide, l'élément recherché ne peut pas apparaître *)
| h :: t => match h =? v with (* Si la liste est composée d'un entier et d'une liste, on compare l'entier avec l'élément recherché *)
| true => S (count v t) (* S'ils sont égaux, on continue la recherche sur le reste de la liste en ajoutant 1 au nombre d'occurrences *)
| false => count v t (* S'ils ne sont pas égaux, on continue la recherche sur le reste de la liste *)
end
end.</pre>

* Vérifier qu'un nombre appartient à un sac

<pre lang="coq">Fixpoint member (v:nat) (s:bag) : bool :=
match s with
| nil => false
| h :: t => match h =? v with
| true => true
| false => member v t
end
end.</pre>

* Retirer un ou toutes les occurrences d'un nombre dans un sac

<pre lang="coq">Fixpoint remove_one (v:nat) (s:bag) : bag :=
match s with
| nil => nil (* Si la liste est vide, on n'a plus rien à enlever *)
| h :: t => match h =? v with (* Similairement à count, si la liste est composée d'un entier et d'une liste, on compare l'entier à l'élément recherché *)
| true => t (* S'ils sont égaux, on retourne le reste de la liste, car on a enlevé la première occurrence d'un élément *)
| false => h :: remove_one v t (* S'ils ne sont pas égaux, on concatène l'entier avec le résultat de la recherche au sein de la liste restante *)
end
end.</pre>

remove_all et remove_one fonctionne exactement de la même manière, excepté que remove_all continue la recherche dans tous les cas.

<pre lang="coq">Fixpoint remove_all (v:nat) (s:bag) : bag :=
match s with
| nil => nil
| h :: t => match h =? v with
| true => remove_all v t
| false => h :: remove_all v t
end
end.</pre>

* Vérifier qu'un sac est inclus dans un deuxième sac

<pre lang="coq">Fixpoint subset (s1:bag) (s2:bag) : bool :=
match s1 with
| nil => true (* Si le sac de référence est vide, il est forcément inclus dans le deuxième sac *)
| h :: t => match (member h s2) with (* Si le sac de référence est composée d'un entier et d'une liste, on regarde si cet entier est présent dans le deuxième sac *)
| true => subset t (remove_one h s2) (* S'il est présent, on continue la recherche avec le reste du sac de référence est en retirant une occurrence de l'élément dans le deuxième sac *)
| false => false (* S'il n'est pas présent, alors le sac de référence n'est pas inclus dans le deuxième sac *)
end
end.</pre>

== Sources et annexes ==

'''Sources'''

* Software Foundations volume 1 [https://softwarefoundations.cis.upenn.edu/lf-current/index.html]

* Page Wikipédia de Coq [https://fr.wikipedia.org/wiki/Coq_(logiciel)]

'''Annexe'''

* Théorème des quatre couleurs [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_des_quatre_couleurs]

* Théorème de Feit-Thompson [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_de_Feit-Thompson]

* Compcert [http://compcert.inria.fr/]

* Iris Project [https://iris-project.org/]

* Software Foundations [https://softwarefoundations.cis.upenn.edu/]

* Verified Software Toolchain [https://vst.cs.princeton.edu/]

* FSCQ [http://css.csail.mit.edu/fscq/]

* Bedrock [http://plv.csail.mit.edu/bedrock/]

* CFML [https://www.chargueraud.org/softs/cfml/]

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-17T10:53:31Z

Dornel : /* Introduction */

== Introduction ==

Coq est un logiciel d'aide à la preuve mathématique développé par les équipes PI.R2 et Marelle d'Inria et l'équipe Systèmes Sûrs du Cnam. La première version a été publiée en 1984 et a été codée sous CAML.

Coq est fondé sur le calcul des constructions, une théorie concurrente à la théorie des ensembles de Zermelo-Fraenkel dont l'une des particularités est que les formules logiques sont vues comme des cas particuliers d'ensemble.

Parmi les théorèmes issus des mathématiques dont les preuves sont volumineuses et qui ont été démontrées à l'aide de Coq, on peut citer notamment :

* '''Théorème des quatre couleurs'''

Le théorème des quatre couleurs indique qu'il est possible en utilisant seulement quatre couleurs différentes de colorier n'importe quelle carte découpée en régions de sorte que deux régions ayant une frontière en commun ne soient pas de la même couleur. Le résultat fut initialement conjecturé en 1852, avec les deux premières preuves étant publiées en 1879 et 1880, celles-ci se révélant cependant fausses. La première preuve utilisant l'outil informatique date de 1976 et fut reprise et simplifiée par la suite. Enfin, en 2005, Georges Gonthier et Benjamin Werner ont réussi à formuler avec Coq une preuve formelle permettant à un ordinateur de complètement vérifier le théorème des quatre couleurs. À ce jour, aucune preuve qui ne fasse pas appel à un ordinateur n'a été découverte.

* '''Théorème de Feit-Thompson'''

Le théorème de Feit-Thompson énonce que tout groupe fini d'ordre impair est résoluble, ce qui équivaut à dire que tout groupe simple fini non commutatif est d'ordre pair. Le théorème fut conjecturé en 1911 par William Burnside et démontré en 1963 par Walter Feit et John Griggs Thompson. Une formalisation de la preuve en Coq a été achevée en 2012 par Georges Gonthier et son équipe du laboratoire commun Inria-Microsoft.

Coq sert également à la certification de logiciel. Parmi la multitude d'exemples, on peut mentionner :

* '''CompCert'''

CompCert est un projet ayant pour but de réaliser des compilateurs certifiés formellement. Ce projet développe notamment le compilateur CompCert C pour le langage C. Le projet est réalisé notamment en Coq.

* '''Iris Project'''

Iris Project est un logiciel de séparation logique simultanée d'ordre supérieure (''demander informations complémentaires'')

== Types, fonctions et preuves basiques ==

=== Déclaration de types ===

Pour définir un type sur Coq, une première méthode est l'induction. Cela consiste à utiliser les différents cas particuliers pour définir le cas général.
<pre lang="coq">Inductive day : Type :=
| monday
| tuesday
| wednesday
| thursday
| friday
| saturday
| sunday.</pre>

Ici, pour le type ''day'', on énumère les différentes valeurs que peut adopter le type, à savoir les jours de la semaine. Cette méthode permet notamment de définir des types dont l'ensemble de valeurs possibles est fini, comme les booléens ou les bits. Cependant, tenter de représenter les nombres avec cette méthode est contre-indiqué, car il faudrait un temps et une capacité de stockage disproportionnellement élevés.

Pour définir les nombres ou d'autres types dont l'ensemble de valeurs possibles est infini, il est possible de définir un type par récurrence.
<pre lang="coq">Inductive nat : Type:=
| O
| S (n : nat).</pre>

Dans ce cas-là, par exemple, on définit le type ''nat'' (correspondant aux entiers naturels) par un cas initial, ici 0, modélisé par la lettre O, et une hérédité, ici le fait que pour tout n ∈ ℕ, il existe un n' appartenant à ce même intervalle tel que n corresponde à S n'. L'écriture mathématique équivalente de cette définition est :
<math>\forall n > 0, \exists n' \geqslant 0, n = n' + 1</math>

Enfin, il est également possible avec Coq de créer un type utilisant un autre type pour sa définition. Ainsi, si l'on définit comme suit les teintes RGB d'une couleur :
<pre lang="coq">Inductive rgb : Type :=
| red
| green
| blue.</pre>
Il est possible de définir les composantes d'une couleur en utilisant le type ''rgb'' préalablement créé :
<pre lang="coq">Inductive color : Type :=
| black
| white
| primary (p : rgb).</pre>
Ainsi, ''color'' possède trois composantes, à savoir black, white et primary, cette dernière ayant elle-même trois composantes, red, green et blue.

=== Fonctions ===

Il y a plusieurs manières de définir une fonction dans Coq. La première est d'utiliser la commande '''''Definition''''' et de spécifier au cas par cas quel résultat la fonction retourne selon la valeur de la variable d'entrée.
 
Ainsi, en reprenant le type ''day'', on peut définir la fonction next_weekday comme suit :
<pre lang="coq">Definition next_weekday (d:day) : day :=
match d with
| monday => tuesday
| tuesday => wednesday
| wednesday => thursday
| thursday => friday
| friday => saturday
| saturday => sunday
| sunday => monday
end.</pre>
Dans cet exemple, on introduit le nom de la fonction, on indique le nom utilisé en son sein pour désigner la variable ainsi que son type, puis le type du résultat.
 
L'instruction ''match d with'' sert à analyser la valeur de la variable d. La liste qui suit signifie que pour telle valeur de d (par exemple wednesday), on retourne le résultat indiqué par la flèche (ici thursday). Enfin, la commande ''end'' permet de délimiter la fin de la fonction.

Cependant, il est également possible de ne retenir que certains cas et de retourner une même réponse pour tous les cas non vérifiés, dans la même veine qu'un ''else'' dans d'autres langages.
 
Par exemple, en supposant que l'on a défini précédemment un type ''bool'' qui ne peut prendre que true et false comme valeurs, on peut établir la fonction suivante :
<pre lang="coq">Definition isred (c : color) : bool :=
match c with
| black => false
| white => false
| primary red => true
| primary _ => false
end.</pre>
Ici, si l'on voulait écrire la fonction en Python, on aurait :
<pre lang="python">def isred(c) :
if c == black :
return False
elif c == white :
return False :
elif c == primary[red] :
return True
else :
return False</pre>
On remarque donc que le caractère _ signifie "dans tous les autres cas possibles", ce qui permet de ne retenir que les situations particulières et de généraliser le reste.

Une autre manière d'écrire une fonction est d'utiliser la commande '''''Fixpoint'''''. La différence majeure entre Fixpoint et Definition est la possibilité d'appeler la fonction récursivement avec Fixpoint.

Par exemple, une fonction pour définir si un entier naturel est pair s'écrit :
<pre lang="coq">Fixpoint evenb(n:nat) : bool :=
match n with
| 0 => true
| S 0 => false
| S (S n') => evenb n'</pre>

Cela signifie que pour tout entier n, trois cas de figure se présentent :
# <math> n = 0 \rightarrow n\ pair </math>
# <math> n = 1 \rightarrow n\ non\ pair </math>
# <math> \exists n', n = n' + 2 </math>
Dans le troisième cas, on réitère l'étude, mais avec n'.

Enfin, une troisième méthode pour définir une fonction est la commande '''''Theorem''''' qui permet, comme son nom l'indique, de définir un théorème, généralement sous la forme d'une égalité ou d'une implication. S'il s'agit d'une implication A -> B, A peut être utilisé comme hypothèse lors de la preuve.

=== Preuves simples ===

==== Structure générale ====

Dans Coq, la structure d'une preuve suit toujours la même structure :
<pre lang="coq">Proof. (* On indique le début de la preuve... *)
(* On insère ici toutes les instructions nécessaires... *)
Qed. (* Quod erat demonstrandum, équivalent latin de C.Q.F.D., signifie que la preuve est finie *)</pre>

==== Tactiques ====

Les tactiques sont des instructions pour aider Coq à résoudre une preuve.

* simpl.

simpl. permet, comme son nom l'indique, de simplifier une formule.

* reflexivity.

reflexivity. permet de vérifier si une égalité est du type a = a. Si la réflexivité de l'égalité est prouvée, alors la proposition est vraie. Cette instruction permet généralement d'achever une preuve.

* intros n.

intros. s'utilise en début de preuve pour introduire les variables présentes dans un théorème ou une hypothèse. S'il y a plusieurs variables à introduire, il faut les séparer par des espaces

* unfold f.

unfold f. permet de développer l'expression à étudier selon la fonction f.

* rewrite <- / -> H.

Permet de réécrire l'expression en fonction de l'hypothèse H. La flèche <- indique que l'on souhaite passer du membre de droite à celui de gauche et inversement pour ->. Coq va ensuite essayer de trouver un membre de l'expression qui correspond au terme de départ et va le remplacer par le terme d'arrivée.

* destruct n as [n1 | n2 | ...] eqn:E.

destruct permet de décomposer une variable en plusieurs cas de figure qui sont traités séparément. destruct fonctionne différemment selon le type de la variable utilisée. Avec les booléens ou d'autres types binaires, on peut se passer du as [...] car il n'y a par définition que deux valeurs que peut prendre la variable. Avec les entiers, on va généralement décomposer sous la forme as [| n'], autrement dit, on établit une pseudo-récurrence en vérifiant pour n = 0 et ensuite pour tout n' tel que n = n' + 1. Il ne s'agit cependant pas d'une vraie récurrence car il n'y a pas de lien entre n et n'.

==== Séparation des cas ====

Dans Coq, certaines commandes comme destruct occasionnent une séparation de l'expression en plusieurs cas. Pour identifier ces cas, il y a deux méthodes.

# Commencer chaque cas par une puce (-, + et * dans cet ordre)
# Délimiter un cas par des astérisque {}, ce qui permet de réinitialiser la hiérarchie des puces

== Preuve par récurrence, preuves à l'intérieur de preuves, preuves formelles et informelles ==

=== Preuve par récurrence ===

Bien que les tactiques mentionnées dans la partie précédente permettent de résoudre une grande partie des preuves, certains cas requièrent une attention plus particulière. Si la situation s'y prête, on peut notamment utiliser la récurrence avec la syntaxe suivante :

<pre lang="coq">Proof.
intros n. induction n as [| n' IHn']. (* On décompose n en un cas initial, généralement 0, et on introduit l'hypothèse que la proposition est vérifiée pour un palier arbitraire n'. *)
- (* Initialisation. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée pour le cas initial. *)
- (* Hérédité. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée à un niveau n' + 1 si elle est vérifiée pour n'. *)
Qed.</pre>

Ben que la récurrence soit une tactique puissante, il vaut mieux la réserver aux situations qui le nécessitent. Il est également nécessaire d'utiliser à un moment l'hypothèse d'hérédité avec rewrite. S'il est possible de compléter la preuve sans l'utiliser, une autre tactique aurait été probablement plus appropriée.

=== Preuves à l'intérieur de preuves ===

Parfois, il n'est pas possible de démontrer une équation telle quelle. Il faut passer par un lemme qui est introduit en Coq par l'instruction '''''assert'''''. Par exemple, la preuve servant à démontrer que <math>\forall n,m \in \mathbb{R}, (0 + n) * m = n * m</math> se structure comme tel :

<pre lang="Coq">Proof.
intros n m. (* On introduit les deux variables n et m *)
assert (H: 0 + n = n). (* On définit le lemme H qui dit que 0 + n = n *)
{ reflexivity. } (* On vérifie que H est vrai *)
rewrite -> H. (* On reformule l'équation initiale en remplaçant 0 + n par n, maintenant que l'on sait que les deux sont égaux *)
reflexivity. (* Les deux membres de l'équation sont alors identiques, la preuve est achevée *)
Qed.</pre>

=== Preuves formelles et informelles ===

Le principe d'une preuve est de convaincre le lecteur de sa véracité. Cependant, tous les lecteurs n'ont pas la même capacité de compréhension.

Par exemple, en langage mathématique, le théorème de Taylor à l'ordre n en a pourrait s'écrire :

<math>f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</math>

Cette écriture peut être lue aisément par un humain, mais pas par une machine. Cependant, si l'on écrit :

<pre lang="latex">f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</pre>

Un humain aurait du mal à lire cette ligne de code, mais si un interpréteur LaTeX la lit, il affiche l'équation précédente. Il existe donc plusieurs façons de présenter la même information en fonction du lecteur visé. Il en est de même pour les preuves sur Coq.

* Preuves formelles

Les preuves formelles sont celles que Coq peut comprendre facilement et qui n'est pas prévue pour être facilement comprise par un humain. Par exemple, la preuve formelle de l'associativité de l'addition est structurée comme suit :

<pre lang="coq">Proof. intros n m p. induction n as [| n' IHn']. reflexivity. simpl. rewrite -> IHn'. reflexivity. Qed.</pre>

Le code est réduit à l'essentiel, mais la clarté pour le lecteur humain est moindre.

* Preuves informelles

Les preuves informelles sont celles que Coq accepte et qu'un humain peut comprendre facilement. Par exemple, la preuve informelle de l'associativité de l'addition est structurée comme tel :

<pre lang="coq">Proof.
intros n m p. induction n as [| n' IHn'].
- (* n = 0 *)
reflexivity.
- (* n = S n' *)
simpl. rewrite -> IHn'. reflexivity.
Qed.</pre>

Ici, on a éclaté le code pour notamment séparer les deux cas étudiés lors de la récurrence et on a ajouté des commentaires. Coq interprète toujours le code, mais un lecteur humain peut davantage comprendre ce qui se passe.

== Listes, sacs de nombres et opérations sur ces types ==

=== Listes de nombres ===

Dans Coq, on peut définir une liste de nombres sous le type '''''natlist''''' de façon récursive. Une liste est composée soit de l'élément vide, soit de la concaténation d'un entier naturel et d'une autre liste. Parmi les différentes opérations que l'on peut exécuter sur les listes, on peut évoquer :

* Créer une liste de longueur déterminée composée d'un seul élément

<pre lang="coq">Fixpoint repeat (n count : nat) : natlist :=
match count with (* Si count vaut... *)
| O => nil (* ... 0, on ferme la liste avec l'élément nul *)
| S count' => n :: (repeat n count') (* ... count' + 1, on concatène le nombre avec la liste de longueur count' répétant ce nombre *)
end.</pre>

* Calculer la longueur d'une liste

<pre lang="coq">Fixpoint length (l:natlist) : nat :=
match l with
| nil => O (* Cas 1, la liste n'est composée que de l'élément nul, sa longueur est donc nulle *)
| h :: t => S (length t) (* Cas 2, la liste est composée de la concaténation d'un entier et d'une liste, sa longueur vaut donc 1 + la longueur de cette deuxième liste *)
end.</pre>

* Joindre deux listes

<pre lang="coq">Fixpoint app (l1 l2 : natlist) : natlist :=
match l1 with
| nil => l2 (* Si la première liste est vide, le résultat de la jonction est donc la seule deuxième liste *)
| h :: t => h :: (app t l2) (* Si la première liste est composée d'un entier et d'une liste, on concatène cet entier avec la jonction de la liste et de la deuxième liste *)
end.</pre>

* Définir la tête et la queue d'une liste

<pre lang="coq">Definition hd (default:nat) (l:natlist) : nat :=
match l with
| nil => default (* Si la liste est vide, on retourne le nombre défini par défaut, l'élément vide n'ayant pas de premier élément *)
| h :: t => h (* Si la liste est composée d'un entier et d'une liste, on retourne l'entier, celui-ci étant le premier élément *)
end.</pre>

<pre lang="coq">Definition tl (l:natlist) : natlist :=
match l with
| nil => nil (* Si la liste est vide, on retourne l'ensemble vide *)
| h :: t => t (* Si la liste est composée d'un entier et d'une liste, on retourne la liste *)
end.</pre>

=== Sacs de nombres ===

Un sac de nombres ressemble à une liste, à l'exception prêt qu'un même élément peut apparaître plusieurs fois. Mis à part ce détail, le type '''''bag''''' est défini comme une liste de nombres. Parmi les opérations possibles sur ce type, on peut citer :

* Compter le nombre d'occurrence d'un nombre au sein d'un sac

<pre lang="coq">Fixpoint count (v:nat) (s:bag) : nat :=
match s with
| nil => 0 (* Si la liste est vide, l'élément recherché ne peut pas apparaître *)
| h :: t => match h =? v with (* Si la liste est composée d'un entier et d'une liste, on compare l'entier avec l'élément recherché *)
| true => S (count v t) (* S'ils sont égaux, on continue la recherche sur le reste de la liste en ajoutant 1 au nombre d'occurrences *)
| false => count v t (* S'ils ne sont pas égaux, on continue la recherche sur le reste de la liste *)
end
end.</pre>

* Vérifier qu'un nombre appartient à un sac

<pre lang="coq">Fixpoint member (v:nat) (s:bag) : bool :=
match s with
| nil => false
| h :: t => match h =? v with
| true => true
| false => member v t
end
end.</pre>

* Retirer un ou toutes les occurrences d'un nombre dans un sac

<pre lang="coq">Fixpoint remove_one (v:nat) (s:bag) : bag :=
match s with
| nil => nil (* Si la liste est vide, on n'a plus rien à enlever *)
| h :: t => match h =? v with (* Similairement à count, si la liste est composée d'un entier et d'une liste, on compare l'entier à l'élément recherché *)
| true => t (* S'ils sont égaux, on retourne le reste de la liste, car on a enlevé la première occurrence d'un élément *)
| false => h :: remove_one v t (* S'ils ne sont pas égaux, on concatène l'entier avec le résultat de la recherche au sein de la liste restante *)
end
end.</pre>

remove_all et remove_one fonctionne exactement de la même manière, excepté que remove_all continue la recherche dans tous les cas.

<pre lang="coq">Fixpoint remove_all (v:nat) (s:bag) : bag :=
match s with
| nil => nil
| h :: t => match h =? v with
| true => remove_all v t
| false => h :: remove_all v t
end
end.</pre>

* Vérifier qu'un sac est inclus dans un deuxième sac

<pre lang="coq">Fixpoint subset (s1:bag) (s2:bag) : bool :=
match s1 with
| nil => true (* Si le sac de référence est vide, il est forcément inclus dans le deuxième sac *)
| h :: t => match (member h s2) with (* Si le sac de référence est composée d'un entier et d'une liste, on regarde si cet entier est présent dans le deuxième sac *)
| true => subset t (remove_one h s2) (* S'il est présent, on continue la recherche avec le reste du sac de référence est en retirant une occurrence de l'élément dans le deuxième sac *)
| false => false (* S'il n'est pas présent, alors le sac de référence n'est pas inclus dans le deuxième sac *)
end
end.</pre>

== Sources et annexes ==

'''Sources'''

* Software Foundations volume 1 [https://softwarefoundations.cis.upenn.edu/lf-current/index.html]

* Page Wikipédia de Coq [https://fr.wikipedia.org/wiki/Coq_(logiciel)]

'''Annexe'''

* Théorème des quatre couleurs [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_des_quatre_couleurs]

* Théorème de Feit-Thompson [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_de_Feit-Thompson]

* Compcert [http://compcert.inria.fr/]

* Iris Project [https://iris-project.org/]

* Software Foundations [https://softwarefoundations.cis.upenn.edu/]

* Verified Software Toolchain [https://vst.cs.princeton.edu/]

* FSCQ [http://css.csail.mit.edu/fscq/]

* Bedrock [http://plv.csail.mit.edu/bedrock/]

* CFML [https://www.chargueraud.org/softs/cfml/]

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-11T13:45:19Z

Dornel : /* Preuves formelles et informelles */

== Introduction ==

Coq est un logiciel d'aide à la preuve mathématique développé par les équipes PI.R2 et Marelle d'Inria et l'équipe Systèmes Sûrs du Cnam. La première version a été publiée en 1984 et a été codée sous CAML.

Coq est fondé sur le calcul des constructions, une théorie concurrente à la théorie des ensembles de Zermelo-Fraenkel dont l'une des particularités est que les preuves sont au même niveau que les fonctions.

Parmi les théorèmes issus des mathématiques dont les preuves sont volumineuses et qui ont été démontrées à l'aide de Coq, on peut citer notamment :

* '''Théorème des quatre couleurs'''

Le théorème des quatre couleurs indique qu'il est possible en utilisant seulement quatre couleurs différentes de colorier n'importe quelle carte découpée en régions de sorte que deux régions ayant une frontière en commun ne soient pas de la même couleur. Le résultat fut initialement conjecturé en 1852, avec les deux premières preuves étant publiées en 1879 et 1880, celles-ci se révélant cependant fausses. La première preuve utilisant l'outil informatique date de 1976 et fut reprise et simplifiée par la suite. Enfin, en 2005, Georges Gonthier et Benjamin Werner ont réussi à formuler avec Coq une preuve formelle permettant à un ordinateur de complètement vérifier le théorème des quatre couleurs. À ce jour, aucune preuve qui ne fasse pas appel à un ordinateur n'a été découverte.

* '''Théorème de Feit-Thompson'''

Le théorème de Feit-Thompson énonce que tout groupe fini d'ordre impair est résoluble, ce qui équivaut à dire que tout groupe simple fini non commutatif est d'ordre pair. Le théorème fut conjecturé en 1911 par William Burnside et démontré en 1963 par Walter Feit et John Griggs Thompson. Une formalisation de la preuve en Coq a été achevée en 2012 par Georges Gonthier et son équipe du laboratoire commun Inria-Microsoft.

Coq sert également à la certification de logiciel. Parmi la multitude d'exemples, on peut mentionner :

* '''CompCert'''

CompCert est un projet ayant pour but de réaliser des compilateurs certifiés formellement. Ce projet développe notamment le compilateur CompCert C pour le langage C. Le projet est réalisé notamment en Coq.

* '''Iris Project'''

Iris Project est un logiciel de séparation logique simultanée d'ordre supérieure (''demander informations complémentaires'')

== Types, fonctions et preuves basiques ==

=== Déclaration de types ===

Pour définir un type sur Coq, une première méthode est l'induction. Cela consiste à utiliser les différents cas particuliers pour définir le cas général.
<pre lang="coq">Inductive day : Type :=
| monday
| tuesday
| wednesday
| thursday
| friday
| saturday
| sunday.</pre>

Ici, pour le type ''day'', on énumère les différentes valeurs que peut adopter le type, à savoir les jours de la semaine. Cette méthode permet notamment de définir des types dont l'ensemble de valeurs possibles est fini, comme les booléens ou les bits. Cependant, tenter de représenter les nombres avec cette méthode est contre-indiqué, car il faudrait un temps et une capacité de stockage disproportionnellement élevés.

Pour définir les nombres ou d'autres types dont l'ensemble de valeurs possibles est infini, il est possible de définir un type par récurrence.
<pre lang="coq">Inductive nat : Type:=
| O
| S (n : nat).</pre>

Dans ce cas-là, par exemple, on définit le type ''nat'' (correspondant aux entiers naturels) par un cas initial, ici 0, modélisé par la lettre O, et une hérédité, ici le fait que pour tout n ∈ ℕ, il existe un n' appartenant à ce même intervalle tel que n corresponde à S n'. L'écriture mathématique équivalente de cette définition est :
<math>\forall n > 0, \exists n' \geqslant 0, n = n' + 1</math>

Enfin, il est également possible avec Coq de créer un type utilisant un autre type pour sa définition. Ainsi, si l'on définit comme suit les teintes RGB d'une couleur :
<pre lang="coq">Inductive rgb : Type :=
| red
| green
| blue.</pre>
Il est possible de définir les composantes d'une couleur en utilisant le type ''rgb'' préalablement créé :
<pre lang="coq">Inductive color : Type :=
| black
| white
| primary (p : rgb).</pre>
Ainsi, ''color'' possède trois composantes, à savoir black, white et primary, cette dernière ayant elle-même trois composantes, red, green et blue.

=== Fonctions ===

Il y a plusieurs manières de définir une fonction dans Coq. La première est d'utiliser la commande '''''Definition''''' et de spécifier au cas par cas quel résultat la fonction retourne selon la valeur de la variable d'entrée.
 
Ainsi, en reprenant le type ''day'', on peut définir la fonction next_weekday comme suit :
<pre lang="coq">Definition next_weekday (d:day) : day :=
match d with
| monday => tuesday
| tuesday => wednesday
| wednesday => thursday
| thursday => friday
| friday => saturday
| saturday => sunday
| sunday => monday
end.</pre>
Dans cet exemple, on introduit le nom de la fonction, on indique le nom utilisé en son sein pour désigner la variable ainsi que son type, puis le type du résultat.
 
L'instruction ''match d with'' sert à analyser la valeur de la variable d. La liste qui suit signifie que pour telle valeur de d (par exemple wednesday), on retourne le résultat indiqué par la flèche (ici thursday). Enfin, la commande ''end'' permet de délimiter la fin de la fonction.

Cependant, il est également possible de ne retenir que certains cas et de retourner une même réponse pour tous les cas non vérifiés, dans la même veine qu'un ''else'' dans d'autres langages.
 
Par exemple, en supposant que l'on a défini précédemment un type ''bool'' qui ne peut prendre que true et false comme valeurs, on peut établir la fonction suivante :
<pre lang="coq">Definition isred (c : color) : bool :=
match c with
| black => false
| white => false
| primary red => true
| primary _ => false
end.</pre>
Ici, si l'on voulait écrire la fonction en Python, on aurait :
<pre lang="python">def isred(c) :
if c == black :
return False
elif c == white :
return False :
elif c == primary[red] :
return True
else :
return False</pre>
On remarque donc que le caractère _ signifie "dans tous les autres cas possibles", ce qui permet de ne retenir que les situations particulières et de généraliser le reste.

Une autre manière d'écrire une fonction est d'utiliser la commande '''''Fixpoint'''''. La différence majeure entre Fixpoint et Definition est la possibilité d'appeler la fonction récursivement avec Fixpoint.

Par exemple, une fonction pour définir si un entier naturel est pair s'écrit :
<pre lang="coq">Fixpoint evenb(n:nat) : bool :=
match n with
| 0 => true
| S 0 => false
| S (S n') => evenb n'</pre>

Cela signifie que pour tout entier n, trois cas de figure se présentent :
# <math> n = 0 \rightarrow n\ pair </math>
# <math> n = 1 \rightarrow n\ non\ pair </math>
# <math> \exists n', n = n' + 2 </math>
Dans le troisième cas, on réitère l'étude, mais avec n'.

Enfin, une troisième méthode pour définir une fonction est la commande '''''Theorem''''' qui permet, comme son nom l'indique, de définir un théorème, généralement sous la forme d'une égalité ou d'une implication. S'il s'agit d'une implication A -> B, A peut être utilisé comme hypothèse lors de la preuve.

=== Preuves simples ===

==== Structure générale ====

Dans Coq, la structure d'une preuve suit toujours la même structure :
<pre lang="coq">Proof. (* On indique le début de la preuve... *)
(* On insère ici toutes les instructions nécessaires... *)
Qed. (* Quod erat demonstrandum, équivalent latin de C.Q.F.D., signifie que la preuve est finie *)</pre>

==== Tactiques ====

Les tactiques sont des instructions pour aider Coq à résoudre une preuve.

* simpl.

simpl. permet, comme son nom l'indique, de simplifier une formule.

* reflexivity.

reflexivity. permet de vérifier si une égalité est du type a = a. Si la réflexivité de l'égalité est prouvée, alors la proposition est vraie. Cette instruction permet généralement d'achever une preuve.

* intros n.

intros. s'utilise en début de preuve pour introduire les variables présentes dans un théorème ou une hypothèse. S'il y a plusieurs variables à introduire, il faut les séparer par des espaces

* unfold f.

unfold f. permet de développer l'expression à étudier selon la fonction f.

* rewrite <- / -> H.

Permet de réécrire l'expression en fonction de l'hypothèse H. La flèche <- indique que l'on souhaite passer du membre de droite à celui de gauche et inversement pour ->. Coq va ensuite essayer de trouver un membre de l'expression qui correspond au terme de départ et va le remplacer par le terme d'arrivée.

* destruct n as [n1 | n2 | ...] eqn:E.

destruct permet de décomposer une variable en plusieurs cas de figure qui sont traités séparément. destruct fonctionne différemment selon le type de la variable utilisée. Avec les booléens ou d'autres types binaires, on peut se passer du as [...] car il n'y a par définition que deux valeurs que peut prendre la variable. Avec les entiers, on va généralement décomposer sous la forme as [| n'], autrement dit, on établit une pseudo-récurrence en vérifiant pour n = 0 et ensuite pour tout n' tel que n = n' + 1. Il ne s'agit cependant pas d'une vraie récurrence car il n'y a pas de lien entre n et n'.

==== Séparation des cas ====

Dans Coq, certaines commandes comme destruct occasionnent une séparation de l'expression en plusieurs cas. Pour identifier ces cas, il y a deux méthodes.

# Commencer chaque cas par une puce (-, + et * dans cet ordre)
# Délimiter un cas par des astérisque {}, ce qui permet de réinitialiser la hiérarchie des puces

== Preuve par récurrence, preuves à l'intérieur de preuves, preuves formelles et informelles ==

=== Preuve par récurrence ===

Bien que les tactiques mentionnées dans la partie précédente permettent de résoudre une grande partie des preuves, certains cas requièrent une attention plus particulière. Si la situation s'y prête, on peut notamment utiliser la récurrence avec la syntaxe suivante :

<pre lang="coq">Proof.
intros n. induction n as [| n' IHn']. (* On décompose n en un cas initial, généralement 0, et on introduit l'hypothèse que la proposition est vérifiée pour un palier arbitraire n'. *)
- (* Initialisation. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée pour le cas initial. *)
- (* Hérédité. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée à un niveau n' + 1 si elle est vérifiée pour n'. *)
Qed.</pre>

Ben que la récurrence soit une tactique puissante, il vaut mieux la réserver aux situations qui le nécessitent. Il est également nécessaire d'utiliser à un moment l'hypothèse d'hérédité avec rewrite. S'il est possible de compléter la preuve sans l'utiliser, une autre tactique aurait été probablement plus appropriée.

=== Preuves à l'intérieur de preuves ===

Parfois, il n'est pas possible de démontrer une équation telle quelle. Il faut passer par un lemme qui est introduit en Coq par l'instruction '''''assert'''''. Par exemple, la preuve servant à démontrer que <math>\forall n,m \in \mathbb{R}, (0 + n) * m = n * m</math> se structure comme tel :

<pre lang="Coq">Proof.
intros n m. (* On introduit les deux variables n et m *)
assert (H: 0 + n = n). (* On définit le lemme H qui dit que 0 + n = n *)
{ reflexivity. } (* On vérifie que H est vrai *)
rewrite -> H. (* On reformule l'équation initiale en remplaçant 0 + n par n, maintenant que l'on sait que les deux sont égaux *)
reflexivity. (* Les deux membres de l'équation sont alors identiques, la preuve est achevée *)
Qed.</pre>

=== Preuves formelles et informelles ===

Le principe d'une preuve est de convaincre le lecteur de sa véracité. Cependant, tous les lecteurs n'ont pas la même capacité de compréhension.

Par exemple, en langage mathématique, le théorème de Taylor à l'ordre n en a pourrait s'écrire :

<math>f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</math>

Cette écriture peut être lue aisément par un humain, mais pas par une machine. Cependant, si l'on écrit :

<pre lang="latex">f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</pre>

Un humain aurait du mal à lire cette ligne de code, mais si un interpréteur LaTeX la lit, il affiche l'équation précédente. Il existe donc plusieurs façons de présenter la même information en fonction du lecteur visé. Il en est de même pour les preuves sur Coq.

* Preuves formelles

Les preuves formelles sont celles que Coq peut comprendre facilement et qui n'est pas prévue pour être facilement comprise par un humain. Par exemple, la preuve formelle de l'associativité de l'addition est structurée comme suit :

<pre lang="coq">Proof. intros n m p. induction n as [| n' IHn']. reflexivity. simpl. rewrite -> IHn'. reflexivity. Qed.</pre>

Le code est réduit à l'essentiel, mais la clarté pour le lecteur humain est moindre.

* Preuves informelles

Les preuves informelles sont celles que Coq accepte et qu'un humain peut comprendre facilement. Par exemple, la preuve informelle de l'associativité de l'addition est structurée comme tel :

<pre lang="coq">Proof.
intros n m p. induction n as [| n' IHn'].
- (* n = 0 *)
reflexivity.
- (* n = S n' *)
simpl. rewrite -> IHn'. reflexivity.
Qed.</pre>

Ici, on a éclaté le code pour notamment séparer les deux cas étudiés lors de la récurrence et on a ajouté des commentaires. Coq interprète toujours le code, mais un lecteur humain peut davantage comprendre ce qui se passe.

== Listes, sacs de nombres et opérations sur ces types ==

=== Listes de nombres ===

Dans Coq, on peut définir une liste de nombres sous le type '''''natlist''''' de façon récursive. Une liste est composée soit de l'élément vide, soit de la concaténation d'un entier naturel et d'une autre liste. Parmi les différentes opérations que l'on peut exécuter sur les listes, on peut évoquer :

* Créer une liste de longueur déterminée composée d'un seul élément

<pre lang="coq">Fixpoint repeat (n count : nat) : natlist :=
match count with (* Si count vaut... *)
| O => nil (* ... 0, on ferme la liste avec l'élément nul *)
| S count' => n :: (repeat n count') (* ... count' + 1, on concatène le nombre avec la liste de longueur count' répétant ce nombre *)
end.</pre>

* Calculer la longueur d'une liste

<pre lang="coq">Fixpoint length (l:natlist) : nat :=
match l with
| nil => O (* Cas 1, la liste n'est composée que de l'élément nul, sa longueur est donc nulle *)
| h :: t => S (length t) (* Cas 2, la liste est composée de la concaténation d'un entier et d'une liste, sa longueur vaut donc 1 + la longueur de cette deuxième liste *)
end.</pre>

* Joindre deux listes

<pre lang="coq">Fixpoint app (l1 l2 : natlist) : natlist :=
match l1 with
| nil => l2 (* Si la première liste est vide, le résultat de la jonction est donc la seule deuxième liste *)
| h :: t => h :: (app t l2) (* Si la première liste est composée d'un entier et d'une liste, on concatène cet entier avec la jonction de la liste et de la deuxième liste *)
end.</pre>

* Définir la tête et la queue d'une liste

<pre lang="coq">Definition hd (default:nat) (l:natlist) : nat :=
match l with
| nil => default (* Si la liste est vide, on retourne le nombre défini par défaut, l'élément vide n'ayant pas de premier élément *)
| h :: t => h (* Si la liste est composée d'un entier et d'une liste, on retourne l'entier, celui-ci étant le premier élément *)
end.</pre>

<pre lang="coq">Definition tl (l:natlist) : natlist :=
match l with
| nil => nil (* Si la liste est vide, on retourne l'ensemble vide *)
| h :: t => t (* Si la liste est composée d'un entier et d'une liste, on retourne la liste *)
end.</pre>

=== Sacs de nombres ===

Un sac de nombres ressemble à une liste, à l'exception prêt qu'un même élément peut apparaître plusieurs fois. Mis à part ce détail, le type '''''bag''''' est défini comme une liste de nombres. Parmi les opérations possibles sur ce type, on peut citer :

* Compter le nombre d'occurrence d'un nombre au sein d'un sac

<pre lang="coq">Fixpoint count (v:nat) (s:bag) : nat :=
match s with
| nil => 0 (* Si la liste est vide, l'élément recherché ne peut pas apparaître *)
| h :: t => match h =? v with (* Si la liste est composée d'un entier et d'une liste, on compare l'entier avec l'élément recherché *)
| true => S (count v t) (* S'ils sont égaux, on continue la recherche sur le reste de la liste en ajoutant 1 au nombre d'occurrences *)
| false => count v t (* S'ils ne sont pas égaux, on continue la recherche sur le reste de la liste *)
end
end.</pre>

* Vérifier qu'un nombre appartient à un sac

<pre lang="coq">Fixpoint member (v:nat) (s:bag) : bool :=
match s with
| nil => false
| h :: t => match h =? v with
| true => true
| false => member v t
end
end.</pre>

* Retirer un ou toutes les occurrences d'un nombre dans un sac

<pre lang="coq">Fixpoint remove_one (v:nat) (s:bag) : bag :=
match s with
| nil => nil (* Si la liste est vide, on n'a plus rien à enlever *)
| h :: t => match h =? v with (* Similairement à count, si la liste est composée d'un entier et d'une liste, on compare l'entier à l'élément recherché *)
| true => t (* S'ils sont égaux, on retourne le reste de la liste, car on a enlevé la première occurrence d'un élément *)
| false => h :: remove_one v t (* S'ils ne sont pas égaux, on concatène l'entier avec le résultat de la recherche au sein de la liste restante *)
end
end.</pre>

remove_all et remove_one fonctionne exactement de la même manière, excepté que remove_all continue la recherche dans tous les cas.

<pre lang="coq">Fixpoint remove_all (v:nat) (s:bag) : bag :=
match s with
| nil => nil
| h :: t => match h =? v with
| true => remove_all v t
| false => h :: remove_all v t
end
end.</pre>

* Vérifier qu'un sac est inclus dans un deuxième sac

<pre lang="coq">Fixpoint subset (s1:bag) (s2:bag) : bool :=
match s1 with
| nil => true (* Si le sac de référence est vide, il est forcément inclus dans le deuxième sac *)
| h :: t => match (member h s2) with (* Si le sac de référence est composée d'un entier et d'une liste, on regarde si cet entier est présent dans le deuxième sac *)
| true => subset t (remove_one h s2) (* S'il est présent, on continue la recherche avec le reste du sac de référence est en retirant une occurrence de l'élément dans le deuxième sac *)
| false => false (* S'il n'est pas présent, alors le sac de référence n'est pas inclus dans le deuxième sac *)
end
end.</pre>

== Sources et annexes ==

'''Sources'''

* Software Foundations volume 1 [https://softwarefoundations.cis.upenn.edu/lf-current/index.html]

* Page Wikipédia de Coq [https://fr.wikipedia.org/wiki/Coq_(logiciel)]

'''Annexe'''

* Théorème des quatre couleurs [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_des_quatre_couleurs]

* Théorème de Feit-Thompson [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_de_Feit-Thompson]

* Compcert [http://compcert.inria.fr/]

* Iris Project [https://iris-project.org/]

* Software Foundations [https://softwarefoundations.cis.upenn.edu/]

* Verified Software Toolchain [https://vst.cs.princeton.edu/]

* FSCQ [http://css.csail.mit.edu/fscq/]

* Bedrock [http://plv.csail.mit.edu/bedrock/]

* CFML [https://www.chargueraud.org/softs/cfml/]

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-11T13:28:32Z

Dornel : /* Introduction */

== Introduction ==

Coq est un logiciel d'aide à la preuve mathématique développé par les équipes PI.R2 et Marelle d'Inria et l'équipe Systèmes Sûrs du Cnam. La première version a été publiée en 1984 et a été codée sous CAML.

Coq est fondé sur le calcul des constructions, une théorie concurrente à la théorie des ensembles de Zermelo-Fraenkel dont l'une des particularités est que les preuves sont au même niveau que les fonctions.

Parmi les théorèmes issus des mathématiques dont les preuves sont volumineuses et qui ont été démontrées à l'aide de Coq, on peut citer notamment :

* '''Théorème des quatre couleurs'''

Le théorème des quatre couleurs indique qu'il est possible en utilisant seulement quatre couleurs différentes de colorier n'importe quelle carte découpée en régions de sorte que deux régions ayant une frontière en commun ne soient pas de la même couleur. Le résultat fut initialement conjecturé en 1852, avec les deux premières preuves étant publiées en 1879 et 1880, celles-ci se révélant cependant fausses. La première preuve utilisant l'outil informatique date de 1976 et fut reprise et simplifiée par la suite. Enfin, en 2005, Georges Gonthier et Benjamin Werner ont réussi à formuler avec Coq une preuve formelle permettant à un ordinateur de complètement vérifier le théorème des quatre couleurs. À ce jour, aucune preuve qui ne fasse pas appel à un ordinateur n'a été découverte.

* '''Théorème de Feit-Thompson'''

Le théorème de Feit-Thompson énonce que tout groupe fini d'ordre impair est résoluble, ce qui équivaut à dire que tout groupe simple fini non commutatif est d'ordre pair. Le théorème fut conjecturé en 1911 par William Burnside et démontré en 1963 par Walter Feit et John Griggs Thompson. Une formalisation de la preuve en Coq a été achevée en 2012 par Georges Gonthier et son équipe du laboratoire commun Inria-Microsoft.

Coq sert également à la certification de logiciel. Parmi la multitude d'exemples, on peut mentionner :

* '''CompCert'''

CompCert est un projet ayant pour but de réaliser des compilateurs certifiés formellement. Ce projet développe notamment le compilateur CompCert C pour le langage C. Le projet est réalisé notamment en Coq.

* '''Iris Project'''

Iris Project est un logiciel de séparation logique simultanée d'ordre supérieure (''demander informations complémentaires'')

== Types, fonctions et preuves basiques ==

=== Déclaration de types ===

Pour définir un type sur Coq, une première méthode est l'induction. Cela consiste à utiliser les différents cas particuliers pour définir le cas général.
<pre lang="coq">Inductive day : Type :=
| monday
| tuesday
| wednesday
| thursday
| friday
| saturday
| sunday.</pre>

Ici, pour le type ''day'', on énumère les différentes valeurs que peut adopter le type, à savoir les jours de la semaine. Cette méthode permet notamment de définir des types dont l'ensemble de valeurs possibles est fini, comme les booléens ou les bits. Cependant, tenter de représenter les nombres avec cette méthode est contre-indiqué, car il faudrait un temps et une capacité de stockage disproportionnellement élevés.

Pour définir les nombres ou d'autres types dont l'ensemble de valeurs possibles est infini, il est possible de définir un type par récurrence.
<pre lang="coq">Inductive nat : Type:=
| O
| S (n : nat).</pre>

Dans ce cas-là, par exemple, on définit le type ''nat'' (correspondant aux entiers naturels) par un cas initial, ici 0, modélisé par la lettre O, et une hérédité, ici le fait que pour tout n ∈ ℕ, il existe un n' appartenant à ce même intervalle tel que n corresponde à S n'. L'écriture mathématique équivalente de cette définition est :
<math>\forall n > 0, \exists n' \geqslant 0, n = n' + 1</math>

Enfin, il est également possible avec Coq de créer un type utilisant un autre type pour sa définition. Ainsi, si l'on définit comme suit les teintes RGB d'une couleur :
<pre lang="coq">Inductive rgb : Type :=
| red
| green
| blue.</pre>
Il est possible de définir les composantes d'une couleur en utilisant le type ''rgb'' préalablement créé :
<pre lang="coq">Inductive color : Type :=
| black
| white
| primary (p : rgb).</pre>
Ainsi, ''color'' possède trois composantes, à savoir black, white et primary, cette dernière ayant elle-même trois composantes, red, green et blue.

=== Fonctions ===

Il y a plusieurs manières de définir une fonction dans Coq. La première est d'utiliser la commande '''''Definition''''' et de spécifier au cas par cas quel résultat la fonction retourne selon la valeur de la variable d'entrée.
 
Ainsi, en reprenant le type ''day'', on peut définir la fonction next_weekday comme suit :
<pre lang="coq">Definition next_weekday (d:day) : day :=
match d with
| monday => tuesday
| tuesday => wednesday
| wednesday => thursday
| thursday => friday
| friday => saturday
| saturday => sunday
| sunday => monday
end.</pre>
Dans cet exemple, on introduit le nom de la fonction, on indique le nom utilisé en son sein pour désigner la variable ainsi que son type, puis le type du résultat.
 
L'instruction ''match d with'' sert à analyser la valeur de la variable d. La liste qui suit signifie que pour telle valeur de d (par exemple wednesday), on retourne le résultat indiqué par la flèche (ici thursday). Enfin, la commande ''end'' permet de délimiter la fin de la fonction.

Cependant, il est également possible de ne retenir que certains cas et de retourner une même réponse pour tous les cas non vérifiés, dans la même veine qu'un ''else'' dans d'autres langages.
 
Par exemple, en supposant que l'on a défini précédemment un type ''bool'' qui ne peut prendre que true et false comme valeurs, on peut établir la fonction suivante :
<pre lang="coq">Definition isred (c : color) : bool :=
match c with
| black => false
| white => false
| primary red => true
| primary _ => false
end.</pre>
Ici, si l'on voulait écrire la fonction en Python, on aurait :
<pre lang="python">def isred(c) :
if c == black :
return False
elif c == white :
return False :
elif c == primary[red] :
return True
else :
return False</pre>
On remarque donc que le caractère _ signifie "dans tous les autres cas possibles", ce qui permet de ne retenir que les situations particulières et de généraliser le reste.

Une autre manière d'écrire une fonction est d'utiliser la commande '''''Fixpoint'''''. La différence majeure entre Fixpoint et Definition est la possibilité d'appeler la fonction récursivement avec Fixpoint.

Par exemple, une fonction pour définir si un entier naturel est pair s'écrit :
<pre lang="coq">Fixpoint evenb(n:nat) : bool :=
match n with
| 0 => true
| S 0 => false
| S (S n') => evenb n'</pre>

Cela signifie que pour tout entier n, trois cas de figure se présentent :
# <math> n = 0 \rightarrow n\ pair </math>
# <math> n = 1 \rightarrow n\ non\ pair </math>
# <math> \exists n', n = n' + 2 </math>
Dans le troisième cas, on réitère l'étude, mais avec n'.

Enfin, une troisième méthode pour définir une fonction est la commande '''''Theorem''''' qui permet, comme son nom l'indique, de définir un théorème, généralement sous la forme d'une égalité ou d'une implication. S'il s'agit d'une implication A -> B, A peut être utilisé comme hypothèse lors de la preuve.

=== Preuves simples ===

==== Structure générale ====

Dans Coq, la structure d'une preuve suit toujours la même structure :
<pre lang="coq">Proof. (* On indique le début de la preuve... *)
(* On insère ici toutes les instructions nécessaires... *)
Qed. (* Quod erat demonstrandum, équivalent latin de C.Q.F.D., signifie que la preuve est finie *)</pre>

==== Tactiques ====

Les tactiques sont des instructions pour aider Coq à résoudre une preuve.

* simpl.

simpl. permet, comme son nom l'indique, de simplifier une formule.

* reflexivity.

reflexivity. permet de vérifier si une égalité est du type a = a. Si la réflexivité de l'égalité est prouvée, alors la proposition est vraie. Cette instruction permet généralement d'achever une preuve.

* intros n.

intros. s'utilise en début de preuve pour introduire les variables présentes dans un théorème ou une hypothèse. S'il y a plusieurs variables à introduire, il faut les séparer par des espaces

* unfold f.

unfold f. permet de développer l'expression à étudier selon la fonction f.

* rewrite <- / -> H.

Permet de réécrire l'expression en fonction de l'hypothèse H. La flèche <- indique que l'on souhaite passer du membre de droite à celui de gauche et inversement pour ->. Coq va ensuite essayer de trouver un membre de l'expression qui correspond au terme de départ et va le remplacer par le terme d'arrivée.

* destruct n as [n1 | n2 | ...] eqn:E.

destruct permet de décomposer une variable en plusieurs cas de figure qui sont traités séparément. destruct fonctionne différemment selon le type de la variable utilisée. Avec les booléens ou d'autres types binaires, on peut se passer du as [...] car il n'y a par définition que deux valeurs que peut prendre la variable. Avec les entiers, on va généralement décomposer sous la forme as [| n'], autrement dit, on établit une pseudo-récurrence en vérifiant pour n = 0 et ensuite pour tout n' tel que n = n' + 1. Il ne s'agit cependant pas d'une vraie récurrence car il n'y a pas de lien entre n et n'.

==== Séparation des cas ====

Dans Coq, certaines commandes comme destruct occasionnent une séparation de l'expression en plusieurs cas. Pour identifier ces cas, il y a deux méthodes.

# Commencer chaque cas par une puce (-, + et * dans cet ordre)
# Délimiter un cas par des astérisque {}, ce qui permet de réinitialiser la hiérarchie des puces

== Preuve par récurrence, preuves à l'intérieur de preuves, preuves formelles et informelles ==

=== Preuve par récurrence ===

Bien que les tactiques mentionnées dans la partie précédente permettent de résoudre une grande partie des preuves, certains cas requièrent une attention plus particulière. Si la situation s'y prête, on peut notamment utiliser la récurrence avec la syntaxe suivante :

<pre lang="coq">Proof.
intros n. induction n as [| n' IHn']. (* On décompose n en un cas initial, généralement 0, et on introduit l'hypothèse que la proposition est vérifiée pour un palier arbitraire n'. *)
- (* Initialisation. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée pour le cas initial. *)
- (* Hérédité. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée à un niveau n' + 1 si elle est vérifiée pour n'. *)
Qed.</pre>

Ben que la récurrence soit une tactique puissante, il vaut mieux la réserver aux situations qui le nécessitent. Il est également nécessaire d'utiliser à un moment l'hypothèse d'hérédité avec rewrite. S'il est possible de compléter la preuve sans l'utiliser, une autre tactique aurait été probablement plus appropriée.

=== Preuves à l'intérieur de preuves ===

Parfois, il n'est pas possible de démontrer une équation telle quelle. Il faut passer par un lemme qui est introduit en Coq par l'instruction '''''assert'''''. Par exemple, la preuve servant à démontrer que <math>\forall n,m \in \mathbb{R}, (0 + n) * m = n * m</math> se structure comme tel :

<pre lang="Coq">Proof.
intros n m. (* On introduit les deux variables n et m *)
assert (H: 0 + n = n). (* On définit le lemme H qui dit que 0 + n = n *)
{ reflexivity. } (* On vérifie que H est vrai *)
rewrite -> H. (* On reformule l'équation initiale en remplaçant 0 + n par n, maintenant que l'on sait que les deux sont égaux *)
reflexivity. (* Les deux membres de l'équation sont alors identiques, la preuve est achevée *)
Qed.</pre>

=== Preuves formelles et informelles ===

Le principe d'une preuve est de convaincre le lecteur de sa véracité. Cependant, tous les lecteurs n'ont pas la même capacité de compréhension.

Par exemple, en langage mathématique, le théorème de Taylor à l'ordre n en a pourrait s'écrire :

<math>f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</math>

Cette écriture peut être lue aisément par un humain, mais pas par une machine. Cependant, si l'on écrit :

<pre lang="latex">f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</pre>

Un humain aurait du mal à lire cette ligne de code, mais un interpréteur LaTeX le lirait comme l'équation précédente. Il existe donc plusieurs façons de présenter la même information en fonction du lecteur visé. Il en est de même pour les preuves sur Coq.

* Preuves formelles

Les preuves formelles sont celles que Coq peut comprendre facilement et qui n'est pas prévue pour être facilement comprise par un humain. Par exemple, la preuve formelle de l'associativité de l'addition est structurée comme suit :

<pre lang="coq">Proof. intros n m p. induction n as [| n' IHn']. reflexivity. simpl. rewrite -> IHn'. reflexivity. Qed.</pre>

Le code est réduit à l'essentiel, mais la clarté pour le lecteur humain est moindre.

* Preuves informelles

Les preuves informelles sont celles que Coq accepte et qu'un humain peut comprendre facilement. Par exemple, la preuve informelle de l'associativité de l'addition est structurée comme tel :

<pre lang="coq">Proof.
intros n m p. induction n as [| n' IHn'].
- (* n = 0 *)
reflexivity.
- (* n = S n' *)
simpl. rewrite -> IHn'. reflexivity.
Qed.</pre>

Ici, on a éclaté le code pour notamment séparer les deux cas étudiés lors de la récurrence et on a ajouté des commentaires. Coq interprète toujours le code, mais un lecteur humain peut davantage comprendre ce qui se passe.

== Listes, sacs de nombres et opérations sur ces types ==

=== Listes de nombres ===

Dans Coq, on peut définir une liste de nombres sous le type '''''natlist''''' de façon récursive. Une liste est composée soit de l'élément vide, soit de la concaténation d'un entier naturel et d'une autre liste. Parmi les différentes opérations que l'on peut exécuter sur les listes, on peut évoquer :

* Créer une liste de longueur déterminée composée d'un seul élément

<pre lang="coq">Fixpoint repeat (n count : nat) : natlist :=
match count with (* Si count vaut... *)
| O => nil (* ... 0, on ferme la liste avec l'élément nul *)
| S count' => n :: (repeat n count') (* ... count' + 1, on concatène le nombre avec la liste de longueur count' répétant ce nombre *)
end.</pre>

* Calculer la longueur d'une liste

<pre lang="coq">Fixpoint length (l:natlist) : nat :=
match l with
| nil => O (* Cas 1, la liste n'est composée que de l'élément nul, sa longueur est donc nulle *)
| h :: t => S (length t) (* Cas 2, la liste est composée de la concaténation d'un entier et d'une liste, sa longueur vaut donc 1 + la longueur de cette deuxième liste *)
end.</pre>

* Joindre deux listes

<pre lang="coq">Fixpoint app (l1 l2 : natlist) : natlist :=
match l1 with
| nil => l2 (* Si la première liste est vide, le résultat de la jonction est donc la seule deuxième liste *)
| h :: t => h :: (app t l2) (* Si la première liste est composée d'un entier et d'une liste, on concatène cet entier avec la jonction de la liste et de la deuxième liste *)
end.</pre>

* Définir la tête et la queue d'une liste

<pre lang="coq">Definition hd (default:nat) (l:natlist) : nat :=
match l with
| nil => default (* Si la liste est vide, on retourne le nombre défini par défaut, l'élément vide n'ayant pas de premier élément *)
| h :: t => h (* Si la liste est composée d'un entier et d'une liste, on retourne l'entier, celui-ci étant le premier élément *)
end.</pre>

<pre lang="coq">Definition tl (l:natlist) : natlist :=
match l with
| nil => nil (* Si la liste est vide, on retourne l'ensemble vide *)
| h :: t => t (* Si la liste est composée d'un entier et d'une liste, on retourne la liste *)
end.</pre>

=== Sacs de nombres ===

Un sac de nombres ressemble à une liste, à l'exception prêt qu'un même élément peut apparaître plusieurs fois. Mis à part ce détail, le type '''''bag''''' est défini comme une liste de nombres. Parmi les opérations possibles sur ce type, on peut citer :

* Compter le nombre d'occurrence d'un nombre au sein d'un sac

<pre lang="coq">Fixpoint count (v:nat) (s:bag) : nat :=
match s with
| nil => 0 (* Si la liste est vide, l'élément recherché ne peut pas apparaître *)
| h :: t => match h =? v with (* Si la liste est composée d'un entier et d'une liste, on compare l'entier avec l'élément recherché *)
| true => S (count v t) (* S'ils sont égaux, on continue la recherche sur le reste de la liste en ajoutant 1 au nombre d'occurrences *)
| false => count v t (* S'ils ne sont pas égaux, on continue la recherche sur le reste de la liste *)
end
end.</pre>

* Vérifier qu'un nombre appartient à un sac

<pre lang="coq">Fixpoint member (v:nat) (s:bag) : bool :=
match s with
| nil => false
| h :: t => match h =? v with
| true => true
| false => member v t
end
end.</pre>

* Retirer un ou toutes les occurrences d'un nombre dans un sac

<pre lang="coq">Fixpoint remove_one (v:nat) (s:bag) : bag :=
match s with
| nil => nil (* Si la liste est vide, on n'a plus rien à enlever *)
| h :: t => match h =? v with (* Similairement à count, si la liste est composée d'un entier et d'une liste, on compare l'entier à l'élément recherché *)
| true => t (* S'ils sont égaux, on retourne le reste de la liste, car on a enlevé la première occurrence d'un élément *)
| false => h :: remove_one v t (* S'ils ne sont pas égaux, on concatène l'entier avec le résultat de la recherche au sein de la liste restante *)
end
end.</pre>

remove_all et remove_one fonctionne exactement de la même manière, excepté que remove_all continue la recherche dans tous les cas.

<pre lang="coq">Fixpoint remove_all (v:nat) (s:bag) : bag :=
match s with
| nil => nil
| h :: t => match h =? v with
| true => remove_all v t
| false => h :: remove_all v t
end
end.</pre>

* Vérifier qu'un sac est inclus dans un deuxième sac

<pre lang="coq">Fixpoint subset (s1:bag) (s2:bag) : bool :=
match s1 with
| nil => true (* Si le sac de référence est vide, il est forcément inclus dans le deuxième sac *)
| h :: t => match (member h s2) with (* Si le sac de référence est composée d'un entier et d'une liste, on regarde si cet entier est présent dans le deuxième sac *)
| true => subset t (remove_one h s2) (* S'il est présent, on continue la recherche avec le reste du sac de référence est en retirant une occurrence de l'élément dans le deuxième sac *)
| false => false (* S'il n'est pas présent, alors le sac de référence n'est pas inclus dans le deuxième sac *)
end
end.</pre>

== Sources et annexes ==

'''Sources'''

* Software Foundations volume 1 [https://softwarefoundations.cis.upenn.edu/lf-current/index.html]

* Page Wikipédia de Coq [https://fr.wikipedia.org/wiki/Coq_(logiciel)]

'''Annexe'''

* Théorème des quatre couleurs [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_des_quatre_couleurs]

* Théorème de Feit-Thompson [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_de_Feit-Thompson]

* Compcert [http://compcert.inria.fr/]

* Iris Project [https://iris-project.org/]

* Software Foundations [https://softwarefoundations.cis.upenn.edu/]

* Verified Software Toolchain [https://vst.cs.princeton.edu/]

* FSCQ [http://css.csail.mit.edu/fscq/]

* Bedrock [http://plv.csail.mit.edu/bedrock/]

* CFML [https://www.chargueraud.org/softs/cfml/]

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-09T15:14:29Z

Dornel :

== Introduction ==

Coq est un logiciel d'aide à la preuve mathématique développé par les équipes PI.R2 et Marelle d'Inria et l'équipe Systèmes Sûrs du Cnam. La première version a été publiée en 1984 et a été codée sous CAML.

Coq est fondé sur le calcul des constructions, une théorie concurrente à la théorie des ensembles de Zermelo-Fraenkel dont l'une des particularités est que les preuves sont au même niveau que les fonctions.

Parmi les théorèmes issus des mathématiques dont les preuves sont volumineuses et qui ont été démontrées à l'aide de Coq, on peut citer notamment :

* '''Théorème des quatre couleurs'''

Le théorème des quatre couleurs indique qu'il est possible en utilisant seulement quatre couleurs différentes de colorier n'importe quelle carte découpée en régions de sorte que deux régions ayant une frontière en commun ne soient pas de la même couleur. Le résultat fut initialement conjecturé en 1852, avec les deux premières preuves étant publiées en 1879 et 1880, celles-ci se révélant cependant fausses. La première preuve utilisant l'outil informatique date de 1976 et fut reprise et simplifiée par la suite. Enfin, en 2005, Georges Gonthier et Benjamin Werner ont réussi à formuler avec Coq une preuve formelle permettant à un ordinateur de complètement vérifier le théorème des quatre couleurs. À ce jour, aucune preuve qui ne fasse pas appel à un ordinateur n'a été découverte.

* '''Théorème de Feit-Thompson'''

Le théorème de Feit-Thompson énonce que tout groupe fini d'ordre impair est résoluble, ce qui équivaut à dire que tout groupe simple fini non commutatif est d'ordre pair. Le théorème fut conjecturé en 1911 par William Burnside et démontré en 1963 par Walter Feit et John Griggs Thompson. Une formalisation de la preuve en Coq a été achevée en 2012 par Georges Gonthier et son équipe du laboratoire commun Inria-Microsoft.

Coq sert également à la certification de logiciel. Parmi la multitude d'exemples, on peut mentionner :

* '''CompCert'''

CompCert est un compilateur pour le langage C qui utilise des preuves formelles pour vérifier le code. Cela est réalisé notamment en Coq.

* '''Iris Project'''

Iris Project est un logiciel de séparation logique simultanée d'ordre supérieure (''demander informations complémentaires'')

== Types, fonctions et preuves basiques ==

=== Déclaration de types ===

Pour définir un type sur Coq, une première méthode est l'induction. Cela consiste à utiliser les différents cas particuliers pour définir le cas général.
<pre lang="coq">Inductive day : Type :=
| monday
| tuesday
| wednesday
| thursday
| friday
| saturday
| sunday.</pre>

Ici, pour le type ''day'', on énumère les différentes valeurs que peut adopter le type, à savoir les jours de la semaine. Cette méthode permet notamment de définir des types dont l'ensemble de valeurs possibles est fini, comme les booléens ou les bits. Cependant, tenter de représenter les nombres avec cette méthode est contre-indiqué, car il faudrait un temps et une capacité de stockage disproportionnellement élevés.

Pour définir les nombres ou d'autres types dont l'ensemble de valeurs possibles est infini, il est possible de définir un type par récurrence.
<pre lang="coq">Inductive nat : Type:=
| O
| S (n : nat).</pre>

Dans ce cas-là, par exemple, on définit le type ''nat'' (correspondant aux entiers naturels) par un cas initial, ici 0, modélisé par la lettre O, et une hérédité, ici le fait que pour tout n ∈ ℕ, il existe un n' appartenant à ce même intervalle tel que n corresponde à S n'. L'écriture mathématique équivalente de cette définition est :
<math>\forall n > 0, \exists n' \geqslant 0, n = n' + 1</math>

Enfin, il est également possible avec Coq de créer un type utilisant un autre type pour sa définition. Ainsi, si l'on définit comme suit les teintes RGB d'une couleur :
<pre lang="coq">Inductive rgb : Type :=
| red
| green
| blue.</pre>
Il est possible de définir les composantes d'une couleur en utilisant le type ''rgb'' préalablement créé :
<pre lang="coq">Inductive color : Type :=
| black
| white
| primary (p : rgb).</pre>
Ainsi, ''color'' possède trois composantes, à savoir black, white et primary, cette dernière ayant elle-même trois composantes, red, green et blue.

=== Fonctions ===

Il y a plusieurs manières de définir une fonction dans Coq. La première est d'utiliser la commande '''''Definition''''' et de spécifier au cas par cas quel résultat la fonction retourne selon la valeur de la variable d'entrée.
 
Ainsi, en reprenant le type ''day'', on peut définir la fonction next_weekday comme suit :
<pre lang="coq">Definition next_weekday (d:day) : day :=
match d with
| monday => tuesday
| tuesday => wednesday
| wednesday => thursday
| thursday => friday
| friday => saturday
| saturday => sunday
| sunday => monday
end.</pre>
Dans cet exemple, on introduit le nom de la fonction, on indique le nom utilisé en son sein pour désigner la variable ainsi que son type, puis le type du résultat.
 
L'instruction ''match d with'' sert à analyser la valeur de la variable d. La liste qui suit signifie que pour telle valeur de d (par exemple wednesday), on retourne le résultat indiqué par la flèche (ici thursday). Enfin, la commande ''end'' permet de délimiter la fin de la fonction.

Cependant, il est également possible de ne retenir que certains cas et de retourner une même réponse pour tous les cas non vérifiés, dans la même veine qu'un ''else'' dans d'autres langages.
 
Par exemple, en supposant que l'on a défini précédemment un type ''bool'' qui ne peut prendre que true et false comme valeurs, on peut établir la fonction suivante :
<pre lang="coq">Definition isred (c : color) : bool :=
match c with
| black => false
| white => false
| primary red => true
| primary _ => false
end.</pre>
Ici, si l'on voulait écrire la fonction en Python, on aurait :
<pre lang="python">def isred(c) :
if c == black :
return False
elif c == white :
return False :
elif c == primary[red] :
return True
else :
return False</pre>
On remarque donc que le caractère _ signifie "dans tous les autres cas possibles", ce qui permet de ne retenir que les situations particulières et de généraliser le reste.

Une autre manière d'écrire une fonction est d'utiliser la commande '''''Fixpoint'''''. La différence majeure entre Fixpoint et Definition est la possibilité d'appeler la fonction récursivement avec Fixpoint.

Par exemple, une fonction pour définir si un entier naturel est pair s'écrit :
<pre lang="coq">Fixpoint evenb(n:nat) : bool :=
match n with
| 0 => true
| S 0 => false
| S (S n') => evenb n'</pre>

Cela signifie que pour tout entier n, trois cas de figure se présentent :
# <math> n = 0 \rightarrow n\ pair </math>
# <math> n = 1 \rightarrow n\ non\ pair </math>
# <math> \exists n', n = n' + 2 </math>
Dans le troisième cas, on réitère l'étude, mais avec n'.

Enfin, une troisième méthode pour définir une fonction est la commande '''''Theorem''''' qui permet, comme son nom l'indique, de définir un théorème, généralement sous la forme d'une égalité ou d'une implication. S'il s'agit d'une implication A -> B, A peut être utilisé comme hypothèse lors de la preuve.

=== Preuves simples ===

==== Structure générale ====

Dans Coq, la structure d'une preuve suit toujours la même structure :
<pre lang="coq">Proof. (* On indique le début de la preuve... *)
(* On insère ici toutes les instructions nécessaires... *)
Qed. (* Quod erat demonstrandum, équivalent latin de C.Q.F.D., signifie que la preuve est finie *)</pre>

==== Tactiques ====

Les tactiques sont des instructions pour aider Coq à résoudre une preuve.

* simpl.

simpl. permet, comme son nom l'indique, de simplifier une formule.

* reflexivity.

reflexivity. permet de vérifier si une égalité est du type a = a. Si la réflexivité de l'égalité est prouvée, alors la proposition est vraie. Cette instruction permet généralement d'achever une preuve.

* intros n.

intros. s'utilise en début de preuve pour introduire les variables présentes dans un théorème ou une hypothèse. S'il y a plusieurs variables à introduire, il faut les séparer par des espaces

* unfold f.

unfold f. permet de développer l'expression à étudier selon la fonction f.

* rewrite <- / -> H.

Permet de réécrire l'expression en fonction de l'hypothèse H. La flèche <- indique que l'on souhaite passer du membre de droite à celui de gauche et inversement pour ->. Coq va ensuite essayer de trouver un membre de l'expression qui correspond au terme de départ et va le remplacer par le terme d'arrivée.

* destruct n as [n1 | n2 | ...] eqn:E.

destruct permet de décomposer une variable en plusieurs cas de figure qui sont traités séparément. destruct fonctionne différemment selon le type de la variable utilisée. Avec les booléens ou d'autres types binaires, on peut se passer du as [...] car il n'y a par définition que deux valeurs que peut prendre la variable. Avec les entiers, on va généralement décomposer sous la forme as [| n'], autrement dit, on établit une pseudo-récurrence en vérifiant pour n = 0 et ensuite pour tout n' tel que n = n' + 1. Il ne s'agit cependant pas d'une vraie récurrence car il n'y a pas de lien entre n et n'.

==== Séparation des cas ====

Dans Coq, certaines commandes comme destruct occasionnent une séparation de l'expression en plusieurs cas. Pour identifier ces cas, il y a deux méthodes.

# Commencer chaque cas par une puce (-, + et * dans cet ordre)
# Délimiter un cas par des astérisque {}, ce qui permet de réinitialiser la hiérarchie des puces

== Preuve par récurrence, preuves à l'intérieur de preuves, preuves formelles et informelles ==

=== Preuve par récurrence ===

Bien que les tactiques mentionnées dans la partie précédente permettent de résoudre une grande partie des preuves, certains cas requièrent une attention plus particulière. Si la situation s'y prête, on peut notamment utiliser la récurrence avec la syntaxe suivante :

<pre lang="coq">Proof.
intros n. induction n as [| n' IHn']. (* On décompose n en un cas initial, généralement 0, et on introduit l'hypothèse que la proposition est vérifiée pour un palier arbitraire n'. *)
- (* Initialisation. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée pour le cas initial. *)
- (* Hérédité. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée à un niveau n' + 1 si elle est vérifiée pour n'. *)
Qed.</pre>

Ben que la récurrence soit une tactique puissante, il vaut mieux la réserver aux situations qui le nécessitent. Il est également nécessaire d'utiliser à un moment l'hypothèse d'hérédité avec rewrite. S'il est possible de compléter la preuve sans l'utiliser, une autre tactique aurait été probablement plus appropriée.

=== Preuves à l'intérieur de preuves ===

Parfois, il n'est pas possible de démontrer une équation telle quelle. Il faut passer par un lemme qui est introduit en Coq par l'instruction '''''assert'''''. Par exemple, la preuve servant à démontrer que <math>\forall n,m \in \mathbb{R}, (0 + n) * m = n * m</math> se structure comme tel :

<pre lang="Coq">Proof.
intros n m. (* On introduit les deux variables n et m *)
assert (H: 0 + n = n). (* On définit le lemme H qui dit que 0 + n = n *)
{ reflexivity. } (* On vérifie que H est vrai *)
rewrite -> H. (* On reformule l'équation initiale en remplaçant 0 + n par n, maintenant que l'on sait que les deux sont égaux *)
reflexivity. (* Les deux membres de l'équation sont alors identiques, la preuve est achevée *)
Qed.</pre>

=== Preuves formelles et informelles ===

Le principe d'une preuve est de convaincre le lecteur de sa véracité. Cependant, tous les lecteurs n'ont pas la même capacité de compréhension.

Par exemple, en langage mathématique, le théorème de Taylor à l'ordre n en a pourrait s'écrire :

<math>f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</math>

Cette écriture peut être lue aisément par un humain, mais pas par une machine. Cependant, si l'on écrit :

<pre lang="latex">f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</pre>

Un humain aurait du mal à lire cette ligne de code, mais un interpréteur LaTeX le lirait comme l'équation précédente. Il existe donc plusieurs façons de présenter la même information en fonction du lecteur visé. Il en est de même pour les preuves sur Coq.

* Preuves formelles

Les preuves formelles sont celles que Coq peut comprendre facilement et qui n'est pas prévue pour être facilement comprise par un humain. Par exemple, la preuve formelle de l'associativité de l'addition est structurée comme suit :

<pre lang="coq">Proof. intros n m p. induction n as [| n' IHn']. reflexivity. simpl. rewrite -> IHn'. reflexivity. Qed.</pre>

Le code est réduit à l'essentiel, mais la clarté pour le lecteur humain est moindre.

* Preuves informelles

Les preuves informelles sont celles que Coq accepte et qu'un humain peut comprendre facilement. Par exemple, la preuve informelle de l'associativité de l'addition est structurée comme tel :

<pre lang="coq">Proof.
intros n m p. induction n as [| n' IHn'].
- (* n = 0 *)
reflexivity.
- (* n = S n' *)
simpl. rewrite -> IHn'. reflexivity.
Qed.</pre>

Ici, on a éclaté le code pour notamment séparer les deux cas étudiés lors de la récurrence et on a ajouté des commentaires. Coq interprète toujours le code, mais un lecteur humain peut davantage comprendre ce qui se passe.

== Listes, sacs de nombres et opérations sur ces types ==

=== Listes de nombres ===

Dans Coq, on peut définir une liste de nombres sous le type '''''natlist''''' de façon récursive. Une liste est composée soit de l'élément vide, soit de la concaténation d'un entier naturel et d'une autre liste. Parmi les différentes opérations que l'on peut exécuter sur les listes, on peut évoquer :

* Créer une liste de longueur déterminée composée d'un seul élément

<pre lang="coq">Fixpoint repeat (n count : nat) : natlist :=
match count with (* Si count vaut... *)
| O => nil (* ... 0, on ferme la liste avec l'élément nul *)
| S count' => n :: (repeat n count') (* ... count' + 1, on concatène le nombre avec la liste de longueur count' répétant ce nombre *)
end.</pre>

* Calculer la longueur d'une liste

<pre lang="coq">Fixpoint length (l:natlist) : nat :=
match l with
| nil => O (* Cas 1, la liste n'est composée que de l'élément nul, sa longueur est donc nulle *)
| h :: t => S (length t) (* Cas 2, la liste est composée de la concaténation d'un entier et d'une liste, sa longueur vaut donc 1 + la longueur de cette deuxième liste *)
end.</pre>

* Joindre deux listes

<pre lang="coq">Fixpoint app (l1 l2 : natlist) : natlist :=
match l1 with
| nil => l2 (* Si la première liste est vide, le résultat de la jonction est donc la seule deuxième liste *)
| h :: t => h :: (app t l2) (* Si la première liste est composée d'un entier et d'une liste, on concatène cet entier avec la jonction de la liste et de la deuxième liste *)
end.</pre>

* Définir la tête et la queue d'une liste

<pre lang="coq">Definition hd (default:nat) (l:natlist) : nat :=
match l with
| nil => default (* Si la liste est vide, on retourne le nombre défini par défaut, l'élément vide n'ayant pas de premier élément *)
| h :: t => h (* Si la liste est composée d'un entier et d'une liste, on retourne l'entier, celui-ci étant le premier élément *)
end.</pre>

<pre lang="coq">Definition tl (l:natlist) : natlist :=
match l with
| nil => nil (* Si la liste est vide, on retourne l'ensemble vide *)
| h :: t => t (* Si la liste est composée d'un entier et d'une liste, on retourne la liste *)
end.</pre>

=== Sacs de nombres ===

Un sac de nombres ressemble à une liste, à l'exception prêt qu'un même élément peut apparaître plusieurs fois. Mis à part ce détail, le type '''''bag''''' est défini comme une liste de nombres. Parmi les opérations possibles sur ce type, on peut citer :

* Compter le nombre d'occurrence d'un nombre au sein d'un sac

<pre lang="coq">Fixpoint count (v:nat) (s:bag) : nat :=
match s with
| nil => 0 (* Si la liste est vide, l'élément recherché ne peut pas apparaître *)
| h :: t => match h =? v with (* Si la liste est composée d'un entier et d'une liste, on compare l'entier avec l'élément recherché *)
| true => S (count v t) (* S'ils sont égaux, on continue la recherche sur le reste de la liste en ajoutant 1 au nombre d'occurrences *)
| false => count v t (* S'ils ne sont pas égaux, on continue la recherche sur le reste de la liste *)
end
end.</pre>

* Vérifier qu'un nombre appartient à un sac

<pre lang="coq">Fixpoint member (v:nat) (s:bag) : bool :=
match s with
| nil => false
| h :: t => match h =? v with
| true => true
| false => member v t
end
end.</pre>

* Retirer un ou toutes les occurrences d'un nombre dans un sac

<pre lang="coq">Fixpoint remove_one (v:nat) (s:bag) : bag :=
match s with
| nil => nil (* Si la liste est vide, on n'a plus rien à enlever *)
| h :: t => match h =? v with (* Similairement à count, si la liste est composée d'un entier et d'une liste, on compare l'entier à l'élément recherché *)
| true => t (* S'ils sont égaux, on retourne le reste de la liste, car on a enlevé la première occurrence d'un élément *)
| false => h :: remove_one v t (* S'ils ne sont pas égaux, on concatène l'entier avec le résultat de la recherche au sein de la liste restante *)
end
end.</pre>

remove_all et remove_one fonctionne exactement de la même manière, excepté que remove_all continue la recherche dans tous les cas.

<pre lang="coq">Fixpoint remove_all (v:nat) (s:bag) : bag :=
match s with
| nil => nil
| h :: t => match h =? v with
| true => remove_all v t
| false => h :: remove_all v t
end
end.</pre>

* Vérifier qu'un sac est inclus dans un deuxième sac

<pre lang="coq">Fixpoint subset (s1:bag) (s2:bag) : bool :=
match s1 with
| nil => true (* Si le sac de référence est vide, il est forcément inclus dans le deuxième sac *)
| h :: t => match (member h s2) with (* Si le sac de référence est composée d'un entier et d'une liste, on regarde si cet entier est présent dans le deuxième sac *)
| true => subset t (remove_one h s2) (* S'il est présent, on continue la recherche avec le reste du sac de référence est en retirant une occurrence de l'élément dans le deuxième sac *)
| false => false (* S'il n'est pas présent, alors le sac de référence n'est pas inclus dans le deuxième sac *)
end
end.</pre>

== Sources et annexes ==

'''Sources'''

* Software Foundations volume 1 [https://softwarefoundations.cis.upenn.edu/lf-current/index.html]

* Page Wikipédia de Coq [https://fr.wikipedia.org/wiki/Coq_(logiciel)]

'''Annexe'''

* Théorème des quatre couleurs [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_des_quatre_couleurs]

* Théorème de Feit-Thompson [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_de_Feit-Thompson]

* Compcert [http://compcert.inria.fr/]

* Iris Project [https://iris-project.org/]

* Software Foundations [https://softwarefoundations.cis.upenn.edu/]

* Verified Software Toolchain [https://vst.cs.princeton.edu/]

* FSCQ [http://css.csail.mit.edu/fscq/]

* Bedrock [http://plv.csail.mit.edu/bedrock/]

* CFML [https://www.chargueraud.org/softs/cfml/]

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-08T11:04:58Z

Dornel : /* Listes de nombres */

== Introduction ==

Coq est un logiciel d'aide à la preuve mathématique développé par les équipes PI.R2 et Marelle d'Inria et l'équipe Systèmes Sûrs du Cnam. La première version a été publiée en 1984 et a été codée sous CAML.

Coq est fondé sur le calcul des constructions, une théorie concurrente à la théorie des ensembles de Zermelo-Fraenkel dont l'une des particularités est que les preuves sont au même niveau que les fonctions.

Parmi les théorèmes issus des mathématiques dont les preuves sont volumineuses et qui ont été démontrées à l'aide de Coq, on peut citer notamment :

* '''Théorème des quatre couleurs'''

Le théorème des quatre couleurs indique qu'il est possible en utilisant seulement quatre couleurs différentes de colorier n'importe quelle carte découpée en régions de sorte que deux régions ayant une frontière en commun ne soient pas de la même couleur. Le résultat fut initialement conjecturé en 1852, avec les deux premières preuves étant publiées en 1879 et 1880, celles-ci se révélant cependant fausses. La première preuve utilisant l'outil informatique date de 1976 et fut reprise et simplifiée par la suite. Enfin, en 2005, Georges Gonthier et Benjamin Werner ont réussi à formuler avec Coq une preuve formelle permettant à un ordinateur de complètement vérifier le théorème des quatre couleurs. À ce jour, aucune preuve qui ne fasse pas appel à un ordinateur n'a été découverte.

* '''Théorème de Feit-Thompson'''

Le théorème de Feit-Thompson énonce que tout groupe fini d'ordre impair est résoluble, ce qui équivaut à dire que tout groupe simple fini non commutatif est d'ordre pair. Le théorème fut conjecturé en 1911 par William Burnside et démontré en 1963 par Walter Feit et John Griggs Thompson. Une formalisation de la preuve en Coq a été achevée en 2012 par Georges Gonthier et son équipe du laboratoire commun Inria-Microsoft.

Coq sert également à la certification de logiciel. Parmi la multitude d'exemples, on peut mentionner :

* '''CompCert'''

CompCert est un compilateur pour le langage C qui utilise des preuves formelles pour vérifier le code. Cela est réalisé notamment en Coq.

* '''Iris Project'''

Iris Project est un logiciel de séparation logique simultanée d'ordre supérieure (''demander informations complémentaires'')

----
Oral :

Software Foundation (pédagogique :wave:)
VST (Verified Software Toolchain)
fscq
Bedrock
CFML

Conclusion :
Je n'ai pas pu couvrir qu'une fraction des fonctionnalités proposées par Coq, mais j'ai quand même atteint l'objectif que mon tuteur avait fixé.

== Types, fonctions et preuves basiques ==

=== Déclaration de types ===

Pour définir un type sur Coq, une première méthode est l'induction. Cela consiste à utiliser les différents cas particuliers pour définir le cas général.
<pre lang="coq">Inductive day : Type :=
| monday
| tuesday
| wednesday
| thursday
| friday
| saturday
| sunday.</pre>

Ici, pour le type ''day'', on énumère les différentes valeurs que peut adopter le type, à savoir les jours de la semaine. Cette méthode permet notamment de définir des types dont l'ensemble de valeurs possibles est fini, comme les booléens ou les bits. Cependant, tenter de représenter les nombres avec cette méthode est contre-indiqué, car il faudrait un temps et une capacité de stockage disproportionnellement élevés.

Pour définir les nombres ou d'autres types dont l'ensemble de valeurs possibles est infini, il est possible de définir un type par récurrence.
<pre lang="coq">Inductive nat : Type:=
| O
| S (n : nat).</pre>

Dans ce cas-là, par exemple, on définit le type ''nat'' (correspondant aux entiers naturels) par un cas initial, ici 0, modélisé par la lettre O, et une hérédité, ici le fait que pour tout n ∈ ℕ, il existe un n' appartenant à ce même intervalle tel que n corresponde à S n'. L'écriture mathématique équivalente de cette définition est :
<math>\forall n > 0, \exists n' \geqslant 0, n = n' + 1</math>

Enfin, il est également possible avec Coq de créer un type utilisant un autre type pour sa définition. Ainsi, si l'on définit comme suit les teintes RGB d'une couleur :
<pre lang="coq">Inductive rgb : Type :=
| red
| green
| blue.</pre>
Il est possible de définir les composantes d'une couleur en utilisant le type ''rgb'' préalablement créé :
<pre lang="coq">Inductive color : Type :=
| black
| white
| primary (p : rgb).</pre>
Ainsi, ''color'' possède trois composantes, à savoir black, white et primary, cette dernière ayant elle-même trois composantes, red, green et blue.

=== Fonctions ===

Il y a plusieurs manières de définir une fonction dans Coq. La première est d'utiliser la commande '''''Definition''''' et de spécifier au cas par cas quel résultat la fonction retourne selon la valeur de la variable d'entrée.
 
Ainsi, en reprenant le type ''day'', on peut définir la fonction next_weekday comme suit :
<pre lang="coq">Definition next_weekday (d:day) : day :=
match d with
| monday => tuesday
| tuesday => wednesday
| wednesday => thursday
| thursday => friday
| friday => saturday
| saturday => sunday
| sunday => monday
end.</pre>
Dans cet exemple, on introduit le nom de la fonction, on indique le nom utilisé en son sein pour désigner la variable ainsi que son type, puis le type du résultat.
 
L'instruction ''match d with'' sert à analyser la valeur de la variable d. La liste qui suit signifie que pour telle valeur de d (par exemple wednesday), on retourne le résultat indiqué par la flèche (ici thursday). Enfin, la commande ''end'' permet de délimiter la fin de la fonction.

Cependant, il est également possible de ne retenir que certains cas et de retourner une même réponse pour tous les cas non vérifiés, dans la même veine qu'un ''else'' dans d'autres langages.
 
Par exemple, en supposant que l'on a défini précédemment un type ''bool'' qui ne peut prendre que true et false comme valeurs, on peut établir la fonction suivante :
<pre lang="coq">Definition isred (c : color) : bool :=
match c with
| black => false
| white => false
| primary red => true
| primary _ => false
end.</pre>
Ici, si l'on voulait écrire la fonction en Python, on aurait :
<pre lang="python">def isred(c) :
if c == black :
return False
elif c == white :
return False :
elif c == primary[red] :
return True
else :
return False</pre>
On remarque donc que le caractère _ signifie "dans tous les autres cas possibles", ce qui permet de ne retenir que les situations particulières et de généraliser le reste.

Une autre manière d'écrire une fonction est d'utiliser la commande '''''Fixpoint'''''. La différence majeure entre Fixpoint et Definition est la possibilité d'appeler la fonction récursivement avec Fixpoint.

Par exemple, une fonction pour définir si un entier naturel est pair s'écrit :
<pre lang="coq">Fixpoint evenb(n:nat) : bool :=
match n with
| 0 => true
| S 0 => false
| S (S n') => evenb n'</pre>

Cela signifie que pour tout entier n, trois cas de figure se présentent :
# <math> n = 0 \rightarrow n\ pair </math>
# <math> n = 1 \rightarrow n\ non\ pair </math>
# <math> \exists n', n = n' + 2 </math>
Dans le troisième cas, on réitère l'étude, mais avec n'.

Enfin, une troisième méthode pour définir une fonction est la commande '''''Theorem''''' qui permet, comme son nom l'indique, de définir un théorème, généralement sous la forme d'une égalité ou d'une implication. S'il s'agit d'une implication A -> B, A peut être utilisé comme hypothèse lors de la preuve.

=== Preuves simples ===

==== Structure générale ====

Dans Coq, la structure d'une preuve suit toujours la même structure :
<pre lang="coq">Proof. (* On indique le début de la preuve... *)
(* On insère ici toutes les instructions nécessaires... *)
Qed. (* Quod erat demonstrandum, équivalent latin de C.Q.F.D., signifie que la preuve est finie *)</pre>

==== Tactiques ====

Les tactiques sont des instructions pour aider Coq à résoudre une preuve.

* simpl.

simpl. permet, comme son nom l'indique, de simplifier une formule.

* reflexivity.

reflexivity. permet de vérifier si une égalité est du type a = a. Si la réflexivité de l'égalité est prouvée, alors la proposition est vraie. Cette instruction permet généralement d'achever une preuve.

* intros n.

intros. s'utilise en début de preuve pour introduire les variables présentes dans un théorème ou une hypothèse. S'il y a plusieurs variables à introduire, il faut les séparer par des espaces

* unfold f.

unfold f. permet de développer l'expression à étudier selon la fonction f.

* rewrite <- / -> H.

Permet de réécrire l'expression en fonction de l'hypothèse H. La flèche <- indique que l'on souhaite passer du membre de droite à celui de gauche et inversement pour ->. Coq va ensuite essayer de trouver un membre de l'expression qui correspond au terme de départ et va le remplacer par le terme d'arrivée.

* destruct n as [n1 | n2 | ...] eqn:E.

destruct permet de décomposer une variable en plusieurs cas de figure qui sont traités séparément. destruct fonctionne différemment selon le type de la variable utilisée. Avec les booléens ou d'autres types binaires, on peut se passer du as [...] car il n'y a par définition que deux valeurs que peut prendre la variable. Avec les entiers, on va généralement décomposer sous la forme as [| n'], autrement dit, on établit une pseudo-récurrence en vérifiant pour n = 0 et ensuite pour tout n' tel que n = n' + 1. Il ne s'agit cependant pas d'une vraie récurrence car il n'y a pas de lien entre n et n'.

==== Séparation des cas ====

Dans Coq, certaines commandes comme destruct occasionnent une séparation de l'expression en plusieurs cas. Pour identifier ces cas, il y a deux méthodes.

# Commencer chaque cas par une puce (-, + et * dans cet ordre)
# Délimiter un cas par des astérisque {}, ce qui permet de réinitialiser la hiérarchie des puces

== Preuve par récurrence, preuves à l'intérieur de preuves, preuves formelles et informelles ==

=== Preuve par récurrence ===

Bien que les tactiques mentionnées dans la partie précédente permettent de résoudre une grande partie des preuves, certains cas requièrent une attention plus particulière. Si la situation s'y prête, on peut notamment utiliser la récurrence avec la syntaxe suivante :

<pre lang="coq">Proof.
intros n. induction n as [| n' IHn']. (* On décompose n en un cas initial, généralement 0, et on introduit l'hypothèse que la proposition est vérifiée pour un palier arbitraire n'. *)
- (* Initialisation. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée pour le cas initial. *)
- (* Hérédité. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée à un niveau n' + 1 si elle est vérifiée pour n'. *)
Qed.</pre>

Ben que la récurrence soit une tactique puissante, il vaut mieux la réserver aux situations qui le nécessitent. Il est également nécessaire d'utiliser à un moment l'hypothèse d'hérédité avec rewrite. S'il est possible de compléter la preuve sans l'utiliser, une autre tactique aurait été probablement plus appropriée.

=== Preuves à l'intérieur de preuves ===

Parfois, il n'est pas possible de démontrer une équation telle quelle. Il faut passer par un lemme qui est introduit en Coq par l'instruction '''''assert'''''. Par exemple, la preuve servant à démontrer que <math>\forall n,m \in \mathbb{R}, (0 + n) * m = n * m</math> se structure comme tel :

<pre lang="Coq">Proof.
intros n m. (* On introduit les deux variables n et m *)
assert (H: 0 + n = n). (* On définit le lemme H qui dit que 0 + n = n *)
{ reflexivity. } (* On vérifie que H est vrai *)
rewrite -> H. (* On reformule l'équation initiale en remplaçant 0 + n par n, maintenant que l'on sait que les deux sont égaux *)
reflexivity. (* Les deux membres de l'équation sont alors identiques, la preuve est achevée *)
Qed.</pre>

=== Preuves formelles et informelles ===

Le principe d'une preuve est de convaincre le lecteur de sa véracité. Cependant, tous les lecteurs n'ont pas la même capacité de compréhension.

Par exemple, en langage mathématique, le théorème de Taylor à l'ordre n en a pourrait s'écrire :

<math>f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</math>

Cette écriture peut être lue aisément par un humain, mais pas par une machine. Cependant, si l'on écrit :

<pre lang="latex">f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</pre>

Un humain aurait du mal à lire cette ligne de code, mais un interpréteur LaTeX le lirait comme l'équation précédente. Il existe donc plusieurs façons de présenter la même information en fonction du lecteur visé. Il en est de même pour les preuves sur Coq.

* Preuves formelles

Les preuves formelles sont celles que Coq peut comprendre facilement et qui n'est pas prévue pour être facilement comprise par un humain. Par exemple, la preuve formelle de l'associativité de l'addition est structurée comme suit :

<pre lang="coq">Proof. intros n m p. induction n as [| n' IHn']. reflexivity. simpl. rewrite -> IHn'. reflexivity. Qed.</pre>

Le code est réduit à l'essentiel, mais la clarté pour le lecteur humain est moindre.

* Preuves informelles

Les preuves informelles sont celles que Coq accepte et qu'un humain peut comprendre facilement. Par exemple, la preuve informelle de l'associativité de l'addition est structurée comme tel :

<pre lang="coq">Proof.
intros n m p. induction n as [| n' IHn'].
- (* n = 0 *)
reflexivity.
- (* n = S n' *)
simpl. rewrite -> IHn'. reflexivity.
Qed.</pre>

Ici, on a éclaté le code pour notamment séparer les deux cas étudiés lors de la récurrence et on a ajouté des commentaires. Coq interprète toujours le code, mais un lecteur humain peut davantage comprendre ce qui se passe.

== Listes, sacs de nombres et opérations sur ces types ==

=== Listes de nombres ===

Dans Coq, on peut définir une liste de nombres sous le type '''''natlist''''' de façon récursive. Une liste est composée soit de l'élément vide, soit de la concaténation d'un entier naturel et d'une autre liste. Parmi les différentes opérations que l'on peut exécuter sur les listes, on peut évoquer :

* Créer une liste de longueur déterminée composée d'un seul élément

<pre lang="coq">Fixpoint repeat (n count : nat) : natlist :=
match count with (* Si count vaut... *)
| O => nil (* ... 0, on ferme la liste avec l'élément nul *)
| S count' => n :: (repeat n count') (* ... count' + 1, on concatène le nombre avec la liste de longueur count' répétant ce nombre *)
end.</pre>

* Calculer la longueur d'une liste

<pre lang="coq">Fixpoint length (l:natlist) : nat :=
match l with
| nil => O (* Cas 1, la liste n'est composée que de l'élément nul, sa longueur est donc nulle *)
| h :: t => S (length t) (* Cas 2, la liste est composée de la concaténation d'un entier et d'une liste, sa longueur vaut donc 1 + la longueur de cette deuxième liste *)
end.</pre>

* Joindre deux listes

<pre lang="coq">Fixpoint app (l1 l2 : natlist) : natlist :=
match l1 with
| nil => l2 (* Si la première liste est vide, le résultat de la jonction est donc la seule deuxième liste *)
| h :: t => h :: (app t l2) (* Si la première liste est composée d'un entier et d'une liste, on concatène cet entier avec la jonction de la liste et de la deuxième liste *)
end.</pre>

* Définir la tête et la queue d'une liste

<pre lang="coq">Definition hd (default:nat) (l:natlist) : nat :=
match l with
| nil => default (* Si la liste est vide, on retourne le nombre défini par défaut, l'élément vide n'ayant pas de premier élément *)
| h :: t => h (* Si la liste est composée d'un entier et d'une liste, on retourne l'entier, celui-ci étant le premier élément *)
end.</pre>

<pre lang="coq">Definition tl (l:natlist) : natlist :=
match l with
| nil => nil (* Si la liste est vide, on retourne l'ensemble vide *)
| h :: t => t (* Si la liste est composée d'un entier et d'une liste, on retourne la liste *)
end.</pre>

=== Sacs de nombres ===

Un sac de nombres ressemble à une liste, à l'exception prêt qu'un même élément peut apparaître plusieurs fois. Mis à part ce détail, le type '''''bag''''' est défini comme une liste de nombres. Parmi les opérations possibles sur ce type, on peut citer :

* Compter le nombre d'occurrence d'un nombre au sein d'un sac

<pre lang="coq">Fixpoint count (v:nat) (s:bag) : nat :=
match s with
| nil => 0 (* Si la liste est vide, l'élément recherché ne peut pas apparaître *)
| h :: t => match h =? v with (* Si la liste est composée d'un entier et d'une liste, on compare l'entier avec l'élément recherché *)
| true => S (count v t) (* S'ils sont égaux, on continue la recherche sur le reste de la liste en ajoutant 1 au nombre d'occurrences *)
| false => count v t (* S'ils ne sont pas égaux, on continue la recherche sur le reste de la liste *)
end
end.</pre>

* Vérifier qu'un nombre appartient à un sac

<pre lang="coq">Fixpoint member (v:nat) (s:bag) : bool :=
match s with
| nil => false
| h :: t => match h =? v with
| true => true
| false => member v t
end
end.</pre>

* Retirer un ou toutes les occurrences d'un nombre dans un sac

<pre lang="coq">Fixpoint remove_one (v:nat) (s:bag) : bag :=
match s with
| nil => nil (* Si la liste est vide, on n'a plus rien à enlever *)
| h :: t => match h =? v with (* Similairement à count, si la liste est composée d'un entier et d'une liste, on compare l'entier à l'élément recherché *)
| true => t (* S'ils sont égaux, on retourne le reste de la liste, car on a enlevé la première occurrence d'un élément *)
| false => h :: remove_one v t (* S'ils ne sont pas égaux, on concatène l'entier avec le résultat de la recherche au sein de la liste restante *)
end
end.</pre>

remove_all et remove_one fonctionne exactement de la même manière, excepté que remove_all continue la recherche dans tous les cas.

<pre lang="coq">Fixpoint remove_all (v:nat) (s:bag) : bag :=
match s with
| nil => nil
| h :: t => match h =? v with
| true => remove_all v t
| false => h :: remove_all v t
end
end.</pre>

* Vérifier qu'un sac est inclus dans un deuxième sac

<pre lang="coq">Fixpoint subset (s1:bag) (s2:bag) : bool :=
match s1 with
| nil => true (* Si le sac de référence est vide, il est forcément inclus dans le deuxième sac *)
| h :: t => match (member h s2) with (* Si le sac de référence est composée d'un entier et d'une liste, on regarde si cet entier est présent dans le deuxième sac *)
| true => subset t (remove_one h s2) (* S'il est présent, on continue la recherche avec le reste du sac de référence est en retirant une occurrence de l'élément dans le deuxième sac *)
| false => false (* S'il n'est pas présent, alors le sac de référence n'est pas inclus dans le deuxième sac *)
end
end.</pre>

== Sources et annexes ==

'''Sources'''

* Software Foundations volume 1 [https://softwarefoundations.cis.upenn.edu/lf-current/index.html]

* Page Wikipédia de Coq [https://fr.wikipedia.org/wiki/Coq_(logiciel)]

'''Annexe'''

* Théorème des quatre couleurs [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_des_quatre_couleurs]

* Théorème de Feit-Thompson [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_de_Feit-Thompson]

* Compcert [http://compcert.inria.fr/]

* Iris Project [https://iris-project.org/]

* Software Foundations [https://softwarefoundations.cis.upenn.edu/]

* Verified Software Toolchain [https://vst.cs.princeton.edu/]

* FSCQ [http://css.csail.mit.edu/fscq/]

* Bedrock [http://plv.csail.mit.edu/bedrock/]

* CFML [https://www.chargueraud.org/softs/cfml/]

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-08T11:03:47Z

Dornel : /* Paires, listes et sacs de nombres */

== Introduction ==

Coq est un logiciel d'aide à la preuve mathématique développé par les équipes PI.R2 et Marelle d'Inria et l'équipe Systèmes Sûrs du Cnam. La première version a été publiée en 1984 et a été codée sous CAML.

Coq est fondé sur le calcul des constructions, une théorie concurrente à la théorie des ensembles de Zermelo-Fraenkel dont l'une des particularités est que les preuves sont au même niveau que les fonctions.

Parmi les théorèmes issus des mathématiques dont les preuves sont volumineuses et qui ont été démontrées à l'aide de Coq, on peut citer notamment :

* '''Théorème des quatre couleurs'''

Le théorème des quatre couleurs indique qu'il est possible en utilisant seulement quatre couleurs différentes de colorier n'importe quelle carte découpée en régions de sorte que deux régions ayant une frontière en commun ne soient pas de la même couleur. Le résultat fut initialement conjecturé en 1852, avec les deux premières preuves étant publiées en 1879 et 1880, celles-ci se révélant cependant fausses. La première preuve utilisant l'outil informatique date de 1976 et fut reprise et simplifiée par la suite. Enfin, en 2005, Georges Gonthier et Benjamin Werner ont réussi à formuler avec Coq une preuve formelle permettant à un ordinateur de complètement vérifier le théorème des quatre couleurs. À ce jour, aucune preuve qui ne fasse pas appel à un ordinateur n'a été découverte.

* '''Théorème de Feit-Thompson'''

Le théorème de Feit-Thompson énonce que tout groupe fini d'ordre impair est résoluble, ce qui équivaut à dire que tout groupe simple fini non commutatif est d'ordre pair. Le théorème fut conjecturé en 1911 par William Burnside et démontré en 1963 par Walter Feit et John Griggs Thompson. Une formalisation de la preuve en Coq a été achevée en 2012 par Georges Gonthier et son équipe du laboratoire commun Inria-Microsoft.

Coq sert également à la certification de logiciel. Parmi la multitude d'exemples, on peut mentionner :

* '''CompCert'''

CompCert est un compilateur pour le langage C qui utilise des preuves formelles pour vérifier le code. Cela est réalisé notamment en Coq.

* '''Iris Project'''

Iris Project est un logiciel de séparation logique simultanée d'ordre supérieure (''demander informations complémentaires'')

----
Oral :

Software Foundation (pédagogique :wave:)
VST (Verified Software Toolchain)
fscq
Bedrock
CFML

Conclusion :
Je n'ai pas pu couvrir qu'une fraction des fonctionnalités proposées par Coq, mais j'ai quand même atteint l'objectif que mon tuteur avait fixé.

== Types, fonctions et preuves basiques ==

=== Déclaration de types ===

Pour définir un type sur Coq, une première méthode est l'induction. Cela consiste à utiliser les différents cas particuliers pour définir le cas général.
<pre lang="coq">Inductive day : Type :=
| monday
| tuesday
| wednesday
| thursday
| friday
| saturday
| sunday.</pre>

Ici, pour le type ''day'', on énumère les différentes valeurs que peut adopter le type, à savoir les jours de la semaine. Cette méthode permet notamment de définir des types dont l'ensemble de valeurs possibles est fini, comme les booléens ou les bits. Cependant, tenter de représenter les nombres avec cette méthode est contre-indiqué, car il faudrait un temps et une capacité de stockage disproportionnellement élevés.

Pour définir les nombres ou d'autres types dont l'ensemble de valeurs possibles est infini, il est possible de définir un type par récurrence.
<pre lang="coq">Inductive nat : Type:=
| O
| S (n : nat).</pre>

Dans ce cas-là, par exemple, on définit le type ''nat'' (correspondant aux entiers naturels) par un cas initial, ici 0, modélisé par la lettre O, et une hérédité, ici le fait que pour tout n ∈ ℕ, il existe un n' appartenant à ce même intervalle tel que n corresponde à S n'. L'écriture mathématique équivalente de cette définition est :
<math>\forall n > 0, \exists n' \geqslant 0, n = n' + 1</math>

Enfin, il est également possible avec Coq de créer un type utilisant un autre type pour sa définition. Ainsi, si l'on définit comme suit les teintes RGB d'une couleur :
<pre lang="coq">Inductive rgb : Type :=
| red
| green
| blue.</pre>
Il est possible de définir les composantes d'une couleur en utilisant le type ''rgb'' préalablement créé :
<pre lang="coq">Inductive color : Type :=
| black
| white
| primary (p : rgb).</pre>
Ainsi, ''color'' possède trois composantes, à savoir black, white et primary, cette dernière ayant elle-même trois composantes, red, green et blue.

=== Fonctions ===

Il y a plusieurs manières de définir une fonction dans Coq. La première est d'utiliser la commande '''''Definition''''' et de spécifier au cas par cas quel résultat la fonction retourne selon la valeur de la variable d'entrée.
 
Ainsi, en reprenant le type ''day'', on peut définir la fonction next_weekday comme suit :
<pre lang="coq">Definition next_weekday (d:day) : day :=
match d with
| monday => tuesday
| tuesday => wednesday
| wednesday => thursday
| thursday => friday
| friday => saturday
| saturday => sunday
| sunday => monday
end.</pre>
Dans cet exemple, on introduit le nom de la fonction, on indique le nom utilisé en son sein pour désigner la variable ainsi que son type, puis le type du résultat.
 
L'instruction ''match d with'' sert à analyser la valeur de la variable d. La liste qui suit signifie que pour telle valeur de d (par exemple wednesday), on retourne le résultat indiqué par la flèche (ici thursday). Enfin, la commande ''end'' permet de délimiter la fin de la fonction.

Cependant, il est également possible de ne retenir que certains cas et de retourner une même réponse pour tous les cas non vérifiés, dans la même veine qu'un ''else'' dans d'autres langages.
 
Par exemple, en supposant que l'on a défini précédemment un type ''bool'' qui ne peut prendre que true et false comme valeurs, on peut établir la fonction suivante :
<pre lang="coq">Definition isred (c : color) : bool :=
match c with
| black => false
| white => false
| primary red => true
| primary _ => false
end.</pre>
Ici, si l'on voulait écrire la fonction en Python, on aurait :
<pre lang="python">def isred(c) :
if c == black :
return False
elif c == white :
return False :
elif c == primary[red] :
return True
else :
return False</pre>
On remarque donc que le caractère _ signifie "dans tous les autres cas possibles", ce qui permet de ne retenir que les situations particulières et de généraliser le reste.

Une autre manière d'écrire une fonction est d'utiliser la commande '''''Fixpoint'''''. La différence majeure entre Fixpoint et Definition est la possibilité d'appeler la fonction récursivement avec Fixpoint.

Par exemple, une fonction pour définir si un entier naturel est pair s'écrit :
<pre lang="coq">Fixpoint evenb(n:nat) : bool :=
match n with
| 0 => true
| S 0 => false
| S (S n') => evenb n'</pre>

Cela signifie que pour tout entier n, trois cas de figure se présentent :
# <math> n = 0 \rightarrow n\ pair </math>
# <math> n = 1 \rightarrow n\ non\ pair </math>
# <math> \exists n', n = n' + 2 </math>
Dans le troisième cas, on réitère l'étude, mais avec n'.

Enfin, une troisième méthode pour définir une fonction est la commande '''''Theorem''''' qui permet, comme son nom l'indique, de définir un théorème, généralement sous la forme d'une égalité ou d'une implication. S'il s'agit d'une implication A -> B, A peut être utilisé comme hypothèse lors de la preuve.

=== Preuves simples ===

==== Structure générale ====

Dans Coq, la structure d'une preuve suit toujours la même structure :
<pre lang="coq">Proof. (* On indique le début de la preuve... *)
(* On insère ici toutes les instructions nécessaires... *)
Qed. (* Quod erat demonstrandum, équivalent latin de C.Q.F.D., signifie que la preuve est finie *)</pre>

==== Tactiques ====

Les tactiques sont des instructions pour aider Coq à résoudre une preuve.

* simpl.

simpl. permet, comme son nom l'indique, de simplifier une formule.

* reflexivity.

reflexivity. permet de vérifier si une égalité est du type a = a. Si la réflexivité de l'égalité est prouvée, alors la proposition est vraie. Cette instruction permet généralement d'achever une preuve.

* intros n.

intros. s'utilise en début de preuve pour introduire les variables présentes dans un théorème ou une hypothèse. S'il y a plusieurs variables à introduire, il faut les séparer par des espaces

* unfold f.

unfold f. permet de développer l'expression à étudier selon la fonction f.

* rewrite <- / -> H.

Permet de réécrire l'expression en fonction de l'hypothèse H. La flèche <- indique que l'on souhaite passer du membre de droite à celui de gauche et inversement pour ->. Coq va ensuite essayer de trouver un membre de l'expression qui correspond au terme de départ et va le remplacer par le terme d'arrivée.

* destruct n as [n1 | n2 | ...] eqn:E.

destruct permet de décomposer une variable en plusieurs cas de figure qui sont traités séparément. destruct fonctionne différemment selon le type de la variable utilisée. Avec les booléens ou d'autres types binaires, on peut se passer du as [...] car il n'y a par définition que deux valeurs que peut prendre la variable. Avec les entiers, on va généralement décomposer sous la forme as [| n'], autrement dit, on établit une pseudo-récurrence en vérifiant pour n = 0 et ensuite pour tout n' tel que n = n' + 1. Il ne s'agit cependant pas d'une vraie récurrence car il n'y a pas de lien entre n et n'.

==== Séparation des cas ====

Dans Coq, certaines commandes comme destruct occasionnent une séparation de l'expression en plusieurs cas. Pour identifier ces cas, il y a deux méthodes.

# Commencer chaque cas par une puce (-, + et * dans cet ordre)
# Délimiter un cas par des astérisque {}, ce qui permet de réinitialiser la hiérarchie des puces

== Preuve par récurrence, preuves à l'intérieur de preuves, preuves formelles et informelles ==

=== Preuve par récurrence ===

Bien que les tactiques mentionnées dans la partie précédente permettent de résoudre une grande partie des preuves, certains cas requièrent une attention plus particulière. Si la situation s'y prête, on peut notamment utiliser la récurrence avec la syntaxe suivante :

<pre lang="coq">Proof.
intros n. induction n as [| n' IHn']. (* On décompose n en un cas initial, généralement 0, et on introduit l'hypothèse que la proposition est vérifiée pour un palier arbitraire n'. *)
- (* Initialisation. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée pour le cas initial. *)
- (* Hérédité. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée à un niveau n' + 1 si elle est vérifiée pour n'. *)
Qed.</pre>

Ben que la récurrence soit une tactique puissante, il vaut mieux la réserver aux situations qui le nécessitent. Il est également nécessaire d'utiliser à un moment l'hypothèse d'hérédité avec rewrite. S'il est possible de compléter la preuve sans l'utiliser, une autre tactique aurait été probablement plus appropriée.

=== Preuves à l'intérieur de preuves ===

Parfois, il n'est pas possible de démontrer une équation telle quelle. Il faut passer par un lemme qui est introduit en Coq par l'instruction '''''assert'''''. Par exemple, la preuve servant à démontrer que <math>\forall n,m \in \mathbb{R}, (0 + n) * m = n * m</math> se structure comme tel :

<pre lang="Coq">Proof.
intros n m. (* On introduit les deux variables n et m *)
assert (H: 0 + n = n). (* On définit le lemme H qui dit que 0 + n = n *)
{ reflexivity. } (* On vérifie que H est vrai *)
rewrite -> H. (* On reformule l'équation initiale en remplaçant 0 + n par n, maintenant que l'on sait que les deux sont égaux *)
reflexivity. (* Les deux membres de l'équation sont alors identiques, la preuve est achevée *)
Qed.</pre>

=== Preuves formelles et informelles ===

Le principe d'une preuve est de convaincre le lecteur de sa véracité. Cependant, tous les lecteurs n'ont pas la même capacité de compréhension.

Par exemple, en langage mathématique, le théorème de Taylor à l'ordre n en a pourrait s'écrire :

<math>f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</math>

Cette écriture peut être lue aisément par un humain, mais pas par une machine. Cependant, si l'on écrit :

<pre lang="latex">f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</pre>

Un humain aurait du mal à lire cette ligne de code, mais un interpréteur LaTeX le lirait comme l'équation précédente. Il existe donc plusieurs façons de présenter la même information en fonction du lecteur visé. Il en est de même pour les preuves sur Coq.

* Preuves formelles

Les preuves formelles sont celles que Coq peut comprendre facilement et qui n'est pas prévue pour être facilement comprise par un humain. Par exemple, la preuve formelle de l'associativité de l'addition est structurée comme suit :

<pre lang="coq">Proof. intros n m p. induction n as [| n' IHn']. reflexivity. simpl. rewrite -> IHn'. reflexivity. Qed.</pre>

Le code est réduit à l'essentiel, mais la clarté pour le lecteur humain est moindre.

* Preuves informelles

Les preuves informelles sont celles que Coq accepte et qu'un humain peut comprendre facilement. Par exemple, la preuve informelle de l'associativité de l'addition est structurée comme tel :

<pre lang="coq">Proof.
intros n m p. induction n as [| n' IHn'].
- (* n = 0 *)
reflexivity.
- (* n = S n' *)
simpl. rewrite -> IHn'. reflexivity.
Qed.</pre>

Ici, on a éclaté le code pour notamment séparer les deux cas étudiés lors de la récurrence et on a ajouté des commentaires. Coq interprète toujours le code, mais un lecteur humain peut davantage comprendre ce qui se passe.

== Listes, sacs de nombres et opérations sur ces types ==

=== Listes de nombres ===

Dans Coq, on peut définir une liste de nombres sous le type '''''natlistx''''' de façon récursive. Une liste est composée soit de l'élément vide, soit de la concaténation d'un entier naturel et d'une autre liste. Parmi les différentes opérations que l'on peut exécuter sur les listes, on peut évoquer :

* Créer une liste de longueur déterminée composée d'un seul élément

<pre lang="coq">Fixpoint repeat (n count : nat) : natlist :=
match count with (* Si count vaut... *)
| O => nil (* ... 0, on ferme la liste avec l'élément nul *)
| S count' => n :: (repeat n count') (* ... count' + 1, on concatène le nombre avec la liste de longueur count' répétant ce nombre *)
end.</pre>

* Calculer la longueur d'une liste

<pre lang="coq">Fixpoint length (l:natlist) : nat :=
match l with
| nil => O (* Cas 1, la liste n'est composée que de l'élément nul, sa longueur est donc nulle *)
| h :: t => S (length t) (* Cas 2, la liste est composée de la concaténation d'un entier et d'une liste, sa longueur vaut donc 1 + la longueur de cette deuxième liste *)
end.</pre>

* Joindre deux listes

<pre lang="coq">Fixpoint app (l1 l2 : natlist) : natlist :=
match l1 with
| nil => l2 (* Si la première liste est vide, le résultat de la jonction est donc la seule deuxième liste *)
| h :: t => h :: (app t l2) (* Si la première liste est composée d'un entier et d'une liste, on concatène cet entier avec la jonction de la liste et de la deuxième liste *)
end.</pre>

* Définir la tête et la queue d'une liste

<pre lang="coq">Definition hd (default:nat) (l:natlist) : nat :=
match l with
| nil => default (* Si la liste est vide, on retourne le nombre défini par défaut, l'élément vide n'ayant pas de premier élément *)
| h :: t => h (* Si la liste est composée d'un entier et d'une liste, on retourne l'entier, celui-ci étant le premier élément *)
end.</pre>

<pre lang="coq">Definition tl (l:natlist) : natlist :=
match l with
| nil => nil (* Si la liste est vide, on retourne l'ensemble vide *)
| h :: t => t (* Si la liste est composée d'un entier et d'une liste, on retourne la liste *)
end.</pre>

=== Sacs de nombres ===

Un sac de nombres ressemble à une liste, à l'exception prêt qu'un même élément peut apparaître plusieurs fois. Mis à part ce détail, le type '''''bag''''' est défini comme une liste de nombres. Parmi les opérations possibles sur ce type, on peut citer :

* Compter le nombre d'occurrence d'un nombre au sein d'un sac

<pre lang="coq">Fixpoint count (v:nat) (s:bag) : nat :=
match s with
| nil => 0 (* Si la liste est vide, l'élément recherché ne peut pas apparaître *)
| h :: t => match h =? v with (* Si la liste est composée d'un entier et d'une liste, on compare l'entier avec l'élément recherché *)
| true => S (count v t) (* S'ils sont égaux, on continue la recherche sur le reste de la liste en ajoutant 1 au nombre d'occurrences *)
| false => count v t (* S'ils ne sont pas égaux, on continue la recherche sur le reste de la liste *)
end
end.</pre>

* Vérifier qu'un nombre appartient à un sac

<pre lang="coq">Fixpoint member (v:nat) (s:bag) : bool :=
match s with
| nil => false
| h :: t => match h =? v with
| true => true
| false => member v t
end
end.</pre>

* Retirer un ou toutes les occurrences d'un nombre dans un sac

<pre lang="coq">Fixpoint remove_one (v:nat) (s:bag) : bag :=
match s with
| nil => nil (* Si la liste est vide, on n'a plus rien à enlever *)
| h :: t => match h =? v with (* Similairement à count, si la liste est composée d'un entier et d'une liste, on compare l'entier à l'élément recherché *)
| true => t (* S'ils sont égaux, on retourne le reste de la liste, car on a enlevé la première occurrence d'un élément *)
| false => h :: remove_one v t (* S'ils ne sont pas égaux, on concatène l'entier avec le résultat de la recherche au sein de la liste restante *)
end
end.</pre>

remove_all et remove_one fonctionne exactement de la même manière, excepté que remove_all continue la recherche dans tous les cas.

<pre lang="coq">Fixpoint remove_all (v:nat) (s:bag) : bag :=
match s with
| nil => nil
| h :: t => match h =? v with
| true => remove_all v t
| false => h :: remove_all v t
end
end.</pre>

* Vérifier qu'un sac est inclus dans un deuxième sac

<pre lang="coq">Fixpoint subset (s1:bag) (s2:bag) : bool :=
match s1 with
| nil => true (* Si le sac de référence est vide, il est forcément inclus dans le deuxième sac *)
| h :: t => match (member h s2) with (* Si le sac de référence est composée d'un entier et d'une liste, on regarde si cet entier est présent dans le deuxième sac *)
| true => subset t (remove_one h s2) (* S'il est présent, on continue la recherche avec le reste du sac de référence est en retirant une occurrence de l'élément dans le deuxième sac *)
| false => false (* S'il n'est pas présent, alors le sac de référence n'est pas inclus dans le deuxième sac *)
end
end.</pre>

== Sources et annexes ==

'''Sources'''

* Software Foundations volume 1 [https://softwarefoundations.cis.upenn.edu/lf-current/index.html]

* Page Wikipédia de Coq [https://fr.wikipedia.org/wiki/Coq_(logiciel)]

'''Annexe'''

* Théorème des quatre couleurs [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_des_quatre_couleurs]

* Théorème de Feit-Thompson [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_de_Feit-Thompson]

* Compcert [http://compcert.inria.fr/]

* Iris Project [https://iris-project.org/]

* Software Foundations [https://softwarefoundations.cis.upenn.edu/]

* Verified Software Toolchain [https://vst.cs.princeton.edu/]

* FSCQ [http://css.csail.mit.edu/fscq/]

* Bedrock [http://plv.csail.mit.edu/bedrock/]

* CFML [https://www.chargueraud.org/softs/cfml/]

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-08T08:44:26Z

Dornel :

== Introduction ==

Coq est un logiciel d'aide à la preuve mathématique développé par les équipes PI.R2 et Marelle d'Inria et l'équipe Systèmes Sûrs du Cnam. La première version a été publiée en 1984 et a été codée sous CAML.

Coq est fondé sur le calcul des constructions, une théorie concurrente à la théorie des ensembles de Zermelo-Fraenkel dont l'une des particularités est que les preuves sont au même niveau que les fonctions.

Parmi les théorèmes issus des mathématiques dont les preuves sont volumineuses et qui ont été démontrées à l'aide de Coq, on peut citer notamment :

* '''Théorème des quatre couleurs'''

Le théorème des quatre couleurs indique qu'il est possible en utilisant seulement quatre couleurs différentes de colorier n'importe quelle carte découpée en régions de sorte que deux régions ayant une frontière en commun ne soient pas de la même couleur. Le résultat fut initialement conjecturé en 1852, avec les deux premières preuves étant publiées en 1879 et 1880, celles-ci se révélant cependant fausses. La première preuve utilisant l'outil informatique date de 1976 et fut reprise et simplifiée par la suite. Enfin, en 2005, Georges Gonthier et Benjamin Werner ont réussi à formuler avec Coq une preuve formelle permettant à un ordinateur de complètement vérifier le théorème des quatre couleurs. À ce jour, aucune preuve qui ne fasse pas appel à un ordinateur n'a été découverte.

* '''Théorème de Feit-Thompson'''

Le théorème de Feit-Thompson énonce que tout groupe fini d'ordre impair est résoluble, ce qui équivaut à dire que tout groupe simple fini non commutatif est d'ordre pair. Le théorème fut conjecturé en 1911 par William Burnside et démontré en 1963 par Walter Feit et John Griggs Thompson. Une formalisation de la preuve en Coq a été achevée en 2012 par Georges Gonthier et son équipe du laboratoire commun Inria-Microsoft.

Coq sert également à la certification de logiciel. Parmi la multitude d'exemples, on peut mentionner :

* '''CompCert'''

CompCert est un compilateur pour le langage C qui utilise des preuves formelles pour vérifier le code. Cela est réalisé notamment en Coq.

* '''Iris Project'''

Iris Project est un logiciel de séparation logique simultanée d'ordre supérieure (''demander informations complémentaires'')

----
Oral :

Software Foundation (pédagogique :wave:)
VST (Verified Software Toolchain)
fscq
Bedrock
CFML

Conclusion :
Je n'ai pas pu couvrir qu'une fraction des fonctionnalités proposées par Coq, mais j'ai quand même atteint l'objectif que mon tuteur avait fixé.

== Types, fonctions et preuves basiques ==

=== Déclaration de types ===

Pour définir un type sur Coq, une première méthode est l'induction. Cela consiste à utiliser les différents cas particuliers pour définir le cas général.
<pre lang="coq">Inductive day : Type :=
| monday
| tuesday
| wednesday
| thursday
| friday
| saturday
| sunday.</pre>

Ici, pour le type ''day'', on énumère les différentes valeurs que peut adopter le type, à savoir les jours de la semaine. Cette méthode permet notamment de définir des types dont l'ensemble de valeurs possibles est fini, comme les booléens ou les bits. Cependant, tenter de représenter les nombres avec cette méthode est contre-indiqué, car il faudrait un temps et une capacité de stockage disproportionnellement élevés.

Pour définir les nombres ou d'autres types dont l'ensemble de valeurs possibles est infini, il est possible de définir un type par récurrence.
<pre lang="coq">Inductive nat : Type:=
| O
| S (n : nat).</pre>

Dans ce cas-là, par exemple, on définit le type ''nat'' (correspondant aux entiers naturels) par un cas initial, ici 0, modélisé par la lettre O, et une hérédité, ici le fait que pour tout n ∈ ℕ, il existe un n' appartenant à ce même intervalle tel que n corresponde à S n'. L'écriture mathématique équivalente de cette définition est :
<math>\forall n > 0, \exists n' \geqslant 0, n = n' + 1</math>

Enfin, il est également possible avec Coq de créer un type utilisant un autre type pour sa définition. Ainsi, si l'on définit comme suit les teintes RGB d'une couleur :
<pre lang="coq">Inductive rgb : Type :=
| red
| green
| blue.</pre>
Il est possible de définir les composantes d'une couleur en utilisant le type ''rgb'' préalablement créé :
<pre lang="coq">Inductive color : Type :=
| black
| white
| primary (p : rgb).</pre>
Ainsi, ''color'' possède trois composantes, à savoir black, white et primary, cette dernière ayant elle-même trois composantes, red, green et blue.

=== Fonctions ===

Il y a plusieurs manières de définir une fonction dans Coq. La première est d'utiliser la commande '''''Definition''''' et de spécifier au cas par cas quel résultat la fonction retourne selon la valeur de la variable d'entrée.
 
Ainsi, en reprenant le type ''day'', on peut définir la fonction next_weekday comme suit :
<pre lang="coq">Definition next_weekday (d:day) : day :=
match d with
| monday => tuesday
| tuesday => wednesday
| wednesday => thursday
| thursday => friday
| friday => saturday
| saturday => sunday
| sunday => monday
end.</pre>
Dans cet exemple, on introduit le nom de la fonction, on indique le nom utilisé en son sein pour désigner la variable ainsi que son type, puis le type du résultat.
 
L'instruction ''match d with'' sert à analyser la valeur de la variable d. La liste qui suit signifie que pour telle valeur de d (par exemple wednesday), on retourne le résultat indiqué par la flèche (ici thursday). Enfin, la commande ''end'' permet de délimiter la fin de la fonction.

Cependant, il est également possible de ne retenir que certains cas et de retourner une même réponse pour tous les cas non vérifiés, dans la même veine qu'un ''else'' dans d'autres langages.
 
Par exemple, en supposant que l'on a défini précédemment un type ''bool'' qui ne peut prendre que true et false comme valeurs, on peut établir la fonction suivante :
<pre lang="coq">Definition isred (c : color) : bool :=
match c with
| black => false
| white => false
| primary red => true
| primary _ => false
end.</pre>
Ici, si l'on voulait écrire la fonction en Python, on aurait :
<pre lang="python">def isred(c) :
if c == black :
return False
elif c == white :
return False :
elif c == primary[red] :
return True
else :
return False</pre>
On remarque donc que le caractère _ signifie "dans tous les autres cas possibles", ce qui permet de ne retenir que les situations particulières et de généraliser le reste.

Une autre manière d'écrire une fonction est d'utiliser la commande '''''Fixpoint'''''. La différence majeure entre Fixpoint et Definition est la possibilité d'appeler la fonction récursivement avec Fixpoint.

Par exemple, une fonction pour définir si un entier naturel est pair s'écrit :
<pre lang="coq">Fixpoint evenb(n:nat) : bool :=
match n with
| 0 => true
| S 0 => false
| S (S n') => evenb n'</pre>

Cela signifie que pour tout entier n, trois cas de figure se présentent :
# <math> n = 0 \rightarrow n\ pair </math>
# <math> n = 1 \rightarrow n\ non\ pair </math>
# <math> \exists n', n = n' + 2 </math>
Dans le troisième cas, on réitère l'étude, mais avec n'.

Enfin, une troisième méthode pour définir une fonction est la commande '''''Theorem''''' qui permet, comme son nom l'indique, de définir un théorème, généralement sous la forme d'une égalité ou d'une implication. S'il s'agit d'une implication A -> B, A peut être utilisé comme hypothèse lors de la preuve.

=== Preuves simples ===

==== Structure générale ====

Dans Coq, la structure d'une preuve suit toujours la même structure :
<pre lang="coq">Proof. (* On indique le début de la preuve... *)
(* On insère ici toutes les instructions nécessaires... *)
Qed. (* Quod erat demonstrandum, équivalent latin de C.Q.F.D., signifie que la preuve est finie *)</pre>

==== Tactiques ====

Les tactiques sont des instructions pour aider Coq à résoudre une preuve.

* simpl.

simpl. permet, comme son nom l'indique, de simplifier une formule.

* reflexivity.

reflexivity. permet de vérifier si une égalité est du type a = a. Si la réflexivité de l'égalité est prouvée, alors la proposition est vraie. Cette instruction permet généralement d'achever une preuve.

* intros n.

intros. s'utilise en début de preuve pour introduire les variables présentes dans un théorème ou une hypothèse. S'il y a plusieurs variables à introduire, il faut les séparer par des espaces

* unfold f.

unfold f. permet de développer l'expression à étudier selon la fonction f.

* rewrite <- / -> H.

Permet de réécrire l'expression en fonction de l'hypothèse H. La flèche <- indique que l'on souhaite passer du membre de droite à celui de gauche et inversement pour ->. Coq va ensuite essayer de trouver un membre de l'expression qui correspond au terme de départ et va le remplacer par le terme d'arrivée.

* destruct n as [n1 | n2 | ...] eqn:E.

destruct permet de décomposer une variable en plusieurs cas de figure qui sont traités séparément. destruct fonctionne différemment selon le type de la variable utilisée. Avec les booléens ou d'autres types binaires, on peut se passer du as [...] car il n'y a par définition que deux valeurs que peut prendre la variable. Avec les entiers, on va généralement décomposer sous la forme as [| n'], autrement dit, on établit une pseudo-récurrence en vérifiant pour n = 0 et ensuite pour tout n' tel que n = n' + 1. Il ne s'agit cependant pas d'une vraie récurrence car il n'y a pas de lien entre n et n'.

==== Séparation des cas ====

Dans Coq, certaines commandes comme destruct occasionnent une séparation de l'expression en plusieurs cas. Pour identifier ces cas, il y a deux méthodes.

# Commencer chaque cas par une puce (-, + et * dans cet ordre)
# Délimiter un cas par des astérisque {}, ce qui permet de réinitialiser la hiérarchie des puces

== Preuve par récurrence, preuves à l'intérieur de preuves, preuves formelles et informelles ==

=== Preuve par récurrence ===

Bien que les tactiques mentionnées dans la partie précédente permettent de résoudre une grande partie des preuves, certains cas requièrent une attention plus particulière. Si la situation s'y prête, on peut notamment utiliser la récurrence avec la syntaxe suivante :

<pre lang="coq">Proof.
intros n. induction n as [| n' IHn']. (* On décompose n en un cas initial, généralement 0, et on introduit l'hypothèse que la proposition est vérifiée pour un palier arbitraire n'. *)
- (* Initialisation. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée pour le cas initial. *)
- (* Hérédité. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée à un niveau n' + 1 si elle est vérifiée pour n'. *)
Qed.</pre>

Ben que la récurrence soit une tactique puissante, il vaut mieux la réserver aux situations qui le nécessitent. Il est également nécessaire d'utiliser à un moment l'hypothèse d'hérédité avec rewrite. S'il est possible de compléter la preuve sans l'utiliser, une autre tactique aurait été probablement plus appropriée.

=== Preuves à l'intérieur de preuves ===

Parfois, il n'est pas possible de démontrer une équation telle quelle. Il faut passer par un lemme qui est introduit en Coq par l'instruction '''''assert'''''. Par exemple, la preuve servant à démontrer que <math>\forall n,m \in \mathbb{R}, (0 + n) * m = n * m</math> se structure comme tel :

<pre lang="Coq">Proof.
intros n m. (* On introduit les deux variables n et m *)
assert (H: 0 + n = n). (* On définit le lemme H qui dit que 0 + n = n *)
{ reflexivity. } (* On vérifie que H est vrai *)
rewrite -> H. (* On reformule l'équation initiale en remplaçant 0 + n par n, maintenant que l'on sait que les deux sont égaux *)
reflexivity. (* Les deux membres de l'équation sont alors identiques, la preuve est achevée *)
Qed.</pre>

=== Preuves formelles et informelles ===

Le principe d'une preuve est de convaincre le lecteur de sa véracité. Cependant, tous les lecteurs n'ont pas la même capacité de compréhension.

Par exemple, en langage mathématique, le théorème de Taylor à l'ordre n en a pourrait s'écrire :

<math>f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</math>

Cette écriture peut être lue aisément par un humain, mais pas par une machine. Cependant, si l'on écrit :

<pre lang="latex">f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</pre>

Un humain aurait du mal à lire cette ligne de code, mais un interpréteur LaTeX le lirait comme l'équation précédente. Il existe donc plusieurs façons de présenter la même information en fonction du lecteur visé. Il en est de même pour les preuves sur Coq.

* Preuves formelles

Les preuves formelles sont celles que Coq peut comprendre facilement et qui n'est pas prévue pour être facilement comprise par un humain. Par exemple, la preuve formelle de l'associativité de l'addition est structurée comme suit :

<pre lang="coq">Proof. intros n m p. induction n as [| n' IHn']. reflexivity. simpl. rewrite -> IHn'. reflexivity. Qed.</pre>

Le code est réduit à l'essentiel, mais la clarté pour le lecteur humain est moindre.

* Preuves informelles

Les preuves informelles sont celles que Coq accepte et qu'un humain peut comprendre facilement. Par exemple, la preuve informelle de l'associativité de l'addition est structurée comme tel :

<pre lang="coq">Proof.
intros n m p. induction n as [| n' IHn'].
- (* n = 0 *)
reflexivity.
- (* n = S n' *)
simpl. rewrite -> IHn'. reflexivity.
Qed.</pre>

Ici, on a éclaté le code pour notamment séparer les deux cas étudiés lors de la récurrence et on a ajouté des commentaires. Coq interprète toujours le code, mais un lecteur humain peut davantage comprendre ce qui se passe.

== Paires, listes et sacs de nombres ==

== Sources et annexes ==

'''Sources'''

* Software Foundations volume 1 [https://softwarefoundations.cis.upenn.edu/lf-current/index.html]

* Page Wikipédia de Coq [https://fr.wikipedia.org/wiki/Coq_(logiciel)]

'''Annexe'''

* Théorème des quatre couleurs [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_des_quatre_couleurs]

* Théorème de Feit-Thompson [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_de_Feit-Thompson]

* Compcert [http://compcert.inria.fr/]

* Iris Project [https://iris-project.org/]

* Software Foundations [https://softwarefoundations.cis.upenn.edu/]

* Verified Software Toolchain [https://vst.cs.princeton.edu/]

* FSCQ [http://css.csail.mit.edu/fscq/]

* Bedrock [http://plv.csail.mit.edu/bedrock/]

* CFML [https://www.chargueraud.org/softs/cfml/]

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-07T14:54:22Z

Dornel : /* Preuves formelles et informelles */

== Introduction ==

Coq est un logiciel d'aide à la preuve mathématique développé par les équipes PI.R2 et Marelle d'Inria et l'équipe Systèmes Sûrs du Cnam. La première version a été publiée en 1984 et a été codée sous CAML.

Coq est fondé sur le calcul des constructions, une théorie concurrente à la théorie des ensembles de Zermelo-Fraenkel dont l'une des particularités est que les preuves sont au même niveau que les fonctions.

Parmi les théorèmes issus des mathématiques dont les preuves sont volumineuses et qui ont été démontrées à l'aide de Coq, on peut citer notamment :

* '''Théorème des quatre couleurs'''

Le théorème des quatre couleurs indique qu'il est possible en utilisant seulement quatre couleurs différentes de colorier n'importe quelle carte découpée en régions de sorte que deux régions ayant une frontière en commun ne soient pas de la même couleur. Le résultat fut initialement conjecturé en 1852, avec les deux premières preuves étant publiées en 1879 et 1880, celles-ci se révélant cependant fausses. La première preuve utilisant l'outil informatique date de 1976 et fut reprise et simplifiée par la suite. Enfin, en 2005, Georges Gonthier et Benjamin Werner ont réussi à formuler avec Coq une preuve formelle permettant à un ordinateur de complètement vérifier le théorème des quatre couleurs. À ce jour, aucune preuve qui ne fasse pas appel à un ordinateur n'a été découverte.

* '''Théorème de Feit-Thompson'''

Le théorème de Feit-Thompson énonce que tout groupe fini d'ordre impair est résoluble, ce qui équivaut à dire que tout groupe simple fini non commutatif est d'ordre pair. Le théorème fut conjecturé en 1911 par William Burnside et démontré en 1963 par Walter Feit et John Griggs Thompson. Une formalisation de la preuve en Coq a été achevée en 2012 par Georges Gonthier et son équipe du laboratoire commun Inria-Microsoft.

Coq sert également à la certification de logiciel. Parmi la multitude d'exemples, on peut mentionner :

* '''CompCert'''

CompCert est un compilateur pour le langage C qui utilise des preuves formelles pour vérifier le code. Cela est réalisé notamment en Coq.

* '''Iris Project'''

Iris Project est un logiciel de séparation logique simultanée d'ordre supérieure (''demander informations complémentaires'')

----
Oral :

Software Foundation (pédagogique :wave:)
VST (Verified Software Toolchain)
fscq
Bedrock
CFML

Conclusion :
Je n'ai pas pu couvrir qu'une fraction des fonctionnalités proposées par Coq, mais j'ai quand même atteint l'objectif que mon tuteur avait fixé.

== Types, fonctions et preuves basiques ==

=== Déclaration de types ===

Pour définir un type sur Coq, une première méthode est l'induction. Cela consiste à utiliser les différents cas particuliers pour définir le cas général.
<pre lang="coq">Inductive day : Type :=
| monday
| tuesday
| wednesday
| thursday
| friday
| saturday
| sunday.</pre>

Ici, pour le type ''day'', on énumère les différentes valeurs que peut adopter le type, à savoir les jours de la semaine. Cette méthode permet notamment de définir des types dont l'ensemble de valeurs possibles est fini, comme les booléens ou les bits. Cependant, tenter de représenter les nombres avec cette méthode est contre-indiqué, car il faudrait un temps et une capacité de stockage disproportionnellement élevés.

Pour définir les nombres ou d'autres types dont l'ensemble de valeurs possibles est infini, il est possible de définir un type par récurrence.
<pre lang="coq">Inductive nat : Type:=
| O
| S (n : nat).</pre>

Dans ce cas-là, par exemple, on définit le type ''nat'' (correspondant aux entiers naturels) par un cas initial, ici 0, modélisé par la lettre O, et une hérédité, ici le fait que pour tout n ∈ ℕ, il existe un n' appartenant à ce même intervalle tel que n corresponde à S n'. L'écriture mathématique équivalente de cette définition est :
<math>\forall n > 0, \exists n' \geqslant 0, n = n' + 1</math>

Enfin, il est également possible avec Coq de créer un type utilisant un autre type pour sa définition. Ainsi, si l'on définit comme suit les teintes RGB d'une couleur :
<pre lang="coq">Inductive rgb : Type :=
| red
| green
| blue.</pre>
Il est possible de définir les composantes d'une couleur en utilisant le type ''rgb'' préalablement créé :
<pre lang="coq">Inductive color : Type :=
| black
| white
| primary (p : rgb).</pre>
Ainsi, ''color'' possède trois composantes, à savoir black, white et primary, cette dernière ayant elle-même trois composantes, red, green et blue.

=== Fonctions ===

Il y a plusieurs manières de définir une fonction dans Coq. La première est d'utiliser la commande '''''Definition''''' et de spécifier au cas par cas quel résultat la fonction retourne selon la valeur de la variable d'entrée.
 
Ainsi, en reprenant le type ''day'', on peut définir la fonction next_weekday comme suit :
<pre lang="coq">Definition next_weekday (d:day) : day :=
match d with
| monday => tuesday
| tuesday => wednesday
| wednesday => thursday
| thursday => friday
| friday => saturday
| saturday => sunday
| sunday => monday
end.</pre>
Dans cet exemple, on introduit le nom de la fonction, on indique le nom utilisé en son sein pour désigner la variable ainsi que son type, puis le type du résultat.
 
L'instruction ''match d with'' sert à analyser la valeur de la variable d. La liste qui suit signifie que pour telle valeur de d (par exemple wednesday), on retourne le résultat indiqué par la flèche (ici thursday). Enfin, la commande ''end'' permet de délimiter la fin de la fonction.

Cependant, il est également possible de ne retenir que certains cas et de retourner une même réponse pour tous les cas non vérifiés, dans la même veine qu'un ''else'' dans d'autres langages.
 
Par exemple, en supposant que l'on a défini précédemment un type ''bool'' qui ne peut prendre que true et false comme valeurs, on peut établir la fonction suivante :
<pre lang="coq">Definition isred (c : color) : bool :=
match c with
| black => false
| white => false
| primary red => true
| primary _ => false
end.</pre>
Ici, si l'on voulait écrire la fonction en Python, on aurait :
<pre lang="python">def isred(c) :
if c == black :
return False
elif c == white :
return False :
elif c == primary[red] :
return True
else :
return False</pre>
On remarque donc que le caractère _ signifie "dans tous les autres cas possibles", ce qui permet de ne retenir que les situations particulières et de généraliser le reste.

Une autre manière d'écrire une fonction est d'utiliser la commande '''''Fixpoint'''''. La différence majeure entre Fixpoint et Definition est la possibilité d'appeler la fonction récursivement avec Fixpoint.

Par exemple, une fonction pour définir si un entier naturel est pair s'écrit :
<pre lang="coq">Fixpoint evenb(n:nat) : bool :=
match n with
| 0 => true
| S 0 => false
| S (S n') => evenb n'</pre>

Cela signifie que pour tout entier n, trois cas de figure se présentent :
# <math> n = 0 \rightarrow n\ pair </math>
# <math> n = 1 \rightarrow n\ non\ pair </math>
# <math> \exists n', n = n' + 2 </math>
Dans le troisième cas, on réitère l'étude, mais avec n'.

Enfin, une troisième méthode pour définir une fonction est la commande '''''Theorem''''' qui permet, comme son nom l'indique, de définir un théorème, généralement sous la forme d'une égalité ou d'une implication. S'il s'agit d'une implication A -> B, A peut être utilisé comme hypothèse lors de la preuve.

=== Preuves simples ===

==== Structure générale ====

Dans Coq, la structure d'une preuve suit toujours la même structure :
<pre lang="coq">Proof. (* On indique le début de la preuve... *)
(* On insère ici toutes les instructions nécessaires... *)
Qed. (* Quod erat demonstrandum, équivalent latin de C.Q.F.D., signifie que la preuve est finie *)</pre>

==== Tactiques ====

Les tactiques sont des instructions pour aider Coq à résoudre une preuve.

* simpl.

simpl. permet, comme son nom l'indique, de simplifier une formule.

* reflexivity.

reflexivity. permet de vérifier si une égalité est du type a = a. Si la réflexivité de l'égalité est prouvée, alors la proposition est vraie. Cette instruction permet généralement d'achever une preuve.

* intros n.

intros. s'utilise en début de preuve pour introduire les variables présentes dans un théorème ou une hypothèse. S'il y a plusieurs variables à introduire, il faut les séparer par des espaces

* unfold f.

unfold f. permet de développer l'expression à étudier selon la fonction f.

* rewrite <- / -> H.

Permet de réécrire l'expression en fonction de l'hypothèse H. La flèche <- indique que l'on souhaite passer du membre de droite à celui de gauche et inversement pour ->. Coq va ensuite essayer de trouver un membre de l'expression qui correspond au terme de départ et va le remplacer par le terme d'arrivée.

* destruct n as [n1 | n2 | ...] eqn:E.

destruct permet de décomposer une variable en plusieurs cas de figure qui sont traités séparément. destruct fonctionne différemment selon le type de la variable utilisée. Avec les booléens ou d'autres types binaires, on peut se passer du as [...] car il n'y a par définition que deux valeurs que peut prendre la variable. Avec les entiers, on va généralement décomposer sous la forme as [| n'], autrement dit, on établit une pseudo-récurrence en vérifiant pour n = 0 et ensuite pour tout n' tel que n = n' + 1. Il ne s'agit cependant pas d'une vraie récurrence car il n'y a pas de lien entre n et n'.

==== Séparation des cas ====

Dans Coq, certaines commandes comme destruct occasionnent une séparation de l'expression en plusieurs cas. Pour identifier ces cas, il y a deux méthodes.

# Commencer chaque cas par une puce (-, + et * dans cet ordre)
# Délimiter un cas par des astérisque {}, ce qui permet de réinitialiser la hiérarchie des puces

== Preuve par récurrence, preuves à l'intérieur de preuves, preuves formelles et informelles ==

=== Preuve par récurrence ===

Bien que les tactiques mentionnées dans la partie précédente permettent de résoudre une grande partie des preuves, certains cas requièrent une attention plus particulière. Si la situation s'y prête, on peut notamment utiliser la récurrence avec la syntaxe suivante :

<pre lang="coq">Proof.
intros n. induction n as [| n' IHn']. (* On décompose n en un cas initial, généralement 0, et on introduit l'hypothèse que la proposition est vérifiée pour un palier arbitraire n'. *)
- (* Initialisation. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée pour le cas initial. *)
- (* Hérédité. On met ici toutes les tactiques nécessaires pour prouver que la proposition est vérifiée à un niveau n' + 1 si elle est vérifiée pour n'. *)
Qed.</pre>

Ben que la récurrence soit une tactique puissante, il vaut mieux la réserver aux situations qui le nécessitent. Il est également nécessaire d'utiliser à un moment l'hypothèse d'hérédité avec rewrite. S'il est possible de compléter la preuve sans l'utiliser, une autre tactique aurait été probablement plus appropriée.

=== Preuves à l'intérieur de preuves ===

Parfois, il n'est pas possible de démontrer une équation telle quelle. Il faut passer par un lemme qui est introduit en Coq par l'instruction '''''assert'''''. Par exemple, la preuve servant à démontrer que <math>\forall n,m \in \mathbb{R}, (0 + n) * m = n * m</math> se structure comme tel :

<pre lang="Coq">Proof.
intros n m. (* On introduit les deux variables n et m *)
assert (H: 0 + n = n). (* On définit le lemme H qui dit que 0 + n = n *)
{ reflexivity. } (* On vérifie que H est vrai *)
rewrite -> H. (* On reformule l'équation initiale en remplaçant 0 + n par n, maintenant que l'on sait que les deux sont égaux *)
reflexivity. (* Les deux membres de l'équation sont alors identiques, la preuve est achevée *)
Qed.</pre>

=== Preuves formelles et informelles ===

Le principe d'une preuve est de convaincre le lecteur de sa véracité. Cependant, tous les lecteurs n'ont pas la même capacité de compréhension.

Par exemple, en langage mathématique, le théorème de Taylor à l'ordre n en a pourrait s'écrire :

<math>f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</math>

Cette écriture peut être lue aisément par un humain, mais pas par une machine. Cependant, si l'on écrit :

<pre lang="latex">f(x) = \sum_{k=0}^{n}{\frac{f^{(k)}(a)}{k!}{x - a}^{k}} + R_{n}(x), \lim_{x \to a} R_{n}(x)= 0</pre>

Un humain aurait du mal à lire cette ligne de code, mais un interpréteur LaTeX le lirait comme l'équation précédente. Enfin, il est également possible d'écrire :

À un ordre n et en un point a donnés, une fonction n fois dérivables au voisinage de a peut se décomposer en une fonction polynomiale dont les coefficients sont les quotients des dérivées d'ordre entre 0 et n en a par la factorielle de l'ordre dont le reste est négligeable devant la variable de plus haut degré en a.

Cette dernière formulation peut être difficile à interpréter, autant par un humain que par une machine, mais équivaut aux deux premières. Il en est de même pour les preuves sur Coq.

* Preuves formelles

Les preuves formelles sont celles que Coq peut comprendre facilement et qui n'est pas prévue pour être facilement comprise par un humain. Par exemple, la preuve formelle de l'associativité de l'addition est structurée comme suit :

<pre lang="coq">Proof. intros n m p. induction n as [| n' IHn']. reflexivity. simpl. rewrite -> IHn'. reflexivity. Qed.</pre>

Le code est réduit à l'essentiel, mais la clarté pour le lecteur humain est moindre.

* Preuves informelles

Les preuves informelles sont celles que Coq accepte et qu'un humain peut comprendre facilement. Par exemple, la preuve informelle de l'associativité de l'addition est structurée comme tel :

<pre lang="coq">Proof.
intros n m p. induction n as [| n' IHn'].
- (* n = 0 *)
reflexivity.
- (* n = S n' *)
simpl. rewrite -> IHn'. reflexivity.
Qed.</pre>

Ici, on a éclaté le code pour notamment séparer les deux cas étudiés lors de la récurrence et on a ajouté des commentaires. Coq interprète toujours le code, mais un lecteur humain peut davantage comprendre ce qui se passe.

== Sources et annexes ==

'''Sources'''

* Software Foundations volume 1 [https://softwarefoundations.cis.upenn.edu/lf-current/index.html]

* Page Wikipédia de Coq [https://fr.wikipedia.org/wiki/Coq_(logiciel)]

'''Annexe'''

* Théorème des quatre couleurs [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_des_quatre_couleurs]

* Théorème de Feit-Thompson [https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_de_Feit-Thompson]

* Compcert [http://compcert.inria.fr/]

* Iris Project [https://iris-project.org/]

* Software Foundations [https://softwarefoundations.cis.upenn.edu/]

* Verified Software Toolchain [https://vst.cs.princeton.edu/]

* FSCQ [http://css.csail.mit.edu/fscq/]

* Bedrock [http://plv.csail.mit.edu/bedrock/]

* CFML [https://www.chargueraud.org/softs/cfml/]

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-07T14:32:18Z

Dornel : /* Preuves formelles et informelles */

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-07T14:32:00Z

Dornel : /* Preuves formelles et informelles */

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-07T14:29:47Z

Dornel : /* Preuves formelles et informelles */

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-07T14:20:51Z

Dornel : /* Preuve par récurrence, preuves à l'intérieur de preuves, preuves formelles et informelles */

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-07T14:20:08Z

Dornel : /* Tactiques */

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-07T14:19:16Z

Dornel : /* Preuve par récurrence */

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-07T14:17:35Z

Dornel : /* Preuves à l'intérieur de preuves */

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-07T14:12:30Z

Dornel : /* Preuve par récurrence, preuves à l'intérieur de preuves, preuves formelles et informelles */

Initiation à la démonstration sur ordinateur et certification de logiciel

2019-05-06T12:59:11Z

Dornel : /* Sources et annexes */