Bellpair

The arithmetic contribution

A finite address for a growing count.

Divide the nonzero residues of an integer into digit bins. Multiply each residue by the number base and reduce it back into range. Count the residues that remain in their original bin: that is a digit collision.

The count appears to require visiting every position. The finite determination theorem gives it directly as a known scale term plus a table entry. For any integer coprime to the base, its final two digits select that entry.

The table stays fixed as the integer grows. Reading a larger integer and checking primality still cost work; the theorem removes enumeration from the collision calculation.

Reflection gives each fingerprint a counterpart.

In base b, an ending a is paired with b² − a. Their raw table entries add to −1. Doubling each entry and adding one gives equal and opposite integer weights.

Bellpair assigns those two roles before the search starts. Each role needs a SHA-256-derived prime with its prescribed ending. Once both contributions pass their checks, the centered balance is zero by construction.

This is a classical arithmetic relationship. The hash target and prime search provide the work; the reflection law supplies the matching rule.

A receipt tied to one challenge.

1. Issue the challenge. Bind a fresh identifier, message hash, base, reflection pair, difficulty and expiry into the work.
2. Find both contributions. Each nonce must yield a qualifying hash and a 64-bit prime with the assigned ending.
3. Check the witness. Recompute both hashes and candidates, prove primality in the specified range, and check the endings and fingerprints.
4. Consume the receipt. Accept the issued challenge once. A changed proof or a second redemption is rejected.

The local C/GMP implementation runs the full exchange, including cancellation and an independent verifier. The public demonstration retains a real receipt for every base from 2 to 36.

The cost of the construction.

The original reference run adds one filter at a time at the same hash difficulty. It uses one worker, twelve pairs per method, and the decimal 09/91 pair at 6, 8 and 10 bits.

Repeated arithmetic verification averaged 0.031 ms over 1,000 repetitions. These timings exclude process startup and HTTP overhead.

These results isolate the cost of each added constraint at the same hash difficulty. Use them as a starting point for comparisons at matched total solving cost.

Put the lab to work.

Bellpair gives you a complete local experiment and reusable native components. Start with the lab, then adapt the challenge-and-receipt workflow to a question you want to test.

Work-backed forms and submissions

Prototype a small computation requirement for contact forms, sign-ups or public submissions. Bind each receipt to its submission and test the cost of sending them in bulk.

Agent and API workflows

Explore per-action work requirements for automated tool calls and job queues. An agent can solve a challenge and return a receipt that another program checks automatically.

Protocol design and benchmarking

Compare number bases, difficulty and the two search roles. Measure how design choices change completion time and verification cost, using the C/GMP implementation as a starting point.

Security teaching and testing

Follow a proof from challenge to acceptance. Change its bytes, let it expire or submit it twice, and inspect what the verifier and issuer do. The code makes each step visible.

The repository includes the protocol specification, C/GMP solver and verifier, tampering and replay checks, and recorded benchmarks. MIT licensing lets you modify the implementation and build on it.

From one pair to richer arithmetic rules.

The collision invariant extends beyond one digit shift. Longer shifts have their own finite residue addresses and reflection laws. They supply a concrete direction for exploring receipts with several related arithmetic requirements.

The lab provides a way to study those choices in practice: match expected worker cost, vary the arithmetic rules, and measure completion time, verification and behavior when clients abandon challenges.