b = liste_binaire.pop() graphe[i][j] = b

graphe[j][i] = b

Voici le principe de cette boucle qui remplit la partie au-dessus de la diagonale (et aussi la partie en-dessous par symétrie). Cette boucle prend le dernier bit de la liste et le place sur la première case libre au-dessus de la diagonale ; puis l’avant-dernier bit est placé sur la seconde case libre. . . ; le premier bit de la liste remplit la dernière case libre.

1 0 1 0 0 0 1 1 0 1

Écriture de p sur N bits

0 0 1 0 1 0 0 0 0 1 0 1 0 1 0 Remplissage du tableau

N cases sous la diagonale (remplies par symétrie)

N cases au-dessus de la diagonale

3. Transforme la fonction précédente en une fonction

test_tous_graphes(n)

qui teste la conjecture « il y a trois amis ou trois étrangers » pour tous les graphes à n sommets. Tu dois trouver que :

• pour n= 4 et n = 5 la conjecture est fausse. Donne un graphe à 4 sommets (puis à 5 sommets) qui n’a ni 3 amis, ni 3 étrangers ;

• pour n= 6 laisse l’ordinateur vérifier que, pour chacun des N = 25×62 = 32 768 graphes ayant 6 sommets, soit il possède 3 amis, soit il possède 3 étrangers.

Activité 6 (Pour aller plus loin).

Objectifs : améliorer ton programme et prouver d’autres conjectures. Activité facultative.

1. Améliore ton programme afin qu’il vérifie la conjecture pour n= 6 en moins d’une seconde.

Idées.

• Il faut générer la liste des triplets une fois pour toute au début du programme (et non à chaque nouveau graphe).

• Il ne faut pas générer une liste de tous les graphes possibles, puis les tester dans un second temps. Il faut en générer un puis le tester avant de passer au suivant.

• Dès que tu as trouvé 3 amis (ou 3 étrangers) c’est gagné ! Stoppe immédiatement la boucle quitte à utiliser l’instruction

break

et passe au graphe suivant.

• Tu peux seulement tester les graphes qui correspondent à p entre 0 et 2N/2 (car pour les p suivants cela revient à échanger les segments verts en rouges et inversement).

Nombre de sommets Nombre de graphes Temps de calcul approximatif

n= 6 32 768 < 1 seconde

n= 7 2 097 152 < 1 minute

n= 8 268 435 456 < 1 heure

n= 9 68 719 476 736 < 10 jours

2. Il existe un énoncé plus difficile. Il s’agit de trouver à partir de quelle taille n un graphe contient toujours ou bien 4 amis ou bien 3 étrangers. Être 4 amis signifie que deux à deux ils sont reliés par un segment vert, comme ci-dessous :

(a) Trouve des graphes à n= 6 (puis n = 7) sommets qui ne vérifient pas cet énoncé.

(b) En cherchant un peu avec la machine trouve des graphes à 8 sommets qui ne vérifient pas cet énoncé.

(c) Prouve que n’importe quel graphe ayant 9 sommets contient 4 amis ou bien 3 étrangers !

Indications.Il faut tester tous les graphes correspondants aux entiers p compris entre 0 et 2N₌

28×92 = 68 719 476 736. Le temps total de calcul est d’environ 20 jours ! Tu peux partager les calculs entre plusieurs ordinateurs : un ordinateur fait les calculs pour 0₆p61 000 000, un deuxième ordinateur pour 1 000 0016p62 000 000,. . .

3. • Il existe des raisonnements pour pouvoir démontrer à la main que pour n= 6 il y a toujours 3 amis ou 3 étrangers. Cherche un tel raisonnement ! Avec un peu plus d’efforts, on prouve aussi que c’est n= 9 qui répond au problème des 4 amis/3 étrangers.

• On sait prouver qu’il faut n= 18 sommets pour avoir toujours 4 amis ou 4 étrangers.

• Par contre personne dans le monde ne sait quelle est la valeur du plus petit n pour le problème des 5 amis/5 étrangers !

Bitcoin

22

Lebitcoin est une monnaie dématérialisée et décentralisée. Elle repose sur deux principes informa-

tiques : la cryptographie à clé publique et la preuve de travail. Pour comprendre ce second principe, tu vas créer un modèle simple debitcoin.

Vidéo „ Bitcoin - partie 1 - principe général

