PROOF OF HUMAN WORKTHE DISTRIBUTED LEDGER
SECTION 02 / THE PROTOCOL

The
protocol.

Explore the protocol
THE IDEA02 — 03

1. Task seed

Nova is designed as a directed acyclic graph (DAG) rather than a strictly linear blockchain. The reason is fairly simple. Human work in Nova accumulates: a miner collects completed tasks until enough work has been gathered to support a block. This is different from, e.g., Bitcoin mining, where unsuccessful hashing attempts do not accumulate. In a linear chain, a miner connected to the largest pool of Nova participants would therefore tend to reach the required amount of work first and could repeatedly dominate block production. A DAG allows several miners to produce blocks concurrently instead of forcing all of them to compete for a single tip.

There are three basic roles in the network. Mining nodes construct blocks and collect proofs of human work. Participating nodes are human users who perform the physical tasks from which these proofs are derived. User nodes synchronize with the network, verify the ledger and send or receive transactions. These roles are not mutually exclusive; the same physical node may perform more than one of them.

To begin producing a block, a miner determines the current canonical DAG and selects the eligible tip blocks on which the new block will build. The chosen tips are placed in a canonical order so that all nodes process the same set in exactly the same way.

Each selected parent contributes three pieces of information: its block identifier, the Proof of Work nonce contained in its attached Proof of Human Work, and the Merkle root of its committed physical evidence (discussed below). The miner also constructs the new candidate block header, including its transactions and other canonical data, and calculates the header hash.

These values are then hashed together to obtain the candidate block's task seed. In simplified form,

task seed=H( ordered parent data∥candidate block-header hash).\begin{aligned}\text{task seed}=H(&\,\text{ordered parent data}\\&\parallel\text{candidate block-header hash}).\end{aligned}

The task seed therefore depends on the candidate block itself, on the particular DAG tips it extends, and on the Proof of Human Work commitments of those parents. Changing any of these values produces a different seed.

The seed is then expanded into an ordered sequence of task hashes. If the task seed is ss, the first task hash is

t1=H(s),t_1=H(s),

the second is

t2=H(t1),t_2=H(t_1),

and so on.

If a miner claims qq completed human tasks, those tasks must correspond to the first qq hashes in this sequence. The miner cannot skip an inconvenient task and substitute a later one, nor can the order be changed.

A miner may construct different candidate headers and therefore examine different task seeds before settling on one candidate. Nova does not rely on preventing this altogether. Instead, tasks are designed to have similar expected difficulty for human participants, and a block contains a large number of independently derived tasks. Unusually easy and unusually difficult tasks should therefore tend to average out across the block. With enough tasks per block, the possible advantage from searching over candidate task seeds should be small relative to the computational cost.

FIG. 02.01Task derivation
Selected parents · canonical order 1, 2, 300 / 24s
How a new block gets its task seed and task hashes

2. Performing human-work tasks

Mining nodes distribute task hashes to connected participants. Each task hash is converted, through a public deterministic function, into a specific physical instruction set. The miner does not choose these instructions manually; any node given the same task hash can reconstruct the same task. Furthermore, because task instructions depend on the candidate block and its DAG ancestry, a valid recording for that exact task cannot be prepared before the task seed exists.

The exact physical task is not fundamental to the protocol mechanism and may change as Nova develops. A useful task should be easy for ordinary people to perform, require little training, allow a very large number of fresh variations, produce physical behaviour that can be measured reliably, and remain more expensive to synthesize than to perform physically.

Ideally, much of the complexity should come from the physical world rather than from difficult actions required of the participant. Gravity, object contact, movement, deformation, lighting, shadows and reflections can all add information to the recording without requiring much additional skill from the person performing the task.

As a simple example, participants could use a standardized board divided into clearly marked positions together with a set of distinguishable small objects. The objects might differ in colour, texture or surface markings and could be inexpensive or locally manufactured (e.g., using 3D printing).

A task might ask the participant to place several specified objects at particular positions on the board, hold one object while tilting the board, move the board through a particular sequence and make the held object interact with another object while it is moving.

