ZIR-181: Add Elliptic Curve BigInt circuits

zirgen/Dialect/BigInt/IR/Dialect.cpp

@@ -41,7 +41,12 @@ void BigIntDialect::initialize() {
 
 codegen::CodegenIdent<codegen::IdentKind::Type>
 BigIntType::getTypeName(codegen::CodegenEmitter& cg) const {
-  return cg.getStringAttr("byte_poly");
+  return cg.getStringAttr("byte_poly_" + std::to_string(getCoeffs()));
+}
+
+void BigIntType::emitTypeDefinition(codegen::CodegenEmitter& cg) const {
+  cg.emitInvokeMacro(cg.getStringAttr("bigint_declare_byte_poly"), {getTypeName(cg), getCoeffs()});
+  cg << ";\n";
 }
 
 bool BigIntType::allowDuplicateTypeNames() const {

zirgen/Dialect/BigInt/IR/Ops.cpp

@@ -196,13 +196,40 @@ codegen::CodegenValue toConstantValue(codegen::CodegenEmitter& cg, MLIRContext*
 } // namespace
 
 void DefOp::emitExpr(codegen::CodegenEmitter& cg) {
-  cg.emitFuncCall(cg.getStringAttr("def"),
-                  /*contextArgs=*/{"ctx"},
-                  {
-                      toConstantValue(cg, getContext(), getType().getCoeffs()),
-                      cg.guessAttributeType(getLabelAttr()),
-                      cg.guessAttributeType(getIsPublicAttr()),
-                  });
+  cg.emitInvokeMacro(cg.getStringAttr("bigint_def"),
+                     /*contextArgs=*/{"ctx"},
+                     {
+                         toConstantValue(cg, getContext(), getType().getCoeffs()),
+                         cg.guessAttributeType(getLabelAttr()),
+                         cg.guessAttributeType(getIsPublicAttr()),
+                     });
+}
+
+void AddOp::emitExpr(codegen::CodegenEmitter& cg) {
+  cg.emitInvokeMacro(cg.getStringAttr("bigint_add"),
+                     {
+                         getLhs(),
+                         getRhs(),
+                         toConstantValue(cg, getContext(), getType().getCoeffs()),
+                     });
+}
+
+void SubOp::emitExpr(codegen::CodegenEmitter& cg) {
+  cg.emitInvokeMacro(cg.getStringAttr("bigint_sub"),
+                     {
+                         getLhs(),
+                         getRhs(),
+                         toConstantValue(cg, getContext(), getType().getCoeffs()),
+                     });
+}
+
+void MulOp::emitExpr(codegen::CodegenEmitter& cg) {
+  cg.emitInvokeMacro(cg.getStringAttr("bigint_mul"),
+                     {
+                         getLhs(),
+                         getRhs(),
+                         toConstantValue(cg, getContext(), getType().getCoeffs()),
+                     });
 }
 
 void EqualZeroOp::emitExpr(codegen::CodegenEmitter& cg) {
@@ -214,21 +241,24 @@ void EqualZeroOp::emitExpr(codegen::CodegenEmitter& cg) {
 }
 
 void NondetRemOp::emitExpr(codegen::CodegenEmitter& cg) {
-  cg.emitFuncCall(cg.getStringAttr("nondet_rem"),
-                  /*contextArgs=*/{"ctx"},
-                  {getLhs(), getRhs(), toConstantValue(cg, getContext(), getType().getCoeffs())});
+  cg.emitInvokeMacro(
+      cg.getStringAttr("bigint_nondet_rem"),
+      /*contextArgs=*/{"ctx"},
+      {getLhs(), getRhs(), toConstantValue(cg, getContext(), getType().getCoeffs())});
 }
 
 void NondetQuotOp::emitExpr(codegen::CodegenEmitter& cg) {
-  cg.emitFuncCall(cg.getStringAttr("nondet_quot"),
-                  /*contextArgs=*/{"ctx"},
-                  {getLhs(), getRhs(), toConstantValue(cg, getContext(), getType().getCoeffs())});
+  cg.emitInvokeMacro(
+      cg.getStringAttr("bigint_nondet_quot"),
+      /*contextArgs=*/{"ctx"},
+      {getLhs(), getRhs(), toConstantValue(cg, getContext(), getType().getCoeffs())});
 }
 
 void NondetInvModOp::emitExpr(codegen::CodegenEmitter& cg) {
-  cg.emitFuncCall(cg.getStringAttr("nondet_inv"),
-                  /*contextArgs=*/{"ctx"},
-                  {getLhs(), getRhs(), toConstantValue(cg, getContext(), getType().getCoeffs())});
+  cg.emitInvokeMacro(
+      cg.getStringAttr("bigint_nondet_inv"),
+      /*contextArgs=*/{"ctx"},
+      {getLhs(), getRhs(), toConstantValue(cg, getContext(), getType().getCoeffs())});
 }
 
 void ConstOp::emitExpr(codegen::CodegenEmitter& cg) {

zirgen/Dialect/BigInt/IR/Ops.td

@@ -45,9 +45,9 @@ class BinaryOp<string mnemonic, list<Trait> traits = []>
   let assemblyFormat = [{ $lhs `:` type($lhs) `,` $rhs `:` type($rhs) `->` type($out) attr-dict }];
 }
 
-def AddOp : BinaryOp<"add", [Pure, Commutative]> {}
-def SubOp : BinaryOp<"sub", [Pure, ]> {}
-def MulOp : BinaryOp<"mul", [Pure, Commutative]> {}
+def AddOp : BinaryOp<"add", [Pure, Commutative, DeclareOpInterfaceMethods<CodegenExprOpInterface>]> {}
+def SubOp : BinaryOp<"sub", [Pure, DeclareOpInterfaceMethods<CodegenExprOpInterface>]> {}
+def MulOp : BinaryOp<"mul", [Pure, Commutative, DeclareOpInterfaceMethods<CodegenExprOpInterface>]> {}
 def NondetRemOp : BinaryOp<"nondet_rem", [DeclareOpInterfaceMethods<CodegenExprOpInterface>]> {}
 def NondetQuotOp : BinaryOp<"nondet_quot", [DeclareOpInterfaceMethods<CodegenExprOpInterface>]> {}
 def NondetInvModOp : BinaryOp<"nondet_invmod", [DeclareOpInterfaceMethods<CodegenExprOpInterface>]> {}

zirgen/Dialect/BigInt/IR/Types.td

@@ -22,7 +22,7 @@ class BigIntType<string name, string typeMnemonic, list<Trait> traits = []>
 }
 
 def BigInt : BigIntType<"BigInt", "bigint", [
-   DeclareTypeInterfaceMethods<CodegenTypeInterface, ["getTypeName", "allowDuplicateTypeNames"]>,
+   DeclareTypeInterfaceMethods<CodegenTypeInterface, ["getTypeName", "allowDuplicateTypeNames", "emitTypeDefinition"]>,
    CodegenNeedsCloneType
 ]> {
   let summary = "A big interger value represented as a polynomial";

zirgen/Dialect/Zll/IR/CodegenEmitter.cpp

@@ -502,9 +502,8 @@ void CodegenEmitter::emitTypeDefs(TypeRange tys) {
         }
       } else {
         typeNames[name.getAttr()] = ty;
+        ty.emitTypeDefinition(*this);
       }
-
-      ty.emitTypeDefinition(*this);
       types.insert(ty);
     });
   }

