How VQE-gated block production works on QuantumAI Blockchain

Most blockchains decide who writes the next block by one of two methods. Proof of work asks machines to guess hashes until one lands under a target. Proof of stake asks a bonded set of validators to take turns and vote. QuantumAI Blockchain runs a hybrid of a different shape. A bonded, post-quantum validator set still votes on finality, but the right to author a block is gated by a variational quantum eigensolver run against a Hamiltonian that the chain itself derives for that block. We call the authoring rule VQE-gated single-leader authoring, and the energy proof it carries Proof of SUSY Alignment.

This post explains the whole mechanism end to end, as it runs on the live chain today at runtime spec 182. It also says plainly what the mechanism proves and what it does not, because an honest description is the only kind worth publishing.

The idea in one paragraph

Every block height defines a small, deterministic quantum-chemistry-style problem: an 8-qubit Hamiltonian written as a sum of weighted Pauli strings. The block author runs a parameterised quantum circuit, classically simulated, and optimises its 32 rotation angles so that the circuit's expectation value of that Hamiltonian is as low as possible. The author then publishes the angles and the resulting energy inside the block. Every other node recomputes the energy from the published angles, which costs the same as checking a hash, and rejects the block unless the energy sits below a quality threshold that the chain retargets block by block. A post-quantum ticket lottery decides which single validator is allowed to attempt this at each height, and GRANDPA finalises the result.

Hash-based proof of work burns effort on a problem with no structure. This replaces the guess with an optimisation: an author cannot cheat the gate, and a verifier never has to trust the author's arithmetic.

Step one: the chain derives the problem

For a block at height h with parent hash p, the chain computes a base seed by hashing the height and parent together. The author mixes in a nonce and its own address to obtain a full seed. That full seed drives a ChaCha8 stream from which the Hamiltonian is built.

The Hamiltonian has sixteen weighted Pauli-string terms over 8 qubits, in four groups:

• Structural terms with coefficients graded by the golden ratio, so the problem has a fixed scale separation.
• Phase-rotated terms whose coefficients are s cos θ and s sin θ, where θ advances by the golden angle divided by one hundred at each height. Over one hundred blocks the phase sweeps a full turn, so a parameter set that was a good minimiser last block is not an exact minimiser this block.
• Diagonal bias terms with fixed negative coefficients.
• Nine random terms, each a random 8-qubit Pauli string with a random coefficient. These are what make precomputation pointless: the full seed includes the nonce and the author address, so nobody can solve a block's problem before the parent is known, and no two authors even see the same problem.

Every verifier can regenerate the identical Hamiltonian from the block header alone. Nothing about the problem is chosen by the author except the nonce, and changing the nonce changes the whole problem.

Step two: the author optimises a circuit

The author's circuit is a two-layer hardware-efficient ansatz: a layer of RY rotations on all 8 qubits, a ladder of controlled-Z entanglers, another RY layer, another entangling ladder, and a final RY layer. That gives 32 real parameters acting on the 256-amplitude state vector of 8 qubits. The expectation value of the Hamiltonian under this state is the energy.

The author runs a derivative-free optimiser, COBYLA, over the 32 angles to push the energy down. On the live miner this takes on the order of a hundred milliseconds per attempt. Energies for the live Hamiltonians land roughly between minus one and minus two and a half in the chain's units, and they vary from block to block because the problem does.

It is worth saying clearly: this is a classical simulation of a variational quantum circuit. No quantum hardware is involved. The point is not quantum speed. The point is a proof-of-work puzzle whose output has a meaning, whose verification is exact, and whose difficulty can be set on the quality of the answer rather than on the luck of a hash.

Step three: the energy is made exactly reproducible

A float-valued proof is a liability in consensus. Two nodes on different CPUs, or one native node and one running the WebAssembly runtime, can disagree in the last bits of a floating-point sum, and a disagreement in the last bits is a fork.

