Recherche · Géométrie discrète · distances unitaires

Distances unitaires entre points rationnels : 121 points, 429 distances

Cette page présente un travail de recherche en géométrie discrète : un ensemble de 121 points du plan à coordonnées rationnelles, dont 429 paires sont à distance exactement 1. Elle montre l’énoncé exact, le paysage des valeurs publiques avec leurs sources, puis la configuration en entier, avec un programme court que chacun exécute pour la revérifier.

1. Le problème

Combien de paires de n points du plan peuvent être à distance exactement 1 ? Soit u(n) ce maximum. Erdős a posé la question en 1946 ; le tableau rappelle la majoration u(n) = O(n^4/3) (Spencer, Szemerédi et Trotter, 1984). Pour des points à coordonnées rationnelles, notons u_Q(n) le plus grand nombre de distances unitaires entre n points distincts du plan à coordonnées rationnelles.

L’énoncé du tableau, en anglais : « How many pairs of n points in the plane can be at distance exactly 1? Let u(n) be the max. » et, pour le palier A, « most unit distances among n rational points ». Soit : un ensemble de points distincts, chaque coordonnée étant un entier, une fraction « p/q » ou un couple [numérateur, dénominateur] ; le contrôle du tableau (check.py) compte les paires à distance exactement 1, en arithmétique rationnelle exacte et sans nombre flottant, et ce nombre est le score. Source : github.com/math-market/unit-distances, fichier TASK.md, lu le 13/10/2026 ; le tableau et son contrôle sont publiés sous licence Apache-2.0.

Le schéma montre à gauche quatre points rationnels A (0 ; 0), B (3/5 ; 4/5), D (1 ; 0) et C (8/5 ; 4/5) : les quatre côtés sont à distance exactement 1, par exemple (3/5)² + (4/5)² = 1, et les diagonales ne le sont pas. À droite, le point C est déplacé de 1/10 : les côtés BC et DC cessent d’être à distance 1, il reste deux distances unitaires. Un ensemble se juge ainsi, paire par paire, sans approximation.

2. Le paysage public

Le tableau réunit les nombres publics autour de n = 121, avec leur source et leur date de lecture. Ce sont les repères du problème : ils situent les valeurs connues. Les trois premières lignes concernent le plan réel, où les points n’ont pas à être rationnels.

Lectures du 13/10/2026 : tableau math-market/unit-distances (README, TASK.md, check.py, task.json, generator_example.py, liste des pull requests), OEIS A186705, arXiv:2406.15317v3, arXiv:2606.29415v2.

Pour les points à coordonnées rationnelles, les sources citées ne donnent aucune table de valeurs par n. Le tableau écrit « Beat the best known for your n » sans publier de valeurs ; le dossier submissions/ de son dépôt ne contient que son README, et les sept autres pull requests du dépôt portent sur l’infrastructure du tableau (titres lus). L’article de Rodis (arXiv:2606.29415v2, 3 septembre 2026), que le tableau cite, explore le plan rationnel pour construire un graphe de 2 411 001 sommets et 33 237 700 distances unitaires ; son texte ne donne pas de valeurs chiffrées pour des ensembles de taille modeste, et son dépôt publie des graphes entiers (jusqu’à 2,4 millions de sommets), non une table par n (texte lu en entier, pages du dépôt lues le 13/10/2026). Dans le plan réel, u(n) est connu exactement pour n ≤ 21 (OEIS A186705, 57 à n = 21) ; pour n de 22 à 100, la table d’Engel et al. donne la plus grande valeur trouvée par leur recherche, jusqu’à 439 à n = 100. Les graphes de cette table sont des sous-ensembles du réseau de Moser, engendré par 1, ω₁, ω₃ et ω₁ω₃, où ω₁ et ω₃ sont racines de x² − x + 1 et de x² − (5/3)x + 1 (théorème 2.3 de l’article) : leurs points n’ont pas, en général, de coordonnées rationnelles.

Aux lectures du 13/10/2026, 429 est la plus grande valeur publiée pour le nombre de distances unitaires entre 121 points à coordonnées rationnelles dans les sources citées ci-dessus, et la seule : ces sources ne donnent aucune valeur pour des points rationnels à ce n. Ce n’est pas la valeur exacte de u_Q(121). Elle ne se compare pas directement à la table du plan réel : dans le plan réel, u(121) ≥ 439 (un ensemble de 100 points complété de 21 points isolés), et la table donne 429 pour 98 points.

