mimc random changes

Cargo.toml

@@ -72,3 +72,7 @@ path = "src/bin/zkvm.rs"
 name = "dfi"
 path = "src/bin/dfi.rs"
 
+[[bin]]
+name = "mimc"
+path = "src/old/mimc.rs"
+

lisp/examples/macro-test.lisp

@@ -209,7 +209,6 @@
     (def! val (last (last (zk-double u v))))
     (def! acc 0)
     (dotimes (count result) (                    
-        (def! acc (i+ acc 1))        
         (def! u3 (get val "u3"))
         (def! v3 (get val "v3"))            
         (def! r (nth result acc))        
@@ -226,13 +225,14 @@
         (println 'cond cond-result)
         (println 'add add-result)
         (println 'double acc val)        
+        (def! acc (i+ acc 1))        
     ))
     (println 'out val)
 )))
 
 (load-file "mimc-constants.lisp")
 (defmacro! mimc-macro (fn* [xr xl acc] (
-    (let* [tmp-xl (gensym) xl-new-value (gensym) cur-mimc-const (gensym)] (
+    (let* [tmp-xl (gensym2 'tmp_xl) xl-new-value (gensym2 'xl_new_value) cur-mimc-const (gensym2 'cur_mimc_const)] (
     `(def! ~cur-mimc-const (alloc-const ~cur-mimc-const (nth mimc-constants ~acc)))
     `(def! ~tmp-xl (alloc ~tmp-xl (square (+ ~cur-mimc-const ~xl))))        
     `(enforce 
@@ -249,26 +249,39 @@
         ((scalar::one xl) (~cur-mimc-const cs::one))            
         ((scalar::one ~xl-new-value) (scalar::one::neg xr))            
     )
-)))))
+    { "left" xl-new-value }    
+    )    
+))))
+
 (def! mimc (fn* [left right] (
     (def! xl (alloc "xl" left))
     (def! xr (alloc "xr" right))
     (def! acc 0)
     (dotimes 322 (
-        (println acc)
-        (println (mimc-macro xl xr acc))
+        ;; (println acc xr xl)
+        (def! result (mimc-macro xl xr acc))
+        (println '-----)
+        (println acc 'print-for-amir result)
+        (println '-----)
+        (def! xl (get (last (last result)) "left"))
         (def! acc (i+ acc 1))        
     ))
 )))
 
-(def! param3 (rnd-scalar))
+;; (def! param3 (rnd-scalar))
 ;; (println 'rnd-scalar param3)
-(def! param-u (scalar "6800f4fa0f001cfc7ff6826ad58004b4d1d8da41af03744e3bce3b7793664337"))
-(def! param-v (scalar "6d81d3a9cb45dedbe6fb2a6e1e22ab50ad46f1b0473b803b3caefab9380b6a8b"))
+;; (def! param-u (scalar "6800f4fa0f001cfc7ff6826ad58004b4d1d8da41af03744e3bce3b7793664337"))
+;; (def! param-v (scalar "6d81d3a9cb45dedbe6fb2a6e1e22ab50ad46f1b0473b803b3caefab9380b6a8b"))
+;; (jj-mul param-u param-v param3)
+(def! left (scalar "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e"))
+(def! right (scalar "015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891"))
 (prove 
-  (
+  (    
+    (mimc left right)
+    ;; (def! param3 (rnd-scalar))
+    ;; (def! param-u (scalar "6800f4fa0f001cfc7ff6826ad58004b4d1d8da41af03744e3bce3b7793664337"))
+    ;; (def! param-v (scalar "6d81d3a9cb45dedbe6fb2a6e1e22ab50ad46f1b0473b803b3caefab9380b6a8b"))
     ;; (jj-mul param-u param-v param3)
-    (mimc param-u param-v)
   )
 )
 

lisp/examples/util.lisp

@@ -2,9 +2,13 @@
 (def! gensym
   (let* [counter (atom 0)]
     (fn* []
-      ;; (symbol (str "G__" (genrand) (swap! counter inc))))))
       (symbol (str "G__" (swap! counter inc))))))
 
+(def! gensym2
+  (let* [counter (atom 0)]
+    (fn* [name]
+      (symbol (str name "__" (swap! counter inc))))))
+
 ;; Like load-file, but will never load the same path twice.
 
 ;; This file is normally loaded with `load-file`, so it needs a

lisp/lisp.rs

@@ -517,7 +517,7 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                         // );
                         // println!("enforce here {:?}", get_enforce_allocs_nested(&env));
 
-                        Ok(MalVal::Nil)
+                        Ok(MalVal::Str("enforce-eof".to_string()))
                     }
                     _ => match eval_ast(&ast, &env)? {
                         List(ref el, _) => {

run_mimc.sh

@@ -1,5 +1,5 @@
 #!/bin/bash -x
-python scripts/preprocess.py proofs/mimc.psm > /tmp/mimc.psm || exit $?
-python scripts/compile.py --supervisor /tmp/mimc.psm --output mimc.zcd || exit $?
+python3 scripts/preprocess.py proofs/mimc.psm > /tmp/mimc.psm || exit $?
+python3 scripts/compile.py --supervisor /tmp/mimc.psm --output mimc.zcd || exit $?
 cargo run --release --bin mimc
 

run_mimc2.sh

@@ -1,6 +1,6 @@
 #!/bin/bash -x
-python scripts/preprocess.py proofs/mimc.psm > /tmp/mimc.psm || exit $?
-python scripts/compile.py --supervisor /tmp/mimc.psm --output mimc.zcd || exit $?
+python3 scripts/preprocess.py proofs/mimc.psm > /tmp/mimc.psm || exit $?
+python3 scripts/compile.py --supervisor /tmp/mimc.psm --output mimc.zcd || exit $?
 cargo run --release --bin zkvm -- init mimc.zcd mimc.zts
 cargo run --release --bin zkvm -- prove mimc.zcd mimc.zts proofs/mimc.params mimc.prf
 cargo run --release --bin zkvm -- verify mimc.zcd mimc.zts mimc.prf

src/bin/mimc.rs

@@ -94,6 +94,9 @@ fn main() -> Result<()> {
         0x015d_8c7f_5b43_fe33,
     ]);
 
+    println!("----> {:?}", left);
+    println!("----> {:?}", right);
+    
     contract.set_param("left_0", left.clone())?;
     contract.set_param("right", right.clone())?;
 

src/old/mimc.rs

@@ -130,6 +130,8 @@ impl<'a, Scalar: PrimeField> Circuit<Scalar> for MiMCDemo<'a, Scalar> {
                 |lc| lc + new_xl - xr,
             );
 
+            println!("{:?} xr_value {:?} xl_value {:?} new_xl_value {:?}", i, xr_value, xl_value, new_xl_value);
+
             // xR = xL
             xr = xl;
             xr_value = xl_value;