Quelques notions de complexité - IMJ-PRG

Chapitre 3
Quelques notions de
complexité
3.1. Les entiers en informatique
3.1.1. Numération en base b.Soit b>1un entier. Nous allons brièvement rap-
peler une notion qui remonte à nos souvenirs de jeunesse : la numération en base
b.
Théorème 3.1. Tout entier naturel ns’écrit de manière unique sous la forme
n=akbk+ak1bk1+···+a1b+a0,
avec a0,...,a
k2{0,...,b1}.
Démonstration. Concernant l’existence, on procède par récurrence sur l’entier n:
pour n<b, c’est immédiat. Pour n>b, le théorème 2.22 affirme que les entiers
met a02{0,...,b1}tels que n=bm +a0existent et sont univoquement
déterminés. On a clairement l’inégalité stricte m<n. Par hypothèse de récurrence,
il existe a1,...,a
k2{0,...,b1}tels que m=akbk1+···+a1, ce qui donne
n=akbk+···+a0. Concernant l’unicité, il suffit de remarquer que a0est le reste
de la division de n0=npar b; il est donc unique. Dans ce cas a1est le reste de la
division euclidienne de n1=(n0a0)/b par b, et est lui aussi unique. En iérant ce
procédé, on en déduit qu’il en est de même pour ai, qui est le reste de la division
euclidienne de ni=(ni1ai1)/b par b.⇤
En suivant la notation du théorème ci-dessus, on dit que n=(akak1...a
0)b
est l’écriture de nen base b. Si aucune confusion n’est possible, on écrit parfois
n=ak...a
0.
29

30 3. Quelques notions de complexité
Exemple 3.2. Le tableau ci-dessous contient les écritures de l’entier 2016 en base
b<10.
2 3 4 5 6 7 8 9
11111100000 2202200 133200 31031 13200 5610 3740 2680
Remarque 3.3. Ayant commencé à compter en utilisant les dix doigts de nos
mains, c’est l’écriture en base 10 qui s’est imposée au fil des siècles. Cependant,
d’un point de vue pratique, et particulièrement en ce qui concerne les application
en informatique, on utilise le plus souvent l’écriture en base 2.
3.1.2. Entiers et bits. Un bit est une variable qui ne peut prendre que les valeurs
0et 1. En considérant son écriture en base 2, un entier naturel peut être considéré
comme une suite de bits. De manière plus précise, pour n=(ak1...a
0)2, l’entier
naturel kest la taille de n, i.e. le nombre de bits nécéssaires pour le mémoriser. Le
bit ak1est le plus significatif er a0est le moins significatif. On remarquera que k
est le seul entier tel que 2k1n<2k, ce qui implique que la taille de nest la
partie entière du nombre réel log(n)/log(2)+1. Dans le cas d’un entier quelconque
n, on peut considérer un bit supplémentaire encodant son signe. Il est important de
signaler que dans la pratique, on utilise plutôt la technique du complément à deux,
qui permet d’effectuer des soustractions de manière plus naturelle. Voulant éviter
de s’éloigner des objectifs du cours, nous ne détaillerons pas cette méthode. À ce
jour, dans les applications cryptographiques tels que le cryptosystème RSA (que
nous verrons plus loin dans le cours), on utilise des entiers à 1024 bits, ce qui
correspond à 309 chiffres décimales.
3.1.3. Opérations élémentaires sur les bits. Il existe quatre opérations élémen-
taires sur les bits : NOT,OR,AND et XOR. Leur résultat est présenté dans les
tableaux ci-dessous.
aNOT a
0 1
1 0
a b a OR b a AND b a XOR b
0 0 0 0 0
0 1 1 0 1
1 0 1 0 1
1 1 1 1 0
Exercice 3.4. Vérifier les relations
aXOR b=(aAND(NOT b)) OR((NOT a) AND b)=
=(aOR b) AND((NOT a) OR(NOT b)).
On considère également l’opération élémentaire de décalage à droite sur une
suite de kbits, définie par RS(ak1...a
0)=0ak1...a 1. On définit de ma-
nière analogue le décalage à gauche en posant LS(ak1...a
0)=ak2...a 00.
On remarquera que si n=(ak1...a
0)2est un entier de kbits, l’entier RS(n)=
(0ak1...a
1)2est le quotient de la division euclidienne de npar 2et a0est son
reste. De plus, si ak1=0alors on a l’identité LS(n)=(ak2...a
00) = 2n.

