Merge pull request #8 from distributed-lab/feat/circom-2.1.9

circom 2.1.9

Author: Arvolear

Cargo.lock

@@ -1,5 +1,18 @@
 # Release notes
+## April 23, 2024 circom 2.1.9
 
+#### Extensions 
+- Improvement of error messages: providing more descriptive messages.
+- Improvement of documentation and new sections: detailed explanation of the applied simplification techniques and precise description of constraint-related output formats.
+- Allowing arbitrary number of different input names in the main component.
+
+#### Fixed bugs
+- Removing non-determinism in R1CS generation: fixing assignment order of anonymous components inputs.
+- Fixing an error when computing array accesses involving complex expressions in multidimensional arrays.
+- Improving known/unknown analysis: arrays of vars combining known/unknown positions.
+- Fixing minor panics: main component not calling to a template, anonymous component with wrong number of arguments, log messages containing line breaks.
+
+  
 ## Jan 17, 2024 circom 2.1.8
 
 #### Extensions

RELEASES.md

@@ -1,6 +1,6 @@
 [package]
 name = "circom"
-version = "2.1.8"
+version = "2.1.9"
 authors = ["Costa Group UCM","iden3"]
 edition = "2018"
 

circom/Cargo.toml

@@ -554,13 +554,13 @@ impl<C: Default + Clone + Display + Hash + Eq> ArithmeticExpression<C> {
     }
 
     // Bit operations