For example, one task could require the participant to place objects 1, 5, 7, 12 and 18 at positions C5, D4, A7, A9 and B3; keep object 7 at A7 while tilting the board to the left; tilt the board forward and then backward; and, while object 12 is moving during the backward tilt, move object 7 so that it touches object 12.

The particular objects, locations, directions, timing ranges and interactions are determined by the task hash. This example is only illustrative. The production task would be designed together with the verification system and could change between protocol versions.

The participant records the complete performance using equipment that satisfies the minimum requirements of the current protocol version. Initially this could be a smartphone or several cameras positioned around the working area. Before recording, the participant software may check basic conditions such as visibility of the workspace, resolution and lighting. The recording must show the relevant parts of the participant’s body together with the physical apparatus, potentially from several synchronized viewpoints.

After the task is completed, the recording is sent to the miner. The miner may run inexpensive preliminary checks before accepting it. It may reject obviously incorrect recordings or maintain its own reputation system for participants who repeatedly submit poor-quality work. These local checks are not part of consensus; they simply reduce the miner's risk of constructing a block that later fails network verification.

FIG. 02.02Task execution
TASK HASH → INSTRUCTIONS
  1. 01place objects
  2. 02tilt left
  3. 03tilt forward/back
  4. 04touch one object with another
task hash → instructions00 / 24s
From task hash to human action

3. Constructing the Proof of Human Work

Once enough task recordings have been collected, the miner constructs the candidate block's Proof of Human Work attachment. For clarity, Nova treats the block itself and its Proof of Human Work attachment as separate objects.

Each task has a fixed number kk of steps that must be performed in order. When video is used as evidence of a task, the complete recording is divided into kk consecutive clips, one for each required step. Together, the clips cover the entire task recording without gaps or overlaps. The miner has some freedom to choose where one clip ends and the next begins, but each clip must show its assigned step and stay within the duration limits set by the protocol.

If the miner claims qq completed tasks, and every task contributes kk clips, the total number of evidence clips is

N=qk.N=qk.

The protocol sets a maximum value for NN, which also places an upper bound on the amount of work that one block may claim.

The miner calculates a cryptographic hash of each selected clip and arranges these clip commitments in an ordered Merkle tree. The first kk leaves commit to the clips belonging to the first task hash, the next kk leaves to the second task hash, and so on. Within each task, the leaves appear in the same order as the task's required steps. As a result, the position of any leaf uniquely determines both the task hash to which it belongs and the action it is supposed to show.

Let RR be the Merkle root of this evidence tree, NN the number of leaves, BB the candidate block-header hash and uu a Proof of Work nonce.

The miner searches over nonce values until it finds one for which

z=H(B∥R∥N∥u)z=H(B\parallel R\parallel N\parallel u)

falls below the current Proof of Work target.

The successful digest zz has two purposes. It proves that the miner performed the required amount of computational work, and it provides the randomness used to decide which evidence must be disclosed.

A public deterministic function takes zz and selects a fixed number of distinct leaves from the committed evidence tree. The sample is derived from the complete successful digest.

This means that changing any committed input changes the audit. A different nonce gives a different digest. So does a different evidence root, a different number of leaves or a different candidate block. A miner cannot preserve a favourable sample while repeatedly varying some other committed value.

Once a valid digest has been found, the miner reveals the selected clips together with Merkle proofs showing that their hashes were committed at the claimed positions in the tree. The remaining clips are not broadcast and remain represented only by the Merkle commitment.

Proof of Work has a narrower role here than it does in Bitcoin. Its purpose is to make repeated attempts to obtain an unusually favourable audit expensive.

Suppose a miner commits NN clips, of which MM would pass verification, and the audit selects aa distinct clips. If every selected clip must pass, the probability of obtaining a favourable sample is

Ppass=(Ma)(Na).P_{\mathrm{pass}}=\frac{\binom{M}{a}}{\binom{N}{a}}.

For a sufficiently large evidence set, this is approximately pap^a, where p=M/Np=M/N.

If, for example, only 70% of a miner’s clips would pass and the audit checks 20 clips, the approximate probability that all 20 come from the acceptable portion is

0.720≈0.000798=0.0798%.0.7^{20}\approx0.000798=0.0798\%.

That is roughly one favourable sample in 1,253 independent attempts, on average.

