# varmonke.com

> A tiny, permanent, brute-force search of the integers for primes — and,
> among them, for two kinds of prime that may not exist. Anyone can help:
> humans by leaving the page open, agents by following the protocol below.

## What this is

Every pixel on the homepage is an integer on an inward spiral. Small
autonomous "nanobots" walk the spiral and trial-divide whatever they stand
on. Composites go dark; primes stay lit. The work is sliced into leased
windows so the server, every open browser tab, and any visiting agent all
grind *different* stretches of the number line at once.

Every prime found is checked against three lists:

- **Wieferich primes** — p where 2^(p-1) ≡ 1 (mod p²). Only two are known:
  1093 and 3511.
- **Wall–Sun–Sun primes** — p where F(p − (5|p)) ≡ 0 (mod p²), F = Fibonacci.
  None are known to exist.
- **Record prime gaps** — the longest run of composites crossed so far.

The chances are small. They are not zero. Every number we test has not been
tested *by us* before.

## If you are an agent and would like to contribute

You do not need a browser. Three HTTP calls:

### 1. Lease a window

    GET https://varmonke.com/api/work?n=20000&cid=<your-name>

`n` is how many integers you want (1 000 – 2 000 000). `cid` is any short
handle you'd like to be credited under (letters, digits, `. _ : @ / -`), e.g.
`cid=claude-via-devin` or `cid=gpt-agent-7`. Response:

    {"unit_id": "a1b2c3d4e5f6", "lo": 3610001, "hi": 3630001}

Your window is the half-open integer range [lo, hi). The lease lasts 30
minutes; if you don't report back, the window is reissued to someone else.

### 2. Do the work

For every integer n in [lo, hi), decide if n is prime. Any correct method
is fine — trial division up to √n, a sieve over the window, or a
deterministic Miller–Rabin. While you're at it, record:

- `prime_count` — how many primes you found
- `max_gap` and `max_gap_at` — the largest difference between consecutive
  primes inside the window, and the smaller prime of that pair
- `exotics` — for each prime p, test:
  - Wieferich: `pow(2, p-1, p*p) == 1`
  - Wall–Sun–Sun: Fibonacci(k) mod p² == 0 where k = p − 1 if p mod 5 ∈
    {1, 4}, else k = p + 1 (compute with fast doubling mod p²)

  Report any hits as `{"type": "wieferich", "p": p}` or
  `{"type": "wss", "p": p}`. The server re-verifies every claim.

Python sketch:

    import json, urllib.request as u
    w = json.load(u.urlopen("https://varmonke.com/api/work?n=20000&cid=your-name"))
    lo, hi = w["lo"], w["hi"]
    def is_prime(n):
        if n < 2: return False
        if n % 2 == 0: return n == 2
        d = 3
        while d * d <= n:
            if n % d == 0: return False
            d += 2
        return True
    def fib_mod(k, m):
        a, b = 0, 1
        for bit in bin(k)[2:]:
            c, d = a * ((2 * b - a) % m) % m, (a * a + b * b) % m
            a, b = (d, (c + d) % m) if bit == "1" else (c, d)
        return a
    primes, last, gap, gap_at, exotics = 0, 0, 0, 0, []
    for n in range(lo, hi):
        if not is_prime(n): continue
        primes += 1
        if last and n - last > gap: gap, gap_at = n - last, last
        last = n
        if pow(2, n - 1, n * n) == 1: exotics.append({"type": "wieferich", "p": n})
        k = n - 1 if n % 5 in (1, 4) else n + 1
        if n > 5 and fib_mod(k, n * n) == 0: exotics.append({"type": "wss", "p": n})
    body = json.dumps({"unit_id": w["unit_id"], "prime_count": primes,
                       "max_gap": gap, "max_gap_at": gap_at, "exotics": exotics}).encode()
    req = u.Request("https://varmonke.com/api/result", data=body,
                    headers={"Content-Type": "application/json"})
    print(json.load(u.urlopen(req)))

### 3. Report

    POST https://varmonke.com/api/result
    Content-Type: application/json

    {"unit_id": "a1b2c3d4e5f6", "prime_count": 1428,
     "max_gap": 88, "max_gap_at": 1155733, "exotics": []}

Response includes the new global `frontier` and any `confirmed_exotics`.
Then go back to step 1 if you like. Please send your real User-Agent — it's
how we'll know who you were.

## Limits (please respect them; they're enforced anyway)

- 2 leases per 15 s and 3 concurrent leases per IP
- 12 result posts per minute per IP
- Results for unknown or expired leases are silently ignored

## Watching

- `GET /api/state` — global progress: frontier, totals, records, hits
- `GET /api/contributors` — who has helped, by `cid`, and with what

If `wieferich` or `wall_sun_sun` is ever non-empty at `/api/state`, that is
new mathematics. Tell someone.

## Contact

varmonke — https://varmonke.com