Calcul Formel

Calcul formel
Introduction
Notes de cours
version 09
(version provisoire à vérifier, ne pas imprimer)
Guillermo MORENO-SOCÍAS
UVSQ (Paris–Saclay) 2024/2025

Table des matières
Introduction 3
0 Prérequis : définitions, notations, conventions, résultats 5

0.1 Ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
0.2 Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
0.3 Relations binaires : relations d’équivalence, relations d’ordre total . . . . . . . . . . . . . . . . 6
0.4 Ensembles de nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
0.5 Familles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
0.6 Cardinaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
0.7 Divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1 Éléments de complexité 10
1.1 Définition de la complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Quelques propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2 Entiers 14
2.1 Entiers multiprécision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2 Algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3 Addition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4 Multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4.1 Algorithme naïf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4.2 Algorithme de Karatsuba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.5 Exponentiation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.6 Division euclidienne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.7 Plus grand commun diviseur et algorithme de Euclide dans ℤ . . . . . . . . . . . . . . . . . . 27
2.8 Exercices supplémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3 Structures algébriques (résumé) 34

3.1 Opérations binaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.2 Anneaux unitaires commutatifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.3 Idéaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.4 Divisibilité dans un anneau commutatif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.5 Anneaux intègres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.6 Corps commutatifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.7 Anneaux de polynômes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.7.1 Dérivée formelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.7.2 Division euclidienne dans un anneaux de polynômes . . . . . . . . . . . . . . . . . . . 41
3.8 Espaces vectoriels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.9 Les entiers : l’anneau ℤ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.9.1 Multiplication dans ℤ : divisibilité, primalité, factorisation . . . . . . . . . . . . . . . . 44
3.9.2 Factorisation dans ℤ∗ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.9.3 Les groupes quotient ℤ/𝑛ℤ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.9.4 Divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.10 Groupes monogènes, groupes cycliques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.11 Polynômes : l’anneau 𝕜[𝑋] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.12 Les entiers modulo 𝑛 : l’anneau ℤ/𝑛ℤ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.12.1 Le lemme chinois . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.12.2 Groupe des inversibles modulo 𝑛 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Calcul formel 1/52 version 09 © GMS

Références 52

Introduction
Notes d’un cours de 1re année du Master Algèbre Appliquée de l’Université de Versailles (Paris–Saclay).
« Calcul formel » est un terme spécifiquement français. En anglais on parle de « Computer Algebra », en
espagnol de « Álgebra computacional », etc.
On peut caractériser le Calcul formel par les trois E :
• E comme exact, par opposition aux calculs utilisant des nombres approchés.
On aura affaire en particulier à des entiers de grande taille.
• E comme effectif, où l’on a une méthode de calcul, par opposition aux théorèmes de pure existence.
On s’intéressera donc aux algorithmes.
• E comme efficace, car si le calcul voulu prend trop de mémoire ou trop de temps il ne sera pas intéressant ;
et s’il y a plusieurs façons de faire, on préférerait la moins chère.
Mesurer ces coûts est le but de la théorie de la complexité.
Exemples 0.0.1
√
1. Est-ce que ( 3)2 = 3 ?
Dans Python 3 on a
>>> from math import sqrt
>>> sqrt(3)
1.7320508075688772
>>> sqrt(3)**2
2.9999999999999996
Dans SageMath on a en revanche

sage:
√ sqrt(3)
3
sage: (sqrt(3))^2
3
+∞
1
2. Valeur de ∑ ?
𝑛=1
𝑛2
Dans Python 3, la somme ordonnée 112 + 212 + 312 + ⋯ + 𝑁12 donne 1.644934057834575 pour 𝑁 ⩾ 94906265,
ce qui peut faire croire que la série “converge” vers 1,644934057834575. Ce résultat est faux et de plus ne
donne aucune information.
Dans SageMath on a en revanche la valeur exacte (et la valeur approchée selon la précision souhaitée) :
sage: m=var('m')
sage: sum(1/m^2,m,1,+oo,hold=True)==sum(1/m^2,m,1,+oo)
+∞
1 1
∑ 2 = 𝜋2
𝑚=1
𝑚 6
sage: sum(1/m^2,m,1,+oo).n(digits=89)
1.6449340668482264364724151666460251892189499012067984377355582293700074704032008738336289

Notre objectif dans ce cours est de présenter des notions élémentaires de calcul formel. Les questions aux-
quelles nous chercheront à répondre auront essentiellement cette forme :
⎧ représenter ⎫ ⎧ entiers ⎫
{ additionner } { polynômes }
{ } { }
Comment ⎨ multiplier ⎬ des ⎨ matrices
⎬ avec un ordinateur ?
{ diviser } { entiers modulaires }
{ } { }
⎩ … ⎭ ⎩ … ⎭
Comment le faire de façon efficace ?
Pour donner un sens au mot « efficace », il sera nécessaire d’étudier la complexité de fonctions et d’algo-
rithmes. Cela fera l’objet du premier chapitre de ce cours. Nous appliquerons tout de suite ces notions à
des algorithmes simples : par exemple, nous verrons pourquoi l’algorithme de multiplication d’entiers qu’on
apprend à l’école n’est pas terriblement efficace et comment faire beaucoup mieux.
Selon les auteurs, les notations et les définitions peuvent différer, ce qui a des conséquences sur les résultats
(énoncés et démonstrations). On a dû donc faire un choix, en essayant d’avoir une certaine cohérence interne.
À la fin de ces notes on trouvera quelques références (attention aux différences dans les notations et les
définitions).
Ces notes sont basées sur un travail préalable de Pierre-Guy Plamondon.
Commentaires et remarques bienvenus, notamment concernant le signalement d’erreurs (dont des coquilles)
et d’améliorations (sachant que l’auteur de ces notes n’est nullement un spécialiste) : [email protected]
ou [email protected].
Plutôt que de diffuser ces notes, merci de dire aux personnes intéressées de demander à l’auteur la dernière
version disponible.
For people fluent in English, the following might be useful:

• Gathen et Gerhard 2013
• Shoup 2008
• Wikipedia, the free encyclopedia s. d.
(but beware of differences with these notes).

0 Prérequis : définitions, notations, conventions, résultats
0.1 Ensembles
On assume ZFC (théorie des ensembles de Zermelo–Fraenkel avec l’axiome du choix).
def
Ensemble vide : ⌀ = { }. Notation à éviter ici : ∅ = ⌀.
Inclusion, égalité, inclusion stricte, ensemble des parties, union, intersection, différence :
def
𝐴 ⊆ 𝐵 ⟺ ∀ 𝑥 ∈ 𝐴, 𝑥 ∈ 𝐵
def
𝐴 = 𝐵 ⟺ (𝐴 ⊆ 𝐵 et 𝐵 ⊆ 𝐴)
def
𝐴 & 𝐵 ⟺ (𝐴 ⊆ 𝐵 et 𝐴 ≠ 𝐵)
def
𝐶 ∈ 𝒫(𝐴) ⟺ 𝐶 ⊆ 𝐴
def
𝑥 ∈ 𝐴 ∪ 𝐵 ⟺ (𝑥 ∈ 𝐴 ou 𝑥 ∈ 𝐵)
def
𝑥 ∈ 𝐴 ∩ 𝐵 ⟺ (𝑥 ∈ 𝐴 et 𝑥 ∈ 𝐵)
def
𝐴 et 𝐵 sont disjoints ⟺ 𝐴 ∩ 𝐵 = ⌀
def
𝑥 ∈ 𝐴 r 𝐵 ⟺ (𝑥 ∈ 𝐴 et 𝑥 ∉ 𝐵)
Notations ambiguës à éviter ici : 𝐴 ⊂ 𝐵 et 𝐴 \ 𝐵 = 𝐴 r 𝐵.
Définition : 𝑃 est une partition d’un ensemble 𝐴 si : • 𝑃 ⊆ 𝒫(𝐴)

• ⌀∉𝑃
• ⋃ 𝐵=𝐴
𝐵∈𝑃
• ∀ 𝐵1 , 𝐵2 ∈ 𝑃 , (𝐵1 = 𝐵2 ou 𝐵1 ∩ 𝐵2 = ⌀)
En particulier : ⌀ possède une unique partition (à savoir ⌀)
{𝑥} possède une unique partition (à savoir {{𝑥}})
def
Couples : (𝑎, 𝑏) = {{𝑎}, {𝑎, 𝑏}}.
def
Produit cartésien : 𝐴 × 𝐵 = { (𝑎, 𝑏) ∣ 𝑎 ∈ 𝐴, 𝑏 ∈ 𝐵 }.
En particulier : 𝐴 × ⌀ = ⌀ × 𝐵 = ⌀
𝐴 × 𝐵 = 𝐵 × 𝐴 ⟺ (𝐴 = ⌀ ou 𝐵 = ⌀ ou 𝐴 = 𝐵)
0.2 Applications
Une application 𝑓 est la donnée de 3 ensembles 𝐴, 𝐵, 𝐺 où 𝐺 ⊆ 𝐴 × 𝐵 et
∀ 𝑎 ∈ 𝐴, ∃ 𝑏 ∈ 𝐵, (𝑎, 𝑏) ∈ 𝐺
∀ 𝑎 ∈ 𝐴, ∀ 𝑏1 , 𝑏2 ∈ 𝐵, (𝑎, 𝑏1 ), (𝑎, 𝑏2 ) ∈ 𝐺 ⟹ 𝑏1 = 𝑏2
On écrit 𝑓 ∶ 𝐴 ⟶ 𝐵, on dit que 𝑓 est une application de l’ensemble 𝐴 dans l’ensemble 𝐵, et 𝐴 est l’ensemble
de départ de 𝑓, et 𝐵 l’ensemble d’arrivée de 𝑓 et 𝒢𝑓 = 𝐺 le graphe de 𝑓. L’image de 𝑎 ∈ 𝐴 par 𝑓 est 𝑓(𝑎) = 𝑏
tel que (𝑎, 𝑏) ∈ 𝒢𝑓 . Donc 𝑓 ∶ 𝐴 ⟶ 𝐵 est une application si tout élément de 𝐴 possède une unique image qui
appartient à 𝐵.
def
Notation : 𝐵𝐴 = { 𝑓 ∶ 𝐴 ⟶ 𝐵 ∣ 𝑓 est une application }.
Deux applications 𝑓1 ∶ 𝐴1 ⟶ 𝐵1 et 𝑓2 ∶ 𝐴2 ⟶ 𝐵2 sont égales, noté 𝑓1 = 𝑓2 (ou 𝑓1 ≡ 𝑓2 ), si 𝐴1 = 𝐴2 et
𝐵1 = 𝐵2 et ∀ 𝑎 ∈ 𝐴1 = 𝐴2 , 𝑓1 (𝑎) = 𝑓2 (𝑎) (cela peut se résumer à 𝐵1 = 𝐵2 et 𝒢𝑓1 = 𝒢𝑓2 ).
𝑎 ∈ 𝐴 est un antécédent de 𝑏 ∈ 𝐵 pour 𝑓 si 𝑓(𝑎) = 𝑏.

def
Si 𝐴′ ⊆ 𝐴, l’image directe de 𝐴′ par 𝑓 est 𝑓(𝐴′ ) = { 𝑓(𝑎) ∣ 𝑎 ∈ 𝐴′ }.
def
L’image de 𝑓 est im 𝑓 = 𝑓(𝐴) = { 𝑓(𝑎) ∣ 𝑎 ∈ 𝐴 }.
def
Si 𝐵′ ⊆ 𝐵, l’image réciproque de 𝐵′ pour 𝑓 est 𝑓 −1 (𝐵′ ) = { 𝑎 ∈ 𝐴 ∣ 𝑓(𝑎) ∈ 𝐵′ }.
Si 𝑓 ∈ 𝐵𝐴 et 𝐴1 , 𝐴2 ⊆ 𝐴 et 𝐵1 , 𝐵2 ⊆ 𝐵 alors
𝑓(𝐴1 ∪ 𝐴2 ) = 𝑓(𝐴1 ) ∪ 𝑓(𝐴2 ) 𝑓 −1 (𝐵1 ∪ 𝐵2 ) = 𝑓 −1 (𝐵1 ) ∪ 𝑓 −1 (𝐵2 )
𝑓(𝐴1 ∩ 𝐴2 ) ⊆ 𝑓(𝐴1 ) ∩ 𝑓(𝐴2 ) 𝑓 −1 (𝐵1 ∩ 𝐵2 ) = 𝑓 −1 (𝐵1 ) ∩ 𝑓 −1 (𝐵2 )
𝑓 −1 (𝑓(𝐴1 )) ⊇ 𝐴1 𝑓(𝑓 −1 (𝐵1 )) ⊆ 𝐵1
Soit 𝑓 ∶ 𝐴 ⟶ 𝐵 une application.
def
𝑓 est injective ⟺ (∀ 𝑎1 , 𝑎2 ∈ 𝐴, 𝑓(𝑎1 ) = 𝑓(𝑎2 ) ⟹ 𝑎1 = 𝑎2 ) ⟺ ∀ 𝑏 ∈ 𝐵, card 𝑓 −1 ({𝑏}) ⩽ 1
def
𝑓 est surjective ⟺ ∀ 𝑏 ∈ 𝐵, ∃ 𝑎 ∈ 𝐴, 𝑓(𝑎) = 𝑏 ⟺ ∀ 𝑏 ∈ 𝐵, card 𝑓 −1 ({𝑏}) ⩾ 1
def
𝑓 est bijective ⟺ 𝑓 est injective et surjective ⟺ ∀ 𝑏 ∈ 𝐵, card 𝑓 −1 ({𝑏}) = 1
En particulier, quel que soit l’ensemble 𝐵 il existe une unique application 𝑓 ∶ ⌀ ⟶ 𝐵 ; elle est toujours
injective ; elle est surjective ssi 𝐵 = ⌀. En revanche, il n’existe pas d’application 𝑓 ∶ 𝐴 ⟶ ⌀ sauf dans le
cas 𝐴 = ⌀.
L’application identité de 𝐴 est id𝐴 ∶ 𝐴 ⟶ 𝐴 définie par id𝐴 (𝑎) = 𝑎 ; elle est bijective.
Soient 𝑓 ∶ 𝐴 ⟶ 𝐵, 𝑔 ∶ 𝐵 ⟶ 𝐶, ℎ ∶ 𝐶 ⟶ 𝐷 des applications.
La restriction de 𝑓 à 𝐴′ ⊆ 𝐴 est l’application 𝑓 |𝐴′ ∶ 𝐴′ ⟶ 𝐵 définie par 𝑓 |𝐴′ (𝑎) = 𝑓(𝑎).
La composée de 𝑓 et 𝑔 est 𝑔 ∘ 𝑓 ∶ 𝐴 ⟶ 𝐶 définie par (𝑔 ∘ 𝑓)(𝑎) = 𝑔(𝑓(𝑎)).
Associativité : (ℎ ∘ 𝑔) ∘ 𝑓 = ℎ ∘ (𝑔 ∘ 𝑓).
Éléments neutres à droite et à gauche : 𝑓 ∘ id𝐴 = 𝑓 et id𝐵 ∘𝑓 = 𝑓.
Non commutativité : On n’a pas 𝑔 ∘ 𝑓 = 𝑓 ∘ 𝑔 en général.
Si 𝑓 ∶ 𝐴 ⟶ 𝐵 est bijective, alors l’application réciproque de 𝑓 ou application inverse de 𝑓 est 𝑓 −1 ∶ 𝐵 ⟶ 𝐴
définie par 𝑓 −1 (𝑏) = 𝑎 tel que 𝑓(𝑎) = 𝑏 (c’est-à-dire, 𝑎 ∈ 𝐴 est l’unique antécédent de 𝑏 pour 𝑓).
Si 𝐴, 𝐵 ≠ ⌀, on a les applications 𝜋1 ∶ 𝐴 × 𝐵 ⟶ 𝐴 et 𝜋2 ∶ 𝐴 × 𝐵 ⟶ 𝐵 définies par 𝜋1 ((𝑎, 𝑏)) = 𝑎 et

𝜋2 ((𝑎, 𝑏)) = 𝑏, appelées projections ; elles sont surjectives.
0.3 Relations binaires : relations d’équivalence, relations d’ordre total

def
Soit 𝑋 un ensemble. Alors 𝐺 ⊆ 𝑋 × 𝑋 définit une relation binaire ℛ sur 𝑋 par 𝑥 ℛ 𝑦 ⟺ (𝑥, 𝑦) ∈ 𝐺.
Cette relation est une relation d’équivalence sur 𝑋 si elle est
• réflexive : ∀ 𝑥 ∈ 𝑋, 𝑥 ℛ 𝑥 ;
• symétrique : ∀ 𝑥, 𝑦 ∈ 𝑋, 𝑥 ℛ 𝑦 ⟹ 𝑦 ℛ 𝑥 ;
• transitive : ∀ 𝑥, 𝑦, 𝑧 ∈ 𝑋, (𝑥 ℛ 𝑦 et 𝑦 ℛ 𝑧) ⟹ 𝑥 ℛ 𝑧.
def
Si ℛ est une relation d’équivalence sur 𝑋, la classe d’équivalence de 𝑥 ∈ 𝑋 est [𝑥]ℛ = { 𝑦 ∈ 𝑋 ∣ 𝑦 ℛ 𝑥 }. L’en-
def
semble quotient de 𝑋 par ℛ est 𝑋/ℛ = { [𝑥]ℛ ∣ 𝑥 ∈ 𝑋 }, c’est-à-dire, l’ensemble des classes d’équivalence.
Deux classes d’équivalence sont soit égales soit disjointes.
On a une bijection entre les partitions de 𝑋 et les relations d’équivalence sur 𝑋, qui à la partition 𝑃 associe
def
la relation d’équivalence 𝑥 ℛ 𝑦 ⟺ (∃ 𝐵 ∈ 𝑃 , 𝑥, 𝑦 ∈ 𝐵), et à la relation d’équivalence ℛ associe la
partition 𝑋/ℛ.
On a que 𝜋 ∶ 𝑋 ⟶ 𝑋/ℛ définie par 𝜋(𝑥) = [𝑥]ℛ est une application surjective.
Une relation binaire ≼ sur 𝑋 est une relation d’ordre si elle est
• réflexive : ∀ 𝑥 ∈ 𝑋, 𝑥 ≼ 𝑥 ;
• antisymétrique : ∀ 𝑥, 𝑦 ∈ 𝑋, (𝑥 ≼ 𝑦 et 𝑦 ≼ 𝑥) ⟹ 𝑥 = 𝑦 ;
• transitive : ∀ 𝑥, 𝑦, 𝑧 ∈ 𝑋, (𝑥 ≼ 𝑦 et 𝑦 ≼ 𝑧) ⟹ 𝑥 ≼ 𝑧.
Une relation d’ordre ≼ sur 𝑋 est une relation d’ordre total si ∀ 𝑥, 𝑦 ∈ 𝑋, (𝑥 ≼ 𝑦 ou 𝑦 ≼ 𝑥).
On a une bijection entre les relations d’ordre total sur 𝑋 et les relations d’ordre total strict sur 𝑋, qui à ≼
def
associe ≺ définie par 𝑥 ≺ 𝑦 ⟺ (𝑥 ≼ 𝑦 et 𝑥 ≠ 𝑦).

0.4 Ensembles de nombres
Sont supposés connus : Les ensembles ℕ = {0, 1, 2, 3, …}, ℤ, ℚ, ℝ, ℂ avec les opérations + et ⋅ et leurs
propriétés.
Notations à éviter ici : ℕ = {1, 2, 3, …} et ℕ0 = {0, 1, 2, 3, …}.
def
Dans ℕ, on définit 𝑚1 ⩽ 𝑚2 ⟺ ∃ 𝑛 ∈ ℕ, 𝑚1 + 𝑛 = 𝑚2 . C’est une relation d’ordre total.
def
Dans ℤ, on définit 𝑎1 ⩽ 𝑎2 ⟺ ∃ 𝑛 ∈ ℕ, 𝑎1 + 𝑛 = 𝑎2 . C’est une relation d’ordre total qui étend celle de ℕ.
def
Dans ℚ, pour 𝑟𝑖 = 𝑚𝑖 avec 𝑎𝑖 ∈ ℤ, 𝑚𝑖 ∈ ℕ∗ , on définit ⟺ 𝑎1 𝑚2 ⩽ 𝑎2 𝑚1 dans ℤ. C’est une
𝑎 𝑎1 𝑎2
𝑚1 ⩽ 𝑚2
𝑖
relation d’ordre total qui étend celle de ℤ.
def
Dans ℝ, on peut définir 𝑥1 ⩽ 𝑥2 ⟺ ∃ 𝑦 ∈ ℝ, 𝑥1 + 𝑦2 = 𝑥2 . C’est une relation d’ordre total qui étend celle
de ℚ.
Ces relations d’ordre total sont compatibles avec + et ⋅ : Dans ℕ, ℤ, ℚ et ℝ on a :
• ∀ 𝑥1 , 𝑥2 , 𝑦, 𝑥1 ⩽ 𝑥2 ⟹ 𝑥1 + 𝑦 ⩽ 𝑥2 + 𝑦
• ∀ 𝑥, 𝑦, (0 ⩽ 𝑥 et 0 ⩽ 𝑦) ⟹ 0 ⩽ 𝑥 ⋅ 𝑦
En revanche : Dans ℂ il n’existe pas de relation d’ordre total compatible avec + et ⋅ .
def
Pour 𝑥, 𝑦 ∈ ℝ, on note J𝑥, 𝑦K = { 𝑎 ∈ ℤ ∣ 𝑥 ⩽ 𝑎 ⩽ 𝑦 }.
Définitions : Pour un ensemble 𝐸 ≠ ⌀ : On dit que 𝑥0 minore 𝐸 si ∀ 𝑒 ∈ 𝐸, 𝑥0 ⩽ 𝑒.
On dit que 𝑥0 majore 𝐸 si ∀ 𝑒 ∈ 𝐸, 𝑒 ⩽ 𝑥0 .
def
Infimum d’un ensemble 𝐸 ≠ ⌀ : On a inf 𝐸 = 𝑥0 ⟺ (𝑥0 minore 𝐸 et (𝑦0 minore 𝐸 ⟹ 𝑦0 ⩽ 𝑥0 )). Il
peut ne pas exister, mais s’il existe il est unique.
def
Supremum d’un ensemble 𝐸 ≠ ⌀ : On a sup 𝐸 = 𝑥0 ⟺ (𝑥0 majore 𝐸 et (𝑦0 majore 𝐸 ⟹ 𝑥0 ⩽ 𝑦0 )). Il
peut ne pas exister, mais s’il existe il est unique.
def
Minimum d’un ensemble 𝐸 : min 𝐸 = 𝑒0 ⟺ (𝑒0 ∈ 𝐸 et 𝑒0 minore 𝐸). Il peut ne pas exister, mais s’il
existe il est unique et min 𝐸 = inf 𝐸.
def
Maximum d’un ensemble 𝐸 : max 𝐸 = 𝑒0 ⟺ (𝑒0 ∈ 𝐸 et 𝑒0 majore 𝐸). Il peut ne pas exister, mais s’il
existe il est unique et max 𝐸 = sup 𝐸.
• Tout sous-ensemble non vide de ℕ possède un (unique) minimum.
• Tout sous-ensemble non vide et minoré de ℤ possède un (unique) minimum.
• Il existe des sous-ensembles non vides et minorés de ℚ qui n’ont pas d’infimum dans ℚ.
• Tout sous-ensemble non vide et minoré de ℝ possède un (unique) infimum dans ℝ.
• Tout sous-ensemble non vide et majoré de ℕ possède un (unique) maximum.
• Tout sous-ensemble non vide et majoré de ℤ possède un (unique) maximum.
• Il existe des sous-ensembles non vides et majorés de ℚ qui n’ont pas de supremum dans ℚ.
• Tout sous-ensemble non vide et majoré de ℝ possède un (unique) supremum dans ℝ.
0.5 Familles
Une famille indexée par un ensemble 𝐼 est une application 𝑓 dont l’ensemble de départ est 𝐼. On l’écrit
(𝑥𝑖 )𝑖∈𝐼 ou ( 𝑥𝑖 ∣ 𝑖 ∈ 𝐼 ), où 𝑥𝑖 = 𝑓(𝑖). Son graphe est donc 𝒢𝑓 = { (𝑖, 𝑥𝑖 ) ∣ 𝑖 ∈ 𝐼 }, et son ensemble d’arrivée
contient l’ensemble { 𝑥𝑖 ∣ 𝑖 ∈ 𝐼 }.
La seule famille indexée par 𝐼 = ⌀ est la famille vide ( ) = ⌀.
La famille ( 𝑥𝑖 ∣ 𝑖 ∈ 𝐼 ) et l’ensemble { 𝑥𝑖 ∣ 𝑖 ∈ 𝐼 } sont différents (sauf si 𝐼 = ⌀).
Si 𝑛 ∈ ℕ, un 𝑛-uplet (𝑥1 , … , 𝑥𝑛 ) est une famille indexée par J1, 𝑛K et correspond à l’ensemble
{(1, 𝑥1 ), … , (𝑛, 𝑥𝑛 )}. En particulier, pour 𝑛 = 0 on a un unique 0-uplet ( ) = ⌀.
def
Si 𝑛 ∈ ℕ, alors 𝐴1 × ⋯ × 𝐴𝑛 = { (𝑎1 , … , 𝑎𝑛 ) ∣ 𝑎𝑖 ∈ 𝐴𝑖 }. En particulier, pour 𝑛 = 0 on trouve {( )} = {⌀}.
def
𝐴×𝑛 = 𝐴1 × ⋯ × 𝐴𝑛 où 𝐴𝑖 = 𝐴. En particulier, 𝐴×0 = {( )} = {⌀}.
Remarque : La notation 𝐴𝑛 est réservée à d’autres fins : 𝐴𝑛 = { 𝑎𝑛 ∣ 𝑎 ∈ 𝐴 }.
Une suite infinie classique (𝑥𝑛 )𝑛∈ℕ est une famille indexée par ℕ ; c’est donc une application 𝑛 ↦ 𝑥𝑛 dont
l’ensemble de départ est ℕ et l’ensemble d’arrivée contient l’ensemble { 𝑥𝑛 ∣ 𝑛 ∈ ℕ }.

Généralisations : Si ( 𝐴𝑖 ∣ 𝑖 ∈ 𝐼 ) est une famille d’ensembles indexée par 𝐼, alors
def
Les 𝐴𝑖 sont 2 à 2 disjoints ⟺ (∀ 𝑖, 𝑗 ∈ 𝐼, 𝑖 ≠ 𝑗 ⟹ 𝐴𝑖 ∩ 𝐴𝑗 = ⌀)
def
𝑥 ∈ ⋃ 𝐴𝑖 ⟺ ∃ 𝑖 ∈ 𝐼, 𝑥 ∈ 𝐴𝑖
𝑖∈𝐼
def
(𝐼 ≠ ⌀) 𝑥 ∈ ⋂ 𝐴𝑖 ⟺ ∀ 𝑖 ∈ 𝐼, 𝑥 ∈ 𝐴𝑖
𝑖∈𝐼
def
⨉ 𝐴𝑖 = ∏ 𝐴𝑖 = { ( 𝑎𝑖 ∣ 𝑖 ∈ 𝐼 ) ∣ 𝑎𝑖 ∈ 𝐴𝑖 }
𝑖∈𝐼 𝑖∈𝐼
En particulier : ⋃ 𝐴𝑖 = ⌀ et ⨉ 𝐴𝑖 = {( )} = {⌀}
𝑖∈⌀ 𝑖∈⌀
En revanche, ⋂ 𝐴𝑖 n’est pas défini en général (ce serait l’ensemble contenant “tout”, qui n’existe pas) ; si
𝑖∈⌀
l’on considère qu’on n’a affaire qu’à des sous-ensembles d’un ensemble 𝐴, on peut adopter la convention
def
⋂ 𝐴𝑖 = 𝐴.
𝑖∈⌀
∃ 𝑖0 ∈ 𝐼, 𝐴𝑖0 = ⌀ ⟹ ⨉ 𝐴𝑖 = ⌀
𝑖∈𝐼
“Associativité” du produit cartésien : Si 𝐼 ∩ 𝐽 = ⌀, on peut identifier (⨉ 𝐴𝑖 ) × (⨉ 𝐴𝑗 ) et ⨉ 𝐴𝑘 .

𝑖∈𝐼 𝑗∈𝐽 𝑘∈𝐼∪𝐽
0.6 Cardinaux
def
Cardinal d’un ensemble : card 𝐴 ⩽ card 𝐵 ⟺ ∃ 𝑓 ∶ 𝐴 ⟶ 𝐵 injective.
Autres notations à éviter ici : #𝐴 = |𝐴| = card 𝐴.
Propriétés : Soient 𝐴, 𝐵, 𝐶 des ensembles. Alors :
card 𝐴 ⩾ card 𝐵 ⟺ ∃ 𝑓 ∶ 𝐴 ⟶ 𝐵 surjective
card 𝐴 = card 𝐵 ⟺ ∃ 𝑓 ∶ 𝐴 ⟶ 𝐵 bijective
card 𝐴 ⩽ card 𝐴
(card 𝐴 ⩽ card 𝐵 et card 𝐵 ⩽ card 𝐴) ⟹ card 𝐴 = card 𝐵
(card 𝐴 ⩽ card 𝐵 et card 𝐵 ⩽ card 𝐶) ⟹ card 𝐴 ⩽ card 𝐶
On a soit card 𝐴 < card 𝐵, soit card 𝐴 = card 𝐵, soit card 𝐴 > card 𝐵.
Opérations sur les cardinaux :
𝐴 ∩ 𝐵 = ⌀ ⟹ card(𝐴) + card(𝐵) = card(𝐴 ∪ 𝐵)
card(𝐴) ⋅ card(𝐵) = card(𝐴 × 𝐵)
card(𝐵)card(𝐴) = card(𝐵𝐴 )
def
Un ensemble 𝐴 est infini ⟺ ∃ 𝐵 & 𝐴, card(𝐴) = card(𝐵).
Un ensemble est fini s’il n’est pas infini.
def def
Définitions : ℵ0 = card ℕ (“aleph indice zéro”) et 𝔠 = 2ℵ0 .
Propriétés :
𝐴, 𝐵 finis ⟹ card(𝐴 ∪ 𝐵) = card(𝐴) + card(𝐵) − card(𝐴 ∩ 𝐵)
card(𝒫(𝐴)) = 2card(𝐴) > card(𝐴)
card(𝐴) = 0 ⟺ 𝐴 = ⌀
∀ 𝑛 ∈ ℕ, card(J1, 𝑛K) = 𝑛 < ℵ0
card ℕ = card ℤ = card ℚ = ℵ0 < card(𝒫(ℕ)) = card ℝ = card ℂ = 𝔠 = 2ℵ0
𝐴 est infini ⟺ card 𝐴 ⩾ ℵ0
def
Un ensemble 𝐴 est infini dénombrable ⟺ card(𝐴) = ℵ0 .
Si 𝑓 ∶ 𝐴 ⟶ 𝐵 est une application entre 2 ensembles finis de même cardinal, alors :
𝑓 est injective ⟺ 𝑓 est surjective