Repeatedly searching for a favourable sample therefore adds a cost to avoiding the human work required to make all committed clips acceptable. The magnitude of this additional cost depends on the resources, i.e., computational work, required for each attempt.

An honest miner whose evidence is almost entirely valid does not face this additional penalty. Once it finds an ordinary valid Proof of Work solution, the resulting audit should pass with very high probability. A miner that has committed a substantial amount of bad evidence may instead need to find many valid Proof of Work solutions before obtaining one whose audit happens to avoid it.

Importantly, the network can adjust both the audit size and the Proof of Work difficulty so that this kind of grinding remains economically unattractive.

FIG. 02.03Random audit
Task 1 · k clips / Task 2 · k clips00 / 50s
Turning recordings into committed evidence

4. Broadcasting the block

After finding a valid Proof of Work result, the miner broadcasts the candidate block together with its Proof of Human Work attachment.

The attachment contains the evidence Merkle root RR, the committed number of leaves NN, the successful Proof of Work nonce uu, the clips selected by the audit, and the Merkle proof for every disclosed clip.

A receiving node in the network does not trust the miner's claimed sample. It independently reconstructs the Proof of Work digest from the candidate block, evidence root, evidence count and nonce, verifies that the digest satisfies the current difficulty target, and derives the audit from that digest.

The node then checks each Merkle proof. Since the position of every leaf has a fixed meaning, the validator can determine exactly which task hash and which instruction step every disclosed clip is supposed to represent.

More than one Proof of Human Work attachment can in principle be produced for the same task seed (e.g., because different clips may be used as evidence for human work corresponding to the same task hash, or because different valid Proof of Work nonces may be found). Nova treats these as alternative realizations of the same logical block. The consensus rules therefore allow only one block carrying a particular task seed to contribute weight to the canonical DAG. Furthermore, the required Proof of Work also serves a secondary purpose: it makes it costly for a miner to flood the network with alternative block variants.

FIG. 02.04Block broadcast
Candidate blockheader · transactions
ordinary block data
Proof of Human Work
attachment
evidence root · leaf count · PoW nonce
sampled clips · Merkle proofs
Candidate block00 / 24s
What the miner actually publishes

5. Validating a block

When a network node receives a candidate block, it verifies both the ordinary block contents and the attached Proof of Human Work.

The first step is to reconstruct the task seed. The validator checks the candidate's parent blocks, orders them according to the protocol and combines the same parent information and candidate block-header hash that the miner used. If this produces a different task seed, the block is invalid.

The node then determines how many human tasks the block claims. Since every task contributes exactly kk clips,

q=Nk.q=\frac{N}{k}.

The evidence count NN must be divisible by kk and must lie between the protocol-defined minimum and maximum values.

The validator derives exactly the first qq task hashes from the task seed and reconstructs the physical instructions belonging to each one. Since every task contributes the same number of ordered clips, the position of every disclosed Merkle leaf identifies both its task and its required action step.

The validator next recalculates

z=H(B∥R∥N∥u)z=H(B\parallel R\parallel N\parallel u)

and checks that it satisfies the current Proof of Work target. From the same digest zz it independently reconstructs the list of evidence leaves that the miner was required to reveal.

The same digest may also be used to choose which verification tests are applied to which evidence. Concretely, separate hashes derived from zz can be used for different purposes, for example, one for selecting evidence locations (leaves) and another for selecting verification tests, so that the different uses of randomness remain clearly separated.

FIG. 02.05Block validation
  1. 01reconstruct task seed
  2. 02reconstruct task list
  3. 03recompute PoW digest
  4. 04reconstruct audit sample
  5. 05verify Merkle proofs
  6. 06pass evidence to the verifier bundle
reconstruct task seed00 / 30s
How a verifying node reconstructs and checks the proof

6. Verifying the physical evidence

Nova's verifier is not necessarily one model. It is better understood as a collection of public tests performed by computer-vision models.

Depending on the active verifier set version, a test might examine whether the required action occurred, whether the correct objects are present, whether object identities remain consistent, whether trajectories and contacts make sense, or whether observable properties such as geometry, lighting, texture and movement remain mutually compatible.

