Struct CircuitSimulator

pub struct CircuitSimulator {
    solvable_witnesses: HashSet<Witness>,
    initialized_blocks: HashSet<BlockId>,
}

Simulate solving a circuit symbolically Instead of evaluating witness values from the inputs, like the PWG module is doing, this pass simply marks the witness that can be evaluated, from the known inputs, and incrementally from the previously marked witnesses. This avoids any computation on a big field which makes the process efficient. When all the witness of an opcode are marked as solvable, it means that the opcode is solvable.

Fields

solvable_witnesses: HashSet<Witness>

Track the witnesses that can be solved

initialized_blocks: HashSet<BlockId>

Track whether a [BlockId] has been initialized

Implementations

impl CircuitSimulator

pub fn check_circuit<F: AcirField>(circuit: &Circuit<F>) -> Option<usize>

Check whether the circuit is solvable in theory.

Returns

Returns None if the circuit is deemed to be solvable Otherwise returns Some(index) where index is the opcode index of the first unsolvable opcode.

fn run_check_circuit<F: AcirField>( &mut self, circuit: &Circuit<F>, ) -> Option<usize>

Simulate solving a circuit symbolically by keeping track of the witnesses that can be solved. Returns the index of an opcode that cannot be solved, if any.

fn try_solve<F: AcirField>(&mut self, opcode: &Opcode<F>) -> bool

Check if the Opcode can be solved, and if yes, add the solved witness to set of solvable witness

pub(crate) fn mark_solvable(&mut self, witness: Witness)

Adds the witness to set of solvable witness

pub fn can_solve_function_input<F: AcirField>( &self, input: &FunctionInput<F>, ) -> bool

fn can_solve_expression<F>(&self, expr: &Expression<F>) -> bool

fn can_solve_brillig_input<F>(&self, input: &BrilligInputs<F>) -> bool

pub(crate) fn expr_witness<F>( expr: &Expression<F>, ) -> impl Iterator<Item = Witness>

Trait Implementations

impl Default for CircuitSimulator

fn default() -> CircuitSimulator

Returns the “default value” for a type.