qp-plonky2 1.4.1

Recursive SNARKs based on PLONK and FRI
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! Fast Reed-Solomon IOP (FRI) protocol.
//!
//! It provides both a native implementation and an in-circuit version
//! of the FRI verifier for recursive proof composition.

#[cfg(not(feature = "std"))]
use alloc::vec::Vec;

use plonky2_field::extension::Extendable;

use crate::hash::hash_types::RichField;
use crate::iop::challenger::RecursiveChallenger;
use crate::plonk::circuit_builder::CircuitBuilder;
use crate::plonk::config::AlgebraicHasher;

pub mod challenges;
pub mod oracle;
pub mod proof;
pub mod prover;
pub mod recursive_verifier;
pub mod structure;
pub(crate) mod validate_shape;
pub mod verifier;
pub mod witness_util;

// Re-export FRI types from core
pub use qp_plonky2_core::{
    FriBatchMaskingParams, FriChallenger, FriConfig, FriConfigObserve, FriFinalPolyLayout,
    FriParams, FriParamsObserve, FriReductionStrategy,
};

/// Trait for observing FRI configuration in a RecursiveChallenger (circuit target version).
///
/// This is used for recursive verification where the FRI config must be observed
/// as circuit targets.
pub trait FriConfigObserveTarget {
    /// Observe the FRI configuration parameters in a RecursiveChallenger.
    fn observe_target<F, H, const D: usize>(
        &self,
        builder: &mut CircuitBuilder<F, D>,
        challenger: &mut RecursiveChallenger<F, H, D>,
    ) where
        F: RichField + Extendable<D>,
        H: AlgebraicHasher<F>;
}

impl FriConfigObserveTarget for FriConfig {
    fn observe_target<F, H, const D: usize>(
        &self,
        builder: &mut CircuitBuilder<F, D>,
        challenger: &mut RecursiveChallenger<F, H, D>,
    ) where
        F: RichField + Extendable<D>,
        H: AlgebraicHasher<F>,
    {
        challenger.observe_element(builder.constant(F::from_canonical_usize(self.rate_bits)));
        challenger.observe_element(builder.constant(F::from_canonical_usize(self.cap_height)));
        challenger
            .observe_element(builder.constant(F::from_canonical_u32(self.proof_of_work_bits)));
        challenger.observe_elements(&builder.constants(&self.reduction_strategy.serialize()));
        challenger
            .observe_element(builder.constant(F::from_canonical_usize(self.num_query_rounds)));
    }
}

/// Trait for observing FRI parameters in a RecursiveChallenger (circuit target version).
///
/// This is used for recursive verification where the FRI params must be observed
/// as circuit targets.
pub trait FriParamsObserveTarget {
    /// Observe the FRI parameters in a RecursiveChallenger.
    fn observe_target<F, H, const D: usize>(
        &self,
        builder: &mut CircuitBuilder<F, D>,
        challenger: &mut RecursiveChallenger<F, H, D>,
    ) where
        F: RichField + Extendable<D>,
        H: AlgebraicHasher<F>;
}

impl FriParamsObserveTarget for FriParams {
    fn observe_target<F, H, const D: usize>(
        &self,
        builder: &mut CircuitBuilder<F, D>,
        challenger: &mut RecursiveChallenger<F, H, D>,
    ) where
        F: RichField + Extendable<D>,
        H: AlgebraicHasher<F>,
    {
        self.config.observe_target(builder, challenger);

        challenger.observe_element(builder.constant(F::from_bool(self.leaf_hiding)));
        challenger.observe_element(builder.constant(F::from_bool(self.batch_masking.is_some())));
        if let Some(batch_masking) = &self.batch_masking {
            challenger.observe_element(
                builder.constant(F::from_canonical_usize(batch_masking.mask_degree)),
            );
        }
        challenger.observe_element(builder.constant(F::from_canonical_usize(self.degree_bits)));
        challenger.observe_elements(
            &builder.constants(
                &self
                    .reduction_arity_bits
                    .iter()
                    .map(|&e| F::from_canonical_usize(e))
                    .collect::<Vec<_>>(),
            ),
        );
        match self.final_poly_layout {
            FriFinalPolyLayout::Single => {
                challenger.observe_element(builder.zero());
            }
            FriFinalPolyLayout::Split {
                chunk_degree_bits,
                chunks,
            } => {
                challenger.observe_element(builder.one());
                challenger
                    .observe_element(builder.constant(F::from_canonical_usize(chunk_degree_bits)));
                challenger.observe_element(builder.constant(F::from_canonical_usize(chunks)));
            }
        }
    }
}