pour videos

Author: arnaud

bitcoin/bitcoin.pdf

@@ -154,7 +154,7 @@
 \bigskip
 
 Pour éviter que quelqu'un ne vienne truquer le livre de compte, après chaque transaction on ajoute dans le livre une certification construite à partir d'une preuve de travail.
-Voici ce que l'on écrit dans le livre
+Voici ce que l'on écrit dans le livre :
 \begin{enumerate}
   \item On commence par une preuve de travail quelconque. Pour nous ce sera 
   \ci{[0,0,0,0,0,0]}.
@@ -298,7 +298,7 @@
 }  
 
 
-  Exemple avec la liste $[0,1,2,3,4,5,1,1,1,1,1,1,1,10,10,10,10,10,10]$.
+  Exemple avec la liste $[0,1,2,3,4,5,1,1,1,1,1,1,10,10,10,10,10,10]$.
   \begin{itemize}
     \item Le premier bloc est $[0,1,2,3,4,5]$, son mélange à $10$ tours est 
     $[98, 95, 86, 55, 66, 75]$. 

bitcoin/bitcoin.tex

@@ -0,0 +1,318 @@
+\documentclass[12pt,class=report,crop=false]{standalone}
+\usepackage[screen]{../python}
+
+
+\pagestyle{empty}
+
+\begin{document}
+
+
+%====================================================================
+\chapitre{Bitcoin}
+%====================================================================
+
+\section*{Bitcoin}
+
+\begin{itemize}
+   \item La monnaie \emph{bitcoin} est une monnaie dématérialisée. 
+
+   \item Les transactions sont enregistrées dans un grand livre de compte appelé \emph{blockchain}. 
+
+
+   \item Imaginons un groupe d'amis qui souhaitent partager les dépenses du groupe de façon la plus simple possible.
+
+   \item Au départ tout le monde dispose de 1000 \emph{bitcoins} et on note au fur et à mesure les dépenses et les recettes de chacun.
+ 
+   \item On note sur le livre de compte la liste des dépenses/recettes, par exemple :
+\begin{itemize}
+  \item \og{}Amir a dépensé 100 \emph{bitcoins}\fg{}
+  \item \og{}Barbara a reçu 45 \emph{bitcoins}\fg{}
+  \item etc.
+\end{itemize}
+
+   \item Il suffit de parcourir tout le livre pour savoir combien chacun a reçu ou dépensé depuis le début.
+\end{itemize}
+
+\newpage
+
+\section*{Blockchain}
+
+Pour éviter que quelqu'un ne vienne truquer le livre de compte, après chaque transaction on ajoute dans le livre une certification construite à partir d'une preuve de travail.
+\begin{enumerate}
+  \item On commence par une preuve de travail quelconque. Pour nous ce sera 
+  \ci{[0,0,0,0,0,0]}.
+  \item On écrit la première transaction (par exemple \ci{"Amir -100"}).
+  \item On calcule et on écrit dans le livre une preuve de travail, qui va servir de certificat. C'est une liste
+  (par exemple \ci{[56,42,10,98,2,34]}) obtenue après beaucoup de calculs prenant en compte la transaction précédente et la précédente preuve de travail.
+  \item À chaque nouvelle transaction (par exemple \ci{"Barbara +45"}), quelqu'un calcule une preuve de travail pour la dernière transaction associée à la précédente preuve. On écrit la transaction, puis la preuve de travail.
+\end{enumerate}
+
+\myfigure{0.5}{
+\tikzinput{fig-bitcoin-4}
+}  
+
+\newpage
+
+
+\section*{Preuve de travail}
+
+
+
+\begin{itemize}
+   \item Une preuve de travail est la résolution d'un problème difficile, mais où il est facile de vérifier que la solution obtenue est correcte.
+
+  \item 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.
+\end{itemize}
+
+\myfigure{0.5}{
+\tikzinput{fig-bitcoin-4}
+}  
+
+\newpage
+
+\section*{Fonction de hachage}
+
+
+\begin{itemize}
+  \item À partir d'un long message nous calculons une courte empreinte. 
+  \item Il est difficile de trouver deux messages différents ayant la même empreinte.
+  \item Ici notre message est une liste d'entiers (entre $0$ et $99$) de longueur un multiple quelconque de $N=6$.
+  \item Son empreinte (ou \emph{hash}) sera une liste de longueur $N=6$.
+  
+  \item  Exemple : \ci{[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]} a pour empreinte :\\
+  \centerline{\ci{[10, 0, 58, 28, 0, 90]}}
+  \item Exemple : \ci{[1, 1, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]} a pour empreinte :\\
+  \centerline{\ci{[25, 14, 29, 1, 19, 6]}}
+\end{itemize}  
+  
+ L'idée est de mélanger les nombres par bloc de $N=6$ entiers, puis de combiner ce bloc au suivant et de recommencer, jusqu'à obtenir un seul bloc.
+
+\newpage
+
+\section*{Un tour} 
+  
+  Pour un bloc $[b_0,b_1,b_2,b_3,b_4,b_5]$ de taille $N=6$, \emph{faire un tour} consiste à faire les opérations suivantes :
+  \begin{enumerate}
+    \item On additionne certains entiers : 
+    $$[b_0',b_1',b_2',b_3',b_4',b_5'] = [b_0,b_1+b_0,b_2,b_3+b_2,b_4,b_5+b_4]$$
+    
+    \item On multiplie ces entiers par des nombres premiers (dans l'ordre $7,11,13,17,19,23$) et on rajoute $1$ :
+    $$[b_0'',b_1'',b_2'',b_3'',b_4'',b_5''] = [7 \times b_0'+1,11\times b_1'+1,13\times b_2'+1,17 \times b_3'+1,19 \times b_4'+1,23 \times b_5'+1]$$
+    
+    \item On effectue une permutation circulaire (le dernier passe devant) :
+    $$[b_0''',b_1''',b_2''',b_3''',b_4''',b_5'''] = [b_5'',b_0'',b_1'',b_2'',b_3'',b_4'']$$
+    
+    \item On réduit chaque entier modulo $100$ afin d'obtenir des entiers entre $0$ et $99$.
+  \end{enumerate}
+
+
+\myfigure{0.7}{
+\tikzinput{fig-bitcoin-1}
+}  
+
+
+\newpage
+\begin{minipage}{0.6\textwidth}  
+  Partant du bloc $[0, 1, 2, 3, 4, 5]$, on a donc successivement :
+   \begin{enumerate}
+    \item additions : $[0, 1, 2, 5, 4, 9]$
+    
+    \item multiplications : $[7\times 0 + 1, 11\times 1+1, 13\times 2+1, 17 \times 5+1,19 \times  4+1, 23 \times 9+1] = [1,12,27,86,77,208]$ 
+    
+    \item permutation : $[208,1,12,27,86,77]$
+    
+    \item réduction modulo $100$ : $[8,1,12,27,86,77]$
+  \end{enumerate}
+  
+   Vérifie que le bloc $[1, 1, 2, 3, 4, 5]$ est transformé en $[8, 8, 23, 27, 86, 77]$.
+\end{minipage}\quad
+\begin{minipage}{0.3\textwidth}
+ \myfigure{0.7}{
+\tikzinput{fig-bitcoin-1}
+}  
+\end{minipage} 
+ 
+ 
+\newpage
+
+ 
+\section*{Dix tours} 
+    
+    Pour bien mélanger chaque bloc, itère dix fois les opérations précédentes.
+    Après $10$ tours :
+    \begin{itemize}
+      \item le bloc $[0, 1, 2, 3, 4, 5]$ devient $[98, 95, 86, 55, 66, 75]$,
+      \item le bloc $[1, 1, 2, 3, 4, 5]$ devient $[18, 74, 4, 42, 77, 42]$.
+    \end{itemize}
+ Deux blocs proches sont transformés en deux blocs très différents ! 
+   
+\newpage   
+   
+\section*{Hachage d'une liste} 
+   
+   Partant d'une liste de longueur un multiple de $N=6$, on la découpe en blocs de longueur $6$ et on calcule l'empreinte de cette liste selon l'algorithme suivant :
+   \begin{itemize}
+     \item On extrait le premier bloc de la liste, on effectue $10$ tours de mélange.
+     \item On ajoute terme à terme (et modulo $100$), le résultat de ce mélange au second bloc.
+     \item On recommence en partant du nouveau second bloc.
+     \item Lorsqu'il ne reste plus qu'un bloc, on effectue $10$ tours de mélange, le résultat est l'empreinte de la liste.
+   \end{itemize}
+ 
+ 
+Voici le schéma d'une situation avec trois blocs : dans un premier temps il y a trois blocs (A,B,C) ; dans un second temps il ne reste plus que deux bloc (B' et C) ; à la fin il ne reste qu'un bloc (C'') : c'est l'empreinte !
+\myfigure{0.5}{
+\tikzinput{fig-bitcoin-2}
+}  
+  
+\newpage
+  
+  Exemple avec la liste $[0,1,2,3,4,5,1,1,1,1,1,1,10,10,10,10,10,10]$.
+  \begin{itemize}
+    \item Le premier bloc est $[0,1,2,3,4,5]$, son mélange à $10$ tours est 
+    $[98, 95, 86, 55, 66, 75]$. 
+    \item On ajoute ce mélange au second bloc $[1,1,1,1,1,1]$.
+    \item La liste restante est maintenant $[99,96,87,56,67,76,10,10,10,10,10,10]$.
+    \item On recommence. Le nouveau premier bloc est $[99,96,87,56,67,76]$, son mélange à $10$ tours vaut $[60, 82, 12, 94, 6, 80]$, on l'ajoute au dernier bloc $[10,10,10,10,10,10$] pour obtenir (modulo $100$) $[70,92,22,4,16,90]$.
+    \item On effectue un dernier mélange à $10$ tours pour obtenir l'empreinte : $[77, 91, 5, 91, 89, 99]$.
+   \end{itemize}
+   
+   
+\myfigure{0.4}{
+\tikzinput{fig-bitcoin-2}
+}     
+
+\end{document}
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Activité 4
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\begin{activite}[Preuve de travail - Minage]
+
+\objectifs{Objectifs : construire un mécanisme de preuve de travail à l'aide de notre fonction de hachage.}
+
+\index{minage}
+
+On va construire un problème compliqué à résoudre, pour lequel, si quelqu'un nous donne la solution, alors il est facile de vérifier qu'elle convient.
+
+\textbf{Problème à résoudre.} On nous donne une liste, il s'agit de trouver un bloc tel que, lorsque qu'on le rajoute à la liste, cela produit un hachage commençant par des zéros.
+Plus précisément étant donné une liste  \ci{liste} et un objectif maximal \ci{Max}, il s'agit de trouver un bloc \ci{preuve} qui, concaténé à la liste puis haché, est plus petit que la liste \ci{Max}, c'est-à-dire : \\
+\centerline{\ci{hachage(liste + preuve)} \  plus petit que \  \ci{Max}}
+
+La liste est de longueur quelconque (un multiple de $N=6$), la preuve est un bloc de longueur $N$, l'objectif est de trouver une liste commençant par des $0$ (voir l'activité 2).
+
+Par exemple : soit la \ci{liste = [0,1,2,3,4,5]} et \ci{Max = [0,0,7]}. Quel bloc \ci{preuve} puis-je concaténer à \ci{liste} pour résoudre mon problème ?
+\begin{itemize}
+  \item \ci{preuve = [12, 3, 24, 72, 47, 77]} convient car concaténé à notre liste cela donne \ci{[0,1,2,3,4,5,12, 3, 24, 72, 47, 77]} et le hachage de toute cette liste vaut
+  \ci{[0, 0, 5, 47, 44, 71]} qui commence par \ci{[0,0,5]} plus petit que l'objectif.
+
+  \item \ci{preuve = [0, 0, 2, 0, 61, 2]} convient aussi car après concaténation on a 
+  \ci{[0,1,2,3,4,5,0, 0, 2, 0, 61, 2]} dont le hachage donne \ci{[0, 0, 3, 12, 58, 92]}.
+  
+  \item \ci{[97, 49, 93, 87, 89, 47]} ne convient pas, car après concaténation puis hachage on obtient \ci{[0, 0, 8, 28, 6, 60]} qui est plus grand que l'objectif voulu.
+\end{itemize}
+
+\begin{enumerate}
+  \item \textbf{Vérification (facile).} 
+  
+  Programme une fonction \ci{verification_preuve_de_travail(liste,preuve)} qui renvoie vrai si la solution \ci{preuve} proposée convient pour \ci{liste}. Utilise la fonction \ci{est_plus_petit()} de l'activité 2.
+  
+  \item \textbf{Recherche de solution (difficile).}
+  
+  Programme une fonction \ci{preuve_de_travail(liste)} qui cherche un bloc \ci{preuve} solution à notre problème pour la liste donnée. 
+  
+  
+  \emph{Indications.}
+  
+  \begin{itemize}
+    \item La méthode la plus simple est de prendre un bloc \ci{preuve} de nombres au hasard et de recommencer jusqu'à trouver une solution.
+    
+    \item Tu peux aussi tester systématiquement tous les blocs en commençant avec \ci{[0,0,0,0,0,0]}, puis \ci{[0,0,0,0,0,1]}\ldots{} et t'arrêter au premier qui convient.
+    
+    \item Tu ajustes la difficulté du problème en changeant l'objectif : facile avec \ci{Max = [0,0,50]}, moyen avec \ci{Max = [0,0,5]}, difficile avec \ci{Max = [0,0,0]}, trop difficile avec \ci{Max = [0,0,0,0]}.
+    
+    \item Comme il existe plusieurs solutions, tu n'obtiens pas nécessairement la même solution à chaque recherche. 
+    
+   \end{itemize}
+   
+   \item \textbf{Temps de calcul.}
+   
+   Compare le temps de calcul d'une simple vérification par rapport au temps de recherche d'une solution. Choisis l'objectif \ci{Max} de sorte que la recherche d'une preuve de travail nécessite environ entre 30 et 60 secondes de calculs.
+  
+\end{enumerate}  
+
+Pour le \emph{bitcoin}, ceux qui calculent des preuves de travail sont appelés les \emph{mineurs}. Le premier qui trouve une preuve gagne une récompense. La difficulté du problème est ajustée de sorte 
+que le temps de calcul mis par le gagnant (parmi l'ensemble de tous les mineurs) pour trouver une solution, soit d'environ $10$ minutes.
+
+\end{activite}
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Activité 4
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\begin{activite}[Tes \emph{bitcoins}]
+
+\objectifs{Objectifs : créer un livre de compte (appelé \emph{blockchain} pour le \emph{bitcoin}) qui enregistre toutes les transactions, ce registre est public et certifié. Il est pratiquement impossible d'y falsifier une transaction déjà inscrite.}
+
+
+\myfigure{0.5}{
+\tikzinput{fig-bitcoin-3}
+}  
+
+\begin{enumerate}
+  \item \textbf{Initialisation et ajout d'une transaction.}
+  
+  \begin{enumerate}
+    \item Initialise une variable globale \ci{Livre} qui est une liste et contient au départ une preuve nulle : \ci{Livre = [ [0,0,0,0,0,0] ]} .
+  
+    \item Une \emph{transaction} est une chaîne de caractères comprenant un nom et la somme à ajouter (ou à retrancher) à son compte. Par exemple \ci{"Abel +25"} ou \ci{"Barbara -45"}.
+    
+    Programme une fonction \ci{ajout_transaction(transaction)} qui ajoute la chaine de caractère \ci{transaction} à la liste \ci{Livre}. 
+Par exemple après l'initialisation \ci{ajout_transaction("Camille +100")},  
+    \ci{Livre} vaut \ci{[ [0, 0, 0, 0, 0, 0], "Camille +100" ]}.
+    Attention, pour pouvoir modifier \ci{Livre} il faut commencer la fonction par : \ci{global Livre}.
+    
+  \end{enumerate} 
+  
+   \item Dès qu'une transaction est ajoutée, il faut calculer et ajouter au livre de comptes une preuve de travail. Programme une fonction \ci{minage()}, sans paramètre, qui ajoute une preuve de travail au livre.   
+   
+Voici comment faire :
+  \begin{itemize}
+    \item On prend la dernière transaction \ci{transaction}, on la transforme en une liste d'entiers par la fonction \ci{phrase_vers_liste()} de l'activité 2.
+    \item On prend la preuve de travail \ci{prec_preuve} située juste avant cette transaction.
+    \item On forme la liste \ci{liste} composée d'abord des éléments de \ci{prec_preuve}, puis des éléments de la liste d'entiers obtenue en convertissant la chaîne \ci{transaction}.
+    \item On calcule une preuve de travail de cette liste.
+    \item  On ajoute cette preuve au livre de compte.
+  \end{itemize}
+  Par exemple si le livre se termine par :\\
+  \centerline{\ci{[3, 1, 4, 1, 5, 9], "Abel +35"}}
+  alors après calcul de la preuve de travail le livre se termine par exemple par :\\
+  \centerline{\ci{[3, 1, 4, 1, 5, 9], "Abel +35", [32, 17, 37, 73, 52, 90]}}  
+     On rappelle que la preuve de travail n'est pas unique et qu'en plus elle dépend 
+   de l'objectif \ci{Max}.
+   
+   \item Une seule personne à la fois ajoute une preuve de travail. Par contre tout le monde a la possibilité de vérifier que la preuve proposée est correcte (et devrait le faire). 
+	Écris une fonction \ci{verification_livre()}, sans paramètre, qui vérifie que la dernière preuve ajoutée au \ci{Livre} est valide.
+	
+	\item Écris un livre de compte qui correspond aux données suivantes :
+	\begin{itemize}
+	  \item On prend \ci{Max  = [0,0,5]} et au départ \ci{Livre = [ [0,0,0,0,0,0] ]}.
+	  \item \ci{"Alfred -100"} (Alfred doit 100 \emph{bitcoins}).
+	  \item Barnabé en reçoit 150.
+	  \item Chloé gagne 35 \emph{bitcoins}.
+	\end{itemize}
+
+\end{enumerate} 
+
+Conclusion : imaginons que Alfred veuille tricher, il veut changer le livre de compte afin de recevoir 100 \emph{bitcoins} au lieu d'en devoir 100. Il doit donc changer la transaction le concernant en \ci{"Alfred +100"} mais il doit alors recalculer une nouvelle preuve de travail ce qui est compliqué, surtout il doit aussi recalculer la preuve de la transaction de Barnabé et aussi celle de la transaction de Chloé ! 
+
+Quelqu'un qui veut modifier une transaction doit modifier toutes les preuves de travail suivantes. Si chaque preuve demande suffisamment de temps de calcul ceci est impossible. Pour le \emph{bitcoin} chaque preuve demande énormément de calculs (trop pour une personne seule) et une nouvelle preuve est à calculer toutes les 10 minutes. Il est donc impossible pour une personne de modifier une transaction passée.
+
+\end{activite}
+
+
+L'autre aspect du \emph{bitcoin} que nous n'avons pas abordé, c'est de s'assurer de l'identité de chaque personne impliquée, afin que personne ne puisse récupérer l'argent d'un autre. Ceci est rendu possible grâce à la cryptographie à clé privée/clé publique (système RSA). Chaque compte est identifié par une clé publique (deux très grands entiers), ce qui garantit l'anonymat. Mais surtout, seul celui qui possède la clé privée du compte (un grand entier) peut accéder à ses \emph{bitcoins}.
+
+\end{document}

bitcoin/pres-bitcoin.pdf

@@ -37,9 +37,24 @@ def chercher_find(chaine,sous_chaine):
 position = chercher_find(chaine,"XYZ")
 print(position)
 
-
 ## Question 3 ##
 
+def chercher_index(chaine,sous_chaine):
+    position = chaine.index(sous_chaine)    
+    return position
+
+# Test 
+print("--- Avec index() ---")
+
+position = chercher_index(chaine,sous_chaine)
+print(position)
+
+# position = chercher_index(chaine,"XYZ")
+# print(position)
+
+
+## Question 4 ##
+
 
 def chercher(chaine,sous_chaine):
     long_chaine = len(chaine)