feat: component signal connections (#25)

src/assets/Dense.circom

@@ -0,0 +1,28 @@
+pragma circom 2.0.0;
+
+include "./matMul.circom";
+// Dense layer
+// n = 10 to the power of the number of decimal places
+template Dense (nInputs, nOutputs, n) {
+    signal input in[nInputs];
+    signal input weights[nInputs][nOutputs];
+    signal input bias[nOutputs];
+    signal output out[nOutputs];
+    //signal input remainder[nOutputs];
+
+    component dot[nOutputs];
+
+    for (var i=0; i<nOutputs; i++) {
+        //assert (remainder[i] < n);
+        dot[i] = matMul(1,nInputs,1);
+
+        for (var j=0; j<nInputs; j++) {
+            dot[i].a[0][j] <== in[j];
+            dot[i].b[j][0] <== weights[j][i];
+        }
+
+        out[i] <== dot[i].out[0][0] + bias[i];
+    }
+}
+// component main = Dense(20,10,10**36);
+component main = Dense(4,2,10**2);

src/assets/circuit.circom

@@ -1,17 +1,37 @@
 pragma circom 2.0.0;
 
-include "lib.circom";
+template Wire(){
+   signal input input_signal;
+   signal output output_signal;
+   output_signal <== input_signal;
+}
 
-template InnerProd () {  
+template MainComponent () {  
    signal input input_A;  
    signal input input_B;  
    signal output ip;
 
    var variable_A;
+   var variable_B;
 
    variable_A = 100;
+   variable_B = is_positive(variable_A);
+
+   component wire_component;
+   wire_component = Wire();
+
+   wire_component.input_signal <== input_A + input_B;
+
+   while (variable_A > 10) {
+      variable_A = variable_A - 1;
+   }
+
+   ip <== input_A + input_B + variable_A + variable_B + wire_component.output_signal;
+}
 
-   ip <== input_A + input_B + variable_A;
+function is_positive(n){
+   if(n > 0){ return 50;}
+   else{ return 0;}
 }
 
-component main = InnerProd();
+component main = MainComponent();

src/assets/matElemMul.circom

@@ -0,0 +1,14 @@
+pragma circom 2.0.0;
+
+// matrix multiplication by element
+template matElemMul (m,n) {
+    signal input a[m][n];
+    signal input b[m][n];
+    signal output out[m][n];
+
+    for (var i=0; i < m; i++) {
+        for (var j=0; j < n; j++) {
+            out[i][j] <== a[i][j] * b[i][j];
+        }
+    }
+}

src/assets/matElemSum.circom

@@ -0,0 +1,22 @@
+pragma circom 2.0.0;
+
+// sum of all elements in a matrix
+template matElemSum (m,n) {
+    signal input a[m][n];
+    signal output out;
+
+    signal sum[m*n];
+    sum[0] <== a[0][0];
+    var idx = 0;
+
+    for (var i=0; i < m; i++) {
+        for (var j=0; j < n; j++) {
+            if (idx > 0) {
+                sum[idx] <== sum[idx-1] + a[i][j];
+            }
+            idx++;
+        }
+    }
+
+    out <== sum[m*n-1];
+}

src/assets/matMul.circom

@@ -0,0 +1,29 @@
+pragma circom 2.0.0;
+
+include "matElemMul.circom";
+include "matElemSum.circom";
+
+// matrix multiplication
+template matMul (m,n,p) {
+    signal input a[m][n];
+    signal input b[n][p];
+    signal output out[m][p];
+
+    component matElemMulComp[m][p];
+    component matElemSumComp[m][p];
+
+    for (var i=0; i < m; i++) {
+        for (var j=0; j < p; j++) {
+            matElemMulComp[i][j] = matElemMul(1,n);
+            matElemSumComp[i][j] = matElemSum(1,n);
+            for (var k=0; k < n; k++) {      
+                matElemMulComp[i][j].a[0][k] <== a[i][k];
+                matElemMulComp[i][j].b[0][k] <== b[k][j];
+            }
+            for (var k=0; k < n; k++) {
+                matElemSumComp[i][j].a[0][k] <== matElemMulComp[i][j].out[0][k];
+            }
+            out[i][j] <== matElemSumComp[i][j].out;
+        }
+    }
+}