> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/a16z/jolt/llms.txt
> Use this file to discover all available pages before exploring further.

# 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

```rust theme={null}
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

```rust theme={null}
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

```rust theme={null}
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

```rust theme={null}
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

```rust theme={null}
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

```rust theme={null}
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:

```rust theme={null}
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:

```rust theme={null}
#[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]`:

```rust theme={null}
#[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`](/api/functions/compile) - Compiles the guest program required for preprocessing
* [`prove`](/api/functions/prove) - Uses prover preprocessing to generate proofs
* [`verify`](/api/functions/verify) - Uses verifier preprocessing to verify proofs
* [`memory_config`](/api/functions/memory-config) - Returns the memory configuration