Research & development
Less computation.
Exact results.
Our research replaces exhaustive digit-collision counts with exact formulas and finite tables. The same work establishes reflection laws and relationships across number bases and digit shifts. Boston Agile Labs develops these results into algorithms, tools and protocols.
Bellpair applies the reflection law to verifiable computational work. Its open-source lab lets you generate challenges, inspect receipts, and compare the cost of producing and checking a result.
Current project · Bellpair
Build on a working
solver and verifier.
Working prototype · bases 2–36
Start with a complete challenge-and-receipt implementation instead of writing the plumbing. The C/GMP solver finds two primes with prescribed arithmetic fingerprints. A separate verifier checks the result, and the local server tracks expiry and one-time acceptance.
Use it to compare number bases, measure search and verification, inspect the proof bytes, or test how changed and replayed receipts are rejected. The code is MIT-licensed so you can modify the construction and run your own experiments.
Build, measure, explore
Reasons to try Bellpair.
Run the lab for protocol experiments and teaching, or use its solver and verifier to prototype a work requirement in your own application.
- 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.
Exact calculation
Calculate the count.
Skip the enumeration.
A direct digit-collision count checks each nonzero residue. The finite determination theorem gives the same answer from an integer division and a table entry. The result is exact.
The table depends on the number base, not on the size of the integer. Below, a small example and a 64-bit prime use the same table. Change the base to see the reduction yourself.
This reduces the collision calculation. Finding a prime that satisfies a Bellpair challenge is a separate search, measured in the lab.
How the calculation worksA small coprime integer
10F
Written in base 16
- Residues in the full count
- 270
- Known scale term
- 16
- Table fingerprint
- +14
- Collision count
- 30
A prime from the recorded receipt
F85A32126989C20F
Written in base 16
- Residues in the full count
- 17,895,671,123,971,523,086
- Known scale term
- 1,118,479,445,248,220,192
- Table fingerprint
- +14
- Collision count
- 1,118,479,445,248,220,206
Collision count = known scale term + table fingerprint
The counts are exact evaluations of the finite determination theorem; the browser does not enumerate the residues. Count values are shown in decimal. Inspect this prime’s receipt.
Follow the idea into the implementation.
The research explains the arithmetic. The implementation gives you working code. The measurements let you compare choices and design your own experiments.
We welcome research discussion and collaborators with a concrete system in which to test the work.