Struct folding::instance_witness::RelaxedInstance

pub struct RelaxedInstance<G: CommitmentCurve, I: Instance<G>> {
    pub extended_instance: ExtendedInstance<G, I>,
    pub u: G::ScalarField,
    pub error_commitment: PolyComm<G>,
    pub blinder: G::ScalarField,
}

A relaxed instance is an instance that has been relaxed by the folding scheme. It contains the original instance, extended with the columns added by quadriticization, the scalar u and a commitment to the slack/error term. See page 15 of Nova.

Fields

extended_instance: ExtendedInstance<G, I>

The original instance, extended with the columns added by quadriticization

u: G::ScalarField

The scalar u that is used to homogenize the polynomials

error_commitment: PolyComm<G>

The commitment to the error term, introduced when homogenizing the polynomials

blinder: G::ScalarField

Blinder used for the commitments to the cross terms

Implementations

impl<G: CommitmentCurve, I: Instance<G>> RelaxedInstance<G, I>

pub fn to_absorb(&self) -> (Vec<G::ScalarField>, Vec<G>)

Returns the elements to be absorbed by the sponge

The scalar elements of the are appended with the scalar u and the commitments are appended by the commitment to the error term.

pub fn get_extended_column_commitment(&self, i: usize) -> Option<&PolyComm<G>>

Provides access to commitments to the extra columns added by quadraticization

Trait Implementations

impl<G: Clone + CommitmentCurve, I: Clone + Instance<G>> Clone for RelaxedInstance<G, I>where G::ScalarField: Clone,

fn clone(&self) -> RelaxedInstance<G, I>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<G: CommitmentCurve, I: Instance<G>> Foldable<<G as AffineRepr>::ScalarField> for RelaxedInstance<G, I>

A relaxed instance can be folded.

fn combine(a: Self, b: Self, challenge: G::ScalarField) -> Self

Combine two relaxed instances into a new relaxed instance.

impl<G: PartialEq + CommitmentCurve, I: PartialEq + Instance<G>> PartialEq<RelaxedInstance<G, I>> for RelaxedInstance<G, I>where G::ScalarField: PartialEq,

fn eq(&self, other: &RelaxedInstance<G, I>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<G: CommitmentCurve, I: Instance<G>> RelaxableInstance<G, I> for RelaxedInstance<G, I>

A relaxed instance is trivially relaxable.

fn relax(self) -> RelaxedInstance<G, I>

impl<G: Eq + CommitmentCurve, I: Eq + Instance<G>> Eq for RelaxedInstance<G, I>where G::ScalarField: Eq,

impl<G: CommitmentCurve, I: Instance<G>> StructuralEq for RelaxedInstance<G, I>

impl<G: CommitmentCurve, I: Instance<G>> StructuralPartialEq for RelaxedInstance<G, I>