0.7 Divers
L’expression “𝑥 est positif” est en général ambiguë dans certaines langues, et notamment en français, et
notamment en France. D’après le mathématicien francophone Nicolas Bourbaki (un grand génie, bien qu’il
n’ait jamais existé), “𝑥 est positif” signifie 𝑥 ⩾ 0.
math français non ambigu anglais*
𝑥>0 𝑥 est strictement positif 𝑥 is positive
𝑥⩾0 𝑥 est positif ou nul 𝑥 is nonnegative
𝑥⩽0 𝑥 est négatif ou nul 𝑥 is nonpositive
𝑥<0 𝑥 est strictement négatif 𝑥 is negative
* Et de même en allemand, espagnol, finnois, grec, italien, portugais, russe, suédois, etc.
Aussi, “𝑥 est supérieur à 𝑦” est ambigu, on dira donc : 𝑥 est strictement supérieur à 𝑦 si 𝑥>𝑦
𝑥 est supérieur ou égal à 𝑦 si 𝑥⩾𝑦
⎧−1 si 𝑥 < 0
{
Le signe de 𝑥 ∈ ℝ est défini par sign(𝑥) = ⎨ 0 si 𝑥 = 0
{+1 si 𝑥 > 0
⎩
La valeur absolue de 𝑥 ∈ ℝ est |𝑥| = sign(𝑥) 𝑥.
La partie entière inférieure de 𝑥 ∈ ℝ est ⌊𝑥⌋ = max{ 𝑚 ∈ ℤ ∣ 𝑚 ⩽ 𝑥 }.
La partie entière supérieure de 𝑥 ∈ ℝ est ⌈𝑥⌉ = min{ 𝑚 ∈ ℤ ∣ 𝑚 ⩾ 𝑥 }.
On a donc les caractérisations
⌊𝑥⌋ ∈ ℤ et ⌊𝑥⌋ ⩽ 𝑥 < ⌊𝑥⌋ + 1 ou aussi ⌊𝑥⌋ ∈ ℤ et 𝑥 − 1 < ⌊𝑥⌋ ⩽ 𝑥
⌈𝑥⌉ ∈ ℤ et ⌈𝑥⌉ − 1 < 𝑥 ⩽ ⌈𝑥⌉ ⌈𝑥⌉ ∈ ℤ et 𝑥 ⩽ ⌈𝑥⌉ < 𝑥 + 1
Pour 𝑥 ∈ ℝ on définit
𝑥 + ∞ = +∞ + 𝑥 = +∞
𝑥 − ∞ = −∞ + 𝑥 = −∞
+∞ + ∞ = +∞
−∞ − ∞ = −∞
(+∞) ⋅ (+∞) = (−∞) ⋅ (−∞) = +∞
(+∞) ⋅ (−∞) = (−∞) ⋅ (+∞) = −∞
𝑥 > 0 ⟹ (+∞) ⋅ 𝑥 = 𝑥 ⋅ (+∞) = +∞ et (−∞) ⋅ 𝑥 = 𝑥 ⋅ (−∞) = −∞
𝑥 < 0 ⟹ (+∞) ⋅ 𝑥 = 𝑥 ⋅ (+∞) = −∞ et (−∞) ⋅ 𝑥 = 𝑥 ⋅ (−∞) = +∞
Restent non définis (indéterminés) : +∞ − ∞, −∞ + ∞, (±∞) ⋅ 0, 0 ⋅ (±∞).
On assume aussi −∞ < 𝑥 < +∞.
𝑥 ≈ 1,58496 signifie 𝑥 ∈ [1,584955, 1,584965[
𝑥 = 1,58496− signifie 𝑥 ∈ [1,584955, 1,584960[
𝑥 = 1,58496+ signifie 𝑥 ∈ [1,584960, 1,584965[
Soit 𝑧 ∈ ℂ. On l’écrit 𝑧 = 𝑥 + i𝑦 avec 𝑥, 𝑦 ∈ ℝ.
Le conjugué de 𝑧 dans ℂ est 𝑧 = 𝑥 − i𝑦.
√
Le module de 𝑧 est |𝑧| = 𝑧 ⋅ 𝑧 = √𝑥2 + 𝑦2 (bien défini car 𝑧 ⋅ 𝑧 = 𝑥2 + 𝑦2 ∈ [0, +∞[ ).
Pour 𝑧 ∈ ℝ, le module et la valeur absolue coïncident.
On a 𝑧1 ⋅ 𝑧2 = 𝑧1 ⋅ 𝑧2 et |𝑧1 ⋅ 𝑧2 | = |𝑧1 | ⋅ |𝑧2 | et |𝑧1 + 𝑧2 | ⩽ |𝑧1 | + |𝑧2 |.
𝑧 |𝑧 |
Et pour 𝑧2 ≠ 0 on a 𝑧1 /𝑧2 = 𝑧1 /𝑧2 et ∣ 1 ∣ = 1 .
𝑧2 |𝑧2 |
√
Attention : En Théorie des nombres : Dans les corps quadratiques réels (ℚ( D) avec D ∈ ℕ sans facteur
carré, D ⩾ 2), le conjugué de 𝑧, noté 𝑧, ne désigne pas le conjugué dans ℂ.

1 Éléments de complexité
Pour définir et évaluer la complexité d’un algorithme, il nous faudra donner un sens à ce genre de question :
pour une donnée initiale de taille 𝑛, comment se comporte le nombre 𝑓(𝑛) d’opérations élémentaires effectuées
par l’algorithme ?
1.1 Définition de la complexité

Commençons par un exemple pour motiver la définition.
Exemple 1.1.1 Soit 𝑛 ∈ ℕ∗ un entier strictement positif. Soient 𝑎 et 𝑏 deux entiers dont l’écriture en
base 10 nécessite 𝑛 chiffres (on travaillera plus tard avec une base quelconque). Si l’on considère que l’addition
de deux chiffres (0 à 9) est une opération élémentaire, combien d’opérations élémentaires sont nécessaires
pour calculer la somme de 𝑎 et 𝑏 ?
Si 𝑎 = 𝑎𝑛−1 𝑎𝑛−2 … 𝑎0(10 et 𝑏 = 𝑏𝑛−1 𝑏𝑛−2 … 𝑏0(10 sont les écritures décimales de 𝑎 et 𝑏, alors on peut faire
comme suit (à droite, 57394(10 + 82198(10 = 139592(10 ).
(𝑟𝑛 ) (𝑟𝑛−1 ) (𝑟𝑛−2 ) ⋯ (𝑟1 ) (1) (0) (0) (1) (1)
𝑎𝑛−1 𝑎𝑛−2 ⋯ 𝑎1 𝑎0 5 7 3 9 4
+ 𝑏𝑛−1 𝑏𝑛−2 ⋯ 𝑏1 𝑏0 + 8 2 1 9 8
𝑐𝑛 𝑐𝑛−1 𝑐𝑛−2 ⋯ 𝑐1 𝑐0 1 3 9 5 9 2
Les 𝑎𝑖 et 𝑏𝑖 sont les chiffres (entre 0 et 9), les 𝑟𝑖 sont les retenues (elles valent 0 ou 1), et les 𝑐𝑖 sont les
chiffres de l’écriture décimale de 𝑎 + 𝑏.
On trouve 𝑐0 et 𝑟1 en effectuant 𝑎0 + 𝑏0 (1 addition élémentaire).
Puis 𝑐1 et 𝑟2 en effectuant 𝑎1 + 𝑏1 + 𝑟1 (2 additions élémentaires).
⋮
Puis 𝑐𝑛−1 et 𝑟𝑛 en effectuant 𝑎𝑛−1 + 𝑏𝑛−1 + 𝑟𝑛−1 (2 additions élémentaires).
Finalement, on pose 𝑐𝑛 = 𝑟𝑛 .
Cela donne un coût de 1 + (𝑛 − 1) ⋅ 2 = 2𝑛 − 1 additions élémentaires, où 𝑛 est le nombre de chiffres (en
base 10) de 𝑎 et 𝑏.
Si l’on considère que chaque addition élémentaire prend un temps 𝑡0 , alors le coût en temps est (2𝑛 − 1)𝑡0 .
Pour 𝑛 « très grand », c’est le terme 2𝑡0 𝑛 qui compte. Si l’on ignore les constantes multiplicatives, on a ce
qu’on appelle un coût en O(𝑛) (voir ci-après). On parle de coût linéaire (voir plus loin).
Quel est le coût en mémoire ? On doit garder les 𝑛 chiffres de 𝑎, les 𝑛 chiffres de 𝑏, les 𝑛 retenues et les
𝑛 + 1 chiffres de 𝑐, ce qui donne 4𝑛 + 1 chifres. Si chaque chiffre occupe 𝑚0 bits, le coût en mémoire est
(4𝑛 + 1)𝑚0 .
Pour 𝑛 « très grand », c’est le terme 4𝑚0 𝑛 qui compte. Si l’on ignore les constantes multiplicatives, on a un
coût en O(𝑛), encore linéaire.
Le point de départ de la théorie de la complexité est d’essayer de mesurer le coût d’un calcul, que ce soit en
temps (ou nombre d’opérations élémentaires) ou en mémoire.
En général, on ne veut pas un coût exact, mais une estimation. De plus, on ne s’intéresse pas à ce coût
quand on traite des données de petite taille, mais plutôt à sa valeur pour des données de grande taille.
C’est pourquoi on veut estimer le coût asymptotique (dans l’exemple, ce serait pour 𝑛 → +∞).
Suivent quelques définitions.

Un voisinage ouvert de +∞ est tout intervalle de la forme ]𝑥, +∞[ avec 𝑥 ∈ ℝ.
Un voisinage entier de +∞ est tout ensemble { 𝑛 ∈ ℕ ∣ 𝑛 ⩾ 𝑛0 } avec 𝑛0 ∈ ℕ.
Soit 𝑃 (𝑛) une propriété dépendant d’un entier 𝑛. On dit que 𝑃 (𝑛) est vraie pour 𝑛 ≫ 0 (prononcé pour 𝑛
suffisamment grand) s’il existe 𝑛0 ∈ ℕ tel que ∀ 𝑛 ⩾ 𝑛0 , 𝑃 (𝑛) est vraie. Autrement dit, 𝑃 (𝑛) est vraie dans
un voisinage entier de +∞.

Soient 𝑓 et 𝑔 deux applications de ℕ dans ℝ.
1. On dira que 𝑓 ∈ O(𝑔) (prononcé 𝑓 est un grand O de 𝑔 ou 𝑓 est dominée par 𝑔) si :
il existe 𝑐 > 0 tel que |𝑓(𝑛)| ⩽ 𝑐 ⋅ |𝑔(𝑛)| pour 𝑛 ≫ 0.
2. On dira que 𝑓 ∈ Ω(𝑔) (prononcé 𝑓 est un grand oméga de 𝑔 ou 𝑓 domine 𝑔) si 𝑔 ∈ O(𝑓).
3. On dira que 𝑓 ∈ Θ(𝑔) (prononcé 𝑓 est un grand thêta de 𝑔) si l’on a à la fois que 𝑓 ∈ O(𝑔) et 𝑔 ∈ O(𝑓).
4. On dira que 𝑓 ∈ o(𝑔) (prononcé 𝑓 est un petit o de 𝑔 ou 𝑓 est négligeable devant 𝑔) si :
pour tout 𝜀 > 0, |𝑓(𝑛)| < 𝜀 ⋅ |𝑔(𝑛)| pour 𝑛 ≫ 0.
5. On dira que 𝑓 ∈ 𝜔(𝑔) (prononcé 𝑓 est un petit oméga de 𝑔) si 𝑔 ∈ o(𝑓).
Remarque : En théorie analytique des nombres, on utilise Ω pour quelque chose de différent.
Exemples 1.1.2
1. On a que 1 𝑛 ∈ O(𝑛2 ). En effet, 𝑛 ⩽ 1 ⋅ 𝑛2 pour 𝑛 ⩾ 1.
2. On a que 𝑛 ∈ o(𝑛2 ). En effet, soit 𝜀 > 0. Alors pour tout 𝑛 > 1/𝜀, on a 𝜀𝑛2 > 𝜀 1𝜀 𝑛 = 𝑛.
Ainsi, 𝑛 < 𝜀𝑛2 pour 𝑛 ≫ 0.
3. 𝑛2 ∉ O(𝑛). En effet, pour tout 𝑐 > 0, dès que 𝑛 > 𝑐, on a que 𝑛2 > 𝑐𝑛. En particulier, 𝑛 ∉ Θ(𝑛2 ).
4. Si 𝐶 > 0, alors l’application constante 𝑛 ↦ 𝐶 satisfait à 𝐶 ∈ O(1). En revanche, on a que 𝐶 ∉ o(1).
1.2 Quelques propriétés

Les propriétés suivantes sont utiles pour calculer la complexité d’une fonction.
Proposition 1.2.1
Soient 𝑓, 𝑓1 , 𝑓2 , 𝑔, 𝑔1 , 𝑔2 , ℎ des applications de ℕ dans ℝ.
1. Si 𝑓 ∈ o(𝑔), alors 𝑓 ∈ O(𝑔).
2. Si 𝑓 ∈ o(𝑔) et 𝑔 ∈ o(ℎ), alors 𝑓 ∈ o(ℎ). Il en va de même si l’on remplace o par O.
3. On a que 𝑓 ∈ O(𝑓), mais 𝑓 ∉ o(𝑓).
4. Si 𝑓1 ∈ o(𝑔) et 𝑓2 ∈ o(𝑔), alors 𝑓1 + 𝑓2 ∈ o(𝑔). Il en va de même si l’on remplace o par O.
5. Si 𝑓1 ∈ o(𝑔1 ) et 𝑓2 ∈ o(𝑔2 ), alors 𝑓1 𝑓2 ∈ o(𝑔1 𝑔2 ). Il en va de même si l’on remplace o par O.
DÉMONSTRATION. (1) Si 𝑓 ∈ o(𝑔), alors |𝑓(𝑛)| < 𝜀 |𝑔(𝑛)| pour 𝑛 ≫ 0. En prenant par exemple 𝜀 = 1, on a
pour 𝑐 = 1 que |𝑓(𝑛)| ⩽ 𝑐 |𝑔(𝑛)| pour 𝑛 ≫ 0. D’où 𝑓 ∈ O(𝑔).
(2) Si 𝑓 ∈ o(𝑔) et 𝑔 ∈ o(ℎ), alors |𝑓(𝑛)| < 𝜀1 |𝑔(𝑛)| pour 𝑛 ≫ 0 et |𝑔(𝑛)| < 𝜀2 |ℎ(𝑛)| pour 𝑛 ≫ 0. En prenant
√
𝜀1 = 𝜀2 = 𝜀 on a |𝑓(𝑛)| < 𝜀 |ℎ(𝑛)| pour 𝑛 ≫ 0. D’où 𝑓 ∈ o(ℎ).
La démonstration pour O est similaire et est laissée en exercice.
(3) Pour 𝑐 = 1 on a |𝑓(𝑛)| ⩽ 𝑐 |𝑓(𝑛)| pour tout 𝑛 ⩾ 0, donc 𝑓 ∈ O(𝑓).
Si 𝜀 ∈ ]0, 1[, alors |𝑓(𝑛)| ⩾ 𝜀 |𝑓(𝑛)| pour tout 𝑛 ⩾ 0. Donc 𝑓 ∉ o(𝑓).
(4) Si 𝑓1 ∈ o(𝑔) et 𝑓2 ∈ o(𝑔), alors |𝑓𝑖 (𝑛)| < 𝜀𝑖 |𝑔(𝑛)| pour 𝑛 ≫ 0. En prenant 𝜀1 = 𝜀2 = 𝜀/2 on a
|𝑓1 (𝑛) + 𝑓2 (𝑛)| ⩽ |𝑓1 (𝑛)| + |𝑓2 (𝑛)| < 𝜀 |𝑔(𝑛)| pour 𝑛 ≫ 0.
D’où 𝑓1 + 𝑓2 ∈ o(𝑔).
(5) Si 𝑓𝑖 ∈ o(𝑔𝑖 ) alors |𝑓𝑖 (𝑛)| < 𝜀𝑖 |𝑔𝑖 (𝑛)| pour 𝑛 ≫ 0.
√
En prenant 𝜀1 = 𝜀2 = 𝜀 on a |𝑓1 (𝑛)𝑓2 (𝑛)| < 𝜀 |𝑔1 (𝑛)𝑔2 (𝑛)| pour 𝑛 ≫ 0. D’où 𝑓1 𝑓2 ∈ o(𝑔1 𝑔2 ).
Dans certaines conditions, on peut aussi reformuler les définitions de o et O en utilisant des limites.
Proposition 1.2.2
Soient 𝑓 et 𝑔 deux applications de ℕ dans ℝ. Supposons que 𝑔(𝑛) ne s’annule pas pour 𝑛 ≫ 0.
|𝑓(𝑛)|
1. On a que 𝑓 ∈ o(𝑔) si et seulement si lim = 0.
𝑛→+∞ |𝑔(𝑛)|
|𝑓(𝑛)|
2. On a que 𝑓 ∈ O(𝑔) si et seulement si lim sup < +∞.
𝑛→+∞ |𝑔(𝑛)|
1. La notation 𝑛 ∈ O(𝑛2 ) est un abus. Il faudrait écrire : soient 𝑓 et 𝑔 les applications définies par 𝑓(𝑛) = 𝑛 et 𝑔(𝑛) = 𝑛2 ;
alors 𝑓 ∈ O(𝑔). Nous ferons constamment ce genre d’abus de notations.

DÉMONSTRATION. Laissée en exercice.
Forts de ces propriétés, nous pouvons à présent calculer la complexité d’une plus grande famille d’exemples.
Exemples 1.2.3
1. Si 𝑓 ∶ ℕ ⟶ ℝ est une application et 𝐶 > 0 une constante, alors 𝐶𝑓 ∈ O(𝑓). Pour le voir, on peut constater
que 𝐶 ∈ O(1) et 𝑓 ∈ O(𝑓), puis prendre le produit.
𝑛𝑑
2. Si 𝑑 et 𝑒 sont deux réels, alors 𝑛𝑑 ∈ o(𝑛𝑒 ) si et seulement si 𝑑 < 𝑒. En effet, il suffit de voir que lim 𝑒 = 0
𝑛→+∞ 𝑛
si et seulement si 𝑑 < 𝑒 et d’appliquer la Proposition 1.2.2.
𝑑
3. Si 𝑃 (𝑛) est un polynôme en 𝑛 de degré 𝑑 ⩾ 0, alors 𝑃 (𝑛) ∈ O(𝑛𝑑 ). Pour le voir, écrivons 𝑃 (𝑛) = ∑ 𝑎𝑖 𝑛𝑖 .
𝑖=0
En utilisant l’exemple précédent, on voit que chaque 𝑎𝑖 𝑛𝑖 avec 0 ⩽ 𝑖 ⩽ 𝑑 est tel que 𝑎𝑖 𝑛𝑖 ∈ O(𝑛𝑖 ). Comme
𝑛𝑖 ∈ O(𝑛𝑑 ), on en déduit que 𝑎𝑖 𝑛𝑖 ∈ O(𝑛𝑑 ) pour tout 𝑖. Leur somme (finie) 𝑃 (𝑛) est donc aussi dans
O(𝑛𝑑 ).
Lorsque nous étudierons la complexité d’algorithmes, nous devrons étudier la complexité de fonctions définies
à partir d’autres fonctions. Voici un exemple d’un tel calcul.
D’abord, un résultat facile.
Lemme 1.2.4
𝑛
𝑛(𝑛 + 1)
Soit 𝑛 ⩾ 0 un entier. Alors ∑ 𝑖 = .
𝑖=0
2
DÉMONSTRATION. Il s’agit d’une preuve par récurrence classique que nous laissons en exercice au lecteur.
Proposition 1.2.5
Soit 𝑓 ∶ ℕ ⟶ ℝ une application telle que 𝑓 ∈ O(𝑛).
𝑛
On définit 𝑔 ∶ ℕ ⟶ ℝ par 𝑔(𝑛) = ∑ 𝑓(𝑖). Alors 𝑔 ∈ O(𝑛2 ).
𝑖=0
DÉMONSTRATION. Soient 𝑐 > 0 et 𝑁 > 0 tels que |𝑓(𝑛)| ⩽ 𝑐𝑛 ∀ 𝑛 ⩾ 𝑁. On suppose 𝑛 > 𝑁. Alors
𝑛 𝑛
|𝑔(𝑛)| = ∣∑ 𝑓(𝑖)∣ ⩽ ∑|𝑓(𝑖)|
𝑖=0 𝑖=0
𝑁−1 𝑛
= ∑ |𝑓(𝑖)| + ∑|𝑓(𝑖)|
𝑖=0 𝑖=𝑁
𝑛 𝑁−1
= 𝑀 + ∑|𝑓(𝑖)| (où 𝑀 = ∑ |𝑓(𝑖)| est une constante)
𝑖=𝑁 𝑖=0
𝑛
⩽ 𝑀 + ∑ 𝑐𝑖 (car 𝑖 ⩾ 𝑁)
𝑖=𝑁
𝑛
= 𝑀 +𝑐∑𝑖
𝑖=𝑁
𝑛
⩽ 𝑀 + 𝑐∑𝑖 (car 𝑖 ⩾ 0 et 𝑁 ⩾ 0)
𝑖=0
𝑛(𝑛 + 1)
=𝑀 +𝑐 (d’après 1.2.4)
2
Le dernier terme de droite est un polynôme de degré 2 en la variable 𝑛 ; il est donc dans O(𝑛2 ). Ainsi,
l’inégalité |𝑔(𝑛)| ⩽ 𝑀 + 𝑐 𝑛(𝑛+1)
2 pour 𝑛 > 𝑁 nous permet de conclure que 𝑔 ∈ O(𝑛2 ).

1.3 Exercices
Exercice 1.3.1
1 1
Soient 𝑓, 𝑔 ∶ ℕ ⟶ ℝ deux applications ne s’annulant jamais. Montrer que si 𝑓 ∈ o(𝑔), alors ∈ o( ).
𝑔 𝑓
Exercice 1.3.2
Soient 𝑓, 𝑔 ∶ ℕ ⟶ ℝ deux applications. Montrer que les conditions suivantes sont équivalentes.
(a) 𝑓 ∈ Θ(𝑔)
(b) Pour toute application ℎ ∶ ℕ ⟶ ℝ, on a que ℎ ∈ O(𝑓) si et seulement si ℎ ∈ O(𝑔).
Exercice 1.3.3
Démontrer les faits suivants.
1. Pour tout réel 𝛼, on a que 𝑛𝛼 ∈ o(exp(𝑛)).
2. Pour tous réels 𝑎, 𝑏 tels que 0 < 𝑎 < 𝑏, on a que 𝑎𝑛 ∈ o(𝑏𝑛 ).
3. Pour tout réel 𝛼 > 0, on a que log(𝑛) ∈ o(𝑛𝛼 ).
4. Pour tout réel 𝛼 ⩾ 0, on a que 𝑛−𝛼 ∈ o(1).
5. log log(𝑛) ∈ o(log(𝑛)).
6. exp(𝑛) ∈ o(exp(exp(𝑛))).
7. exp(𝑛) ∈ o(𝑛!).
Exercice 1.3.4
Soit 𝑓 ∶ ℕ ⟶ ℝ une application. Montrer que 𝑓 ∈ O(1) si et seulement si |𝑓| est majorée.
Exercice 1.3.5
Soit 𝑓 ∶ ℕ ⟶ ℝ une application. Montrer que 1 ∈ O(𝑓) si et seulement si |𝑓| est minorée.
Exercice 1.3.6
Soit 𝑓 ∶ ℕ ⟶ ℝ une application. Montrer qu’on a 𝑓 ∈ o(1) si et seulement si lim 𝑓(𝑛) = 0.
𝑛→+∞
Exercice 1.3.7
𝑛
Soit 𝑓 ∶ ℕ ⟶ ℝ une application telle que 𝑓 ∈ O(𝑛) et soit 𝑔 ∶ ℕ ⟶ ℝ définie par 𝑔(𝑛) = ∑ 𝑓(𝑖)2 .
𝑖=0
Montrer que 𝑔 ∈ O(𝑛3 ).
𝑛
𝑛(𝑛 + 1)(2𝑛 + 1)
Indication : Démontrer l’égalité ∑ 𝑖2 = , puis imiter la preuve de la Proposition 1.2.5.
𝑖=1
6
Exercice 1.3.8
𝑛
Soit 𝑓 ∶ ℕ ⟶ ℝ une application telle que 𝑓 ∈ O(𝑛) et soit 𝑔 ∶ ℕ ⟶ ℝ définie par 𝑔(𝑛) = ∏ 𝑓(𝑖).
𝑖=0
Montrer qu’il existe un réel 𝑐 > 0 tel que 𝑔 ∈ O(𝑐𝑛 𝑛!).

2 Entiers
Dans ce chapitre, nous étudierons les entiers multiprécision, implémentation des entiers permettant de repré-
senter des entiers arbitrairement grands. Nous étudierons ensuite la complexité des algorithmes élémentaires,
comme l’addition et la multiplication. La référence principale pour toute cette section est le livre de D. Knuth
KNUTH 1997b, qui demeure, après toutes ces décennies, une excellente introduction au sujet.
2.1 Entiers multiprécision

Pour désigner les éléments de ℕ, après avoir défini 0 et 1 on définit 2 = 1 + 1, 3 = 2 + 1... Mais il est clair
qu’on ne peut pas donner un nom individuel à chaque entier positif. Une solution consiste à employer un
système de numération positionnelle utilisant une base. Ainsi, on s’arrête à 9 + 1 qu’on utilise comme base,
ce qui donne 9 + 1 = 10, 10 + 1 = 11, 11 + 1 = 12, etc.
Cela permet de représenter n’importe quel élément de ℕ avec seulement les chiffres 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.
Par exemple, dans la base 𝛽 = 9 + 1 on a 𝛽 = 10(𝛽 et 7059(𝛽 = 7 ⋅ 𝛽 3 + 0 ⋅ 𝛽 2 + 5 ⋅ 𝛽 1 + 9 ⋅ 𝛽 0 , qu’on écrit
couramment 7059(10 = 7 ⋅ 103 + 0 ⋅ 102 + 5 ⋅ 101 + 9 ⋅ 100 .
De plus, en connaissant les résultats des opérations de base sur ces chiffres (4 + 9 = 13(10 , 8 ⋅ 7 = 56(10 , etc.),
on peut faire ces opérations sur des nombres plus grands.
Le principe des entiers multiprécision est le même, à plus grande échelle : la base 𝛽 = 10 est remplacée par
une base 𝛽 que l’ordinateur peut traiter rapidement et les chiffres de 0 à 9 sont remplacés par les « entiers
machine » de 0 à 𝛽 − 1. Par exemple, les processeurs actuels utilisent des entiers machine de 64 bits. Pour
des raisons techniques, la base utilisée par un langage de programmation est généralement une puissance
de 2. On considèrera toujours que les opérations élémentaires s’effectuent sur des entiers machine en temps
constant, ou O(1) ; on ne s’intéressera pas dans ce cours à la façon dont les opérations sont traitées sur les
entiers machine.
Théorème 2.1.1 (Écriture en base 𝛽)
Soit 𝛽 ∈ ℕ, 𝛽 ⩾ 2. Alors tout 𝑛 ∈ ℤ∗ s’écrit de façon unique comme
ℓ−1
𝑛 = (−1)𝜎 ∑ 𝑛𝑖 𝛽 𝑖 avec 𝜎 ∈ {0, 1}, ℓ ∈ ℕ∗ , 𝑛𝑖 ∈ J0, 𝛽 − 1K, 𝑛ℓ−1 ≠ 0.
𝑖=0
On utilisera toujours implicitement l’existence et l’unicité de la représentation d’un entier dans une base
𝛽 ⩾ 2 quelconque.
Pour le reste de ce chapitre, on fixe une base 𝛽 ⩾ 2.
Définition 2.1.2 Un entier multiprécision est une suite finie
𝒏 = (𝜎, 𝑚0 , … , 𝑚𝐿−1 ) où 𝜎 ∈ {0, 1}, 𝐿 ∈ ℕ, 𝑚𝑖 ∈ J0, 𝛽 − 1K.
𝐿−1
Alors 𝒏 représente l’entier (−1)𝜎 ∑ 𝑚𝑖 𝛽 𝑖 .
𝑖=0
Réciproquement, tout élément de ℤ peut être représenté par une suite finie comme dans la définition.
Attention : On ne demande pas 𝑚𝐿−1 ≠ 0, ce qui fait qu’un élément de ℤ est représenté par une infinité d’en-
tiers multiprécision : en effet, (𝜎, 𝑚0 , … , 𝑚ℓ−1 ) et (𝜎, 𝑚0 , … , 𝑚ℓ−1 , 0, … , 0) correspondent au même élément
de ℤ. Cela n’est pas grave, car il suffit de supprimer les 0 en fin de suite pour retrouver l’unique écriture en
base 𝛽 (on est en train de dire que 7059(10 = 0007059(10 ).
On définit la longueur de 𝒏 = (𝜎, 𝑚0 , … , 𝑚𝐿−1 ) par 𝜆(𝒏) = max({0} ∪ { 𝑖 + 1 ∣ 𝑚𝑖 ≠ 0 }).
ℓ−1
Si l’écriture en base 𝛽 de 𝑛 ∈ ℤ∗ est 𝑛 = (−1)𝜎 ∑ 𝑛𝑖 𝛽 𝑖 , alors la représentation la plus courte de 𝑛 est
𝑖=0
𝒏 = (𝜎, 𝑛0 , … , 𝑛ℓ−1 ) et 𝜆(𝑛) = ℓ. Pour toute autre représentation 𝒏 = (𝜎, 𝑚0 , … , 𝑚𝐿−1 ) on aura 𝜆(𝑛) ⩽ 𝐿.
Dans la suite on identifiera 𝑛 ∈ ℤ et ses représentations 𝒏 = (𝜎, 𝑚0 , … , 𝑚𝐿−1 ).

Le cas 𝑛 = 0 : En prenant 𝐿 = 0, on a la somme vide qui vaut 0, donc 0 ∈ ℤ est représenté par l’entier
multiprécision (0) (ou aussi (1), qui correspond à −0), et sa longueur est 𝜆(0) = 0.
Remarque 2.1.3
Dans un ordinateur, un entier multiprécision peut être encodé par une liste
[𝜎, 𝐿, 𝑚0 , … , 𝑚𝐿−1 ]
(on ne prend pas [𝜎, 𝑚0 , … , 𝑚𝐿−1 ] pour beaucoup de raisons).
Comme 𝜎 ne prend qu’un bit, on peut grouper 𝜎 et 𝐿 en un seul mot machine. Dans un processeur à 64 bits
(avec des mots machine à 64 bits, base 𝛽 = 264 ), cela laisse 63 bits pour 𝐿, qui sera limité à 263 − 1, et le
plus grand entier représentable sera
263 −2
63
∑ (264 − 1)264𝑖 = 264(2 −1)
− 1.
𝑖=0
Dans le cas du langage Python 3 on a 𝛽 = 230 ou 𝛽 = 215 , et l’encodage est la liste
[𝑠 ⋅ 𝐿, 𝑚0 , … , 𝑚𝐿−1 ]
où 𝑠 = (−1) est le signe. Mais 𝑠 ⋅ 𝐿 n’est pas borné (c’est un entier multiprécision à son tour), donc la
𝜎
seule limite est celle de la mémoire disponible (pour l’espace ; côté temps elle sera celle de la patience de
l’utilisateur…).
Pour représenter 𝑛 = 0 de façon unique on prend 𝜎 = 0 et 𝐿 = 0, son encodage est donc la liste [0].
Exercice 2.1.4
On travaille en base 𝛽 ⩾ 2. Soit 𝑛 ≠ 0 un entier. Montrer que 𝜆(𝑛) = 1 + ⌊log𝛽 |𝑛|⌋.
Remarque 2.1.5
Quand on a 2 entiers multiprécision 𝒙 = (𝜎, 𝑥0 , … , 𝑥𝑚−1 ) et 𝒚 = (𝜎′ , 𝑦0 , … , 𝑦𝑛−1 ), on pourra toujours
supposer 𝑚 = 𝑛, quite à rajouter des 0 à gauche, c’est-à-dire, des 0 à la fin de la suite (comme indiqué, on
n’aura pas l’écriture unique, mais ce n’est pas grave).
Remarque 2.1.6
Ne pas oublier que les entiers machine en base 𝛽 sont des entiers positifs ou nuls (ceux de l’intervalle
J0, 𝛽 − 1K).
2.2 Algorithme
Définition informelle : Un algorithme applique à des données qu’on lui donne (Entrées) une suite finie et
non ambiguë d’instructions et d’opérations, et fournit une série de données (Sortie) censée répondre à une
question.
Il ressemble à une recette de cuisine : On prend des ingrédients (Entrées), on les manipule d’une certaine
façon, et l’on obtient une tarte au citron (Sortie).
Définition : Un algorithme est correct si :
1) Toutes les opérations qu’il effectue se font sans erreur.
2) Il s’arrête au bout d’un temps fini.
3) Il fournit le résultat annoncé.
2.3 Addition
La première opération élémentaire que nous étudierons est l’addition d’entiers multiprécision. Rappelons
qu’on considère que la somme de 2 entiers machine se fait en temps constant, ou O(1).
L’algorithme que nous allons présenter est exactement celui qu’on nous apprend à l’école pour additionner
des entiers ; la seule différence sera la base d’expression des entiers, qui sera 𝛽 au lieu de 10.

Dans le processeur, on dispose de la fonction ADD pour additionner 2 entiers machine 𝑎 et 𝑏 :
(𝑐, 𝜌′ ) ← ADD(𝑎, 𝑏, 𝜌)
où 𝑎 + 𝑏 + 𝜌 = 𝑐 + 𝜌′ 𝛽 avec 𝜌, 𝜌′ ∈ {0, 1} (ce sont les retenues, ancienne et nouvelle). Remarquer que 𝑐 est
un entier machine même si 𝑎 + 𝑏 + 𝜌 ⩾ 𝛽.
Algorithme 2.3.1 (Addition de 2 entiers multiprécision positifs ou nuls)

INPUT : Deux entiers multiprécision positifs ou nuls 𝒙 = (0, 𝑥0 , … , 𝑥𝑛−1 ) et 𝒚 = (0, 𝑦0 , … , 𝑦𝑛−1 ).
OUTPUT : Un entier multiprécision 𝒔 = (0, 𝑠0 , … , 𝑠𝑛 ) tel que 𝒔 = 𝒙 + 𝒚.
BEGIN
1 : 𝜌0 ← 0
2 : FOR 𝑖 FROM 0 TO 𝑛 − 1 DO
3: (𝑠𝑖 , 𝜌𝑖+1 ) ← ADD(𝑥𝑖 , 𝑦𝑖 , 𝜌𝑖 )
4 : END FOR
5 : 𝑠𝑛 ← 𝜌 𝑛
6 : 𝒔 ← (0, 𝑠0 , … , 𝑠𝑛 )
7 : RETURN 𝒔
END
Proposition 2.3.2
L’algorithme 2.3.1 est correct (sauf débordement longueur).
Il calcule la somme de deux entiers multiprécision positifs ou nuls 𝑥 et 𝑦 de longueur ⩽ 𝑛 avec un coût en
temps inférieur ou égal à 𝑛 ADD.
DÉMONSTRATION.
Correct : Tous les ADD s’exécutent sans erreur car pour tout 𝑖 on a 𝑥𝑖 , 𝑦𝑖 ∈ J0, 𝛽 − 1K et 𝜌𝑖 ∈ {0, 1}.
En revanche, il peut y avoir un problème au moment de créer 𝒔. En effet, si 𝑛 atteint la longueur maximale
possible, il y aura un débordement (“overflow”). On pourrait par exemple rajouter un test :
BEGIN
[...]
FOR 𝑖 FROM 0 TO 𝑛 − 1 DO
[...]
END FOR
IF 𝑛 = 𝜆max THEN
IF 𝜌𝑛 = 1 THEN
ERROR
ELSE
𝒔 ← (0, 𝑠0 , … , 𝑠𝑛−1 )
END IF
ELSE
𝑠𝑛 ← 𝜌 𝑛
𝒔 ← (0, 𝑠0 , … , 𝑠𝑛 )
END IF
RETURN 𝒔
END
Une autre technique est celle des trappes (par exemple, dans Python 3 on a try: ... except ...:).
L’algorithme s’arrête car la boucle se fait 𝑛 fois.
Voyons qu’il fournit le résultat annoncé. On a 𝜌0 = 0 et ∀ 𝑖 ∈ J0, 𝑛 − 1K, 𝑠𝑖 + 𝜌𝑖+1 𝛽 = 𝑥𝑖 + 𝑦𝑖 + 𝜌𝑖 , d’où
𝑛−1 𝑛−1
𝑥 + 𝑦 = ∑(𝑥𝑖 + 𝑦𝑖 )𝛽 𝑖 = ∑(𝑠𝑖 + 𝜌𝑖+1 𝛽 − 𝜌𝑖 )𝛽 𝑖
𝑖=0 𝑖=0
𝑛−1 𝑛−1 𝑛
= −𝜌0 + ∑ 𝑠𝑖 𝛽 𝑖 + 𝜌𝑛 𝛽 𝑛 = −0 + ∑ 𝑠𝑖 𝛽 𝑖 + 𝑠𝑛 𝛽 𝑛 = ∑ 𝑠𝑖 𝛽 𝑖
𝑖=0 𝑖=0 𝑖=0
=𝑠

Coût :
La seule opération coûteuse est ADD. En effet, les affectations et la boucle prennent un temps négligeable.
Et 𝒔 s’obtient comme une liste d’éléments connus (ce n’est pas une vraie somme).
Par conséquent, le coût en temps de cet algorithme est celui de 𝑛 fois la durée d’une opération ADD.
Comme celle-ci prend un temps constant 𝑘, on trouve un coût de 𝑘𝑛 ∈ O(𝑛) (coût linéaire en la longueur
des entrées).
Pour le coût en mémoire : 𝒙 et 𝒚 prennent 𝑛 mots machine chacun, 𝒔 prend 𝑛 + 1 mots machine, la retenue
prend 1 mot machine, ce qui donne 3𝑛 + 4 ∈ O(𝑛) mots machine (coût linéaire en la longueur des entrées).
Exercice 2.3.3
Dans le processeur, on dispose de la fonction SUB pour soustraire 2 entiers machine 𝑎 et 𝑏 :
(𝑐, 𝜌′ ) ← SUB(𝑎, 𝑏, 𝜌)
où 𝑎 − 𝑏 − 𝜌 = 𝑐 − 𝜌′ 𝛽 avec 𝜌, 𝜌′ ∈ {0, 1} (ce sont les retenues, ancienne et nouvelle). Remarquer que 𝑐 est
un entier machine même si 𝑎 − 𝑏 − 𝜌 < 0.
Écrire un algorithme calculant la différence 𝒙 − 𝒚 de deux entiers multiprécision de longueur ⩽ 𝑛 avec
𝒙 > 𝒚 ⩾ 0 en temps O(𝑛).
2.4 Multiplication
2.4.1 Algorithme naïf
Commençons par étudier l’algorithme de multiplication qu’on apprend à l’école. Rappelons qu’on considère
l’addition et la multiplication d’entiers machine comme des opérations élémentaires effectuées en temps
constant.
Dans le processeur, on dispose de la fonction MUL pour multiplier 2 entiers machine 𝑎 et 𝑏 :
(𝑐0 , 𝑐1 ) ← MUL(𝑎, 𝑏)
où 𝑎 ⋅ 𝑏 = 𝑐0 + 𝑐1 𝛽 avec 𝑐0 , 𝑐1 des entiers machine.
On regarde d’abord le produit d’un entier machine par un entier multiprécision (algorithme 2.4.1).
Algorithme 2.4.1 (Multiplication d’un entier machine par un entier multiprécision ⩾ 0)

INPUT : Un entier machine 𝑎 et un entier multiprécision positif ou nul 𝒙 = (0, 𝑥0 , … , 𝑥𝑛−1 ).
OUTPUT : Un entier multiprécision 𝒑 = (0, 𝑝0 , … , 𝑝𝑛 ) tel que 𝒑 = 𝑎 ⋅ 𝒙.
BEGIN
1 : (𝑝0 , 𝑑0′ ) ← MUL(𝑎, 𝑥0 )
3: (𝑐𝑖 , 𝑑𝑖 ) ← MUL(𝑎, 𝑥𝑖 )
4: (𝑝𝑖 , 𝜌𝑖 ) ← ADD(𝑐𝑖 , 𝑑𝑖−1
′
, 0)
5: (𝑑𝑖 , 0) ← ADD(𝑑𝑖 , 0, 𝜌𝑖 )
′
6 : END FOR
7 : 𝑝𝑛 ← 𝑑𝑛−1 ′
8 : 𝒑 ← (0, 𝑝0 , … , 𝑝𝑛 )
9 : RETURN 𝒑
END
Proposition 2.4.2
Il calcule le produit d’un entier machine par un entier multiprécision positif ou nul de longueur ⩽ 𝑛 avec un
coût inférieur ou égal à 𝑛 MUL et (2𝑛 − 2) ADD.
DÉMONSTRATION. Exercice.
Il peut y avoir un débordement de la longueur au moment de créer 𝒑.

Remarquer que 𝜌𝑖 ∈ {0, 1} et que 𝑑𝑖 ∈ J0, 𝛽 − 2K, donc 𝑑𝑖 + 𝜌𝑖 donne un entier machine sans retenue.
Maintenant le cas général (algorithme 2.4.3).
Algorithme 2.4.3 (Multiplication naïve de 2 entiers multiprécision positifs ou nuls)

INPUT : Deux entiers multiprécision positifs ou nuls 𝒙 = (0, 𝑥0 , … , 𝑥𝑚−1 ) et 𝒚 = (0, 𝑦0 , … , 𝑦𝑛−1 ).
OUTPUT : Un entier multiprécision 𝒑 = (0, 𝑝0 , … , 𝑝𝑚+𝑛−1 ) tel que 𝒑 = 𝒙 ⋅ 𝒚.
BEGIN
1: 𝒘 ←0
0
2 : FOR 𝑖 FROM 0 TO 𝑚 − 1 DO
3: 𝒛𝑖 ← 𝑥 𝑖 ⋅ 𝒚 ▷ algorithme 2.4.1
4: 𝒔𝑖 ← 𝒘 𝑖 + 𝒛 𝑖 ▷ algorithme 2.3.1
5: 𝑝𝑖 + 𝒘𝑖+1 𝛽 ← 𝒔𝑖
6 : END FOR
7 : 𝒑 ← (0, 𝑝0 , … , 𝑝𝑚−1 ) + 𝒘 𝛽 𝑚
𝑚
8 : RETURN 𝒑
END
Proposition 2.4.4
Il calcule le produit de deux entiers multiprécision positifs ou nuls de longueurs 𝑚 et 𝑛 avec un coût inférieur
ou égal à 𝑚𝑛 MUL et (3𝑚𝑛 − 2𝑚 − 𝑛) ADD.
DÉMONSTRATION.
Correct :
1) Les opérations se font sans erreur : Il peut y avoir des débordements de la longueur maximale dans
• 𝑥𝑖 ⋅ 𝒚
• 𝒘𝑖 + 𝒛𝑖
• 𝒘𝑚 𝛽 𝑚
On suppose donc que cela n’arrive pas ou que c’est géré.
2) L’algorithme s’arrête : C’est clair (boucle finie).
3) L’algorithme fournit le résultat annoncé :
On a 𝑤0 = 0 et ∀ 𝑖 ∈ J0, 𝑚 − 1K, 𝑥𝑖 ⋅ 𝒚 = 𝒛𝑖 = 𝒔𝑖 − 𝒘𝑖 = 𝑝𝑖 + 𝒘𝑖+1 𝛽 − 𝒘𝑖 donc
𝑚−1 𝑚−1 𝑚−1
𝑥 ⋅ 𝑦 = ∑ 𝑥𝑖 𝛽 𝑖 𝒚 = ∑ (𝑝𝑖 + 𝒘𝑖+1 𝛽 − 𝒘𝑖 ) 𝛽 𝑖 = ∑ 𝑝𝑖 𝛽 𝑖 + 𝒘𝑚 𝛽 𝑚 − 𝒘0 = 𝑝
𝑖=0 𝑖=0 𝑖=0
Coût :
Chaque produit 𝑥𝑖 ⋅ 𝒚 coûte 𝑛 MUL et (2𝑛 − 2) ADD.
Il y en a 𝑚, ce qui donne 𝑚𝑛 MUL et 𝑚(2𝑛 − 2) ADD.
D’autre part, les 𝒘𝑖 et 𝒛𝑖 sont de longueur ⩽ 𝑛, donc chaque somme 𝒘𝑖 + 𝒛𝑖 coûte au plus 𝑛 ADD.
Comme 𝑤0 = 0, on peut éviter la première somme, il y en a alors 𝑚 − 1, ce qui fait (𝑚 − 1)𝑛 ADD.
Le calcul de 𝑝𝑖 et 𝒘𝑖+1 a un coût négligeable : si 𝒔𝑖 = (0, 𝑚0 , … , 𝑚𝐿 ), on a 𝑝𝑖 = 𝑚0 et 𝒘𝑖 = (0, 𝑚1 , … , 𝑚𝐿 ).
Pour trouver 𝒑 le coût est aussi négligeable : si 𝒘𝑚 = (0, 𝑚0 , … , 𝑚𝐿 ), alors 𝒑 = (0, 𝑝0 , … , 𝑝𝑚−1 , 𝑚0 , … , 𝑚𝐿 ).
Au total, on a au plus 𝑚𝑛 MUL et (3𝑚𝑛 − 2𝑚 − 𝑛) ADD.
On a donc un coût en temps qui est dans O(𝑚𝑛).

On remarque aussi le manque de symétrie : si 𝜆(𝑥) < 𝜆(𝑦), on a intérêt à échanger 𝑥 et 𝑦.
Si 𝜆(𝑥) = 𝜆(𝑦) = 𝑛, le coût est O(𝑛2 ), qui est un coût quadratique en la longueur.
Remarque 2.4.5
Un algorithme encore plus naïf pour calculer 𝑥 ⋅ 𝑦 serait de faire la somme de 𝑥 avec lui-même 𝑦 fois
(algorithme 2.4.6).

Algorithme 2.4.6 (Multiplication coûteuse de 2 entiers multiprécision positifs ou nuls)
INPUT : Deux entiers multiprécision 𝒙, 𝒚 positifs ou nuls
OUTPUT : Un entier multiprécision 𝒑 tel que 𝒑 = 𝒙 ⋅ 𝒚.
BEGIN
1: 𝒑←0
2 : FOR 𝒊 FROM 1 TO 𝒚 DO
3: 𝒑←𝒑+𝒚
4 : END FOR
5 : RETURN 𝒑
END
Si 𝑥 et 𝑦 sont de longueur 𝑛, ceci revient à appliquer 𝑦 fois l’algorithme d’addition de la Proposition 2.3.2 à
des entiers de longueur au plus 2𝑛 + 1. Ceci se fait donc en temps O(𝑦) ; comme 𝛽 𝑛−1 ⩽ 𝑦 < 𝛽 𝑛 , on a que
O(𝑦) = O(𝛽 𝑛 ) (voir Exercice 2.4.7).
Comme 𝛽 > 1, cette méthode prend donc un temps exponentiel en 𝑛, ce qui est beaucoup moins efficace
que le temps quadratique en O(𝑛2 ) de la Proposition 2.4.4.
Exercice 2.4.7
Soit 𝛼 > 0 un nombre réel, et soit 𝑓 ∶ ℕ ⟶ ℝ une fonction telle que 𝛽 𝑛−1 ⩽ 𝑓(𝑛) < 𝛽 𝑛 pour tout 𝑛 ∈ ℕ.
Montrer que O(𝑓) = O(𝛽 𝑛 ) (ou, de façon équivalente, que 𝑓 ∈ Θ(𝛽 𝑛 )).
2.4.2 Algorithme de Karatsuba

L’algorithme naïf de multiplication de la Proposition 2.4.4 peut être grandement amélioré par une astuce à
la portée d’un élève de 5e .
Voyons d’abord un aperçu de la stratégie.
Soient 𝑥 et 𝑦 des entiers positifs ou nuls, et soit 𝑛 pair tel que 𝜆(𝑥), 𝜆(𝑦) ⩽ 𝑛 (on rajoutera donc des 0 à
gauche si nécessaire). On écrit 𝑛 = 2𝑚.
On peut alors regrouper l’écriture en base 𝛽 de 𝑥 en deux paquets :
𝑥 = (𝑥0 + 𝑥1 𝛽 + ⋯ + 𝑥𝑚−1 𝛽 𝑚−1 ) + (𝑥𝑚 𝛽 𝑚 + ⋯ + 𝑥2𝑚−1 𝛽 2𝑚−1 )
= (𝑥0 + 𝑥1 𝛽 + ⋯ + 𝑥𝑚−1 𝛽 𝑚−1 ) + (𝑥𝑚 + ⋯ + 𝑥2𝑚−1 𝛽 𝑚−1 )𝛽 𝑚
= 𝑎 0 + 𝑎1 𝛽 𝑚 ,
où 𝑎0 , 𝑎1 sont des entiers de longueur ⩽ 𝑚. De même, on écrit 𝑦 = 𝑏0 + 𝑏1 𝛽 𝑚 , où 𝑏0 , 𝑏1 sont des entiers de
longueur ⩽ 𝑚. Alors
𝑥𝑦 = (𝑎0 + 𝑎1 𝛽 𝑚 )(𝑏0 + 𝑏1 𝛽 𝑚 )
= (𝑎0 𝑏0 ) + (𝑎0 𝑏1 + 𝑎1 𝑏0 )𝛽 𝑚 + (𝑎1 𝑏1 )𝛽 2𝑚 .
Ceci nécessite le calcul de quatre produits d’entiers de longueur 𝑚 (à savoir les produits 𝑎0 𝑏0 , 𝑎0 𝑏1 , 𝑎1 𝑏0 et
𝑎1 𝑏1 ), puis d’une somme (dont le coût en temps est négligeable par rapport aux produits).
Idée : calculer plutôt (𝑎0 + 𝑎1 )(𝑏0 + 𝑏1 ). Ceci ne nécessite que deux sommes (coût négligeable par rapport
au produit) et un seul produit. De plus,
(𝑎0 + 𝑎1 )(𝑏0 + 𝑏1 ) = 𝑎0 𝑏0 + (𝑎0 𝑏1 + 𝑎1 𝑏0 ) + 𝑎1 𝑏1
d’où
𝑎0 𝑏1 + 𝑎1 𝑏0 = (𝑎0 + 𝑎1 )(𝑏0 + 𝑏1 ) − 𝑎0 𝑏0 − 𝑎1 𝑏1 .
Par conséquent, si l’on calcule 𝑎0 𝑏0 , 𝑎1 𝑏1 et (𝑎0 + 𝑎1 )(𝑏0 + 𝑏1 ) (pour un total de deux sommes et trois
produits), on retrouve 𝑎0 𝑏1 + 𝑎1 𝑏0 (en effectuant deux soustractions), et l’on en déduit donc 𝑥𝑦. Le coût
des sommes et de la soustraction étant négligeable par rapport à celui des produits, on a pu calculer 𝑥𝑦
en faisant seulement trois produits d’entiers de longueur 𝑚, alors qu’il en fallait quatre dans le paragraphe
précédent. (Il faut faire un peu attention : les entiers 𝑎0 + 𝑎1 et 𝑏0 + 𝑏1 peuvent être de longueur 𝑚 + 1 ; on
traitera ce cas avec soin plus tard.)

L’algorithme de Karatsuba 1 exploite cette idée de façon récursive : Pour calculer 𝑎0 ⋅ 𝑏0 , on coupe 𝑎0 et 𝑏0
en 2, et l’on applique la même astuce, etc. (de même pour 𝑎1 ⋅ 𝑏1 et (𝑎0 + 𝑎1 ) ⋅ (𝑏0 + 𝑏1 )). Cela nécessite que
𝑛 soit une puissance de 2.
Remarque : Ceci est un exemple d’algorithme récursif, car il s’appelle lui-même. La preuve qu’il s’arrête
sera donc adaptée à cette situation.
Algorithme 2.4.8 (Karatsuba(𝑘, 𝑥, 𝑦))
INPUT : 𝑘 ∈ ℕ et 2 entiers multiprécision ⩾ 0 : 𝑥 = (0, 𝑥0 , … , 𝑥𝑛−1 ) et 𝑦 = (0, 𝑦0 , … , 𝑦𝑛−1 ) avec 𝑛 = 2𝑘 .

OUTPUT : Un entier multiprécision 𝑝 = (0, 𝑝0 , … , 𝑝2𝑛−1 ) tel que 𝑝 = 𝑥 ⋅ 𝑦.
BEGIN
1 : IF 𝑘 = 0 THEN
2: 𝑝 ← 𝑥 0 ⋅ 𝑦0 ▷ MUL(𝑥0 , 𝑦0 )
3: RETURN 𝑝
4 : END IF
5 : 𝑚 ← 𝑛/2 ▷ 𝑚 = 2𝑘−1
Créer les entiers
6 : 𝑎0 ← (0, 𝑥0 , … , 𝑥𝑚−1 ) ▷ 𝑎0 = 𝑥0 + ⋯ + 𝑥𝑚−1 𝛽 𝑚−1 , 𝜆(𝑎0 ) ⩽ 𝑚
7 : 𝑎1 ← (0, 𝑥𝑚 , … , 𝑥2𝑚−1 ) ▷ 𝑎1 = 𝑥𝑚 + ⋯ + 𝑥2𝑚−1 𝛽 𝑚−1 , 𝜆(𝑎1 ) ⩽ 𝑚
8 : 𝑏0 ← (0, 𝑦0 , … , 𝑦𝑚−1 ) ▷ 𝑏0 = 𝑦0 + ⋯ + 𝑦𝑚−1 𝛽 𝑚−1 , 𝜆(𝑏0 ) ⩽ 𝑚
9 : 𝑏1 ← (0, 𝑦𝑚 , … , 𝑦2𝑚−1 ) ▷ 𝑏1 = 𝑦𝑚 + ⋯ + 𝑦2𝑚−1 𝛽 𝑚−1 , 𝜆(𝑏1 ) ⩽ 𝑚
Effectuer (appels récursifs)
10 : 𝐴 ← Karatsuba(𝑘 − 1, 𝑎0 , 𝑏0 ) ▷ 𝜆(𝐴) ⩽ 2𝑚
11 : 𝐵 ← Karatsuba(𝑘 − 1, 𝑎1 , 𝑏1 ) ▷ 𝜆(𝐵) ⩽ 2𝑚
Calculer et décomposer
12 : 𝑎 + 𝑎′ 𝛽 𝑚 ← 𝑎0 + 𝑎1 ▷ 𝜆(𝑎) ⩽ 𝑚, 𝑎′ ∈ {0, 1}
′ 𝑚
13 : 𝑏 + 𝑏 𝛽 ← 𝑏0 + 𝑏1 ▷ 𝜆(𝑏) ⩽ 𝑚, 𝑏′ ∈ {0, 1}
Effectuer (appel récursif)
14 : 𝐶 ← Karatsuba(𝑘 − 1, 𝑎, 𝑏) ▷ 𝜆(𝐶) ⩽ 2𝑚
Calculer
15 : 𝑑 ← 𝑎 ⋅ 𝑏′ ▷ 𝜆(𝑑) ⩽ 𝑚
16 : 𝑒 ← 𝑎′ ⋅ 𝑏 ▷ 𝜆(𝑒) ⩽ 𝑚
17 : 𝑓 ← 𝑑 + 𝑒 ▷ 𝜆(𝑓) ⩽ 𝑚
18 : 𝑔 ← 𝑓 + 𝐵 ▷ 𝜆(𝑔) ⩽ 2𝑚 + 1
19 : ℎ ← 𝐴 + 𝑔 𝛽 2𝑚
▷ 𝜆(ℎ) ⩽ 4𝑚
20 : 𝑗 ← 𝐶 − 𝐴 − 𝐵 ▷ 𝜆(𝑗) ⩽ 2𝑚 + 1
21 : 𝑟 ← 𝑎′ ⋅ 𝑏′ ▷ 𝑟 ∈ {0, 1}
𝑚
22 : 𝑝 ← ℎ + 𝑗 𝛽 + 𝑟 𝛽 3𝑚
▷ 𝜆(𝑝) ⩽ 4𝑚 + 1
23 : RETURN 𝑝
END
Théorème 2.4.9
L’algorithme 2.4.8 de Karatsuba est correct (sauf débordement longueur).
Il permet de calculer le produit de deux entiers de longueur ⩽ 𝑛 en temps ∈ O(𝑛log2 3 ) (attention : ce 𝑛
majorant la longueur est différent du 𝑛 de l’algorithme, voir démonstration).
DÉMONSTRATION.
Correct :
1) Les opérations se font sans erreur :
On a 𝑛/2 ∈ ℕ car 𝑘 ⩾ 1.
Toutes les autres opérations se font sans erreur, sauf cas de débordement de la longueur. On suppose donc
que cela n’arrive pas ou que c’est géré.
1. L’algorithme doit son nom au mathématicien russe Анато́лий Алексе́евич Карацу́ба, qui l’a découvert en 1960.

2) L’algorithme s’arrête :
Dans les appels récursifs, on a que 𝑘 ∈ ℕ diminue de 1. Comme pour 𝑘 = 0 il n’y a plus d’appel récursif, la
profondeur de cet algorithme récursif est 𝑘 + 1 et il s’arrête.
3) L’algorithme fournit le résultat annoncé : Par récurrence sur 𝑘 ∈ ℕ.
Pour 𝑘 = 0, on a bien Karatsuba(𝑥, 𝑦) = 𝑥 ⋅ 𝑦.
Pour 𝑘 ⩾ 1 on a
𝑥 = 𝑎 0 + 𝑎1 𝛽 𝑚 𝑎𝑏 = 𝐶 𝐶 −𝐴−𝐵=𝑗
𝑦 = 𝑏 0 + 𝑏1 𝛽 𝑚 𝑎𝑏′ = 𝑑 𝑎′ 𝑏 ′ = 𝑟
𝑎 0 𝑏0 = 𝐴 𝑎′ 𝑏 = 𝑒 ℎ + 𝑗 𝛽 𝑚 + 𝑟𝛽 3𝑚 = 𝑝
𝑎 1 𝑏1 = 𝐵 𝑑+𝑒=𝑓
′ 𝑚
𝑎0 + 𝑎 1 = 𝑎 + 𝑎 𝛽 𝑓 +𝐵=𝑔
′ 𝑚
𝑏0 + 𝑏 1 = 𝑏 + 𝑏 𝛽 𝐴 + 𝑔 𝛽 2𝑚 = ℎ
et alors
𝑥𝑦 = (𝑎0 𝑏0 ) + (𝑎0 𝑏1 + 𝑎1 𝑏0 )𝛽 𝑚 + (𝑎1 𝑏1 )𝛽 2𝑚
= 𝐴 + (𝑎0 𝑏1 + 𝑎1 𝑏0 )𝛽 𝑚 + 𝐵 𝛽 2𝑚 .
Or
𝑎0 𝑏1 + 𝑎1 𝑏0 = (𝑎0 + 𝑎1 )(𝑏0 + 𝑏1 ) − 𝑎0 𝑏0 − 𝑎1 𝑏1
= (𝑎 + 𝑎′ 𝛽 𝑚 )(𝑏 + 𝑏′ 𝛽 𝑚 ) − 𝐴 − 𝐵
= 𝑎𝑏 + (𝑎𝑏′ + 𝑎′ 𝑏)𝛽 𝑚 + (𝑎′ 𝑏′ )𝛽 2𝑚 − 𝐴 − 𝐵
= 𝐶 + (𝑑 + 𝑒)𝛽 𝑚 + 𝑟𝛽 2𝑚 − 𝐴 − 𝐵
= 𝑗 + 𝑓 𝛽 𝑚 + 𝑟𝛽 2𝑚
d’où
𝑥𝑦 = 𝐴 + (𝑎0 𝑏1 + 𝑎1 𝑏0 )𝛽 𝑚 + 𝐵 𝛽 2𝑚
= 𝐴 + (𝑗 + 𝑓 𝛽 𝑚 + 𝑟 𝛽 2𝑚 )𝛽 𝑚 + 𝐵 𝛽 2𝑚
= 𝐴 + 𝑗 𝛽 𝑚 + (𝑓 + 𝐵)𝛽 2𝑚 + 𝑟 𝛽 3𝑚
= 𝐴 + 𝑗 𝛽 𝑚 + 𝑔 𝛽 2𝑚 + 𝑟 𝛽 3𝑚
= ℎ + 𝑗 𝛽 𝑚 + 𝑟 𝛽 3𝑚
= 𝑝.
Donc l’algorithme est correct.
Coût :
Soit 𝑇 (𝑘) le nombre d’opérations élémentaires nécessaires pour calculer le produit de deux entiers de longueur
⩽ 𝑛 = 2𝑘 par l’algorithme de Karatsuba.
Il est clair que 𝑇 (0) = 1 (on fait 1 MUL).
Supposons que 𝑘 ⩾ 1, et voyons combien d’opérations élémentaires chaque ligne de l’algorithme nécessite.
Rappel : 𝑚 = 2𝑘−1 .
— La création des entiers multiprécision 𝑎0 , 𝑎1 , 𝑏0 et 𝑏1 ne nécessite aucune opération élémentaire. Cette
étape se fait donc en temps constant, négligeable.
— Le calcul de 𝐴 se fait en temps 𝑇 (𝑘 − 1) ; il en va de même pour 𝐵.
— Le calcul de 𝑎0 + 𝑎1 se fait en temps O(𝑚). Il en va de même pour 𝑏0 + 𝑏1 .
— Le calcul de 𝐶 se fait en temps 𝑇 (𝑘 − 1).
— Puisque 𝑎′ et 𝑏′ valent 0 ou 1, le calcul de 𝑑, 𝑒 et 𝑟 se fait en temps négligeable.
— 𝑓 est la somme de 2 entiers de longueur ⩽ 𝑚, coût O(𝑚).
— 𝑔 et 𝑗 sont somme de 2 entiers de longueur ⩽ 2𝑚, coût O(𝑚).
— ℎ n’est qu’une simple concaténation (aucun calcul).
— Pour le calcul final de 𝑝 : notons que la multiplication par une puissance de 𝛽 se fait en temps négligeable
(rajout de zéros à droite, simple décalage). Il suffit donc de faire 3 sommes d’entiers de longueur ⩽ 4𝑚,
une opération qui se fait en temps O(𝑚).
En prenant la somme de ces complexités, on obtient que 𝑇 (𝑘) ∈ 3𝑇 (𝑘 − 1) + O(2𝑘−1 ).

Lemme 2.4.10
Soit 𝑇 ∶ ℕ ⟶ ℝ une application telle que 𝑇 (𝑘) ∈ 3𝑇 (𝑘 − 1) + O(2𝑘−1 ). Alors 𝑇 (𝑘) ∈ O(3𝑘 ).
𝑇 (𝑘)
DÉMONSTRATION. D’après la Proposition 1.2.2, il suffit d’avoir lim < +∞. Par hypothèse, il existe
𝑘→+∞ 3𝑘
𝑐 > 0 et 𝑘0 > 0 tels que pour 𝑘 ⩾ 𝑘0 on a 𝑇 (𝑘) ⩽ 3𝑇 (𝑘 − 1) + 𝑐2𝑘−1 . Divisant par 3𝑘 , on obtient
𝑇 (𝑘) 𝑇 (𝑘 − 1) 𝑐 2 𝑘−1
∀ 𝑘 ⩾ 𝑘0 , − ⩽ ( )
3𝑘 3𝑘−1 3 3
donc pour 𝑚 ⩾ 𝑘0 on a
𝑚 𝑚
𝑇 (𝑚) 𝑇 (𝑘0 − 1) 𝑇 (𝑘) 𝑇 (𝑘 − 1) 𝑐 2 𝑘−1
− = ∑ ( − ) ⩽ ∑ ( )
3𝑚 3𝑘0 −1 𝑘=𝑘
3𝑘 3𝑘−1 𝑘=𝑘
3 3
0 0
(somme téléscopique). Pour 𝑚 → +∞ on a alors

+∞
𝑇 (𝑚) 𝑇 (𝑘0 − 1) 𝑐 2 𝑘−1
( lim ) − ⩽ ∑ ( ) < +∞
𝑚→+∞ 3𝑚 3𝑘0 −1 3 𝑘=𝑘 3
0
car à droite on a la somme d’une série géométrique de raison avec ∣ 23 ∣ < 1.

2
3
𝑇 (𝑚)
Cela implique lim < +∞, ce qui donne 𝑇 (𝑘) ∈ O(3𝑘 ).
𝑚→+∞ 3𝑚
On complète maintenant la preuve du Théorème 2.4.9.

D’après le Lemme 2.4.10, on a que 𝑇 (𝑘) ∈ O(3𝑘 ).
Soit maintenant 𝑆(𝑛) le nombre d’opérations élémentaires nécessaires pour calculer le produit de deux entiers
de longueur ⩽ 𝑛 par l’algorithme de Karatsuba (on ne suppose plus que 𝑛 est une puissance de 2).
Soit 𝑛
̃ ∈ ℕ le plus petit possible tel que 𝑛
̃ = 2𝑘 et 𝑛 ⩽ 𝑛
̃ , c’est-à-dire, 𝑘 = ⌈log2 (𝑛)⌉.
Alors on a 𝑥 = (0, 𝑥0 , … , 𝑥𝑛̃ −1 ) et 𝑦 = (0, 𝑦0 , … , 𝑦𝑛̃ −1 ) avec 𝑛
̃ = 2𝑘 , 𝑘 ∈ ℕ.
En y appliquant Karatsuba, on trouve 𝑆(𝑛) = 𝑇 (𝑘) ∈ O(3𝑘 ). Or
3𝑘 = 3⌈log2 (𝑛)⌉ = 3 ⋅ 3⌈log2 (𝑛)⌉−1
⩽ 3 ⋅ 3log2 (𝑛) = 3 ⋅ 2log2 (3) log2 (𝑛) = 3𝑛log2 (3)
donc 𝑆(𝑛) ∈ O(𝑛log2 (3) ) comme voulu.
Remarque 2.4.11
Comme log2 (3) = 1,58496+ < 2, l’algorithme de Karatsuba a une complexité bien moindre que l’algorithme
naïf de multiplication d’entiers.
2.5 Exponentiation
Étant donné un entier 𝑎 et un entier 𝑘 ⩾ 0, un premier algorithme naïf pour calculer 𝑎𝑘 serait de multiplier
𝑎 avec lui-même 𝑘 fois (algorithme 2.5.1).
Algorithme 2.5.1 (Exponentiation naïve)

INPUT : Deux entiers 𝑎, 𝑘 avec 𝑘 ⩾ 0.
OUTPUT : L’entier 𝑝 = 𝑎𝑘 .
BEGIN
1: 𝑝←1
2 : FOR 𝑖 FROM 1 TO 𝑘 DO
3: 𝑝 ←𝑎⋅𝑝
4 : END FOR
5 : RETURN 𝑝
END

Exercice 2.5.2
Soit 𝑎 un entier de longueur 𝑛. On considère que 𝑛 est fixé. Montrer que le calcul de 𝑎𝑘 par l’algorithme 2.5.1
se fait en temps O(𝑘2 ). Indication : Faire le produit de 𝑘 entiers de longueur bornée par 𝑘𝑛.
On peut faire beaucoup mieux. Pour l’illustrer, calculons 𝑎8 de la façon suivante :
𝑎8 = 𝑎 4 ⋅ 𝑎 4
= (𝑎2 ⋅ 𝑎2 ) ⋅ (𝑎2 ⋅ 𝑎2 )
= ((𝑎 ⋅ 𝑎) ⋅ (𝑎 ⋅ 𝑎)) ⋅ ((𝑎 ⋅ 𝑎) ⋅ (𝑎 ⋅ 𝑎)).
Il suffit donc de calculer 𝑎 = 𝑎 ⋅ 𝑎, puis 𝑎4 = 𝑎2 ⋅ 𝑎2 , et enfin 𝑎8 = 𝑎4 ⋅ 𝑎4 , ce qui ne nécessite que trois
2
multiplications. Cette méthode se généralise aisément au calcul de 𝑎𝑘 où 𝑘 est une puissance de 2.

Et si 𝑘 n’est pas une puissance de 2 ? Prenons le cas de 𝑎11 .
Il suffit de remarquer que 11 = 8 + 2 + 1 = 23 + 21 + 20 = 1011(2 , ce qui veut dire que 𝑎11 = 𝑎8 ⋅ 𝑎2 ⋅ 𝑎1 . On
calcule ensuite 𝑎2 , 𝑎4 et 𝑎8 comme précédemment, ce qui ne demande que 3 multiplications, puis on prend le
produit 𝑎8 ⋅ 𝑎2 ⋅ 𝑎, pour 2 multiplications supplémentaires. On obtient donc 𝑎11 au coût de 5 multiplications
au lieu de 10.
L’exemple précédent montre que le calcul de 𝑎𝑘 dépendra de l’écriture de 𝑘 comme somme de puissances
de 2 ; autrement dit, de son écriture en base 2. L’écriture en base 2 d’un entier se trouve en itérant des
divisions euclidiennes par cette base 2 (algorithme 2.5.3).
Algorithme 2.5.3 (Représentation en base 2 d’un entier)

INPUT : Un entier 𝑘 ⩾ 0
𝑟
OUTPUT : (0) si 𝑘 = 0, et sinon (𝑘0 , … , 𝑘𝑟 ) où 𝑟 ∈ ℕ, 𝑘𝑖 ∈ {0, 1}, 𝑘 = ∑ 𝑘𝑖 2𝑖 et 𝑘𝑟 ≠ 0.
𝑖=0
BEGIN
1 : IF 𝑘 = 0 THEN
2: RETURN (0)
3 : END IF
4: 𝑖←0
5 : WHILE 𝑘 ≠ 0 DO
6: (𝑞, 𝑟) ← (Quo(𝑘, 2), Rem(𝑘, 2)) ▷ quotient et reste de la division de 𝑘 par 2
7: 𝑘𝑖 ← 𝑟
8: 𝑘←𝑞
9: 𝑖←𝑖+1
10 : END WHILE
11 : RETURN (𝑘0 , … , 𝑘𝑖−1 )
END
Exercice 2.5.4
Montrer que l’algorithme 2.5.3 donne bien la représentation en base 2 de 𝑘. Comment adapter l’algorithme
pour qu’il renvoie la représentation en base 𝛽 de 𝑘 ?
Remarque : Les processeurs utilisant comme base de calcul une puissance de 2, le coût de cet algorithme est
négligeable.
Nous pouvons maintenant écrire un algorithme d’exponentiation rapide.
2. La division par 2 s’effectue rapidement par la plupart des ordinateurs, où les entiers sont représentés dans une base qui est
une puissance de 2.

Algorithme 2.5.5 (Exponentiation rapide, “Square & Multiply”)
INPUT : Deux entiers 𝑎, 𝑘 avec 𝑘 ⩾ 0.
OUTPUT : 𝑝 = 𝑎𝑘 .
BEGIN
1: 𝑝←1
2: 𝑏←𝑎
3 : WHILE 𝑘 > 0 DO
4: (𝑞, 𝑟) ← (Quo(𝑘, 2), Rem(𝑘, 2)) ▷ quotient et reste de la division de 𝑘 par 2
5: IF 𝑟 = 1 THEN
6: 𝑝 ←𝑝⋅𝑏
7: END IF
8: 𝑘←𝑞
9: 𝑏 ←𝑏⋅𝑏
10 : END WHILE
11 : RETURN 𝑝
END
Proposition 2.5.6
L’algorithme 2.5.5 d’exponentiation rapide est correct.
Il calcule 𝑎𝑘 en effectuant un nombre de multiplications qui est dans O(log2 (𝑘)).
DÉMONSTRATION. La boucle se répète au plus ⌈log2 (𝑘)⌉ + 1 fois, et il y a au plus deux multiplications à
chaque répétition de la boucle. Le nombre de multiplications est donc O(⌈log2 (𝑘)⌉). Pour 𝑘 ⩾ 2 on a
⌈log2 (𝑘)⌉ < log2 𝑘 + 1 ⩽ 2 log2 𝑘
donc ⌈log2 (𝑘)⌉ ∈ O(log2 (𝑘)), ce qui nous permet de conclure.
Exercice 2.5.7 (▾ )
1. Implémenter en SageMath les algorithmes 2.5.1 et 2.5.5 d’exponentiation naïve et rapide.
2. Comparer les temps d’exécution des deux algorithmes pour calculer 1010 pour 𝑖 allant de 0 à 7. (Utile :
𝑖
ajouter %time devant une commande en SageMath permet d’afficher le temps d’exécution.)
2.6 Division euclidienne

Le théorème suivant sera admis.
Théorème 2.6.1 (division euclidienne dans ℤ)
Pour tous 𝑎, 𝑏 ∈ ℤ avec 𝑏 ≠ 0, il existe un unique (𝑞, 𝑟) ∈ ℤ × ℤ tel que 𝑎 = 𝑏𝑞 + 𝑟 et 𝑟 ∈ J0, |𝑏| − 1K.
Dans les conditions du théorème, on définit Quo(𝑎, 𝑏) = 𝑞 et Rem(𝑎, 𝑏) = 𝑟 et QuoRem(𝑎, 𝑏) = (𝑞, 𝑟).
𝑎 𝑏 𝑟
On écrit aussi
𝑞
Soient 𝑥, 𝑦 ∈ ℕ avec 𝑦 ≠ 0.
La division euclidienne du dividende 𝑥 par le diviseur 𝑦 consiste donc à trouver l’unique quotient 𝑞 et l’unique
reste 𝑟 tels que 𝑥 = 𝑞𝑦 + 𝑟 avec 𝑞, 𝑟 ∈ ℕ et 0 ⩽ 𝑟 < 𝑦.
𝑚−1 𝑛−1
Soient 𝑚 = 𝜆(𝑥) et 𝑛 = 𝜆(𝑦) ⩾ 1. On écrit 𝑥 = ∑ 𝑥𝑖 𝛽 𝑖 et 𝑦 = ∑ 𝑦𝑗 𝛽 𝑗 .
𝑖=0 𝑗=0
Si 𝑚 < 𝑛, alors 𝑞 = Quo(𝑥, 𝑦) = 0 et 𝑟 = Rem(𝑥, 𝑦) = 𝑦.
On suppose donc 𝑚 ⩾ 𝑛.
Lemme 2.6.2
Soient 𝑥, 𝑦 ∈ ℕ∗ deux entiers avec 𝜆(𝑥) ⩾ 𝜆(𝑦) ⩾ 1.
Soit 𝑞 = Quo(𝑥, 𝑦), le quotient de la division euclidienne de 𝑥 par 𝑦.
Alors 𝜆(𝑞) est égal à 𝜆(𝑥) − 𝜆(𝑦) ou à 𝜆(𝑥) − 𝜆(𝑦) + 1.

DÉMONSTRATION. Soient 𝑚 = 𝜆(𝑥), 𝑛 = 𝜆(𝑦). On a 𝛽 𝑚−1 ⩽ 𝑥 ⩽ 𝛽 𝑚 − 1 et 𝛽 𝑛−1 ⩽ 𝑦 ⩽ 𝛽 𝑛 − 1.
𝑥−𝑟
Alors le maximum pour 𝑞 = est atteint pour
𝑦
(𝑥, 𝑦) = (𝛽 𝑚 − 1, 𝛽 𝑛−1 ) qui donne (𝑞, 𝑟) = (𝛽 𝑚−𝑛+1 − 1, 𝛽 𝑛−1 − 1) avec 𝜆(𝑞) = 𝑚 − 𝑛 + 1.
Et le minimum est atteint pour
(𝑥, 𝑦) = (𝛽 𝑚−1 , 𝛽 𝑛 − 1) qui donne (𝑞, 𝑟) = (∑𝑘=0 𝛽 , 1) avec 𝜆(𝑞) = 𝑚 − 𝑛.
𝑚−𝑛−1 𝑘
ℓ−1
En prenant ℓ = 𝑚 − 𝑛 + 1 on peut donc écrire 𝑞 = ∑ 𝑞𝑘 𝛽 𝑘 avec 𝑞ℓ−1 ≠ 0 ou 𝑞ℓ−2 ≠ 0.
𝑘=0
Algorithme 2.6.3 (Division euclidienne : quotient et reste.)

𝑚−1 𝑛−1
INPUT : 𝑚, 𝑛 ∈ ℕ avec 𝑚 ⩾ 𝑛 ⩾ 1 et deux entiers 𝑥 = ∑ 𝑥𝑖 𝛽 𝑖 , 𝑦 = ∑ 𝑦𝑗 𝛽 𝑗 avec 𝑥𝑚−1 ≠ 0, 𝑦𝑛−1 ≠ 0.
𝑖=0 𝑗=0
OUTPUT : (𝑞, 𝑟) = QuoRem(𝑥, 𝑦).
BEGIN
1: ℓ←𝑚−𝑛+1
2 : 𝑟ℓ ← 𝑥
3 : FOR 𝑘 FROM ℓ − 1 DOWN TO 0 DO
𝑟
4: 𝑞𝑘 ← ⌊ 𝑘+1𝑘 ⌋ ▷ formule mathématique non effective
𝑦𝛽
5: 𝑟𝑘 ← 𝑟𝑘+1 − 𝑞𝑘 𝑦 𝛽 𝑘
6 : END FOR
ℓ−1
7: 𝑞 ← ∑ 𝑞𝑘 𝛽 𝑘
𝑘=0
8: 𝑟 ← 𝑟0
9 : RETURN (𝑞, 𝑟)
END
Proposition 2.6.4 L’algorithme 2.6.3 est correct.

DÉMONSTRATION.
Toutes les opérations se font sans erreur, et il s’arrête (pas de débordement de la longueur ici).
Modulo 𝑦 (c’est-à-dire, en considérant que 𝑦 est équivalent à 0, ce qu’on écrit 𝑦 ≡ 0) on a l’invariance
𝑥 = 𝑟ℓ ≡ 𝑟ℓ−1 ≡ ⋯ ≡ 𝑟0 = 𝑟.
On a aussi 0 ⩽ 𝑟𝑘 < 𝑦 𝛽 𝑘 , donc 0 ⩽ 𝑞𝑘 < 𝛽, et 0 ⩽ 𝑟 < 𝑦 comme voulu.
Cet algorithme est théorique, car il ne dit pas comment calculer les 𝑞𝑘 explicitement. La question est donc
de trouver ces 𝑞𝑘 , sachant que dans le processeur on dispose de la fonction DIV qui effectue la division
euclidienne d’un entier machine double 𝑎0 + 𝑎1 𝛽 par un entier machine 𝑏 :
(𝑞0 , 𝑞1 , 𝑟) ← DIV(𝑎0 , 𝑎1 , 𝑏)
où 𝑏(𝑞0 + 𝑞1 𝛽) + 𝑟 = 𝑎0 + 𝑎1 𝛽 avec 𝑞0 , 𝑞1 , 𝑟 des entiers machine.
On va regarder d’abord la division euclidienne d’un entier multiprécision par un entier machine non nul,
donc pour 𝑛 = 1.
Pour cela, on aura besoin du résultat suivant, qui dit essentiellement que le premier chiffre du quotient est
déterminé par les 2 premiers chiffres du dividende.
Proposition 2.6.5
𝑥 𝑥′
Soient 𝑥 = 𝑥′ 𝛽 + 𝑥0 et 𝑦 = 𝑦′ 𝛽 ≠ 0 avec 0 ⩽ 𝑥0 < 𝛽. Alors ⌊ ⌋ = ⌊ ′ ⌋.
𝑦 𝑦
DÉMONSTRATION. Soient 𝑚 = ⌊𝑥/𝑦⌋ et 𝑚′ = ⌊𝑥′ /𝑦′ ⌋. On a

𝑥 𝑥′ 𝑥 𝑥′
= ′ + ′0 ⩾ ′
𝑦 𝑦 𝑦𝛽 𝑦

donc 𝑚 ⩾ 𝑚′ .
On a par définition 𝑚′ ⩽ 𝑥′
𝑦′ < 𝑚′ + 1 donc 0 ⩽ 𝑥′ − 𝑦′ 𝑚′ < 𝑦′ dans ℤ, d’où 0 ⩽ 𝑥′ − 𝑦′ 𝑚′ ⩽ 𝑦′ − 1, ce qui
𝑥′ 1
donne l’encadrement plus précis 𝑚′ ⩽ ⩽ 𝑚′ + 1 − ′ . Alors
𝑦′ 𝑦
𝑥 𝑥′ 𝑥 1 𝑥′ 1
= ′ + 0 ⋅ ′ < ′ + ′ ⩽ 𝑚′ + 1
𝑦 𝑦 𝛽 𝑦 𝑦 𝑦
𝑥
d’où < 𝑚′ + 1 et 𝑚 ⩽ 𝑚′ .
𝑦
Algorithme 2.6.6 (Division euclidienne d’un entier multiprécision ⩾ 0 par un entier machine
non nul)
INPUT : (𝒙, 𝑎) où 𝒙 = (0, 𝑥0 , … , 𝑥𝑛−1 ) et 𝑎 ∈ J1, 𝛽 − 1K.
OUTPUT : (𝒒, 𝑟) = QuoRem(𝒙, 𝑎) avec 𝒒 = (0, 𝑞0 , … , 𝑞𝑛−1 ) le quotient et 𝑟 ∈ J0, 𝑎 − 1K le reste de la
division euclidienne de 𝒙 par 𝑎.
BEGIN
1 : 𝑟𝑛 ← 0
2 : 𝑞1,0 ← 0
3 : FOR 𝑖 FROM 𝑛 − 1 DOWN TO 0 DO
4: (𝑞0,𝑖 , 𝑞1,𝑖 , 𝑟𝑖 ) ← DIV(𝑥𝑖 , 𝑟𝑖+1 , 𝑎)
5 : END FOR
6 : 𝒒 ← (0, 𝑞0,0 , … , 𝑞0,𝑛−1 ) ▷ 𝜆(𝒒 ) ⩽ 𝑛
0 0
7: 𝒒 ← (0, 0, 𝑞0,1 , … , 𝑞1,𝑛−2 ) ▷ 𝜆(𝒒 ) ⩽ 𝑛
1 1
8: 𝒒←𝒒 +𝒒
0 1
9: 𝑟 ← 𝑟0
10 : RETURN (𝒒, 𝑟)
END
Proposition 2.6.7
L’algorithme 2.6.6 est correct.
Il calcule la division euclidienne d’un entier multiprécision positif ou nul de longueur ⩽ 𝑛 par un entier
machine non nul avec un coût inférieur ou égal à 𝑛 DIV et 𝑛 ADD.
DÉMONSTRATION. On a 𝑟𝑖 , 𝑞𝑖,0 , 𝑞𝑖,1 ∈ J0, 𝛽 − 1K, ce sont donc bien des entiers machine et les opérations
sont correctes (pas de débordement de la longueur ici).
Dans le premier DIV on a 𝑞1,𝑛−1 = 0 car 𝑟𝑛 = 0 donc Quo(𝑥𝑛−1 + 𝑟𝑛 𝛽, 𝑎) = ⌊ 𝑛−1
𝑥
𝑎 ⌋ ⩽ 𝑥𝑛−1 < 𝛽.
Pour 𝑖 ∈ J0, 𝑛 − 1K on a 𝑥𝑖 = 𝑎(𝑞0,𝑖 + 𝑞1,𝑖 𝛽) + 𝑟𝑖 − 𝑟𝑖+1 𝛽, donc
𝑛−1 𝑛−1
𝒙 = ∑ 𝑥𝑖 𝛽 = ∑(𝑎(𝑞0,𝑖 + 𝑞1,𝑖 𝛽) + 𝑟𝑖 − 𝑟𝑖+1 𝛽)𝛽 𝑖
𝑖
𝑖=0 𝑖=0
𝑛−1 𝑛−1
= 𝑎 ∑ 𝑞0,𝑖 𝛽 𝑖 + 𝑎 ∑ 𝑞1,𝑖 𝛽 𝑖+1 + 𝑟0 − 𝑟𝑛 𝛽 𝑛 (somme télescopique)
𝑖=0 𝑖=0
𝑛
= 𝑎 𝒒 + 𝑎 ∑ 𝑞1,𝑖−1 𝛽 𝑖 + 𝑟 − 0
0
𝑖=1
𝑛−1
= 𝑎 𝒒 + ∑ 𝑞1,𝑖−1 𝛽 𝑖 + 𝑟 (car 𝑞1,𝑛−1 = 0)
0
𝑖=1
= 𝑎(𝒒 + 𝒒 ) + 𝑟
0 1
= 𝑎𝒒 + 𝑟
et l’on a bien 𝒙 = 𝑎 𝒒 + 𝑟 avec 0 ⩽ 𝑟 < 𝑎.

Coût : Il y a 𝑛 DIV, et la somme 𝒒 + 𝒒 nécessite au plus 𝑛 ADD (car 𝜆(𝒒 ), 𝜆(𝒒 ) ⩽ 𝑛).
0 1 0 1
Dans le cas général (division par un entier multiprécision > 0), les choses se compliquent car on doit parfois
tâtonner pour trouver le bon 𝑞𝑘 . Cela devient assez technique, nous nous contenterons ici de donner le
résultat suivant sans démonstration.
Théorème 2.6.8
Pour 𝑥, 𝑦 ∈ ℤ tels que 𝜆(𝑥) ⩾ 𝜆(𝑦) ⩾ 1, l’algorithme classique (ou naïf) peut effectuer la division euclidienne
de 𝑥 par 𝑦 en temps O(ℓ2 ), où ℓ = 𝜆(𝑥).
On a donc un coût quadratique en la longueur de 𝑥.
2.7 Plus grand commun diviseur et algorithme de Euclide dans ℤ

Définition de la divisibilité dans ℤ : Pour 𝑎, 𝑏 ∈ ℤ, on dit que 𝑎 divise 𝑏 ou que 𝑏 est un multiple de 𝑎 s’il
existe 𝑐 ∈ ℤ tel que 𝑎𝑐 = 𝑏. Notation : 𝑎 \ 𝑏. Pour 𝑎 ≠ 0 on a : 𝑎 \ 𝑏 ⟺ Rem(𝑏, 𝑎) = 0.
Le pgcd canonique de deux entiers 𝑥, 𝑦 ∈ ℕ∗ , noté Gcd(𝑥, 𝑦), peut être défini de plusieurs façons équivalentes.
• Gcd(𝑥, 𝑦) = max{ 𝑑 ∈ ℕ∗ ∣ 𝑑 \ 𝑥 et 𝑑 \ 𝑦 }.
• Gcd(𝑥, 𝑦) est (l’unique) 𝑑 ∈ ℕ∗ tel que
1) 𝑑 \ 𝑥 et 𝑑 \ 𝑦.
2) Si 𝛿 ∈ ℕ∗ et 𝛿 \ 𝑥 et 𝛿 \ 𝑦, alors 𝛿 \ 𝑑.
On étend cela à 𝑎, 𝑏 ∈ ℤ∗ en disant que Gcd(𝑎, 𝑏) = Gcd(|𝑎|, |𝑏|).
Si 𝑎 ≠ 0 et 𝑏 = 0, on étend facilement la définition : Gcd(𝑎, 0) = |𝑎|.
Si 𝑎 = 𝑏 = 0, on définit Gcd(0, 0) = 0.
L’algorithme de Euclide calcule le pgcd canonique de deux entiers. Il repose sur le résultat suivant.
Proposition 2.7.1
Soient 𝑥, 𝑦 ∈ ℤ avec 𝑦 ≠ 0, et soit 𝑟 = Rem(𝑥, 𝑦). Alors Gcd(𝑥, 𝑦) = Gcd(𝑦, 𝑟).
DÉMONSTRATION. Posons 𝑑1 = Gcd(𝑥, 𝑦) et 𝑑2 = Gcd(𝑦, 𝑟). Alors

• 𝑑1 \ 𝑥 et 𝑑1 \ 𝑦, d’où 𝑑1 \ (𝑥 − 𝑞𝑦) = 𝑟. Donc 𝑑1 \ 𝑑2 .
• 𝑑2 \ 𝑦 et 𝑑2 \ 𝑟, d’où 𝑑2 \ (𝑞𝑦 + 𝑟) = 𝑥. Donc 𝑑2 \ 𝑑1 .
D’où 𝑑1 = ±𝑑2 . Comme 𝑑1 , 𝑑2 ⩾ 0, on a 𝑑1 = 𝑑2 .
L’algorithme de Euclide itère la Proposition 2.7.1 pour trouver le pgcd de deux entiers.
Algorithme 2.7.2 (algorithme de Euclide)

INPUT : Deux entiers 𝑥, 𝑦, avec 𝑦 ≠ 0.
OUTPUT : Gcd(𝑥, 𝑦).
BEGIN
1 : 𝑎 ← |𝑥|
2 : 𝑏 ← |𝑦|
3 : WHILE 𝑏 ≠ 0 DO
4: 𝑟 ← Rem(𝑎, 𝑏) ▷ reste de la division euclidienne de 𝑎 par 𝑏
5: (𝑎, 𝑏) ← (𝑏, 𝑟)
6 : END WHILE
7 : RETURN 𝑎
END
Corollaire 2.7.3
L’algorithme de Euclide 2.7.2 est correct.
DÉMONSTRATION. Il suffit d’appliquer la Proposition 2.7.1 et une récurrence.

Quelle est la complexité de l’algorithme de Euclide ? Pour trouver son coût, on cherche à majorer le nombre
de divisions euclidiennes effectuées.
La réponse à cette question fait intervenir de façon inattendue les nombres de Fibonacci (voir Exercice 2.8.6).
La suite (𝐹𝑛 )𝑛⩾0 des nombres de Fibonacci est définie ainsi :
𝐹0 = 𝐹 1 = 1 et 𝐹𝑛+2 = 𝐹𝑛+1 + 𝐹𝑛 pour 𝑛 ⩾ 0.
Les premiers nombres de Fibonacci sont 1, 1, 2, 3, 5, 8, 13, 21, 34, ….
Lemme 2.7.4
Si 𝑛 > 0, alors le nombre de divisions euclidiennes nécessaires pour calculer Gcd(𝐹𝑛+1 , 𝐹𝑛 ) par l’algorithme
de Euclide est exactement 𝑛.
Exemple 2.7.5 Pour 𝑛 = 4, on a 𝐹𝑛+1 = 8 et 𝐹𝑛 = 5, et l’algorithme de Euclide donne :
8=5⋅1+3
5=3⋅1+2 8 5 3 2 1 0
qu’on écrit
3=2⋅1+1 1 1 1 2
2=1⋅2+0
où l’on a bien effectué 4 divisions euclidiennes.
DÉMONSTRATION. (du lemme 2.7.4)
• On montre par récurrence que pour 𝑛 ⩾ 2 on a 1 ⩽ 𝐹𝑛−1 < 𝐹𝑛 .
• Alors pour 𝑛 ⩾ 2 la division euclidienne de 𝐹𝑛+1 par 𝐹𝑛 donne QuoRem(𝐹𝑛+1 , 𝐹𝑛 ) = (1, 𝐹𝑛−1 )
On montre le lemme par récurrence sur 𝑛 ∈ ℕ∗ .
Pour 𝑛 = 1, comme QuoRem(𝐹2 , 𝐹1 ) = (1, 0), on ne fait qu’une division euclidienne.
On suppose le résultat vrai pour 𝑛, on regarde pour 𝑛 + 1.
La division euclidienne de 𝐹𝑛+2 par 𝐹𝑛+1 donne QuoRem(𝐹𝑛+2 , 𝐹𝑛+1 ) = (1, 𝐹𝑛 ). On se ramène donc à
(𝐹𝑛+1 , 𝐹𝑛 ), qui par hypothèse de récurrence nécessite exactement 𝑛 divisions euclidiennes.
Donc Euclide pour (𝐹𝑛+2 , 𝐹𝑛+1 ) nécessite exactement 1 + 𝑛 divisions euclidiennes, d’où le résultat.
L’écriture de l’algorithme de Euclide appliqué à 𝐹𝑛+1 et 𝐹𝑛 :

𝐹𝑛+1 𝐹𝑛 𝐹𝑛−1 ⋯ 𝐹2 𝐹1 0
1 1 ⋯ 1 2
montre bien 𝑛 divisions euclidiennes.
Théorème 2.7.6 (Léger (1837) et Lamé (1844))
Soient 𝑥, 𝑦 ∈ ℕ avec 𝑥 > 𝑦 > 0. Si l’algorithme de Euclide appliqué à 𝑥 et 𝑦 nécessite 𝑛 divisions euclidiennes,
alors 𝑥 ⩾ 𝐹𝑛+1 et 𝑦 ⩾ 𝐹𝑛 .
DÉMONSTRATION. On montre le résultat par récurrence sur 𝑛.

Comme 𝑥 ⩾ 2 et 𝑦 ⩾ 1, pour 𝑛 = 1 on a bien 𝑥 ⩾ 𝐹2 et 𝑦 ⩾ 𝐹1 .
On suppose le résultat vrai pour 𝑛, on regarde pour 𝑛 + 1.
Soient 𝑥, 𝑦 avec 𝑥 > 𝑦 > 0 tels que Euclide nécessite 𝑛 + 1 divisions euclidiennes. La première donne
(𝑞, 𝑟) = QuoRem(𝑥, 𝑦). Après il faut appliquer Euclide à (𝑦, 𝑟), qui nécessite donc (𝑛 + 1) − 1 = 𝑛 divisions
euclidiennes. Par hypothèse de récurrence, on a ainsi 𝑦 ⩾ 𝐹𝑛+1 et 𝑟 ⩾ 𝐹𝑛 . Et pour 𝑥 on a
𝑥 = 𝑞𝑦 + 𝑟 ⩾ 𝑞𝐹𝑛+1 + 𝐹𝑛 ⩾ 𝐹𝑛+1 + 𝐹𝑛 = 𝐹𝑛+2
(car 𝑞 ⩾ 1) comme voulu.
Corollaire 2.7.7
La complexité (exprimée en fonction du nombre de divisions euclidiennes) de l’algorithme de Euclide appliqué
√
aux entiers 𝑥, 𝑦 > 0 est O(log𝜑 min{𝑥, 𝑦}), où 𝜑 = 1+ 5
2 est le nombre d’or.
DÉMONSTRATION. Soient 𝑥 et 𝑦 deux entiers positifs. Quitte à ajouter une étape à l’algorithme de Euclide
(ce qui ne changera pas sa complexité asymptotique), on peut supposer que 𝑥 > 𝑦.
Soit 𝑛 le nombre d’étapes nécessaires pour appliquer l’algorithme de Euclide.

On veut montrer que 𝑛 ∈ O(log𝜑 min{𝑥, 𝑦}) = O(log𝜑 𝑦).
On montre d’abord que 𝐹𝑛 ∈ Θ(𝜑𝑛 ) par récurrence. On utilisera le fait que 𝜑2 = 𝜑 + 1.
On remarque que 𝐹0 ⩽ 𝜑0 et 𝐹1 ⩽ 𝜑1 , et que si 𝐹𝑛−1 ⩽ 𝜑𝑛−1 et 𝐹𝑛−2 ⩽ 𝜑𝑛−2 pour un certain 𝑛 ⩾ 2, alors
𝐹𝑛 = 𝐹𝑛−1 + 𝐹𝑛−2 ⩽ 𝜑𝑛−1 + 𝜑𝑛−2 = 𝜑𝑛−2 (𝜑 + 1) = 𝜑𝑛−2 𝜑2 = 𝜑𝑛 .
Donc 𝐹𝑛 ∈ O(𝜑𝑛 ).
De même, on remarque que 2𝐹0 ⩾ 𝜑0 et 2𝐹1 ⩾ 𝜑1 , et que si 2𝐹𝑛−1 ⩾ 𝜑𝑛−1 et 2𝐹𝑛−2 ⩾ 𝜑𝑛−2 pour un
certain 𝑛 ⩾ 2, alors
2𝐹𝑛 = 2𝐹𝑛−1 + 2𝐹𝑛−2 ⩾ 𝜑𝑛−1 + 𝜑𝑛−2 = 𝜑𝑛−2 (𝜑 + 1) = 𝜑𝑛−2 𝜑2 = 𝜑𝑛 .
Donc 𝜑𝑛 ∈ O(𝐹𝑛 ). On a bien montré que 𝐹𝑛 ∈ Θ(𝜑𝑛 ).
Ainsi, il existe une constante 𝑐 > 0, indépendante de 𝑥 et 𝑦, telle que 𝜑𝑛 ⩽ 𝑐 𝐹𝑛 ⩽ 𝑐 𝑦.
Par conséquent, 𝑛 ⩽ log𝜑 𝑐 + log𝜑 𝑦 ∈ O(log𝜑 𝑦).
En plus de calculer le pgcd, on peut aussi vouloir calculer les coefficients de Bézout.
Proposition 2.7.8 (identité de Bézout)
Si 𝑑 = Gcd(𝑥, 𝑦), alors il existe des entiers 𝛼 et 𝛽 (appelés coefficients de Bézout) tels que 𝛼𝑥 + 𝛽𝑦 = 𝑑.
Remarque 2.7.9 Attention : 𝛼 et 𝛽 ne sont jamais uniques.

DÉMONSTRATION. On peut le montrer par récurrence sur le nombre d’étapes de l’algorithme de Euclide
appliqué à 𝑥 et 𝑦. Supposons que 𝑥 ⩾ 𝑦. Si l’algorithme de Euclide ne demande qu’une étape, alors 𝑦 divise 𝑥,
d’où Gcd(𝑥, 𝑦) = 𝑦 = 0 ⋅ 𝑥 + 1 ⋅ 𝑦 et 𝛼𝑥 + 𝛽𝑦 = 𝑑 avec 𝛼 = 0, 𝛽 = 1.
Si le nombre 𝑛 d’étapes de l’algorithme de Euclide est supérieur à 1, écrivons
𝑥 = 𝑞𝑦 + 𝑟
pour la première division faite par l’algorithme. Alors on a vu que Gcd(𝑥, 𝑦) = Gcd(𝑦, 𝑟), et le nombre
d’étapes de l’algorithme de Euclide appliqué à (𝑦, 𝑟) est 𝑛−1. Par l’hypothèse de récurrence, il existe 𝛼, 𝛽 ∈ ℤ
tels que 𝑑 = 𝛼𝑦 + 𝛽𝑟. Mais alors
𝑑 = 𝛼𝑦 + 𝛽𝑟 = 𝛼𝑦 + 𝛽(𝑥 − 𝑞𝑦) = 𝛽𝑥 + (𝛼 − 𝛽𝑞)𝑦.
comme voulu.
On peut déduire de cette preuve un algorithme pour calculer à la fois le pgcd et des coefficients de Bézout
pour deux entiers.
Algorithme 2.7.10 (algorithme de Euclide étendu : pgcd plus Bézout)

INPUT : Deux entiers 𝑥, 𝑦.
OUTPUT : (𝑑, 𝑢, 𝑣) avec 𝑑 = Gcd(𝑥, 𝑦) et 𝑢𝑥 + 𝑣𝑦 = 𝑑.
BEGIN
1 : (𝑟0 , 𝑢0 , 𝑣0 ) ← (𝑥, 1, 0)
2 : (𝑟1 , 𝑢1 , 𝑣2 ) ← (𝑦, 0, 1)
3: 𝑖←0
4 : WHILE 𝑟𝑖 ≠ 0 DO
5: 𝑖←𝑖+1
6: 𝑞𝑖 ← Quo(𝑟𝑖−1 , 𝑟𝑖 ) ▷ quotient canonique de la division euclidienne
7: 𝑟𝑖+1 ← 𝑟𝑖−1 − 𝑞𝑖 𝑟𝑖
8: 𝑢𝑖+1 ← 𝑢𝑖−1 − 𝑞𝑖 𝑢𝑖
9: 𝑣𝑖+1 ← 𝑣𝑖−1 − 𝑞𝑖 𝑣𝑖
10 : END WHILE
11 : RETURN (𝑟𝑖 , 𝑢𝑖 , 𝑣𝑖 )
END
Correct : À chaque étape on a 𝑥𝑢𝑖 + 𝑦𝑣𝑖 = 𝑟𝑖 . Et à la sortie de la boucle on a 𝑟𝑖 = Gcd(𝑥, 𝑦).

À noter que la Proposition 2.7.8 peut être améliorée pour les entiers premiers entre eux.

Théorème 2.7.11 (de Bézout)
Deux entiers 𝑥 et 𝑦 sont premiers entre eux si et seulement s’il existe des entiers 𝛼 et 𝛽 tels que 𝛼𝑥 + 𝛽𝑦 = 1.
DÉMONSTRATION. Si 𝑥 et 𝑦 sont premiers entre eux, alors Gcd(𝑥, 𝑦) = 1, et l’existence de 𝛼 et 𝛽 découle
de la Proposition 2.7.8. S’il existe des entiers 𝛼 et 𝛽 tels que 𝛼𝑥 + 𝛽𝑦 = 1, alors tout diviseur commun de 𝑥
et 𝑦 doit diviser 𝛼𝑥 + 𝛽𝑦, et divise donc 1. D’où Gcd(𝑥, 𝑦) = 1, et 𝑥 et 𝑦 sont premiers entre eux.
Enfin, notons que le calcul du plus petit commun multiple (ppcm) canonique de deux entiers est équivalent
en complexité au calcul de leur pgcd, grâce à la propriété suivante (que nous ne démontrerons pas ici).
Proposition 2.7.12
Soient 𝑥 et 𝑦 deux entiers positifs qui ne sont pas tous les deux nuls. Alors 𝑥𝑦 = Gcd(𝑥, 𝑦) Lcm(𝑥, 𝑦).
Exercice 2.7.13
▾ Implémenter l’algorithme de Euclide et l’algorithme de Euclide étendu en SageMath.
Exercice 2.7.14
Vérifier que l’Algorithme 2.7.10 renvoie bien le pgcd canonique de 𝑥 et 𝑦 ainsi que des coefficients de Bézout.
2.8 Exercices supplémentaires

Exercice 2.8.1
Soient 𝑥 un entier de longueur 𝑛 (écrit en base 𝛽), et soit 𝑦 un entier machine (c’est-à-dire un entier de
longueur 1 en base 𝛽). En supposant que le produit et la somme d’entiers machine sont des opérations
élémentaires, montrer que l’algorithme naïf de multiplication de 𝑥 par 𝑦 est de complexité O(𝑛).
Exercice 2.8.2
Voici un algorithme effectuant la division euclidienne d’un entier positif ou nul par un entier strictement
positif.
Algorithme (Division euclidienne lente)
INPUT : Deux entiers 𝑥 ⩾ 0 et 𝑦 > 0.

OUTPUT : Le quotient 𝑞 et le reste 𝑟 de la division euclidienne de 𝑥 par 𝑦.
BEGIN
1: 𝑞←0
2 : WHILE 𝑥 ⩾ 𝑦 DO
3: 𝑥←𝑥−𝑦
4: 𝑞 ←𝑞+1
5 : END WHILE
6: 𝑟←𝑥
7 : RETURN (𝑞, 𝑟)
END
1. Expliquer pourquoi l’algorithme ci-dessus est correct.

2. Supposons que 𝑥 et 𝑦 sont de longueur 𝑚 et 𝑛 dans leur écriture en base 𝛽. Montrer que l’algorithme
ci-dessus se termine après au plus 𝛽 𝑚−𝑛+1 itérations de la boucle. Commenter sur la complexité de
l’algorithme.
Exercice 2.8.3
▾ Implémenter en SageMath une fonction qui prend en entrée un entier 𝑎 et un entier 𝛽 ⩾ 2 et renvoie la
liste des chiffres de l’écriture de 𝑎 dans la base 𝛽.
Exercice 2.8.4
▾ Dans cet exercice, on sera peut-être amené à utiliser les fonctions factor, is_prime, next_prime.
Si 𝑛 ⩾ 0 est un entier, le 𝑛-ième nombre de Fermat est 22 + 1.
𝑛
1. Écrire une fonction qui, étant donné 𝑛, renvoie le 𝑛-ième nombre de Fermat.

2. Donner la liste des 10 premiers nombres de Fermat (où 𝑛 commence à 0).
3. Tester lesquels des 10 premiers nombres de Fermat sont premiers.
Exercice 2.8.5
Considérons l’algorithme suivant (pgcd binaire).
Algorithme (GcdBin(𝑎, 𝑏))
INPUT : Deux entiers strictement positifs 𝑎 et 𝑏.

OUTPUT : Le pgcd de 𝑎 et 𝑏.
BEGIN
1 : IF 𝑎 = 𝑏 THEN
2: 𝑑←𝑎
3: RETURN 𝑑
4 : END IF
5 : IF 𝑎 < 𝑏 THEN
6: 𝑑 ← GcdBin(𝑏, 𝑎) ▷ appel récursif
7: RETURN 𝑑
8 : END IF
9 : IF 𝑎 et 𝑏 sont pairs THEN
10 : 𝑑 ← 2 ∗ GcdBin( 𝑎2 , 2𝑏 ) ▷ appel récursif
11 : RETURN 𝑑
12 : END IF
13 : IF 𝑎 est pair et 𝑏 est impair THEN
14 : 𝑑 ← GcdBin( 𝑎2 , 𝑏) ▷ appel récursif
15 : RETURN 𝑑
16 : END IF
17 : IF 𝑎 est impair et 𝑏 est pair THEN
18 : 𝑑 ← GcdBin(𝑎, 2𝑏 ) ▷ appel récursif
19 : RETURN 𝑑
20 : END IF
21 : 𝑑 ← GcdBin( 𝑏−𝑎 2 , 𝑏) ▷ appel récursif
22 : RETURN 𝑑
END
1. ▾ Implémenter cet algorithme et le tester sur les couples (34, 21), (136, 51), (481, 325) et (8771, 3206).
2. Montrer que cet algorithme est correct.
3. Montrer son coût est O(𝑛2 ) opérations élémentaires, avec 𝑛 majorant la longueur de 𝑎 et 𝑏.
4. ▾ Modifier cet algorithme pour obtenir un Bézout de 𝑎, 𝑏.
Exercice 2.8.6
La suite (𝐹𝑛 )𝑛⩾0 des nombres de Fibonacci est définie par récurrence de la façon suivante :
𝐹0 = 𝐹 1 = 1 et 𝐹𝑛 = 𝐹𝑛−1 + 𝐹𝑛−2 (𝑛 ⩾ 2).
Dans cet exercice, on fixe un entier 𝛽 ⩾ 2.
1. Montrer que le nombre 𝐹𝑛 est de longueur au plus 𝑛 pour tout 𝑛 ⩾ 1. Indication : Si 𝑥 et 𝑦 sont de
longueur au plus 𝑛, alors 𝑥 + 𝑦 est de longueur au plus...
2. Considérons l’algorithme suivant.

Algorithme (Leonardo)
INPUT : Un entier 𝑛 ⩾ 0.
OUTPUT : Le 𝑛-ième nombre de Fibonacci 𝐹𝑛 .
BEGIN
1 : IF 𝑛 = 0 ou 𝑛 = 1 THEN
2: RETURN 1
3 : END IF
4 : (𝑓0 , 𝑓1 ) ← (1, 1)
6: (𝑓0 , 𝑓1 ) ← (𝑓1 , 𝑓0 + 𝑓1 )
7 : END FOR
8 : RETURN 𝑓1
END
(a) Expliquer pourquoi cet algorithme est correct.

(b) ▾ Implémenter cet algorithme en SageMath et l’utiliser pour calculer les 20 premiers nombres de
Fibonacci.
(c) Montrer que le coût en temps du calcul de 𝐹𝑛 est O(𝑛2 ). Indication : Utiliser la Proposition 1.2.5.
Exercice 2.8.7
Pour un entier 𝑛 > 0, on désigne par 𝜆(𝑛) la longueur de l’écriture de 𝑛 en base 𝛽. On veut évaluer la
complexité du temps du calcul de la factorielle d’après sa définition
𝑛! = 1 ⋅ 2 ⋅ ⋯ ⋅ (𝑛 − 1) ⋅ 𝑛.
1. Rappeler pourquoi log(𝑛) < 𝜆(𝑛) ⩽ log(𝑛) + 1.
2. Montrer que 𝜆(𝑛!) ⩽ 𝑛 log(𝑛) + 1.
3. Supposons que nous disposons d’une méthode permettant de multiplier deux entiers de longueur au
plus 𝐿 − 1 en temps O(𝐿2 ). Montrer que la méthode de calcul de 𝑛! consistant à calculer 1 ⋅ 2, puis
multiplier par 3 pour obtenir 3!, puis par 4 pour obtenir 4!, et ainsi de suite, permet le calcul de 𝑛! en
temps
O(𝑛3 (log(𝑛))2 ).
Exercice 2.8.8
Pour 𝑎0 ∈ ℤ, 𝑛 ∈ ℕ et 𝑎1 , 𝑎2 , … , 𝑎𝑛 ∈ ℕ∗ , on définit [𝑎0 ; 𝑎1 , 𝑎2 , … , 𝑎𝑛 ] comme suit :
1 1 1
[𝑎0 ] = 𝑎0 [𝑎0 ; 𝑎1 ] = 𝑎0 + [𝑎0 ; 𝑎1 , 𝑎2 ] = 𝑎0 + [𝑎0 ; 𝑎1 , 𝑎2 , 𝑎3 ] = 𝑎0 +
𝑎1 1 1
𝑎1 + 𝑎1 +
𝑎2 1
𝑎2 +
𝑎3
etc. Ce sont des fractions continues finies.
Il est clair que toute fraction continue finie est un nombre rationnel.
1. Réciproquement, on va démontrer constructivement que tout nombre rationnel est égal à une fraction
continue finie. Soit 𝑎𝑏 ∈ ℚ avec 𝑎 ∈ ℤ, 𝑏 ∈ ℕ∗ .
Soit (𝑟−1 , 𝑟0 ) = (𝑎, 𝑏). La division euclidienne de 𝑟−1 par 𝑟0 ≠ 0 donne 𝑟−1 = 𝑟0 𝑞0 + 𝑟1 . On prend 𝑎0 = 𝑞0 .
Si 𝑟1 = 0 on s’arrête avec 𝑛 = 0.
Sinon, la division euclidienne de 𝑟0 par 𝑟1 ≠ 0 donne 𝑟0 = 𝑟1 𝑞1 + 𝑟2 . On prend 𝑎1 = 𝑞1 .
Si 𝑟2 = 0 on s’arrête avec 𝑛 = 1. Sinon, on continue tant qu’on a un reste non nul. On a ainsi
𝑟−1 = 𝑟0 𝑞0 + 𝑟1
⋮
𝑟𝑛−2 = 𝑟𝑛−1 𝑞𝑛−1 + 𝑟𝑛 avec 𝑟𝑛 ≠ 0
𝑟𝑛−1 = 𝑟𝑛 𝑞𝑛 + 𝑟𝑛+1 avec 𝑟𝑛+1 = 0
ce qui donne [𝑎0 ; 𝑎1 , … , 𝑎𝑛 ] avec 𝑎𝑖 = 𝑞𝑖 .

Montrer que le processus précédent s’arrête effectivement puis que [𝑎0 ; 𝑎1 , … , 𝑎𝑛 ] est une fraction continue
finie égale à 𝑎𝑏 .
2. En déduire qu’on peut trouver une expression en fraction continue finie du nombre rationnel 𝑎𝑏 en effectuant
O(log𝜑 (min{𝑎, 𝑏}) divisions euclidiennes. Indication : Faire un rapprochement avec l’algorithme de Euclide.
3. ▾ Implémenter en SageMath l’algorithme décrit en (1).
4. L’expression d’un nombre rationnel comme fraction continue n’est pas unique (exemple : 3 = [3] = [2; 1]).
Montrer que pour 𝑛 ∈ ℕ on a [𝑎0 ; 𝑎1 , … , 𝑎𝑛 , 1] = [𝑎0 ; 𝑎1 , … , 𝑎𝑛 + 1] (en particulier, pour 𝑛 = 0 on a
[𝑎0 ; 1] = [𝑎0 + 1]).
En déduire que tout nombre rationnel admet exactement deux expressions comme fraction continue finie.
Laquelle des deux est fournie par l’algorithme précédent ?
5. Si 𝑎0 ∈ ℤ et 𝑎𝑖 ∈ ℕ∗ pour 𝑖 ∈ ℕ∗ , on définit
[𝑎0 ; 𝑎1 , 𝑎2 , 𝑎3 , …] = lim [𝑎0 ; 𝑎1 , 𝑎2 , … , 𝑎𝑛 ]
𝑛→+∞
ce qui peut s’écrire
1
[𝑎0 ; 𝑎1 , 𝑎2 , 𝑎3 , …] = 𝑎0 +
1
𝑎1 +
1
𝑎2 +
𝑎3 + ⋯
et l’on parle de fraction continue infinie.
★ Montrer qu’une fraction continue infinie représente toujours un nombre irrationnel et que tout nombre
irrationnel s’exprime de façon unique comme fraction continue infinie.

3 Structures algébriques (résumé)
On ne donne ici qu’un résumé des principaux notions et résultats. Pour plus de précisions, se référer à la
dernière version des notes de cours de Théorie des nombres disponible sur eCampus.
3.1 Opérations binaires

Une opération binaire est une application ⋆ ∶ 𝑋 × 𝑌 ⟶ 𝑍 où 𝑋, 𝑌 , 𝑍 sont des ensembles.
Notation : 𝑥 ⋆ 𝑦 = ⋆((𝑥, 𝑦)).
Une loi de composition interne sur un ensemble 𝑋 est une opération binaire ⋆ ∶ 𝑋 × 𝑋 ⟶ 𝑋. Autrement
dit, à 𝑥, 𝑦 ∈ 𝑋 elle fait correspondre un unique élément 𝑥 ⋆ 𝑦 qui appartient à 𝑋.
Soit ⋆ une loi de composition interne sur 𝑋.
⋆ est associative si ∀ 𝑥, 𝑦, 𝑧 ∈ 𝑋, (𝑥 ⋆ 𝑦) ⋆ 𝑧 = 𝑥 ⋆ (𝑦 ⋆ 𝑧).
𝑒 ∈ 𝑋 est un élément neutre pour ⋆ si ∀ 𝑥 ∈ 𝑋, 𝑥 ⋆ 𝑒 = 𝑒 ⋆ 𝑥 = 𝑥.
Si 𝑒 ∈ 𝐸 est un élément neutre pour ⋆ et 𝑥 ∈ 𝑋, alors 𝑥′ est un symétrique de 𝑥 si 𝑥′ ∈ 𝑋 et 𝑥⋆𝑥′ = 𝑥′ ⋆𝑥 = 𝑒.
⋆ est commutative si ∀ 𝑥, 𝑦 ∈ 𝑋, 𝑥 ⋆ 𝑦 = 𝑦 ⋆ 𝑥.
(𝑋, ⋆) est un groupe abélien si ⋆ est une loi de composition interne sur 𝑋 qui est associative, commutative,
possède un élément neutre, et pour laquelle tout élément possède un symétrique.
Le neutre est unique :
Si 𝑥 ⋆ 𝑒1 = 𝑒1 ⋆ 𝑥 = 𝑥 et 𝑥 ⋆ 𝑒2 = 𝑒2 ⋆ 𝑥 = 𝑥 ∀ 𝑥 ∈ 𝑋, alors 𝑒1 = 𝑒1 ⋆ 𝑒2 = 𝑒2 .
Le symétrique de 𝑥 est unique :
Si 𝑥 ⋆ 𝑥′1 = 𝑥′1 ⋆ 𝑥 = 𝑒 et 𝑥 ⋆ 𝑥′2 = 𝑥′2 ⋆ 𝑥 = 𝑒, alors 𝑥′1 = 𝑥′1 ⋆ 𝑒 = 𝑥′1 ⋆ (𝑥 ⋆ 𝑥′2 ) = (𝑥′1 ⋆ 𝑥) ⋆ 𝑥′2 = 𝑒 ⋆ 𝑥′2 = 𝑥′2 .
Notation additive :
Dans (𝑋, +), l’élément neutre est noté 0𝑋 ; le symétrique de 𝑥 ∈ 𝑋 est noté −𝑥 et appelé l’opposé de 𝑥, et
def
𝑥 − 𝑦 = 𝑥 + (−𝑦).
Notation : 𝑋 ∗ = 𝑋 r {0𝑋 }.
On a ∑ 𝑥 = 0𝑋 (la somme vide est égale à l’élément neutre pour la somme).
𝑥∈⌀
Une famille ( 𝑥𝑖 ∣ 𝑖 ∈ 𝐼 ) d’éléments de 𝑋 est presque nulle si { 𝑖 ∈ 𝐼 ∣ 𝑥𝑖 ≠ 0𝑋 } est un ensemble fini. Dans
def
ce cas-là, ∑ 𝑥𝑖 = ∑ 𝑥𝑖 .
𝑖∈𝐼 𝑖∈𝐼
𝑥𝑖 ≠0𝑋
Notation multiplicative :
Dans (𝑋, ⋅), l’élément neutre est noté 1𝑋 ; le symétrique de 𝑥 ∈ 𝐸 est noté 𝑥−1 et appelé l’inverse de 𝑥.
On a ∏ 𝑥 = 1𝑋 (le produit vide est égal à l’élément neutre pour le produit).
𝑥∈⌀
Produit direct de groupes abéliens : Si 𝑛 ∈ ℕ et (𝐺1 , ⋆1 ), … , (𝐺𝑛 , ⋆𝑛 ) sont des groupes abéliens, alors
(𝐺1 × ⋯ × 𝐺𝑛 , ⋆) est un groupe abélien pour la loi (𝑥1 , … , 𝑥𝑛 ) ⋆ (𝑦1 , … , 𝑦𝑛 ) = (𝑥1 ⋆1 𝑦1 , … , 𝑥𝑛 ⋆𝑛 𝑦𝑛 ). Son
neutre est 𝑒 = (𝑒1 , … , 𝑒𝑛 ).
Définition : 𝐻 est un sous-groupe de (𝐺, ⋆) si 𝐻⊆𝐺

𝑒∈𝐻
∀ ℎ1 , ℎ2 ∈ 𝐻, ℎ1 ⋆ ℎ2 ∈ 𝐻
∀ ℎ ∈ 𝐻, ℎ′ ∈ 𝐻
def
Notation : 𝐻 ⩽ 𝐺. Aussi : 𝐻 < 𝐺 ⟺ (𝐻 ⩽ 𝐺 et 𝐻 ≠ 𝐺).
⎧𝐻 ⊆ 𝐺
{
𝐻 est un sous-groupe de (𝐺, ⋆) ⟺ ⎨𝑒 ∈ 𝐻 ou 𝐻 ≠ ⌀
{∀ ℎ , ℎ ∈ 𝐻, ℎ ⋆ ℎ′ ∈ 𝐻
⎩ 1 2 1 2

def
Si 𝐻 ⩽ 𝐺, alors (𝐻, ⋆) est un groupe abélien pour la loi ⋆ ∶ 𝐻 × 𝐻 ⟶ 𝐻 avec ℎ1 ⋆ ℎ2 = ℎ1 ⋆ ℎ2 . Son neutre
est celui de 𝐺.
L’intersection d’une famille non vide de sous-groupes de 𝐺 est un sous-groupe de 𝐺.

On peut rajouter la convention que l’intersection de la famille vide de sous-groupes de 𝐺 est égale à 𝐺.
Si 𝐸 ⊆ 𝐺, le sous-groupe de 𝐺 engendré par 𝐸 est ⟨𝐸⟩ = ⋂ 𝐻.
𝐻⊇𝐸
𝐻 ss-gr de 𝐺
Quel que soit l’ensemble 𝐸 ⊆ 𝐺, on a que ⟨𝐸⟩ est un sous-groupe de 𝐺.
Notation : ⟨𝑔1 , … , 𝑔𝑛 ⟩ = ⟨{𝑔1 , … , 𝑔𝑛 }⟩.
Soit (𝐺, ⋆) un groupe de neutre 𝑒. Pour 𝑚 ∈ ℤ et 𝑔 ∈ 𝐺 on définit une opération binaire ∶ ℤ × 𝐺 ⟶ 𝐺 par
⎧𝑒 si 𝑚 = 0
{ 𝑚 fois
def
{
𝑚 𝑔 = ⎨𝑔⏞ ⋆⋯⋆𝑔 si 𝑚 > 0
{ −𝑚 fois
{⏞′⏞⏞⏞⏞′
⎩𝑔 ⋆ ⋯ ⋆ 𝑔 si 𝑚 < 0
Propriétés : Pour 𝑚, 𝑚1 , 𝑚2 ∈ ℤ et 𝑔 ∈ 𝐺 on a
𝑚1 (𝑚2 𝑔) = (𝑚1 𝑚2 ) 𝑔.
(𝑚1 + 𝑚2 ) 𝑔 = (𝑚1 𝑔) ⋆ (𝑚2 𝑔).
1 𝑔 = 𝑔.
𝑚 𝑒 = 𝑒.
(−1) 𝑔 = 𝑔′ .
𝑚 (𝑔1 ⋆ 𝑔2 ) = (𝑚 𝑔1 ) ⋆ (𝑚 𝑔2 )
Notation additive : 𝑎𝑔 = 𝑚 𝑔 (ce n’est pas une multiplication en général, car 𝑚 ∈ ℤ et 𝑔 ∈ 𝐺).
Notation multiplicative : 𝑔𝑚 = 𝑚 𝑔 (ce n’est pas une puissance en général, car 𝑚 ∈ ℤ et 𝑔 ∈ 𝐺).
Définition : L’ordre d’un groupe (𝐺, ⋆) est le cardinal de 𝐺. Si 𝐺 n’est pas fini, on dit que le groupe est
d’ordre infini.
Un groupe abélien (𝐺, ⋆) est monogène s’il existe 𝑔 ∈ 𝐺 tel que 𝐺 = ⟨𝑔⟩.
Un groupe abélien (𝐺, ⋆) est cyclique s’il est monogène et d’ordre fini.
Définition : Soit 𝑔 ∈ 𝐺. Si ⟨𝑔⟩ est fini, l’ordre de l’élément 𝑔 est o(𝑔) = card⟨𝑔⟩. Sinon, 𝑔 est d’ordre infini.
o(𝑔) = min({ 𝑛 ∈ ℕ∗ ∣ 𝑛 𝑔 = 𝑒 } ∪ {+∞}).
𝑚 𝑔 = 𝑒 ⟹ o(𝑔) \ 𝑚.
En notation multiplicative :
o(𝑔) = min({ 𝑛 ∈ ℕ∗ ∣ 𝑔𝑛 = 𝑒 } ∪ {+∞}).
𝑔𝑚 = 𝑒 ⟹ o(𝑔) \ 𝑚.
Théorème 3.1.1 (Lagrange)
Si 𝐺 est un groupe abélien fini, alors l’ordre de tout sous-groupe de 𝐺 divise l’ordre de 𝐺.
En particulier : ∀ 𝑔 ∈ 𝐺, o(𝑔) \ card 𝐺.
Soient (𝐺1 , ⋆1 ) et (𝐺2 , ⋆2 ) deux groupes abéliens de neutres respectifs 𝑒1 et 𝑒2 . Une application 𝑓 ∶ 𝐺1 ⟶ 𝐺2
est un homomorphisme de groupes si ∀ 𝑥, 𝑦 ∈ 𝐺1 , 𝑓(𝑥 ⋆1 𝑦) = 𝑓(𝑥) ⋆2 𝑓(𝑦).
Le noyau de 𝑓 est ker 𝑓 = { 𝑔1 ∈ 𝐺1 ∣ 𝑓(𝑔1 ) = 𝑒2 }.
On a pour 𝑔1 ∈ 𝐺 et 𝑚 ∈ ℤ :
𝑓(𝑒1 ) = 𝑒2
𝑓(𝑔1′ ) = 𝑓(𝑔1 )′
o(𝑓(𝑔1 )) ⩽ o(𝑔1 )
o(𝑔1 ) ∈ ℕ∗ ⟹ o(𝑓(𝑔1 )) \ o(𝑔1 )
𝑓 injectif ⟹ o(𝑓(𝑔1 )) = o(𝑔1 )
𝑓(𝑚 1 𝑔1 ) = 𝑚 2 𝑓(𝑔1 )

𝐻1 ⩽ 𝐺1 ⟹ 𝑓(𝐻1 ) ⩽ 𝐺2
En particulier, im 𝑓 ⩽ 𝐺2
𝐻2 ⩽ 𝐺2 ⟹ 𝑓 −1 (𝐻2 ) ⩽ 𝐺1
En particulier, ker 𝑓 ⩽ 𝐺1
𝑓 est injectif ⟺ ker 𝑓 = {𝑒1 }
Un isomorphisme de groupes est un homomorphisme de groupes bijectif.

def
Notation : 𝐺1 ≃ 𝐺2 ⟺ ∃ 𝑓 ∶ 𝐺1 ⟶ 𝐺2 homomorphisme de groupes bijectif. On dit que 𝐺1 est isomorphe
gr
à 𝐺2 en tant que groupe. “Être isomorphe en tant que groupe” est une relation d’équivalence.
Si 𝑓 ∶ 𝐺1 ⟶ 𝐺2 est un homomorphisme de groupes injectif, on a un isomorphisme de groupes 𝐺1 ≃ im 𝑓,
gr
ce qui permet de les identifier, et de considérer 𝐺1 comme un sous-groupe de 𝐺2 .
Notations :
def
Homgr (𝐺1 , 𝐺2 ) = { 𝑓 ∶ 𝐺1 ⟶ 𝐺2 ∣ 𝑓 est un homomorphisme de groupes }.
def
L’ensemble des endomorphismes de 𝐺 est Endgr (𝐺) = Homgr (𝐺, 𝐺).
def
L’ensemble des automorphismes de 𝐺 est Autgr (𝐺) = { 𝑓 ∈ Endgr (𝐺) ∣ 𝑓 est bijectif }.
Pour 𝐻1 , 𝐻2 ⩽ 𝐺 on définit 𝐻1 ⋆ 𝐻2 = { ℎ1 ⋆ ℎ2 ∣ ℎ𝑖 ∈ 𝐻𝑖 } = ⟨𝐻1 ∪ 𝐻2 ⟩ qui est un sous-groupe de 𝐺.

⎧𝐻 1 , 𝐻 2 ⩽ 𝐺
def {
Définition : Le groupe 𝐺 est somme directe de 𝐻1 et 𝐻2 ⟺ ⎨𝐻1 ⋆ 𝐻2 = 𝐺 .
{𝐻 ∩ 𝐻 = {𝑒}
⎩ 1 2
Notation : 𝐺 = 𝐻1 ⊕ 𝐻2 .
Attention : 𝐺 = 𝐻1 ⊕ 𝐻2 n’indique pas une opération mais est l’expression d’une propriété (les écritures
𝐻1 ⊕ 𝐻2 = 𝐺 et 𝐻1 ⊕ 𝐻2 n’ont pas de sens ici).
def
Si 𝐻 un sous-groupe de (𝐺, ⋆), la relation 𝑥 ℛ 𝑦 ⟺ 𝑥 ⋆ 𝐻 = 𝑦 ⋆ 𝐻 ⟺ 𝑥 ⋆ 𝑦′ ∈ 𝐻 est une relation
d’équivalence sur 𝐺. Alors le groupe quotient 𝐺 sur 𝐻 est (𝐺/𝐻, ⋆) où 𝐺/𝐻 = 𝐺/ℛ = { [𝑔]𝐻 ∣ 𝑔 ∈ 𝐺 } avec
[𝑔]𝐻 = 𝑔 ⋆ 𝐻 = { 𝑔 ⋆ ℎ ∣ ℎ ∈ 𝐻 } et [𝑔1 ]𝐻 ⋆ [𝑔2 ]𝐻 = [𝑔1 ⋆ 𝑔2 ]𝐻 .
Si 𝐻 un sous-groupe de (𝐺, ⋆), alors (𝐺/𝐻, ⋆) est un groupe abélien, et l’application 𝜋 ∶ 𝐺 ⟶ 𝐺/𝐻 avec
𝜋(𝑔) = [𝑔]𝐻 est un homomorphisme de groupes surjectif, avec ker 𝜋 = 𝐻.
Soit 𝑓 ∶ 𝐺1 ⟶ 𝐺2 un homomorphisme de groupes abéliens. Soient 𝐻1 ⩽ 𝐺1 et 𝐻2 ⩽ 𝐺2 . Alors

• 𝑓(𝐻1 ) ⩽ 𝑓(𝐺1 ) = im 𝑓 ⩽ 𝐺2
• 𝑓 −1 (𝐻2 ) ⩽ 𝐺1
• En particulier, ker 𝑓 ⩽ 𝐺1
Théorème 3.1.2 (Premier théorème d’isomorphisme pour les groupes abéliens)

Si 𝑓 ∶ 𝐺1 ⟶ 𝐺2 est un homomorphisme de groupes abéliens, on a un isomorphisme de groupes
𝑓 ∶ (𝐺1 / ker 𝑓) ⟶ im 𝑓 avec 𝑓([𝑔]ker 𝑓 ) = 𝑓(𝑔).
3.2 Anneaux unitaires commutatifs

(𝐴, +, ⋅) est un anneau unitaire commutatif si (𝐴, +) est un groupe abélien (élément neutre noté 0𝐴 ) et ⋅
est une loi de composition interne sur 𝐴 vérifiant ∀ 𝑎, 𝑏, 𝑐 ∈ 𝐴 :
• associativité : (𝑎 ⋅ 𝑏) ⋅ 𝑐 = 𝑎 ⋅ (𝑏 ⋅ 𝑐)
• commutativité : 𝑎 ⋅ 𝑏 = 𝑏 ⋅ 𝑎
• élément neutre : il existe 1𝐴 ∈ 𝐴 tel que 1𝐴 ⋅ 𝑎 = 𝑎
• distributivité : 𝑎 ⋅ (𝑏 + 𝑐) = (𝑎 ⋅ 𝑏) + (𝑎 ⋅ 𝑐)
Définition : Un anneau unitaire commutatif (𝐴, +, ⋅) est nul si 𝐴 = {0𝐴 }.

Un anneau unitaire commutatif (𝐴, +, ⋅) est nul ssi 1𝐴 = 0𝐴 .
Soit (𝐴, +, ⋅) un anneau unitaire commutatif.
𝑛 fois
def def
Puissances positives ou nulle : Si 𝑎 ∈ 𝐴 et 𝑛 ∈ ℕ∗ alors 𝑎𝑛 = 𝑎⏞
⋅ ⋯ ⋅ 𝑎. On définit en plus 𝑎0 = 1𝐴 .
Définition : 𝐵 est un sous-anneau de (𝐴, +, ⋅) si • 𝐵 est un sous-groupe de (𝐴, +)
• ∀ 𝑏1 , 𝑏2 ∈ 𝐵, 𝑏1 ⋅ 𝑏2 ∈ 𝐵
• 1𝐴 ∈ 𝐵
⎧𝐵 ⊆ 𝐴
{
𝐵 est un sous-anneau de (𝐴, +, ⋅) ⟺ ⎨∀ 𝑏1 , 𝑏2 ∈ 𝐵 on a 𝑏1 + 𝑏2 , 𝑏1 ⋅ 𝑏2 ∈ 𝐵
{−1 ∈ 𝐵
⎩ 𝐴
Si 𝐵 est un sous-anneau d’un anneau (𝐴, +, ⋅) unitaire commutatif, alors (𝐵, +, ⋅) est un anneau unitaire
def def
commutatif pour les lois +, ⋅ ∶ 𝐵 × 𝐵 ⟶ 𝐵 avec 𝑏1 + 𝑏2 = 𝑏1 + 𝑏2 , 𝑏1 ⋅ 𝑏2 = 𝑏1 ⋅ 𝑏2 . De plus, 0𝐵 = 0𝐴 et
1𝐵 = 1𝐴 .
Produit direct : Si 𝑛 ∈ ℕ et (𝐴1 , +1 , ⋅1 ), … , (𝐴𝑛 , +𝑛 , ⋅𝑛 ) sont des anneaux unitaires commutatifs, alors
(𝐴1 × ⋯ × 𝐴𝑛 , +, ⋅) est un anneau unitaire commutatif pour les lois
def
(𝑎1 , … , 𝑎𝑛 ) + (𝑏1 , … , 𝑏𝑛 ) = (𝑎1 +1 𝑏1 , … , 𝑎𝑛 +𝑛 𝑏𝑛 ) (élément neutre (0𝐴1 , … , 0𝐴𝑛 ))
def
(𝑎1 , … , 𝑎𝑛 ) ⋅ (𝑏1 , … , 𝑏𝑛 ) = (𝑎1 ⋅1 𝑏1 , … , 𝑎𝑛 ⋅𝑛 𝑏𝑛 ) (élément neutre (1𝐴1 , … , 1𝐴𝑛 ))
Soient (𝐴1 , +1 , ⋅1 ) et (𝐴2 , +2 , ⋅2 ) deux anneaux unitaires commutatifs. Une application 𝑓 ∶ 𝐴1 ⟶ 𝐴2 est un
homomorphisme d’anneaux si • ∀ 𝑎, 𝑏 ∈ 𝐴1 , 𝑓(𝑎 +1 𝑏) = 𝑓(𝑎) +2 𝑓(𝑏)
• ∀ 𝑎, 𝑏 ∈ 𝐴1 , 𝑓(𝑎 ⋅1 𝑏) = 𝑓(𝑎) ⋅2 𝑓(𝑏)
• 𝑓(1𝐴1 ) = 1𝐴2
Le noyau de 𝑓 est ker 𝑓 = { 𝑎 ∈ 𝐴1 ∣ 𝑓(𝑎) = 0𝐴2 }.
Un isomorphisme d’anneaux est un homomorphisme d’anneaux bijectif.
def
Notation : 𝐴1 ≃ 𝐴2 ⟺ ∃ 𝑓 ∶ 𝐴1 ⟶ 𝐴2 homomorphisme d’anneaux bijectif. On dit que 𝐴1 est isomorphe
ann
à 𝐴2 en tant qu’anneau. “Être isomorphe en tant qu’anneau” est une relation d’équivalence.
Si 𝑓 ∶ 𝐴1 ⟶ 𝐴2 est un homomorphisme d’anneaux injectif, on a un isomorphisme d’anneaux 𝐴1 ≃ im 𝑓,
ann
ce qui permet de les identifier, et de considérer 𝐴1 comme un sous-anneau de 𝐴2 .
Notations :
def
Homann (𝐴1 , 𝐴2 ) = { 𝑓 ∶ 𝐴1 ⟶ 𝐴2 ∣ 𝑓 est un homomorphisme d’anneaux }.
def
L’ensemble des endomorphismes de 𝐴 est Endann (𝐴) = Homann (𝐴, 𝐴).
def
L’ensemble des automorphismes de 𝐴 est Autann (𝐴) = { 𝑓 ∈ Endann (𝐴) ∣ 𝑓 est bijectif }.
def min{ 𝑛 ∈ ℕ∗ ∣ ∀ 𝑎 ∈ 𝐴, 𝑛 𝑎 = 0𝐴 } s’il existe
La charactéristique d’un anneau (𝐴, +, ⋅) est char 𝐴 = {
0 sinon.
𝑛 fois
(rappel : 𝑛 𝑎 = 𝑎
⏞⏞+⏞⋯⏞ +⏞𝑎).
Si 1𝐴 est d’ordre fini dans le groupe additif (𝐴, +), alors char 𝐴 est égal à cet ordre ; sinon, char 𝐴 = 0.
3.3 Idéaux
𝐼 est un idéal de 𝐴 si • 𝐼 est un sous-groupe de (𝐴, +)
• ∀ 𝑖 ∈ 𝐼, ∀ 𝑎 ∈ 𝐴, 𝑖 ⋅ 𝑎 ∈ 𝐼 (absorption)
𝐼 est un idéal de 𝐴 ⟺ (∀ 𝑖1 , 𝑖2 ∈ 𝐼, 𝑖1 + 𝑖2 ∈ 𝐼 et ∀ 𝑖 ∈ 𝐼, ∀ 𝑎 ∈ 𝐴, 𝑖 ⋅ 𝑎 ∈ 𝐼)
Intersection : L’intersection d’une famille non vide d’idéaux de 𝐴 est un idéal de 𝐴.
On peut rajouter la convention que l’intersection de la famille vide d’idéaux de 𝐴 est égale à 𝐴.

Si 𝐸 ⊆ 𝐴, l’idéal de 𝐴 engendré par 𝐸 est ⟨𝐸⟩ = ⋂ 𝐼.
𝐼⊇𝐸
𝐼 idéal de 𝐴
Quel que soit l’ensemble 𝐸 ⊆ 𝐴, on a que ⟨𝐸⟩ est un idéal de 𝐴.
Notation : ⟨𝑎1 , … , 𝑎𝑛 ⟩ = ⟨{𝑎1 , … , 𝑎𝑛 }⟩.
Un idéal 𝐼 de 𝐴 est principal s’il existe 𝑎 ∈ 𝐴 tel que 𝐼 = ⟨𝑎⟩.
Un anneau est principal si tous ses idéaux sont principaux.
Union : L’union d’idéaux n’est pas un idéal en général.
Somme : Si ( 𝐼𝑗 ∣ 𝑗 ∈ 𝐽 ) est une famille d’idéaux de 𝐴 indexée par 𝐽, on définit leur somme par
∑ 𝐼𝑗 = ⟨⋃ 𝐼𝑗 ⟩.
𝑗∈𝐽 𝑗∈𝐽
Si 𝑛 ∈ ℕ et 𝐼1 , … , 𝐼𝑛 sont des idéaux de 𝐴, alors 𝐼1 + ⋯ + 𝐼𝑛 = { 𝑖1 + ⋯ + 𝑖𝑛 ∣ 𝑖𝑗 ∈ 𝐼𝑗 }.
Produit fini : Si 𝑛 ∈ ℕ et 𝐼1 , … , 𝐼𝑛 sont des idéaux de 𝐴, alors 𝐼1 ⋅ ⋯ ⋅ 𝐼𝑛 = ⟨{ 𝑖1 ⋅ ⋯ ⋅ 𝑖𝑛 ∣ 𝑖𝑗 ∈ 𝐼𝑗 }⟩.
(L’ensemble { 𝑖1 ⋅ ⋯ ⋅ 𝑖𝑛 ∣ 𝑖𝑗 ∈ 𝐼𝑗 } n’est pas forcément un idéal de 𝐴.)
def
Si 𝐼 est un idéal de 𝐴, la relation 𝑥 ℛ 𝑦 ⟺ 𝑥 + 𝐼 = 𝑦 + 𝐼 ⟺ 𝑥 − 𝑦 ∈ 𝐼 est une relation d’équivalence
sur 𝐴. L’anneau quotient 𝐴 sur 𝐼 est (𝐴/𝐼, +, ⋅) où 𝐴/𝐼 = 𝐴/ℛ = { [𝑎]𝐼 ∣ 𝑎 ∈ 𝐴 } avec [𝑎]𝐼 = 𝑎 + 𝐼 et
[𝑎1 ]𝐼 + [𝑎2 ]𝐼 = [𝑎1 + 𝑎2 ]𝐼 et [𝑎1 ]𝐼 ⋅ [𝑎2 ]𝐼 = [𝑎1 ⋅ 𝑎2 ]𝐼 .
Si 𝐼 est un idéal de 𝐴, alors (𝐴/𝐼, +, ⋅) est un anneau et l’application 𝜋 ∶ 𝐴 ⟶ 𝐴/𝐼 avec 𝜋(𝑎) = [𝑎]𝐼 est un
homomorphisme d’anneaux surjectif, avec ker 𝜋 = 𝐼.
Soit 𝑓 ∶ 𝐴1 ⟶ 𝐴2 un homomorphisme d’anneaux unitaires commutatifs. Alors

𝐵1 sous-anneau de 𝐴1 ⟹ 𝑓(𝐵1 ) sous-anneau de 𝐴2
En particulier, im 𝑓 est un sous-anneau de 𝐴2
𝐵2 sous-anneau de 𝐴2 ⟹ 𝑓 −1 (𝐵2 ) sous-anneau de 𝐴1
𝐼1 idéal de 𝐴1 ⟹
| 𝑓(𝐼1 ) idéal de 𝐴2
𝐼1 idéal de 𝐴1 ⟹ 𝑓(𝐼1 ) idéal de im 𝑓
𝐼2 idéal de 𝐴2 ⟹ 𝑓 −1 (𝐼2 ) idéal de 𝐴1
En particulier, ker 𝑓 est un idéal de 𝐴1
𝑓 est injectif ⟺ ker 𝑓 = {0𝐴1 }
Théorème 3.3.1 (Premier théorème d’isomorphisme pour les anneaux unitaires commutatifs)
Si 𝑓 ∶ 𝐴1 ⟶ 𝐴2 est un homomorphisme d’anneaux unitaires commutatifs, on a un isomorphisme d’anneaux
𝑓 ∶ (𝐴1 / ker 𝑓) ⟶ im 𝑓 avec 𝑓([𝑎]ker 𝑓 ) = 𝑓(𝑎).
Dans un anneau 𝐴 :
𝔭 est un idéal premier de 𝐴 si 𝔭 est un idéal de 𝐴, 𝔭 ≠ 𝐴
∀ 𝑎, 𝑏 ∈ 𝐴, 𝑎𝑏 ∈ 𝔭 ⟹ (𝑎 ∈ 𝑝 ou 𝑏 ∈ 𝑝).
𝔪 est un idéal maximal de 𝐴 si
𝔪 est un idéal de 𝐴, 𝔪 ≠ 𝐴
pour tout 𝐼 idéal de 𝐴 on a 𝔪 ⊆ 𝐼 ≠ 𝐴 ⟹ 𝔪 = 𝐼.
𝔪 idéal maximal de 𝐴 ⟹ 𝔪 idéal premier de 𝐴.
3.4 Divisibilité dans un anneau commutatif

Définitions : Si 𝑎, 𝑏 ∈ 𝐴, on dit que
𝑎 divise 𝑏 ⎫
} def
𝑏 est un multiple de 𝑎 ⟺ ∃ 𝑐 ∈ 𝐴, 𝑎 ⋅ 𝑐 = 𝑏.
⎬
}
𝑎\𝑏 ⎭
Notation à éviter : 𝑎 | 𝑏.

Pour 𝑎, 𝑏, 𝑐 ∈ 𝐴 on a ∀ 𝑎 ∈ 𝐴, 𝑎 \ 𝑎 𝑎 \ 𝑏 ⟹ ±𝑎 \ ±𝑏
∀ 𝑎 ∈ 𝐴, 𝑎 \ 0𝐴 0𝐴 \ 𝑏 ⟺ 𝑏 = 0 𝐴 𝑎 \ 𝑏 et 𝑏 \ 𝑐 ⟹ 𝑎 \ 𝑐
∀ 𝑏 ∈ 𝐴, 1𝐴 \ 𝑏 𝑎 \ 𝑏 et 𝑎 \ 𝑐 ⟹ 𝑎 \ (𝑏 + 𝑐)
On dit que 𝑎 est un diviseur de zéro si 𝑎 ∈ 𝐴∗ et qu’il existe 𝑏 ∈ 𝐴∗ tel que 𝑎 ⋅ 𝑏 = 0𝐴 .

Ne pas confondre “𝑎 divise 0𝐴 ” (qui est vrai pour tout 𝑎 ∈ 𝐴) et “𝑎 est un diviseur de zéro”.
On dit que 𝑎 est une unité ou inversible de 𝐴 si 𝑎 \ 1𝐴 , c’est-à-dire, s’il existe 𝑏 ∈ 𝐴 tel que 𝑎 ⋅ 𝑏 = 1𝐴 .
L’ensemble des inversibles de 𝐴 est noté 𝐴× .
Si (𝐴, +, ⋅) est un anneau unitaire commutatif, on a que (𝐴× , ⋅) est un groupe abélien de neutre 1𝐴 .
Notation à éviter : 𝐴∗ = 𝐴× (ici 𝐴∗ = 𝐴 r {0𝐴 }).
Un diviseur de zéro n’est pas une unité et vice-versa.
Définition : 𝑎 et 𝑏 sont associés dans 𝐴, noté 𝑎 ∼ 𝑏, si 𝑎, 𝑏 ∈ 𝐴 et 𝑎 \ 𝑏 et 𝑏 \ 𝑎 dans 𝐴.
“Être associé” est une relation d’équivalence dans 𝐴.
∃ 𝑢 ∈ 𝐴× , 𝑎 = 𝑢 ⋅ 𝑏 ⟹ 𝑎 ∼ 𝑏.
𝑎⋅𝑏 =𝑎⋅𝑐 ⎫
}
Pour 𝑎, 𝑏, 𝑐 ∈ 𝐴 on a 𝑎≠0
⎬ ⟹ 𝑏=𝑐
𝑎 n’est pas un diviseur de zéro }
⎭
𝑎\𝑏 ⎫
}
Pour 𝑎, 𝑏 ∈ 𝐴 on a 𝑎≠0 ⟹ ∃! 𝑐 ∈ 𝐴, 𝑎 ⋅ 𝑐 = 𝑏
⎬
𝑎 n’est pas un diviseur de zéro }
⎭
Définitions :
𝑝 est un premier de 𝐴 si 𝑝 ∈ 𝐴, 𝑝 ≠ 0𝐴 , 𝑝 ∉ 𝐴×
∀ 𝑎, 𝑏 ∈ 𝐴, 𝑝 \ 𝑎𝑏 ⟹ (𝑝 \ 𝑎 ou 𝑝 \ 𝑏)
𝑝 est un irréductible de 𝐴 si 𝑝 ∈ 𝐴, 𝑝 ≠ 0𝐴 , 𝑝 ∉ 𝐴×
∀ 𝑎 ∈ 𝐴, 𝑎 \ 𝑝 ⟹ (𝑎 ∼ 1𝐴 ou 𝑎 ∼ 𝑝)
Soit 𝑝 ∈ 𝐴. Alors 𝑝 est un premier de 𝐴 ⟺ ⟨𝑝⟩ est un idéal premier de 𝐴.
3.5 Anneaux intègres

Définition : Un anneau est intègre s’il est non nul, unitaire, commutatif et sans diviseur de zéro.
Si (𝐴, +, ⋅) est un anneau intègre, alors
𝑎 ⋅ 𝑏 = 0𝐴 ⟺ (𝑎 = 0𝐴 ou 𝑏 = 0𝐴 )
(𝑎 ⋅ 𝑏 = 𝑎 ⋅ 𝑐 et 𝑎 ≠ 0) ⟹ 𝑏 = 𝑐
(𝑎 \ 𝑏 et 𝑎 ≠ 0) ⟹ ∃! 𝑐 ∈ 𝐴, 𝑎 ⋅ 𝑐 = 𝑏
𝑎 ∼ 𝑏 ⟺ (∃ 𝑢 ∈ 𝐴× , 𝑎 = 𝑢 ⋅ 𝑏)
Tout sous-anneau d’un anneau intègre est intègre.
Proposition 3.5.1
Si 𝐴 est intègre, alors 𝑝 premier de 𝐴 ⟹ 𝑝 irréductible de 𝐴.
DÉMONSTRATION. On a 𝑎 \ 𝑝 ⟹ 𝑝 = 𝑎𝑏 ⟹ 𝑝 \ 𝑎𝑏 ⟹ (𝑝 \ 𝑎 ou 𝑝 \ 𝑏).
Si 𝑝 \ 𝑎, alors 𝑎 ∼ 𝑝.
Si 𝑝 \| 𝑎, alors 𝑝 \ 𝑏 ⟹ 𝑏 = 𝑝𝑐 ⟹ 𝑝(1𝐴 − 𝑎𝑐) = 0𝐴 . Or 𝐴 est intègre et 𝑝 ≠ 0𝐴 donc 1𝐴 − 𝑎𝑐 = 0𝐴 ⟹
𝑎𝑐 = 1𝐴 ⟹ 𝑎 ∼ 1𝐴 .

Proposition 3.5.2
Soit 𝐴 un anneau non nul, unitaire, commutatif. Alors
𝐴 est un anneau intègre ⟺ l’idéal ⟨0𝐴 ⟩ est premier.
3.6 Corps commutatifs

(𝐴, +, ⋅) est un corps commutatif si c’est un anneau non nul, unitaire, commutatif et tel que 𝐴× = 𝐴∗ .
Attention : En anglais, “field” signifie “corps commutatif”.
Un corps commutatif 𝕜 a exactement 2 idéaux, à savoir, {0𝕜 } = ⟨0𝕜 ⟩ et 𝕜 = ⟨𝕜× ⟩.
Tout corps commutatif est un anneau intègre.
Tout anneau intègre fini est un corps commutatif.
Soit 𝐴 un anneau non nul, unitaire, commutatif. Alors
• Un idéal 𝔭 de 𝐴 est premier ssi 𝐴/𝔭 est un anneau intègre.
• Un idéal 𝔪 de 𝐴 est maximal ssi 𝐴/𝔪 est un corps commutatif.
3.7 Anneaux de polynômes

Soit (𝐴, +, ⋅) un anneau non nul, unitaire, commutatif.
On considère l’ensemble 𝑆(𝐴) des suites presque nulles à coefficients dans 𝐴.
Pour (𝑎𝑛 )𝑛∈ℕ , (𝑏𝑛 )𝑛∈ℕ ∈ 𝑆(𝐴) on définit
(𝑎𝑛 )𝑛∈ℕ + (𝑏𝑛 )𝑛∈ℕ = (𝑐𝑛 )𝑛∈ℕ avec ∀𝑛 ∈ ℕ, 𝑐𝑛 = 𝑎𝑛 + 𝑏𝑛
𝑛
(𝑎𝑛 )𝑛∈ℕ ⋅ (𝑏𝑛 )𝑛∈ℕ = (𝑑𝑛 )𝑛∈ℕ avec ∀𝑛 ∈ ℕ, 𝑑𝑛 = ∑ 𝑎𝑖 𝑏𝑛−𝑖
𝑖=0
Alors (𝑆(𝐴), +, ⋅) est un anneau non nul, unitaire, commutatif, infini.
On a 0𝑆(𝐴) = (0𝐴 )𝑛∈ℕ , la suite nulle, et 1𝑆(𝐴) = (1𝐴 , 0𝐴 , 0𝐴 , 0𝐴 , …).
L’application 𝜄 ∶ 𝐴 ⟶ 𝑆(𝐴) définie par 𝜄(𝑎) = (𝑎, 0𝐴 , 0𝐴 , 0𝐴 , …) est un homomorphisme d’anneaux injectif,
ce qui permet de considérer 𝐴 comme un sous-anneau de 𝑆(𝐴). Pour 𝑎 ∈ 𝐴 et (𝑎𝑛 )𝑛∈ℕ ∈ 𝑆(𝐴) on identifiera
donc 𝑎 avec 𝜄(𝑎), ce qui permet d’écrire 𝑎 ⋅ (𝑎𝑛 )𝑛∈ℕ au lieu de 𝜄(𝑎) ⋅ (𝑎𝑛 )𝑛∈ℕ .
Soit 𝑋 = (0𝐴 , 1𝐴 , 0𝐴 , 0𝐴 , 0𝐴 , …). Alors 𝑋 ∈ 𝑆(𝐴).
Si (𝑎𝑛 )𝑛∈ℕ ∈ 𝑆(𝐴), on a (𝑎𝑛 )𝑛∈ℕ = 𝑎0 ⋅ 1𝐴 + 𝑎1 ⋅ 𝑋 + 𝑎2 ⋅ 𝑋 2 + ⋯ + 𝑎𝑑 ⋅ 𝑋 𝑑 où 𝑑 = max{ 𝑛 ∈ ℕ ∣ 𝑎𝑛 ≠ 0𝐴 }
(ce maximum existe car la suite est presque nulle).
Notation et définition : 𝐴[𝑋] = 𝑆(𝐴) est l’anneau de polynômes à 1 variable à coefficients dans 𝐴. Comme
indiqué, on le voit comme un sur-anneau de 𝐴.
𝑑
Ceci permet d’écrire 𝐴[𝑋] = { ∑ 𝑎𝑖 ⋅ 𝑋 𝑖 𝑑 ∈ ℕ, 𝑎𝑖 ∈ 𝐴 } (rappel : 𝑋 0 = 1𝐴[𝑋] = (1𝐴 , 0𝐴 , 0𝐴 , 0𝐴 , …)).
𝑖=0
𝑑
Composition : Si 𝑃 (𝑋), 𝑄(𝑋) ∈ 𝐴[𝑋] avec 𝑃 (𝑋) = ∑ 𝑎𝑛 ⋅ 𝑋 𝑛 et 𝑄(𝑋) = ∑ 𝑏𝑖 ⋅ 𝑋 𝑖 , on définit
𝑛∈ℕ 𝑖=0
𝑑
𝑄(𝑃 (𝑋)) = ∑ 𝑏𝑖 ⋅ (𝑃 (𝑋))𝑖 (avec (𝑃 (𝑋))0 = 1𝐴 ).
𝑖=0
Définition : Si 𝑃 (𝑋) ∈ 𝐴[𝑋], 𝑃 (𝑋) = ∑ 𝑎𝑛 ⋅ 𝑋 𝑛 , alors le degré de 𝑃 (𝑋) est

𝑛∈ℕ
def
deg 𝑃 (𝑋) = max({−∞} ∪ { 𝑛 ∈ ℕ ∣ 𝑎𝑛 ≠ 0𝐴 }).
On a deg 𝑃 (𝑋) = −∞ ⟺ 𝑃 (𝑋) = 0(𝑋) = 0𝐴[𝑋] , le polynôme nul.
Les éléments 𝑎 ∈ 𝐴 sont les polynômes constants, de degré 0 (si 𝑎 ≠ 0𝐴 ) ou −∞ (si 𝑎 = 0𝐴 ).

𝑑
Si 𝑃 (𝑋) ∈ 𝐴[𝑋] est non nul de degré 𝑑, il s’écrit de façon unique 𝑃 (𝑋) = ∑ 𝑎𝑖 ⋅ 𝑋 𝑖 avec 𝑎𝑖 ∈ 𝐴, 𝑎𝑑 ≠ 0𝐴 .
𝑖=0
Définitions :
def
• Le coefficient dominant de 𝑃 (𝑋) est lc(𝑃 (𝑋)) = 𝑎𝑑 .
def
• Le monôme dominant de 𝑃 (𝑋) est lm(𝑃 (𝑋)) = 𝑋 𝑑 .
def
• Le terme dominant de 𝑃 (𝑋) est lt(𝑃 (𝑋)) = 𝑎𝑑 𝑋 𝑑 .
Attention : lc(0(𝑋)), lm(0(𝑋)) et lt(0(𝑋)) ne sont pas définis.
Un polynôme 𝑃 (𝑋) ∈ 𝐴[𝑋] est unitaire s’il est non nul et lc(𝑃 (𝑋)) = 1.
∀ 𝑎(𝑋), 𝑏(𝑋) ∈ 𝐴[𝑋] on a
deg(𝑎(𝑋) + 𝑏(𝑋)) ⩽ max{deg 𝑎(𝑋), deg 𝑏(𝑋)}
deg 𝑎(𝑋) ≠ deg 𝑏(𝑋) ⟹ deg(𝑎(𝑋) + 𝑏(𝑋)) = max{deg 𝑎(𝑋), deg 𝑏(𝑋)}
deg(𝑎(𝑋) ⋅ 𝑏(𝑋)) ⩽ deg 𝑎(𝑋) + deg 𝑏(𝑋)
lc(𝑎(𝑋)) défini et non diviseur de zéro ⟹ deg(𝑎(𝑋) ⋅ 𝑏(𝑋)) = deg 𝑎(𝑋) + deg 𝑏(𝑋)
Si 𝐴 est un anneau intègre, alors
∀ 𝑎(𝑋), 𝑏(𝑋) ∈ 𝐴[𝑋], deg(𝑎(𝑋) ⋅ 𝑏(𝑋)) = deg 𝑎(𝑋) + deg 𝑏(𝑋).
𝐴[𝑋] est un anneau intègre.
(𝐴[𝑋])× = 𝐴× (donc pas de nouveaux inversibles).
Évaluation polynomiale :
Pour 𝑃 (𝑋) ∈ 𝐴[𝑋] avec 𝑃 (𝑋) = ∑ 𝑐𝑛 ⋅ 𝑋 𝑛 on définit l’application 𝑃 ∶ 𝐴 ⟶ 𝐴 par 𝑃 (𝑎) = ∑ 𝑐𝑛 ⋅ 𝑎𝑛 .
𝑛∈ℕ 𝑛∈ℕ
Pour 𝑎 ∈ 𝐴 on définit l’évaluation ev𝑎 ∶ 𝐴[𝑋] ⟶ 𝐴 par ev𝑎 (𝑃 (𝑋)) = 𝑃 (𝑎).
Quel que soit 𝑎 ∈ 𝐴, on a que ev𝑎 est un homomorphisme d’anneaux surjectif vérifiant ∀ 𝑏 ∈ 𝐴, ev𝑎 (𝑏) = 𝑏.
def
Définition : 𝑎 est une racine de 𝑃 (𝑋) ∈ 𝐴[𝑋] dans 𝐴 ⟺ (𝑎 ∈ 𝐴 et 𝑃 (𝑎) = 0𝐴 ).
3.7.1 Dérivée formelle
On considère toujours (𝐴, +, ⋅) un anneau non nul, unitaire, commutatif.

𝑚
Soit 𝑓(𝑋) ∈ 𝐴[𝑋], on l’écrit 𝑓(𝑋) = ∑ 𝑎𝑖 𝑋 𝑖 .
𝑖=0
𝑚
Définition : La dérivée (formelle) de 𝑓(𝑋) est 𝑓 ′ (𝑋) = ∑ 𝑖 𝑎𝑖 𝑋 𝑖−1 .
𝑖=1
Propriétés :
On a deg 𝑓 ′ (𝑋) ⩽ deg 𝑓(𝑋) − 1 (où −∞ − 1 = −∞).
En particulier, 𝑓(𝑋) ∈ 𝐴 ⟹ 𝑓 ′ (𝑋) = 0(𝑋).
Si 𝐴 est intègre et 𝑓(𝑋) ∉ 𝐴, alors deg 𝑓 ′ (𝑋) = deg 𝑓(𝑋) − 1.
Pour 𝑎, 𝑏 ∈ 𝐴 et 𝑓(𝑋), 𝑔(𝑋) ∈ 𝐴[𝑋] on a (𝑎𝑓(𝑋) + 𝑏𝑔(𝑋))′ = 𝑎𝑓 ′ (𝑋) + 𝑏𝑔′ (𝑋)
(𝑓(𝑋)𝑔(𝑋))′ = 𝑓 ′ (𝑋)𝑔(𝑋) + 𝑓(𝑋)𝑔′ (𝑋)
3.7.2 Division euclidienne dans un anneaux de polynômes
On considère toujours (𝐴, +, ⋅) un anneau non nul, unitaire, commutatif.

Soient 𝑎(𝑋), 𝑏(𝑋) ∈ 𝐴[𝑋]. Faire la division euclidienne de 𝑎(𝑋) par 𝑏(𝑋) dans 𝐴[𝑋] consiste à trouver
𝑞(𝑋), 𝑟(𝑋) ∈ 𝐴[𝑋] tels que 𝑎(𝑋) = 𝑏(𝑋)𝑞(𝑋) + 𝑟(𝑋) et deg 𝑟(𝑋) < deg 𝑏(𝑋).
Il est clair que si 𝑏(𝑋) est nul, cela est impossible. Il faut donc 𝑏(𝑋) ≠ 0(𝑋).
Mais cela ne suffit pas. Par exemple, pour l’anneau 𝐴 = ℤ, la division euclidienne de 𝑎(𝑋) = 3𝑋 2 − 1 par
𝑏(𝑋) = 5𝑋 + 1 ≠ 0 dans ℤ[𝑋] est impossible.
Cependant, si le coefficient dominant de 𝑏(𝑋) est un inversible de 𝐴 alors on peut toujours faire la division
euclidienne (proposition ci-après).

Lemme 3.7.1 Soit 𝐴 un anneau non nul, unitaire, commutatif, et soit 𝑎(𝑋) ∈ 𝐴[𝑋]∗ .
Alors lc(𝑎(𝑋)) n’est pas un diviseur de zéro dans 𝐴 ⟹ 𝑎(𝑋) n’est pas un diviseur de zéro dans 𝐴[𝑋].
DÉMONSTRATION. Soient 𝑎(𝑋), 𝑏(𝑋) ∈ 𝐴[𝑋]∗ , et soient 𝑑 = deg 𝑎(𝑋) ∈ ℕ, 𝑒 = deg 𝑏(𝑋) ∈ ℕ. On écrit
𝑑 𝑒
𝑎(𝑋) = ∑ 𝑎𝑖 𝑋 𝑖 et 𝑏(𝑋) = ∑ 𝑏𝑗 𝑋 𝑗 , on a lc(𝑎(𝑋)) = 𝑎𝑑 et lc(𝑏(𝑋)) = 𝑏𝑒 .
𝑖=0 𝑗=0
Contraposée : Si 𝑎(𝑋)𝑏(𝑋) = 0(𝑋), alors 𝑎𝑑 𝑏𝑒 = 0𝐴 .
Proposition 3.7.2 (division euclidienne dans un anneau de polynômes)

Soit 𝐴 un anneau non nul, unitaire, commutatif.
Soit 𝑏(𝑋) ∈ 𝐴[𝑋] avec 𝑏(𝑋) ≠ 0 et lc(𝑏(𝑋)) ∈ 𝐴× .
Alors pour tout 𝑎(𝑋) ∈ 𝐴[𝑋] il existe un unique (𝑞(𝑋), 𝑟(𝑋)) ∈ 𝐴[𝑋] × 𝐴[𝑋] tel que
𝑎(𝑋) = 𝑏(𝑋)𝑞(𝑋) + 𝑟(𝑋) et deg 𝑟(𝑋) < deg 𝑏(𝑋).
DÉMONSTRATION.
Existence : Preuve algorithmique.
𝛿
Soit 𝛿 = deg 𝑏(𝑋) ∈ ℕ. Alors 𝑏(𝑋) s’écrit 𝑏(𝑋) = ∑ 𝑏𝑖 𝑋 𝑖 avec lc(𝑏(𝑋)) = 𝑏𝛿 ∈ 𝐴× . Soit 𝑢 = 𝑏𝛿−1 .
𝑖=0
Condition d’arrêt : Si 𝑑0 < 𝛿, on prend 𝑞0 (𝑋) = 0(𝑋) et 𝑟(𝑋) = 𝑎(𝑋).
Si 𝑑 ⩾ 𝛿, on prend 𝑎
̃(𝑋) = 𝑎(𝑋) − 𝑢 lc(𝑎(𝑋))𝑋 𝑑−𝛿 𝑏(𝑋) ∈ 𝐴[𝑋].
Comme lm(𝑎(𝑋)) = lm(𝑢 lc(𝑎(𝑋))𝑋 𝑑−𝛿 𝑏(𝑋)), on a deg 𝑎 ̃(𝑋) < deg 𝑎(𝑋), et l’on recommence avec 𝑎
̃(𝑋).
On a ainsi, en notant 𝑑𝑖 = deg 𝑎̃𝑖 (𝑋) :
𝑎
̃0 (𝑋) = 𝑎(𝑋)
𝑎 ̃0 (𝑋) − 𝑢 lc(̃
̃1 (𝑋) = 𝑎 𝑎0 (𝑋))𝑋 𝑑0 −𝛿 𝑏(𝑋)
⋮
𝑎 ̃𝑖 (𝑋) − 𝑢 lc(̃
̃𝑖+1 (𝑋) = 𝑎 𝑎𝑖 (𝑋))𝑋 𝑑𝑖 −𝛿 𝑏(𝑋)
⋮
𝑎 ̃𝑠 (𝑋) − 𝑢 lc(̃
̃𝑠+1 (𝑋) = 𝑎 𝑎𝑠 (𝑋))𝑋 𝑑𝑠 −𝛿 𝑏(𝑋)
avec et 𝑑0 > 𝑑1 > ⋯ > 𝑑𝑠 > 𝛿 et 𝑑𝑠+1 ⩽ 𝛿 (arrêt).
𝑠
En remontant, cela donne 𝑎 ̃0 (𝑋) − 𝑢 ∑ lc(̃
̃𝑠+1 (𝑋) = 𝑎 𝑎𝑖 (𝑋))𝑋 𝑑𝑖 −𝛿 𝑏(𝑋).
𝑖=0
𝑠
En prenant 𝑞(𝑋) = 𝑢 ∑ lc(̃
𝑎𝑖 (𝑋))𝑋 𝑑𝑖 −𝛿
et 𝑟(𝑋) = 𝑎
̃𝑠+1 on a bien 𝑎(𝑋) = 𝑏(𝑋)𝑞(𝑋) avec 𝑞(𝑋), 𝑟(𝑋) ∈ 𝐴[𝑋]
𝑖=0
et deg 𝑟(𝑋) < deg 𝑏(𝑋).
Unicité :
Si 𝑎(𝑋) = 𝑏(𝑋)𝑞1 (𝑋) + 𝑟1 (𝑋) = 𝑏(𝑋)𝑞2 (𝑋) + 𝑟2 (𝑋) avec deg 𝑟𝑖 (𝑋) < deg 𝑏(𝑋), alors
𝑟1 (𝑋) − 𝑟2 (𝑋) = 𝑏(𝑋)(𝑞2 (𝑋) − 𝑞1 (𝑋)) avec deg(𝑟1 (𝑋) − 𝑟2 (𝑋)) ⩽ max{deg 𝑟1 (𝑋), deg 𝑟2 (𝑋)} < deg 𝑏(𝑋).
On a donc deg 𝑏(𝑋) > deg(𝑟1 (𝑋) − 𝑟2 (𝑋)) = deg(𝑏(𝑋)(𝑞2 (𝑋) − 𝑞1 (𝑋))) = deg 𝑏(𝑋) + deg(𝑞2 (𝑋) − 𝑞1 (𝑋))
(car lc(𝑏(𝑋)) n’est pas un diviseur de zéro).
Or si 𝑞1 (𝑋) ≠ 𝑞2 (𝑋) alors deg(𝑞2 (𝑋) − 𝑞1 (𝑋)) ⩾ 0, ce qui donne deg 𝑏(𝑋) > deg 𝑏(𝑋), impossible.
Ainsi, 𝑞1 (𝑋) = 𝑞2 (𝑋) et 𝑟1 (𝑋) = 𝑎(𝑋) − 𝑏(𝑋)𝑞1 (𝑋) = 𝑎(𝑋) − 𝑏(𝑋)𝑞2 (𝑋) = 𝑟2 (𝑋).
Proposition 3.7.3 Soit 𝐴 un anneau non nul, unitaire, commutatif, et soient 𝑓(𝑋) ∈ 𝐴[𝑋]∗ et 𝑎 ∈ 𝐴.
Alors 𝑓(𝑎) = 0𝐴 ⟺ (𝑋 − 𝑎) \ 𝑓(𝑋) dans 𝐴[𝑋].
DÉMONSTRATION. Puisque 𝑋 − 𝑎 ∈ 𝐴[𝑋] est unitaire, on peut faire la division euclidienne de 𝑓(𝑋) par
𝑋 − 𝑎, on trouve 𝑓(𝑋) = (𝑋 − 𝑎)𝑞(𝑋) + 𝑟(𝑋) avec deg 𝑟(𝑋) < deg(𝑋 − 𝑎) = 1 donc 𝑟(𝑋) = 𝑏 ∈ 𝐴,
c’est-à-dire, 𝑓(𝑋) = (𝑋 − 𝑎)𝑞(𝑋) + 𝑏 avec 𝑏 ∈ 𝐴.
Alors 𝑓(𝑎) = 0 ⟺ 𝑏 = 0 ⟺ (𝑋 − 𝑎) \ 𝑓(𝑋) dans 𝐴[𝑋].

Corollaire 3.7.4 Soit 𝐴 un anneau intègre, et soit 𝑓(𝑋) ∈ 𝐴[𝑋].
Si 𝑓(𝑋) possède 𝑚 racines distinctes 𝑎1 , … , 𝑎𝑚 dans 𝐴, alors (𝑋 − 𝑎1 ) ⋯ (𝑋 − 𝑎𝑚 ) \ 𝑓(𝑋) dans 𝐴[𝑋].
DÉMONSTRATION. Exercice (récurrence sur 𝑚 ∈ ℕ).
Corollaire 3.7.5 Soit 𝐴 un anneau intègre.

Alors 𝑓(𝑋) ∈ 𝐴[𝑋]∗ possède au plus deg 𝑓(𝑋) racines dans 𝐴.
DÉMONSTRATION. Conséquence du résultat précédent.
Soit 𝑓(𝑋) ∈ 𝐴[𝑋]∗ . Si 𝑎 est une racine de 𝑓(𝑋) dans 𝐴 on dit que
la multiplicité de 𝑎 comme racine de 𝑓(𝑋) est max{ 𝑚 ∈ ℕ∗ ∣ (𝑋 − 𝑎)𝑚 \ 𝑓(𝑋) }.
Ceci est bien défini : Soit 𝐸 = { 𝑚 ∈ ℕ∗ ∣ (𝑋 − 𝑎)𝑚 \ 𝑓(𝑋) }. Alors 1 ∈ 𝐸 donc 𝐸 ≠ ⌀. Comme 𝑓(𝑎) = 0𝐴 ,
on a 𝑓(𝑋) = (𝑋 − 𝑎)𝑓1 (𝑋) dans 𝐴[𝑋]. Si 𝑓1 (𝑋) ≠ 0𝐴 , alors 𝐸 = {1} et c’est fini.
Sinon, on a 𝑓1 (𝑋) = (𝑋 − 𝑎)𝑓2 (𝑋), etc. Comme deg 𝑓𝑖 (𝑋) = deg(𝑓(𝑋)) − 𝑖 (car 𝑋 − 𝑎 est unitaire), ce
processus s’arrête au bout d’au plus 𝑛 étapes.
Une racine simple est une racine de multiplicité 1.
Une racine multiple est une racine de multiplicité > 1.
Une racine double est une racine de multiplicité 2.
Une racine triple est une racine de multiplicité 3, etc.
3.8 Espaces vectoriels

Soit (𝕜, +, ⋅) un corps commutatif.
(𝑉 , +, ) est un espace vectoriel sur 𝕜 ou un 𝕜-espace vectoriel si
1) (𝑉 , +) est un groupe abélien. On note 0𝑉⃗ son élément neutre.
2) ∶ 𝕜 × 𝑉 ⟶ 𝑉 est une opération binaire vérifiant pour tous 𝜆, 𝜆1 , 𝜆2 ∈ 𝕜 et 𝑣,⃗ 𝑣1⃗ , 𝑣2⃗ ∈ 𝑉 :
• “Associativité” : (𝜆1 ⋅ 𝜆2 ) 𝑣 ⃗ = 𝜆1 (𝜆2 𝑣).
⃗
• “Élément neutre” : 1𝕜 𝑣 ⃗ = 𝑣.⃗
• “Distributivités” : (𝜆1 + 𝜆2 ) 𝑣 ⃗ = (𝜆1 𝑣)⃗ + (𝜆2 𝑣)⃗
𝜆 (𝑣1⃗ + 𝑣2⃗ ) = (𝜆 𝑣1⃗ ) + (𝜆 𝑣2⃗ )
Soient 𝑟 ∈ ℕ et 𝑣1⃗ , … , 𝑣𝑟⃗ ∈ 𝑉.
Une combinaison linéaire de 𝑣1⃗ , … , 𝑣𝑟⃗ ∈ 𝑉 est 𝜆1 𝑣1⃗ + ⋯ + 𝜆𝑟 𝑣𝑟⃗ avec 𝜆1 , … 𝜆𝑟 ∈ 𝕜. Une combinaison linéaire
a toujours un nombre fini de termes. La combinaison linéaire nulle de 𝑣1⃗ , … , 𝑣𝑟⃗ ∈ 𝑉 est 𝜆1 𝑣1⃗ + ⋯ + 𝜆𝑟 𝑣𝑟⃗
avec 𝜆1 = ⋯ = 𝜆𝑟 = 0𝕜 .
𝑣 ⃗ ∈ 𝑉 est combinaison linéaire de 𝑣1⃗ , … , 𝑣𝑟⃗ s’il existe 𝜆1 , … 𝜆𝑟 ∈ 𝕜 tels que 𝑣 ⃗ = 𝜆1 𝑣1⃗ + ⋯ + 𝜆𝑟 𝑣𝑟⃗ .
Soit 𝐹 = ( 𝑣𝑖⃗ ∣ 𝑖 ∈ 𝐼 ) une famille d’éléments de 𝑉.
Le sous-espace vectoriel de 𝑉 engendré par 𝐹 est l’ensemble des combinaisons linéaires d’éléments de 𝐹.
La famille 𝐹 est libre si la seule combinaison linéaire d’éléments de 𝐹 donnant 0𝑉⃗ est la combinaison linéaire
nulle.
La famille 𝐹 est une base de 𝑉 en tant que 𝕜-espace vectoriel si 𝐹 est libre et engendre 𝑉.
La dimension de 𝑉 en tant que 𝕜-espace vectoriel est dim𝕜 𝑉 = card ℬ, où ℬ est une base de 𝑉 en tant que
𝕜-espace vectoriel.
En dimension finie :
Si 𝑑 = dim𝕜 𝑉 ∈ ℕ, alors 𝑉 ≃ 𝕜𝑑 (isomorphisme de 𝕜-espaces vectoriels).
ev
En particulier, on a card 𝑉 = (card 𝕜)dim𝕜 𝑉 .

3.9 Les entiers : l’anneau ℤ
Du point de vue de l’addition, (ℤ, +) est un groupe monogène (ℤ = ⟨1⟩ = ⟨−1⟩), donc abélien. Il est infini
dénombrable.
Quel que soit 𝑎 ∈ ℤ, on a que 𝑎ℤ = { 𝑎𝑧 ∣ 𝑧 ∈ ℤ } = ⟨𝑎⟩ est un sous-groupe de ℤ. Et −𝑎ℤ = 𝑎ℤ.
Afin de montrer qu’il n’y a pas d’autres sous-groupes, on a besoin de la division euclidienne (et donc de la
multiplication).
En fait, la propriété fondamentale de l’anneau (ℤ, +, ⋅) est l’existence d’une division euclidienne (on dit que
c’est un anneau euclidien).
Pour commencer : L’anneau (ℤ, +, ⋅) est non nul, unitaire, commutatif, intègre et infini dénombrable.
Aussi : (ℤ, +, ⋅, ⩽) est un anneau totalement ordonné, car + et ⋅ sont compatibles avec ⩽ :
Dans ℤ on a :
• ∀ 𝑥1 , 𝑥2 , 𝑦, 𝑥1 ⩽ 𝑥2 ⟹ 𝑥1 + 𝑦 ⩽ 𝑥2 + 𝑦
• ∀ 𝑥, 𝑦, (0 ⩽ 𝑥 et 0 ⩽ 𝑦) ⟹ 0 ⩽ 𝑥 ⋅ 𝑦
3.9.1 Multiplication dans ℤ : divisibilité, primalité, factorisation

On note 𝑎𝑏 = 𝑎 ⋅ 𝑏.
Proposition 3.9.1 Soient 𝑎, 𝑏, 𝑐 ∈ ℤ. On a
±1 \ 𝑏 ∀ 𝑏 ∈ ℤ 𝑎 \ 1 ⟺ 𝑎 = ±1 𝑎 \ 𝑏 et 𝑎 \ 𝑐 ⟹ 𝑎 \ (𝑏 + 𝑐)
𝑎\0 ∀ 𝑎∈ℤ 0\𝑏 ⟺ 𝑏 =0 𝑎 \ 𝑏 et 𝑏 ≠ 0 ⟹ 1 ⩽ |𝑎| ⩽ |𝑏|
𝑎\𝑎 ∀ 𝑎∈ℤ 𝑎 \ 𝑏 ⟺ |𝑎| \ |𝑏| 𝑎 \ 𝑏 et 𝑏 \ 𝑎 ⟺ |𝑎| = |𝑏|
En particulier, ℤ× = {−1, 1} et 𝑎 ∼ 𝑏 ⟺ |𝑎| = |𝑏|.
Proposition 3.9.2 Dans ℤ on a (𝑎𝑏 = 𝑎𝑐 et 𝑎 ≠ 0) ⟹ 𝑏 = 𝑐.
DÉMONSTRATION. L’anneau ℤ est intègre.
Théorème 3.9.3 (Divison euclidienne dans ℤ)

Pour tout (𝑎, 𝑏) ∈ ℤ × ℤ∗ il existe un unique (𝑞, 𝑟) ∈ ℤ × ℤ tel que 𝑎 = 𝑏𝑞 + 𝑟 et 0 ⩽ 𝑟 < |𝑏|.
DÉMONSTRATION. L’anneau ℤ est intègre.
Pour (𝑎, 𝑏) ∈ ℤ × ℤ∗ on définit Quo(𝑎, 𝑏) = 𝑞, Rem(𝑎, 𝑏) = 𝑟, QuoRem(𝑎, 𝑏) = (𝑞, 𝑟).

Attention : La division euclidienne de 𝑎 par 𝑏 = 0 n’est pas définie.
Proposition 3.9.4 (Idéaux de ℤ)
On a :
1) Tout sous-groupe de (ℤ, +) est un idéal de l’anneau ℤ.
2) Tous les idéaux de ℤ sont 𝑎ℤ = ⟨𝑎⟩ avec 𝑎 ∈ ℤ.
3) Les idéaux de ℤ sont tous principaux, donc ℤ est un anneau principal.
4) On a 𝑎ℤ ⊆ 𝑏ℤ ⟺ 𝑏 \ 𝑎.
5) Ainsi, 𝑎ℤ = 𝑏ℤ ⟺ |𝑎| = |𝑏|, ce qui donne une bijection entre ℕ et l’ensemble des idéaux de ℤ, définie
par 𝑛 ↦ ⟨𝑛⟩.
DÉMONSTRATION. Admis.
Plus grand commun diviseur canonique : Pour 𝑎, 𝑏 ∈ ℤ, on définit Gcd(𝑎, 𝑏) = 𝑑 où 𝑑 ∈ ℕ et 𝑎ℤ + 𝑏ℤ = 𝑑ℤ.
On a donc Gcd(±1, 𝑎) = 1, Gcd(0, 𝑎) = |𝑎| et en particulier Gcd(0, 0) = 0.
Définitions : Pour 𝑎, 𝑏 ∈ ℤ, 𝑎, 𝑏 sont premiers entre eux ou 𝑎 est premier à 𝑏 si Gcd(𝑎, 𝑏) = 1.
Généralisation : Pour 𝑛 ∈ ℕ et 𝑎1 , … , 𝑎𝑛 ∈ ℤ, on définit Gcd(𝑎1 , … , 𝑎𝑛 ) = 𝑑 où 𝑑 ∈ ℕ et 𝑎1 ℤ+⋯+𝑎𝑛 ℤ = 𝑑ℤ.
En particulier, Gcd(𝑎) = |𝑎| et Gcd( ) = Gcd(0) = Gcd(0, … , 0) = 0.
def
Définition : 𝑎1 , … , 𝑎𝑛 ∈ ℤ sont 2 à 2 premiers entre eux ⟺ (∀ 𝑖, 𝑗 ∈ J1, 𝑟K, 𝑖 ≠ 𝑗 ⟹ Gcd(𝑎𝑖 , 𝑎𝑗 ) = 1).

Proposition 3.9.5 (Bézout dans ℤ) ∀ 𝑎, 𝑏 ∈ ℤ, ∃ 𝑢, 𝑣 ∈ ℤ, 𝑎𝑢 + 𝑏𝑣 = Gcd(𝑎, 𝑏).
En particulier, si 𝑎, 𝑏 ∈ ℤ sont premiers entre eux, alors ∃ 𝑢, 𝑣 ∈ ℤ, 𝑎𝑢 + 𝑏𝑣 = 1.
DÉMONSTRATION. Soit 𝑑 = Gcd(𝑎, 𝑏). Par définition, 𝑑 ∈ 𝑎ℤ + 𝑏ℤ = { 𝑎𝑥 + 𝑏𝑦 ∣ 𝑥, 𝑦 ∈ ℤ }, d’où le résultat.
Attention : 𝑢, 𝑣 ne sont pas uniques.

Proposition 3.9.6 (Lemme de Gauß dans ℤ)
Dans ℤ on a : Si 𝑎 \ 𝑏𝑐 et 𝑎 est premier à 𝑏, alors 𝑎 \ 𝑐.
DÉMONSTRATION. D’après Bézout on a 𝑢, 𝑣 ∈ ℤ tels que 𝑎𝑢 + 𝑏𝑣 = 1, donc 𝑎𝑢𝑐 + 𝑏𝑣𝑐 = 𝑐. Comme 𝑎 \ 𝑎𝑢𝑐
et 𝑎 \ 𝑏𝑐𝑣, on a que 𝑎 \ 𝑐.
L’élément neutre pour + est 0. L’élément neutre pour ⋅ est 1. L’ensemble des inversibles est ℤ× = {±1}.
On a :
Un nombre 𝑝 est un premier de ℤ ssi 𝑝 ∈ ℤ r {0, ±1} et ∀ 𝑎, 𝑏 ∈ ℤ, 𝑝 \ 𝑎𝑏 ⟹ (𝑝 \ 𝑎 ou 𝑝 \ 𝑏).
Un nombre 𝑝 est un irréductible de ℤ ssi 𝑝 ∈ ℤ r {0, ±1} et ∀ 𝑎 ∈ ℤ, 𝑎 \ 𝑝 ⟹ 𝑎 ∈ {±1, ±𝑝}.
Proposition 3.9.7 On a que 𝑝 est un premier de ℤ ssi 𝑝 est un irréductible de ℤ.
Cela donne la classification suivante des éléments de ℤ :
• Le neutre pour l’addition : le nombre 0.
• Les unités ou inversibles : ±1.
• Les nombres premiers : ±2, ±3, ±5, ±7, ±11, ±13, etc.
• Les nombres composés : tout le reste : ±4, ±6, ±8, ±9, ±10, ±12, etc.
3.9.2 Factorisation dans ℤ∗

Théorème 3.9.8 Tout 𝑎 ∈ ℤ∗ admet une unique écriture
avec
𝑒 𝑒
𝑎 = 𝑢 𝑝11 ⋯ 𝑝𝑟𝑟 𝑢 ∈ {1, −1}, 𝑟 ∈ ℕ, 𝑝𝑖 ∈ ℙ, 𝑝1 < ⋯ < 𝑝𝑟 , 𝑒𝑖 ∈ ℕ∗ .
Attention : Le nombre 0 n’a pas de factorisation.
Proposition 3.9.9 (Idéaux premiers et maximaux de ℤ)
On a :
1) Les idéaux premiers de ℤ sont ⟨0⟩ et ⟨𝑝⟩ avec 𝑝 ∈ ℙ.
2) Les idéaux maximaux de ℤ sont ⟨𝑝⟩ avec 𝑝 ∈ ℙ.
Théorème 3.9.10 (Euclide) Dans ℤ il y a une infinité de premiers.
3.9.3 Les groupes quotient ℤ/𝑛ℤ
Soit 𝑛 ∈ ℕ. Puisque ⟨𝑛⟩ = 𝑛ℤ est un sous-groupe de (ℤ, +) qui est un groupe abélien, on a le groupe quotient
(ℤ/𝑛ℤ, +) avec
def
ℤ/𝑛ℤ = { [𝑎]𝑛 ∣ 𝑎 ∈ ℤ }
def
[𝑎]𝑛 = 𝑎 + 𝑛ℤ = { 𝑎 + 𝑛𝑘 ∣ 𝑘 ∈ ℤ }
def
[𝑎]𝑛 + [𝑏]𝑛 = [𝑎 + 𝑏]𝑛 = (𝑎 + 𝑏) + 𝑛ℤ
𝜋 ∶ ℤ ⟶ ℤ/𝑛ℤ défini par 𝜋(𝑎) = [𝑎]𝑛 est un homomorphisme de groupes surjectif.

Lemme 3.9.11 Soit 𝑛 ∈ ℕ.
On a que le groupe (ℤ/𝑛ℤ, +) est monogène. Plus précisément :
— Si 𝑛 = 0, (ℤ/0ℤ, +) est monogène infini.
— Si 𝑛 > 0, (ℤ/𝑛ℤ, +) est cyclique d’ordre 𝑛.
3.9.4 Divers
Plus petit commun multiple canonique : Pour 𝑎, 𝑏 ∈ ℤ, on définit Lcm(𝑎, 𝑏) = 𝑚 où 𝑚 ∈ ℕ et 𝑎ℤ ∩ 𝑏ℤ = 𝑚ℤ.

On a donc Lcm(±1, 𝑎) = |𝑎|, Lcm(0, 𝑎) = 0.
Généralisation : Pour 𝑟 ∈ ℕ et 𝑎1 , … , 𝑎𝑟 ∈ ℤ, on définit Lcm(𝑎1 , … , 𝑎𝑟 ) = 𝑚 où 𝑚 ∈ ℕ et 𝑎1 ℤ∩⋯∩𝑎𝑟 ℤ = 𝑚ℤ.
On a donc Lcm(𝑎) = |𝑎| et Lcm( ) = 1 et Lcm(0, 𝑎2 , … , 𝑎𝑟 ) = 0.
Pour 𝑛 ∈ ℕ∗ on définit 𝐷(𝑛) = { 𝑚 ∈ J1, 𝑛K ∣ 𝑚 \ 𝑛 }

𝑈 (𝑛) = { 𝑚 ∈ J1, 𝑛K ∣ Gcd(𝑚, 𝑛) = 1 }
3.10 Groupes monogènes, groupes cycliques

On utilisera la notation multiplicative.
On voit d’abord les groupes monogènes infinis.
Lemme 3.10.1 Soit (𝐺, ⋅) un groupe quelconque, et soit 𝑔 ∈ 𝐺 d’ordre infini.
1) ∀ 𝑎 ∈ ℤ∗ , 𝑔𝑎 est d’ordre infini.
2) ∀ 𝑎, 𝑏 ∈ ℤ, (𝑔𝑎 = 𝑔𝑏 ⟺ 𝑎 = 𝑏).
Proposition 3.10.2 Soit (𝐺, ⋅) un groupe monogène infini engendré par 𝑔0 .

1) On a que 𝑔 ∈ 𝐺 engendre 𝐺 ssi 𝑔 = 𝑔0 ou 𝑔 = 𝑔0−1 .
2) Tout sous-groupe de (𝐺, ⋅) est monogène infini, sauf le sous-groupe nul (qui est cyclique).
3) ∀ 𝑎, 𝑏 ∈ ℤ, (⟨𝑔0𝑎 ⟩ ⊆ ⟨𝑔0𝑏 ⟩ ⟺ 𝑏 \ 𝑎). En particulier, ⟨𝑔0𝑎 ⟩ = ⟨𝑔0𝑏 ⟩ ⟺ |𝑎| = |𝑏|.
4) On a une bijection entre ℕ et l’ensemble des sous-groupes de 𝐺, donnée par 𝑛 ↦ ⟨𝑔0𝑛 ⟩.
5) Tous les groupes monogènes infinis sont isomorphes. En particulier, 𝜙 ∶ ℤ ⟶ 𝐺 avec 𝜙(𝑎) = 𝑔0𝑎 est un
isomorphisme entre les groupes (ℤ, +) et (𝐺, ⋅).
Maintenant on regarde les groupes cycliques.
Lemme 3.10.3 Soit (𝐺, ⋅) un groupe quelconque, et soit 𝑔 ∈ 𝐺 d’ordre fini 𝑛.
1) ∀ 𝑘 ∈ ℤ, o(𝑔𝑘 ) = 𝑛/ Gcd(𝑛, 𝑘).
2) ∀ 𝑎, 𝑏 ∈ ℤ, (𝑔𝑎 = 𝑔𝑏 ⟺ 𝑛 \ (𝑎 − 𝑏) ⟺ 𝑎 ≡ 𝑏 [𝑛]).
Proposition 3.10.4 Soit (𝐺, ⋅) un groupe cyclique d’ordre 𝑛 engendré par 𝑔0 .

