Skip to content
Crypto.world

Research

Proof-of-Machine-Learning-Inference: Mining Knowledge, Not Hashes

Formalizes when ML inference can replace hash work in consensus, giving a security reduction that could make useful-computation mining designable rather than hand-wavy.

Proof-of-Machine-Learning-Inference: Mining Knowledge, Not Hashes
arXiv
2610.26713
Published
2026-10-19
Authors
Wan Ki Wong, Michele Ciampi, Rik Sarkar

AI summary

Overview

Research area: Blockchain consensus and cryptography, specifically Proof-of-Useful-Work protocols that replace hash-based mining with generative-AI inference; intersects with zero-knowledge proofs, verifiable random functions, and machine-learning systems.

Technical level: Advanced. The paper is written for readers comfortable with cryptographic definitions (NIZKs, VRFs, public-key encryption, the Bitcoin Backbone model) and with how diffusion models and autoregressive LLMs work internally. The prose is readable, but the core content is formal definitions, a protocol specification, and theorems.

Scope: The paper defines, formalizes, and evaluates Proof-of-ML-Inference (PoML), a Bitcoin-style consensus protocol in which miners win blocks by performing user-requested machine-learning inference, and it argues that current generative models are suitable for this role.

What This Paper Is About

Bitcoin-style Proof-of-Work secures permissionless blockchains but burns enormous computation on hash puzzles that produce nothing except chain extension. At the same time, generative AI inference is expensive and effectively concentrated among a few well-resourced players. The paper asks whether the inference computation itself can serve as the mining work — so that the energy spent securing the chain simultaneously answers real user queries — and what computational assumptions a model must satisfy for this substitution to be safe.

Key Contributions

  1. A consensus protocol (PoML) that mines with ML inference. Users post queries to a mempool; miners answer them with a fixed public model and win the block lottery when a hash of their (encrypted) output falls below a complexity-scaled threshold. No nonce grinding over unrelated data is performed.
  2. A formal notion of "Computational Independence" (CI) and the class of PoML-compatible models. The paper defines ε_i-computational independence — informally, that no adversary with bounded circuit depth and arbitrary polynomial-time precomputation can shortcut the evaluation once the randomness is revealed — and defines PoML-compatible models as the class 𝒦 of models satisfying it.
  3. Evidence that real generative models qualify. Stochastic diffusion models are argued formally to satisfy CI (Theorems 0.D.1 and 0.D.2 in the appendix), and LLMs are argued empirically, using GPT-2 experiments, to satisfy a stated Assumption 1.
  4. A security reduction and a simulated evaluation. The protocol's security is reduced to that of the Bitcoin Backbone model, and a simulation study reports block-time stability relative to a calibrated target and lower observed block-time variance than a PoW baseline.

Main Findings

  • Computational Independence is the precise missing assumption. The paper isolates exactly what inference must guarantee to safely replace hash work: that given uniformly sampled randomness ℛ, the only way to compute M_θ(x, ℛ) is through a circuit of depth at least (1 − ε_i)·Depth_θ(x, ℛ). Precomputation, cached partial results, or prior work on the same prompt must not help.
  • Stochastic diffusion models satisfy CI naturally. Per-step Gaussian noise z_t ∼ 𝒩(0, I_d) plus a random starting point x_T ∼ 𝒩(0, I_d) makes denoising trajectories diverge. In dimension d, the probability that two processes' noise draws land within distance δ is approximately δ^d, which shrinks rapidly with dimension. In experiments, two inputs differing only by Gaussian noise with standard deviation 0.001 produced a minimal difference between any intermediate vector of 2.93 × 10⁻³, which the authors take as evidence that no meaningful computational state can be cached and reused.
  • LLMs satisfy the property only empirically, under a stated assumption. Because LLMs lack a random starting point and sample from potentially concentrated distributions, the paper adds small Gaussian noise to token embeddings (a technique used in RESTA and Soft Reasoning). On GPT-2, this produced numerical differences of at least 2.03 × 10⁻³ between inferences of the identical prompt, and decoded output tokens differed after 5 tokens with >99% probability. The authors formalize this as Assumption 1 and explicitly leave a proof that some LLM is CI as an open question.
  • Security reduces to the Bitcoin Backbone. Under CI, a flat computation model, a synchronous diffusion network, and a strict honest computational majority, the protocol inherits the Backbone's common prefix, chain quality, and chain growth properties.
  • Block production stays near target in simulation. The evaluation reports block production "close to its calibrated block-time target," with lower observed block-time variance than the PoW baseline. Specific block times, variance figures, simulation sizes, and miner counts are not reported in the available content.
  • Wasted work is bounded in the deduplication experiments. Because only one miner wins per block, losers may post results as RESPONSE_QUERY transactions. Where the number of pending queries is 100× the number of miners, the fraction of deduplicated work remained below 5% in the authors' experiments.
  • Solutions can be kept private. Outputs are encrypted under the querying user's public key, accompanied by a zero-knowledge proof that the ciphertext contains a correct answer, so losing miners and other users do not get free access to paid answers.
  • Chaining defeats subset-grinding. Making the winning condition a hash over all solutions would let an adversary try arbitrary subsets. PoML instead feeds the previous solution's ciphertext into the next query's seed, forming a sub-chain (bind_i = H(G(s, tx) ‖ 𝒴_{i−1}) for i ≥ 2), so reordering requires recomputing all dependent inference.
  • Difficulty scales with query complexity. The winning probability for a candidate of combined complexity C is τ_D(C) = 1 − (1 − D/2^κ)^C, with threshold D_C = ⌊2^κ τ_D(C)⌋, so variable-length outputs do not distort the lottery.