-    pub fn complement_256(
+    pub fn complement_254(
         elem: &ArithmeticExpression<C>,
         field: &BigInt,
     ) -> ArithmeticExpression<C> {
         use ArithmeticExpression::*;
         if let Number { value } = elem {
-            Number { value: modular_arithmetic::complement_256(value, field) }
+            Number { value: modular_arithmetic::complement_254(value, field) }
         } else {
             NonQuadratic
         }

circom_algebra/src/algebra.rs

@@ -92,13 +92,13 @@ pub fn multi_inv(values: &Vec<BigInt>, field: &BigInt) -> Vec<BigInt>{
 
 //Bit operations
 
-// 256 bit complement
-pub fn complement_256(elem: &BigInt, field: &BigInt) -> BigInt {
+// 254 bit complement
+pub fn complement_254(elem: &BigInt, field: &BigInt) -> BigInt {
     let (sign, mut bit_repr) = bit_representation(elem);
-    while bit_repr.len() > 256 {
+    while bit_repr.len() > 254 {
         bit_repr.pop();
     }
-    for _i in bit_repr.len()..256 {
+    for _i in bit_repr.len()..254 {
         bit_repr.push(0);
     }
     for bit in &mut bit_repr {
@@ -252,8 +252,8 @@ mod tests {
             .expect("generating the big int was not possible");
         let big_num = BigInt::parse_bytes("1234".as_bytes(), 10)
             .expect("generating the big int was not possible");
-        let big_num_complement = complement_256(&big_num, &field);
-        let big_num_complement_complement = complement_256(&big_num_complement, &field);
+        let big_num_complement = complement_254(&big_num, &field);
+        let big_num_complement_complement = complement_254(&big_num_complement, &field);
         let big_num_modulus = modulus(&big_num, &field);
         assert_eq!(big_num_complement_complement, big_num_modulus);
     }

circom_algebra/src/modular_arithmetic.rs

@@ -1,6 +1,6 @@
 [package]
 name = "code_producers"
-version = "2.1.8"
+version = "2.1.9"
 authors = ["Costa Group UCM","iden3"]
 edition = "2018"
 

code_producers/Cargo.toml

@@ -22,8 +22,8 @@ const S_IO_DEF: &str = "IODef";
 const IO_DEF_FIELDS: [&str; 2] = ["offset", "lengths"];
 
 // Global variables
-pub const SIZE_INPUT_HASHMAP: usize = 256;
-const G_INPUT_HASHMAP: &str = "inputHashMap"; // type HashSignalInfo[256]
+//pub const SIZE_INPUT_HASHMAP: usize = 256;
+const G_INPUT_HASHMAP: &str = "inputHashMap"; // type HashSignalInfo[max(256,needed)]
 const G_RM_INPUT_SIGNAL_COUNTER: &str = "remainingInputSignalCounter"; // type u32
 const G_INPUT_SIGNAL_SET: &str = "inputSignalSetMap"; // type bool[M]
 const G_WITNESS_TO_SIGNAL: &str = "witness2signalList"; // type u64[W]
@@ -469,15 +469,14 @@ pub fn collect_function_headers(functions: Vec<String>) -> Vec<String> {
 
 //--------------- generate all kinds of Data for the .dat file ---------------
 
-pub fn generate_hash_map(signal_name_list: &Vec<(String, usize, usize)>) -> Vec<(u64, u64, u64)> {
-    assert!(signal_name_list.len() <= 256);
-    let len = 256;
-    let mut hash_map = vec![(0, 0, 0); len];
+pub fn generate_hash_map(signal_name_list: &Vec<(String, usize, usize)>, size: usize) -> Vec<(u64, u64, u64)> {
+    assert!(signal_name_list.len() <= size);
+    let mut hash_map = vec![(0, 0, 0); size];
     for i in 0..signal_name_list.len() {
         let h = hasher(&signal_name_list[i].0);
-        let mut p = (h % 256) as usize;
+        let mut p = h as usize % size;
         while hash_map[p].1 != 0 {
-            p = (p + 1) % 256;
+            p = (p + 1) % size;
         }
         hash_map[p] = (h, signal_name_list[i].1 as u64, signal_name_list[i].2 as u64);
     }
@@ -653,9 +652,9 @@ pub fn generate_dat_file(dat_file: &mut dyn Write, producer: &CProducer) -> std:
     //dfile.flush()?;
 
     let aux = producer.get_main_input_list();
-    let map = generate_hash_map(&aux);
+    let map = generate_hash_map(&aux,producer.get_input_hash_map_entry_size());
     let hashmap = generate_dat_from_hash_map(&map); //bytes u64 --> u64
-                                                    //let hml = 256 as u32;
+                                                    //let hml = producer.get_input_hash_map_entry_size() as u32;
                                                     //dfile.write_all(&hml.to_be_bytes())?;
     dat_file.write_all(&hashmap)?;
     //dat_file.flush()?;
@@ -946,7 +945,7 @@ pub fn generate_c_file(name: String, producer: &CProducer) -> std::io::Result<()
     let full_name = name + ".cpp";
     let mut cfile = File::create(full_name)?;
     let mut code = vec![];
-    let len = 256;
+    let len = producer.get_input_hash_map_entry_size();
     code.push("#include <stdio.h>".to_string());
     code.push("#include <iostream>".to_string());
     code.push("#include <assert.h>".to_string());

code_producers/src/c_elements/c_code_generator.rs

@@ -52,10 +52,10 @@ uint Circom_CalcWit::getInputSignalHashPosition(u64 h) {
   uint pos = (uint)(h % (u64)n);
   if (circuit->InputHashMap[pos].hash!=h){
     uint inipos = pos;
-    pos++;
+    pos = (pos+1)%n; 
     while (pos != inipos) {
-      if (circuit->InputHashMap[pos].hash==h) return pos;
-      if (circuit->InputHashMap[pos].hash==0) {
+      if (circuit->InputHashMap[pos].hash == h) return pos;
+      if (circuit->InputHashMap[pos].signalid == 0) {
 	fprintf(stderr, "Signal not found\n");
 	assert(false);
       }

code_producers/src/c_elements/common/calcwit.cpp

@@ -134,6 +134,9 @@ impl CProducer {
     pub fn get_main_input_list(&self) -> &InputList {
         &self.main_input_list
     }
+    pub fn get_input_hash_map_entry_size(&self) -> usize {
+        std::cmp::max(usize::pow(2,(self.main_input_list.len() as f32).log2().ceil() as u32),256)
+    }    
     pub fn get_number_of_witness(&self) -> usize {
         self.signals_in_witness
     }

code_producers/src/c_elements/mod.rs

@@ -179,6 +179,9 @@ impl WASMProducer {
     pub fn get_main_input_list(&self) -> &InputList {
         &self.main_input_list
     }
+    pub fn get_input_hash_map_entry_size(&self) -> usize {
+        std::cmp::max(usize::pow(2,(self.main_input_list.len() as f32).log2().ceil() as u32),256)
+    }
     pub fn get_number_of_witness(&self) -> usize {
         self.signals_in_witness
     }
@@ -261,7 +264,7 @@ impl WASMProducer {
         (4 * self.size_32_bit) + 8 + self.get_shared_rw_memory_start()
     }
     pub fn get_remaining_input_signal_counter(&self) -> usize {
-        self.get_input_signals_hashmap_start() + 4096 // 256*(8(h)+4(pos)+4(size))
+        self.get_input_signals_hashmap_start() + self.get_input_hash_map_entry_size()*16 // input_hash_map_entry_size*(8(h)+4(pos)+4(size))
     }
     pub fn get_input_signal_set_map_start(&self) -> usize {
         self.get_remaining_input_signal_counter() + 4

code_producers/src/wasm_elements/mod.rs

@@ -226,15 +226,14 @@ pub fn get_initial_size_of_memory(producer: &WASMProducer) -> usize {
 
 //------------------- generate all kinds of Data ------------------
 
-pub fn generate_hash_map(signal_name_list: &Vec<(String, usize, usize)>) -> Vec<(u64, usize, usize)> {
-    assert!(signal_name_list.len() <= 256);
-    let len = 256;
-    let mut hash_map = vec![(0, 0, 0); len];
+pub fn generate_hash_map(signal_name_list: &Vec<(String, usize, usize)>, size: usize) -> Vec<(u64, usize, usize)> {
+    assert!(signal_name_list.len() <= size);
+    let mut hash_map = vec![(0, 0, 0); size];
     for i in 0..signal_name_list.len() {
         let h = hasher(&signal_name_list[i].0);
-        let mut p = (h % 256) as usize;
+        let mut p = h as usize %  size;
         while hash_map[p].1 != 0 {
-            p = (p + 1) % 256;
+            p = (p + 1) % size;
         }
         hash_map[p] = (h, signal_name_list[i].1, signal_name_list[i].2);
     }
@@ -567,7 +566,7 @@ pub fn generate_data_list(producer: &WASMProducer) -> Vec<WasmInstruction> {
         producer.get_shared_rw_memory_start() - 8,
         "\\00\\00\\00\\00\\00\\00\\00\\80"
     ));
-    let map = generate_hash_map(&producer.get_main_input_list());
+    let map = generate_hash_map(&producer.get_main_input_list(),producer.get_input_hash_map_entry_size());
     wdata.push(format!(
         "(data (i32.const {}) \"{}\")",
         producer.get_input_signals_hashmap_start(),
@@ -852,6 +851,7 @@ pub fn init_generator(producer: &WASMProducer) -> Vec<WasmInstruction> {
 pub fn get_input_signal_map_position_generator(producer: &WASMProducer) -> Vec<WasmInstruction> {
     let mut instructions = vec![];
     let header = "(func $getInputSignalMapPosition (type $_t_i64ri32)".to_string();
+    let sizeones = producer.get_input_hash_map_entry_size()-1;
     instructions.push(header);
     instructions.push(" (param $hn i64)".to_string());
     instructions.push("(result i32)".to_string());
@@ -860,7 +860,7 @@ pub fn get_input_signal_map_position_generator(producer: &WASMProducer) -> Vec<W
     instructions.push(" (local $aux i32)".to_string());
     instructions.push(get_local("$hn"));
     instructions.push(wrap_i6432());
-    instructions.push(set_constant("255"));
+    instructions.push(set_constant(&sizeones.to_string()));
     instructions.push(and32());
     instructions.push(set_local("$ini"));
     instructions.push(get_local("$ini"));
@@ -891,7 +891,7 @@ pub fn get_input_signal_map_position_generator(producer: &WASMProducer) -> Vec<W
     instructions.push(get_local("$i"));
     instructions.push(set_constant("1"));
     instructions.push(add32());
-    instructions.push(set_constant("255"));
+    instructions.push(set_constant(&sizeones.to_string()));
     instructions.push(and32());
     instructions.push(set_local("$i"));
     instructions.push(get_local("$i"));

code_producers/src/wasm_elements/wasm_code_generator.rs

@@ -1,6 +1,6 @@
 [package]
 name = "compiler"
-version = "2.1.8"
+version = "2.1.9"
 authors = ["Costa Group UCM","iden3"]
 edition = "2018"
 

compiler/Cargo.toml

@@ -346,7 +346,8 @@ impl WriteC for Circuit {
             "uint get_number_of_components() {{return {};}}\n",
             producer.get_number_of_components()
         ));
-        code.push(format!("uint get_size_of_input_hashmap() {{return {};}}\n", SIZE_INPUT_HASHMAP));
+        //code.push(format!("uint get_size_of_input_hashmap() {{return {};}}\n", SIZE_INPUT_HASHMAP));
+        code.push(format!("uint get_size_of_input_hashmap() {{return {};}}\n", producer.get_input_hash_map_entry_size()));
         code.push(format!(
             "uint get_size_of_witness() {{return {};}}\n",
             producer.get_witness_to_signal_list().len()
@@ -464,7 +465,8 @@ impl WriteC for Circuit {
             "uint get_number_of_components() {{return {};}}\n",
             producer.get_number_of_components()
         ));
-        code.push(format!("uint get_size_of_input_hashmap() {{return {};}}\n", SIZE_INPUT_HASHMAP));
+        //code.push(format!("uint get_size_of_input_hashmap() {{return {};}}\n", SIZE_INPUT_HASHMAP));
+        code.push(format!("uint get_size_of_input_hashmap() {{return {};}}\n", producer.get_input_hash_map_entry_size()));
         code.push(format!(
             "uint get_size_of_witness() {{return {};}}\n",
             producer.get_witness_to_signal_list().len()

compiler/src/circuit_design/circuit.rs

@@ -232,7 +232,7 @@ impl WriteC for CreateCmpBucket {
             }
         }
         // generate array with the positions that are actually created if there are empty components
-        // if not only traverse the defined positions, but i gets the value of the indexed accesed position
+        // if not only traverse the defined positions, but i gets the value of the indexed accessed position
         else{
             instructions.push(format!("uint aux_positions [{}]= {};", self.defined_positions.len(), set_list(self.defined_positions.iter().map(|(x, _y)| *x).collect())));
             instructions.push(format!("for (uint i_aux = 0; i_aux < {}; i_aux++) {{",  self.defined_positions.len()));
@@ -302,4 +302,4 @@ impl WriteC for CreateCmpBucket {
         instructions.push("}".to_string());
         (instructions, "".to_string())
     }
-}
+}

compiler/src/intermediate_representation/create_component_bucket.rs

@@ -15,4 +15,4 @@ mod value_bucket;
 
 pub mod ir_interface;
 pub mod translate;
-pub use ir_interface::{Instruction, InstructionList, InstructionPointer};
+pub use ir_interface::InstructionList;