Struct StandardConfig

pub struct StandardConfig<G, Col, Chall, I, W, Srs, Sel = (), Str = EmptyStructure<G>>(/* private fields */);

A standard folding config that supports: G: any curve Col: any column implementing FoldingColumnTrait Chall: any challenge Sel: any dynamic selector Str: structures that can be indexed by Col, thus implementing Index<Col> I: instances (implementing Instance) that can be indexed by Chall W: witnesses (implementing Witness) that can be indexed by Col and Sel

use ark_poly::{EvaluationDomain, Radix2EvaluationDomain};
use mina_poseidon::FqSponge;
use folding::{examples::{BaseSponge, Curve, Fp}, FoldingScheme};

// instantiating the config with our types and the defaults for selectors and structure
type MyConfig = StandardConfig<Curve, MyCol, MyChallenge, MyInstance<Curve>, MyWitness<Curve>>;
let constraints = vec![constraint()];
let domain = Radix2EvaluationDomain::<Fp>::new(2).unwrap();
let srs = poly_commitment::srs::SRS::<Curve>::create(2);
srs.get_lagrange_basis(domain);
// this is the default structure, which does nothing or panics if
// indexed (as it shouldn't be indexed)
let structure = EmptyStructure::default();

// here we can use the config
let (scheme, _) =
FoldingScheme::<MyConfig>::new(constraints, &srs, domain, &structure);

let [left, right] = pairs;
let left = (left.0, left.1);
let right = (right.0, right.1);

let mut fq_sponge = BaseSponge::new(Curve::other_curve_sponge_params());
let _output = scheme.fold_instance_witness_pair(left, right, &mut fq_sponge);

Trait Implementations

impl<G, Col, Chall, I, W, Srs, Sel, Str> Debug for StandardConfig<G, Col, Chall, I, W, Srs, Sel, Str>

fn fmt(&self, __f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<G, Col, Chall, Sel, Str, I, W, Srs> FoldingConfig for StandardConfig<G, Col, Chall, I, W, Srs, Sel, Str>

where Self: 'static, G: CommitmentCurve, I: Instance<G> + Index<Chall, Output = G::ScalarField> + Clone, W: Witness<G> + Clone + Index<Col, Output = [G::ScalarField]> + Index<Sel, Output = [G::ScalarField]>, Srs: SRS<G>, Col: Hash + Eq + Debug + Clone + FoldingColumnTrait, Sel: Ord + Copy + Hash + Debug, Chall: Hash + Eq + Debug + Copy, Str: Clone + Index<Col, Output = [G::ScalarField]>,

type Column = Col

type Selector = Sel

type Challenge = Chall

The type of an abstract challenge that can be found in the expressions provided as constraints.

type Curve = G

The target curve used by the polynomial commitment

type Srs = Srs

The SRS used by the polynomial commitment. The SRS is used to commit to the additional columns that are added by the quadraticization.

type Instance = I

For Plonk, it will be the commitments to the polynomials and the challenges

type Witness = W

For PlonK, it will be the polynomials in evaluation form that we commit to, i.e. the columns. In the generic prover/verifier, it would be kimchi_msm::witness::Witness.

type Structure = Str

type Env = Env<G, Col, Chall, Sel, Str, I, W>

impl<G, Col, Chall, I, W, Srs, Sel, Str> Hash for StandardConfig<G, Col, Chall, I, W, Srs, Sel, Str>

fn hash<__HGColChallIWSrsSelStr>(&self, __state: &mut __HGColChallIWSrsSelStr)

where __HGColChallIWSrsSelStr: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<G, Col, Chall, I, W, Srs, Sel, Str> PartialEq for StandardConfig<G, Col, Chall, I, W, Srs, Sel, Str>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<G, Col, Chall, I, W, Srs, Sel, Str> Eq for StandardConfig<G, Col, Chall, I, W, Srs, Sel, Str>