We learned this the hard way. In August the chain wedged at mining height 1,296,548 because the native miner and the WebAssembly verifier resolved one ill-conditioned Hamiltonian to energies that differed by 0.3, not by a rounding error, and the block failed verification on every node. The fix that went live in spec 175 is structural: the miner no longer submits its own native energy. It calls the runtime API compute_energy_v4 and submits the value the WebAssembly runtime itself computes. Submitted and verified values are now the same bytes on any hardware.

On top of that, the consensus energy is fixed point. Each Pauli expectation is computed, each coefficient is scaled to an integer, the products are accumulated in 128-bit integers, and the result is an exact integer. A public conformance vector of 1,024 entries pins the expected integer for each input, and both the Rust verifier and the Go re-implementation inside the QVM must match it bit for bit.

Step four: the verifier recomputes, for free

A block carries the height, parent hash, author address, nonce, the 32 angles, the claimed energy, and a seal hash. The verifier:

1. Regenerates the Hamiltonian from the header and nonce.
2. Rebuilds the state vector from the 32 angles and computes the energy in fixed point.
3. Checks that the recomputed energy equals the claimed energy.
4. Checks that the seal hash, which commits to the seed, nonce, author and energy, meets the seal target.
5. Checks the energy gate, described next.

Step 2 costs the verifier exactly what one optimiser evaluation costs the author: one state-vector simulation of 8 qubits, microseconds of work. Verification is cheap because the hard part, the search over angles, is the author's problem alone. That asymmetry is the whole reason a variational problem can serve as a proof of work.

Step five: the energy gate, and why it is the real innovation

Until September, the chain checked that the published energy matched the published angles, but it did not check that the energy was low. An author could publish all-zero angles, which gives the trivial state and a positive energy, and the proof was accepted about a thousand times cheaper than an honest solve. We measured this on the live chain, wrote it up in the open, and fixed it with a fork.

Since mining height 1,537,800, live from 14 September 2026 at spec 181, every proof must also satisfy:

E_recomputed  <=  -alpha(h) * sum_i |c_i|

where the c_i are the Hamiltonian's coefficients and alpha(h) is a retargetable difficulty parameter stored on-chain in basis points.

Three properties make this gate unusual, and together they are what we think is new.

It needs no eigensolver. Every Pauli string has eigenvalues of plus or minus one, so the true ground-state energy of any such Hamiltonian can never be below -sum|c_i|. That makes the ratio E / -sum|c_i| a scale-free quality score in [0, 1] that is comparable across Hamiltonians of different magnitudes. The verifier gets a rigorous bound from one pass over sixteen coefficients it already generated. There is no 256 by 256 diagonalisation in consensus.

It cannot halt the chain. A fixed-problem gate would be dangerous: if a block's problem happened to be unsatisfiable at the current threshold, the chain would stop. Here each nonce derives a different Hamiltonian. A draw that cannot pass costs the author one solve, and the next nonce is a fresh problem. Passing the gate is an independent Bernoulli trial per nonce, which is exactly the statistical shape a proof of work needs. A threshold set too high makes blocks slower, and the retarget loop corrects it. It never makes blocks impossible.

It retargets on quality, not on hash luck. Every 144 blocks the runtime compares the window's actual time with the 3.3 second target. If blocks were slow by more than 15 percent, alpha steps down; if fast, it steps up, at most 25 basis points per adjustment, clamped to the range 0.35 to 0.58. Both ends were calibrated against the live network phase, not a lab sample, because the pass rate for an honest solve is sensitive to where θ sits.

The lazy all-zero proof has a negative quality score. It fails at any positive alpha, absolutely rather than probabilistically. That attack is closed.

Step six: one leader, chosen by a post-quantum lottery

The VQE proof says a block was produced with real optimisation work. It does not by itself say who was allowed to produce it. That is the job of the leader election, and it is where the hybrid comes together.

At each height a post-quantum ticket lottery, built on a hash-based verifiable random function rather than any elliptic-curve VRF, selects exactly one validator from the bonded set as the author. The rule is enforced in three layers: the author's own node refuses to build if it did not win, the runtime rejects a block whose author does not match the lottery, and the import path hard-rejects such a block before it reaches the database. If the elected author is silent for two slots, the chain falls back to the Aura schedule so liveness does not depend on one machine. Fork choice is by cumulative difficulty weight with first-seen on ties, so a miner who finds several valid nonces cannot grind the block hash to win races, a weakness we found and removed in July.