3.1. Les entiers en informatique 31
Toutes les opérations usuelles entre entiers (comparaison 1, addition, soustrac-
tion, multiplication et division euclidienne) peuvent être effectuées par une suite
d’opérations élémentaires sur leurs bits. Décrivons par exemple un algorithme per-
mettant d’effectuer la somme de deux entiers naturels de kbits a=(ak1...a
0)2,
et b=(bk1...b
0)2:
r 0(bit de retenue)
Pour ide 0àk1
ci (aiXOR bi)XORr
r (aiAND bi)OR(aiAND r)OR(biAND r)
ck r
Cet algorithme nécessite 7kopérations élémentaires. Le résultat est un entier
c=(ck...c
0)2de k+1bits, qui coïncide avec la somme de aet b. Le tableau
ci-dessous indique le nombre (pas nécessairement minimal et arrondi par excès)
d’opérations élémentaires nécessaires pour effectuer les opérations usuelles entre
deux entiers naturels de kbits.
Comparaison 2k
Addition 7k
Soustraction 8k
Multiplication 7k2
Division euclidienne 13k2
3.1.4. Complexité. Étant donné un algorithme sur des entiers (n’utilisant que des
opérations de base telles que la comparaison, la somme, la différence, le produit,
et la division euclidienne), on peut lui associer deux types de complexités : la com-
plexité en espace, qui mesure la mémoire (de l’ordinateur) nécessaire à son execu-
tion, et la complexité en temps, qui est une évaluation de sa durée d’exécution. C’est
cette deuxième notion qui nous intéresse principalement. Nous partirons du prin-
cipe que toutes les opérations élémentaires sur les bits ont la même durée d’exé-
cution et qu’elles seules contribuent de manière significative au temps d’exécution
de l’algorithme (c’est clairement une simplification du problème, mais les résultats
présentés restent néanmoins valables). Avec ces conventions, le temps d’exécu-
tion est proportionnel au nombre d’opérations élémentaires effectuées sur les bits.
Cette constante de proportionnalité dépend de l’ordinateur utilisé et n’est pas d’un
réel intérêt (tant que l’on ne s’intéresse pas à l’implémentation effective de l’al-
gorithme). Afin d’obtenir une expression qui ne tienne pas compte de ce facteur,
il est utile d’introduire quelques notions de comparaison asymptotique. Considé-
rons deux fonctions f,g :Rn!R. On dit que gest dominée par f, et on écrit
1. L’opération de comparaison entre deux entiers consiste à déterminer lequel est le plus grand.

