Research · Discrete geometry · unit distances

Unit distances between rational points: 121 points, 429 distances

This page presents a piece of research in discrete geometry: a set of 121 points of the plane with rational coordinates, of which 429 pairs are at distance exactly 1. It shows the exact statement, the landscape of public values with their sources, then the whole configuration, with a short program that anyone runs to recheck it.

1. The problem

How many pairs of n points in the plane can be at distance exactly 1? Let u(n) be that maximum. Erdős asked the question in 1946; the board recalls the upper bound u(n) = O(n^4/3) (Spencer, Szemerédi and Trotter, 1984). For points with rational coordinates, let u_Q(n) be the greatest number of unit distances among n distinct points of the plane with rational coordinates.

The board’s statement: “How many pairs of n points in the plane can be at distance exactly 1? Let u(n) be the max.” and, for Tier A, “most unit distances among n rational points”. That is: a set of distinct points, each coordinate being an integer, a fraction “p/q” or a pair [numerator, denominator]; the board’s checker (check.py) counts the pairs at distance exactly 1, in exact rational arithmetic and without floating point, and that number is the score. Source: github.com/math-market/unit-distances, file TASK.md, read on 13 Oct 2026; the board and its checker are published under the Apache-2.0 licence.

On the left, the diagram shows four rational points A (0, 0), B (3/5, 4/5), D (1, 0) and C (8/5, 4/5): the four sides are at distance exactly 1, for instance (3/5)² + (4/5)² = 1, and the diagonals are not. On the right, point C is moved by 1/10: sides BC and DC stop being at distance 1, and two unit distances remain. A set is judged this way, pair by pair, with no approximation.

2. The public landscape

The table gathers the public numbers around n = 121, with their source and reading date. They are the landmarks of the problem: they place the known values. The first three rows concern the real plane, where points need not be rational.

Readings of 13 Oct 2026: board math-market/unit-distances (README, TASK.md, check.py, task.json, generator_example.py, list of pull requests), OEIS A186705, arXiv:2406.15317v3, arXiv:2606.29415v2.

For points with rational coordinates, the sources cited give no table of values by n. The board writes “Beat the best known for your n” without publishing values; the submissions/ folder of its repository holds only its README, and the seven other pull requests of the repository concern the board’s infrastructure (titles read). Rodis’s paper (arXiv:2606.29415v2, 3 September 2026), which the board cites, explores the rational plane to build a graph of 2,411,001 vertices and 33,237,700 unit distances; its text gives no numerical values for sets of modest size, and its repository publishes whole graphs (up to 2.4 million vertices), not a table by n (text read in full, repository pages read on 13 Oct 2026). In the real plane, u(n) is known exactly for n ≤ 21 (OEIS A186705, 57 at n = 21); for n from 22 to 100, the table of Engel et al. gives the largest value found by their search, up to 439 at n = 100. The graphs of that table are subsets of the Moser lattice, generated by 1, ω₁, ω₃ and ω₁ω₃, where ω₁ and ω₃ are roots of x² − x + 1 and of x² − (5/3)x + 1 (Theorem 2.3 of the paper): their points do not, in general, have rational coordinates.

At the readings of 13 Oct 2026, 429 is the largest value published for the number of unit distances among 121 points with rational coordinates in the sources cited above, and the only one: those sources give no value for rational points at this n. It is not the exact value of u_Q(121). It does not compare directly with the real-plane table: in the real plane, u(121) ≥ 439 (a set of 100 points completed with 21 isolated points), and the table gives 429 for 98 points.

3. The result

The set has 121 distinct points with rational coordinates and 429 pairs at distance exactly 1, hence u_Q(121) ≥ 429. Each coordinate is given as a numerator over the common denominator 1,105: point i is (x_i/1,105, y_i/1,105).

All 121 points are published. The file in the board’s format is unit_distances_n121.json (3,619 bytes); the same points are given below as a list of numerators, built into the recheck program.

The checks

Four checks, replayed on 13 Oct 2026 on the points file:

Output of the board judge on the configuration:

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

Output of the judge on the configuration with point no. 40 moved by 1/10⁹ in x:

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

Recheck it yourself

The program below contains the configuration. Save it in a file verifier_distances.py and run python verifier_distances.py: Python 3 is enough, with no library to install. Each line of the list gives the two numerators of a point over the common denominator. The program applies two checks of different natures, replays two canaries (the point of highest degree moved by a tiny amount: both checks must count fewer distances) and prints the fingerprint of the rebuilt JSON file, to be compared with the one in section 3. Saveable version: verifier_distances_en.py.

# verifier_distances.py: standard library only; python verifier_distances.py
import hashlib, json
from fractions import Fraction
from math import isqrt

D = 1105
# the configuration: one line per point "x y", as numerators over the common denominator D (the point is (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)

# check 1: every pair, exact fractions: (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)

# check 2, unrelated to check 1: in integers, the vectors (a, b) with a^2 + b^2 = D^2, then a lookup in the set of 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

