proofs / mathematics

"641 divides \(2^{32} + 1\) exactly."

mathematics · generated 2026-03-28 · v0.10.0
PROVED pure computation — no citations
Verified by computation — no external sources required.
⬡ Verified by Proof Engine — an open-source tool that verifies claims using cited sources and executable code. Reasoning transparent and auditable.
methodology · github · re-run this proof · submit your own
summary · caveats · audit trail · formats

641 divides 2^32 + 1 without a remainder — and this result was confirmed three independent ways, including by a classical argument that dates back to Euler.

What Was Claimed?

The claim is that 641 divides the number 2^32 + 1 exactly, meaning no remainder is left over. That number — 2^32 + 1, which equals 4,294,967,297 — is historically significant. Fermat conjectured in the 1600s that all numbers of this form (1 plus a power-of-two exponent that is itself a power of two) are prime. This claim is a direct test of whether Fermat was wrong about the fifth such number.

What Did We Find?

The most direct check: compute 4,294,967,297 divided by 641 and look at the remainder. The remainder is zero. That alone is sufficient to confirm the claim.

To make sure the result wasn't a fluke of how the arithmetic was done, a second method reconstructed the original number from scratch. Dividing 4,294,967,297 by 641 gives a quotient of 6,700,417 with nothing left over. Multiplying back — 641 times 6,700,417 — returns exactly 4,294,967,297. The numbers agree to the last digit.

A third approach follows Euler's own 18th-century proof. The number 641 can be written two different ways: as 5^4 + 2^4, and as 5 × 2^7 + 1. These two representations can be combined through a short chain of modular arithmetic to show that 2^32 must be congruent to −1 modulo 641 — which is just another way of saying that adding 1 makes it divisible by 641. This approach uses no division at all, yet reaches the same conclusion.

All three methods agree. The complete factorization of 4,294,967,297 is 641 × 6,700,417. Both of those factors are prime, so this is as far as the number breaks down.

What Should You Keep In Mind?

The arithmetic here is exact — there's no rounding, no estimation. Python's integers can be arbitrarily large, so computing with a 10-digit number introduces no precision risk.

The claim doesn't require 641 to be prime (though it is). "Divides exactly" just means remainder zero, and that's what was tested.

This result disproves Fermat's conjecture for F_5, but it says nothing about the other Fermat numbers. Some are prime; many others are composite. The pattern Fermat hoped for doesn't hold in general, and this specific number is the most famous counterexample.

One thing worth appreciating: the fact that 641 has the dual representations 5^4 + 2^4 and 5 × 2^7 + 1 isn't a coincidence used in hindsight — Euler deliberately sought a number with both properties, knowing that structure would force divisibility. It's a rare case where a proof from three centuries ago can be re-run as working code and confirmed digit-by-digit.

How Was This Verified?

This result was produced using the proof-engine framework, which runs automated computation, cross-checks results using independent methods, and tests adversarial scenarios before returning a verdict. The full reasoning is in the structured proof report, every computation step is logged in the full verification audit, and you can re-run the proof yourself.

What could challenge this verdict?

Source: proof.py JSON summary

detailed evidence

Detailed Evidence ▸

Evidence Summary

ID Fact Verified
A1 Direct modular arithmetic: (2^32 + 1) mod 641 Computed: 0 (641 divides 2^32 + 1 with no remainder)
A2 Integer division cross-check: 2^32 + 1 == 641 x quotient Computed: True (641 x 6,700,417 = 4,294,967,297)
A3 Algebraic decomposition via Euler's method Computed: 2^32 mod 641 = 640, so (2^32 + 1) mod 641 = 0

Source: proof.py JSON summary

Proof Logic

The proof establishes divisibility through three mathematically independent methods:

Method 1 — Direct modular arithmetic (A1): Python's arbitrary-precision integers compute (2^32 + 1) % 641 = 0 directly. Since the remainder is zero, 641 divides 2^32 + 1.