1) Tout sous-groupe de (𝐺, ⋅) est cyclique.
2) Pour tout 𝑎 ∈ ℤ, on a ⟨𝑔0𝑎 ⟩ = ⟨𝑔0𝑑 ⟩ avec 𝑑 = Gcd(𝑎, 𝑛) ∈ 𝐷(𝑛).
3) Pour tout 𝑑 ∈ 𝐷(𝑛), il existe un unique sous-groupe d’ordre 𝑑, c’est ⟨𝑔0 ⟩.
𝑛/𝑑
4) On a une bijection entre 𝐷(𝑛) et l’ensemble des sous-groupes de (𝐺, ⋅), donnée par 𝑑 ↦ ⟨𝑔0𝑑 ⟩.
5) Tous les groupes cycliques d’un même ordre 𝑛 sont isomorphes. En particulier, 𝜙 ∶ ℤ/𝑛ℤ ⟶ 𝐺 avec
𝜙(𝑎) = 𝑔0𝑎 est un isomorphisme entre les groupes (ℤ/𝑛ℤ, +) et (𝐺, ⋅).

Proposition 3.10.5 Deux groupes monogènes sont isomorphes si et seulement s’ils ont même ordre.
DÉMONSTRATION. Conséquence de ce qui précède.
3.11 Polynômes : l’anneau 𝕜[𝑋]

