Struct Circuit

pub struct Circuit<F: AcirField> {
    pub current_witness_index: u32,
    pub opcodes: Vec<Opcode<F>>,
    pub expression_width: ExpressionWidth,
    pub private_parameters: BTreeSet<Witness>,
    pub public_parameters: PublicInputs,
    pub return_values: PublicInputs,
    pub assert_messages: Vec<(OpcodeLocation, AssertionPayload<F>)>,
}

Representation of a single ACIR circuit. The execution trace of this structure is dictated by the construction of a crate::native_types::WitnessMap

Fields

current_witness_index: u32

current_witness_index is the highest witness index in the circuit. The next witness to be added to this circuit will take on this value. (The value is cached here as an optimization.)

opcodes: Vec<Opcode<F>>

The circuit opcodes representing the relationship between witness values.

The opcodes should be further converted into a backend-specific circuit representation. When initial witness inputs are provided, these opcodes can also be used for generating an execution trace.

expression_width: ExpressionWidth

Maximum width of the expression’s which will be constrained

private_parameters: BTreeSet<Witness>

The set of private inputs to the circuit.

public_parameters: PublicInputs

The set of public inputs provided by the prover.

return_values: PublicInputs

The set of public inputs calculated within the circuit.

assert_messages: Vec<(OpcodeLocation, AssertionPayload<F>)>

Maps opcode locations to failed assertion payloads. The data in the payload is embedded in the circuit to provide useful feedback to users when a constraint in the circuit is not satisfied.

Implementations

impl<F: AcirField> Circuit<F>

pub fn num_vars(&self) -> u32

pub fn circuit_arguments(&self) -> BTreeSet<Witness>

Returns all witnesses which are required to execute the circuit successfully.

pub fn public_inputs(&self) -> PublicInputs

Returns all public inputs. This includes those provided as parameters to the circuit and those computed as return values.

Trait Implementations

impl<F: Clone + AcirField> Clone for Circuit<F>

fn clone(&self) -> Circuit<F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: AcirField> Debug for Circuit<F>

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

Formats the value using the given formatter.

impl<F: Default + AcirField> Default for Circuit<F>

fn default() -> Circuit<F>

Returns the “default value” for a type.

impl<'de, F> Deserialize<'de> for Circuit<F>

where F: Deserialize<'de> + AcirField,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F: AcirField> Display for Circuit<F>

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

Formats the value using the given formatter.

impl<F: Hash + AcirField> Hash for Circuit<F>

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<F: PartialEq + AcirField> PartialEq for Circuit<F>

fn eq(&self, other: &Circuit<F>) -> 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<F: AcirField> ProtoCodec<Circuit<F>, Circuit> for ProtoSchema<F>

fn encode(value: &Circuit<F>) -> Circuit

Convert domain type T to protobuf representation R.

fn decode(value: &Circuit) -> Result<Circuit<F>>

Try to convert protobuf representation R to domain type T.

fn encode_some(value: &T) -> Option<R>

Encode a field as Some.

fn encode_vec<'a, I>(values: I) -> Vec<R>

where I: IntoIterator<Item = &'a T>, T: 'a,

Encode multiple values as a vector.

fn decode_wrap(value: &R, msg: &'static str) -> Result<T, Report>

Decode a field and attach the name of the field if it fails.

fn decode_vec(values: &[R]) -> Result<Vec<T>, Report>

Decode multiple values into a vector.

fn decode_vec_wrap(values: &[R], msg: &'static str) -> Result<Vec<T>, Report>

Decode multiple values into a vector, attaching a field name to any errors.

fn decode_arr<const N: usize>(values: &[R]) -> Result<[T; N], Report>

Decode a fixed size array.

fn decode_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<[T; N], Report>

Decode a fixed size array, attaching a field name to any errors

fn decode_box_arr<const N: usize>(values: &[R]) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array.

fn decode_box_arr_wrap<const N: usize>( values: &[R], msg: &'static str, ) -> Result<Box<[T; N]>, Report>

Decode a boxed fixed size array, attaching a field name to any errors

fn decode_some(value: &Option<R>) -> Result<T, Report>

Decode an optional field as a required one; fails if it’s None.

fn decode_some_wrap(value: &Option<R>, msg: &'static str) -> Result<T, Report>

Decode an optional field as a required one, attaching a field name to any errors. Returns error if the field is missing.

fn decode_opt_wrap( value: &Option<R>, msg: &'static str, ) -> Result<Option<T>, Report>

Decode an optional field, attaching a field name to any errors. Return None if the field is missing.

fn serialize_to_vec(value: &T) -> Vec<u8>

where R: Message,

Encode a domain type to protobuf and serialize it to bytes.

fn deserialize_from_slice(buf: &[u8]) -> Result<T, Report>

where R: Message + Default,

Deserialize a buffer into protobuf and then decode into the domain type.

impl<F> Serialize for Circuit<F>

where F: Serialize + AcirField,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<F: Eq + AcirField> Eq for Circuit<F>

impl<F: AcirField> StructuralPartialEq for Circuit<F>