Pinned Tweet
Precopscan : The Bitcoin L1 Radar for any taproot Asset.
Every token.
Every covenant.
Any tree.
Any $leaf.
Any script.
Verify on-chain. 🌱
Precopscan (🌱) retweeted
Bitcoin just verified a 48-bit multiplication on mainnet.
@laz1m0v put a 1,087-byte Tapscript through the mempool that confirmed the exact result of 1,003,519 × 2,002,943 = 2,009,991,356,417. No OP_MUL. No OP_CAT. No soft fork. Regular miners included it. The same approach also handled a state transition that updates a cell across transactions and binds future spends to the expected path, or a penalty leaf.
For years the default answer was that Bitcoin can’t do real computation without changing consensus or moving to a sidechain. These transactions show the opposite is already possible if you compile carefully against the actual TapScript rules that nodes run today. The witness gets bigger and the scripts are ugly, but the base layer already accepts them.
The compiler that produced these is called Complexity. Whether this stays a research curiosity or becomes something people actually use depends on how much further they can push it, but the “Bitcoin can’t do math” claim just got harder to defend.
Precopscan (🌱) retweeted
So if I understand correctly…
Complexity turns a few logic blocks into normal Tapscript that already runs on every btc node today?
Some Rocq proofs make sure it never overflows the 31-bit limit, plus these “jets” for bigger math and a way to slash cheaters without a multisig?
Precopscan (🌱) retweeted
It shows complex, formally verified computation and state machines can already run natively on Bitcoin L1 via existing Tapscript. No soft fork required. This expands practical on-chain contracts, automatic bond-slashing, and financial predicates while preserving Bitcoin’s austere, fully verifiable base layer. Compiler engineering substitutes for consensus changes.
Precopscan (🌱) retweeted
GitHub hosts the full open-source code, Coq formal proof, Rust/Python auditors, and Bitcoin Core tests. This lets anyone independently review, verify, and reuse the work.
The article demonstrates that two numbers (up to ~46,340) can be multiplied inside Bitcoin Tapscript today with a compact 371-byte script of additions and doublings. No soft fork or OP_MUL is needed. It is formally proven and tested on Bitcoin Core.
Precopscan (🌱) retweeted
The point is enabling reliable multiplication of numbers up to ~46k inside existing Bitcoin Tapscript (via additions + doublings) for arithmetic in covenants or on-chain checks, without any soft fork or disabled opcodes like OP_MUL. It is formally proven and Core-tested.
Expert skill level is required: deep Tapscript knowledge, CScriptNum limits, Horner arithmetic, and Coq formal verification.
Similar small multiplies exist in older script libs and BitVM work, but this compact proven 371-byte unrolled version for the full safe range is presented as a first.
Precopscan (🌱) retweeted
I implemented the theorems so that Bitcoin could have financial primitives... This unlocks all use cases in a native, trustless, and decentralized way...
Precopscan (🌱) retweeted
How we do it on-chain: Our compiler, Complexity (.com), translates 8 simple logic blocks directly into standard Bitcoin Tapscript, backed by 311 computer-verified math theorems in Rocq 9.3.0 (0 axioms) that guarantee no calculation ever overflows Bitcoin's 31-bit number limit. It links together 48 pre-verified bytecode modules called jets to split numbers into 12-bit chunks for 48-bit multiplication (multilimb_u24_u48), unpack 3 state variables from a single SHA-256 hash (auth_word31_open), and arm a cryptographic trap (BitAt) that automatically slashes 100% of a cheater's bond without any multisig committee.
On standardization: We don't need a soft-fork or political permission to standardize .com because its compiled output already runs natively on 100% of unmodified Bitcoin Core (v31.1.0) nodes today. The v0.0.1 standard is open-source (MIT/CC0), mathematically locked by our tri-target equivalence theorem (rc1_com_total_tritarget_bisimulation), and permanently etched on Bitcoin Mainnet in blocks 974,029 and 974,037.
Precopscan (🌱) retweeted
Soft covenants always leaked trust somewhere.
A committee. A bridge. A federated layer. Someone who could freeze, censor, or rug.
Real covenants don’t. The rules live in the script. The money and the law stay in the same place.
Precopscan (🌱) retweeted
Complexity doesn’t ask Bitcoin to change.
It takes the math we already wanted (the kind Simplicity promised) and forces it to run on the machine we already have.
Unmodified Bitcoin Core nodes already accept it.
Precopscan (🌱) retweeted
You can now write logic that:
- checks arithmetic safely
- carries state between transactions
- punishes anyone who breaks the rules
All on-chain. All verifiable by every node. No extra trust.
Precopscan (🌱) retweeted
Before: “We need a soft fork for covenants.”
After: “We can already do it. The compiler pays the price in math so the user doesn’t pay it in trust.”
Precopscan (🌱) retweeted
This is not Ethereum on Bitcoin.
It’s Bitcoin finally being allowed to enforce its own rules without outsourcing the enforcement.
Hyperbitcoinization needs both the money and the law on Layer 1. Complexity is the first serious step toward that.
Precopscan (🌱) retweeted
For years we were told Bitcoin can’t do real covenants.
Only “soft” ones. Workarounds. Sidechains. Trust.
Today that changed.
Complexity just compiled real covenants directly onto Bitcoin L1. No soft fork.
Precopscan (🌱) retweeted
GM Frens.
Bitcoin still can’t do multiplication natively.
Or at least it couldn’t until now. @laz1m0v just showed a way to multiply two numbers inside a TapScript transaction using only 371 bytes. No soft fork. No OP_CAT. Formally verified and tested on Bitcoin Core.
Most people assume you need new opcodes or a consensus change to do basic math on Bitcoin. This proves you can already do it today if you’re willing to unroll the logic carefully. It’s not practical for every use case yet, but it removes one of the usual excuses for why certain things “can’t be done on L1.”
The technical write-up is worth reading if you care about what Bitcoin Script can actually do without waiting for soft forks.
Bitcoin can’t multiply.
Or can it? 👀
I built a way to multiply two numbers directly in Bitcoin transactions — with zero changes to Bitcoin.
371 bytes. No soft fork. No OP_CAT.
Formally verified and tested on Bitcoin Core.
How it works
delvingbitcoin.org/t/multipl…