Not every test has to be run on every disclosed clip. The PoW-derived audit can choose both the evidence and the checks applied to it. This allows Nova to maintain a relatively rich verifier bundle without requiring every node to run every available model on every piece of evidence.

A verifier may also inspect several clips from one task together or compare synchronized observations from several cameras.

Every selected check returns an exact deterministic result, either as a Boolean value or as a bounded integer score. The active verifier version also defines the exact aggregation rule GG used to combine these outputs into one overall result WW, including any conditions that must pass independently and cannot be compensated for by high scores elsewhere.

A block is valid only if

W≥TH,W\geq T_H,

where THT_H is the verification threshold defined by the active protocol version.

If the threshold is not met, the block is invalid.

FIG. 02.06Evidence verification
Sampled clips00 / 28s
A bundle of checks, not just one model

7. Deterministic verification

For consensus to work, different Nova nodes must obtain exactly the same verification result from the same evidence. Each verifier must therefore define one exact verification procedure, including input decoding and preprocessing, model weights, numerical operations, rounding and quantization rules, post-processing and final decision procedure. For every valid input, these rules define one exact result.

Many modern computer-vision models can already be executed efficiently using integer-only arithmetic. Nova would use the same general approach but impose stricter consensus requirements: every consensus-critical operation must have exact semantics rather than depend on hardware- or implementation-specific behaviour. Achieving this requires substantial engineering, but the underlying components are well established.

Nodes may execute the verifier using CPUs, GPUs or other accelerators. The underlying hardware and implementation may differ, but each conforming implementation must follow the same exact rules. Hardware can therefore affect verification speed, but not the consensus result.

FIG. 02.07Deterministic verification
canonical deterministic verifier
laptopdesktopserverGPU workstation
same block + sampled evidence00 / 24s
Different machines, same result

8. Proof score

Once the sampled evidence has passed verification, the block's Proof of Human Work score is simply the number of included tasks:

P=q=Nk.P=q=\frac{N}{k}.

Nova defines both a minimum and a maximum proof score.

The minimum, Pmin⁡P_{\min}, determines how much human work a block must contain before it can contribute to the DAG. The maximum, Pmax⁡P_{\max}, limits how much work a single block can claim. This bounds the size of the evidence tree and prevents a single unusually lucky audit from giving one block an arbitrarily large amount of consensus weight.

A valid block must therefore satisfy

Pmin⁡≤P≤Pmax⁡.P_{\min}\leq P\leq P_{\max}.

The network may periodically adjust Pmin⁡P_{\min} and Pmax⁡P_{\max} as participation changes. If blocks are being produced too quickly, more human work can be required per block; if production becomes too slow, the requirement can be reduced.

The Proof of Work difficulty used for audit selection is adjusted separately. These two parameters have different roles. Pmin⁡P_{\min} and Pmax⁡P_{\max} control the quantity of human work required per block, while the PoW difficulty controls the cost of repeatedly searching for an unusually favourable audit.

FIG. 02.08Proof score
Pminminimum work required
Pmaxmaximum credited work per block
P = 0 · verified tasks00 / 30s
Valid human tasks determine the block’s consensus weight.

9. The DAG

This paper does not attempt to introduce a new DAG-ordering algorithm.

Nova can use a suitable weighted DAG consensus mechanism in which every valid block carries a weight equal to its Proof of Human Work score. The selected DAG design must specify how blocks are ordered, how conflicting transactions are handled, how finality is reached and how cumulative weight is calculated.

Given the same set of valid blocks, every conforming node must eventually derive the same canonical ledger state.

The detailed security analysis of the chosen DAG mechanism is separate from the Proof of Human Work mechanism described here.

FIG. 02.09DAG
proof score Pcanonical accepted structureside branches
valid blocks · proof score P00 / 26s
Blocks contribute human-work weight to the DAG

10. Full and light verification

A full node verifies every audit (video) clip attached to every block it accepts. It checks the Merkle proofs, reconstructs the required task instructions and runs the verification tests selected by the block's PoW-derived audit.

It does not need to download the parts of the miner's original evidence tree that were not selected. Those clips remain represented only by the Merkle commitment.

A light client can reduce the computational burden further. Instead of checking every video clip attached to every block, it independently chooses a subset of those already published clips and verifies them using the same canonical verifiers.

