preprocess

Generate preprocessing data for proving and verifying

Overview

Preprocessing functions generate reusable data structures required for efficient proving and verification. The #[jolt::provable] macro generates several preprocessing functions that must be called before proving or verifying.

Preprocessing Pipeline

The preprocessing pipeline has three stages:

1. Shared preprocessing - Common data used by both prover and verifier
2. Prover preprocessing - Prover-specific data derived from shared preprocessing
3. Verifier preprocessing - Verifier-specific data derived from shared preprocessing

Program → Shared Preprocessing → Prover Preprocessing
                                → Verifier Preprocessing

Function Signatures

preprocess_shared

pub fn preprocess_shared_<function_name>(
    program: &mut jolt::host::Program
) -> jolt::JoltSharedPreprocessing

Generates shared preprocessing data from the compiled program.

Parameters:

• program - Mutable reference to the compiled guest program

Returns:

• Shared preprocessing data containing:
  • Decoded bytecode
  • Memory layout
  • Memory initialization
  • Maximum trace length configuration

preprocess_prover

pub fn preprocess_prover_<function_name>(
    shared_preprocessing: jolt::JoltSharedPreprocessing
) -> jolt::JoltProverPreprocessing<jolt::F, jolt::PCS>

Generates prover-specific preprocessing from shared data.

Parameters:

• shared_preprocessing - The shared preprocessing output

Returns:

• Prover preprocessing including commitment scheme generators and prover-specific state

preprocess_verifier

pub fn preprocess_verifier_<function_name>(
    shared_preprocessing: jolt::JoltSharedPreprocessing,
    generators: <jolt::PCS as jolt::CommitmentScheme>::VerifierSetup,
) -> jolt::JoltVerifierPreprocessing<jolt::F, jolt::PCS>

Generates verifier-specific preprocessing from shared data.

Parameters:

• shared_preprocessing - The shared preprocessing output
• generators - Verifier setup for the commitment scheme (obtained from prover preprocessing)

Returns:

• Verifier preprocessing containing all data needed for verification

verifier_preprocessing_from_prover

pub fn verifier_preprocessing_from_prover_<function_name>(
    prover_preprocessing: &jolt::JoltProverPreprocessing<jolt::F, jolt::PCS>
) -> jolt::JoltVerifierPreprocessing<jolt::F, jolt::PCS>

Convenience function to derive verifier preprocessing from prover preprocessing.

Parameters:

• prover_preprocessing - Reference to prover preprocessing

Returns:

• Verifier preprocessing

Usage Examples

Standard Preprocessing Flow

let target_dir = "/tmp/jolt-guest-targets";

// Step 1: Compile the guest program
let mut program = guest::compile_fib(target_dir);

// Step 2: Generate shared preprocessing
let shared_preprocessing = guest::preprocess_shared_fib(&mut program);

// Step 3: Generate prover preprocessing
let prover_preprocessing = guest::preprocess_prover_fib(shared_preprocessing.clone());

// Step 4: Generate verifier preprocessing
let verifier_setup = prover_preprocessing.generators.to_verifier_setup();
let verifier_preprocessing = guest::preprocess_verifier_fib(
    shared_preprocessing,
    verifier_setup,
);

// Now ready to prove and verify
let prove_fib = guest::build_prover_fib(program, prover_preprocessing);
let verify_fib = guest::build_verifier_fib(verifier_preprocessing);

Alternative: Deriving Verifier from Prover

let mut program = guest::compile_fib(target_dir);
let shared_preprocessing = guest::preprocess_shared_fib(&mut program);
let prover_preprocessing = guest::preprocess_prover_fib(shared_preprocessing);

// Derive verifier preprocessing from prover
let verifier_preprocessing = guest::verifier_preprocessing_from_prover_fib(
    &prover_preprocessing
);

Serializing Preprocessing

Preprocessing data can be serialized and saved to disk for reuse:

use jolt_sdk::serialize_and_print_size;

let save_to_disk = true;
if save_to_disk {
    serialize_and_print_size(
        "Verifier Preprocessing",
        "/tmp/jolt_verifier_preprocessing.dat",
        &verifier_preprocessing,
    )
    .expect("Could not serialize preprocessing.");
}

Memory Configuration

The preprocessing uses memory configuration attributes from the #[jolt::provable] macro:

#[jolt::provable(
    max_input_size = 4096,
    max_output_size = 4096,
    max_trusted_advice_size = 0,
    max_untrusted_advice_size = 0,
    stack_size = 4096,
    heap_size = 1_000_000,
    max_trace_length = 1_000_000,
)]
fn my_function(input: u32) -> u32 {
    // implementation
}

These attributes configure the memory layout embedded in the preprocessing:

• max_input_size - Maximum size of serialized public inputs
• max_output_size - Maximum size of serialized outputs
• max_trusted_advice_size - Maximum size of trusted advice
• max_untrusted_advice_size - Maximum size of untrusted advice
• stack_size - Guest program stack size
• heap_size - Guest program heap size
• max_trace_length - Maximum execution trace length

Performance Considerations

One-Time Cost

Preprocessing is a one-time cost for a given program. Once computed, the preprocessing can be reused for any number of proofs with different inputs.

Computation Time

Preprocessing time depends on:

• Program size (bytecode length)
• max_trace_length parameter
• Memory configuration sizes

Typically takes seconds to minutes for moderate-sized programs.

Storage Size

Verifier preprocessing is typically much smaller than prover preprocessing, making it suitable for:

• Embedding in verifier applications
• Distribution to multiple verifiers
• Long-term storage

Generated From

For a function annotated with #[jolt::provable]:

#[jolt::provable]
fn fib(n: u32) -> u32 {
    // implementation
}

The macro generates:

• preprocess_shared_fib
• preprocess_prover_fib
• preprocess_verifier_fib
• verifier_preprocessing_from_prover_fib

Related Functions

• compile - Compiles the guest program required for preprocessing
• prove - Uses prover preprocessing to generate proofs
• verify - Uses verifier preprocessing to verify proofs
• memory_config - Returns the memory configuration