Soit 𝕜 un corps commutatif.
L’anneau de polynômes 𝕜[𝑋] est non nul, unitaire, commutatif, intègre, infini.
Inversibles : (𝕜[𝑋])× = 𝕜× = 𝕜∗ .
Forme normale : On définit normal(0(𝑋)) = 0(𝑋) et si 𝑝(𝑋) ∈ 𝕜[𝑋]∗ alors normal(𝑝(𝑋)) = lc(𝑝(𝑋))−1 𝑝(𝑋).
∀ 𝑝(𝑋) ∈ 𝕜[𝑋], normal(𝑝(𝑋)) est nul ou unitaire et ⟨𝑝(𝑋)⟩ = ⟨normal(𝑝(𝑋))⟩.
Théorème 3.11.1 (Divison euclidienne dans 𝕜[𝑋])
Soient 𝑎(𝑋), 𝑏(𝑋) ∈ 𝕜[𝑋] avec 𝑏(𝑋) ≠ 0(𝑋). Alors il existe un unique (𝑞(𝑋), 𝑟(𝑋)) ∈ 𝕜[𝑋] × 𝕜[𝑋] tel que
𝑎(𝑋) = 𝑏(𝑋)𝑞(𝑋) + 𝑟(𝑋) et deg 𝑟(𝑋) < deg 𝑏(𝑋).
DÉMONSTRATION. Comme 𝑏(𝑋) ≠ 0(𝑋), lc(𝑏(𝑋)) est défini et lc(𝑏(𝑋)) ≠ 0 donc lc(𝑏(𝑋)) ∈ 𝕜× . Alors
3.7.2 donne l’existence et l’unicité.
Dans les conditions du théorème, pour (𝑎(𝑋), 𝑏(𝑋)) ∈ 𝕜[𝑋] × 𝕜[𝑋]∗ on définit Quo(𝑎(𝑋), 𝑏(𝑋)) = 𝑞(𝑋) et
Rem(𝑎(𝑋), 𝑏(𝑋)) = 𝑟(𝑋) et QuoRem(𝑎(𝑋), 𝑏(𝑋)) = (𝑞(𝑋), 𝑟(𝑋)).
Théorème 3.11.2 L’anneau 𝕜[𝑋] est principal.
Corollaire 3.11.3 (Idéaux de 𝕜[𝑋])

