Update `Cargo.toml` in `r1cs-std` and delete useless `ConstraintSystem`s

4 years ago · f575af4da1
3 changed files with 2 additions and 365 deletions
--- a/r1cs-std/Cargo.toml
+++ b/r1cs-std/Cargo.toml
@ -41,8 +41,8 @@ full = [
 ]

 bls12_377 = [ "algebra/bls12_377" ]
 ed_on_bls12_381 = [ "algebra/ed_on_bls12_381" ]
 ed_on_bn254 = [ "algebra/ed_on_bn254" ]
 ed_on_bls12_381 = [ "algebra/ed_on_bls12_381" ]
 ed_on_bls12_377 = [ "algebra/ed_on_bls12_377" ]
 ed_on_cp6_782 = [ "algebra/ed_on_cp6_782" ]
 ed_on_bw6_761 = [ "algebra/ed_on_bw6_761", "algebra/ed_on_cp6_782" ]
@ -53,5 +53,5 @@ mnt4_753 = [ "algebra/mnt4_753" ]
 mnt6_298 = [ "algebra/mnt6_298" ]
 mnt6_753 = [ "algebra/mnt6_753" ]

 std = [ "algebra/std" ]
 std = [ "algebra/std", "r1cs-core/std" ]
 parallel = [ "std", "algebra/parallel" ]
--- a/r1cs-std/src/test_constraint_counter.rs
+++ b/r1cs-std/src/test_constraint_counter.rs
@ -1,130 +0,0 @@
 use crate::String;
 use algebra::Field;
 use r1cs_core::{ConstraintSystem, Index, LinearCombination, SynthesisError, Variable};

 /// Constraint counter for testing purposes.
 pub struct ConstraintCounter {
    pub num_inputs: usize,
    pub num_aux: usize,
    pub num_constraints: usize,
 }

 impl ConstraintCounter {
    pub fn new() -> Self {
        Self {
            num_aux: 0,
            num_inputs: 0,
            num_constraints: 0,
        }
    }

    pub fn num_constraints(&self) -> usize {
        self.num_constraints
    }
 }

 impl<ConstraintF: Field> ConstraintSystem<ConstraintF> for ConstraintCounter {
    type Root = Self;

    fn alloc<F, A, AR>(&mut self, _: A, _: F) -> Result<Variable, SynthesisError>
    where
        F: FnOnce() -> Result<ConstraintF, SynthesisError>,
        A: FnOnce() -> AR,
        AR: Into<String>,
    {
        let var = Variable::new_unchecked(Index::Aux(self.num_aux));
        self.num_aux += 1;
        Ok(var)
    }

    fn alloc_input<F, A, AR>(&mut self, _: A, _: F) -> Result<Variable, SynthesisError>
    where
        F: FnOnce() -> Result<ConstraintF, SynthesisError>,
        A: FnOnce() -> AR,
        AR: Into<String>,
    {
        let var = Variable::new_unchecked(Index::Input(self.num_inputs));
        self.num_inputs += 1;

        Ok(var)
    }

    fn enforce<A, AR, LA, LB, LC>(&mut self, _: A, _: LA, _: LB, _: LC)
    where
        A: FnOnce() -> AR,
        AR: Into<String>,
        LA: FnOnce(LinearCombination<ConstraintF>) -> LinearCombination<ConstraintF>,
        LB: FnOnce(LinearCombination<ConstraintF>) -> LinearCombination<ConstraintF>,
        LC: FnOnce(LinearCombination<ConstraintF>) -> LinearCombination<ConstraintF>,
    {
        self.num_constraints += 1;
    }

    fn push_namespace<NR, N>(&mut self, _: N)
    where
        NR: Into<String>,
        N: FnOnce() -> NR,
    {
    }

    fn pop_namespace(&mut self) {}

    fn get_root(&mut self) -> &mut Self::Root {
        self
    }

    fn num_constraints(&self) -> usize {
        self.num_constraints
    }
 }

 #[cfg(test)]
 mod tests {
    use super::*;
    use crate::test_constraint_system::TestConstraintSystem;
    use algebra::{bls12_381::Fq, Field};
    use r1cs_core::{ConstraintSynthesizer, SynthesisError};

    // circuit proving knowledge of a square root
    #[derive(Clone, Debug)]
    struct TestCircuit<F>(Option<F>);

    impl<F: Field> ConstraintSynthesizer<F> for TestCircuit<F> {
        fn generate_constraints<CS: ConstraintSystem<F>>(
            self,
            cs: &mut CS,
        ) -> Result<(), SynthesisError> {
            let x = cs.alloc(|| "x", || self.0.ok_or(SynthesisError::AssignmentMissing))?;
            // 1 input!
            let out = cs.alloc_input(
                || "square",
                || {
                    self.0
                        .map(|x| x.square())
                        .ok_or(SynthesisError::AssignmentMissing)
                },
            )?;
            cs.enforce(|| "x * x = x^2", |lc| lc + x, |lc| lc + x, |lc| lc + out);
            Ok(())
        }
    }

    #[test]
    fn test_constraints_counter() {
        let empty_circuit = TestCircuit::<Fq>(None);
        let populated_circuit = TestCircuit(Some(Fq::from(10u32)));

        let mut counter = ConstraintCounter::new();
        let mut cs = TestConstraintSystem::new();

        empty_circuit
            .clone()
            .generate_constraints(&mut counter)
            .unwrap();
        // an empty circuit cannot be used with TestConstraintSystem
        empty_circuit.generate_constraints(&mut cs).unwrap_err();
        populated_circuit.generate_constraints(&mut cs).unwrap();

        assert_eq!(counter.num_constraints(), cs.num_constraints())
    }
 }