Methodology in Plain English

The authors take a Bitcoin-like protocol and swap out its lottery ticket. Instead of hashing a counter until a hash comes out below a threshold, a miner picks a random eligible query from the mempool, derives the model's randomness from a seed tied to the block, runs the inference, encrypts the answer to the user, and checks whether a hash of the encrypted output is below a difficulty threshold scaled to the query's complexity. If it is, the miner publishes the block along with the encrypted outputs, the VRF transcripts proving the randomness was derived honestly, and zero-knowledge proofs that each ciphertext really contains the correct inference result.

Two problems drive the design. First, an adversary could submit queries it can answer cheaply (precomputed or cacheable ones), so the protocol needs models where the randomness is supplied after the query is fixed and no shortcut exists — the Computational Independence property. Second, since query answers cannot be recycled across blocks, losing miners would waste all their work; the protocol therefore lets them post finished answers as ordinary transactions for a smaller reward, provided the query is still open and not too old.

To justify CI, the authors reason about high-dimensional geometry (different noise draws in large latent spaces almost never coincide) and run experiments measuring how much intermediate activations and output tokens diverge under small input perturbations. For security, they prove that if the model is CI, the protocol's chain behaves like the Bitcoin Backbone under the same honest-majority and flat-computation assumptions. For performance, they simulate the protocol and compare block-production regularity against a PoW baseline.

Why This Matters

Impact on research. The paper supplies a reusable abstraction — Computational Independence — that turns "can we mine with useful computation?" into a concrete, checkable property of a model class. It also opens a clear formal question: whether any LLM can be proven CI, not merely observed to behave that way. The reduction to the Bitcoin Backbone gives PoUW work a template that avoids the wasteful "hash–useful-work–hash" structure of earlier proposals such as Ofelimos and D-PoDL.

Real-world applications (as the paper frames them):

  • Text-to-image generation with stochastic diffusion models.
  • Video editing with diffusion-based pipelines.
  • Audio synthesis with diffusion models.
  • Answering batches of LLM queries on a shared, permissionless execution network, including for small or medium-sized organisations that cannot afford dedicated inference infrastructure.

Industry relevance. A permissionless market where anyone can supply inference and be paid per query would compete directly with centralized inference providers, and the "burn / solve / include" fee split gives a concrete mechanism for pricing variable-length outputs. The privacy layer matters commercially too: paying users do not want their answers published in the clear, and encrypted outputs with zero-knowledge verification is the paper's answer. The open-weights ecosystem around hubs such as Hugging Face is the natural supply side, and the protocol also supports independent auditing of public model safeguards.

Future Directions

  • Prove that some LLM is computationally independent. The paper calls this "an interesting open question"; currently LLM suitability rests on Assumption 1 and GPT-2 experiments rather than a theorem.
  • Close the duplicate-work gap in the incentive design. The RESPONSE_QUERY mechanism only mitigates wasted work — multiple miners may still answer the same query — and the paper acknowledges that its deduplication numbers (<5% under 100× pending queries) do not fully solve it.
  • Measure zero-knowledge proving costs for real-scale models. The complexity function C_{θ,Π} folds in ZKP generation alongside inference, but the visible content reports no measurements of proving time or proof size for models at deployment scale.
  • Validate block-time stability outside simulation. Results come from a simulated environment, with no reported deployment, network latency model, or adversarial-mining study in the visible content.

Target Audience

Cryptography and blockchain-security researchers working on Proof-of-Useful-Work and consensus reductions; protocol designers building decentralized compute or inference marketplaces; and machine-learning researchers interested in the computational properties of diffusion and autoregressive models as seen from a security perspective. Readers without a cryptography background will find the protocol mechanics and motivation accessible, but the formal contributions demand familiarity with the Bitcoin Backbone model, VRFs, and NIZK proof systems.

Authors’ abstract

Bitcoin-style Proof-of-Work (PoW) secures permissionless blockchains but spends substantial computation on hash puzzles which have no utility other than extending the chain. At the same time, we have seen that the rise of generative AI has created significant demand for computational resources that are unfortunately available only to a few players. We propose a solution that solves both problems at the same time. In particular, we present Proof-of-ML-Inference (PoML), a…

The full abstract on arXiv
Read the original paper