Tout idéal non nul de 𝕜[𝑋] est engendré par un unique polynôme unitaire.
On a ainsi une bijection entre l’ensemble des polynômes unitaires de 𝕜[𝑋] et l’ensemble des idéaux non nuls
de 𝕜[𝑋], donnée par 𝑝(𝑋) ↦ ⟨𝑝(𝑋)⟩.
Plus grand commun diviseur canonique : Pour 𝑟 ∈ ℕ et 𝑝1 (𝑋), … , 𝑝𝑟 (𝑋) ∈ 𝕜[𝑋], on définit
Gcd(𝑝1 (𝑋), … , 𝑝𝑟 (𝑋)) = 𝑑(𝑋) où ⟨𝑝1 (𝑋)⟩ + ⋯ + ⟨𝑝𝑟 (𝑋)⟩ = ⟨𝑑(𝑋)⟩ avec 𝑑(𝑋) ∈ 𝕜[𝑋] nul ou unitaire.
On a donc Gcd(0, 𝑝(𝑋)) = Gcd(𝑝(𝑋)) = normal(𝑝(𝑋))
𝜆 ∈ 𝕜∗ ⟹ Gcd(𝜆, 𝑝(𝑋)) = 1
Gcd( ) = Gcd(0(𝑋)) = Gcd(0(𝑋), … , 0(𝑋)) = 0(𝑋)
Définition : Pour 𝑎(𝑋), 𝑏(𝑋) ∈ 𝕜[𝑋], 𝑎(𝑋), 𝑏(𝑋) sont premiers entre eux ou 𝑎(𝑋) est premier à 𝑏(𝑋) si
Gcd(𝑎(𝑋), 𝑏(𝑋)) = 1.
Définition : 𝑝1 (𝑋), … , 𝑝𝑟 (𝑋) ∈ 𝕜[𝑋] sont 2 à 2 premiers entre eux
def
⟺ (∀ 𝑖, 𝑗 ∈ J1, 𝑟K, 𝑖 ≠ 𝑗 ⟹ Gcd(𝑝𝑖 (𝑋), 𝑝𝑗 (𝑋)) = 1).
Proposition 3.11.4 (Bézout dans 𝕜[𝑋]) ∀ 𝑎(𝑋), 𝑏(𝑋) ∈ 𝕜[𝑋], ∃ 𝑢(𝑋), 𝑣(𝑋) ∈ 𝕜[𝑋] tels que
𝑎(𝑋)𝑢(𝑋) + 𝑏(𝑋)𝑣(𝑋) = Gcd(𝑎(𝑋), 𝑏(𝑋)).
En particulier, si 𝑎(𝑋), 𝑏(𝑋) ∈ 𝕜[𝑋] sont premiers entre eux, alors
∃ 𝑢(𝑋), 𝑣(𝑋) ∈ 𝕜[𝑋], 𝑎(𝑋)𝑢(𝑋) + 𝑏(𝑋)𝑣(𝑋) = 1.
Attention : 𝑢(𝑋), 𝑣(𝑋) ne sont pas uniques.
Proposition 3.11.5 (Lemme de Gauß dans 𝕜[𝑋])
Dans 𝕜[𝑋] on a : Si 𝑎(𝑋) \ 𝑏(𝑋)𝑐(𝑋) et 𝑎(𝑋) est premier à 𝑏(𝑋), alors 𝑎(𝑋) \ 𝑐(𝑋).

