sp1-recursion-circuit 6.0.0

Recursion circuit for SP1 proof aggregation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use std::collections::BTreeSet;

use slop_air::BaseAir;
use slop_algebra::{ExtensionField, Field};
use slop_multilinear::Point;
use sp1_hypercube::{
    air::MachineAir, log2_ceil_usize, Chip, ChipEvaluation, LogUpEvaluations, LogUpGkrOutput,
    LogupGkrProof, LogupGkrRoundProof,
};

use super::sumcheck::dummy_sumcheck_proof;

pub fn dummy_gkr_proof<F: Field, EF: ExtensionField<F>, A: MachineAir<F>>(
    shard_chips: &BTreeSet<Chip<F, A>>,
    log_max_row_height: usize,
) -> LogupGkrProof<F, EF> {
    let total_num_interactions =
        shard_chips.iter().map(|chip| chip.num_interactions()).sum::<usize>();
    let output_size = 1 << (log2_ceil_usize(total_num_interactions) + 1);
    let circuit_output = LogUpGkrOutput {
        numerator: vec![EF::zero(); output_size].into(),
        denominator: vec![EF::zero(); output_size].into(),
    };

    let round_proofs = (0..log_max_row_height - 1)
        .map(|i| LogupGkrRoundProof {
            numerator_0: EF::zero(),
            numerator_1: EF::zero(),
            denominator_0: EF::zero(),
            denominator_1: EF::zero(),
            sumcheck_proof: dummy_sumcheck_proof::<EF>(
                i + log2_ceil_usize(total_num_interactions) + 1,
                3,
            ),
        })
        .collect();

    let logup_evaluations = LogUpEvaluations {
        point: Point::from_usize(0, log_max_row_height),
        chip_openings: shard_chips
            .iter()
            .map(|chip| {
                (
                    chip.air.name().to_string(),
                    ChipEvaluation {
                        main_trace_evaluations: vec![EF::zero(); chip.width()].into(),
                        preprocessed_trace_evaluations: if chip.preprocessed_width() > 0 {
                            Some(vec![EF::zero(); chip.preprocessed_width()].into())
                        } else {
                            None
                        },
                    },
                )
            })
            .collect(),
    };

    LogupGkrProof { circuit_output, round_proofs, logup_evaluations, witness: F::zero() }
}