feat: impl Add for Sum<Weighted>

Author: mmaker

src/linear_relation/mod.rs

@@ -761,10 +761,7 @@ where
     /// let proof = nizk.prove_batchable(&vec![x], &mut OsRng).unwrap();
     /// assert!(nizk.verify_batchable(&proof).is_ok());
     /// ```
-    pub fn into_nizk(
-        self,
-        session_identifier: &[u8],
-    ) -> Nizk<SchnorrProof<G>, ShakeCodec<G>>
+    pub fn into_nizk(self, session_identifier: &[u8]) -> Nizk<SchnorrProof<G>, ShakeCodec<G>>
     where
         G: group::GroupEncoding,
     {

src/linear_relation/ops.rs

@@ -217,6 +217,41 @@ mod add {
             self + Self::from(rhs)
         }
     }
+
+    impl<G: Group> Add<Weighted<GroupVar<G>, G::Scalar>> for Term<G> {
+        type Output = Sum<Weighted<Term<G>, G::Scalar>>;
+
+        fn add(self, rhs: Weighted<GroupVar<G>, G::Scalar>) -> Self::Output {
+            Sum(vec![
+                Weighted {
+                    term: self,
+                    weight: G::Scalar::ONE,
+                },
+                Weighted {
+                    term: Term {
+                        scalar: super::ScalarTerm::Unit,
+                        elem: rhs.term,
+                    },
+                    weight: rhs.weight,
+                },
+            ])
+        }
+    }
+
+    impl<G: Group> Add<Weighted<GroupVar<G>, G::Scalar>> for Sum<Weighted<Term<G>, G::Scalar>> {
+        type Output = Sum<Weighted<Term<G>, G::Scalar>>;
+
+        fn add(mut self, rhs: Weighted<GroupVar<G>, G::Scalar>) -> Self::Output {
+            self.0.push(Weighted {
+                term: Term {
+                    scalar: super::ScalarTerm::Unit,
+                    elem: rhs.term,
+                },
+                weight: rhs.weight,
+            });
+            self
+        }
+    }
 }
 
 mod mul {

src/tests/composition.rs

@@ -83,8 +83,7 @@ fn composition_proof_correct() {
     let protocol = Protocol::And(vec![or_protocol1, simple_protocol1, and_protocol1]);
     let witness = ProtocolWitness::And(vec![or_witness1, simple_witness1, and_witness1]);
 
-    let nizk =
-        Nizk::<Protocol<RistrettoPoint>, ShakeCodec<G>>::new(domain_sep, protocol);
+    let nizk = Nizk::<Protocol<RistrettoPoint>, ShakeCodec<G>>::new(domain_sep, protocol);
 
     // Batchable and compact proofs
     let proof_batchable_bytes = nizk.prove_batchable(&witness, &mut rng).unwrap();

src/tests/test_utils.rs

@@ -184,3 +184,18 @@ pub fn bbs_blind_commitment_computation<G: Group + GroupEncoding>(
     assert!(vec![C] == relation.linear_map.evaluate(&witness).unwrap());
     (relation, witness)
 }
+
+/// Test function with the requested LinearRelation code
+#[allow(non_snake_case)]
+pub fn test_linear_relation_example<G: Group + GroupEncoding>() -> LinearRelation<G> {
+    use ff::Field;
+
+    let mut sigma__lr = LinearRelation::<G>::new();
+    let x = sigma__lr.allocate_scalar();
+    let B = sigma__lr.allocate_element();
+    let _sigma__eq1 =
+        sigma__lr.allocate_eq((x + (-<<G as Group>::Scalar as Field>::ONE)) * B + (-B));
+
+    sigma__lr
+}
+