On a :
Un polynôme 𝑝(𝑋) est un premier de 𝕜[𝑋] ssi 𝑝(𝑋) ∈ 𝕜[𝑋], deg 𝑝(𝑋) ⩾ 1 et
∀ 𝑎(𝑋), 𝑏(𝑋) ∈ 𝕜[𝑋], 𝑝(𝑋) \ 𝑎(𝑋)𝑏(𝑋) ⟹ (𝑝(𝑋) \ 𝑎(𝑋) ou 𝑝(𝑋) \ 𝑏(𝑋)).
Un polynôme 𝑝(𝑋) est un irréductible de 𝕜[𝑋] ssi 𝑝(𝑋) ∈ 𝕜[𝑋], deg 𝑝(𝑋) ⩾ 1 et
∀ 𝑎(𝑋) ∈ 𝕜[𝑋], 𝑎(𝑋) \ 𝑝(𝑋) ⟹ (𝑎(𝑋) ∈ 𝕜∗ ou normal(𝑎(𝑋)) = normal(𝑝(𝑋))).
Proposition 3.11.6 On a que 𝑝(𝑋) est un premier de 𝕜[𝑋] ssi 𝑝(𝑋) est un irréductible de 𝕜[𝑋].
Remarque : Dans ℤ on utilise plutôt le terme “premier”, alors que dans 𝕜[𝑋] c’est plutôt “irréductible”.
Corollaire 3.11.7 Soit 𝑓(𝑋) ∈ 𝕜[𝑋]. Alors 𝑓(𝑋) est irréductible dans 𝕜[𝑋] ssi
deg 𝑓(𝑋) ⩾ 1 et ∀ 𝑎(𝑋), 𝑏(𝑋) ∈ 𝕜[𝑋], (𝑓(𝑋) = 𝑎(𝑋)𝑏(𝑋) ⟹ (𝑎(𝑋) ∈ 𝕜∗ ou 𝑏(𝑋) ∈ 𝕜∗ )).
DÉMONSTRATION. Facile.
Proposition 3.11.8 (Idéaux premiers et maximaux de 𝕜[𝑋])

