Proof-of-Collaborative-Learning (PoCL)

• Proof-of-Collaborative-Learning (PoCL) is a consensus paradigm that fuses federated or split learning with blockchain, verifying and rewarding contributions via cryptographic proofs.
• It employs mechanisms such as federated multi-winner voting and zkSNARK-based proof-of-contribution to ensure transparent, fair, and privacy-preserving model updates.
• PoCL transforms energy from traditional Proof-of-Work into a productive process by incentivizing and verifying collaborative training, addressing inefficiencies and enhancing security.

Proof-of-Collaborative-Learning (PoCL) is a consensus paradigm that integrates federated or split learning with verifiable, incentive-aligned contributions to distributed ledger systems. It redirects computational resources from conventional Proof-of-Work (PoW) mining into productive collaborative model training. Participants' (miners' or trainers') contributions are evaluated, verified, and compensated according to their quantifiable marginal improvement to the joint model, with blockchain enforcing fairness, transparency, and security. Diverse protocol designs exist, including both federated multi-winner voting schemes and smart-contract–secured proof-of-contribution mechanisms using zero-knowledge proofs.

1. High-Level Principles and Motivation

PoCL addresses two principal inefficiencies of traditional blockchain consensus:

• The nonproductive nature of energy-intensive PoW hash computations.
• The difficulty of trustless, fair, and privacy-preserving contributions in collaborative machine learning.

In PoCL, mining consists of participants collaboratively training a global deep model, evaluated for both prediction quality and timeliness. Incentives (block rewards) are distributed among those whose updates demonstrably improve the model. The approach maintains blockchain decentralization and security, repurposes mining energy for machine learning, and achieves incentive-compatibility through verifiable and transparent contribution rewards (Sokhankhosh et al., 2024).

2. Federated Multi-Winner PoCL Workflow

A core PoCL realization structures each blockchain round as a competitive, yet collaborative, federated learning cycle:

1. Parameter Announcement: System administrator posts contest parameters—number of winners $K$, deadlines $(\Delta_1, \Delta_2, \Delta_3)$—on-chain.
2. Model Proposal: Each miner downloads the current global model $M_G^{(t-1)}$, trains it on private data $D_i$, produces local model $M_i^{(t)}$, commits to its hash $h_i$, and submits a batch of unlabeled test records $T_i^{(t)}$ before $\Delta_1$.
3. Peer Evaluation: All test records $T^{(t)} = \bigcup_i T_i^{(t)}$ are aggregated and distributed. Each miner downloads peer models, predicts labels $\hat{y}_{j \to T}$, and submits results before $(\Delta_1, \Delta_2, \Delta_3)$0.
4. Voting: Each miner computes the average prediction loss for all peers,

$(\Delta_1, \Delta_2, \Delta_3)$1

ranks models lexicographically by increasing $(\Delta_1, \Delta_2, \Delta_3)$2 (prediction loss, then submission timestamp), and posts a ranking before $(\Delta_1, \Delta_2, \Delta_3)$3.

1. Winner Selection & Aggregation: The K miners with the most first-place votes are declared winners; their transactions form the next block. Their submitted weights are verified against hashes, aggregated (e.g., FedAvg), and form the updated global model $(\Delta_1, \Delta_2, \Delta_3)$4.
2. Reward Calculation: Each winner receives a share of the block reward proportional to the marginal per-weight contribution of their update relative to the prior global model:

$(\Delta_1, \Delta_2, \Delta_3)$5

The total reward is split in proportion to $(\Delta_1, \Delta_2, \Delta_3)$6 across all $(\Delta_1, \Delta_2, \Delta_3)$7 winners (Sokhankhosh et al., 2024).

3. Verifiable Proof-of-Contribution Mechanisms

An alternative PoCL implementation is founded on explicit proof-of-contribution via cryptographically enforced protocols, often leveraging zero-knowledge succinct non-interactive arguments of knowledge (zkSNARKs):

• Trainer updates $(\Delta_1, \Delta_2, \Delta_3)$8 are aggregated only after robust outlier filtering. The new global model is computed as a weighted average over non-outlier trainers:

$(\Delta_1, \Delta_2, \Delta_3)$9

with uniform or learned weights.

• Marginal contribution is quantified using a randomized leave-one-out (RLOO) score,

$M_G^{(t-1)}$0

where $M_G^{(t-1)}$1 is a randomly sampled subset of honest trainers including $M_G^{(t-1)}$2.

• Zero-Knowledge Verification: All key computations—outlier filtering, aggregation, and contribution assessment—are performed off-chain but proved correct on-chain with succinct zkSNARKs. Core operations (e.g., model averaging, norm computations, validation inference) are encoded as R1CS-arithmetic circuits over a finite field (Buyukates et al., 2023).

A smart contract manages trainer registration, submission of local updates (via content identifiers to decentralized storage), validation of zkSNARKs for outlier scores, aggregation, and contribution splits, and finally, payout of rewards according to provable marginal contribution.

4. Split Learning PoCL with End-to-End Verifiability