32 3. Quelques notions de complexité
g=O(f), s’il existe deux constantes C, N > 0telles que
|g(x1,...,x
n)|C|f(x1,...,x n)|
pour tout (x1,...,x
n)vérifiant min{x1,...,x n}>N.
Exercice 3.5. Soient f,g,u,v :Rn!Rdes fonctions. Montrer que si u=O(f)
et v=O(g)alors u+v=O(|f|+|g|)et uv =O(fg).
Remarque 3.6. Il est important de remarquer que le symbole d’égalité dans l’ex-
pression g=O(f)doit être entendu comme une inégalité stricte et "O" se traduit
par "une constante fois". En d’autres termes, on effectue une estimation de g(ma-
joration). On a par exemple l’identité log(x)=O(x2), mais aussi log(x)=O(x).
La complexité (en temps) d’un algorithme sur des entiers a1,...,a
npeut être
assimilée à une fonction f:Nn!R. On obtient alors la relation
f=O(k),
où kest le nombre d’opérations élémentaires effectuées lors de son execution. L’en-
tier kdépend de la taille de a1,...,a
n. Ne s’intéressant en fait qu’à des majora-
tions de la complexité, on peut se réduire au cas où fest une fonction d’une seule
variable (correspondant au plus grand des ai).
Exemple 3.7. La complexité de l’algorithme d’addition de deux entiers aet b
décrit précédemment est égale à 7tk, où test le temps d’execution d’une opération
élémentaire sur les bits et kest la taille du plus grand des deux entiers. Si ab, la
complexité est alors O(log(a)).
Le tableau suivant donne une expression de la complexité de quelques algo-
rithmes de base sur deux entiers ab.
Algorithme Complexité
Comparaison O(log(a))
Addition/soustraction O(log(a))
Multiplication/division euclidienne O(log2(a))
Remarque 3.8. L’algorithme d’addition utilisé dans la pratique est très proche
de celui décrit dans cette section. On peut montrer que sa complexité est optimale.
Concernant la multiplication (ou la division euclidienne), on a utilisé un algorithme
qui n’est autre que l’adaptation en base 2de la technique multiplication (ou de
division) à la main, telle que l’on apprend à l’école. C’est à partir de ces estimations
que nous calculerons (ou du moins bornerons) la complexité d’algorithmes plus
élaborés.
Exercice 3.9. Soit nun entier. Montrer que la complexité du calcul de n!est
O(n2log2(n)) et que celle du passage de l’écriture de nen base 10 à celle en
base 2(ou vice-versa) est O(log2(n)).

3.1. Les entiers en informatique 33
Un algorithme sur des entiers a1,...,a
nest polynomial s’il existe des entiers
naturels d1,...,d
ntels que sa complexité soit égale à O(logd1(a1)···logdn(an)).
On dit également que la complexité de l’algorithme est polynomiale. Les algo-
rithmes d’addition, soustraction, multiplication et soustraction sont des exemples
de complexité polynomiale.
3.1.5. La complexité de l’algorithme d’Euclide. Comme nous l’avons souligné
dans le chapitre précédent, l’algorithme d’Euclide (étendu) constitue un outil fon-
damental en cryptologie. Ceci est essentiellement lié au fait que sa complexité est
polynomiale, comme nous le montrerons dans ce paragraphe.
Étant donnés deux entiers aet b, avec a>b, considérons la suite des restes
r0=a>r
1=b>···>r n>r n+1 =0. L’entier n, que nous noterons µ(a, b),
est le nombre de divisions euclidiennes à effectuer pour déterminer rn; on dit que
c’est le nombre de pas nécessaires dans l’algorithme d’Euclide. Afin d’obtenir une
majoration de µ(a, b), on commence par introduire la suite de Fibonacci (Fi)i0
définie par
8
>
<
>
:
F0=0,
F1=1,
Fi+1 =Fi+Fi1pour i>0.
Exercice 3.10. En posant x=1+p5
2et y=1p5 2, montrer que l’on a la relation
Fi=xiyi
p5.
Proposition 3.11 (Lamé).On a l’inégalité
µ(a, b)<log(b)
log(x)+2,
avec x=1+p5
2.
Démonstration. Pour tout i2{0,...,n}, posons wi=rn+1i, de telle sorte que
w0=0,w
1=rn=(a, b)et wn=r1=b. Montrons que wiFi+1 pour tout
i>0. On a clairement
w1=(a, b)1=F2et w2(a, b)+12=F3.
En procédant par récurrence, on obient les relations
wi+1 =qn+1iwi+wi1wi+wi1Fi+1 +Fi=Fi+2,
d’où l’assertion (on remarquera que les entiers qisont strictement positifs). Main-
tenant, en utilisant l’exercice 3.10, l’identité y=x1et l’inégalité y2<2/5
amènent aux relations
Fn=xn1(1)ny2n
p5>3
5p5xn>1
4xn