Struct R1CSShape 

pub struct R1CSShape<E: Engine> { /* private fields */ }

A type that holds the shape of the R1CS matrices

Implementations

impl<E: Engine> R1CSShape<E>

pub fn num_cons(&self) -> usize

Returns the number of constraints in the R1CS shape.

This is useful for computing the number of rounds in sumcheck.

pub fn num_vars(&self) -> usize

Returns the number of variables in the R1CS shape.

This is useful for computing the number of rounds in sumcheck.

pub fn num_io(&self) -> usize

Returns the number of public inputs/outputs in the R1CS shape.

This is useful for dimension validation.

pub fn A(&self) -> &SparseMatrix<E::Scalar>

Returns a reference to the A matrix of the R1CS shape.

pub fn B(&self) -> &SparseMatrix<E::Scalar>

Returns a reference to the B matrix of the R1CS shape.

pub fn C(&self) -> &SparseMatrix<E::Scalar>

Returns a reference to the C matrix of the R1CS shape.

pub fn new( num_cons: usize, num_vars: usize, num_io: usize, A: SparseMatrix<E::Scalar>, B: SparseMatrix<E::Scalar>, C: SparseMatrix<E::Scalar>, ) -> Result<R1CSShape<E>, NovaError>

Create an object of type R1CSShape from the explicitly specified R1CS matrices

pub fn commitment_key( shapes: &[&R1CSShape<E>], ck_floors: &[&CommitmentKeyHint<E>], ) -> Result<<<E as Engine>::CE as CommitmentEngineTrait<E>>::CommitmentKey, NovaError>

Generates public parameters for a Rank-1 Constraint System (R1CS).

This function takes into consideration the shape of the R1CS matrices and a hint function for the number of generators. It returns a CommitmentKey.

Arguments

• shapes: A slice of references to R1CS shapes.
• ck_floors: A slice of functions that provide a floor for the number of generators. A good function to provide is the ck_floor field defined in the trait RelaxedR1CSSNARKTrait.

Panics

Panics if shapes is empty or if shapes and ck_floors have different lengths.

Errors

Returns an error if the underlying commitment engine’s setup fails (e.g., HyperKZG in production builds without the test-utils feature).

pub fn commitment_key_from_ptau_dir( shapes: &[&R1CSShape<E>], ck_floors: &[&CommitmentKeyHint<E>], ptau_dir: &Path, ) -> Result<<<E as Engine>::CE as CommitmentEngineTrait<E>>::CommitmentKey, NovaError>

where E::GE: PairingGroup,

Generates public parameters for a Rank-1 Constraint System (R1CS) from a ptau directory.

This function is similar to commitment_key but loads the commitment key from a Powers of Tau ceremony file instead of generating it randomly. This is useful for production deployments using trusted setup ceremonies like the Ethereum PPOT.

Note: This method is only available for engines with pairing-friendly curves (e.g., BN256 with HyperKZG or Mercury). For non-pairing curves (e.g., Grumpkin with Pedersen commitments), use the standard commitment_key method.

The function automatically selects the appropriate ptau file from the directory based on the required number of generators. Files should be named ppot_pruned_{power}.ptau.

Arguments

• shapes: A slice of references to R1CS shapes.
• ck_floors: A slice of functions that provide a floor for the number of generators.
• ptau_dir: Path to the directory containing pruned ptau files.

Returns

A CommitmentKey loaded from the appropriate ptau file.

pub fn digest(&self) -> E::Scalar

Returns the digest of the R1CSShape

pub fn multiply_vec( &self, z: &[E::Scalar], ) -> Result<(Vec<E::Scalar>, Vec<E::Scalar>, Vec<E::Scalar>), NovaError>

Multiplies the R1CS matrices A, B, C by a vector z and returns (Az, Bz, Cz).

pub fn is_sat_relaxed( &self, ck: &<<E as Engine>::CE as CommitmentEngineTrait<E>>::CommitmentKey, U: &RelaxedR1CSInstance<E>, W: &RelaxedR1CSWitness<E>, ) -> Result<(), NovaError>

Checks if the Relaxed R1CS instance is satisfiable given a witness and its shape

pub fn is_sat( &self, ck: &<<E as Engine>::CE as CommitmentEngineTrait<E>>::CommitmentKey, U: &R1CSInstance<E>, W: &R1CSWitness<E>, ) -> Result<(), NovaError>

Checks if the R1CS instance is satisfiable given a witness and its shape

pub fn commit_T( &self, ck: &<<E as Engine>::CE as CommitmentEngineTrait<E>>::CommitmentKey, U1: &RelaxedR1CSInstance<E>, W1: &RelaxedR1CSWitness<E>, U2: &R1CSInstance<E>, W2: &R1CSWitness<E>, r_T: &E::Scalar, ) -> Result<(Vec<E::Scalar>, <<E as Engine>::CE as CommitmentEngineTrait<E>>::Commitment), NovaError>

A method to compute a commitment to the cross-term T given a Relaxed R1CS instance-witness pair and an R1CS instance-witness pair

pub fn commit_T_relaxed( &self, ck: &<<E as Engine>::CE as CommitmentEngineTrait<E>>::CommitmentKey, U1: &RelaxedR1CSInstance<E>, W1: &RelaxedR1CSWitness<E>, U2: &RelaxedR1CSInstance<E>, W2: &RelaxedR1CSWitness<E>, r_T: &E::Scalar, ) -> Result<(Vec<E::Scalar>, <<E as Engine>::CE as CommitmentEngineTrait<E>>::Commitment), NovaError>

A method to compute a commitment to the cross-term T given two Relaxed R1CS instance-witness pairs

pub fn pad(&self) -> Self

Pads the R1CSShape so that the shape passes is_regular_shape Renumbers variables to accommodate padded variables

pub fn sample_random_instance_witness( &self, ck: &<<E as Engine>::CE as CommitmentEngineTrait<E>>::CommitmentKey, ) -> Result<(RelaxedR1CSInstance<E>, RelaxedR1CSWitness<E>), NovaError>

Samples a new random RelaxedR1CSInstance/RelaxedR1CSWitness pair

Trait Implementations

impl<E: Clone + Engine> Clone for R1CSShape<E>

where E::Scalar: Clone,

fn clone(&self) -> R1CSShape<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug + Engine> Debug for R1CSShape<E>

where E::Scalar: Debug,

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

Formats the value using the given formatter.

impl<'de, E: Engine> Deserialize<'de> for R1CSShape<E>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<E: PartialEq + Engine> PartialEq for R1CSShape<E>

where E::Scalar: PartialEq,

fn eq(&self, other: &R1CSShape<E>) -> 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<E: Engine> Serialize for R1CSShape<E>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<E: Eq + Engine> Eq for R1CSShape<E>

where E::Scalar: Eq,

impl<E: Engine> SimpleDigestible for R1CSShape<E>

impl<E: Engine> StructuralPartialEq for R1CSShape<E>