zirgen/circuit/bigint/BUILD.bazel

@@ -8,10 +8,12 @@ package(
 cc_library(
     name = "lib",
     srcs = [
+        "elliptic_curve.cpp",
         "op_tests.cpp",
         "rsa.cpp",
     ],
     hdrs = [
+        "elliptic_curve.h",
         "op_tests.h",
         "rsa.h",
         "//zirgen/circuit/recursion",
@@ -31,6 +33,25 @@ ZKRS = [
     "rsa_256_x1",
     "rsa_256_x2",
     "rsa_3072_x15",
+    "ec_add_rz8test",
+    "ec_add_secp256k1",
+    "ec_sub_rz8test",
+    "ec_sub_secp256k1",
+    "ec_doub_rz8test",
+    "ec_doub_secp256k1",
+    "ec_mul_rz8test",
+    "ec_mul_secp256k1",
+    "ec_neg_rz8test",
+    "ec_neg_secp256k1",
+    "ec_pts_eq_rz8test",
+    "ec_pts_eq_secp256k1",
+    "ec_on_curve_rz8test",
+    "ec_on_curve_secp256k1",
+    "ec_add_freely_rz8test",
+    "ec_sub_freely_rz8test",
+    "ec_doub_freely_rz8test",
+    "ec_neg_freely_rz8test",
+    "ec_mul_freely_rz8test",
     "const_add_test_8",
     "const_add_alt_test_16",
     "const_mul_test_8",
@@ -46,6 +67,13 @@ ZKRS = [
     "reduce_test_8",
     "reduce_test_128",
     "nondet_inv_test_8",
+    # Perf tests, re-enable if needed
+    # "rep_ec_add_secp256k1_r5",
+    # "rep_ec_add_secp256k1_r10",
+    # "rep_ec_add_secp256k1_r256",
+    # "rep_ec_doub_secp256k1_r5",
+    # "rep_ec_doub_secp256k1_r10",
+    # "rep_ec_doub_secp256k1_r256",
 ]
 
 build_circuit(