Algorithmes | Dr. Goulu

Suites infinies en Python

Mon, 26 Jun 2017 00:00:00 +0000

Depuis que je programme en Python, j’entasse les petits bouts de code utiles ou potentiellement réutilisables dans “Goulib”, ma librairie perso et néanmoins disponible en open-source (licence LGPL) sur , , ReadTheDocs pour , avec des

Comme la valeur d’un code se mesure surtout par les tests qui vérifient son bon fonctionnement, je me suis lancé dans un ambitieux projet (de plus…) : tester un maximum de fonctions de mes modules et en calculant des suites de l’ , plus connue sous son acronyme anglais OEIS.

Pour cela j’ai fait un truc dont je suis vachement fier* :

La classe Sequence

Ce ( ) permet de représenter une (sequence en anglais) finie ou infinie de nombres** à partir d’‘une ou plusieurs fonctions passées à :

iterf : un ou générateur produisant les termes de la suite l’un après l’autre
itemf : une fonction retournant le i-ème paramètre de la suite
containf : une fonction renvoyant vrai (True) si son paramètre appartient à la suite.

On peut créer par exemple la série (infinie) des nombres premiers ainsi :

=Sequence(containf= )

Ensuite, l’objet ainsi créé avec n’importe quelle combinaison de ces 3 paramètres peut être utilisé indifféremment:

comme un générateur : for p in A000040() : print(p) # affiche les nombres premiers (jusqu’à l’infini)
comme une liste: A000040 \[999\]# renvoie le 1000ème nombre premier (parce que Python indice à partir de 0…)
comme un ensemble: 201420142013 in A000040 # renvoie True car ce nombre est premier.

Evidemment, si on dispose de fonctions plus efficaces pour chacun de ces paramètres, on peut les utiliser pour rendre les calculs bien plus rapides. Par exemple pour la suite de Fibonacci, on peut exploiter trois algorithmes différents :

=Sequence(iterf= , itemf= , containf= )

En passant, voici comment est définie la séquence “auto descriptrice"qui orne la bannière de l’OEIS ci-dessus:

=Sequence( ( lambda x: ( ( ( ( (x))))) ,1))

Compact et presque clair, non ?

Dérivation

Une Sequence peut être dérivée d’une autre grâce à plusieurs méthodes:

renvoie une Sequence correspondant à la Sequence source filtrée par une fonction. Par exemple: =A000040.filter( ) renvoie les “exposants de Mersenne”, les nombres premiers p tels que $2^p - 1$ est premier.
applique une fonction à chaque terme de la Sequence source. Par exemple la série des carrés des nombres premiers peut se définir ainsi: =A000040.apply(lambda n:n*n)
Pour éviter l’utilisation d’apply dans des cas trivialement simples, l’addition (et la soustraction) d’une Sequence et d’un entier sont définies. Par exemple: = +1 définit les à partir des nombres de la forme $2^{2^n}$
renvoie une Sequence dont le n-ième terme est obtenu en sommant les n premiers termes de la Sequence source: =A000040.accumulate()
renvoie une Sequence produite en appliquant applique une fonction à chaque paire de termes consécutifs. Ainsi la suite des différences entre nombres premiers consécutifs s’écrit: =A000040.pairwise(operator.sub)

On peut aussi combiner deux Sequences pour en créer une nouvelle:

L’opérateur % (modulo, pourquoi pas…) renvoie les termes de la Sequence opérande de gauche qui ne sont PAS dans l’opérande de droite. Ainsi: =A000040 % définit la Sequence des nombres premiers qui ne sont pas
L’opérateur & (and) renvoie les termes de la Sequence opérande de gauche qui sont aussi dans l’opérande de droite. Ainsi: = & A000040 définit la suite des nombres premiers dont qui ne s’écrivent qu’avec des 0 et des 1.
L’opérateur | (or) renvoie la fusion de deux séquences à l’aide du génial . Ainsi: = | définit les nombres ayant 4 diviseurs (dont 1 et eux-mêmes) comme l’union de ceux qui sont le produit de deux nombres premiers avec ceux qui sont le cube d’un nombre premier.

Il y a encore deux méthodes un peu “tirées par les cheveux” du point de vue mathématique, mais qui fonctionnent très bien informatiquement:

