> ## 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.

# prove

> Generate a zero-knowledge proof for a provable function

## Overview

The `prove_<function_name>` function generates a zero-knowledge proof that a computation was executed correctly. It is automatically generated by the `#[jolt::provable]` macro for each provable function.

## Function Signature

```rust theme={null}
pub fn prove_<function_name>(
    mut program: jolt::host::Program,
    preprocessing: jolt::JoltProverPreprocessing<jolt::F, jolt::PCS>,
    // ... function arguments (public inputs, untrusted advice, trusted advice)
    // Optional: trusted_advice_commitment and trusted_advice_hint (if function has trusted advice)
) -> (ReturnType, jolt::RV64IMACProof, jolt::JoltDevice)
```

### Parameters

* `program` - The compiled guest program (obtained from `compile_<function_name>`)
* `preprocessing` - Prover preprocessing data (obtained from `preprocess_prover_<function_name>`)
* Function arguments in order:
  * **Public inputs** - Regular function parameters that become part of the proof statement
  * **Untrusted advice** - Parameters marked with `jolt::UntrustedAdvice<T>` wrapper
  * **Trusted advice** - Parameters marked with `jolt::TrustedAdvice<T>` wrapper
* `trusted_advice_commitment` (optional) - Commitment to trusted advice, if function has trusted advice parameters
* `trusted_advice_hint` (optional) - Opening proof hint for trusted advice commitment

### Return Value

Returns a tuple containing:

1. **Return value** - The function's output (or `()` if no return value)
2. **Proof** - The generated zero-knowledge proof (`jolt::RV64IMACProof`)
3. **Program I/O** - I/O device state including inputs, outputs, and panic flag (`jolt::JoltDevice`)

## Two-Pass Proving Strategy

The prove function uses a two-pass strategy for programs with advice:

1. **First pass** (if `compute_advice` ELF exists): Runs the compute\_advice version to populate the advice tape
2. **Second pass**: Runs the normal version with the populated advice tape to generate the proof

This allows complex computations to be performed off-circuit while maintaining zero-knowledge properties.

## Usage Example

### Basic Usage

```rust theme={null}
use std::time::Instant;

// Compile and preprocess
let target_dir = "/tmp/jolt-guest-targets";
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);

// Generate proof
let now = Instant::now();
let (output, proof, io_device) = guest::prove_fib(program, prover_preprocessing, 50);
println!("Prover runtime: {} s", now.elapsed().as_secs_f64());

println!("Output: {}", output);
```

### With Build Prover (Recommended)

For repeated proving with the same preprocessing:

```rust theme={null}
let prove_fib = guest::build_prover_fib(program, prover_preprocessing);

// Can now call prove_fib multiple times with different inputs
let (output1, proof1, io1) = prove_fib(10);
let (output2, proof2, io2) = prove_fib(20);
let (output3, proof3, io3) = prove_fib(30);
```

### With Trusted Advice

For functions that use trusted advice, you must first commit to the advice:

```rust theme={null}
let trusted_data = vec![1, 2, 3, 4, 5];

// Commit to trusted advice
let (commitment, hint) = guest::commit_trusted_advice_my_function(
    trusted_data.clone(),
    &prover_preprocessing,
);

// Generate proof with committed advice
let public_input = 42;
let (output, proof, io_device) = guest::prove_my_function(
    program,
    prover_preprocessing,
    public_input,
    trusted_data,
    commitment,
    hint,
);
```

## Generated From

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

```rust theme={null}
#[jolt::provable]
fn fib(n: u32) -> u32 {
    // function implementation
}
```

The macro generates `prove_fib` with the signature shown above.

## Related Functions

* [`verify`](/api/functions/verify) - Verifies a generated proof
* [`preprocess`](/api/functions/preprocess) - Generates preprocessing data required for proving
* [`analyze`](/api/functions/analyze) - Analyzes execution without generating a proof