Struct kimchi_msm::witness::Witness

pub struct Witness<const N_WIT: usize, T> {
    pub cols: Box<[T; N_WIT]>,
}

The witness columns used by a gate of the MSM circuits. It is generic over the number of columns, N_WIT, and the type of the witness, T. It is parametrized by a type T which can be either:

• Vec<G::ScalarField> for the evaluations
• PolyComm<G> for the commitments It can be used to represent the different subcircuits used by the project.

Fields

cols: Box<[T; N_WIT]>

A witness row is represented by an array of N witness columns When T is a vector, then the witness describes the rows of the circuit.

Implementations

impl<const N_WIT: usize, T> Witness<N_WIT, T>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

impl<const N_WIT: usize, T: Zero + Clone> Witness<N_WIT, Vec<T>>

pub fn zero_vec(domain_size: usize) -> Self

pub fn to_pub_columns<const NPUB: usize>(&self) -> Witness<NPUB, Vec<T>>

Trait Implementations

impl<const N_WIT: usize, T: Clone> Clone for Witness<N_WIT, T>

fn clone(&self) -> Witness<N_WIT, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const N_WIT: usize, T: Debug> Debug for Witness<N_WIT, T>

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

Formats the value using the given formatter.

impl<const N_WIT: usize, T: Zero + Clone> Default for Witness<N_WIT, T>

fn default() -> Self

Returns the “default value” for a type.

impl<const N: usize, F: FftField> Foldable<F> for Witness<N, Evaluations<F, Radix2EvaluationDomain<F>>>

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

Combine two objects ‘a’ and ‘b’ into a new object using the challenge.

impl<const N_WIT: usize, G: Send + Debug> FromParallelIterator<G> for Witness<N_WIT, G>

fn from_par_iter<I>(par_iter: I) -> Selfwhere I: IntoParallelIterator<Item = G>,

Creates an instance of the collection from the parallel iterator par_iter.

impl<const N_WIT: usize, T: Hash> Hash for Witness<N_WIT, T>

fn hash<__H: Hasher>(&self, state: &mut __H)

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<const N_WIT: usize, T> Index<usize> for Witness<N_WIT, T>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'lt, const N_WIT: usize, G> IntoIterator for &'lt Witness<N_WIT, G>

type Item = &'lt G

The type of the elements being iterated over.

type IntoIter = IntoIter<&'lt G, Global>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<const N_WIT: usize, F: Clone> IntoIterator for Witness<N_WIT, F>

fn into_iter(self) -> Self::IntoIter

Iterate over the columns in the circuit.

type Item = F

The type of the elements being iterated over.

type IntoIter = IntoIter<F, Global>

Which kind of iterator are we turning this into?

impl<'data, const N_WIT: usize, G> IntoParallelIterator for &'data Witness<N_WIT, G>where Vec<&'data G>: IntoParallelIterator,

type Iter = <Vec<&'data G, Global> as IntoParallelIterator>::Iter

The parallel iterator type that will be created.

type Item = <Vec<&'data G, Global> as IntoParallelIterator>::Item

The type of item that the parallel iterator will produce.

fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.

impl<'data, const N_WIT: usize, G> IntoParallelIterator for &'data mut Witness<N_WIT, G>where Vec<&'data mut G>: IntoParallelIterator,

type Iter = <Vec<&'data mut G, Global> as IntoParallelIterator>::Iter

The parallel iterator type that will be created.

type Item = <Vec<&'data mut G, Global> as IntoParallelIterator>::Item

The type of item that the parallel iterator will produce.

fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.

impl<const N_WIT: usize, G> IntoParallelIterator for Witness<N_WIT, G>where Vec<G>: IntoParallelIterator,

fn into_par_iter(self) -> Self::Iter

Iterate over the columns in the circuit, in parallel.

type Iter = <Vec<G, Global> as IntoParallelIterator>::Iter

The parallel iterator type that will be created.

type Item = <Vec<G, Global> as IntoParallelIterator>::Item

The type of item that the parallel iterator will produce.

impl<const N_WIT: usize, T: PartialEq> PartialEq<Witness<N_WIT, T>> for Witness<N_WIT, T>

fn eq(&self, other: &Witness<N_WIT, T>) -> 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<const N_WIT: usize, T> TryFrom<Vec<T, Global>> for Witness<N_WIT, T>

type Error = String

The type returned in the event of a conversion error.

fn try_from(value: Vec<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const N_WIT: usize, T: Eq> Eq for Witness<N_WIT, T>

impl<const N_WIT: usize, T> StructuralEq for Witness<N_WIT, T>

impl<const N_WIT: usize, T> StructuralPartialEq for Witness<N_WIT, T>

impl<const N: usize, G: CommitmentCurve> Witness<G> for Witness<N, Evaluations<G::ScalarField, Radix2EvaluationDomain<G::ScalarField>>>