fix witness

lisp/examples/macro-test.lisp

@@ -1,8 +1,4 @@
-(def! inc (fn* [a] (i+ a 1)))
-(def! gensym
-  (let* [counter (atom 0)]
-    (fn* []
-      (symbol (str "G__" (swap! counter inc))))))
+(load-file "util.lisp")
 
 (defmacro! zk-square (fn* [var] (
         (let* [v1 (gensym)
@@ -36,30 +32,34 @@
     ))
 ))
 
-;; -u^2 + v^2 = 1 + du^2v^2
 (defmacro! zk-witness (fn* [val1 val2] (
-        (let* [u2v2 (gensym)] (
+        (let* [u2 (gensym)
+               v2 (gensym)
+               u2v2 (gensym)
+               EDWARDS_D (gensym)] (
         `(def! ~EDWARDS_D (alloc-const ~EDWARDS_D (scalar "2a9318e74bfa2b48f5fd9207e6bd7fd4292d7f6d37579d2601065fd6d6343eb1")))
-        `(def! u2 (alloc ~u2 (get (nth (nth (zk-square ~val1) 0) 3) "v2")))
-        `(def! v2 (alloc ~v2 (get (nth (nth (zk-square ~val2) 0) 3) "v2")))
-        `(alloc ~u2v2 (get (last (last (zk-mul u2 v2))) "result"))
+        `(def! ~u2 (alloc ~u2 (get (nth (nth (zk-square ~val1) 0) 3) "v2")))
+        `(def! ~v2 (alloc ~v2 (get (nth (nth (zk-square ~val2) 0) 3) "v2")))
+        `(def! result (alloc-input ~u2v2 (get (last (last (zk-mul ~u2 ~v2))) "result")))        
         `(enforce  
             ((scalar::one::neg ~u2) (scalar::one ~v2))
-            (scalar::one cs::one) 
+            (scalar::one cs::one)
             ((scalar::one cs::one) (~EDWARDS_D ~u2v2))
-        )
+         )
+        `{ "result" result }
         )
     ))
 ))
 
-
 (def! param1 (scalar 3))
-(def! param2 (scalar 1))
+(def! param2 (scalar 9))
+(def! param-u (scalar "6800f4fa0f001cfc7ff6826ad58004b4d1d8da41af03744e3bce3b7793664337"))
+(def! param-v (scalar "6d81d3a9cb45dedbe6fb2a6e1e22ab50ad46f1b0473b803b3caefab9380b6a8b"))
 (prove 
   (
     ;; (def! result1 (zk-square param1))
     ;; (println 'result1_map (get (nth (nth result1 0) 3) "v2"))
-    ;; (def! result2 (zk-square param2))
     ;; (println 'result_mul (get (last (last (zk-mul param1 param1))) "result"))
+    (println (zk-witness param-u param-v))
   )
 )

lisp/examples/util.lisp

@@ -2,6 +2,7 @@
 (def! gensym
   (let* [counter (atom 0)]
     (fn* []
+      ;; (symbol (str "G__" (genrand) (swap! counter inc))))))
       (symbol (str "G__" (swap! counter inc))))))
 
 ;; Like load-file, but will never load the same path twice.

lisp/lisp.rs

@@ -108,7 +108,7 @@ fn macroexpand(mut ast: MalVal, env: &Env) -> (bool, MalRet) {
             Err(e) => return (false, Err(e)),
             Ok(a) => a,
         };
-        // println!("macroexpand 2: {:?}", ast);
+        // println!("macroexpand 2: {:?}", ast); 
         was_expanded = true;
     }
     (was_expanded, Ok(ast))

lisp/types.rs

@@ -75,52 +75,52 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
         let mut variables: FnvHashMap<String, Variable> = FnvHashMap::default();
         let mut params_const = self.params;
 
-        // println!("Allocations\n");
+        println!("Allocations\n");
         for (k, v) in &self.allocs {
             match v {
                 MalVal::ZKScalar(val) => {
                     let var = cs.alloc(|| k, || Ok(*val))?;
                     variables.insert(k.to_string(), var);
-                    // println!("k {:?} v {:?} var {:?}", k, v, var);
+                    println!("k {:?} v {:?} var {:?}", k, v, var);
                 }
                 MalVal::Str(val) => {
                     let val_scalar = bls12_381::Scalar::from_string(&*val);
                     let var = cs.alloc(|| k, || Ok(val_scalar))?;
                     variables.insert(k.to_string(), var);
-                    // println!("k {:?} v {:?} var {:?}", k, v, var);
+                    println!("k {:?} v {:?} var {:?}", k, v, var);
                 }
                 _ => {
-                    // println!("not allocated k {:?} v {:?}", k, v);
+                    println!("not allocated k {:?} v {:?}", k, v);
                 }
             }
         }
 
-        // println!("Allocations Input\n");
+        println!("Allocations Input\n");
         for (k, v) in &self.alloc_inputs {
             // println!("k {:?} v {:?}", k, v);
             match v {
                 MalVal::ZKScalar(val) => {
                     let var = cs.alloc_input(|| k, || Ok(*val))?;
                     variables.insert(k.to_string(), var);
-                    // println!("k {:?} v {:?} var {:?}", k, v, var);
+                    println!("k {:?} v {:?} var {:?}", k, v, var);
                 }
                 MalVal::Str(val) => {
                     let val_scalar = bls12_381::Scalar::from_string(&*val);
                     let var = cs.alloc_input(|| k, || Ok(val_scalar))?;
                     variables.insert(k.to_string(), var);
-                    // println!("k {:?} v {:?} var {:?}", k, v, var);
+                    println!("k {:?} v {:?} var {:?}", k, v, var);
                 }
                 _ => {
-                    // println!("not allocated k {:?} v {:?}", k, v);
+                    println!("not allocated k {:?} v {:?}", k, v);
                 }
             }
         }
 
-        // println!("Enforce Allocations\n");
+        println!("Enforce Allocations\n");
         let mut enforce_sorted = self.constraints.clone();
         enforce_sorted.sort_by(|a, b| a.idx.cmp(&b.idx));
         for alloc_value in enforce_sorted.iter() {
-            // println!("Enforce -> {:?}", alloc_value);
+            println!("Enforce -> {:?}", alloc_value);
             let coeff = bls12_381::Scalar::one();
             let mut left = bellman::LinearCombination::<Scalar>::zero();
             let mut right = bellman::LinearCombination::<Scalar>::zero();
@@ -142,7 +142,7 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                         }
                     }
                 }
-                //                println!("left: a {:?} b {:?} val_b: {:?}", a, b, val_b);
+                println!("left: a {:?} b {:?} val_b: {:?}", a, b, val_b);
             }
 
             for values in alloc_value.right.iter() {
@@ -156,7 +156,7 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                 } else if a == "scalar::one::neg" {
                     right = right + (coeff.neg(), val_b);
                 }
-                //println!("right: a {:?} b {:?} val_b: {:?}", a, b, val_b);
+                println!("right: a {:?} b {:?} val_b: {:?}", a, b, val_b);
             }
 
             for values in alloc_value.output.iter() {
@@ -170,7 +170,7 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                 } else if a == "scalar::one::neg" {
                     output = output + (coeff.neg(), val_b);
                 }
-                //println!("output: a {:?} b {:?} val_b: {:?}", a, b, val_b);
+                println!("output: a {:?} b {:?} val_b: {:?}", a, b, val_b);
             }
 
             // println!("Enforcing ...");