some code rfks

Author: erhant

README.md

@@ -78,7 +78,7 @@ P(x) = 82*x^4 + 81*x^3 + 83*x^2 + 88*x + 54
 P(x) / T(x) = 82*x + 88
 ```
 
-We can also design circuits with the existing gates (see [this example](./tests/circuits_test.rs)) and then print a wire that you have to see its gates, everything is composed of `+` and `*` gates only!
+We can also design circuits with the existing gates (see [this example](./tests/circuits_test.rs)) and then print a wire's lavel to see its gates, everything is composed of `+` and `*` only!
 
 ```py
 # for equal wires a, b in a field of order 97

src/circuits/wire.rs

@@ -3,40 +3,55 @@ use lambdaworks_math::field::{
     traits::{IsField, IsPrimeField},
 };
 
+// TODO: we should add a `Context` ref field here that handles
+// wire namings so that there are no collisions etc.
+
+/// A circuit "wire" that holds a value and a label.
+///
+/// It has addition, multiplication, subtraction, and negation operations overloaded
+/// so that the label is updated to indicate the operation w.r.t addition gates and
+/// multiplication gates.
+///
+/// You can create constant wires (which are labeled by numbers) or named wires
+/// with a label that you provide.
+///
+/// You can use `u64` values while creating constants, or even wires, which are implement
+/// `Into` to become a field element in the corresponding field.
 #[derive(Clone, Debug)]
 pub struct Wire<F: IsField> {
     pub label: String,
     pub value: FieldElement<F>,
 }
 
 impl<F: IsPrimeField> Wire<F> {
-    pub fn constant(value: FieldElement<F>) -> Self {
+    pub fn constant(value: impl Into<FieldElement<F>>) -> Self {
+        let value = value.into();
         Self {
             label: value.representative().to_string(),
             value,
         }
     }
 
-    pub fn new(value: impl Into<FieldElement<F>>, label: String) -> Self {
+    pub fn new(value: impl Into<FieldElement<F>>, label: impl ToString) -> Self {
         Self {
-            label,
+            label: label.to_string(),
             value: value.into(),
         }
     }
 
-    #[inline]
+    #[inline(always)]
     pub fn one() -> Self {
-        Self::constant(FieldElement::<F>::one())
+        Self::constant(1)
     }
 
-    #[inline]
+    #[inline(always)]
     pub fn neg_one() -> Self {
         Self::constant(-FieldElement::<F>::one())
     }
 
-    #[inline]
+    #[inline(always)]
     pub fn zero() -> Self {
-        Self::constant(FieldElement::<F>::zero())
+        Self::constant(0)
     }
 }
 
@@ -48,12 +63,6 @@ impl<F: IsField> PartialEq for Wire<F> {
 
 impl<F: IsField> Eq for &Wire<F> {}
 
-impl<F: IsPrimeField> std::fmt::Display for Wire<F> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}: {}", self.label, self.value.representative())
-    }
-}
-
 impl<F: IsField> std::ops::Add<Wire<F>> for Wire<F> {
     type Output = Wire<F>;
 
@@ -123,3 +132,9 @@ impl<'a, F: IsPrimeField> std::ops::Neg for &'a Wire<F> {
         &Wire::<F>::neg_one() * self
     }
 }
+
+impl<F: IsPrimeField> From<u64> for Wire<F> {
+    fn from(value: u64) -> Self {
+        Wire::constant(value)
+    }
+}

tests/circuits_test.rs

@@ -1,24 +1,41 @@
 use lambdaworks_math::field::fields::u64_prime_field::U64PrimeField;
 use mpbc_arithmetic_circuits::*;
 
+// some arbitrary field order
 const ORDER: u64 = 97;
-type F = U64PrimeField<ORDER>; // Example field with a small prime for simplicity
+type F = U64PrimeField<ORDER>;
 type W = circuits::Wire<F>;
 
 #[test]
-fn test_main() {
-    let a = W::new(23, "a".to_string());
-    let b = W::new(23, "b".to_string());
-    let c = W::new(55, "c".to_string());
+fn test_is_equal() {
+    let a = W::new(23, "a");
+    let b = W::new(23, "b");
+    let c = W::new(55, "c");
 
     let a_is_b = circuits::comparators::is_equal(&a, &b);
-    println!("a == b is given by {}", a_is_b);
+    assert_eq!(a_is_b.label, "(1+(96*((a+(96*b))*0)))");
 
     let b_is_c = circuits::comparators::is_equal(&b, &c);
-    println!("b == c is given by {}", b_is_c);
+    assert_eq!(b_is_c.label, "(1+(96*((b+(96*c))*(b+(96*c))_neg)))");
+}
 
-    // create r1cs
-    let cc = c.clone() * c.clone();
+#[test]
+fn test_c_cube() {
+    let c = W::new(55, "c");
+    let cc = &c * &c;
     let ccc = cc * c;
-    println!("c^3 is given by {}", ccc);
+
+    assert_eq!(ccc.label, "((c*c)*c)");
+    assert_eq!(ccc.value, (55 * 55 * 55).into());
+}
+
+#[test]
+fn test_vitalik_example() {
+    // we are constructing: x^3 + x + 5 = 35
+    let x = W::new(3, "x");
+    let xx = &x * &x;
+    let ans = (&xx * &x) + x + 5.into();
+
+    assert_eq!(ans.label, "((((x*x)*x)+x)+5)");
+    assert_eq!(ans.value, 35.into());
 }