3. Le résultat

L’ensemble compte 121 points distincts à coordonnées rationnelles et 429 paires à distance exactement 1, donc u_Q(121) ≥ 429. Chaque coordonnée est donnée en numérateur sur le dénominateur commun 1 105 : le point i est (x_i/1 105, y_i/1 105).

Les 121 points sont publiés en entier. Le fichier au format du tableau est unit_distances_n121.json (3 619 octets) ; les mêmes points sont donnés ci-dessous en liste de numérateurs, intégrée au programme de revérification.

Les vérifications

Quatre contrôles, rejoués le 13/10/2026 sur le fichier des points :

Sortie du juge du tableau sur la configuration :

OK  121 points, 429 unit distances  (score = 429)

Sortie du juge sur la configuration dont le point n° 40 est déplacé de 1/10⁹ en x :

OK  121 points, 416 unit distances  (score = 416)

Revérifier soi-même

Le programme ci-dessous contient la configuration. Il suffit de l’enregistrer dans un fichier verifier_distances.py et de lancer python verifier_distances.py : Python 3 suffit, sans aucune bibliothèque à installer. Chaque ligne de la liste donne les deux numérateurs d’un point sur le dénominateur commun. Le programme applique deux contrôles de natures différentes, rejoue deux canaris (le point de plus fort degré déplacé d’une quantité infime : les deux contrôles doivent compter moins de distances) et affiche l’empreinte du fichier JSON reconstruit, à comparer à celle de la section 3. Version enregistrable : verifier_distances_fr.py.

# verifier_distances.py : bibliothèque standard seule ; python verifier_distances.py
import hashlib, json
from fractions import Fraction
from math import isqrt

D = 1105
# la configuration : une ligne par point « x y », en numérateurs sur le dénominateur commun D (le point est (x/D, y/D))
LISTE = """
-2619 3285
-2347 2214
-2151 4286
-2099 2310
-2043 4228
-1879 3215
-1827 1239
-1771 3157
-1735 2622
-1676 2709
-1667 3846
-1631 3311
-1575 5229
-1523 3253
-1463 1551
-1404 1638
-1395 2775
-1359 2240
-1303 4158
-1267 3623
-1251 2182
-1215 1647
-1208 3710
-1199 4847
-1159 3565
-1156 1734
-1147 2871
-1100 3652
-1091 4789
-1055 4254
-995 2552
-943 576
-936 2639
-927 3776
-887 2494
-884 663
-875 1800
-828 2581
-819 3718
-792 2046
-783 3183
-747 2648
-724 3270
-691 4566
-688 2735
-679 3872
-639 2590
-632 4653
-623 5790
-580 2677
-571 3814
-520 975
-511 2112
-475 1577
-452 2199
-419 3495
-416 1664
-407 2801
-367 1519
-360 3582
-351 4719
-324 3047
-315 4184
-308 1606
-299 2743
-272 1071
-263 2208
-256 4271
-216 2989
-207 4126
-204 2295
-171 3591
-148 4213
-112 3678
-103 4815
-52 1976
-43 3113
0 0
9 1137
16 3200
56 1918
65 3055
68 1224
101 2520
124 3142
160 2607
169 3744
196 2072
205 3209
252 3990
261 5127
264 3296
304 2014
313 3151
320 5214
372 3238
432 1536
468 1001
477 2138
524 2919
536 2225
576 943
585 2080
628 3608
644 2167
680 1632
736 3550
772 3015
781 4152
840 4239
900 2537
952 561
1008 2479
1044 1944
1053 3081
1148 2633
1204 4551
1256 2575
1420 1562
1528 1504
1724 3576
"""
P = [tuple(int(w) for w in l.split()) for l in LISTE.strip().splitlines()]
assert all(len(p) == 2 for p in P)

# contrôle 1 : toutes les paires, fractions exactes : (x1 - x2)^2 + (y1 - y2)^2 == 1
def frac(pts):
    return [(Fraction(x, D), Fraction(y, D)) for x, y in pts]

def controle1(F):
    return sum(1 for i in range(len(F)) for j in range(i) if (F[i][0] - F[j][0]) ** 2 + (F[i][1] - F[j][1]) ** 2 == 1)

