Can a Computer Discover Mathematical Truths Humans Cannot Easily Prove?

Chapter 1 — Discovery versus proof

Mathematics runs on a status ladder: conjecture proposed → examples tested → counterexample search survived (so far) → proof drafted → formally verified → independently reviewed. Each rung eliminates a different failure. Symbolic computation explores exactly; numerical exploration explores fast and approximately; automated theorem provers search for derivations; proof assistants check them (Article 01). A conjecture that survives testing has earned investigation, not belief — the difference between a lead and a theorem is the whole subject of this article.

Chapter 2 — Symbolic and numerical exploration

Computer algebra manipulates exact symbols (x²−1 = (x−1)(x+1), always); floating point approximates (0.1 + 0.2 ≠ 0.3 in binary, famously). Pattern discovery mines sequences for candidate identities; counterexample search is its adversarial twin. The lab below uses exact integer arithmetic throughout, so its verdicts — “counterexample at n=40” — are mathematically certain for the range searched, and honestly silent beyond it.

def is_prime(x):
    if x < 2: return False
    d = 2
    while d * d <= x:
        if x % d == 0: return False
        d += 1
    return True

counterexample = next(n for n in range(100) if not is_prime(n*n + n + 41))
print(counterexample)  # 40 (executed): the 40-case winning streak ends

Chapter 3 — Automated theorem proving

ESTABLISHED landscape: resolution and SAT/SMT solvers settle logical and arithmetic goals by search; term rewriting simplifies symbolic expressions; type-theoretic assistants (Lean, Isabelle [1][2]) build proof terms a kernel can check. Search differs from verification in cost and in failure mode: a timed-out search says nothing, a checked proof says everything — about its formal statement. Small example to feel the asymmetry: finding integer solutions to x² = 2 searches forever; proving none exist is one parity argument — once someone hands it to the checker.

Chapter 4 — Gödel's incompleteness theorems, carefully

ESTABLISHED (Gödel, 1931), with assumptions stated: any consistent, effectively axiomatized formal system capable of expressing elementary arithmetic (1) contains statements it can neither prove nor refute, and (2) cannot prove its own consistency. It does not follow that specific practical truths are unknowable, that humans exceed machines, or that mathematics is broken — every working proof assistant thrives inside these limits daily.

Chapter 5 — Can machines find unexpected results?

Demonstrated (in the literature, at varying scales): automated conjecture generation over graph invariants, symbolic regression rediscovering physical laws from data, and AI-assisted proof steps inside formal libraries. The honest taxonomy: machines are tireless at enumeration, pattern-matching and checking; humans remain central to choosing what matters and judging novelty — and every “machine discovery” headline deserves the question this article trains: which rung of the ladder, exactly, was reached, and who verified it?

Chapter 6 — Mathematical discovery lab

Below: pick a claim, set a bound, and let exact arithmetic vote. One claim (Σi³ = (Σi)²) is a true theorem that survives; the other (n²+n+41 always prime) dies at n=40 after forty straight wins. The lab stores nothing and proves nothing universal — it demonstrates the epistemology: survival is provisional, death is final.

# Status dashboard discipline, in code: never print 'proved' for a tested claim.
def test_identity(bound):
    for n in range(1, bound + 1):
        if sum(i**3 for i in range(1, n+1)) != (n*(n+1)//2)**2:
            return ('counterexample', n)
    return ('tested_survived', bound)  # NOT ('proved',) - ever (executed to 50)

Chapter 7 — Formalizing a discovery

Take Σi³ = (Σi)² through the pipeline: informal pattern → precise statement (for all natural n…) → proof by induction (base n=1; step: assume for n, algebra gives n+1) → counterexample search (survives, as it must) → formal specification in a proof assistant → kernel verification → documented theorem. Each arrow is a place where informality leaks; the formalization bottleneck — translating intent into definitions — is where most real projects spend their hours (Chapter 8's frontier).

Chapter 8 — Research frontiers

OPEN fronts: AI-guided tactic search that proposes checkable steps, growing formal libraries that make the next formalization cheaper, conjecture generation with novelty filters, and proof explanation for human readers. Conclusion: computers already discover — patterns, counterexamples, occasionally proof steps — under human direction and machine checking. Truth, however, still enters only through the narrow gate labelled proof. Play with the bound below and watch forty confirmations lose to a single counterexample; that asymmetry is mathematics working as intended.