PoCL can be realized in split learning (SL) architectures by leveraging cryptographic proofs of correct computation at each round's "cut layer":

• Data flow: Each client computes the local forward pass up to a cut layer, transmits "smashed" activations $M_G^{(t-1)}$3 and a zk-SNARK proof $M_G^{(t-1)}$4 to the server.
• Verification: The server accepts only if $M_G^{(t-1)}$5 proves that $M_G^{(t-1)}$6 corresponds to a correct execution on committed client weights and data, per arithmetic circuit constraints.
• Backward pass: The server computes gradients and produces $M_G^{(t-1)}$7, a zk-SNARK proof that updates and gradients are faithfully computed; clients update only if $M_G^{(t-1)}$8 is valid.
• Security theorems: The system guarantees completeness, soundness, and zero-knowledge (i.e., no data leakage), enforced per batch. Adversarial clients or server cannot fake correct computation without being detected (Alaa et al., 3 Nov 2025).
• Consensus: A lightweight verifier entity plays the role of a decentralized "miner," logging only those batch/model updates that carry valid cryptographic proofs, inducing blockchain consensus through universal verifiability rather than hash-based work.

5. Security Models and Robustness

PoCL protocols are constructed to resist a range of adversarial behaviors:

• Zero-Model Attack: Publishing degenerate (e.g., all-zero) models is self-defeating, as such models yield maximal prediction loss and receive no votes or rewards.
• K-Nearest-Neighbor (KNN) Substitution: Attempting to submit predictions from non-model-based mechanisms (e.g., KNN) is noncompetitive due to lower efficiency (higher timeliness) and accuracy, and is robustly filtered (Sokhankhosh et al., 2024).
• Label or Ranking Manipulation: Voting manipulation is prevented since the honest majority’s votes according to verifiable $M_G^{(t-1)}$9 rankings cannot be systematically subverted by minority coalitions (reverse-voting attacks are ineffective unless the attacker controls the majority).
• Byzantine and Backdoor Attacks: Outlier detection is implemented via cross-round cosine similarity and cross-trainer norm deviation, robust to both abrupt and subtle deviations without knowledge of the number of adversaries:

$D_i$0

with removal of trainers falling below thresholds or outside of a standard deviation band. Empirical results confirm 100% detection/removal rates for Byzantine updates and high rates for scaling backdoors (Buyukates et al., 2023).

• Proof Integrity: All critical computation steps are accompanied by zkSNARKs verified on-chain, preventing any party from misreporting contributions, aggregations, or outcomes without detection.

6. Fairness and Reward Distribution

PoCL enforces both within-round and across-round fairness in reward allocation:

• Marginal Contribution Proportionality: Each participant’s reward share in round $D_i$1 is given by

$D_i$2

where $D_i$3 is the per-weight improvement or RLOO score, and $D_i$4 is the round’s total reward (Sokhankhosh et al., 2024).

• Empirical evidence: Participants with larger, higher-quality datasets may win fewer rounds but accrue higher rewards per win, faithfully tracking their impact on model performance.
• Long-term cumulative fairness: Over $D_i$5 rounds, cumulative payout

$D_i$6

reflects all rounds' contributions, robust against temporal or batch heterogeneities.

• Proof of correct payment: Reward computation is included in the on-chain smart contract and verified via proof, preventing misallocation or project-owner cheat strategies (Buyukates et al., 2023).

7. System Architecture and Scalability Considerations

PoCL systems are architected for scalability and practical deployment:

Aspect	Federated Consensus	Proof-of-Contribution w/ zkSNARKs	Split Learning PoCL w/ zkSNARKs
Data Handling	On-device, no data movement	On-device, no data movement	Activations only cross “cut layer”
Privacy	Local-data privacy, test label exposure to validators	Full privacy (only encrypted models/updates; all off-chain ops zk-proved)	Strong—no raw data/weights leave device; only hashes/proofs
On-chain Load	Rankings, hashes, reward splits	Succinct Groth16 proofs (3–20 ms verify)	Minimal—only model/proof records
Computational Cost	FL local update + peer scoring	Local SGD; ZKP prove/verify for aggregator/on-chain	Proving at each cut-layer pass (0.1–1s / batch)
Attack Robustness	Empirically and theoretically robust to sabotage, free-riding, vote manipulation	Outlier detection + ZKP-enforced correctness	Verifiability at each round; universal soundness, completeness

By offloading the heavy cryptographic computation to an aggregator (federated case) or to Prover Entities (split learning), and using succinct zkSNARKs for proof, systems achieve practical performance even at scale, with on-chain verification times near-constant and low per training round (Buyukates et al., 2023, Alaa et al., 3 Nov 2025).

• "Proof-of-Collaborative-Learning: A Multi-winner Federated Learning Consensus Algorithm" (Sokhankhosh et al., 2024)
• "Proof-of-Contribution-Based Design for Collaborative Machine Learning on Blockchain" (Buyukates et al., 2023)
• "Verifiable Split Learning via zk-SNARKs" (Alaa et al., 3 Nov 2025)