Validators bond stake, are selected by the same post-quantum sortition into the active set, and vote finality with GRANDPA. Equivocation slashing is autonomous and on-chain. Block signatures are ML-DSA-87, formerly Dilithium5. There is no classical-curve cryptography on the consensus path.

So the hybrid is this: stake and finality decide who may speak and what is final; variational work decides whether what they said is admissible. Neither half is decorative.

What this does not claim

The SusyLabs writing standard requires that every public claim have a verification surface and that nothing be inflated. Here is the part of the story that an enthusiastic write-up would leave out.

• The energy is a variational upper bound, not a ground state. Scored against exact diagonalisation on sampled Hamiltonians, a single honest solve reaches roughly 80 percent of the way to the true ground state, and the best of forty restarts about 88 percent. No sample has ever reached the ground state.
• The current circuit provably cannot reach it. RY rotations and controlled-Z gates are all real matrices, so the state never acquires an imaginary part. A real state cannot see the anti-symmetric part of a Hamiltonian, and these Hamiltonians carry Pauli strings with an odd number of Y factors. The lowest energy any parameter set can reach is strictly above the ground state in every sample tested. Making the ground state reachable means adding gates that generate complex amplitudes, which changes the energy of every historical proof and is therefore a second fork. It is designed, not built.
• The results are discarded. The Hamiltonians are seed-derived puzzles. Nobody is waiting on their solutions. We do not call the work "useful" until there is a citable use.
• Chain safety rests on the bonded validator set and GRANDPA finality, not on the energy work. The gate makes block production cost real optimisation and removes the free-block attack ahead of permissionless mining. It does not, on its own, secure the ledger.
• Alpha currently sits at its floor of 0.35. Block cadence on the live chain is governed by the slot schedule, so the retarget loop has eased the gate to its minimum. At that setting an honest solve passes on the first nonce almost every time, which is what the live logs show. The gate still rejects the lazy proof absolutely; it is not yet the thing that paces the chain.

Numbers from the live chain

SNAPSHOT, read from the Intel validator at 08:06 AEST on 15 October 2026:

You can check the energy of any block yourself at the explorer on qbc.network/explorer: open a block and read its energy and parameters, or open the Hamiltonian Lab view, which plots the achieved variational energy next to the exact ground state for the same Hamiltonian so the gap is visible rather than hidden.

Why we think this matters

Variational quantum algorithms have been proposed as blockchain work before. What we have not seen elsewhere, and what took the better part of a year to get right on a live chain, is the combination:

1. A per-block, per-author Hamiltonian that defeats precomputation without any trusted setup.
2. A consensus energy defined in integers against a public conformance vector, so the proof is identical on x86, ARM and WebAssembly, with a runtime API that makes the miner submit the verifier's number.
3. A quality gate referenced to a rigorous, free bound instead of an eigensolver, with a proof that it cannot deadlock the chain.
4. Difficulty that retargets on the quality of an optimisation rather than the luck of a hash.
5. All of it sitting under post-quantum leader election, post-quantum signatures and GRANDPA finality, so the chain's security does not rest on the puzzle alone.

Each of those is live today and checkable from a block header. The maturity labels, in the language we use everywhere: the gate is live, the retargeting is live, the fixed-point conformance path is live, permissionless mining is built behind a call-site gate and not yet opened, and the complex-amplitude ansatz that would make ground states reachable is designed.

Where it goes next

Two changes are queued, in order. First, opening mining to operators outside the current validator set, which is why closing the free-block hole had to come first. Second, the ansatz fork, so that the variational energy can in principle meet the ground state and the "quality versus the true answer" column in the explorer can close.

The specification, the gate design document with every measurement behind this post, the conformance vector and the verifier are public in the repositories. If you find a block whose energy you cannot reproduce from its header, that is a bug, and we want to hear about it.