Add support for Assert statements.

• https://docs.circom.io/circom-language/code-quality/code-assertion/

Implement unit testing for basic operations.

CircuitError(Inconsistency ...) error when trying to compile Keras2Circom generated circuit

pragma circom 2.0.0;

include "../circuits/Dense.circom";
include "../circuits/Flatten2D.circom";
include "../circuits/ArgMax.circom";

template Model() {
signal input in[2][1][1];
signal input flatten_11_out[2];
signal input dense_23_weights[2][10];
signal input dense_23_bias[10];
signal input dense_23_out[10];
signal input dense_23_softmax_out[1];
signal output out[1];

component flatten_11 = Flatten2D(2, 1, 1);
component dense_23 = Dense(2, 10, 10);
component dense_23_softmax = ArgMax(10);

for (var i0 = 0; i0 < 2; i0++) {
    for (var i1 = 0; i1 < 1; i1++) {
        for (var i2 = 0; i2 < 1; i2++) {
            flatten_11.in[i0][i1][i2] <== in[i0][i1][i2];
}}}
for (var i0 = 0; i0 < 2; i0++) {
    flatten_11.out[i0] <== flatten_11_out[i0];
}
for (var i0 = 0; i0 < 2; i0++) {
    dense_23.in[i0] <== flatten_11.out[i0];
}
for (var i0 = 0; i0 < 2; i0++) {
    for (var i1 = 0; i1 < 10; i1++) {
        dense_23.weights[i0][i1] <== dense_23_weights[i0][i1];
}}
for (var i0 = 0; i0 < 10; i0++) {
    dense_23.bias[i0] <== dense_23_bias[i0];
}
for (var i0 = 0; i0 < 10; i0++) {
    dense_23.out[i0] <== dense_23_out[i0];
}
for (var i0 = 0; i0 < 10; i0++) {
    dense_23_softmax.in[i0] <== dense_23.out[i0];
}
dense_23_softmax.out <== dense_23_softmax_out[0];
out[0] <== dense_23_softmax.out;

}

component main = Model();

We can make a basic optimizer to interpret from general gates (of circom) to machine supported gates, e.g. MP-SPDZ support more gates than mpz.

We should allow all InfixOp being a gate type itself as we aim for more backends.

So far the gates are created independently when a template is executed (as a component).

But these templates have defined input and output signals, which are wired when setting up the component, these connections are currently only stored in each component but are not being part of the actual circuit.

The idea of this issue is to implement this connections.

• Components inputs and outputs should be declared in the AC.
• Circuit signal identifiers should be updated following the wiring maps of the components.

Add support for handling UniformArray expressions, expressions like:

var x[2][3];

will halt the circuit generation and return the ExpressionNotImplemented error.

Implement our version of circomlib in order to support basic functions.

This is needed due to circomlib being done to work with R1CS, not working for execution.

We should add support for the assignment of whole signal arrays. Example:

template fc (width, height) {
    signal input weights[height][width];
    signal output out[height];
}

template network() {
    signal input in;
    signal output out;

    component l0 = fc(3, 5);

    signal input w0[5][3];
    signal input b0[5];

    l0.weights <== w0;
    ...
}

We may have redundant info now so we may want to streamline the output.

Below is Bristol format we can extend it:
https://nigelsmart.github.io/MPC-Circuits/

Eg when running this program:

template network() {
    signal input x;
    signal output y;

    var z = 3;
    z += x; // <----- compound assignment

    y <== z;
}

component main = network();

We get:

Error: RuntimeError(ItemNotDeclared("get_variable_value: DataAccess { name: \"random_3750075181\", access: [] }"))

Compound assignment doesn't need to be implemented for signals, that's handled as an error by circom, eg:

error[T2000]: Typing error found
    ┌─ "./src/assets/circuit.circom":173:5
    │
173 │     y += x;
    │     ^^^^^^ The operator does not match the types of the assigned elements.
 Assignments to signals do not allow the operator =, try using <== or <-- instead

Error: AnalysisError

also by using tag?

I tried to compile the circuit with out of bounds error:

pragma circom 2.1.0;

template circuit() {
   signal arr[10];

   for (var i = 0; i < 100; i++) {
      arr[i] <== 1;
   }
}

component main = circuit();

The compiler doesn't show the error; original Circom does show the out of bounds error, so something wrong with circom-2-arithc

Error is very generic right now it is not super helpful, can we improve the information display upon error?

We have a lot of small integration tests files - it's not good, cause each of them is a different crate, therefore it generates separate binary; each of them is relinked with the library crate separately, etc.

You can read about it here

It's better to create one big integration test crate that'll contain all the tests we have as separate modules

The if and while statements are being executed in the parent context. We should instantiate a new context to isolate possible declarations, execute and then merge back.

Parameterized by the the size of the num (n bits). Basically we replicate the behavior of this: https://github.com/iden3/circomlib/blob/master/circuits/bitify.circom

Add support for multidimensional arrays

Support while loop statement of circom.

On each compilation the circuit output is slightly different. This could be problematic for a backend, or some verification step if you're comparing compiled files. Here's an example:

First run:

4 12
8 1 1 1 1 1 1 1 1
4 1 1 1 1

2 1 2 4 10 AMul
2 1 7 0 9 AMul
2 1 3 5 8 AMul
2 1 6 1 11 AMul

