Research & development
Digital technology
from number theory.
Boston Agile Labs develops software from original research in number theory. One concrete result: an exact digit-collision count can be recovered from a finite table instead of checking every position. We build tools that let you use and test these constructions.
For developers exploring computational work, Bellpair provides a complete lab: a native solver, a separate verifier, receipts and measurements. Change the number base and difficulty, run the search, and inspect what it costs.
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.
A concrete computational benefit
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.