Method 2 — Integer division reconstruction (A2): Using divmod(4294967297, 641), we obtain quotient 6,700,417 and remainder 0. Multiplying back: 641 x 6,700,417 = 4,294,967,297, which equals 2^32 + 1 exactly.

Method 3 — Euler's algebraic decomposition (A3): Euler's classical proof relies on two identities: 641 = 5^4 + 2^4 and 641 = 5 x 2^7 + 1. From the second identity, 5 x 2^7 is congruent to -1 (mod 641). Raising to the 4th power gives 5^4 x 2^28 congruent to 1 (mod 641). From the first identity, 5^4 is congruent to -2^4 (mod 641). Substituting: -2^4 x 2^28 = -2^32 is congruent to 1 (mod 641), so 2^32 is congruent to -1 (mod 641), meaning 2^32 + 1 is congruent to 0 (mod 641).

All three methods independently confirm the claim.

Source: author analysis

Conclusion

PROVED. 641 divides 2^32 + 1 exactly. Direct computation shows (2^32 + 1) mod 641 = 0, confirmed independently by integer division (4,294,967,297 = 641 x 6,700,417) and by Euler's algebraic decomposition. The complete prime factorization of the fifth Fermat number is 4,294,967,297 = 641 x 6,700,417.

audit trail

Claim Specification ▸
Field Value
Subject 2^32 + 1 (the fifth Fermat number, F_5)
Property (2^32 + 1) mod 641
Operator ==
Threshold 0
Operator note 'Divides exactly' means 641 is a factor of 2^32 + 1, i.e., (2^32 + 1) mod 641 == 0. This is equivalent to showing 2^32 + 1 = 641 * k for some positive integer k.

Source: proof.py JSON summary

Claim Interpretation ▸

Natural language: 641 divides 2^{32} + 1 exactly.

Formal interpretation: "Divides exactly" means 641 is a factor of 2^32 + 1, i.e., (2^32 + 1) mod 641 == 0. This is equivalent to showing 2^32 + 1 = 641 x k for some positive integer k. The number 2^32 + 1 = 4,294,967,297 is the fifth Fermat number (F_5), historically conjectured by Fermat to be prime. Euler disproved this by finding that 641 divides it.

Source: proof.py JSON summary

Computation Traces ▸ 
2^32 + 1 = 4294967297
  A1: (2^32 + 1) mod 641: fermat_5 % 641 = 4294967297 % 641 = 0

Cross-check 1 (integer division):
  divmod(2^32 + 1, 641) = quotient=6700417, remainder=0
  A2: 641 * quotient: 641 * quotient = 641 * 6700417 = 4294967297
  A2: 641 * quotient == 2^32 + 1: 4294967297 == 4294967297 = True

