Minimal viable protocol

With these issues in mind we can construct a minimally viable protocol for creating and publishing pairwise comparisons in a decentralized context.

Desired features

Our desired features for such a protocol include:

Calculating pairwise comparisons between nodes so we can tell whether their work results were within an acceptable error threshold for a given task.
Publishing and sharing data on some medium M—for example a blockchain like Ethereum or a decentralized communications platform like XMTP.
A way to stop each node from prematurely stealing another node’s work.
A way to stop nodes from lying about their side of a pairwise comparison.
Surfacing disputes wherever the protocol makes that possible.
Identifying the minimally required stakeholders in the protocol.
A defined threshold for acceptable errors.

Specification

The generalized CRPC protocol lets multiple nodes independently verify each other’s work through these steps:

Distribute the work to all nodes.
Nodes independently perform their work.
Generate commitments for the work results.
Publish commitments for the work results.
Reveal the original work and the salts used to build those commitments.
Compute distances between results as pairwise comparisons.
Generate commitments for the pairwise comparisons.
Publish commitments for the pairwise comparisons.
Reveal the pairwise comparisons and their salts.
The originator reviews the outcome and decides whether the pairwise comparisons are acceptable.

The protocol uses two commit–reveal rounds: the first stops nodes from free-riding on others’ work after seeing it; the second stops them from lying about pairwise comparisons. That structure supports decentralization and creates several natural dispute surfaces.

Let n be the number of nodes in a graph N with $\lvert V \rvert \geq 2$ . Let $\{N_1, N_2, \ldots, N_n\}$ be the nodes in the run. Each node $N_i$ holds salts $\text{S1}_i$ and $\text{S2}_i$ —one pair per commit–reveal round—usable as disposable randomness for commitments.

Coordination happens over a medium M (blockchain, messaging layer, etc.).

All nodes are assumed to share a known function f used to execute the work W.

Formal step summary (KaTeX)

Let M be the medium (broadcast to all parties where needed). Salts $\text{S1}_i$ , $\text{S2}_i$ bind the two commit–reveal rounds.

\begin{aligned} \text{(1)}\quad & W \ \text{delivered to each } N_i \\ \text{(2)}\quad & \Phi_i = f(W) \\ \text{(3)}\quad & C(\Phi_i) = \operatorname{Hash}\bigl(\Phi_i \parallel S1_i\bigr) \\ \text{(4)}\quad & \text{Publish } C(\Phi_i) \text{ on } M \\ \text{(5)}\quad & \text{Publish } (\Phi_i, S1_i) \text{ on } M \\ \text{(6)}\quad & \delta_{ij} = \operatorname{distance}(\Phi_i, \Phi_j) \\ \text{(7)}\quad & C(\delta_{ij}) = \operatorname{Hash}\bigl(\delta_{ij} \parallel S2_i\bigr) \\ \text{(8)}\quad & \text{Publish } C(\delta_{ij}) \text{ on } M \\ \text{(9)}\quad & \text{Publish } (\delta_{ij}, S2_i) \text{ on } M \\ \text{(10)}\quad & r_{ij} = e_{ij} = e_{ji},\quad r_{ij} < \epsilon \ \ \text{(similarity-style threshold; invert for separation / randomness)} \end{aligned}

Protocol detailed steps

Step 1: Work distribution

The originator O selects (by whatever policy you use) which nodes may service W, then distributes W over M to every node in N.

Work W broadcast on medium M to all nodes in graph N — Work distribution on M to graph N (reference export).

Step 2: Independent work execution

Each $N_i$ runs f on W independently. Outputs may be non-deterministic or noisy; node i’s result is $\Phi_i$ .

Independent execution: each node produces Phi_i — Parallel execution yielding $\Phi_i$ per node (reference export).

Step 3: Work commitments created

Each $N_i$ forms a hash-based commitment to $\Phi_i$ together with salt $\text{S1}_i$ .

Work commitment C of Phi_i with salt S1_i — Commitment $C(\Phi_i)$ (reference export).

Step 4: Work commitments published