--- a/r1cs-std/src/test_constraint_system.rs
+++ b/r1cs-std/src/test_constraint_system.rs
@ -1,233 +0,0 @@
 use crate::{BTreeMap, String, Vec};
 use algebra::Field;
 use r1cs_core::{ConstraintSystem, Index, LinearCombination, SynthesisError, Variable};

 #[derive(Debug)]
 enum NamedObject {
    Constraint(usize),
    Var(Variable),
    Namespace,
 }

 /// Constraint system for testing purposes.
 pub struct TestConstraintSystem<ConstraintF: Field> {
    named_objects: BTreeMap<String, NamedObject>,
    current_namespace: Vec<String>,
    pub constraints: Vec<(
        LinearCombination<ConstraintF>,
        LinearCombination<ConstraintF>,
        LinearCombination<ConstraintF>,
        String,
    )>,
    inputs: Vec<(ConstraintF, String)>,
    aux: Vec<(ConstraintF, String)>,
 }

 impl<ConstraintF: Field> TestConstraintSystem<ConstraintF> {
    fn eval_lc(
        terms: &[(Variable, ConstraintF)],
        inputs: &[(ConstraintF, String)],
        aux: &[(ConstraintF, String)],
    ) -> ConstraintF {
        let mut acc = ConstraintF::zero();

        for &(var, ref coeff) in terms {
            let mut tmp = match var.get_unchecked() {
                Index::Input(index) => inputs[index].0,
                Index::Aux(index) => aux[index].0,
            };

            tmp *= coeff;
            acc += tmp;
        }

        acc
    }
 }

 impl<ConstraintF: Field> TestConstraintSystem<ConstraintF> {
    pub fn new() -> TestConstraintSystem<ConstraintF> {
        let mut map = BTreeMap::new();
        map.insert(
            "ONE".into(),
            NamedObject::Var(TestConstraintSystem::<ConstraintF>::one()),
        );

        TestConstraintSystem {
            named_objects: map,
            current_namespace: vec![],
            constraints: vec![],
            inputs: vec![(ConstraintF::one(), "ONE".into())],
            aux: vec![],
        }
    }

    #[allow(unused_variables)]
    pub fn print_named_objects(&self) {
        for &(_, _, _, ref name) in &self.constraints {
            println!("{}", name);
        }
    }

    pub fn which_is_unsatisfied(&self) -> Option<&str> {
        for &(ref a, ref b, ref c, ref path) in &self.constraints {
            let mut a = Self::eval_lc(a.as_ref(), &self.inputs, &self.aux);
            let b = Self::eval_lc(b.as_ref(), &self.inputs, &self.aux);
            let c = Self::eval_lc(c.as_ref(), &self.inputs, &self.aux);

            a.mul_assign(&b);

            if a != c {
                return Some(&*path);
            }
        }

        None
    }

    pub fn is_satisfied(&self) -> bool {
        self.which_is_unsatisfied().is_none()
    }

    pub fn num_constraints(&self) -> usize {
        self.constraints.len()
    }

    pub fn set(&mut self, path: &str, to: ConstraintF) {
        match self.named_objects.get(path) {
            Some(&NamedObject::Var(ref v)) => match v.get_unchecked() {
                Index::Input(index) => self.inputs[index].0 = to,
                Index::Aux(index) => self.aux[index].0 = to,
            },
            Some(e) => panic!(
                "tried to set path `{}` to value, but `{:?}` already exists there.",
                path, e
            ),
            _ => panic!("no variable exists at path: {}", path),
        }
    }

    pub fn get(&mut self, path: &str) -> ConstraintF {
        match self.named_objects.get(path) {
            Some(&NamedObject::Var(ref v)) => match v.get_unchecked() {
                Index::Input(index) => self.inputs[index].0,
                Index::Aux(index) => self.aux[index].0,
            },
            Some(e) => panic!(
                "tried to get value of path `{}`, but `{:?}` exists there (not a variable)",
                path, e
            ),
            _ => panic!("no variable exists at path: {}", path),
        }
    }

    fn set_named_obj(&mut self, path: String, to: NamedObject) {
        if self.named_objects.get(&path).is_some() {
            panic!("tried to create object at existing path: {}", path);
        }

        self.named_objects.insert(path, to);
    }
 }

 fn compute_path(ns: &[String], this: String) -> String {
    if this.chars().any(|a| a == '/') {
        panic!(
            "'/' is not allowed in namespaces. Error in namespace '{}'",
            this
        );
    }

    let mut name = String::new();

    let mut needs_separation = false;
    for ns in ns.iter().chain(Some(&this).into_iter()) {
        if needs_separation {
            name += "/";
        }

        name += ns;
        needs_separation = true;
    }

    name
 }

 impl<ConstraintF: Field> ConstraintSystem<ConstraintF> for TestConstraintSystem<ConstraintF> {
    type Root = Self;

    fn alloc<F, A, AR>(&mut self, annotation: A, f: F) -> Result<Variable, SynthesisError>
    where
        F: FnOnce() -> Result<ConstraintF, SynthesisError>,
        A: FnOnce() -> AR,
        AR: Into<String>,
    {
        let index = self.aux.len();
        let path = compute_path(&self.current_namespace, annotation().into());
        self.aux.push((f()?, path.clone()));
        let var = Variable::new_unchecked(Index::Aux(index));
        self.set_named_obj(path, NamedObject::Var(var));

        Ok(var)
    }

    fn alloc_input<F, A, AR>(&mut self, annotation: A, f: F) -> Result<Variable, SynthesisError>
    where
        F: FnOnce() -> Result<ConstraintF, SynthesisError>,
        A: FnOnce() -> AR,
        AR: Into<String>,
    {
        let index = self.inputs.len();
        let path = compute_path(&self.current_namespace, annotation().into());
        self.inputs.push((f()?, path.clone()));
        let var = Variable::new_unchecked(Index::Input(index));
        self.set_named_obj(path, NamedObject::Var(var));

        Ok(var)
    }

    fn enforce<A, AR, LA, LB, LC>(&mut self, annotation: A, a: LA, b: LB, c: LC)
    where
        A: FnOnce() -> AR,
        AR: Into<String>,
        LA: FnOnce(LinearCombination<ConstraintF>) -> LinearCombination<ConstraintF>,
        LB: FnOnce(LinearCombination<ConstraintF>) -> LinearCombination<ConstraintF>,
        LC: FnOnce(LinearCombination<ConstraintF>) -> LinearCombination<ConstraintF>,
    {
        let path = compute_path(&self.current_namespace, annotation().into());
        let index = self.constraints.len();
        self.set_named_obj(path.clone(), NamedObject::Constraint(index));

        let mut a = a(LinearCombination::zero());
        let mut b = b(LinearCombination::zero());
        let mut c = c(LinearCombination::zero());
        a.0.shrink_to_fit();
        b.0.shrink_to_fit();
        c.0.shrink_to_fit();

        self.constraints.push((a, b, c, path));
    }

    fn push_namespace<NR, N>(&mut self, name_fn: N)
    where
        NR: Into<String>,
        N: FnOnce() -> NR,
    {
        let name = name_fn().into();
        let path = compute_path(&self.current_namespace, name.clone());
        self.set_named_obj(path, NamedObject::Namespace);
        self.current_namespace.push(name);
    }

    fn pop_namespace(&mut self) {
        assert!(self.current_namespace.pop().is_some());
    }

    fn get_root(&mut self) -> &mut Self::Root {
        self
    }

    fn num_constraints(&self) -> usize {
        self.constraints.len()
    }
 }