On a :
1) Les idéaux premiers de 𝕜[𝑋] sont ⟨0⟩ et ⟨𝑝(𝑋)⟩ avec 𝑝(𝑋) irréductible.
2) Les idéaux maximaux de 𝕜[𝑋] sont ⟨𝑝(𝑋)⟩ avec 𝑝(𝑋) irréductible.
Proposition 3.11.9 Soient 𝑓(𝑋) ∈ 𝕜[𝑋]∗ et 𝑎 ∈ 𝕜. Alors 𝑓(𝑎) = 0 ⟺ (𝑋 − 𝑎) \ 𝑓(𝑋).
DÉMONSTRATION. L’anneau 𝕜 est intègre.
Proposition 3.11.10 Soit 𝑓(𝑋) ∈ 𝕜[𝑋]∗ . Le nombre de racines de 𝑓(𝑋) dans 𝕜 est ⩽ deg 𝑓(𝑋).
DÉMONSTRATION. L’anneau 𝕜 est intègre.
On a (𝕜[𝑋])× = 𝕜∗ . Donc 𝑓(𝑋) ∈ 𝕜[𝑋] est une unité ssi deg 𝑓(𝑋) = 0.
Proposition 3.11.11 (Factorisation dans 𝕜[𝑋])
Tout 𝑓(𝑋) ∈ 𝕜[𝑋]∗ admet une écriture
𝑓(𝑋) = 𝑢 𝑃1 (𝑋)𝑒1 ⋯ 𝑃𝑟 (𝑋)𝑒𝑟
avec
𝑢 ∈ 𝕜∗ 𝑟∈ℕ 𝑃𝑖 (𝑋) ∈ 𝕜[𝑋] unitaires irréductibles 2 à 2 distincts 𝑒𝑖 ∈ ℕ∗ .
Cette écriture est unique à l’ordre des (𝑃𝑖 (𝑋), 𝑒𝑖 ) près.

