fixing new dsl for cs

lisp/core.rs

@@ -256,18 +256,18 @@ fn sub_scalar(a: MalArgs) -> MalRet {
             s0.sub_assign(s1);
             Ok(Str(std::string::ToString::to_string(&s0)[2..].to_string()))
         }
-        _ => error("expected (scalar, scalar"),
+        _ => error("expected (scalar, scalar)"),
     }
 }
 
 fn mul_scalar(a: MalArgs) -> MalRet {
     match (a[0].clone(), a[1].clone()) {
-        (Str(a0), Str(a1)) => {
+        (MalVal::Scalar(a0), MalVal::Scalar(a1)) => {
             let (mut s0, s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
             s0.mul_assign(s1);
-            Ok(Str(std::string::ToString::to_string(&s0)[2..].to_string()))
+            Ok(MalVal::Scalar(std::string::ToString::to_string(&s0)[2..].to_string()))
         }
-        _ => error("expected (scalar, scalar"),
+        _ => error("expected (scalar, scalar)"),
     }
 }
 
@@ -308,6 +308,18 @@ fn scalar_one(a: MalArgs) -> MalRet {
     println!("{:?}", a);
     Ok(Nil)
 }
+fn scalar_from(a: MalArgs) -> MalRet {
+    println!("{:?}", a);
+    match (a[0].clone()) {
+        (Str(a0)) => {
+            let (s0) = (Scalar::from_string(&a0.to_string()));
+            Ok(MalVal::Scalar(
+                std::string::ToString::to_string(&s0)[2..].to_string()
+            ))
+        }
+        _ => error("expected (string)"),
+    }
+}
 fn alloc(a: MalArgs) -> MalRet {
     println!("{:?}", a);
     Ok(Nil)
@@ -445,7 +457,7 @@ pub fn ns() -> Vec<(&'static str, MalVal)> {
         ("alloc", func(alloc)),
         ("alloc-input", func(alloc_input)),
         ("scalar::one", func(scalar_one)),
-        ("scalar", func(scalar_one)),
+        ("scalar", func(scalar_from)),
         ("cs::one", func(cs_one)),
         ("bellman::one", func(bellman_one)),
     ]

lisp/lisp.rs

@@ -272,7 +272,7 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                         }
                     }
                     Sym(ref a0sym) if a0sym == "setup" => {
-                        let (a1, _a2) = (l[1].clone(), l[2].clone());
+                        let a1 = l[1].clone();
                         eval(a1.clone(), env.clone())
                     }
                     //Sym(ref a0sym) if a0sym == "prove" => {
@@ -292,15 +292,6 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
                         env_set(&env, a1.clone(), eval(a1.clone(), env.clone())?);
                         eval(a1.clone(), env.clone())
                     }
-                    Sym(ref a0sym) if a0sym == "defzk!" => {
-                        // private, public and constrains
-                        //let (a1, a2, a3) = (l[1].clone(), l[2].clone(), l[3].clone());
-                        let a1 = l[1].clone();
-                        let circuit = zk_circuit_create(&a1, &env);
-                        let val = types::MalVal::Zk(circuit.clone());
-                        env_set(&env, a1.clone(), val.clone());
-                        Ok(val.clone())
-                    }
                     Sym(ref a0sym) if a0sym == "fn*" => {
                         let (a1, a2) = (l[1].clone(), l[2].clone());
                         Ok(MalFunc {

lisp/new-cs.lisp

@@ -10,8 +10,8 @@
 ;; prove
 ;; verify
 (println "new-cs.lisp")
-(defzk! MyCircuit (fn* [aux]  
-[let x  (alloc "num" (first aux))
+(def! MyCircuit (fn* [aux]  
+(let* [x  (alloc "num" (first aux))
      x2 (alloc "product num" (second aux)) 
      x3 (alloc "product num" (last aux))
      input (alloc-input "input variable" (last aux))
@@ -26,10 +26,21 @@
          (zero + x3))
     (enforce "mc" coeff (zero + x2) (zero + x) (zero + x3))
     (enforce "mc" coeff (zero + input) (zero + cs::one) (zero + x3))
-))
-(def! a (scalar 3))
-(setup MyCircuit (a (* a a) (* a a a)))
+)))
+(def! a (scalar "0000000000000000000000000000000000000000000000000000000000000003"))
+(println (* (* a a) a))
+(setup (MyCircuit (a (* a a) (* (* a a) a))))
 ;; (prove MyCircuit)
 ;; (verify (prove MyCircuit) (scalar 27))
+;; (U - A - B) / (1 - C)
+;; [(1 - C)] * [y] = [U - A - B]
+;; Lc0: [(Scalar::one(), CS::one()), (Scalar::one().neg(), C)]
+;; Lc1: [(Scalar::one(), y)]
+;; Lc2: [(Scalar::one(), U), (Scalar::one().neg(), A), (Scalar::one().neg(), B)]
+;; assert (x1 + y1) * (x2 + y2) == U
+;; Lc0: [(Scalar::one(), x1), (Scalar::one(), y1)]
+;; Lc1: [(Scalar::one(), x2), (Scalar::one(), y2)]
+;; Lc2: [(Scalar::one(), U)]
+;; (enforce ((scalar::one x1) (scalar::one y1)) ((scalar::one x2) (scalar::one y2) ((scalar::one U)))
 
      

lisp/printer.rs

@@ -45,10 +45,7 @@ impl MalVal {
                 ast: a, params: p, ..
             } => format!("(fn* {} {})", p.pr_str(true), a.pr_str(true)),
             Atom(a) => format!("(atom {})", a.borrow().pr_str(true)),
-            Zk(a) => format!("{:?}", a),
-            _Add => format!("add"),
-            _Sub => format!("sub"),
-            _Lc0 => format!("Lc0"),
+            MalVal::Scalar(a) => format!("{:?}", a),
             i => format!("{:?}", i.pr_str(true)),
         }
     }

lisp/types.rs

@@ -38,7 +38,8 @@ pub enum MalVal {
     },
     Atom(Rc<RefCell<MalVal>>),
     Zk(ZKCircuit),
-    Enforce(Rc<Vec<MalVal>>)
+    Enforce(Rc<Vec<MalVal>>),
+    Scalar(String)
 }
 
 #[derive(Debug, Clone)]