Each node publishes its work commitment on M. Everyone sees an immutable promise of what will be opened next—no post-hoc edits to $\Phi_i$ after others have committed.

That removes a wait-and-see strategy: commitments $C(\Phi_i)$ are public before reveals, so a node cannot quietly copy another’s labor and claim it as its own.

Dispute point 1 — timeouts: The first moment disputes can appear is a timeout: an implementation must define how to treat nodes that fail to publish work commitments on M in time.

Work commitments published on medium M — Work commitments on M (reference export).

Step 5: Work revealed

Each node publishes $\Phi_i$ and $\text{S1}_i$ so neighbors can check $C(\Phi_i)$ and proceed to distance / comparison work.

Note: Heavy payloads can live on L2 or blobs while M carries commitments and pointers—useful if the originator or others need material when a dispute opens at this stage.

Dispute point 2 — timeouts and commitment checks: Timeouts apply again. After reveal, any node can recompute a neighbor’s commitment; mismatches are evidence that a node lied about its work.

Reveal Phi_i and S1_i after commitments — Reveal $\Phi_i$ , $\text{S1}_i$ (reference export).

Step 6: Distance calculations as pairwise comparisons

With $\Phi_i$ visible to neighbors $N_j$ , each edge uses a distance appropriate to f (e.g. SSIM for images, embedding distance for text).

For every reference comparison $r_{ij}$ , we assume two reciprocal measurements: i → j and j → i. Each node publishes the comparison it computed toward each neighbor.

Pairwise distance delta_ij from revealed work — $\delta_{ij}$ from revealed work (reference export).

Step 7: Pairwise comparison commitments created

Each $N_i$ commits to its reported $\delta_{ij}$ toward each neighbor $N_j$ , using salt $\text{S2}_i$ .

Commitment C of delta_ij with salt S2_i — $C(\delta_{ij})$ (reference export).

Step 8: Pairwise comparison commitments published

Nodes publish $C(\delta_{ij})$ on M, mirroring the work-commitment phase: they cannot rewrite comparisons after seeing neighbors’ values, and cannot steal a neighbor’s comparison claim.

Dispute point 3 — timeouts: As with dispute point 1, some nodes may fail to publish comparison commitments in time.

Note: These commitments are small; they can sit on-chain if M is a chain.

Comparison commitments published on medium M — Comparison commitments on M (reference export).

Step 9: Pairwise comparisons revealed

Each node publishes $\delta_{ij}$ and $\text{S2}_i$ so $C(\delta_{ij})$ can be verified.

Dispute point 4 — reciprocal mismatch: On each edge, nodes can dispute if their reciprocal calculations do not match—i.e. the edge that should realize $r_{ij}$ is inconsistent with $\delta_{ij}$ and $\delta_{ji}$ .

Note: Scalar $\delta$ values can also be stored on-chain for contracts to validate and to drive automation in the final step.

Reveal delta_ij and S2_i — Reveal $\delta_{ij}$ , $\text{S2}_i$ (reference export).

Step 10: Verification

O uses the stored pairwise comparisons: compare to $\epsilon$ , flag disputes, and run any decision logic that depends on acceptable comparisons.

Verification against epsilon and dispute identification — Threshold checks and dispute identification (reference export).

By this step, reciprocal disagreements are expected to have been surfaced in step 9. Acceptability can be checked once per edge using the mutual reference value $r_{ij}$ with

r_{ij} = e_{ij} = e_{ji}, \quad r_{ij} < \epsilon

(under the “similar enough” reading of the threshold; other tasks may invert the inequality as in the randomness example.)

At this point the run has let many nodes publish pairwise comparisons decentralized, while mitigating theft of work and blatant lying about comparisons.

Sequence diagram for two nodes

Below is the conceptual sequence for two nodes over an abstract medium M, emphasizing where disputes can arise and what kind they are. The appendix keeps PlantUML source for tooling; this page renders the same flow with Mermaid (Nextra compiles fenced mermaid code blocks automatically).

Two-node CRPC flow overview from the reference export — Two-node CRPC overview strip from the reference export (see Mermaid below for the step-by-step sequence).