15 - Théorème de Lagrange : tout entier est somme de quatre carrés

A Course in Arithmetic, chapitre 4 (Serre, GTM 7) — Disquisitiones Arithmeticae § 293 (Gauss, 1801). Le carnet 11 a posé la décomposition p = a² + b² pour p ≡ 1 mod 4 (Fermat, par Cornacchia). Le carnet 14 a posé la composition de Gauss et h(D). Ce carnet 15 franchit une étape majeure : tout entier positif est somme de quatre carrés (n = a² + b² + c² + d²). C’est le théorème de Lagrange (1770), la pierre angulaire de la théorie des formes quadratiques quaternaires, et l’origine du théorème des nombres premiers pour les formes modulaires (suite dans le ch. 7 de Serre). Outils : Python stdlib pur (math.isqrt). Le carnet 11 a montré la méthode Cornacchia ; ce 15 la généralise en arithmétique des quaternions d’Hamilton (le théorème des quatre carrés est équivalent à la multiplicativité des normes dans les quaternions).

Plan

1. Théorème de Lagrange : existence de la décomposition n = a² + b² + c² + d²
2. Formule de Jacobi pour r₄(n) — nombre de représentations ordonnées
3. Algorithme de Lagrange/Jacobi : recherche d’une racine u avec u² ≡ -1 mod p puis Euclide
4. Vérification numérique : exhaustivité sur n ≤ 10³ et comparaison avec la formule de Jacobi
5. Exercices

1. Théorème de Lagrange

Le théorème de Lagrange (1770, démontré par Lagrange) dit que tout entier positif n peut s’écrire comme somme de quatre carrés : \[n = a^2 + b^2 + c^2 + d^2, \quad a, b, c, d \geq 0.\] L’identité fondamentale qui rend ce théorème multiplicatif est l’identité de Brahmagupta–Fibonacci (Euclide ?), qui donne le produit de deux sommes de quatre carrés comme une autre somme de quatre carrés, via les quaternions d’Hamilton : \[(a_1^2 + b_1^2 + c_1^2 + d_1^2)(a_2^2 + b_2^2 + c_2^2 + d_2^2) = (a_1 a_2 - b_1 b_2 - c_1 c_2 - d_1 d_2)^2 + (a_1 b_2 + b_1 a_2 + c_1 d_2 - d_1 c_2)^2 + \ldots\] En arithmétique quaternionique, cette identité dit que la norme N(q) = a² + b² + c² + d² est multiplicative : N(q_1 q_2) = N(q_1) N(q_2). La décomposition de n en quatre carrés se ramène donc à la décomposition des facteurs premiers de n.

from math import isqrt

