Game of Coding: Coding Theory in the Presence of Rational Adversaries, Motivated by Decentralized Machine Learning

TL;DR

The game of coding is introduced, a novel game-theoretic framework that extends coding theory to trust-minimized settings where honest nodes are not in the majority and demonstrates the ability to achieve a non-zero probability of data recovery even when adversarial nodes are in the majority.

Abstract

Coding theory plays a crucial role in enabling reliable communication, storage, and computation. Classical approaches assume a worst-case adversarial model and ensure error correction and data recovery only when the number of honest nodes exceeds the number of adversarial ones by some margin. However, in some emerging decentralized applications, particularly in decentralized machine learning (DeML), participating nodes are rewarded for accepted contributions. This incentive structure naturally gives rise to rational adversaries who act strategically rather than behaving in purely malicious ways. In this paper, we first motivate the need for coding in the presence of rational adversaries, particularly in the context of outsourced computation in decentralized systems. We contrast this need with existing approaches and highlight their limitations. We then introduce the game of coding, a novel game-theoretic framework that extends coding theory to trust-minimized settings where honest nodes are not in the majority. Focusing on repetition coding, we highlight two key features of this framework: (1) the ability to achieve a non-zero probability of data recovery even when adversarial nodes are in the majority, and (2) Sybil resistance, i.e., the equilibrium remains unchanged even as the number of adversarial nodes increases. Finally, we explore scenarios in which the adversary's strategy is unknown and outline several open problems for future research.

Figures (9)

• Figure 1: Game of coding aims to address scenarios that the trust assumptions of classical coding theory no longer hold, particularly in decentralized environmentssliwinski2019blockchains.
• Figure 2: In Web 2.0, back-ends rely on powerful corporate servers with limited transparency. Web 3.0 uses decentralized platforms, which are transparent but computationally limited, requiring heavy tasks to be outsourced without an honest majority guarantee.
• Figure 3: In verifiable computing, the prover performs the computation off-chain and sends both the result and a validity proof to the verifier (typically a smart contract on the blockchain). The verifier checks the proof and either accepts or rejects the output without re-executing the computation. This architecture provides fast finality and resilience in adversarial-majority settings. However, it incurs high computational cost for proof generation and lacks compatibility with approximate, real-valued workloads.
• Figure 4: Illustration of optimistic verification for a layered function $f(x) = f_4 \circ f_3 \circ f_2 \circ f_1(x)$. The computing node performs the full computation and commits to the intermediate values $z_1, z_2, z_3, z_4$ using a binary hash tree: $a = \mathsf{h}(\mathsf{h}(z_1), \mathsf{h}(z_2))$, $b = \mathsf{h}(\mathsf{h}(z_3), \mathsf{h}(z_4))$, and $r = \mathsf{h}(a, b)$, which is submitted to the blockchain. If a challenger disputes the result, it independently recomputes the function and submits its own root $r'$, based on its version of the intermediate values. For example, assume the first point of discrepancy is at $z_3$. Since $r \neq r'$, both parties reveal the corresponding hash preimages. In this case, they agree on $a$ but disagree on $b$, prompting the reveal of $z_3, z_4$ versus $z_3', z_4'$. The blockchain then verifies the first differing subfunction, in this case $f_3$, by checking whether $f_3(z_2) = z_3$, using only on-chain execution of the lightweight function $f_3$.
• Figure 5: In coded (redundant) computing, the task is distributed among multiple external nodes using repetition or error-correcting codes. Some of these nodes may be adversarial, but a decoding function (e.g., median or polynomial interpolation) aggregates the results to eliminate errors. This method avoids the need for proof generation and supports approximate computing. It also provides fast confirmation. However, it fundamentally relies on an honest majority assumption.

Theorems & Definitions (3)

• Example 1
• Example 2
• Example 3