Vidéo „ Bitcoin - partie 2 - fonction de hachage Vidéo „ Bitcoin - partie 3 - preuve de travail

Vidéo „ Bitcoin - partie 4 - tes bitcoins

Activité 1 (Preuve de travail).

Objectifs : comprendre ce qu’est une preuve de travail sur un modèle simple. Cette activité est indépendante du reste de la fiche. L’idée est de trouver un problème difficile à résoudre mais facile à vérifier. Comme les sudokus par exemple : il suffit de dix secondes pour vérifier qu’une grille est remplie correctement, par contre il a fallu plus de dix minutes pour le résoudre.

Le problème mathématique est le suivant : on te donne un nombre premier p et un entier y ; tu dois trouver un entier x tel que :

x2= y (mod p)

Autrement dit x est une racine carrée de y modulo p. Attention, il n’existe pas toujours de solution pour

x.

Exemples.

• Pour p= 13 et y = 10, alors une solution est x = 6. Effet x2= 62= 36. Et 36 = 2 × 13 + 10 donc

x2= 10 (mod 13).

• La solution n’est pas forcément unique. Par exemple, vérifie que x= 7 est aussi solution.

• Il n’y a pas toujours de solution, par exemple pour p= 13 et y = 5, aucun entier x n’est solution. • Exercice : pour p= 13, trouve à la main deux solutions x au problème x2= 9 (mod 13) ; trouve une

solution x au problème x2= 3 (mod 13).

L’entier p est fixé pour toute l’activité. Pour les exemples faciles on prendra p= 101, pour les exemples moyens p= 15 486 869 et pour les exemples difficiles p = 2 276 856 017. Plus l’entier p est grand, plus la preuve de travail est difficile à obtenir.

1. Vérification (facile). Écris une fonction

verification(x,y)

qui renvoie « vrai » si x est bien solution du problème x2= y (mod p) et « faux » sinon.

Vérifie que x= 6 543 210 est solution lorsque y = 8 371 779 et p = 15 486 869. Affiche le temps de calcul nécessaire à cette vérification. (Voir le cours plus bas.)

2. Recherche de solution (difficile). Pour trouver une solution x, il n’y a pas vraiment d’autres choix pour nous que de tester tous les x en commençant par x = 0, x = 1. . . Programme une fonction

• Pour p= 101 et y = 17, trouve x tel que x2= y (mod p).

• Pour p= 15 486 869 et y = 8 371 779, tu dois retrouver le x de la première question. Combien de temps a pris la recherche ?

• Pour p= 15 486 869 et y = 13 017 204, trouve x tel que x2= y (mod p).

Conclusion : nous avons trouvé un problème difficile à résoudre, mais pour lequel il est facile de vérifier qu’une solution donnée convient. Pour des valeurs de p plus grandes, la recherche d’une solution x peut être beaucoup trop longue et ne pas aboutir. Nous allons voir comment on peut ajuster la difficulté du problème.

3. Au lieu de chercher une solution exacte à notre problème x2= y (mod p), qui est équivalent à x2_{− y} (mod p) = 0. On cherche une solution approchée, c’est-à-dire qui vérifie :

x2_{− y (mod p)} 6m.

Par exemple si m= 5, alors on peut avoir (modulo p) : x2_{− y = 0, x}2_{− y = 1, x}2_{− y = 2,. . . ,}

x2− y = 5.

Programme une fonction

racine_approchee(y,marge)

qui trouve une solution approchée à notre problème x2= y (mod p).

Combien de temps faut-il pour trouver un solution au problème approché lorsque p= 15 486 869,

y= 8 371 779 et m = 20 ? Choisis un nombre premier p assez grand et trouve une marge d’erreur m

de sorte que trouver une solution au problème approché nécessite environ entre 30 et 60 secondes de calculs (pour un y quelconque).

Voici des exemples de nombres premiers que tu peux utiliser pour tes essais :

101 1097 10651 100109 1300573 15486869 179426321 2276856017 32416187567

Cours 1 (Chronomètre).

Le module

time

permet de chronométrer le temps d’exécution mais aussi de savoir la date et l’heure (voir aussi le module

timeit

expliqué dans la fiche « Arithmétique – Tant que – I »). Voici un petit script

pour mesurer le temps de calcul d’une instruction.

Dans le document Python livre pour debuter la programmation avec le language (Page 162-165)