Unpacking the VSL: What are Claims?

Introduction

Imagine trying to prove you completed a task, say, solving a complex math problem without anyone watching you do it. Instead of redoing the whole thing in front of someone, you hand them a short certificate that says, “I did it, and here’s proof.” They check the certificate, and if everything checks out, they trust your result instantly.

That’s the core idea behind verifiable computing: proving that work was done correctly, without redoing the work. It’s an approach that’s rapidly transforming how we think about trust in decentralized systems, especially in Web3, where verifying the correctness of off-chain computation and on-chain actions is essential.

At the center of this model is a concept called claims.

In this article, we’ll unpack what a claim really is from its simplest form to how it works in complex cryptographic systems. We’ll explore why claims are essential to verifiable computing and how our Verifiable Settlement Layer (VSL) uses them to create a trustless, provable Web3.

What is a claim?

In one simple sentence, a claim is any statement that can be evaluated as true or false.

In the context of verifiable computing, a claim is something someone wants to prove. It might be a computational result, a state change, a data point, or even a cross-chain message. What matters is that the claim can be backed by proof.

Let’s take an example:

“Given input X, I ran program F and got result Y.”

That’s a claim. Now, to make it verifiable, you attach a proof—a signature, a zero-knowledge proof, or even a transcript of the computation—that a verifier can use to confirm the claim without redoing the entire process.

This model is powerful because it removes the need for blind trust or expensive re-computation. Instead, verifiers check proofs, not the full computation.

Figure 1: A simplistic explanation of a claim

The importance of claims in verifiable computing

In traditional computing, we trust results because we control the system or we trust the source. But in decentralized systems like Web3, that kind of trust doesn’t scale. You can’t rely on every node, contract, or user to be honest. You need proof.

That’s where claims come in. They allow systems to say, “This result is correct and here’s why,” without requiring blind trust or redundant computation.

The following are some reasons why claims are important:

1. Interoperability across systems: Different blockchains, smart contracts, or decentralized applications can verify the same claim without needing to understand how it was originally created. This enables cross-chain communication and shared trust between otherwise siloed systems.

2. Efficiency and scale: Verifiers can validate claims in milliseconds, even if the underlying computation took hours. That’s a huge gain for applications that require frequent or complex computations like zero-knowledge proofs, machine learning models, or transaction batching.

3. Privacy-preserving guarantees: Claims can include only what's necessary to verify correctness without revealing sensitive data. This is especially powerful in zk-based systems, where the witness stays hidden but the claim remains verifiable.

4. Auditability and transparency: Because claims are standardized and logged, they form a permanent, traceable record of what happened and when. This is critical for debugging, governance, compliance, and accountability.

Examples of claims in Web3

Claims are everywhere once you know what to look for:

In each case, the structure of the proof and the verification process may differ but the principle is the same: someone made a claim, and that claim is backed by a verifiable method.

How claims work in Pi Squared

At Pi Squared, we believe that everything provable or verifiable is a claim.

That’s why our Verifiable Settlement Layer (VSL) treats claims as the foundational building block. Whether it’s verifying a computation, confirming a state change, transferring assets, or just signaling intent, it all starts with a claim in VSL.

Unlike systems that expect specific proof types or verification methods, our VSL lets you define your own:

• You define what a claim means.
• You decide what kind of proof supports it.
• You choose how that proof should be verified.

This flexibility is what makes VSL universal, modular, and adaptable to any domain from DeFi and oracles to AI and off-chain compute.

Claims, proofs, and verifiers

Let’s simplify the mental model:

• A claim is any verifiable statement.
• A proof is the evidence used to support that claim.
• A verifier checks the proof and decides whether to accept the claim.

That’s it.

Importantly, Pi Squared’s VSL doesn’t impose any restriction on what a claim or a proof must look like.

It doesn’t assume you’re using cryptography. It doesn’t require zero-knowledge proofs. You could be using digital signatures, logs, re-execution, or other verification methods.

As long as the claim is verifiable and follows the proper structure, the VSL accepts it.

How the VSL handles claims

Our VSL has a lightweight, modular backend designed to validate and store claims, not execute complex logic. Here's how it works:

1. Users or applications submit claims via the VSL client, specifying what needs to be verified.
2. The VSL checks the claim’s structure and signatures, deducts a flat fee from the submitter’s account, and logs the claim.
3. A designated verifier (an off-chain actor) picks up the claim and performs the required computation or check.
4. The verifier then submits a result claim, stating whether the original claim was valid, along with a cryptographic proof.
5. If valid, the VSL settles the claim. It credits the verifier, stores the result, and makes it queryable by any external system.

This architecture enables a powerful workflow: Submit a claim once → verify it off-chain → use it anywhere.

Figure 2: The VSL Architecture

The VSL is purposefully minimal:

• It doesn’t interpret or execute the logic behind a claim.
• It only validates structure, manages balances, and stores verified claims.
• The actual computation is delegated to verifiers, making the system faster, more secure, and easier to scale.

By separating verification from storage, the VSL becomes a universal proof ledger: a shared source of truth that any application, smart contract, or blockchain can rely on.

Conclusion

In verifiable computing, a claim is a compact, verifiable statement that a computation was done correctly. 

By building its VSL around the idea that everything is a claim, Pi Squared turns this concept into a foundation for scalable, interoperable, and trustless systems. From computation to consensus, claims unify how interactions are recorded, verified, and shared across chains and applications.

Whether you're validating a blockchain state, checking a computation, or syncing information across networks, it all begins with a claim.

You can learn more about how we use claims and the VSL architecture by exploring our documentation or testing it out on our Devnet.