renvoie une Sequence (par défaut) en triant les termes de la Sequence d’origine. Par exemple, voici la suites des surfaces des dans l’ordre croissant: =Sequence(math2.primitive_triples).apply(lambda x:x \[0\]*x \[1\]//2) .sort()
renvoie une Sequence où les termes redondants de la suite d’origine sont absents, par exemple: = .unique() // oui, parce que le 5 appartient à deux paires de nombres premiers jumeaux …

Ces méthodes utilisent respectivement et qui fonctionnent tant que la suite initiale est “presque” triée, à savoir tant que l’écart n entre un terme $a_i+n \leq a_i$ n’excède pas le paramètre “buffer” de la fonction. On peut évidemment trouver des suites qui ne pourront “mathématiquement” pas être traitées ainsi, mais informatiquement j’arrive à reproduire les suites de l’OEIS rencontrées jusqu’ici avec buffer=100 seulement

Le dictionnaire OEIS

J’ai ainsi constitué peu à peu le fichier qui définit actuellement environ 150 séries de l’OEIS, et que j’étoffe lorsque l’occasion se présente. A la fin de ce module, j’utilise la géniale possibilité d’introspection de Python pour regrouper toutes les Sequence définies dans un dictionnaire fort utile pour les tests:

\[python\]

# Construit le dictionnaire OEIS par introspection : Simple et WOW ! oeis={} # on crée le dictionnaire vide seqs=globals().copy() # on copie tous les objets déclarés dans ce module for id in seqs: # on parcourt tous les identificateurs des objets if id

\[0\]

==‘A’ and len(id)==7: # et s’ils ont un nom de séquence OEIS … oeis

\[id\]

=seqs

\[id\]

# on les ajoute au dictionnaire … seqs

\[id\]

.name=id # et on définit leur champ name

\[/python\]

Performance

Un point important est qu’aucun calcul n’est effectué lors des opérations ci-dessus. Ce n’est qu’au moment d’utiliser les Sequence ainsi définies que les fonctions iterf, itemf, containf et leurs éventuelles compositions sont évaluées.

C’est un peu “automagique”, mais il faut tout de même veiller à utiliser les algorithmes les plus efficaces, et c’est même un des buts que je poursuis avec ce projet. Par exemple la suite des nombres premiers dont qui ne s’écrivent qu’avec des 0 et des 1 = & A000040 aurait pu s’écrire également: A020449=A000040 & A007088 mais la première formulation est beaucoup plus rapide car la série A007088 des nombres ne s’écrivant qu’avec des 0 et des 1 croît beaucoup plus vite que celle des nombres premiers A000040. Il est par conséquent beaucoup plus rapide de tester si les nombres du genre 1101010101011101 sont premiers que d’énumérer tous les nombres premiers de 16 chiffres et de jeter ceux qui contiennent d’autres chiffres que des 0 ou 1.

Malgré toutes ces précautions, parcourir une suite infinie prendra forcément un temps infini, et ces idiots d’ordinateurs ne sont toujours pas foutus de gérer le . J’ai donc écrit un qui limite le temps de calcul d’une boucle ainsi :

for x in (suite,1): print(x) # affiche tous les termes calculables en 1 seconde (au total)

Ce décorateur est utilisé en particulier dans la fonction appelée par pour afficher les dix premiers termes d’une Sequence, ou du moins ceux qu’on peut calculer en moins d’une seconde.

Les suites particulièrement lentes sont par exemple ou dont le n-ième terme donne le nombre de nombres inférieurs à 10^n satisfaisant une certaine condition. Faute de meilleur algorithme, chaque terme prend 10x plus de temps que le précédent …

Tests

Voià, tous les ingrédients sont prêts pour tester si mes beaux algorithmes fonctionnent correctement, ce qui était le but initial je le rappelle.

Pour ceci, il suffit de vérifier que chaque Sequence fournit bien les mêmes termes que ceux disponibles dans l’OEIS. Ceci est facilité par le fait que l’OEIS fournit pour chaque suite les n premières valeurs dans un fichier texte en accessible par le web. Par exemple fournit les 10'000 premiers nombres premiers.

Donc mon fichier est lui aussi génialement simple* : il traverse le dictionnaire oeis et pour chaque Sequence il télécharge les N termes de référence du site OEIS, vérifie que les n premiers termes de la Sequence sont bien ceux attendus, et produit une erreur sinon. Ou un avertissement si itimeout a limité n à moins de 10.

Ces tests sont automatiquement exécutés (avec beaucoup d’autres) chaque fois que je pousse une nouvelle version de , ce qui fait que je suis averti si modification crée un problème avec une ancienne version de Python ou si un Pingouin détecte un problème invisible de mes Fenêtres.

Débogage… de l’OEIS !

J’ai ainsi beaucoup débogué, amélioré et optimisé la plupart des fonctions de et beaucoup d’ , et je compte poursuivre dans cette voie qui permet d’utiliser les données de l’OEIS comme une référence, validées par de nombreux utilisateurs.

Sauf que des fois, le bug était chez eux. Et je ne suis pas peu fier d’ sur l’OEIS :

, comme déjà mentionné dans , le 20ème terme de la série est 145, pas 142.
, dont certains termes avaient besoins de 0 supplémentaires. Tant qu’à faire j’ai fourni un B-file contenant les 1000 premiers termes exacts pour remplacer l’ancien qui n’en avait que 500.

A cette occasion j’ai remarqué que l’édition de l’OEIS est un peu rébarbative, ce qui peut décourager les contributeurs débutants. Peut-être que mon modeste projet pourrait servir de base à un site plus interactif, utilisant du code (Python of course) pour calculer dynamiquement les suites requises …

Ce long article mijoté pendant plus de six mois se termine par un appel aux allumés du code bonnes volontés : si cet article vous a motivé , n’hésitez pas à contribuer à la Goulib sur GitHub.

Pour ma part je m’attaque aux et qui seront l’occasion de nettoyer le code du en utilisant et testant le module

Notes

*sinon je n’en parlerais pas ici… **ou d’autres objets mais je n’ai pas encore trouvé quoi…

Comment calculer le 10'000'000'000'000'000'000 ème terme de la suite de Fibonacci

Tue, 25 Apr 2017 00:00:00 +0000

Tombé l’autre jour sur un problème idiot mais intéressant : calculer le 1019 ème terme de la . Idiot parce que ça ne sert à rien. Intéressant parce que ça sous-entend qu’il existe une manière de calculer le n-ième terme de cette suite définie par récurrence sans calculer tous les termes précédents. En effet, calculer les termes les uns après les autres prendrait dans les 300'000 ans à raison d’une microseconde par terme…

Un nombre d’or, mais flottant

Comme même les ésotéristes le savent, la suite de Fibonacci est liée au A partir de ce fait, Moivre, Euler et Binet ont indépendamment obtenu ce qu’on appelle aujourd’hui la , et qui donne directement le n-ième terme de la suite:

$\mathcal F_n=\frac1{\sqrt5}(\varphi^n-\varphi'^n)$, avec $ \varphi=\frac{1+\sqrt5}2$, et $ \varphi'=-\frac1\varphi$ .

En pratique, le terme en $ \varphi'$ devient rapidement négligeable et il suffit de chercher l’entier le plus proche de $\frac{\varphi^n}{\sqrt5}$. Par exemple pour n=50, on peut calculer très vite $\mathcal F_{50}\approx\frac{\varphi^{50}}{\sqrt5}$ = 12586269025

Mais on se heurte rapidement au problème de la précision de calcul en nombres flottants sur nos ordinateurs : $\varphi$ étant (mais pas aussi que $\pi$ …), il faut calculer $\varphi^n$ avec au moins autant de décimales que $\mathcal F_n$ comporte de chiffres. Dès n=71 on dépasse les 53 bits de la mantisse des nombres “extended precision” et les dernières décimales des termes calculés sont faux.

Dit autrement, à partir de n=70 la division $\mathcal F_n/\mathcal F_{n-1}$ donne au moins autant de décimales de $ \varphi$ que son calcul en nombres flottants

La Matrice salvatrice

Pour une méthode de calcul en nombres entiers atteignant (presque) la rapidité de la formule de Binet, il faut utiliser l’idée d’un certain Brenner : écrire la récurrence de Fibonacci sous forme matricielle . La matrice toute simple $Q=\begin{pmatrix}1&1\\\\1&0\end{pmatrix}$ permet d’obtenir un nouveau terme de la série de Fibonacci en la multipliant par un vecteur formé des deux termes précédents:

$\begin{pmatrix}1&1\\\\1&0\end{pmatrix}\begin{pmatrix}\mathcal F_{n-1}\\\\\mathcal F_{n-2}\end{pmatrix}=\begin{pmatrix}\mathcal F_{n}\\\\\mathcal F_{n-1}\end{pmatrix}$

En enchaînant les multiplications matricielles, on obtient le n-ième terme à partir des deux premiers (0,1) ainsi :

$\begin{pmatrix}1&1\\\\1&0\end{pmatrix}^{n-1}\begin{pmatrix}1\\\\0\end{pmatrix}=\begin{pmatrix}\mathcal F_{n}\\\\\mathcal F_{n-1}\end{pmatrix}$

En fait on retrouve les termes de la suite directement dans la matrice $Q^n = \begin{pmatrix}\mathcal F_{n+1}&\mathcal F_{n}\\\\\mathcal F_{n}&\mathcal F_{n-1}\end{pmatrix}$.

L’algorithme de l’ permet d’élever la matrice Q à la puissance n en effectuant log2(n) multiplications de matrices 2x2, soit pour n=1019. Ultra rapide, et facilement généralisable à d’autres formules de récurrence !

Malheureusement, la fonction souffre d’une qui empêche de l’utiliser dès n=71 car elle utilise les nombres flottants. Il m’a donc fallu la réécrire, en résolvant une petite contrainte technologique au passage.

Vers les pétaoctets et au delà …

Il se trouve que le 1019-ième terme de la suite de Fibonacci est trop grand pour tenir dans le plus super des ordinateurs. En effet, la longueur du n-ième terme de la suite s’obtient facilement en prenant le log (base 10) de la formule de Binet : $\mathcal L_n=\lceil n\log{\varphi}\rceil$ , soit grosso-modo n*0.208987640249978733769272089237555416822459239918210953539…

Vérifions. Pour n=1000, on obtient:

$\mathcal F_{1000}$=43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875 qui comporte bien pile 209 chiffres.

Donc $\mathcal F_{10^{19}}$ comporte 2089876402499787337 chiffres … Il faudrait octets de RAM (de préférence…) pour stocker ce nombre …

(mon premier meme … désolé …)

Et modulo 1000000007 ?

Fort heureusement, le problème idiot avait un petit détail en prime : il fallait calculer le résultat 1000000007, et ça, ça change tout.

Ce nombre est premier (pour que ça soit plus intéressant), mais surtout il est inférieur à 230, ce qui fait que la multiplication modulo 1000000007 ne nécessite que des opérations sur des 32 bits (signés), ultra rapide.

Voici donc quelques fonctions Python tirées du qui effectuent:

le produit matriciel, optionnellement modulaire
l’exponentiation rapide d’une matrice, optionnellement modulaire, et qui corrige le bug de numpy.matrix_power
le calcul quasi instantané du n-ième terme de la série de Fibonacci, avec une option modulaire vivement recommandée pour de grands n

\[gist id="f56725fa32fbb4840c855a8309662c9d"\]

Avec ça on obtient fibonacci(int(1E19),1000000007) = 647754067 ce qui nous fait une belle jambe, mais nous a appris pas mal de choses intéressantes, non ?

Prochaine étape : trouver la correspondante …

Références

sur StackOverflow (et qui m’a inspiré cet article)
Weisstein, Eric W. “ .” From MathWorld–A Wolfram Web Resource.
Arthur Charpentier “ , 2016 sur Freakonometrics (mention spéciale pour l’image de la spirale…)

Répartition proportionnelle

Mon, 02 Dec 2013 00:00:00 +0000

Voici un petit problème qui se présente assez fréquemment sous diverses formes, et pour lequel j’ai été surpris de ne pas trouver de solution bien documentée.

Le cas le plus simple apparaît souvent dans les tableurs : en calculant des pourcentages arrondis, le total ne fait parfois pas 100%. En effet, rien ne garantit que les arrondis “vers le haut” compensent ceux “vers le bas”. Autrement dit, une somme d’arrondis n’est pas égale à la somme arrondie.

Autre exemple assez différent en apparence. Un berger veut répartir ses moutons sur sa parcelle carrée d’un hectare où il veut faire paître a moutons, son parc rond de π hectares qui peut en accueillir b, et les c restants sur la parcelle louée à son voisin le père Néper, qui fait hectares, de manière à ce que chaque mouton ait la même surface à brouter. Sur les conseils de l’instituteur du village, il commence par écrire la petite équation a.(1+π+e) = 1548 pour obtenir a = 225.66 puis b=708.93 et c=613.41, mais ensuite, comment arrondir chacun de ces nombres vers le haut ou le bas de façon à obtenir exactement un total de 1548 et que les rapports b/a et c/a restent respectivement proches de π et de e ?

C’est en planchant sur un problème de ce type que m’est venue une idée : utiliser une méthode du !

Certains parlements comme le sont élus à la “proportionnelle par liste” : le nombre de sièges étant fixé, on commence par répartir ces sièges entre les partis proportionnellement aux nombre de listes portant l’entête d’un parti choisies par les électeurs. Dans une deuxième phase, les n candidats ayant reçu le plus de voix de chaque parti sont élus aux n sièges attribués à leur parti, mais ceci n’est pas le sujet ici.

La phase de répartition des sièges entre partis rencontre exactement les difficultés liées aux arrondis mentionnées plus haut, et comme l’enjeu est d’importance politique, le problème a été non seulement étudié depuis longtemps, mais les solutions sont mêmes formalisées dans les lois régissant le système électoral de bon nombre d’Etats (voir par exemple). Le hic, c’est qu’il n’y a pas une seule solution définitive mais plusieurs, chacune avec ses avantages et inconvénients.

Représentation graphique de la méthode de Hare avec 3 partis

La “méthode de ” est la plus simple des méthodes dites “du plus fort reste”. On commence par calculer un “quotient électoral” en divisant le nombre total de votes valides par le nombre de sièges à pourvoir. Dans le cas d’une élection on obtient en principe un nombre assez grand, mais pour les prés de notre berger, on a: q = (1+π+e)/1548 = 0.004431 , ce qui n’est autre que la surface à brouter par chaque mouton.

Puis on effectue la (ou entière) du nombre de votes obtenus par chaque parti par ce nombre q. Peu importe que dans notre cas, les votes soient remplacés par des nombres réels, l’important est que l’on souhaite diviser un nombre entier en entiers suivant cette proportion.

On commence par ne considérer que les quotients des divisions entières (notées // en Python) et assigner a = 1//q = 225, b = π//q = 708 et c = e//q = 613 moutons aux trois champs. Mais a+b+c ne totalisant que 1546 moutons, il reste à attribuer les moutons restants aux deux “plus fort restes” des divisions entières. Dans notre cas, 1-a.q = 0.0029, π-b.q = 0.0041 et e-c.q = 0.0018, donc on alloue un mouton de plus aux champs b et a pour obtenir finalement a=226, b=709 et c=613.

La méthode de Hare souffre d’un défaut appelé : le fait d’augmenter de 1 le nombre de sièges/moutons peut dans certains cas faire diminuer de 1 le nombre alloué à l’un des partis/prés, ce qui est illogique. De plus, la méthode de Hare avantage les petits partis qui pourraient gagner leur seul élu au plus fort reste. Les grands partis pourraient même être tentés de déposer plusieurs listes pour gagner des sièges, c’est pourquoi les législations introduisent souvent un quorum ou “seuil de représentativité” sous la forme d’un pourcentage minimum de votes à atteindre pour qu’une liste soit prise en considération*.

On peut diminuer la probabilité d’apparition de ces défauts à l’aide d’une astuce due à (1833-1910), scientifique suisse qui proposa de calculer le “quotient électoral” en divisant le nombre total de votes valides par le nombre de sièges à pourvoir augmenté de 1. Le “quotient de Hagenbach-Bischoff” vaut dans notre cas q = (1+π+e)/(1548+1) = 0.004429. La différence par rapport à la méthode de Hare est très faible, mais suffit à répartir 225+709+613=1547 moutons du premier coup, n’en laissant qu’un à attribuer au parti/pré a puisqu’il présente le reste de division le plus élevé, ce qui nous donne le même résultat qu’Hare dans ce cas précis : a=226, b=709 et c=613

Représentation graphique de la méthode D’Hondt avec 3 partis

Il existe d’autres variantes de quotients électoraux (de Droop, de Imperiali), ainsi que des méthodes dites “ ” dans lesquelles on attribue un des sièges restants au parti dont la moyenne des votes/sièges est la plus élevée, puis on recommence tous les calculs jusqu’à ce que tous les postes soient attribués. L’une des plus utilisées, y compris en France pour les élections au Parlement Européen, est est la méthode du belge D’Hondt, connue pour avantager les grands partis, alors que celle du français Sainte-Laguë qui représente mieux les petits partis est plutôt utilisée en Allemagne et au Nord de l’Europe…

Mais revenons à nos moutons : la méthode Hare suffit parfaitement à mon problème, mais le quotient de Hagenbach-Bischoff ajoute un petit plus de science helvétique qui me plaît assez…

J’ai donc codé la méthode du plus fort reste exportable en Excel. Trois onglets résolvent le cas des 1548 moutons, celui des pourcentages du début de l’article, et celui du scrutin proportionnel utilisé comme exemple dans la et qui donne des résultats différents selon le quotient électoral ( Hare, Hagenbach-Bischoff ou Imperiali) choisi. Pour les curieux, la cellule F1 utilise la fonction Excel LARGE, en français pour obtenir la n-ième plus grande valeur des restes calculés dans la colonne E, où n est le nombre de sièges restant à attribuer. Ensuite un simple test permet de déterminer dans la colonne F si un siège/mouton/pourcent doit être ajouté.

Le “bug connu”, c’est qu’en cas d’égalité des restes il se pourrait qu’on en ajoute trop, mais je ne sais pas trop comment empêcher ceci en Excel sans macro… Par contre ce problème est évité dans que j’ai réalisée pour mon application:

\[gist id="7531147"\]

Si vous trouvez ce code utile ou intéressant, vous pouvez voter pour à une question sur StackOverflow, ça me fera une voix de plus en attendant un siège …

Note : * à mon humble avis le quorum devrait donc être approximativement égal à 1 / le nombre de sièges à pourvoir, donc autour de 1% plutôt que 5 ou 7% dans certains parlements…

Références:

" "
David Madore “ ”, 10 juin 2009

Comment bien brasser les cartes

Sat, 19 Jan 2013 00:00:00 +0000

Les amateurs de jeux de cartes savent qu’il faut accorder beaucoup d’attention au brassage des cartes pour éviter la triche, mais qu’en est-il par exemple dans les jeux de poker en ligne ?

Les informaticiens se sont beaucoup , mais relativement peu sur les problèmes de brassage, moins fréquents et apparemment plus simples. Mais comme disait : “il faut se méfier des appâts rances” ©…

Examinons pour commencer un algorithme tout bête que j’avoue avoir utilisé plusieurs fois : on échange la première carte (ou donnée) avec une autre choisie au hasard parmi les N cartes*, puis on fait de même pour la 2ème carte, la 3ème et ainsi de suite jusqu’à la N-ième. Cette méthode semble réunir toutes les caractéristiques d’un bon algorithme : simplicité, rapidité, et efficacité.

(Si vous avez un vrai browser, . C’est ma première oeuvre faite avec , fortement inspirée de , et que j’essaie désespérément d’inclure directement dans cet article…)

Et pourtant, un tel brassage s’avère “biaisé” : toutes les possibles n’ont pas la même probabilité d’être produites. Déjà en ne brassant que N=3 cartes par cette méthode, 3 des 6 permutations possibles sont nettement moins probables que les 3 autres .

biais naïve swap (i ↦ random)

Avec N=60 cartes, ce biais est bien visible sur la figure ci-contre, produite par une autre en ligne . Elle effectue 10'000 mélanges avec le même algo, compte dans une matrice le nombre de fois ou la i-ième carte se retrouve à la j-ième position après le brassage, et représente les positifs en vert et les négatifs en rouge.

La variante “swap (random ↦ random)” dans laquelle on échange N fois 2 cartes choisies au hasard n’est pas meilleure : elle présente un biais positif sur la diagonale (i=j) qui s’atténue si on effectue 2N échanges, et disparaît presque pour 3N échanges.

Signifierait-ce qu’il faut plus de N opérations pour obtenir un “bon” brassage de N cartes ? On pourrait le penser car il existe un algorithme tout simple sans biais : extraire successivement des cartes prises au hasard dans le tas pour en constituer un deuxième, mais il nécessite N.log(N) opérations***, voire N² s’il est mal programmé . Or N.log(N) est la complexité des algorithmes de tri, donc on pourrait avoir l’idée aussi surprenante que séduisante de se faire un brassage en utilisant auquel on passe une fonction aléatoire comme critère de tri.

C’est tellement beau que j’exhibe même ici le petit bout de code Javascript qui fait ça:

\[source language="javascript"\]

function shuffle(array) { array.sort(function() {return Math.random() - .5}); }

\[/source\]

biais sort (random comparator)

random() renvoie un nombre aléatoire entre 0 et 1, donc Math.random() - .5 tire à pile ou face si une carte est “plus grande” que l’autre lors du tri, ce qui est supposé mélanger au lieu de trier.

Cette méthode produit la matrice de biais ci-contre, dont la non-trivialité me laisse pantois.

Par contre, la variante dans laquelle on commence par générer un vecteur de nombres aléatoires, puis on “dé-trie” les données en utilisant ces nombres aléatoires pour les comparaisons donne un résultat non biaisé. (voir “sort (random order)” dans )

Et une fois qu’on est tout content d’avoir trouvé un algorithme de brassage non biaisé de complexité N.log(N), on découvre celui de datant de 1938, non biaisé, assez simple :

\[source language="javascript"\]

function shuffle(array) { var j = array.length, t, i; while (j) { i = Math.floor(Math.random() * j–); t = array

\[j\]

; array

\[j\]

= array

\[i\]

; array

\[i\]

= t; } }

\[/source\]

Les 3 dernières lignes échangent les cartes en i-ième et en j-ième position tout comme dans notre premier algorithme naïf, mais ici on ne choisit la carte à échanger que parmi celles qui n’ont pas encore été traitées. Et pour des raisons de simplicité du code, on mélange le tableau “depuis la fin”.

Et le plus beau est que sa est proportionnelle à N, ce qui est in exemple de plus de l’universalité du principe de Murphy de la thermodynamique de la tartine beurrée qui dit qu’il est toujours plus facile de générer du désordre que de l’ordre.

D’autre part, si vous devez brasser beaucoup de données de manière irréversible, je ne sais pas moi, pour une application de vote par internet par exemple, souvenez-vous de Fisher-Yates. Et utilisez un , car un peut non seulement souffrir de biais, mais surtout être reproductible à partir de la “graine” et permettre ainsi d’inverser le brassage.

Bon, je voulais encore modéliser différentes techniques de brassage de vraies cartes en JavaScript pour déterminer combien d’opérations sont nécessaires pour obtenir un mélange sans biais, mais je préfère laisser ça en exercice pour ChipRaptor et d’autres.

Notes:

Gag © Pierre-Alain de

* et non N-1, car il faut garder une chance sur N que la carte soit “échangée avec elle même” et reste à sa place dans le tas.

** félicitations au premier lecteur qui calculera les probabilités respectives de ces permutations et expliquera ainsi le biais…

*** parce qu’on doit alors forcément parcourir des

Références:

, “ ”, 14 janvier 2012
Mike Bostock, “ ”, 21 janvier 2012
Jeff Atwood “ ”, 2007, Coding Horror

Comment dire 33 avec 3 cubes ?

Wed, 20 Jun 2012 00:00:00 +0000

Le gars qui m’a pourri ma dernière soirée du printemps s’appelle Mike Croucher. il a négligemment posé le problème suivant:

Il est possible d’écrire beaucoup d’entiers comme la somme des cubes de 3 entiers, par exemple: 99 = (-5)^{3 + 2}3+ 6^3 Un exemple plus compliqué est: 91 = (-67134)^{3 + (-65453)^{3+(83538)^{3 Votre tâche est de trouver les entiers x,y, et z tels que: 33 = x}3 + y}3 + z}3

Comme j’ai bien vu que la solution pour 91 impliquait de grands entiers, je me suis dit que 33 demanderait probablement des nombres encore plus grands, mais j’ai quand même vite pondu le programme Python suivant pour voir:

\[sourcecode lang="Python"\]

res={} #dictionary of results def store(n,x,y,z): if n>=0 and n<100 and n not in res: res

\[n\]

=(x,y,z) print n,res

\[n\]

cube=[] x=0 while True: x3=x*x*x cube.append(x3) for y in range(x+1): y3=cube

\[y\]

for z in range(x+1): z3=cube

\[z\]

store(x3+y3+z3,x,y,z) store(x3-y3+z3,x,-y,z) store(x3+y3-z3,x,y,-z) store(x3-y3-z3,x,-y,-z) store(-x3+y3+z3,-x,y,z) store(-x3-y3+z3,-x,-y,z) store(-x3+y3-z3,-x,y,-z) # store(-x3-y3-z3,-x,-y,-z) #you’re right Neamar, it’s useless x+=1 if x==50: #show “small” results for n in range(100): if n in res: print n,res

\[n\]

else: print n,’?’

\[/sourcecode\]

En moins d’une seconde il trouve les 69 des 100 premiers entiers qui sont des sommes de cubes d’entiers inférieurs à 100. Le plus “compliqué” est 78=-55³+53³+26³ .

Ensuite il mouline pendant des heures pour trouver 51=-796³+659³+602³ et 16=1626³-1609³-511³, et pendant ce temps j’ai exploré les liens émaillant les premiers commentaires .

Il s’avère que le problème soumis par Mike Croucher est extrêmement difficile, voire impossible. liste les solutions trouvées par mon programme, et d’autres qui ont nécessité des algorithmes beaucoup plus fûtés que le mien pour résoudre cette :

87 = 4271³ - 4126³ - 1972³ , découvert en 1964
96 = -15250³ + 13139³ + 10853³
91 = 83538³ - 67134³ - 65453³
80 = -112969³ + 103532³ + 69241³
39 = -159380³ + 134476³ + 117367³ découvert en 1991
75 = - 435203231³ + 435203083³ + 4381159³ découvert en 1993
84 = 41639611³ - 41531726³ - 8241191³ découvert en 1994
30 = 2220422932³ - 2218888517³ - 283059965³ ainsi que 52 = -61922712865³ + 60702901317³ + 60702901317³ par la même équipe, qui a mis au point l’algo le plus performant du moment
24 =15584139827³ - 15550555555³ - 2901096694³ a été découvert avec l’algo précédent en 2001 par D. J. Bernstein, dont la page est consacrée à ce problème et son historique

A part ça, les matheux démontrent (essayez…) que les nombres de la forme 9n+4 et 9n+5 ne peuvent pas être la somme de trois cubes, ce qui règle le cas de 4,5,13,14,22,23 etc.

Bon… je n ai pas vraiment le droit d’utiliser ce dessin, mais il va tellement bien là que j espère que vous ne m en voudrez pas, cher Docteur G…

Reste 33 (et 42 et beaucoup d’autres), qui résistent effrontément aux informaticiens cherchant à les obtenir, ainsi qu’aux mathématiciens essayant de prouver que c’est peine perdue…

C’est énervant qu’un petit problème tout bête comme celui-ci puisse résister ainsi aux ordinateurs les plus puissants. Et motivant de penser qu’une solution est peut-être à la portée d’amateurs éclairés. Des idées ?

Références:

Gardiner, V. L., Lazarus, R. B., & Stein, P. R. “ . “, 1964, Mathematics of Computation, 18, 408-413
Heath-Brown, D. R., Lioen, W. M., & te Riele, H. J. J." ”, 1993, Mathematics of Computation, 61, 235-244
Andrew Bremner, “ ”, 1993
B. Conn and L. Vaserstein, “On sums of three integral cubes”, 1994, Contemp. Math. 166, 285-294.
Eric Pine, Kim Yarbrough, Wayne Tarrant and Michael Beck, Noam D. Elkies, “ ”, 2000, ANTS IV
Michael Beck, Eric Pine, Wayne Tarrant, Kim Yarbrough Jensen “New integer representations as the sum of three cubes”, 2007, Math. Comp. 76, 1683-1690 ( )
Wacław Sierpiński (1988). Elementary theory of numbers. North-Holland. ( )

Al-Khawarizmismes

Mon, 12 Jul 2010 00:00:00 +0000

statue d’Al-Khawarizmi en Ousbekistan, par Heathen Dawn sur Flickr

Dans les années 800, le mathématicien perse introduit le zéro (indien) dans les chiffres arabes, décrit comment résoudre les équations du second degré, et propose de résoudre certains problèmes mathématiques en répétant une séquence d’opérations jusqu’à ce qu’un “critère d’arrêt” soit satisfait. Au XIIème siècle, les moines latins nomment “algorismus” cette méthode d’Al Khuwarizmi, qui devient “algorithme” en français en 1554.

Pour cette idée fondamentale des mathématiques et indispensable en informatique, Al-Khwarizmi a reçu à titre posthume un , et environ commises par des ignares qui mettent un y grec à la place d’un ī persan…

Après que des fous aient passé leur vie à calculer à la main des ou des , c’est évidemment l’arrivée des ordinateurs qui a donné à l’algorithmique son importance actuelle. Aujourd’hui, vous utilisez des algorithmes tous les jours, sans le savoir. Par exemple lorsque vous cliquez sur le titre d’une colonne sur votre ordinateur, et que les lignes sont . Ou lorsque vous . A chaque fois que vous téléphonez ou utilisez votre carte de crédit, vous utilisez des algorithmes de cryptographie qui étaient de la science-fiction il y a 50 ans.

Bon, ça c’était l’introduction. En fait cet article est motivé par la coïncidence de trois événements survenus la semaine passée :

Mes collègues ont (enfin) réussi à faire fonctionner un algo que j’avais pondu pour optimiser les mouvements d’une machine. Un algo assez simple (optimisation , évidemment…), bien testé, mais pas suffisamment documenté, donc pas bien utilisé, donc inspirant une certaine méfiance… Mais là ça marche! Vidéo bientôt.
La découverte de l’existence du attribué tous les 4 ans aux auteurs d’un logiciel de calcul numérique particulièrement efficace, dont certains que je connaissais depuis peu ( et ) et d’autres à découvrir ( )
Enfin, sur les , un lien vers la page d’un chercheur listant par ses collègues et lui. Il y en a 32, assez pour évaluer vos connaissances en la matière ou les rafraîchir, et apprendre éventuellement des choses:

l’ trouve le chemin “le plus court ou presque” entre deux nœuds d’ un graphe. Il est et dans les jeux vidéo pour les déplacements des personnages par “intelligence artificielle”
peut dans certains cas trouver un chemin meilleur qu’A*, mais nécessite plus de calculs.
La est la technique que les enfants utilisent pour chercher un mot dans le dictionnaire : on l’ouvre à la moitié, puis à la moitié de la moitié où se trouve le mot et ainsi de suite jusqu’à trouver la bonne page.
“Branch and bound” : est une méthode générique d’ permettant d’éviter d’évaluer toutes les possibilités.
L’ est un truc de matheux datant de 1976, qui généralise à la fois le plus ancien algorithme connu, (l’ ) et celui de l’ (connue des Chinois déjà 1700 ans plus tôt…)
La omniprésente dans nos fichiers informatiques. Il existe de nombreux algorithmes spécifiques, parmi lesquels la me parait particulièrement géniale.
L’ permet à deux personnes qui ne se connaissent pas d’échanger des informations confidentielles sur un canal non sécurisé. Indispensable en télécommunications.
L’ détermine le chemin le plus court entre deux nœuds d’un graphe, sous certaines contraintes expliquées dans encore.
Les permettent d’approximer des dérivées, comme dans la formule f’(x) = (f(x+h) - f(x-h)) / 2h. (Je les utilise tous les jours, mais est-ce vraiment des algorithmes ?)
La est une méthode d’optimisation sous contrainte. Elle permet d’obtenir une solution optimale à partir des solutions optimales de sous-problèmes. Curieusement, en 1976, on a montré que les algorithmes de programmation dynamique sont équivalents à ceux de recherche d’un chemin optimal dans un graphe…
L’ pour déterminer le plus grand diviseur commun (PGCD) de deux entiers est le plus ancien algorithme connu. Il est paru dans les “Eléments” d’Euclide autour de 300 av J.C et ne nécessite pas de factorisation des nombres.
L’ est très utilisé en traitement d’images.
La (FFT) est extrêmement utilisée en traitement du signal, et plein d’autres domaines, jusque dans .
La est l’algorithme le plus connu pour obtenir le minimum d’une fonction à plusieurs variables.
Les permettent de manipuler plus facilement de grosses données en les réduisant à des empreintes. de manière spectaculairement efficace. Mais ici aussi, j’hésiterais à parler d’algorithme pour une “simple” fonction…
Le est une structure de données exploitée dans beaucoup d’algorithmes informatiques très efficaces comme le . ( Il faut absolument que je trouve le temps d’étudier le “ ”, une structure de données “miraculeuse” découverte en 2000 )
L’ permet de multiplier 2 (grands) nombres plus vite qu’avec la méthode que vous avez apprise à l’école.
L’ détermine des vecteurs de base “presque” orthogonaux à partir d’un grand nombre de vecteurs. Il est utilisé en cryptographie.
l’ permet de résoudre le
Le permet de réarranger rapidement une liste dans un ordre spécifique
La permet de trouver une approximation des zéros d’une fonction, des solutions d’une équation à plusieurs variables, ou les minima/maxima.
est une technique d’“apprentissage renforcé”
le est la meilleure méthode de factorisation d’un nombre, à part l’ qui est à peine meilleur mais beaucoup plus compliqué. Si vous voulez casser une clé RSA, c’est ce qu’il vous faut, en plus de beaucoup de gros ordinateurs…
, pour “RANdom SAmple Consensus” est un algorithme d’ajustement de paramètres à des données qui ignore les données “visiblement complètement fausses”
RSA, pour , est le génial algorithme de cryptographie a clé révélée utilisé dans la plupart des systèmes de sécurité actuels : carte bancaire, commerce électronique etc.
l’ effectue des multiplications de grands entiers en utilisant la FFT. Sacrés mathématiciens…
l’ permet de résoudre les problèmes dits de , dans lesquels on cherche à optimiser la valeurs d’une fonction de plusieurs variables devant satisfaire des contraintes d’inégalités.
La permet de factoriser des matrices rectangulaires, donc de résoudre des systèmes linéaires surdéterminés (avec plus d’équations que d’inconnues). Elle est utilisée dans de nombreux domaines, de la robotique aux prévisions météo.
Résoudre des systèmes d’équations linéaires par ou est l’une des opérations les plus communes en analyse numérique, utilisée dans pratiquement tous les domaines de l’ingénierie.
les “tenseurs de structure” ( en anglais) sont très utilisées en traitement d’image : ils permettent de quantifier l’appartenance d’un pixel à une région homogène. Méritent-ils de figurer dans les algorithmes ? la question est ouverte.
est une structure de données permettant de partitionner des données dans des ensembles disjoints, et de trouver rapidement à quel ensemble appartient une donnée ainsi que de réunir rapidement des ensembles.
L’ , une permettant de corriger les erreurs de transmission en télécommunication. Il est bien caché dans vos téléphones portables, mais il est là.

Connaissez-vous d’autres algorithmes dignes de figurer dans la liste ? les commentaires sont là pour les proposer.

Tri réversible ?

Sat, 30 Jan 2010 00:00:00 +0000

animation de l’algorithme Quick Sort

En informatique, le tri est une opération incontournable car il est beaucoup plus rapide de rechercher une information dans une liste triée que dans un fouillis. C’est pourquoi j’ai longtemps cru qu’une liste triée contenait plus d’information qu’une liste non triée, car je voyais le tri comme un pré-traitement permettant d’accélérer les opérations suivantes, donc un “plus” par rapport à une situation “moins” performante.

Pris d’un doute il y a quelques années, j’avais posé la question sur un forum consacré à l’informatique théorique :

“est-ce qu’une liste triée contient vraiment plus d’information qu’une liste non triée ?”

Un érudit professeur m’avait répondu simplement ceci :

“ce contient d’ est- information liste liste? non plus qu’ qu’ triée triée une une vraiment”.

J’ai mis un moment à comprendre la profondeur de cette réponse : ma question, une fois les mots triés par ordre alphabétique, était devenue incompréhensible, et contenait donc moins d’information que la phrase originale ! Depuis je sais que .

a reposé la question sous un angle intéressant : est-il possible de programmer un algorithme de tri “réversible”, permettant de remettre une liste triée dans son état initial ? Évidemment oui : il suffit de stocker en plus l’information perdue lors du tri, le plus simple étant de mémoriser l’état initial de la liste par exemple en ajoutant à chaque élément trié son numéro d’ordre :

“ce2 contient7 d’10 est-1 information11 liste5 liste14 non15 plus9 qu'3 qu'12 triée6 triée?16 une4 une13 vraiment8 ”.

Pour une liste contenant n éléments, on a besoin de log(n) bits* pour stocker chaque numéro, donc de n.log(n) bits au total.

Peut-on faire mieux? On pourrait se dire que beaucoup d’ comme permutent des éléments après les avoir comparés, et qu’il suffirait donc de stocker le résultat des comparaisons effectuées, soit un bit par test, pour pouvoir ensuite “défaire le tri” en parcourant la liste des bits à l’envers. Combien faut-ils de bits ? ben … au moins n.log(n) aussi puisque c’est justement le nombre de comparaisons qui détermine la “complexité” des algorithmes de tri, et que les bons algorithmes ont une complexité de n.log(n).

Rien ne sert de se casser la tête sur “algorithme de tri réversible”, il ne peut pas être plus efficace que de simplement stocker l’ordre initial des données. Etonnant non ?

Le problème, c’est que la donnée du concours spécifie qu’on n’a le droit de stocker que 50% d’information supplémentaire par rapport à la taille des données : si on trie 4K octets, on n’a droit qu’à 2K de données supplémentaires. Or en fonction de ce qui précède on a besoin de 4096*log(4096) bits, soit 6K, plus que les données! En passant, ça signifie qu’en de petites données, on peut perdre plus de la moitié de l’information contenu dans la liste initiale !

Bref, personne n’a gagné le petit concours parce que ce n’était tout simplement pas possible.,

Note* : en informatique, log(n) dénote évidemment le binaire ou base 2

Comment marche Shazam

Sat, 11 Jul 2009 00:00:00 +0000

Si vous ne connaissez pas , demandez à un propriétaire d’iPhone (eux) ou de Google Phone sous Androïd ( ) de vous montrer cette application incroyable. Si personne dans votre entourage ne vit au 21ème siècle, vous pouvez toujours regarder .

Vous ne rêvez pas : Shazam est capable d’identifier en quelques secondes la musique que vous êtes en train d’écouter à la radio, dans un bar bruyant, ou le générique d’une émission TV ou que sais-je. On dirige le micro du téléphone vers un haut-parleur, on clique un seul bouton et Shazam! le titre du morceau apparait, avec les liens qu’il faut pour l’acheter, évidemment. Business is business.

Ce qui nous intéresse ici, c’est de savoir comment diable Shazam fait pour reconnaitre quasi-instantanément 10 secondes de son parmi 8 millions de morceaux de musique de 3 minutes chacun, soit un total de 1.44 milliards de secondes, ou 45 ans de musique, et ceci même lorsque la musique est diffusée par une mauvaise sono et captée par un mauvais micro dans un environnement bruité. Ca ne vous épate peut être pas si vous n’êtes pas dans la technique, mais moi je suis resté coi d’une hébétude aussi stupéfaite qu’interloquée. Sur le cul, quoi.

Pour comprendre, j’ai un peu fouillé et trouvé que la technologie appartient à qui a notamment acquis la propriété intellectuelle de dénommés et David Culbert. Leur brevet de 2003

\[1\]

est un modèle du genre : il décrit le système en termes suffisamment généraux pour comprendre le principe, mais en évitant soigneusement de donner des informations précises sur comment ça marche vraiment. Mais voici tout de même ce que j’en ai compris.

Shazam compare des “empreintes” calculées à des instants remarquables du morceau, par exemple lorsque des notes apparaissent nettement dans le diagramme temps/fréquence du morceau. Pour des raisons expliquées plus bas il faut comparer environ une centaine d’empreintes, et comme Shazam demande d’enregistrer une dizaine de secondes de musique, j’en déduis qu’ils prennent environ 10 empreintes par seconde, donc que chaque morceau est stocké chez eux sous la forme de 1800 empreintes environ.

"FFT" est un joli petit programme qui affiche le diagramme temps/fréquence d’un mp3

Le brevet est extrêmement vague sur le problème clé du calcul des empreintes. Il mentionne une liste de caractéristiques du son qui pourraient être utilisées, et indique qu’un choix judicieux permet de s’affranchir de diverses perturbations du son, en particulier de décalages fréquentiels, mais surtout que l’empreinte peut être ramenée à un nombre de 32 bits seulement. Avec ce qui précède, il en résulte que les empreintes d’un morceau complet ne nécessitent que 7K de mémoire, et que toute la base de données de Shazam tient sur 54 Gigabytes seulement, ce qui veut dire qu’elle peut tenir dans la mémoire RAM d’une vingtaine de PC actuels.

Reste à retrouver dans cette masse d’empreintes la centaine d’empreintes obtenues à partir de la musique transmise depuis votre téléphone. Et là, la méthode est génialement simple : Pour chaque empreinte, Shazam regarde à quels morceaux elle pourrait appartenir en utilisant simplement l’empreinte comme une clé dans la base de données. En effet, comme 32 bits permettent de coder plus de 4 milliards de possibilités alors que la base ne contient “que” 14 milliards d’empreintes, une empreinte donnée se retrouve en moyenne dans 3 morceaux seulement. Puisque les empreintes tirées de l’échantillon sont bruitées, il faut comparer une centaine d’empreinte qui vont chacune correspondre à 3 morceaux, donc on se retrouvera avec 300 morceaux potentiellement candidats.

C’est là que le brevet de Shazam frappe fort : si 2 empreintes seulement correspondent à un même morceau, on considère que c’est celui-là ! En effet, il n’y a qu’environ un risque sur 25'000 que l’un des 300 morceaux suspecté à cause d’une empreinte bruitée corresponde à l’un des 3 morceaux identifié par une empreinte correcte.

La technologie de Shazam/Landmark permet aussi d’autres applications, comme reconnaître la musique utilisée dans les bandes son des vidéos sur YouTube et la virer si elle est soumise à copyright, ou peut-être aussi identifier des mp3 échangés sur des réseaux p2p, des trucs comme ça …

Car pour la reconnaissance de la musique, il y a désormais encore plus fort que Shazam : . Avec Midomi, il suffit de chantonner, siffloter ou hmmm-hmmm-er un air pour qu’il en retrouve le titre et l’auteur. Mais ça m’épate moins parce qu’avec moi, ça ne marche pas. Ni “Yellow Submarine”, ni “Frère Jacques”, ni même , rien.

Référence

WANG, Avery Li-Chun and CULBERT, Daniel, “Robust and invariant audio pattern matching”, 2003,
Avery Wang, “An Industrial-Strength Audio Search Algorithm”, 2003, ISMIR 2003, 4th International Conference on Music Information Retrieval, Baltimore, Maryland, USA \[article pdf](http://www.ee.columbia.edu/~dpwe/papers/Wang03-shazam.pdf)\] \[[slides pdf\]( ]_[[slides_pdf)(http://ismir2003.ismir.net/presentations/Wang.pdf)
\[altmetric doi="10.1145/1145287.1145312" float="right"\]Avery Wang “The Shazam music recognition service”, 2006 , Communications of the ACM - Music information retrieval Volume 49 Issue 8, Pages 44-48