3.12 Les entiers modulo 𝑛 : l’anneau ℤ/𝑛ℤ
Soit 𝑛 ∈ ℕ. Puisque ⟨𝑛⟩ = 𝑛ℤ est un idéal de ℤ, on a l’anneau quotient (ℤ/𝑛ℤ, +, ) avec pour 𝑎, 𝑏 ∈ ℤ :
def
ℤ/𝑛ℤ = { [𝑎]𝑛 ∣ 𝑎 ∈ ℤ }
def
[𝑎]𝑛 = 𝑎 + 𝑛ℤ = { 𝑎 + 𝑛𝑘 ∣ 𝑘 ∈ ℤ }
def
[𝑎]𝑛 + [𝑏]𝑛 = [𝑎 + 𝑏]𝑛 = (𝑎 + 𝑏) + 𝑛ℤ
def
[𝑎]𝑛 [𝑏]𝑛 = [𝑎𝑏]𝑛 = (𝑎𝑏) + 𝑛ℤ
def
𝑎 est congru à 𝑏 modulo 𝑛 ⟺ 𝑎 ≡ 𝑏 [𝑛] ⟺ 𝑎 ≡ 𝑏 (mod 𝑛) ⟺ [𝑎]𝑛 = [𝑏]𝑛 dans ℤ/𝑛ℤ
⟺ 𝑎 − 𝑏 ∈ 𝑛ℤ ⟺ 𝑛 \ (𝑎 − 𝑏) dans ℤ.
Notation : 𝒰𝑛 = (ℤ/𝑛ℤ) . ×
Lemme 3.12.1 Soit 𝑛 ∈ ℕ.

Si 𝑛 = 0, alors l’anneau ℤ/0ℤ est isomorphe à l’anneau ℤ, et 𝒰0 = {±[1]0 }.
Si 𝑛 > 0, alors l’anneau ℤ/𝑛ℤ est fini de cardinal 𝑛.
En particulier, l’anneau ℤ/1ℤ est nul, et 𝒰1 = {[0]1 }.
On étudiera donc l’anneau ℤ/𝑛ℤ pour 𝑛 ∈ ℕ∗ .
Proposition 3.12.2 (Idéaux de ℤ/𝑛ℤ)
Soit 𝑛 ∈ ℕ∗ .
1) Tout sous-groupe de (ℤ/𝑛ℤ, +) est un idéal de l’anneau ℤ/𝑛ℤ.
2) Tous les idéaux de ℤ/𝑛ℤ sont ⟨[𝑑]𝑛 ⟩ avec 𝑑 ∈ 𝐷(𝑛).
3) Tous les idéaux sont principaux, donc ℤ/𝑛ℤ est un anneau principal.
4) Si 𝑑1 , 𝑑2 ∈ 𝐷(𝑛), alors ⟨[𝑑1 ]𝑛 ⟩ ⊆ ⟨[𝑑2 ]𝑛 ⟩ ⟺ 𝑑2 \ 𝑑1 . On a donc une bijection entre 𝐷(𝑛) et l’ensemble
des idéaux de ℤ/𝑛ℤ, donnée par 𝑑 ↦ ⟨[𝑑]𝑛 ⟩.
Remarque : L’idéal nul de ℤ/𝑛ℤ s’obtient ici pour 𝑑 = 𝑛 (et non 𝑑 = 0 qui n’appartient pas à 𝐷(𝑛)).
def
Notation : Si 𝑑 ∈ 𝐷(𝑛), on note 𝑑ℤ/𝑛ℤ = ⟨[𝑑]𝑛 ⟩ = { [𝑑𝑘]𝑛 ∣ 𝑘 ∈ ℤ } = { 𝑑𝑘 + 𝑛ℓ ∣ 𝑘, ℓ ∈ ℤ }.
Proposition 3.12.3 Soit 𝑛 ∈ ℕ∗ . On se place dans ℤ/𝑛ℤ. Pour 𝑎 ∈ ℤ, sont équivalentes :
(a) 𝑎 est premier à 𝑛.
(b) [𝑎]𝑛 engendre le groupe cyclique (ℤ/𝑛ℤ, +).
(c) [𝑎]𝑛 est une unité de l’anneau ℤ/𝑛ℤ, c’est-à-dire, [𝑎]𝑛 ∈ 𝒰𝑛 .
DÉMONSTRATION.
(a) ⟹ (c) : On a un Bézout 𝑎𝑢 + 𝑛𝑣 = 1, et modulo 𝑛 cela donne [𝑎]𝑛 [𝑢]𝑛 = [1]𝑛 , donc [𝑎]𝑛 ∈ 𝒰𝑛 .
(c) ⟹ (b) : On a [𝑎]𝑛 ∈ 𝒰𝑛 ⟹ ∃ 𝑏 ∈ ℤ, [𝑎]𝑛 [𝑏]𝑛 = [1]𝑛 , donc 𝑏 [𝑎]𝑛 = [1]𝑛 donc [1]𝑛 appartient au
sous-groupe de (ℤ/𝑛ℤ, +) engendré par [𝑎]𝑛 , donc ce sous-groupe est ℤ/𝑛ℤ.
(b) ⟹ (a) : [1]𝑛 appartient au sous-groupe engendré par [𝑎]𝑛 , donc il existe 𝑏 ∈ ℤ tel que 𝑏 [𝑎]𝑛 = [1]𝑛 ,
c’est-à-dire, [𝑎𝑏]𝑛 = [1]𝑛 donc 𝑛 \ (𝑎𝑏 − 1) donc il existe 𝑐 ∈ ℤ tel que 𝑎𝑏 − 1 = 𝑐𝑛.
Or 𝑎𝑏 − 𝑐𝑛 = 1 ⟹ Gcd(𝑎, 𝑛) \ 1 ⟹ Gcd(𝑎, 𝑛) = 1.
Alors 𝒰𝑛 = { [𝑎]𝑛 ∣ 𝑎 ∈ 𝑈 (𝑛) }.

La fonction indicatrice de Euler est 𝜙 ∶ ℕ∗ ⟶ ℤ définie par 𝜙(𝑛) = card 𝒰𝑛 = card 𝑈 (𝑛).
Corollaire 3.12.4 L’anneau ℤ/𝑛ℤ est un corps ssi 𝑛 est un premier de ℤ.
DÉMONSTRATION.
Si 𝑛 = 0 alors ℤ/0ℤ ≃ ℤ qui n’est pas un corps.
ann
Si 𝑛 = 1 alors ℤ/1ℤ n’est pas non nul.
Si 𝑝 ∈ ℙ alors ℤ/𝑝ℤ n’est pas l’anneau nul et 𝑈 (𝑝) = J1, 𝑝 − 1K donc 𝒰𝑝 = (ℤ/𝑝ℤ)∗ .

Si 𝑛 est composé, alors 𝑛 = 𝑎𝑏 avec 𝑎, 𝑏 ∈ J2, 𝑛 − 1K. Alors [𝑎]𝑛 , [𝑏]𝑛 ≠ [0]𝑛 mais [𝑎]𝑛 [𝑏]𝑛 = [0]𝑛 , donc ℤ/𝑛ℤ
n’est même pas intègre.
3.12.1 Le lemme chinois
Théorème 3.12.5 (Lemme chinois (TCR))

Soit 𝑟 ∈ ℕ, soient 𝑚1 , … , 𝑚𝑟 ∈ ℕ∗ 2 à 2 premiers entre eux et 𝑚 = 𝑚1 ⋯ 𝑚𝑟 . Alors l’application
𝑓 ∶ ℤ/𝑚ℤ ⟶ (ℤ/𝑚1 ℤ) × ⋯ × (ℤ/𝑚𝑟 ℤ)
[𝑎]𝑚 ⟼ ([𝑎]𝑚1 , … , [𝑎]𝑚𝑟 )
est un isomorphisme d’anneaux.
Remarque : On l’appelle aussi Théorème chinois des restes (TCR), en anglais Chinese Remainder
Theorem (CRT). Le premier énoncé connu se trouve dans le livre 孫子算經 (entre le IIIe et le Ve siècles).
Proposition 3.12.6 Soient 𝑚, 𝑛 ∈ ℕ∗ .

Si 𝑚, 𝑛 ne sont pas premiers entre eux, alors ℤ/𝑚𝑛ℤ et (ℤ/𝑚ℤ) × (ℤ/𝑛ℤ) ont même cardinal mais ne sont
pas isomorphes en tant que groupes additifs (et donc non plus en tant qu’anneaux).
Corollaire 3.12.7 Soient 𝑟 ∈ ℕ et 𝑚1 , … , 𝑚𝑟 ∈ ℕ∗ et 𝑚 = 𝑚1 ⋯ 𝑚𝑟 . Alors

ℤ/𝑚ℤ ≃ (ℤ/𝑚1 ℤ) × ⋯ × (ℤ/𝑚𝑟 ℤ) ⟺ 𝑚1 , … , 𝑚𝑟 sont 2 à 2 premiers entre eux.
ann
DÉMONSTRATION. Conséquence de ce qui précède.
Théorème 3.12.8 (Théorème de Euler) Soit 𝑛 ∈ ℕ∗ .

Alors ∀ 𝑎 ∈ ℤ, (Gcd(𝑎, 𝑛) = 1 ⟺ 𝑎𝜙(𝑛) ≡ 1 [𝑛]).
En particulier, dans (𝒰𝑛 , ⋅) on a o([𝑎]𝑛 ) \ 𝜙(𝑛).
DÉMONSTRATION. Ceci est une conséquence du théorème de Lagrange (dans un groupe fini, l’ordre de tout
élément divise l’ordre du groupe).
Corollaire 3.12.9 Soit 𝑛 ∈ ℕ∗ .

Si Gcd(𝑎, 𝑛) = 1 et 𝛼 ≡ 𝛽 [𝜙(𝑛)] alors 𝑎𝛼 ≡ 𝑎𝛽 [𝑛].
Attention : Tout ceci est faux en général si 𝑎 n’est pas premier à 𝑛.
Théorème 3.12.10 (Petit théorème de Fermat (PTF)) Soit 𝑝 ∈ ℙ. Alors
∀ 𝑎 ∈ ℤ, (𝑝 \| 𝑎 ⟺ 𝑎𝑝−1 ≡ 1 [𝑝])
∀ 𝑎 ∈ ℤ, 𝑎𝑝 ≡ 𝑎 [𝑝].
DÉMONSTRATION. On se place dans ℤ/𝑝ℤ.

Si [𝑎]𝑝 = [0]𝑝 le résultat est vrai.
Si [𝑎]𝑝 ≠ [0]𝑝 alors [𝑎]𝑝 ∈ 𝒰𝑝 donc d’après le théorème de Euler on a ([𝑎]𝑝 )𝑝−1 = [1]𝑝 donc ([𝑎]𝑝 )𝑝 = [𝑎]𝑝 .
Si ([𝑎]𝑝 )𝑝−1 = [1]𝑝 alors [𝑎]𝑝 ([𝑎]𝑝 )𝑝−2 = [1]𝑝 donc [𝑎]𝑝 ∈ 𝒰𝑝 donc 𝑝 \| 𝑎.
3.12.2 Groupe des inversibles modulo 𝑛

Proposition 3.12.11 La fonction indicatrice de Euler est multiplicative, c’est-à-dire,
∀ 𝑚, 𝑛 ∈ ℕ∗ , Gcd(𝑚, 𝑛) = 1 ⟹ 𝜙(𝑚𝑛) = 𝜙(𝑚)𝜙(𝑛).

En factorisant 𝑛 = 𝑝11 ⋯ 𝑝𝑟𝑟 avec 𝑟 ∈ ℕ∗ , 𝑝𝑖 ∈ ℙ, 𝑝1 < ⋯ < 𝑝𝑟 , 𝑒𝑖 ∈ ℕ∗ , on a donc
𝑒 𝑒
ℤ/𝑛ℤ ≃ (ℤ/𝑝11 ℤ) × ⋯ × (ℤ/𝑝𝑟𝑟 ℤ) (isomorphisme d’anneaux)

𝑒 𝑒
ann
ce qui ramène à l’étude de ℤ/𝑝𝑒 ℤ pour 𝑝 ∈ ℙ et 𝑒 ∈ ℕ∗ .
En particulier, on a
(isomorphisme de groupes multiplicatifs)
𝑒 𝑒
(ℤ/𝑛ℤ)× ≃ (ℤ/𝑝11 ℤ)× × ⋯ × (ℤ/𝑝𝑟𝑟 ℤ)×
gr
qu’on écrit 𝒰𝑛 ≃ 𝒰𝑝𝑒11 × ⋯ × 𝒰𝑝𝑒𝑟𝑟 .
Ainsi, 𝜙(𝑛) = 𝜙(𝑝11 ) ⋯ 𝜙(𝑝𝑟𝑟 ).
𝑒 𝑒
Proposition 3.12.12 Soient 𝑝 ∈ ℙ et 𝑒 ∈ ℕ∗ . Alors 𝜙(𝑝𝑒 ) = 𝑝𝑒−1 (𝑝 − 1).
𝑟
Corollaire 3.12.13 Si la factorisation de 𝑛 ∈ ℕ est 𝑛 = ∏ 𝑝𝑖 𝑖 , alors
∗ 𝑒
𝑖=1
𝑟 𝑟
𝑒 −1 1
𝜙(𝑛) = ∏ 𝑝𝑖 𝑖 (𝑝𝑖 − 1) = 𝑛 ∏(1 − )
𝑖=1 𝑖=1
𝑝𝑖
Remarque : Les facteurs à droite appartiennent à ℚ, mais le résultat appartient bien à ℕ∗ .

Théorème 3.12.14 (Structure de 𝒰𝑝𝑒 )
Soient 𝑝 ∈ ℙ et 𝑒 ∈ ℕ∗ . On a :
1) Si 𝑝 est impair, alors (𝒰𝑝𝑒 , ⋅) est un groupe cyclique d’ordre 𝜙(𝑝𝑒 ) = 𝑝𝑒−1 (𝑝 − 1).
2) Si 𝑝 = 2 et 𝑒 ⩽ 2, alors (𝒰2𝑒 , ⋅) est un groupe cyclique d’ordre 𝜙(2𝑒 ) = 2𝑒−1 .
3) Si 𝑝 = 2 et 𝑒 ⩾ 3, alors 𝒰2𝑒 ≃ 𝐶2 × 𝐶2𝑒−2 (isomorphisme de groupes) donc il n’est pas cyclique.
gr
«All primes are odd, except 2, which is the oddest of all.»

Corollaire 3.12.15 𝒰𝑛 est cyclique ⟺ 𝑛 ∈ { 1, 2, 4, 𝑝𝑘 , 2𝑝𝑘 ∣ 𝑝 ∈ ℙ impair, 𝑘 ∈ ℕ∗ }.
DÉMONSTRATION. Exercice (conséquence immédiate du TCR).
À suivre...

Références
DEMAZURE, Michel (2009). Cours d’algèbre. Primalité, divisibilité, codes. 2e éd. Cassini.
GATHEN, Joachim von zur et Jürgen GERHARD (2013). Modern Computer Algebra. 3rd. Cambridge University
Press.
GAUTIER, Christian et André WARUSFEL (2004). Mathématiques tout-en-un, ECS 1re année. avec la colla-
boration de Bruno Caminade, Hélène Fontaine et Serge Nicolas, 1029pp. Dunod, p. 1029.
GRIFONE, Joseph (2015). Algèbre linéaire. 5e édition, 441pp. Cépoduès, p. 441.
KNUTH, Donald E. (1997a). The Art of Computer Programming. 3rd. T. 2 – Seminumerical Algorithms.
First edition 1969. Addison-Wesley, xiv+762pp.
– (1997b). The Art of Computer Programming, Volume 2 : Seminumerical Algorithms. 3rd. First edition
1969. Addison-Wesley, xiv+762pp.
PERRIN, Nicolas (2017-2018). « MAO, Algèbre avec Sage ».
RIOU, Joël (2019-2020). « M.A.O. Calcul formel ». Notes reprises par Stéphane Fischler et Kevin Destagnol,
https://www.imo.universite-paris-saclay.fr/~fischler/ens/MAO/poly.pdf.
SHOUP, Victor (2008). A Computational Introduction to Number Theory and Algebra. Voir aussi les errata.
URL : https://shoup.net/ntb/.
Wikipédia, l’encyclopédie libre (s. d.). URL : https://fr.wikipedia.org.
Wikipedia, the free encyclopedia (s. d.). URL : https://en.wikipedia.org.

Calcul Formel

Transféré par

Droits d'auteur :

Formats disponibles

Calcul Formel

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Calcul Formel

Transféré par

Droits d'auteur :

Formats disponibles

Calcul formel

(version provisoire à vérifier, ne pas imprimer)

UVSQ (Paris–Saclay) 2024/2025

0 Prérequis : définitions, notations, conventions, résultats 5

3 Structures algébriques (résumé) 34

Calcul formel 1/52 version 09 © GMS

Calcul formel 2/52 version 09 © GMS

Dans SageMath on a en revanche

Calcul formel 3/52 version 09 © GMS

Comment le faire de façon efficace ?

Ces notes sont basées sur un travail préalable de Pierre-Guy Plamondon.

For people fluent in English, the following might be useful:

Calcul formel 4/52 version 09 © GMS

Définition : 𝑃 est une partition d’un ensemble 𝐴 si : • 𝑃 ⊆ 𝒫(𝐴)

Calcul formel 5/52 version 09 © GMS

Si 𝐴, 𝐵 ≠ ⌀, on a les applications 𝜋1 ∶ 𝐴 × 𝐵 ⟶ 𝐴 et 𝜋2 ∶ 𝐴 × 𝐵 ⟶ 𝐵 définies par 𝜋1 ((𝑎, 𝑏)) = 𝑎 et

0.3 Relations binaires : relations d’équivalence, relations d’ordre total

Calcul formel 6/52 version 09 © GMS

Calcul formel 7/52 version 09 © GMS

“Associativité” du produit cartésien : Si 𝐼 ∩ 𝐽 = ⌀, on peut identifier (⨉ 𝐴𝑖 ) × (⨉ 𝐴𝑗 ) et ⨉ 𝐴𝑘 .

Calcul formel 8/52 version 09 © GMS

Calcul formel 9/52 version 09 © GMS

1.1 Définition de la complexité

Suivent quelques définitions.

Calcul formel 10/52 version 09 © GMS

1.2 Quelques propriétés

Calcul formel 11/52 version 09 © GMS

Calcul formel 12/52 version 09 © GMS

Calcul formel 13/52 version 09 © GMS

2.1 Entiers multiprécision

Calcul formel 14/52 version 09 © GMS

Calcul formel 15/52 version 09 © GMS

Algorithme 2.3.1 (Addition de 2 entiers multiprécision positifs ou nuls)

Calcul formel 16/52 version 09 © GMS

Algorithme 2.4.1 (Multiplication d’un entier machine par un entier multiprécision ⩾ 0)

Calcul formel 17/52 version 09 © GMS

Maintenant le cas général (algorithme 2.4.3).

Algorithme 2.4.3 (Multiplication naïve de 2 entiers multiprécision positifs ou nuls)

On a donc un coût en temps qui est dans O(𝑚𝑛).

Calcul formel 18/52 version 09 © GMS

2.4.2 Algorithme de Karatsuba

Calcul formel 19/52 version 09 © GMS

Algorithme 2.4.8 (Karatsuba(𝑘, 𝑥, 𝑦))

INPUT : 𝑘 ∈ ℕ et 2 entiers multiprécision ⩾ 0 : 𝑥 = (0, 𝑥0 , … , 𝑥𝑛−1 ) et 𝑦 = (0, 𝑦0 , … , 𝑦𝑛−1 ) avec 𝑛 = 2𝑘 .

Calcul formel 20/52 version 09 © GMS

Calcul formel 21/52 version 09 © GMS

(somme téléscopique). Pour 𝑚 → +∞ on a alors

car à droite on a la somme d’une série géométrique de raison avec ∣ 23 ∣ < 1.

On complète maintenant la preuve du Théorème 2.4.9.

Algorithme 2.5.1 (Exponentiation naïve)

Calcul formel 22/52 version 09 © GMS

multiplications. Cette méthode se généralise aisément au calcul de 𝑎𝑘 où 𝑘 est une puissance de 2.

Algorithme 2.5.3 (Représentation en base 2 d’un entier)

Calcul formel 23/52 version 09 © GMS

2.6 Division euclidienne

Calcul formel 24/52 version 09 © GMS

Algorithme 2.6.3 (Division euclidienne : quotient et reste.)

Proposition 2.6.4 L’algorithme 2.6.3 est correct.

DÉMONSTRATION. Soient 𝑚 = ⌊𝑥/𝑦⌋ et 𝑚′ = ⌊𝑥′ /𝑦′ ⌋. On a

Calcul formel 25/52 version 09 © GMS