# canary: a point moved by a tiny amount must lose unit distances in both checks
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 (distinct: %s); common denominator: %d" % (len(P), len(set(P)) == len(P), D))
print("integer vectors (a, b) with a^2 + b^2 = D^2: %d" % len(vecteurs()))
print("check 1 (every pair, exact fractions)      : %d unit distances" % n1); print("check 2 (integer vectors of length D)      : %d unit distances" % 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("canary 1: point no. %d moved by 1/%d in x -> check 1: %d; check 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("canary 2: point no. %d moved by 1/10^9 in x -> check 1: %d" % (k, c3))
print("sha256 fingerprint of the rebuilt JSON file: %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("VERIFIED: %d distinct points, %d unit distances in both checks; each canary loses distances" % (len(P), n1) if bon else "FAILURE")
raise SystemExit(0 if bon else 1)

This program was run on 13 Oct 2026 (Python 3.11.0rc2, python -I) on the published configuration. Output obtained:

points: 121 (distinct: True); common denominator: 1105
integer vectors (a, b) with a^2 + b^2 = D^2: 108
check 1 (every pair, exact fractions)      : 429 unit distances
check 2 (integer vectors of length D)      : 429 unit distances
canary 1: point no. 40 moved by 1/1105 in x -> check 1: 416; check 2: 416
canary 2: point no. 40 moved by 1/10^9 in x -> check 1: 416
sha256 fingerprint of the rebuilt JSON file: f23f7a70616677fd21d29f19c38b27f70479562e7d3894240ffde8bcbb6af2e1
VERIFIED: 121 distinct points, 429 unit distances in both checks; each canary loses distances

Both checks agree with the board judge and with the second path. The fingerprint rebuilt by the program is that of the file of proposal no. 8.

sha256 fingerprints

Public repository

The configuration is filed on the board’s public repository: proposal no. 8 (pull request) of math-market/unit-distances, opened on 2 Oct 2026. Its file of points has the same sha256 fingerprint as the file of this page. State read on 13 Oct 2026: open, not merged, no comment and no review. The configuration is published under the Apache-2.0 licence, as the board requires for submissions (task.json); the board, its statement and its checker are also under the Apache-2.0 licence (LICENSE of the repository). No third-party data enters the configuration.

4. What this question models

This question belongs to discrete geometry: how many pairs of n points of the plane can be at distance exactly 1? A portion of an integer lattice of side √n gives u(n) ≥ n^{1+c/log log n}, and Erdős conjectured this growth to be sharp (page 84a of Terence Tao’s optimization-problems tracker, read on 13 Oct 2026). The board cites the upper bound u(n) = O(n^4/3) (Spencer, Szemerédi and Trotter, 1984).

According to TASK.md and Tao’s page, an OpenAI reasoning model disproved this conjecture in May 2026: sets of n points have at least n^1+δ unit distances for a fixed δ > 0 (Alon, Bloom, Gowers, Litt, Sawin, Shankar, Tsimerman, Wang and Wood, arXiv:2605.20695). The construction belongs to number theory, and TASK.md places the exponent c between 0.03583… and 1/3. These statements concern growth as n tends to infinity; the board’s Tier A, to which this page belongs, concerns finite values of n. The board retains rational coordinates so that the check is exact and instant, notes that these sets are also a research object in their own right (Rodis, arXiv:2606.29415) and sets aside the triangular lattice, which it describes as optimal but irrational.

Sources: github.com/math-market/unit-distances (README, TASK.md, check.py, task.json, LICENSE, generator_example.py, pull request no. 8, list of pull requests), oeis.org/A186705, arXiv:2406.15317, arXiv:2606.29415, arXiv:2605.20695 (cited by TASK.md), teorth.github.io/optimizationproblems/constants/84a.html, read on 13 Oct 2026.

A research programme, an outside test

These results cover domains with nothing to do with each other: the geometry of packings (Packomania, Friedman Packing Center), space mechanics (ESA SpOC 4), number theory (IBM Ponder This) and graphs (FlyWire Codex). In each, the result is entered on a third party’s page, a table, a ranking or a list, and can be rechecked by computation: ESA evaluates each solution with its simulator, Packomania publishes the entries it accepts, IBM publishes a list of names, Friedman keeps a page that credits authors. These results belong to a single research programme: keep only what a certificate proves.

This page applies the same principle to a problem in geometry: a configuration whose complete list is published, a short program that anyone runs, and the judge of an outside board that counts the unit distances. Here, the reader rechecks it personally.

The principle is public: every hypothesis is tested by computation and kept only if a certificate proves it. Generative AIs serve me as assistants, interchangeable ones: they propose, my AI decides, the certificate settles. The internal workings remain confidential. The results are public.

The certificate changes the nature of proof. A result can be checked without trusting whoever produced it, as a proof can be checked without knowing its author. That is what makes this page possible: you do not have to believe me, you recheck. The submitted result is fixed and its fingerprint is published.

All the work runs on accessible hardware: a desktop PC, a Raspberry Pi 5 and a Raspberry Pi Pico, which also serve to check that the computation stays identical from one machine to another; occasionally, a 32-vCPU instance. The programme aims at a certifiable embedded AI, down to modest machines.

A result that is verifiable without trust, fixed and rechecked: these properties open onto the intended uses:

• certifiable embedded AI, down to modest machines;
• steering generative AIs, keeping only what is proven;
• verifiable identity for AI agents;
• audit after an incident: replaying a past decision exactly;
• reproducible science;
• an open map of certified computations: each result with its certificate, so that what is proven is not recomputed.

The research programme sets out this framework. All the results, with their sources and dates, are gathered on the Results page.