# contrôle 2, sans rapport avec le contrôle 1 : en entiers, les vecteurs (a, b) tels que a^2 + b^2 = D^2, puis une recherche dans l'ensemble des points
def vecteurs():
    V = []
    for a in range(-D, D + 1):
        b = isqrt(D * D - a * a)
        if b * b == D * D - a * a:
            V += [(a, b)] if b == 0 else [(a, b), (a, -b)]
    return V

def controle2(pts):
    S, V = set(pts), vecteurs()
    return sum(1 for (x, y) in S for a, b in V if (x + a, y + b) in S) // 2

# canari : un point déplacé d'une quantité infime doit faire perdre des distances unitaires aux deux contrôles
def deplacer(pts, k):
    return [(x + 1, y) if i == k else (x, y) for i, (x, y) in enumerate(pts)]

n1, n2 = controle1(frac(P)), controle2(P)
print("points : %d (distincts : %s) ; dénominateur commun : %d" % (len(P), len(set(P)) == len(P), D))
print("vecteurs entiers (a, b) avec a^2 + b^2 = D^2 : %d" % len(vecteurs()))
print("contrôle 1 (toutes les paires, fractions exactes)  : %d distances unitaires" % n1); print("contrôle 2 (vecteurs de longueur D, entiers)       : %d distances unitaires" % n2)
deg = lambda i: sum(1 for j in range(len(P)) if j != i and (P[i][0] - P[j][0]) ** 2 + (P[i][1] - P[j][1]) ** 2 == D * D)
k = max(range(len(P)), key=deg)
Q = deplacer(P, k)
c1, c2 = controle1(frac(Q)), controle2(Q)
print("canari 1 : point n° %d déplacé de 1/%d en x -> contrôle 1 : %d ; contrôle 2 : %d" % (k, D, c1, c2))
F = frac(P)
F[k] = (F[k][0] + Fraction(1, 10 ** 9), F[k][1])
c3 = controle1(F)
print("canari 2 : point n° %d déplacé de 1/10^9 en x -> contrôle 1 : %d" % (k, c3))
print("empreinte sha256 du fichier JSON reconstruit : %s" % hashlib.sha256(json.dumps({"points": [[[x, D], [y, D]] for x, y in P]}).encode()).hexdigest())
bon = len(P) == 121 and n1 == n2 and c1 < n1 and c2 < n2 and c3 < n1
print("VÉRIFIÉ : %d points distincts, %d distances unitaires aux deux contrôles ; chaque canari fait perdre des distances" % (len(P), n1) if bon else "ÉCHEC")
raise SystemExit(0 if bon else 1)

Ce programme a été exécuté le 13/10/2026 (Python 3.11.0rc2, python -I) sur la configuration publiée. Sortie obtenue :

points : 121 (distincts : True) ; dénominateur commun : 1105
vecteurs entiers (a, b) avec a^2 + b^2 = D^2 : 108
contrôle 1 (toutes les paires, fractions exactes)  : 429 distances unitaires
contrôle 2 (vecteurs de longueur D, entiers)       : 429 distances unitaires
canari 1 : point n° 40 déplacé de 1/1105 en x -> contrôle 1 : 416 ; contrôle 2 : 416
canari 2 : point n° 40 déplacé de 1/10^9 en x -> contrôle 1 : 416
empreinte sha256 du fichier JSON reconstruit : f23f7a70616677fd21d29f19c38b27f70479562e7d3894240ffde8bcbb6af2e1
VÉRIFIÉ : 121 points distincts, 429 distances unitaires aux deux contrôles ; chaque canari fait perdre des distances

Les deux contrôles s’accordent avec le juge du tableau et avec le second chemin. L’empreinte reconstruite par le programme est celle du fichier de la proposition n° 8.

Empreintes sha256

Dépôt public

La configuration est déposée sur le dépôt public du tableau : proposition n° 8 (pull request) de math-market/unit-distances, ouverte le 02/10/2026. Son fichier de points a la même empreinte sha256 que le fichier de cette page. État lu le 13/10/2026 : ouverte, non fusionnée, sans commentaire ni relecture. La configuration est publiée sous licence Apache-2.0, comme l’exige le tableau pour les soumissions (task.json) ; le tableau, son énoncé et son contrôle sont eux aussi sous licence Apache-2.0 (LICENSE du dépôt). Aucune donnée tierce n’entre dans la configuration.