Second run:

4 12
8 1 1 1 1 1 1 1 1
4 1 1 1 1

2 1 2 5 8 AMul
2 1 0 4 9 AMul
2 1 1 7 11 AMul
2 1 3 6 10 AMul

The change is in the input and output signal ids.

At the moment we assume a traditional arithmetic over u32.

Instead we should define a Number trait and allow the user to specify the number system they are using. Additionally we can provide implementations of common number systems.

trait Number {
    fn op(&self, op: Operation, rhs: &Self) -> Self;
    // note: we may want to separate this as prefix_op, infix_op, but that's a separate issue
}

then anything implementing this trait can be used by using it as the constraint on a generic, like this:

fn execute<N: Number>(&self, inputs: &[N]) -> Result<Vec<N>, CircuitError>

Add support for the PrefixOp expression.

• https://docs.circom.io/circom-language/basic-operators/#arithmetic-operators

Target MP-SPDZ as main backend

• https://github.com/data61/MP-SPDZ

The execute_op function is called whenever we need to operate on two integers (not signals). Transforming to our set of gates is limiting us to perform some operations, and is not really needed, we could operate any opcode directly.

/// Executes an operation, performing the specified arithmetic or logical computation.
pub fn execute_op(lhs: &u32, rhs: &u32, op: &ExpressionInfixOpcode) -> u32 {
    match op {
     ...
    }
}

We should support

• Binary
• Fixed-point
• mod p
  but not mixing too many types, we will see.

The current assets directory should be removed and replaced by an examples directory in the project root.

This new dir should contain single file circuit examples for the different supported features.

The compiled ArgMax circuit doesn't work with MP-SPDZ, because of the errors with constants:

/MP-SPDZ ((704049e1)) ~> PLAYERS=2 Scripts/compile-run.py -E semi circuit -M          Wed Jun 26 12:47:40 2024
Default bit length for compilation: 64
Default security parameter for compilation: 40
Compiling file Programs/Source/circuit.mpc
Traceback (most recent call last):
  File "/MP-SPDZ/Scripts/compile-run.py", line 14, in <module>
    prog = compiler.compile_file()
           ^^^^^^^^^^^^^^^^^^^^^^^
  File "/MP-SPDZ/Scripts/../Compiler/compilerLib.py", line 452, in compile_file
    exec(compile(infile.read(), infile.name, "exec"), self.VARS)
  File "Programs/Source/circuit.mpc", line 6, in <module>
    wires[10] = wires[9] - wires[7]
                ~~~~~~~~~^~~~~~~~~~
TypeError: unsupported operand type(s) for -: 'NoneType' and 'sint'

We may face signal ids collisions on large circuits.

We're currently not taking into account arguments and/or public signals list that could be passed into it.

• https://docs.circom.io/circom-language/the-main-component/

Currently constants are being assigned to the same signal. This means that it's not possible to assign the same constant to multiple circuit outputs.

Update README file with the supported features

This doesn't work without doing + 0 for out signal

pragma circom 2.0.0;

// Flatten layer with that accepts a 2D input
template Flatten2D (nRows, nCols, nChannels) {
    signal input in[nRows][nCols][nChannels];
    signal output out[nRows*nCols*nChannels];

    var idx = 0;

    for (var i=0; i<nRows; i++) {
        for (var j=0; j<nCols; j++) {
            for (var k=0; k<nChannels; k++) {
                // TODO: remove a need to create a gate
                out[idx] <== in[i][j][k] + 0;
                idx++;
            }
        }
    }
}

Right now there seems to be a linear scan for adding connections between caller and callee, may be we can:

• measure the current cost to see if it significantly slowdown circuit generation
• and if it does, improve it in someway

Restructure the codebase to reduce redundant code and improve navigation by merging:

• execute_statement
• traverse_statement
• execute_expression
• traverse_expression

Into two functions to handle statements and expressions in a single way.

https://github.com/namnc/circom-2-arithc/blob/main/src/compiler.rs

I tried the circuit:

pragma circom 2.1.0;

template temp() {
    signal input a;
    signal output out;

    signal intermediate <== 0;
}

component main = temp();

It finishes with error:

thread 'main' panicked at src/compiler.rs:520:51:
no entry found for key
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

This issue is related to the Project Usability item in the project overview.

To improve usability we need to create our own CLI argument parsing and remove the existent one in the circom directory. This one has been built around regular circom usage and needs to be removed, along with any configuration we're not using or planning to.

A project configuration struct has to be made, starting from:

struct CompilerConfig {
    /// Circuit input file.
    input: String,
    /// Circuit and report output paths.
    output: String,
}

This will be helpful when using our project as an executable from a command line interface, but can also serve as inspiration if the project is used as a library.

This will also allow us to update the clap dependency.

Tasks

• Removal of all code in the circom directory related to CLI arguments parsing or project configuration.
• Implementation of our own CLI, with a compile command.
• Implementation of a new CompilerConfig struct that holds all necessary optional data related to project compilation. Keep in mind this would only be related to the compile command on the CLI.
• Update clap dependency.

binary(k)
int(2^k)
uint(2^k)
quantized(2^k,sf)
ring(mod M)
field(mod P)

So that we can evaluate the circuit given the inputs.

This is needed to implement black box testing.