Proof-Carrying Data (PCD)

PCD enables recursive proof composition where each new computation step generates a proof that attests to both the correctness of the current step and the validity of all prior steps. This creates a chain of verifiable computation where the final proof is constant-size regardless of the total computation length.

• Each participant adds their computation and generates a new proof
• The proof size remains O(1) regardless of computation depth
• Enables unbounded distributed computation chains

PCD operates in a mutually distrustful setting where no participant needs to trust any other. Each party verifies the incoming proof before performing their computation and generating an updated proof. This eliminates the need for a central coordinator or trusted third party.

• Participants only need to trust the cryptographic assumptions
• No single party can forge or alter previous computation results
• Enables permissionless participation in computation pipelines

The final proof in a PCD chain can be verified in polylogarithmic time relative to the total computation, making verification extremely efficient. A verifier only needs to check a single, constant-size proof rather than re-executing the entire distributed computation.

• Verification time: O(log n) or better
• Proof size: typically a few hundred bytes
• No need to replay the entire computation history

PCD uses compliance predicates—boolean functions that define what constitutes a valid state transition. Each participant must prove that their computation satisfies the predicate before the proof is accepted. This enforces protocol-level rules without relying on honest behavior.

• Predicates encode application-specific rules
• Invalid transitions are cryptographically rejected
• Enables complex multi-party protocols with guaranteed correctness

PCD leverages zero-knowledge properties to allow participants to prove correct computation without revealing their private inputs or intermediate states. Each party sees only the public outputs and the validity proof, not the sensitive data of previous participants.

• Private inputs remain confidential throughout the chain
• Only designated public outputs are revealed
• Compatible with zk-SNARK and zk-STARK backends

Unlike simple recursive proof systems that may have depth limitations, PCD supports unbounded recursion through its incremental update mechanism. The proof can be extended indefinitely without degradation in security or increase in verification cost.

• No fixed limit on computation chain length
• Security remains constant regardless of depth
• Enables long-running distributed systems and payment channels

PCD is the cryptographic engine behind recursive ZK-rollups, where a single proof attests to the validity of an entire chain of state transitions. Instead of verifying every transaction, a validity proof is generated for a batch, and a subsequent proof verifies that proof, compressing an infinite number of computations into a constant-size proof. This enables horizontal scaling by parallelizing proof generation across many provers, each proving a slice of the execution trace, which are then recursively aggregated into one final proof posted to the Layer 1 chain.

PCD enables verifiable distributed computing frameworks where the correctness of a massive parallelized computation can be proven without re-executing the entire job. In a MapReduce paradigm, each mapper produces a result with an attached proof of correct execution on its data shard. Reducers then combine these results and generate a new proof that attests to the validity of the aggregation step and all underlying mapper proofs. The final output is a single proof verifying the entire distributed pipeline, allowing a weak client to outsource computation to an untrusted server farm and verify the result in milliseconds.

In interbank settlement networks, PCD reconciles the conflict between transaction privacy and regulatory compliance. Each bank in a payment chain can apply its proprietary compliance rules (e.g., sanctions screening) to a transaction locally, producing a proof that the check passed without revealing the sensitive customer data that was screened. This proof is carried forward with the payment. A downstream bank or regulator can verify the incremental proof chain to confirm that every institution in the flow executed the required compliance checks correctly, without ever seeing the underlying transaction details or the internal rule sets of other banks.

Multi-agent systems require agents to make decisions based on the actions of other agents they do not trust. PCD provides a verifiable execution lineage for agent swarms. When Agent A performs an action (e.g., executing a trade or bidding in an auction), it generates a proof of correct execution according to its public policy. Agent B, before acting on this information, verifies Agent A's proof and folds it into its own proof for its subsequent action. This creates an unforgeable, incrementally verifiable audit trail of the entire swarm's decision graph, enabling trustless coordination without a central arbiter.

PCD enables verifiable machine learning (zkML) pipelines where a complex, multi-stage inference can be proven correct without revealing the model weights or the input data. Consider a medical diagnosis pipeline: a scan is processed by a proprietary tumor detection model, then a classification model, then a report generator. Using PCD, each stage produces a proof of correct execution. These are recursively composed into a single proof that verifies the entire pipeline ran correctly on the given input, allowing a patient to receive a cryptographically verified diagnosis without the hospital exposing its proprietary AI models or the patient revealing their medical images.

In decentralized social networks, PCD enables verifiable moderation without a central censor. A content post carries a proof that it complies with a published community moderation policy. As the post propagates through relay nodes, each node verifies the incoming proof and generates a new proof attesting that it performed its own moderation check (e.g., spam filtering) before forwarding. A user receiving the post can verify the chain of compliance proofs to confirm it passed all community rules without trusting any single relay. This decouples moderation from centralized platforms, making content propagation censorship-resistant while maintaining community standards.