• Aide pour la navigation
  • Page d'accueil
  • Mise à jour
  • A faire
  • Rechercher
  • Plan du site
• Contacts
  • Connexion
  • Livre d'or
  • Forum
  • Auteurs
  • Liens
• Grandes parties
  • International (en)
  • Maths
  • Smileys
  • Programmation
  • Nos Programmes
  • Nos jeux
  • Jeux vidéo
• Nos Demos
  • Sommaire « Nos démos »
  • Somme directe de sous-espaces vectoriels
  • Non prouvabilité dans ZF de l'existence de bons ordres
  • Démonstrations et algorithmes : infiniment longs ou impossibles ?
  • Existence d'une base dans un espace vectoriel bien ordonnable
  • Parties indéfinissables par le schéma d'axiomes de séparation
  • Terme général d'une suite u(n+1) = au(n) + b
  • Coefficients directeurs
  • Critère de divisibilité
  • Critère de divisibilité par B+1 en base B
  • Série de puissance
  • Ensembles bien ordonnables

Démonstrations et algorithmes : infiniment longs ou impossibles ?

Introduction

• 1. Un cadre de travail
  • 1.1. Logique
  • 1.2 Algorithmique
• 2. Preuve de convergence de suites arithmétiques
  • 2.1 Les suites de Goodstein
  • 2.2 Les suites de Syracuse
• 3. Existence et programmation d'algorithmes
  • 3.1 Résolution d'équation diophantienne
  • 3.2 Programmation de l'algorithme de Goodstein
• 4. Nouveaux axiomes
  • 4.1 Schéma de recherche d'axiomes
  • 4.2 L'axiome du choix

1. Un cadre de travail

1.1. Logique

1.1.1. Présentation de la logique du premier ordre

Exemple 1.1.1.1

• Un symbole de logiques propositionnelles ∧
• Des quantificateurs ∀, ∃
• Trois termes x₁, x₂, x₃
• Un symbole de constante "0"
• Un symbole de relation binaire "<"
• Un symbole d'opération binaire "+"

Théorème 1.1.1.2 (théorème de déduction)

Théorème 1.1.1.3

Définition 1.1.1.4 (consistant)

1.1.2 Les théorèmes de Gödel

• Tout n-uplet (x₁, x₂, ... x_n) d'entiers peut être représenté par un unique entier [x₁, x₂, ... x_n] = $\prod _{i=1}^n{p_i}^{x_i}$ où p_i représente le i-ème nombre premier. Cela découle de l'unicité de la décomposition en produit de nombres premiers.
• Au i-ème symboles de la logique (connecteurs, quantificateurs) on attribut le numéro [0, i]. Au i-ième terme x_i on attribut le numéro [1, i] et au i-ième symbole de constante le numéro [2, i]. A la i-ème opérations à k arguments on attribut le numéro [2k + 1, i], et à la i-ième relation à k arguments on attribut le numéro [2k + 2, i].
• A partir de là on peut numéroter chaque formule récursivement, par exemple x₁ = x₂ sera numéroté par [[x₁], [=], [x₂]]. Et de même chaque suite finie de formule (F₁, F₂, ... F_n) se voit attribuer le numéro [[F₁], [F₂], ... [F_k]]

• subst telle que pour toute formule F à une variable libre subst([F], k) = [F(S^k 0)]
• preuve_T telle que preuve_T(n, m) vaut 1 si m est le numéro d'une suite de formule constituant une preuve de la formule de numéro n à partir de la théorie T et vaut 0 sinon.
• oppose telle que oppose(n, m) vaut 1 s'il existe une formule F sans variable libre telle que n = [E] et m = [¬E] ou n = [¬E] et m = [E] et 0 sinon.

• F(S^n₁ 0, S^n₂ 0, S^m 0)
• ∀x ¬(x = S^m 0) ⇒ ¬F(S^n₁ 0, S^n₂ 0, x)

• Une formule exprimant la prouvabilité à partir de T : Prouvable_T(x) à une variable libre, qui est ∃y Preuve_T(x, y, S(0)) (qui est Σ₁ )
• Une formule exprimant la consistance de T : Const_T qui est ¬(∃x)(∃y)(Oppose(x, y, S(0)) ∧ Prouvable_T(x) ∧ Prouvable_T(y))

Lemme 1.1.2.1 (lemme diagonal)