def four_squares_count(n):
    """Compte r_4(n) = 8 * sum_{d | n, 4 not | d} d."""
    if n == 0:
        return 1
    total = 0
    d = 1
    while d * d <= n:
        if n % d == 0:
            for dd in {d, n // d}:
                if dd % 4 != 0:
                    total += dd
        d += 1
    return 8 * total

print('Verification de la formule de Jacobi pour r_4(n) sur n <= 30')
print()
print(f"{'n':>4} | {'r_4(n) (Jacobi)':>15} | {'decomposition directe'}")
print('-' * 60)
for n in range(1, 31):
    r = four_squares_count(n)
    # Decomposition directe pour n <= 30
    decomps = []
    for a in range(0, isqrt(n) + 1):
        for b in range(a, isqrt(n - a * a) + 1):
            for c in range(b, isqrt(n - a * a - b * b) + 1):
                d2 = n - a * a - b * b - c * c
                if d2 < c * c:
                    break
                d = isqrt(d2)
                if d * d == d2 and d >= c:
                    decomps.append((a, b, c, d))
                    break
            if decomps and decomps[-1]:
                break
        if decomps and decomps[-1]:
            break
    dec_str = str(decomps[0]) if decomps else 'N/A'
    print(f'{n:>4} | {r:>15} | {dec_str}')

Verification de la formule de Jacobi pour r_4(n) sur n <= 30

   n | r_4(n) (Jacobi) | decomposition directe
------------------------------------------------------------
   1 |               8 | (0, 0, 0, 1)
   2 |              24 | (0, 0, 1, 1)
   3 |              32 | (0, 1, 1, 1)
   4 |              24 | (0, 0, 0, 2)
   5 |              48 | (0, 0, 1, 2)
   6 |              96 | (0, 1, 1, 2)
   7 |              64 | (1, 1, 1, 2)
   8 |              24 | (0, 0, 2, 2)
   9 |             104 | (0, 0, 0, 3)
  10 |             144 | (0, 0, 1, 3)
  11 |              96 | (0, 1, 1, 3)
  12 |              96 | (0, 2, 2, 2)
  13 |             112 | (0, 0, 2, 3)
  14 |             192 | (0, 1, 2, 3)
  15 |             192 | (1, 1, 2, 3)
  16 |              24 | (0, 0, 0, 4)
  17 |             144 | (0, 0, 1, 4)
  18 |             312 | (0, 0, 3, 3)
  19 |             160 | (0, 1, 3, 3)
  20 |             144 | (0, 0, 2, 4)
  21 |             256 | (0, 1, 2, 4)
  22 |             288 | (0, 2, 3, 3)
  23 |             192 | (1, 2, 3, 3)
  24 |              96 | (0, 2, 2, 4)
  25 |             248 | (0, 0, 0, 5)
  26 |             336 | (0, 0, 1, 5)
  27 |             320 | (0, 1, 1, 5)
  28 |             192 | (1, 1, 1, 5)
  29 |             240 | (0, 0, 2, 5)
  30 |             576 | (0, 1, 2, 5)

Lecture du résultat

La formule de Jacobi r_4(n) = 8 * sum_{d | n, 4 not | d} d est vérifiée sur tous les n in [1, 30] : les valeurs de la table concordent avec le dénombrement direct. Quelques valeurs remarquables : - r_4(1) = 8 : les 8 représentations sont les permutations de (+-1, 0, 0, 0) – 4 positions fois 2 signes - r_4(4) = 24 : (+-2, 0, 0, 0) donne 8 représentations et (+-1, +-1, +-1, +-1) en donne 16 – les deux familles totalisent 24 - r_4(5) = 48 : permutations de (+-2, +-1, 0, 0) – 12 positions fois 4 signes - r_4(16) = r_4(8) = r_4(4) = 24 : les puissances de 2 donnent toutes 24 (explication en section 3)

L’algorithme de Lagrange/Jacobi utilise une identité multiplicative (Brahmagupta-Fibonacci) pour ramener la décomposition des grands n à celle de leurs facteurs premiers. C’est la voie standard pour démontrer Lagrange.

2. Algorithme de Lagrange/Jacobi

L’algorithme de Lagrange (1770) pour décomposer n = a² + b² + c² + d² procède ainsi : 1. Cas trivial : n = 0 → (0, 0, 0, 0). Si n est un carré parfait → (√n, 0, 0, 0). 2. Recherche d’une racine u : trouver a, b tels que a² + b² ≡ 0 (mod n) avec 0 < a, b < √n et a ≠ b (l’astuce cruciale est de prendre a impair et b pair, ou inversement). 3. Si a² + b² = n directement, c’est fini. 4. Sinon, poser m = a² + b² = n k avec k > 1. Par hypothèse de récurrence, décomposer k = c² + d² + e² + f² (ou utiliser directement une factorisation par les facteurs premiers), puis utiliser l’identité de Brahmagupta–Fibonacci pour combiner a + bi et c + di + ej + fk en quatre nouveaux carrés. C’est l’algorithme historique. Les versions modernes (SAGE, PARI) utilisent la décomposition en facteurs premiers puis Brahmagupta–Fibonacci par multiplications successives.

print('Verification numerique : tout n <= 1000 est somme de 4 carres')
print()
def premiers(n):
    sieve = [True] * (n + 1)
    sieve[0] = sieve[1] = False
    for i in range(2, isqrt(n) + 1):
        if sieve[i]:
            for j in range(i*i, n + 1, i):
                sieve[j] = False
    return [i for i in range(2, n + 1) if sieve[i]]

n_max = 1000
ok = 0; total = n_max
fail_list = []
for n in range(1, n_max + 1):
    found = False
    for a in range(0, isqrt(n) + 1):
        for b in range(a, isqrt(n - a * a) + 1):
            for c in range(b, isqrt(n - a * a - b * b) + 1):
                d2 = n - a * a - b * b - c * c
                if d2 < c * c:
                    break
                d = isqrt(d2)
                if d * d == d2 and d >= c:
                    found = True
                    break
            if found:
                break
        if found:
            break
    if found:
        ok += 1
    else:
        fail_list.append(n)

print(f'OK : {ok}/{total}, failures : {fail_list[:5] if fail_list else "aucun"}')

# Demonstration pour quelques premiers
print()
print('Demonstrations pour quelques premiers p <= 50 :')
for p in premiers(50):
    for a in range(0, isqrt(p) + 1):
        for b in range(a, isqrt(p - a * a) + 1):
            for c in range(b, isqrt(p - a * a - b * b) + 1):
                d2 = p - a * a - b * b - c * c
                if d2 < c * c:
                    break
                d = isqrt(d2)
                if d * d == d2 and d >= c:
                    print(f'{p} = {a}^2 + {b}^2 + {c}^2 + {d}^2')
                    break
            else:
                continue
            break
        else:
            continue
        break

Verification numerique : tout n <= 1000 est somme de 4 carres

OK : 1000/1000, failures : aucun

Demonstrations pour quelques premiers p <= 50 :
2 = 0^2 + 0^2 + 1^2 + 1^2
3 = 0^2 + 1^2 + 1^2 + 1^2
5 = 0^2 + 0^2 + 1^2 + 2^2
13 = 0^2 + 0^2 + 2^2 + 3^2
17 = 0^2 + 0^2 + 1^2 + 4^2
29 = 0^2 + 0^2 + 2^2 + 5^2
37 = 0^2 + 0^2 + 1^2 + 6^2
41 = 0^2 + 0^2 + 4^2 + 5^2

Lecture du résultat

L’algorithme exhaustif en O(n^{3/2}) (triple boucle + isqrt) confirme que tous les entiers n <= 1000 sont sommes de quatre carrés. Aucune exception : c’est le théorème de Lagrange, démontré numériquement.

Quelques décompositions explicites pour des premiers : - 7 = 2^2 + 1^2 + 1^2 + 1^2 – 4 carrés ; avec 23, 31 et 47, ce sont les quatre premiers p = 3 mod 4, p <= 50, qui exigent 4 carrés - 13 = 3^2 + 2^2 – p = 1 mod 4 : deux carrés suffisent (carnet 11) - 23 = 3^2 + 3^2 + 2^2 + 1^2 = 9 + 9 + 4 + 1 – 4 carrés

Pour p = 1 mod 4, deux carrés suffisent (carnet 11) ; pour p = 3 mod 4 ou p = 2, il faut 3 ou 4 carrés. Le théorème de Lagrange est l’unification : quatre carrés suffisent toujours, jamais cinq ne sont nécessaires.

3. Formule de Jacobi et multiplicativité

La formule de Jacobi (1829) donne le nombre exact de représentations de n comme somme de quatre carrés ordonnées (avec signes et permutations comptés) : \[r_4(n) = 8 \sum_{d \mid n, 4 \nmid d} d.\] Quelques cas : - r_4(1) = 8 (1 seul 1² + 0² + 0² + 0², 8 permutations de signes) - r_4(p) = 8(p + 1) pour p premier impair (somme sur d ∈ {1, p}) - r_4(2^a) = 24 pour a ≥ 1 (diviseurs non multiples de 4 : {1, 2}, donc 8·3) La formule se déduit directement de la multiplicativité de r_4(n) (elle-même conséquence de Brahmagupta–Fibonacci) et du calcul pour les puissances de 2.

def r4_comptage(n):
    """Compte exact r_4(n) par enumeration quadruple (signes et ordre comptes)."""
    count = 0
    for a in range(-isqrt(n), isqrt(n) + 1):
        for b in range(-isqrt(n), isqrt(n) + 1):
            for c in range(-isqrt(n), isqrt(n) + 1):
                d2 = n - a*a - b*b - c*c
                if d2 < 0:
                    continue
                d = isqrt(d2)
                if d * d == d2:
                    # les deux signes de d : +d et -d (un seul si d = 0)
                    count += 2 if d > 0 else 1
    return count

print('Verification formule de Jacobi : r_4(p) = 8(p+1) pour p premier')
print()
print(f"{'p':>5} | {'r_4 formule':>12} | {'r_4 comptage':>12}")
print('-' * 36)
for p in premiers(50):
    formule = four_squares_count(p)  # diviseurs de p : {1, p}, donc 8(p+1)
    comptage = r4_comptage(p)
    print(f'{p:>5} | {formule:>12} | {comptage:>12}')

print()
print('Verification formule de Jacobi : r_4(2^a)')
print()
for a in range(1, 8):
    n = 2 ** a
    # Diviseurs de 2^a non multiples de 4 : exactement {1, 2} pour tout a >= 1
    # (4, 8, ..., 2^a sont tous multiples de 4), donc r_4(2^a) = 8 * 3 = 24.
    print(f'2^{a} = {n:>4}: formule = {four_squares_count(n)}, comptage = {r4_comptage(n)}')

Verification formule de Jacobi : r_4(p) = 8(p+1) pour p premier

    p |  r_4 formule | r_4 comptage
------------------------------------
    2 |           24 |           24
    3 |           32 |           32
    5 |           48 |           48
    7 |           64 |           64
   11 |           96 |           96
   13 |          112 |          112
   17 |          144 |          144
   19 |          160 |          160
   23 |          192 |          192
   29 |          240 |          240
   31 |          256 |          256
   37 |          304 |          304
   41 |          336 |          336
   43 |          352 |          352
   47 |          384 |          384

Verification formule de Jacobi : r_4(2^a)

2^1 =    2: formule = 24, comptage = 24
2^2 =    4: formule = 24, comptage = 24
2^3 =    8: formule = 24, comptage = 24
2^4 =   16: formule = 24, comptage = 24
2^5 =   32: formule = 24, comptage = 24
2^6 =   64: formule = 24, comptage = 24
2^7 =  128: formule = 24, comptage = 24

Lecture du résultat

La formule de Jacobi est vérifiée par comptage direct : pour tous les premiers p <= 50, les colonnes formule et comptage concordent (r_4(p) = 8(p+1)). Pour les puissances de 2 : r_4(2^a) = 24 pour tout a >= 1.

Cette constance s’explique diviseur par diviseur : les diviseurs de 2^a non multiples de 4 sont exactement {1, 2} – tous les autres (4, 8, ..., 2^a) sont exclus par la condition 4 not | d – donc la somme vaut 3 et r_4(2^a) = 8 * 3 = 24, quel que soit a >= 1. C’est un portrait exact de la formule de Jacobi, pas une coïncidence numérique.

4. Exercices

Trois prolongements qui explorent le théorème de Lagrange : Exercice 1 : Vérifier la formule de Jacobi pour r₄(n) sur tous les n ≤ 100 (par énumération quadruple boucle O(n²)). Comparer avec la formule close. Exercice 2 : Pour les premiers p ≤ 1000 avec p ≡ 3 mod 4, observer la distribution du nombre minimal de carrés nécessaires : 3 (comme 7 = 4 + 1 + 1 + 1) ou 4 (comme 23 = 9 + 9 + 4 + 1). Y a-t-il une structure ? Exercice 3 : Implémenter l’identité de Brahmagupta–Fibonacci et l’utiliser pour calculer (a₁² + b₁² + c₁² + d₁²) · (a₂² + b₂² + c₂² + d₂²) comme somme de quatre carrés, sur quelques exemples. Vérifier que le résultat est correct (carré parfait de la somme des carrés).

print('Exo 1 : Verification formule Jacobi pour n <= 100')
print()
ok = 0
total = 0
for n in range(1, 101):
    r_formule = four_squares_count(n)
    r_comptage = r4_comptage(n)
    total += 1
    if r_formule == r_comptage:
        ok += 1
print(f'Concordance formule / comptage : {ok}/{total} pour n <= 100')
print()
for n in [1, 2, 5, 25]:
    r_formule = four_squares_count(n)
    r_comptage = r4_comptage(n)
    print(f'n = {n}: r_4 formule = {r_formule}, r_4 comptage = {r_comptage}, OK = {r_formule == r_comptage}')

Exo 1 : Verification formule Jacobi pour n <= 100

Concordance formule / comptage : 100/100 pour n <= 100

n = 1: r_4 formule = 8, r_4 comptage = 8, OK = True
n = 2: r_4 formule = 24, r_4 comptage = 24, OK = True
n = 5: r_4 formule = 48, r_4 comptage = 48, OK = True
n = 25: r_4 formule = 248, r_4 comptage = 248, OK = True

print('Exo 2 : nombre minimal de carres pour p premiers <= 100, p = 3 mod 4')
print()
def min_squares(n):
    """Nombre minimal de carres pour representer n."""
    s = isqrt(n)
    if s * s == n:
        return 1
    # 2 carres ?
    for a in range(1, isqrt(n) + 1):
        b2 = n - a*a
        if b2 < 0:
            break
        b = isqrt(b2)
        if b * b == b2:
            return 2
    # 3 carres ?
    for a in range(1, isqrt(n) + 1):
        for b in range(a, isqrt(n - a*a) + 1):
            c2 = n - a*a - b*b
            if c2 < 0:
                break
            c = isqrt(c2)
            if c * c == c2:
                return 3
    return 4

p3mod4 = [p for p in premiers(100) if p % 4 == 3]
print(f'Premiers p <= 100, p = 3 mod 4 : {p3mod4}')
print()
print(f"{'p':>3} | {'min':>4} | {'representation'}")
print('-' * 50)
for p in p3mod4:
    m = min_squares(p)
    # Trouver une decomposition minimale
    if m == 3:
        for a in range(1, isqrt(p) + 1):
            for b in range(a, isqrt(p - a*a) + 1):
                c2 = p - a*a - b*b
                if c2 < 0:
                    break
                c = isqrt(c2)
                if c * c == c2:
                    rep = f'{a}^2 + {b}^2 + {c}^2'
                    break
            else:
                continue
            break
    elif m == 4:
        for a in range(1, isqrt(p) + 1):
            for b in range(a, isqrt(p - a*a) + 1):
                for c in range(b, isqrt(p - a*a - b*b) + 1):
                    d2 = p - a*a - b*b - c*c
                    if d2 < 0:
                        break
                    d = isqrt(d2)
                    if d * d == d2:
                        rep = f'{a}^2 + {b}^2 + {c}^2 + {d}^2'
                        break
                else:
                    continue
                break
            else:
                continue
            break
    else:
        rep = f'{isqrt(p)}^2'
    print(f'{p:>3} | {m:>4} | {rep}')

Exo 2 : nombre minimal de carres pour p premiers <= 100, p = 3 mod 4

Premiers p <= 100, p = 3 mod 4 : [3, 7, 11, 19, 23, 31, 43, 47, 59, 67, 71, 79, 83]

  p |  min | representation
--------------------------------------------------
  3 |    3 | 1^2 + 1^2 + 1^2
  7 |    4 | 1^2 + 1^2 + 1^2 + 2^2
 11 |    3 | 1^2 + 1^2 + 3^2
 19 |    3 | 1^2 + 3^2 + 3^2
 23 |    4 | 1^2 + 2^2 + 3^2 + 3^2
 31 |    4 | 1^2 + 1^2 + 2^2 + 5^2
 43 |    3 | 3^2 + 3^2 + 5^2
 47 |    4 | 1^2 + 1^2 + 3^2 + 6^2
 59 |    3 | 1^2 + 3^2 + 7^2
 67 |    3 | 3^2 + 3^2 + 7^2
 71 |    4 | 1^2 + 3^2 + 5^2 + 6^2
 79 |    4 | 1^2 + 2^2 + 5^2 + 7^2
 83 |    3 | 1^2 + 1^2 + 9^2

print('Exo 3 : identite de Brahmagupta-Fibonacci')
print()
def brahmagupta_fibonacci(a1, b1, c1, d1, a2, b2, c2, d2):
    """Calcule (a1^2+b1^2+c1^2+d1^2)(a2^2+b2^2+c2^2+d2^2) comme somme de 4 carres."""
    # Identite classique : 8 termes
    A = a1*a2 - b1*b2 - c1*c2 - d1*d2
    B = a1*b2 + b1*a2 + c1*d2 - d1*c2
    C = a1*c2 - b1*d2 + c1*a2 + d1*b2
    D = a1*d2 + b1*c2 - c1*b2 + d1*a2
    return (A, B, C, D)

tests = [
    (1, 0, 0, 0, 1, 0, 0, 0),  # 1 * 1 = 1
    (1, 1, 0, 0, 1, 1, 0, 0),  # 2 * 2 = 4
    (2, 1, 0, 0, 2, 1, 0, 0),  # 5 * 5 = 25
    (1, 1, 1, 1, 1, 1, 1, 1),  # 4 * 4 = 16
]
for (a1, b1, c1, d1, a2, b2, c2, d2) in tests:
    A, B, C, D = brahmagupta_fibonacci(a1, b1, c1, d1, a2, b2, c2, d2)
    s1 = a1*a1 + b1*b1 + c1*c1 + d1*d1
    s2 = a2*a2 + b2*b2 + c2*c2 + d2*d2
    s12 = A*A + B*B + C*C + D*D
    ok = s12 == s1 * s2
    print(f'({a1},{b1},{c1},{d1})^2 * ({a2},{b2},{c2},{d2})^2 = ({A},{B},{C},{D})^2')
    print(f'  {s1} * {s2} = {s1*s2}, somme = {s12}, OK = {ok}')

Exo 3 : identite de Brahmagupta-Fibonacci

(1,0,0,0)^2 * (1,0,0,0)^2 = (1,0,0,0)^2
  1 * 1 = 1, somme = 1, OK = True
(1,1,0,0)^2 * (1,1,0,0)^2 = (0,2,0,0)^2
  2 * 2 = 4, somme = 4, OK = True
(2,1,0,0)^2 * (2,1,0,0)^2 = (3,4,0,0)^2
  5 * 5 = 25, somme = 25, OK = True
(1,1,1,1)^2 * (1,1,1,1)^2 = (-2,2,2,2)^2
  4 * 4 = 16, somme = 16, OK = True

Conclusion

Le théorème de Lagrange (1770) — tout entier positif est somme de quatre carrés — est l’une des pierres angulaires de la théorie des formes quadratiques. La multiplicativité de la norme quaternionique en fait une démonstration élégante, et la formule de Jacobi donne le nombre exact r₄(n) = 8 \sum_{d \mid n, 4 \nmid d} d. Cette série de carnets Serre100 a maintenant couvert : - Carnet 11 : décomposition p = a² + b² (Fermat, Cornacchia) - Carnet 14 : composition de Gauss, h(D), Stark-Heegner - Carnet 15 : décomposition n = a² + b² + c² + d² (Lagrange, Jacobi) Suite naturelle : - Carnet 16 envisagé : lien avec les formes modulaires pour SL₂(Z) — fonction η de Dedekind, séries de Dirichlet associées, théorème de Modularity (Serre ch. 7-8). - Pont avec la série GenAI : la fonction η(τ) intervient dans la théorie des vertex operator algebras et la monstrous moonshine (Conway-Norton).

Ressources

• Lagrange (1770), « Démonstration d’un théorème d’arithmétique » — l’original.
• Jacobi (1829), Fundamenta Nova Theoriae Functionum Ellipticarum — la formule de r₄(n).
• Serre, A Course in Arithmetic, chapitre 4 (Springer GTM 7) — référence canonique.
• Conway & Smith (2003), On Quaternions and Octonions — l’identité de Brahmagupta–Fibonacci revisitée.
• Ireland & Rosen, A Classical Introduction to Modern Number Theory, chapitre 7.