Theorem 1 (Euclid)
No largest prime exists. Multiply any finite list of primes and add one: the result leaves remainder 1 on division by each of them, so its prime factors sit outside the list. ∎
Launching soon on QUANTUM Chain
Mine math. Get paid in yield.
Your browser hunts for a nonce that drops keccak256(seed ‖ miner ‖ nonce) under the target. When one lands, the fee splits: half buys $QCALC and burns it, half buys YLD for the address inside the hash.
- chain
- QUANTUM · 4663
- fee split
- 50% burn · 50% YLD
- block
- every ~10 min
- contract
- launching soon
01The whole loop
One block in twenty seconds.
Start here. The loop follows a single block: 84 bytes go into keccak, a hash comes out under the target, and one trading fee is cut into a burn and a share of YLD. The sections below slow each step down so you can check it.
02The inequality
keccak256(seed ‖ miner ‖ nonce) ≤ target
One inequality settles every block. You can verify it with keccak in any language; no oracle feeds it and no operator signs off on it.
- Seed32 bytes: the previous block's hash. You cannot start on the next block early.
- Miner20 bytes: your address. A nonce you find works for your address only, so copying it pays nobody.
- Nonce32 bytes: the part you change. Each browser thread tries several hundred thousand per second.
- TargetUnder it, you have a block. Over it, you move on to the next nonce.
03engine.sol
The engine runs on five rules.
- 01
mine(nonce, minOut)Open to any caller. The engine hashes the live seed, the caller and the nonce, and reverts when the hash sits above the target. Your address is baked into the hash, so a stolen nonce is worthless.
- 02
Spend an eighth, burn all of it
The engine takes one eighth of its budget, buys $QCALC on the curve and sends every token to 0x…dEaD in the same transaction. It pays nobody in $QCALC.
- 03
Log the prover
The block log records the address that proved the block. That entry is the claim on the other half of the fee, paid in YLD.
- 04
New seed, new target
The winning hash seeds the next block. A block under five minutes makes the next one need a third more work; over twenty minutes, a quarter less. Bounds hold the target inside [2200, 2240].
- 05
harvest()Moves the engine's half of the creator fee out of the launchpad escrow and into the budget. Anyone can call it, so the budget refills whether or not we are around.
minOut caps the price a block can pay. The curve rejects a zero minimum, so no block ever buys at a price its caller did not accept.
04The split
Half burns. Half buys YLD.
The contract cuts each fee once, before either side can touch it.
0%
Burned
The engine buys $QCALC on the curve and sends it to 0x…dEaD inside the proof transaction. Bytecode enforces this half: read the source and confirm it has no other path.
⌊F / 2⌋ → engine
feeF
0%
YLD, to the prover
The yield desk converts the other half to YLD and pays the address inside the winning hash. The public ledger lists each payout next to its block height.
F − ⌊F / 2⌋ → desk
whyYLD
You spend electricity on math. The reward is a claim on the yield your work secures.
A proof-of-work agent has one honest product: computation somebody performed, checked by the same keccak on every machine. QUANTUM CALC pays that computation in yield, never in the token it just made scarcer.
Emission coins pay miners in the coin their work just shrank, and those miners sell. QUANTUM CALC pays outside the token, so $QCALC supply only moves one way.
The halves always add back to F: the desk takes F − ⌊F/2⌋, so an odd fee never loses a wei to rounding.
05miner.exe
Mine from this tab.
Lend it some threads and press start. With a wallet connected, the pool hands your address a job, re-checks each nonce you return, credits YLD for it and puts you on the board. Without a wallet you mine the genesis block for practice, and nothing leaves your browser.
idle
0H/s
Open until launch$QCALC is launching soon. Until the contract exists the miner runs for anyone.
- seed
- …
- miner
- guest · connect a wallet to mine for your address
- target
- …
- best hash
- …
0 hashes of ~2^20 expected
Your threads hash the same 84 bytes the engine checks: the seed, your address and the nonce.
odds
The benchmark runs keccak on your threads for four seconds.
0.00% chance of at least one hit in the window
- expected wait
- -
- 50% by
- -
- 95% by
- -
- hits per day
- -
- p per hash
- -
leaderboard · proven work
| # | miner | proven hashes | shares | blocks |
|---|---|---|---|---|
| Loading the board… | ||||
block log
each block moves the seed and retargets| height | prover | Δt | difficulty | hash |
|---|---|---|---|---|
| No blocks yet. The first one is 2^20 hashes away. | ||||
payout ledger · YLD
| posted | miner | YLD | transaction |
|---|---|---|---|
| Loading the ledger… | |||
Every payout the desk sends is posted here with its transaction, so the board and the payments can be read against each other.
06Difficulty
Ten-minute blocks, held by one rule.
After each block the engine checks the gap since the last one. Under 300 seconds, the target drops to three quarters. Over 1,200 seconds, it rises by a third. In between it stays put, and clamps at 2200 and 2240 stop a runaway either way.
- block difficulty now
- -
- last gap
- -
- next move
- -
pool blocks · gap and difficulty
07theorem.exe
The sum of 1/p never stops growing.
½ + ⅓ + ⅕ + 1⁄7 + 1⁄11 + … = ∞ Euler proved it in 1737. The sum climbs like ln ln n, slow enough that passing 4 takes primes near 1.8 × 1018, and it has no final term. The engine's budget has the same shape.
Theorem 2 (Euler, 1737)
Σp 1/p = ∞. A stronger claim than Euclid's: the primes are dense enough that their reciprocals diverge, and the partial sums stay close to ln ln n + M. ∎
Lemma 3 (expected work)
keccak output is uniform on [0, 2256). With target T one hash lands with probability (T + 1) / 2256, so the count to a block is geometric with mean 2256 / (T + 1). The site calls that mean difficulty. Luck moves a single block; the mean stays put. ∎
Lemma 4 (the budget never runs dry)
Each block spends B/8 of what is left. After n blocks B(7/8)n remains and B(1 − (7/8)n) is spent: it approaches B and never reaches it. Harvests refill B, so the blocks have no last one. ∎
Proposition 5 (the split is exact)
A fee F splits once: ⌊F/2⌋ to the engine and F − ⌊F/2⌋ to the desk. The subtraction hands the remainder to the second half, so both halves sum to F for every F, odd ones included. ∎
Proposition 6 (retarget)
With Δt since the last block, T' = ¾T if Δt < 300 s, 4⁄3·T if Δt > 1200 s, otherwise T, clamped to [2200, 2240]. One block per 600 seconds is the fixed point. ∎
Arithmetic can check every statement on this list. None of them predicts a price.
Σ 1/p against ln ln n + M
- primes counted
- -
- Σ 1/p
- -
- ln ln n + M
- -
- gap
- -
- block difficulty
- -
Crimson steps: the partial sums over primes up to 100,000. Dashed curve: ln ln n + M, with M = 0.26149…, the Meissel-Mertens constant.
08The token
$QCALC
- contract
- launching soon
- chain
- QUANTUM Chain · 4663
- pair
- ETH, on the launch curve
- launch terms
- published with the contract
- mint after launch
- none: the engine can only burn
- reward asset
- YLD · yield token
$QCALC is what gets burned; it is never the payout. Each block removes some from the curve for good, and provers receive YLD, so the reward never dumps the token it shrinks.
09Status
Running today, and what the contract adds.
live
Browser miner
Multi-threaded keccak-256 in Web Workers, about five times faster per thread than a textbook implementation.
live
The pool
Sealed jobs, server-side re-hashing, vardiff, a public board and a block log that applies the engine's retarget rule.
live
YLD rewards
Every accepted share credits YLD against your address, capped per day. The pool pays out once your balance clears the minimum, and posts each transaction in the ledger.
live
Receipts
Sign your stats with your wallet; anyone can paste the receipt back and check the signature against the pool.
soon
$QCALC
The token contract. This page shows the address with copy and explorer links the day it exists.
soon
engine.sol
On-chain mine() and harvest(). Blocks move from the pool log onto the chain.
soon
Splitter and ledger
The fee cut on chain, and YLD payouts posted against block height.
10paper.txt
Proof of work, in both meanings.
Most token burns depend on a decision. Someone clicks a button or a scheduled job fires, and that step can be skipped, front-run or quietly retired. QUANTUM CALC replaces the decision with an inequality: supply falls when somebody spends computation and lands a hash under the target, and at no other moment.
The payout is the second half of the design. Paying miners in the token their work just made scarcer contradicts itself, and emission coins bleed for it. QUANTUM CALC pays outside the token: half of each fee becomes YLD, paid against the block log. Your work is arithmetic, and your pay is a claim on the yield that work secures.
Three properties follow from the shape of the code. The engine has no mint, so supply can only fall. ETH held by the engine leaves one way, into the curve. $QCALC the engine receives goes to one place, the dead address.
The money comes from creator fees on real trades, pulled out of escrow by a call anyone can make. No emissions, no treasury grant. If nobody trades, no fees arrive, no blocks pay and nothing burns. That failure mode is real, and you should weigh it.
You audit the two halves in different ways. Bytecode enforces the burn. The desk executes the YLD purchase, and a public ledger keyed to block height records it. One is a proof and the other a record; neither promises a price.
Smart contracts carry risk, tokens carry market risk, and yield carries its own. Nothing here promises a price or a return, and none of it is financial advice.
?Questions
Short answers.
Do I need a wallet to mine?
No. Without one you mine the genesis block for practice and nothing leaves the tab. Connect a wallet and the pool credits your shares to that address.
Does mining cost gas?
Pool shares cost nothing: your browser hashes and the pool checks off chain. After launch, calling mine() on the engine costs gas like any other transaction.
Where is the contract?
Launching soon. The token panel, the ticker and the desk show the address the day it exists, with a copy button and an explorer link.
Why YLD?
Mining spends computation, and yield is the honest product of that computation. The reward is a claim on the yield your work secures, and it never touches $QCALC.
Is the YLD real?
It is a yield token on QUANTUM Chain. Each payout is a transfer on chain, listed in the ledger with its transaction hash.
Will it slow my computer down?
It uses the threads you give it and no more. Drop the slider or press stop and the CPU frees up at once. Closing the tab stops everything.
What does a share earn?
YLD, credited the moment the pool accepts it, scaled by the difficulty of that share and capped at 5,000 credited shares a day per address. The pool sends the balance once it clears the minimum and posts the transaction in the ledger. Until the fee stream exists the desk funds this out of its own pocket; after launch the equity half of every fee does.