Démonstration

1. Subst(Sⁿ 0, Sⁿ 0, S^{[¬ Δ_F]} 0)
2. ∀x, Subst(Sⁿ 0, Sⁿ 0, x) ⇒ x = S^{[¬ Δ_F]} 0

Théorème 1.1.2.2 (Gödel, premier théorème d'incomplètude)

Démonstration

Théorème 1.1.2.3 (Gödel, second théorème d'incomplètude)

Démonstration

1.2 Algorithmique

1.2.1 Présentation du modèle de machine de Turing

1.2.2 Problèmes indécidables par un algorithme

Définition 1.2.2.1 (semi-calculable, calculable)

Théorème 1.2.2.2

Démonstration (idée)

2. Preuve de convergence de suites arithmétiques

2.1 Les suites de Goodstein

2.1.1 Présentation

Définition 2.1.1.1 (base b itérée)

Exemple 2.1.1.2

• Une écriture en base 2 itérée de 257 est 1×2 ⁰ + 1×2 ^{21×20 + 1×21}
• Une écriture en base 3 itérée de 15757575757 est 1×3 ⁰ + 2×3 ¹ + 2×3 ² + 2×3 ^{1×3 0 + 1×3 1} + 1×3 ^{1×3 0 + 2×3 1} + 2×3 ^{2×3 0 + 2×3 1} + 2×3 ^{3 2} + 2×3 ^{1×3 0 + 1×3 2} + 1×3 ^{2×3 0 + 1×3 2} + 1×3 ^{1×3 1 + 1×3 2} + 1×3 ^{1×3 0 + 1×3 1 + 1×3 2} + 2×3 ^{2×3 0 + 2×3 1 + 1×3 2} + 1×3 ^{2×3 2} + 1×3 ^{1×3 0 + 2×3 2} + 1×3 ^{2×3 0 + 2×3 2} + 1×3 ^{1×3 1 + 2×3 2}

Proposition 2.1.1.3

Démonstration

Définition 2.1.1.4 (fonction de remplacement)

Exemple 2.1.1.5

Définition 2.1.1.6 (suites de Goodstein)

• g₂(a) = a
• ∀ n ≥ 2, g_{n + 1}(a) = R_{n, n + 1}(g _n(a)) - 1 si g_n(a) n'est pas nul et 0 sinon.

Exemple 2.1.1.7

2.1.2 Étude des suites et algorithme de calculs

Proposition 2.1.2.1

Démonstration

Corollaire 2.1.2.2

Démonstration

Corollaire 2.1.2.3

Démonstration

Exemple 2.1.2.4

Proposition 2.1.2.5

Démonstration

• u₁ = b
• ∀ n ∈ |[1 ; a - 1]|, u_{n + 1} = 2 u_n + 1

Exemple 2.1.2.6

• g₂(2) = 2¹ donc g_n(2) s'annule en f(1, 2 , 1) étapes, c'est-à-dire au rang 2 + (2 + 1)(2¹ - 1) = 5.
• g₂(3) = 2¹ + 1 donc g₃(3) = 3¹ et finalement g_n(3) s'annule au rang 2 + 1 + (3 + 1)(2¹ - 1) = 7.

Proposition 2.1.2.7

Démonstration

• x = b + 1 d'où f(b, x, 0) = b
• y = b + 1 + f(b, x, 0) = 2b + 1 d'où f(b, y, 1) = (2b + 1 + 1)(2^b - 1) = 2(b + 1)(2^b - 1)
• z = b + 1 + f(b, x, 0) + f(b, y, 1) = 2b + 1 + 2^{b + 1}(b + 1) - 2(b + 1) = 2^{b + 1}(b + 1) - 1

Exemple 2.1.2.8

• u₁ = 23
• u₂ = (2^{u₁ + 1} - 1)(u₁ + 1) = 3×2²⁷ - 1
• n₀ = 23 + 2^{u₂ + 1}(u₂ + 1) - (23 + 1) = 2^3×227(3×2²⁷) - 1 = 3×2^{3×227 + 27} - 1 = 3×2^402653211 - 1

2.1.3 Théorème de Goodstein et de Kirby-Paris

Théorème 2.1.3.1 (de Kirby-Paris)

Théorème 2.1.3.2 (de Goodstein)

Définition 2.1.3.3 (prolongement de la fonction de remplacement)

Lemme 2.1.3.4

Démonstration

• Pour k = 0, c₀ étant naturel, c₀ < ω, d'où ω^δ₀×c₀ < ω^δ₀×ω (compatibilité de l'ordre strict avec la multiplication par un facteur non nul). Ensuite, δ₀ < δ₁ implique δ₀ + 1 ≤ δ₁ (on admet que cette propriété des entiers naturels est vraie pour tout ordinal) et donc ω^{δ₀ + 1} ≤ ω^δ₁ (compatibilité de l'exponentiation avec l'ordre large) et finalement ω^δ₀×c₀ < ω^δ₁.
• Supposons maintenant l'inégalité vérifiée pour k ∈ |[0 ; m - 2]|, c'est-à-dire $\sum _{i=0}^k{\omega }^{{\delta }_i}{c}_i<{\omega }^{{\delta }_{k+1}}$ d'où $\sum _{i=0}^{k+1}{\omega }^{{\delta }_i}{c}_i<{{\omega }^{{\delta }_{k+1}}{c}_{k+1}+\omega }^{{\delta }_{k+1}}={\omega }^{{\delta }_{k+1}}(c_{k+1}+1)$ (par compatibilité de la relation d'ordre stricte avec l'addition). Mais c_{k + 1} + 1 est un entier naturel et par un raisonnement analogue au cas k = 0, on en déduit ${\omega }^{{\delta }_{k+1}}\left(c_{k+1}+1\right)<{\omega }^{{\delta }_{k+2}}$ d'où enfin par transitivité $\sum _{i=0}^{k+1}{\omega }^{{\delta }_i}{c}_i<{\omega }^{{\delta }_{k+2}}$ et l'inégalité est vraie au rang k + 1.

Démonstration du théorème 2.1.3.2

2.2 Les suites de Syracuse

3. Existence et programmation d'algorithmes

3.1 Résolution d'équation diophantienne

Proposition 3.1.1

Démonstration

Définition 3.1.2 (ensemble diophantien)

Théorème 3.1.3 (Matiyasevich)

Corollaire 3.1.4 (indécidabilité du 10e problème d'Hilbert)

Démonstration

3.2 Programmation de l'algorithme de Goodstein

3.2.1 Décomposition en base b itérée

3.2.2 Stockage du rang et du terme

3.2.3 Simulation du calcul pour g_n(5)

• n₅ = 2^{u₃ + 1}(u₃ + 1) - 1, avec
  • u₁ = 2⁶ - 1
  • u₂ = 2²⁶(2⁶) - 1 = 2^{26 + 6} - 1
  • u₃ = 2^{226 + 6}(2^{26 + 6}) - 1 = 2^{226 + 6 + 26 + 6} - 1
  D'où n₅ = 2^{2226 + 6 + 26 + 6}(2^{226 + 6 + 26 + 6}) - 1 = 2^{2226 + 6 + 26 + 6 + 226 + 6 + 26 + 6} - 1
• n₆ = n₅ + 1 = 2^{2226 + 6 + 26 + 6 + 226 + 6 + 26 + 6}
• n₇ = n₆ + n₅ = 2×2^{2226 + 6 + 26 + 6 + 226 + 6 + 26 + 6} - 1 = 2^{2226 + 6 + 26 + 6 + 226 + 6 + 26 + 7} - 1
• n₈ = n₇ + (n₇ + 1)(2^n₅ - 1) = 2^n₅×n₇ + 2^n₅ - 1 = 2^n₅(2^{2226 + 6 + 26 + 6 + 226 + 6 + 26 + 7} - 1) + 2^n₅ - 1 = 2^{2226 + 6 + 26 + 6 + 226 + 6 + 26 + n₅ + 7} - 1 = 2^{22226 + 6 + 26 + 6 + 226 + 6 + 26 + 6 + 2226 + 6 + 26 + 6 + 226 + 6 + 26 + 6} - 1

4. Nouveaux axiomes

4.1 Schéma de recherche d'axiomes

4.2 L'axiome du choix

Définition 4.2.1 (fonction de choix, axiome du choix)

Exemple 4.2.2 (théorème de caractérisation séquentielle d'une limite)

Exemple 4.2.3 (existence de base dans les espaces vectoriels)

Conclusion

• Notre objet d'étude était axé sur deux aspects : la possibilité de démontrer une proposition mathématique d'une part et celle de réaliser un algorithme d'autre part.
• Dans les deux cas, nous nous sommes fixé un cadre de travail qui permet de traiter de façon formelle le sujet. Une étude globale montre alors que certains énoncés sont indécidables ou que certains algorithmes sont impossibles à réaliser. Toutefois les premiers sont des énoncés peu naturels tandis que les seconds seraient trop complexes.
• Dans la seconde partie nous avons étudié un exemple d'énoncé "naturel" à savoir la convergence d'une suite. Celle des suites de Goodstein ne peut être établie dans l'arithmétique mais peut l'être dans une théorie plus forte. Celle des suites de Syracuse n'a pas été contredite ni démontrée, mais une généralisation conduit à un énoncé indécidable.
• Dans la troisième partie nous nous sommes intéressés à des algorithmes moins généraux que ceux de la première partie. La résolution des équations diophantiennes s'est révélée être un algorithme impossible à réaliser, mais le problème est relié à celui de la première partie. Nous sommes aussi revenus à l'étude des suites de Goodstein en recherchant un algorithme de calcul du premier terme nul dont on a pu constaté les difficultés pratiques : mémoire nécessaire et temps de calcul.
• Enfin la dernière partie concerne l'amélioration de la portée des démonstrations mathématiques par la recherche d'axiomes "naturels" susceptibles d'être ajouté à une théorie générale. On a vu que l'axiome du choix qui autorise l'usage de choix infini dans les démonstrations mathématiques est un tel axiome largement utilisé aujourd'hui. En ce qui concerne l'algorithmique la référence actuelle reste celui des machines de Turing puisque la thèse de Church n'a pas été contredite, mais on peut toujours conjecturer l'existence un modèle plus puissant.

Références

1. Encyclopédie Wikipédia, portail mathématiques (http://fr.wikipedia.org/wiki/Portail:Mathématiques)
   • http://fr.wikipedia.org/wiki/Indécidabilité
   • http://fr.wikipedia.org/wiki/Problème_de_l'arrêt
   • http://fr.wikipedia.org/wiki/Diophantien
   • http://fr.wikipedia.org/wiki/Conjecture_de_Syracuse
2. Patrick Dehornoy (http://www.math.unicaen.fr/~dehornoy/) : Logique et théorie des ensembles; Notes de cours, FIMFA ENS, version 2005-2006;
   • Chapitre 2 : Les ordinaux
   • Chapitre 8 : Les théorèmes de limitation
3. Justin T. Miller (http://www.u.arizona.edu/~miller/thesis/) On the Independence of Goodstein's Theorem
4. W. et F. Ellison : Abrégé d'histoire des mathématiques ; chapitre V : Théorie des nombres ; §IX : Équations diophantiennes.

Annexe

			(* !!! Fonctions utiles !!! *)

(* ****** Fonction d'exponentiation des entiers et opérateur expo ****** *)
let rec exponentiation a b =
	if b = 0 then 1
		else (
			if b mod 2 = 0 then let c = exponentiation a (b/2) in c*c
					else a * (exponentiation a (b-1)));;
#infix "expo";;
let prefix expo a b = exponentiation a b;;

(* ****** Accès aux différentes parties d'un fwd ****** *)
let prm = function
  |O-> 0
  |Somme((a,_),_) -> a;;
  
let sec = function
  |O -> O
  |Somme((_,a),_) -> a;;
  
let tri = function
  |O-> O
  |Somme((_,_),a) -> a;;

(* ****** Définition du type pile et fonctions associées ****** *)
type 'a pile = {cont : 'a vect ; mutable ind : int ; taille : int};;

let est_vide p =
  p.ind=(-1);;

let est_pleine p =
  p.ind=p.taille;;

let cree_pile x n =
  let tab = make_vect n x in
    let p={cont = tab;ind = -1;taille = n} in
      p;;

let empile e p = 
  if est_pleine p
    then failwith "pile pleine" 
    else (p.ind <- p.ind +1;
         p.cont.(p.ind) <- e);;

let depile p=
  if est_vide p 
    then 
      failwith "pile vide"
    else
      p.ind <- p.ind -1;
      p.cont.(p.ind+1);;



			(* !!! Le type fwd !!! *)

(* ****** Création du type fwd et du signe de concaténation %% ****** *)
type fwd = O|Somme of (int*fwd)*fwd;;
#infix "%%";;
let prefix %% = fun x y -> Somme(x,y);;

(* ****** Afficher un nombre de type fwd en base b (programme peu intéressant) ****** *)
let rec afficher_fwd b = function
	|O -> print_int 0
	|Somme ((coef,puiss),rest) -> if coef<>0 then 
		(	print_int coef;
			if puiss <> O then 
			   ( print_char `*`; print_int b;
			     if puiss <> (1,O)%%O then (print_string "^("; afficher_fwd b puiss;print_char `)`)
			   );
			if rest<>O then print_string " + "
		);
		if rest<>O then afficher_fwd b rest;;

(* ****** Décomposition d'un entier n en base b itérée ****** *)
let rec decomposer b n =
	let r = ref 0
	and q = ref n
	and puiss = ref 0
	and result = ref O in
		while !q<>0 do
		r:= (!q)mod b;
		q:= (!q)/b;
		if !r<>0 then result := (!r,decomposer b !puiss)%%(!result);
		puiss:= !puiss + 1
		done;
	!result;;

decomposer 3 15;;
afficher_fwd 3 (decomposer 3 15);;

(* ****** Fonction d'évaluation d'un entier écrit en base b itérée sous le format fwd (réciproque de decomposer) ****** *)
let rec evaluer b = function
	|O -> 0
	|Somme ((coef,puiss),rest) -> coef * (b expo (evaluer b puiss)) + (evaluer b rest);;
	
evaluer 3 (decomposer 3 2568);;

(* ****** Décrémenter un nombre n en base b itérée ****** *)
let decrementer b n = 
  decomposer b ((evaluer b n) - 1);;



			(* !!! Recherche du premier terme nul !!! *)

(* ****** Fonction de recherche d'un terme nul pour gn(b) pour n variant de 2 à nmax ****** *)
let recherche b nmax =
  let n = ref 2 and gn = ref (decomposer 2 b) in
    while (!n < nmax) && not(!gn = O) do
      gn := decrementer (!n+1) !gn;
      n := !n + 1;
    done;
   if !gn = O then print_int !n else print_string "Aucun terme nul trouvé.";; 

recherche 2 10;;
recherche 3 10;;
(* recherche 4 (2 expo 29);; : N'aboutit pas, même après quelques heures
ce qui était évidement prévisible*)



			(* !!! Le type fwd2 !!! *)

(* ****** Création du type fwd2 et du signe de concaténation @@ ****** *)
type fwd2 = N|Somme2 of (int*fwd2)*fwd2;;
#infix "@@";;
let prefix @@ = fun x y -> Somme2(x,y);;

(* ****** Affichage d'un fwd2 ****** *)
let rec afficher_fwd2 = function
	|N -> print_int 0
	|Somme2 ((coef,puiss),rest) -> if coef<>0 then 
		(	print_int coef;
			if puiss <> N then 
			   ( print_char `*`; print_int 2;
			     if puiss <> (1,N)@@N then (print_string "^("; afficher_fwd2 puiss; print_char `)`)
			   );
			if rest<>N then print_string " + "
		);
		if rest<>N then afficher_fwd2 rest;;

(* ****** Calcul le nombre d'étage (toujours à gauche dans l'écriture) ****** *)
let rec etage = function
	|N -> 0
	|Somme2((a,b),c) -> 1 + etage b;;

(* ****** Fonction de somme de deux fwd2 (plus ou moins ordonnés) et opérateur ++ ****** *)
let rec somfwd2 = fun
	|N a -> a
	|a N -> a
	|(Somme2((a1,b1),c1)) (Somme2((a2,b2),c2)) -> if b1 = b2 then ((a1+a2),b1)@@(somfwd2 c1 c2)
						else ( if etage b1 > etage b2 then ( (a1,b1)@@(somfwd2 c1 ((a2,b2)@@c2) ) )
							else ( (a2,b2)@@(somfwd2 ((a1,b1)@@c1) c2) ));;
#infix "++";;
let prefix ++ = somfwd2;;

(* ****** Calcul de l'opposé, Soustraction et opérateur -- ****** *)
let rec oppfwd2 = function
	|N -> N
	|Somme2 ((a,b),c) -> (-a,b)@@(oppfwd2 c);;

let moinsfwd2 = fun a b -> a++(oppfwd2 b);;
#infix "--";;
let prefix -- = moinsfwd2;;

(* ****** Fonction de produit et opérateur ** ****** *)
let rec prodfwd2 = fun
	|N a -> N
	|a N -> N
	|(Somme2((a1,b1),N)) (Somme2((a2,b2),c2)) -> (((a1*a2),b1++b2)@@N)++(prodfwd2 ((a1,b1)@@N) c2)
	|(Somme2((a1,b1),c1)) (Somme2((a2,b2),c2)) -> (prodfwd2 ((a1,b1)@@N) ((a2,b2)@@c2))++(prodfwd2 c1 ((a2,b2)@@c2));;
#infix "**";;
let prefix ** = prodfwd2;;

(* ****** Fonction d'exponentiation de 2 à la puissance un fwd2 ****** *)
let exp2 = function a -> ((1,a)@@N);;

(* ****** Evaluation d'un fwd2 ****** *)
let rec evaluer2 = function
	|N -> 0
	|Somme2 ((a,b),c) -> a*(2 expo (evaluer2 b)) + (evaluer2 c);;



			(* !!! Calcul du plus petit rang pour lequel la suite s'annule !!! *)

(* ****** Fonction auxiliaire calculant les termes de la suite (un) (cf étude antérieure) ****** *)
let rec u b = function
	|1 -> b
	|k -> let x = (u b (k-1))++((1,N)@@N) in
		((exp2 x)**x)++((-1,N)@@N);;

(* ****** Fonction f (cf étude antérieure) ****** *)
let rec f = fun
	|a _ 0 -> a
	|a b 1 -> (b++((1,N)@@N))**((exp2 a)++((-1,N)@@N))
	|a b 2 -> let x = (u b (evaluer2 a))++((1,N)@@N) in
			((exp2 x)**x)--(b++((1,N)@@N))
	|_ _ _ -> failwith "c est trop important";;

(* ****** Fonction permettant de créer le schéma de calcul des rangs successifs (cf tableau) ****** *)
(* Une première phase (tant que sec (sec x) <> O) permet le calcul du premier rang pour lequel les exposants sont inférieurs aux rang de la suite.
Les calculs se font à l'aide du type fwd pour les termes de la suite, et du type fwd2 pour les rangs.
A la fin de cette phase, on procède à un changement de format du dernier terme calculé.
Celui-ci est transféré dans une pile en tant qu'ensemble de couple d'un coefficient (au format fwd2) et d'un exposant (entier).
L'élément au dessus de la pile est l'élément de plus faible exposant.
On procède ensuite (par le biais de schemb) aux calculs à l'aide de la fonction f si l'exposant minimal le permet.
Sinon on calcule simplement le terme suivant dans la suite (en utilisant ab^c = (a-1)b^c + Som(i=0 c-1)[(b-1)b^i]).
Ceci implique alors une évaluation de a-1 pour savoir s'il est nul (ce que l'on ne peut pas faire en fwd2). *)

let rec schema n x =
	if sec (sec x) = O then
		(
		let y = cree_pile (N,1) (1 + evaluer (evaluer2 n) (sec x)) in
			let rec pass1_2 = function
					|O -> ()
					|Somme((coef,puiss),rest) -> (empile (((coef,N)@@N), prm puiss) y; (pass1_2 rest))
			in pass1_2 x;
		let rec schemb r =
			if est_vide y then r
				else (
					let petit = depile y in
					let puisp = snd petit and coefp = fst petit in
					if puisp <= 2 then schemb (r ++ (f coefp r puisp))
						else (let s = r++((1,N)@@N) in
							(if evaluer2 coefp > 1 then empile ((coefp--((1,N)@@N)),puisp) y);
							for i = puisp-1 downto 0 do
							empile (r,i) y done;
							schemb s)
					)
		in schemb n
		)
		else (	let m = (n++((1,N)@@N)) in
				schema m (decrementer (evaluer2 m) x)
			)
	;;
schema ((2,N)@@N) (decomposer 2 4);;
afficher_fwd2 (schema ((2,N)@@N) (decomposer 2 4));;

Cette page est conforme aux normes du W3C - Auteur : Frédéric WANG - Dernière mise à jour : lundi 7 août 2006