If one of those clips fails, the corresponding block cannot be accepted by that light client. As the client verifies more independently chosen audit evidence, its probability of accepting an incorrectly verified history decreases.

Full-node block validation is deterministic. Properly implemented, light-client validation can achieve practical certainty for low computational cost.

FIG. 02.10Probabilistic verification
Full nodeevery audit clip
full verification
Light clientsome published audit clips
fewer checks
published audit clips00 / 24s
Two ways of checking in Nova

11. Network Updates

Three parts of Nova need to change periodically.

The first is the Proof of Work difficulty used to generate the random audit. It should remain cheap enough for an honest miner to produce a block at reasonable cost, but expensive enough that repeatedly searching for different valid nonces to obtain a more favourable audit is uneconomical. Since the network cannot directly observe the real-world cost of computation or the value of attacking Nova, this difficulty is treated as a security parameter and adjusted periodically using current attack-cost estimates.

The second is the verification bundle. Both synthetic generation and verification technology will improve over time. Nova must therefore be able to replace its verification models and checks in order to preserve the intended cost advantage of real physical execution over synthetic evidence. The same update process may also change the physical task, capture requirements, audit parameters or other security-related rules.

The third is a minimum and a maximum proof score per block (i.e., Pmin⁡P_{\min} and Pmax⁡P_{\max}).

Every proposed update is published before voting begins, giving participants time to obtain it, test it and evaluate its security. Its complete specification is identified by a cryptographic hash. During governance, however, proposals are referred to by small numerical identifiers rather than by their hashes. Each identifier maps to a published update specification and its corresponding hash. Since an accepted update changes the rules by which blocks are validated, its activation is effectively a coordinated protocol upgrade.

Governance is weighted by human work rather than by blocks produced by miners. During a voting period, each human-work task may carry one governance choice vv. The protocol restricts vv to a small fixed range, for example

1≤v≤100.1\leq v\leq100.

Each permitted value may represent support for a particular proposed update, the currently active version, abstention, or another governance option defined for that voting period.

The governance choice is made part of the task itself. If tt is the task hash and vv is the selected governance choice, the hash actually used to generate the physical instructions is

t′=H(t∥v).t'=H(t\parallel v).

The participant therefore performs the task derived from t′t'. The governance choice vv is also committed together with that task's evidence in the Merkle tree.

This means that a miner cannot simply change the governance choice attached to already-produced evidence. Changing vv changes t′t', which changes the physical task that the evidence is expected to show. The existing recording would therefore no longer correspond to the required task. A miner may instead exclude the contribution before constructing the evidence commitment, but doing so also means excluding its human-work weight.

Restricting vv to a small range limits the additional space of task hashes that participants or miners can choose from.

The physical evidence is large, so the normal audit reveals only a relatively small number of video clips. Governance information is much smaller. The successful Proof of Work digest can therefore generate a second, much larger sample of tasks for governance counting. For those tasks, the miner reveals the governance choices already committed alongside the evidence hashes in the Merkle tree, together with their Merkle proofs, without revealing the corresponding videos.

The governance sample is bounded by the protocol but can be much larger than the physical-evidence sample. Its purpose is to estimate the distribution of governance choices across the human work contained in the block while making it prohibitively expensive for a miner to search through enough valid nonces to materially bias that distribution.

Each task carries at most one unit of governance weight. Governance results are accumulated from finalized blocks over a defined voting period rather than decided by any individual block.

Update selection can proceed in two stages. During a proposal period, participants may support a limited number of candidate updates. The strongest qualifying proposal then enters a binary ratification against the currently active version. If it does not receive the required level of human-work-weighted support, the existing version remains active. The voting period, nomination requirement and activation threshold are protocol parameters.

Once an update has been accepted, its activation is fixed in advance. From that time onward, blocks are verified according to the exact specification associated with the accepted governance identifier and identified by its cryptographic hash. Nodes that have not upgraded can no longer fully validate the new consensus rules.

FIG. 02.11Network updates
Off-chain proposals · numerical identifiers00 / 84s
Human-work governance
CONTINUE THE EXPLORATIONA witness
from reality.
SECTION 03The physical witness