Cross-check 2 (Euler's algebraic decomposition):
  A3a: 5^4 + 2^4: 5**4 + 2**4 = 5 ** 4 + 2 ** 4 = 641
  A3a: 5^4 + 2^4 == 641: 641 == 641 = True
  A3b: 5 * 2^7 + 1: 5 * 2**7 + 1 = 5 * 2 ** 7 + 1 = 641
  A3b: 5 * 2^7 + 1 == 641: 641 == 641 = True
  A3c: (5 * 2^7)^4 mod 641: pow(5 * 128, 4, 641) = 1
  A3d: 5^4 mod 641: pow(5, 4, 641) = 625
  A3e: -2^4 mod 641: (-pow(2, 4, 641)) % 641 = -pow(2, 4, 641) % 641 = 625
  A3: 5^4 ≡ -2^4 (mod 641): 625 == 625 = True
  A3f: 2^32 mod 641: pow(2, 32, 641) = 640
  A3: (2^32 + 1) mod 641 == 0 via Euler: 0 == 0 = True

Adversarial: trial division to verify 641 is smallest prime factor
  Smallest factor of 4294967297 found by trial division: 641
  Cofactor: 4294967297 / 641 = 6700417
  Cofactor 6700417 is prime: True
  Complete factorization: 4294967297 = 641 × 6700417
  VERDICT: (2^32 + 1) mod 641 == 0: 0 == 0 = True

Source: proof.py inline output (execution trace)

Adversarial Checks ▸
# Question Verification Performed Finding Breaks Proof?
1 Could the computation overflow or lose precision? Python integers have arbitrary precision — no overflow is possible. 2^32 + 1 = 4294967297, well within exact integer range. The modular arithmetic uses Python's built-in integer mod, which is exact. No precision issue. Python integers are arbitrary-precision. No
2 Is 641 the smallest prime factor of 2^32 + 1? Checked by trial division: no prime less than 641 divides 4294967297. The cofactor 4294967297 / 641 = 6700417, which is itself prime. Thus 4294967297 = 641 × 6700417 is the complete factorization. 641 is indeed the smallest prime factor. Confirmed by trial division. No
3 Does 'divides exactly' require that 641 is a prime factor, or just a factor? The claim says '641 divides 2^{32} + 1 exactly', which in standard number theory means 641 | (2^32 + 1), i.e., the remainder is zero. The claim does not require 641 to be prime (though it is). Our proof shows the remainder is 0, which is sufficient for the claim as stated. The interpretation is correct. 'Divides exactly' means zero remainder. No

Source: proof.py JSON summary

Quality Checks ▸
Rule Status
Rule 1: Every empirical value parsed from quote text N/A — pure computation, no empirical facts
Rule 2: Every citation URL fetched and quote checked N/A — pure computation, no empirical facts
Rule 3: System time used for date-dependent logic Pass — date.today() used for generated_at
Rule 4: Claim interpretation explicit with operator rationale Pass — CLAIM_FORMAL with operator_note present
Rule 5: Adversarial checks searched for counter-evidence Pass — 3 adversarial checks documented
Rule 6: Cross-checks used independently sourced inputs N/A — pure computation, no empirical facts. Three independent mathematical methods used.
Rule 7: Constants/formulas imported from computations.py Pass — compare() and explain_calc() used; no hard-coded constants
validate_proof.py result PASS — 14/14 checks passed, 0 issues, 0 warnings

Source: author analysis

Cite this proof 
Proof Engine. (2026). Claim Verification: “641 divides 2³² + 1 exactly.” — Proved. https://proofengine.info/proofs/641-divides-2-32-1-exactly/
Proof Engine. "Claim Verification: “641 divides 2³² + 1 exactly.” — Proved." 2026. https://proofengine.info/proofs/641-divides-2-32-1-exactly/.
@misc{proofengine_641_divides_2_32_1_exactly,
  title   = {Claim Verification: “641 divides 2³² + 1 exactly.” — Proved},
  author  = {{Proof Engine}},
  year    = {2026},
  url     = {https://proofengine.info/proofs/641-divides-2-32-1-exactly/},
  note    = {Verdict: PROVED. Generated by proof-engine v0.10.0},
}
TY  - DATA
TI  - Claim Verification: “641 divides 2³² + 1 exactly.” — Proved
AU  - Proof Engine
PY  - 2026
UR  - https://proofengine.info/proofs/641-divides-2-32-1-exactly/
N1  - Verdict: PROVED. Generated by proof-engine v0.10.0
ER  -
View proof source 209 lines · 9.2 KB

This is the proof.py that produced the verdict above. Every fact traces to code below. (This proof has not yet been minted to Zenodo; the source here is the working copy from this repository.) 

"""
Proof: 641 divides 2^{32} + 1 exactly.
Generated: 2026-03-28
"""
import json
import os
import sys

PROOF_ENGINE_ROOT = os.environ.get("PROOF_ENGINE_ROOT")
if not PROOF_ENGINE_ROOT:
    _d = os.path.dirname(os.path.abspath(__file__))
    while _d != os.path.dirname(_d):
        if os.path.isdir(os.path.join(_d, "proof-engine", "skills", "proof-engine", "scripts")):
            PROOF_ENGINE_ROOT = os.path.join(_d, "proof-engine", "skills", "proof-engine")
            break
        _d = os.path.dirname(_d)
    if not PROOF_ENGINE_ROOT:
        raise RuntimeError("PROOF_ENGINE_ROOT not set and skill dir not found via walk-up from proof.py")
sys.path.insert(0, PROOF_ENGINE_ROOT)
from datetime import date

from scripts.computations import compare, explain_calc

# 1. CLAIM INTERPRETATION (Rule 4)
CLAIM_NATURAL = '641 divides \\(2^{32} + 1\\) exactly.'
CLAIM_FORMAL = {
    "subject": "2^32 + 1 (the fifth Fermat number, F_5)",
    "property": "(2^32 + 1) mod 641",
    "operator": "==",
    "operator_note": (
        "'Divides exactly' means 641 is a factor of 2^32 + 1, "
        "i.e., (2^32 + 1) mod 641 == 0. This is equivalent to showing "
        "2^32 + 1 = 641 * k for some positive integer k."
    ),
    "threshold": 0,
}

# 2. FACT REGISTRY — A-types only for pure math
FACT_REGISTRY = {
    "A1": {"label": "Direct modular arithmetic: (2^32 + 1) mod 641", "method": None, "result": None},
    "A2": {"label": "Integer division cross-check: 2^32 + 1 == 641 * quotient", "method": None, "result": None},
    "A3": {"label": "Algebraic decomposition via Euler's method", "method": None, "result": None},
}

# 3. COMPUTATION — primary method (direct modular arithmetic)
fermat_5 = 2**32 + 1
print(f"2^32 + 1 = {fermat_5}")

remainder = explain_calc("fermat_5 % 641", {"fermat_5": fermat_5}, label="A1: (2^32 + 1) mod 641")

# 4. CROSS-CHECKS — mathematically independent methods (Rule 6)

# Cross-check 1: Integer division — verify 641 * quotient == 2^32 + 1
quotient, check_remainder = divmod(fermat_5, 641)
print(f"\nCross-check 1 (integer division):")
print(f"  divmod(2^32 + 1, 641) = quotient={quotient}, remainder={check_remainder}")
product = explain_calc("641 * quotient", {"quotient": quotient}, label="A2: 641 * quotient")
division_exact = compare(product, "==", fermat_5, label="A2: 641 * quotient == 2^32 + 1")

# Cross-check 2: Euler's algebraic decomposition
# Euler observed: 641 = 5^4 + 2^4 and 641 = 5 * 2^7 + 1
# From 641 = 5 * 2^7 + 1: 5 * 2^7 ≡ -1 (mod 641)
# Raising to 4th power: 5^4 * 2^28 ≡ 1 (mod 641)
# From 641 = 5^4 + 2^4: 5^4 ≡ -2^4 (mod 641)
# Substituting: -2^4 * 2^28 ≡ 1 (mod 641), i.e., -2^32 ≡ 1, i.e., 2^32 ≡ -1 (mod 641)
# Therefore 2^32 + 1 ≡ 0 (mod 641)
print("\nCross-check 2 (Euler's algebraic decomposition):")

# Verify the two key identities
identity_1 = explain_calc("5**4 + 2**4", {}, label="A3a: 5^4 + 2^4")
identity_1_check = compare(identity_1, "==", 641, label="A3a: 5^4 + 2^4 == 641")

identity_2 = explain_calc("5 * 2**7 + 1", {}, label="A3b: 5 * 2^7 + 1")
identity_2_check = compare(identity_2, "==", 641, label="A3b: 5 * 2^7 + 1 == 641")

# From identity_2: 5 * 128 ≡ -1 (mod 641), so (5 * 128)^4 ≡ 1 (mod 641)
step_a = explain_calc("pow(5 * 128, 4, 641)", {}, label="A3c: (5 * 2^7)^4 mod 641")
# This means 5^4 * 2^28 ≡ 1 (mod 641)

# From identity_1: 5^4 ≡ -2^4 (mod 641)
step_b = explain_calc("pow(5, 4, 641)", {}, label="A3d: 5^4 mod 641")
step_b_expected = explain_calc("(-pow(2, 4, 641)) % 641", {}, label="A3e: -2^4 mod 641")
euler_identity_check = compare(step_b, "==", step_b_expected, label="A3: 5^4 ≡ -2^4 (mod 641)")

# Combining: -2^4 * 2^28 ≡ 1 (mod 641) → -2^32 ≡ 1 → 2^32 ≡ -1 → 2^32 + 1 ≡ 0
euler_final = explain_calc("pow(2, 32, 641)", {}, label="A3f: 2^32 mod 641")
euler_conclusion = compare((euler_final + 1) % 641, "==", 0, label="A3: (2^32 + 1) mod 641 == 0 via Euler")

# Verify all cross-checks agree
assert remainder == 0, f"Primary check failed: remainder = {remainder}"
assert check_remainder == 0, f"Cross-check 1 failed: remainder = {check_remainder}"
assert division_exact, "Cross-check 1 failed: product != fermat_5"
assert identity_1_check, "Euler identity 1 failed"
assert identity_2_check, "Euler identity 2 failed"
assert euler_conclusion, "Euler algebraic proof failed"

# 5. ADVERSARIAL CHECKS (Rule 5)
adversarial_checks = [
    {
        "question": "Could the computation overflow or lose precision?",
        "verification_performed": (
            "Python integers have arbitrary precision — no overflow is possible. "
            "2^32 + 1 = 4294967297, well within exact integer range. "
            "The modular arithmetic uses Python's built-in integer mod, which is exact."
        ),
        "finding": "No precision issue. Python integers are arbitrary-precision.",
        "breaks_proof": False,
    },
    {
        "question": "Is 641 the smallest prime factor of 2^32 + 1?",
        "verification_performed": (
            "Checked by trial division: no prime less than 641 divides 4294967297. "
            "The cofactor 4294967297 / 641 = 6700417, which is itself prime. "
            "Thus 4294967297 = 641 × 6700417 is the complete factorization."
        ),
        "finding": "641 is indeed the smallest prime factor. Confirmed by trial division below.",
        "breaks_proof": False,
    },
    {
        "question": "Does 'divides exactly' require that 641 is a prime factor, or just a factor?",
        "verification_performed": (
            "The claim says '641 divides 2^{32} + 1 exactly', which in standard number theory "
            "means 641 | (2^32 + 1), i.e., the remainder is zero. The claim does not require "
            "641 to be prime (though it is). Our proof shows the remainder is 0, which is "
            "sufficient for the claim as stated."
        ),
        "finding": "The interpretation is correct. 'Divides exactly' means zero remainder.",
        "breaks_proof": False,
    },
]

# Adversarial computation: verify 641 is smallest prime factor by trial division
print("\nAdversarial: trial division to verify 641 is smallest prime factor")
smallest_factor = None
for p in range(2, 642):
    if fermat_5 % p == 0:
        smallest_factor = p
        break
print(f"  Smallest factor of {fermat_5} found by trial division: {smallest_factor}")
assert smallest_factor == 641, f"Expected 641, got {smallest_factor}"

# Verify cofactor is prime
cofactor = fermat_5 // 641
print(f"  Cofactor: {fermat_5} / 641 = {cofactor}")
cofactor_is_prime = all(cofactor % i != 0 for i in range(2, int(cofactor**0.5) + 1))
print(f"  Cofactor {cofactor} is prime: {cofactor_is_prime}")
print(f"  Complete factorization: {fermat_5} = 641 × {cofactor}")

# 6. VERDICT AND STRUCTURED OUTPUT
if __name__ == "__main__":
    claim_holds = compare(remainder, CLAIM_FORMAL["operator"], CLAIM_FORMAL["threshold"],
                          label="VERDICT: (2^32 + 1) mod 641 == 0")

    verdict = "PROVED" if claim_holds else "DISPROVED"

    FACT_REGISTRY["A1"]["method"] = "Python exact integer arithmetic: (2**32 + 1) % 641"
    FACT_REGISTRY["A1"]["result"] = str(remainder)
    FACT_REGISTRY["A2"]["method"] = "Integer division: divmod(2^32 + 1, 641) then verify 641 * quotient == 2^32 + 1"
    FACT_REGISTRY["A2"]["result"] = f"quotient={quotient}, remainder={check_remainder}, 641*{quotient}={product}"
    FACT_REGISTRY["A3"]["method"] = (
        "Euler's algebraic decomposition: 641 = 5^4 + 2^4 = 5*2^7 + 1, "
        "therefore 5^4 ≡ -2^4 and 5*2^7 ≡ -1 (mod 641), "
        "combining gives 2^32 ≡ -1 (mod 641)"
    )
    FACT_REGISTRY["A3"]["result"] = f"2^32 mod 641 = {euler_final}, so (2^32 + 1) mod 641 = {(euler_final + 1) % 641}"

    summary = {
        "fact_registry": {
            fid: {k: v for k, v in info.items()}
            for fid, info in FACT_REGISTRY.items()
        },
        "claim_formal": CLAIM_FORMAL,
        "claim_natural": CLAIM_NATURAL,
        "cross_checks": [
            {
                "description": "Integer division: 641 * quotient reconstructs 2^32 + 1",
                "values_compared": [str(product), str(fermat_5)],
                "agreement": product == fermat_5,
            },
            {
                "description": "Euler's algebraic decomposition confirms 2^32 ≡ -1 (mod 641)",
                "values_compared": [str(euler_final), str(641 - 1)],
                "agreement": euler_conclusion,
            },
        ],
        "adversarial_checks": adversarial_checks,
        "verdict": verdict,
        "key_results": {
            "fermat_5": fermat_5,
            "remainder": remainder,
            "quotient": quotient,
            "cofactor": cofactor,
            "cofactor_is_prime": cofactor_is_prime,
            "complete_factorization": f"{fermat_5} = 641 × {cofactor}",
            "threshold": CLAIM_FORMAL["threshold"],
            "operator": CLAIM_FORMAL["operator"],
            "claim_holds": claim_holds,
        },
        "generator": {
            "name": "proof-engine",
            "version": open(os.path.join(PROOF_ENGINE_ROOT, "VERSION")).read().strip(),
            "repo": "https://github.com/yaniv-golan/proof-engine",
            "generated_at": date.today().isoformat(),
        },
    }

    print("\n=== PROOF SUMMARY (JSON) ===")
    print(json.dumps(summary, indent=2, default=str))

↓ download proof.py

Re-execute this proof

The verdict above is cached from when this proof was minted. To re-run the exact proof.py shown in "View proof source" and see the verdict recomputed live, launch it in your browser — no install required.

Re-execute from GitHub commit 1ba3732 — same bytes shown above.

▶ Re-execute in Binder runs in your browser · ~60s · no install

First run takes longer while Binder builds the container image; subsequent runs are cached.

machine-readable formats

⬡ Jupyter Notebook interactive re-verification ⟳ W3C PROV-JSON provenance trace ⧉ RO-Crate 1.1 research object package
Downloads & raw data
↓ structured proof report ↓ narrative summary ↓ run the proof (Python) ↓ original audit log view on github raw data (JSON)
machine-readable formats
↓ interactive notebook (.ipynb) ↓ provenance trace (W3C PROV) ↓ research package (RO-Crate 1.1)

Generated by proof-engine v0.10.0 on 2026-03-28.

found this useful? ★ star on github