4. Ce que modélise cette question

Cette question relève de la géométrie discrète : combien de paires de n points du plan peuvent être à distance exactement 1 ? Une portion d’un réseau d’entiers de côté √n donne u(n) ≥ n^{1+c/log log n}, et Erdős conjecturait cette croissance exacte (page 84a du suivi des problèmes d’optimisation de Terence Tao, lue le 13/10/2026). Le tableau cite la majoration u(n) = O(n^4/3) (Spencer, Szemerédi et Trotter, 1984).

Selon TASK.md et la page de Tao, un modèle de raisonnement d’OpenAI a réfuté cette conjecture en mai 2026 : des ensembles de n points ont au moins n^1+δ distances unitaires pour un δ > 0 fixé (Alon, Bloom, Gowers, Litt, Sawin, Shankar, Tsimerman, Wang et Wood, arXiv:2605.20695). La construction relève de la théorie des nombres, et TASK.md situe l’exposant c entre 0,03583… et 1/3. Ces énoncés portent sur la croissance quand n tend vers l’infini ; le palier A du tableau, auquel appartient cette page, porte sur des valeurs finies de n. Le tableau retient des coordonnées rationnelles pour que le contrôle soit exact et instantané, note que ces ensembles sont aussi un objet de recherche en soi (Rodis, arXiv:2606.29415) et écarte le réseau triangulaire, qu’il décrit comme optimal mais irrationnel.

Sources : github.com/math-market/unit-distances (README, TASK.md, check.py, task.json, LICENSE, generator_example.py, pull request n° 8, liste des pull requests), oeis.org/A186705, arXiv:2406.15317, arXiv:2606.29415, arXiv:2605.20695 (cité par TASK.md), teorth.github.io/optimizationproblems/constants/84a.html, lus le 13/10/2026.

Un programme de recherche, une épreuve extérieure

Ces résultats couvrent des domaines sans rapport entre eux : la géométrie des empilements (Packomania, Friedman Packing Center), la mécanique spatiale (ESA SpOC 4), la théorie des nombres (IBM Ponder This) et les graphes (FlyWire Codex). Dans chacun, le résultat est inscrit sur la page d’un tiers, table, classement ou liste, et se revérifie par calcul : l’ESA évalue chaque solution avec son simulateur, Packomania publie les entrées qu’il retient, IBM publie une liste de noms, Friedman tient une page qui crédite les auteurs. Ces résultats relèvent d’un même programme de recherche : ne retenir que ce qu’un certificat prouve.

Cette page applique le même principe à un problème de géométrie : une configuration dont la liste complète est publiée, un programme court que chacun exécute, et le juge d’un tableau extérieur qui compte les distances unitaires. Ici, le lecteur revérifie lui-même.

Le principe est public : chaque hypothèse est testée par le calcul et n’est retenue que si un certificat la prouve. Des IA génératives me servent d’assistants, interchangeables : elles proposent, mon IA décide, le certificat tranche. Le fonctionnement interne reste confidentiel. Les résultats, eux, sont publics.

Le certificat change la nature de la preuve. Un résultat se vérifie sans faire confiance à celui qui l’a produit, comme une démonstration se vérifie sans connaître son auteur. C’est ce qui rend cette page possible : vous n’avez pas à me croire, vous revérifiez. Le résultat déposé est figé et son empreinte est publiée.

Tout le travail tourne sur du matériel accessible : un PC de bureau, un Raspberry Pi 5 et un Raspberry Pi Pico, qui servent aussi à vérifier que le calcul reste identique d’une machine à l’autre ; ponctuellement, une instance de 32 processeurs virtuels. Le programme vise une IA embarquée certifiable, jusque sur des machines modestes.

Un résultat vérifiable sans confiance, figé, revérifiable : ces propriétés ouvrent sur les usages visés :

• l’IA embarquée certifiable, jusque sur des machines modestes ;
• le pilotage des IA génératives, dont on ne retient que ce qui est prouvé ;
• l’identité vérifiable des agents d’IA ;
• l’audit après incident : rejouer exactement une décision passée ;
• la science reproductible ;
• la carte ouverte des calculs certifiés : chaque résultat avec son certificat, pour ne pas recalculer ce qui est prouvé.

Le programme de recherche détaille ce cadre. Tous les résultats, avec leurs sources et leurs dates, sont réunis sur la page Résultats.