organizing two circuits interacting

lisp/jubjub-mul.lisp

@@ -1,9 +1,12 @@
- (println "jubjub-mul.lisp")
+(println "jubjub-mul.lisp")
 (def! param4 (scalar "015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891"))
 (def! param3 (scalar "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e"))
 (def! param2 (scalar "015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891"))
 (def! param1 (scalar "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e"))
 
+(setup
+    (prove 
+      (
     (def! double (fn* [val1 val2] (
             (def! u11 (alloc "u11" (scalar val1)))
             (def! v11 (alloc "v11" (scalar val2)))
@@ -16,23 +19,18 @@
         )
     ))
 
-(setup
-    (prove 
-      (
-    (zk* [
-      u1 (alloc "u1" param1)
-      v1 (alloc "v1" param2)
-      u2 (alloc "u2" param3)
-      v2 (alloc "v2" param4)
-      EDWARDS_D (alloc-const "EDWARDS_D" (scalar "2a9318e74bfa2b48f5fd9207e6bd7fd4292d7f6d37579d2601065fd6d6343eb1"))
-      U (alloc "U" (* (+ u1 v1) (+ u2 v2)))
-      A (alloc "A" (* v2 u1))
-      B (alloc "B" (* u2 v1))
-      C (alloc "C" (* EDWARDS_D (* A B)))
-      u3 (alloc-input "u3" (/ (+ A B) (+ scalar::one C)))
-      v3 (alloc-input "v3" (/ (- (- U A) B) (- scalar::one C)))
-      v4 (double param1 param1)
-      ]
+     (def! u1 (alloc "u1" param1))
+     (def! v1 (alloc "v1" param2))
+     (def! u2 (alloc "u2" param3))
+     (def! v2 (alloc "v2" param4))
+     (def! EDWARDS_D (alloc-const "EDWARDS_D" (scalar "2a9318e74bfa2b48f5fd9207e6bd7fd4292d7f6d37579d2601065fd6d6343eb1")))
+     (def! U (alloc "U" (* (+ u1 v1) (+ u2 v2))))
+     (def! A (alloc "A" (* v2 u1)))
+     (def! B (alloc "B" (* u2 v1)))
+     (def! C (alloc "C" (* EDWARDS_D (* A B))))
+     (def! u3 (alloc-input "u3" (/ (+ A B) (+ scalar::one C))))
+     (def! v3 (alloc-input "v3" (/ (- (- U A) B) (- scalar::one C))))
+     (double param1 param1)
   (
   (enforce  
     ((scalar::one u1) (scalar::one v1))
@@ -57,4 +55,4 @@
   )
  )
 )
-))
+)

lisp/lisp.rs

@@ -165,7 +165,6 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                 let a0 = &l[0];
                 match a0 {
                     Sym(ref a0sym) if a0sym == "def!" => {
-                        println!("def {:?}", l[1]);
                         env_set(&env, l[1].clone(), eval(l[2].clone(), env.clone())?)
                     }
                     Sym(ref a0sym) if a0sym == "zk*" => {