From 2f95a9094abd8e2bb2228efe2450ba8dd0123760 Mon Sep 17 00:00:00 2001
From: Sean Bowe <ewillbefull@gmail.com>
Date: Tue, 13 Feb 2018 12:38:06 -0700
Subject: [PATCH] Refactor to handle changes to ConstraintSystem API (no more
 Variable associated type, one is now static method).

---
 src/circuit/blake2s.rs       | 16 ++++----
 src/circuit/boolean.rs       | 75 ++++++++++++++++++------------------
 src/circuit/lookup.rs        | 22 +++++------
 src/circuit/mod.rs           |  2 +-
 src/circuit/mont.rs          | 73 +++++++++++++++++------------------
 src/circuit/num.rs           | 56 +++++++++++++--------------
 src/circuit/pedersen_hash.rs | 12 +++---
 src/circuit/test/mod.rs      | 74 ++++++++++++++++++++++-------------
 src/circuit/uint32.rs        | 40 +++++++++++--------
 9 files changed, 199 insertions(+), 171 deletions(-)

diff --git a/src/circuit/blake2s.rs b/src/circuit/blake2s.rs
index 9a0d283ad..855a8c64f 100644
--- a/src/circuit/blake2s.rs
+++ b/src/circuit/blake2s.rs
@@ -90,13 +90,13 @@ const SIGMA: [[usize; 16]; 10] = [
 
 fn mixing_g<E: Engine, CS: ConstraintSystem<E>>(
     mut cs: CS,
-    v: &mut [UInt32<CS::Variable>],
+    v: &mut [UInt32],
     a: usize,
     b: usize,
     c: usize,
     d: usize,
-    x: &UInt32<CS::Variable>,
-    y: &UInt32<CS::Variable>
+    x: &UInt32,
+    y: &UInt32
 ) -> Result<(), SynthesisError>
 {
     v[a] = UInt32::addmany(cs.namespace(|| "mixing step 1"), &[v[a].clone(), v[b].clone(), x.clone()])?;
@@ -162,8 +162,8 @@ fn mixing_g<E: Engine, CS: ConstraintSystem<E>>(
 
 fn blake2s_compression<E: Engine, CS: ConstraintSystem<E>>(
     mut cs: CS,
-    h: &mut [UInt32<CS::Variable>],
-    m: &[UInt32<CS::Variable>],
+    h: &mut [UInt32],
+    m: &[UInt32],
     t: u64,
     f: bool
 ) -> Result<(), SynthesisError>
@@ -254,8 +254,8 @@ fn blake2s_compression<E: Engine, CS: ConstraintSystem<E>>(
 
 pub fn blake2s<E: Engine, CS: ConstraintSystem<E>>(
     mut cs: CS,
-    input: &[Boolean<CS::Variable>]
-) -> Result<Vec<Boolean<CS::Variable>>, SynthesisError>
+    input: &[Boolean]
+) -> Result<Vec<Boolean>, SynthesisError>
 {
     assert!(input.len() % 8 == 0);
 
@@ -269,7 +269,7 @@ pub fn blake2s<E: Engine, CS: ConstraintSystem<E>>(
     h.push(UInt32::constant(0x1F83D9AB));
     h.push(UInt32::constant(0x5BE0CD19));
 
-    let mut blocks: Vec<Vec<UInt32<CS::Variable>>> = vec![];
+    let mut blocks: Vec<Vec<UInt32>> = vec![];
 
     for block in input.chunks(512) {
         let mut this_block = Vec::with_capacity(16);
diff --git a/src/circuit/boolean.rs b/src/circuit/boolean.rs
index 919acbbdc..4d1c358a2 100644
--- a/src/circuit/boolean.rs
+++ b/src/circuit/boolean.rs
@@ -9,7 +9,8 @@ use pairing::{
 use bellman::{
     ConstraintSystem,
     SynthesisError,
-    LinearCombination
+    LinearCombination,
+    Variable
 };
 
 use super::{
@@ -19,17 +20,17 @@ use super::{
 /// Represents a variable in the constraint system which is guaranteed
 /// to be either zero or one.
 #[derive(Clone)]
-pub struct AllocatedBit<Var> {
-    variable: Var,
+pub struct AllocatedBit {
+    variable: Variable,
     value: Option<bool>
 }
 
-impl<Var: Copy> AllocatedBit<Var> {
+impl AllocatedBit {
     pub fn get_value(&self) -> Option<bool> {
         self.value
     }
 
-    pub fn get_variable(&self) -> Var {
+    pub fn get_variable(&self) -> Variable {
         self.variable
     }
 
@@ -40,7 +41,7 @@ impl<Var: Copy> AllocatedBit<Var> {
         value: Option<bool>,
     ) -> Result<Self, SynthesisError>
         where E: Engine,
-              CS: ConstraintSystem<E, Variable=Var>
+              CS: ConstraintSystem<E>
     {
         let var = cs.alloc(|| "boolean", || {
             if *value.get()? {
@@ -52,10 +53,9 @@ impl<Var: Copy> AllocatedBit<Var> {
 
         // Constrain: (1 - a) * a = 0
         // This constrains a to be either 0 or 1.
-        let one = cs.one();
         cs.enforce(
             || "boolean constraint",
-            |lc| lc + one - var,
+            |lc| lc + CS::one() - var,
             |lc| lc + var,
             |lc| lc
         );
@@ -74,7 +74,7 @@ impl<Var: Copy> AllocatedBit<Var> {
         b: &Self
     ) -> Result<Self, SynthesisError>
         where E: Engine,
-              CS: ConstraintSystem<E, Variable=Var>
+              CS: ConstraintSystem<E>
     {
         let mut result_value = None;
 
@@ -126,7 +126,7 @@ impl<Var: Copy> AllocatedBit<Var> {
         b: &Self
     ) -> Result<Self, SynthesisError>
         where E: Engine,
-              CS: ConstraintSystem<E, Variable=Var>
+              CS: ConstraintSystem<E>
     {
         let mut result_value = None;
 
@@ -164,7 +164,7 @@ impl<Var: Copy> AllocatedBit<Var> {
         b: &Self
     ) -> Result<Self, SynthesisError>
         where E: Engine,
-              CS: ConstraintSystem<E, Variable=Var>
+              CS: ConstraintSystem<E>
     {
         let mut result_value = None;
 
@@ -182,11 +182,10 @@ impl<Var: Copy> AllocatedBit<Var> {
 
         // Constrain (a) * (1 - b) = (c), ensuring c is 1 iff
         // a is true and b is false, and otherwise c is 0.
-        let one = cs.one();
         cs.enforce(
             || "and not constraint",
             |lc| lc + a.variable,
-            |lc| lc + one - b.variable,
+            |lc| lc + CS::one() - b.variable,
             |lc| lc + result_var
         );
 
@@ -203,7 +202,7 @@ impl<Var: Copy> AllocatedBit<Var> {
         b: &Self
     ) -> Result<Self, SynthesisError>
         where E: Engine,
-              CS: ConstraintSystem<E, Variable=Var>
+              CS: ConstraintSystem<E>
     {
         let mut result_value = None;
 
@@ -221,11 +220,10 @@ impl<Var: Copy> AllocatedBit<Var> {
 
         // Constrain (1 - a) * (1 - b) = (c), ensuring c is 1 iff
         // a and b are both false, and otherwise c is 0.
-        let one = cs.one();
         cs.enforce(
             || "nor constraint",
-            |lc| lc + one - a.variable,
-            |lc| lc + one - b.variable,
+            |lc| lc + CS::one() - a.variable,
+            |lc| lc + CS::one() - b.variable,
             |lc| lc + result_var
         );
 
@@ -239,23 +237,23 @@ impl<Var: Copy> AllocatedBit<Var> {
 /// This is a boolean value which may be either a constant or
 /// an interpretation of an `AllocatedBit`.
 #[derive(Clone)]
-pub enum Boolean<Var> {
+pub enum Boolean {
     /// Existential view of the boolean variable
-    Is(AllocatedBit<Var>),
+    Is(AllocatedBit),
     /// Negated view of the boolean variable
-    Not(AllocatedBit<Var>),
+    Not(AllocatedBit),
     /// Constant (not an allocated variable)
     Constant(bool)
 }
 
-impl<Var: Copy> Boolean<Var> {
+impl Boolean {
     pub fn enforce_equal<E, CS>(
         mut cs: CS,
         a: &Self,
         b: &Self
     ) -> Result<(), SynthesisError>
         where E: Engine,
-              CS: ConstraintSystem<E, Variable=Var>
+              CS: ConstraintSystem<E>
     {
         let c = Self::xor(&mut cs, a, b)?;
 
@@ -270,21 +268,25 @@ impl<Var: Copy> Boolean<Var> {
         }
     }
 
-    pub fn lc<E: Engine>(&self, one: Var, coeff: E::Fr) -> LinearCombination<Var, E>
+    pub fn lc<E: Engine>(
+        &self,
+        one: Variable,
+        coeff: E::Fr
+    ) -> LinearCombination<E>
     {
         match self {
             &Boolean::Constant(c) => {
                 if c {
-                    LinearCombination::<Var, E>::zero() + (coeff, one)
+                    LinearCombination::<E>::zero() + (coeff, one)
                 } else {
-                    LinearCombination::<Var, E>::zero()
+                    LinearCombination::<E>::zero()
                 }
             },
             &Boolean::Is(ref v) => {
-                LinearCombination::<Var, E>::zero() + (coeff, v.get_variable())
+                LinearCombination::<E>::zero() + (coeff, v.get_variable())
             },
             &Boolean::Not(ref v) => {
-                LinearCombination::<Var, E>::zero() + (coeff, one) - (coeff, v.get_variable())
+                LinearCombination::<E>::zero() + (coeff, one) - (coeff, v.get_variable())
             }
         }
     }
@@ -310,7 +312,7 @@ impl<Var: Copy> Boolean<Var> {
         b: &'a Self
     ) -> Result<Self, SynthesisError>
         where E: Engine,
-              CS: ConstraintSystem<E, Variable=Var>
+              CS: ConstraintSystem<E>
     {
         match (a, b) {
             (&Boolean::Constant(false), x) | (x, &Boolean::Constant(false)) => Ok(x.clone()),
@@ -337,7 +339,7 @@ impl<Var: Copy> Boolean<Var> {
         b: &'a Self
     ) -> Result<Self, SynthesisError>
         where E: Engine,
-              CS: ConstraintSystem<E, Variable=Var>
+              CS: ConstraintSystem<E>
     {
         match (a, b) {
             // false AND x is always false
@@ -364,7 +366,7 @@ impl<Var: Copy> Boolean<Var> {
         bits: &[Self]
     ) -> Result<Self, SynthesisError>
         where E: Engine,
-              CS: ConstraintSystem<E, Variable=Var>
+              CS: ConstraintSystem<E>
     {
         assert!(bits.len() > 0);
         let mut bits = bits.iter();
@@ -387,7 +389,7 @@ impl<Var: Copy> Boolean<Var> {
         bits: &[Self]
     ) -> Result<(), SynthesisError>
         where E: Engine,
-              CS: ConstraintSystem<E, Variable=Var>
+              CS: ConstraintSystem<E>
     {
         let res = Self::kary_and(&mut cs, bits)?;
 
@@ -409,12 +411,11 @@ impl<Var: Copy> Boolean<Var> {
                 Ok(())
             },
             Boolean::Not(ref res) => {
-                let one = cs.one();
                 cs.enforce(
                     || "enforce nand",
                     |lc| lc,
                     |lc| lc,
-                    |lc| lc + one - res.get_variable()
+                    |lc| lc + CS::one() - res.get_variable()
                 );
 
                 Ok(())
@@ -429,7 +430,7 @@ impl<Var: Copy> Boolean<Var> {
         bits: &[Self]
     ) -> Result<(), SynthesisError>
         where E: Engine,
-              CS: ConstraintSystem<E, Variable=Var>
+              CS: ConstraintSystem<E>
     {
         assert_eq!(bits.len(), F::NUM_BITS as usize);
 
@@ -440,7 +441,7 @@ impl<Var: Copy> Boolean<Var> {
         b.sub_noborrow(&1.into());
 
         // Runs of ones in r
-        let mut last_run = Boolean::<Var>::constant(true);
+        let mut last_run = Boolean::constant(true);
         let mut current_run = vec![];
 
         let mut found_one = false;
@@ -495,8 +496,8 @@ impl<Var: Copy> Boolean<Var> {
     }
 }
 
-impl<Var> From<AllocatedBit<Var>> for Boolean<Var> {
-    fn from(b: AllocatedBit<Var>) -> Boolean<Var> {
+impl From<AllocatedBit> for Boolean {
+    fn from(b: AllocatedBit) -> Boolean {
         Boolean::Is(b)
     }
 }
diff --git a/src/circuit/lookup.rs b/src/circuit/lookup.rs
index 77783ba3f..e433cd087 100644
--- a/src/circuit/lookup.rs
+++ b/src/circuit/lookup.rs
@@ -31,12 +31,12 @@ fn synth<'a, E: Engine, I>(
 
 /// Performs a 3-bit window table lookup. `bits` is in
 /// little-endian order.
-pub fn lookup3_xy<E: Engine, CS, Var: Copy>(
+pub fn lookup3_xy<E: Engine, CS>(
     mut cs: CS,
-    bits: &[Boolean<Var>],
+    bits: &[Boolean],
     coords: &[(E::Fr, E::Fr)]
-) -> Result<(AllocatedNum<E, Var>, AllocatedNum<E, Var>), SynthesisError>
-    where CS: ConstraintSystem<E, Variable=Var>
+) -> Result<(AllocatedNum<E>, AllocatedNum<E>), SynthesisError>
+    where CS: ConstraintSystem<E>
 {
     assert_eq!(bits.len(), 3);
     assert_eq!(coords.len(), 8);
@@ -84,7 +84,7 @@ pub fn lookup3_xy<E: Engine, CS, Var: Copy>(
 
     let precomp = Boolean::and(cs.namespace(|| "precomp"), &bits[1], &bits[2])?;
 
-    let one = cs.one();
+    let one = CS::one();
 
     cs.enforce(
         || "x-coordinate lookup",
@@ -119,12 +119,12 @@ pub fn lookup3_xy<E: Engine, CS, Var: Copy>(
 
 /// Performs a 3-bit window table lookup, where
 /// one of the bits is a sign bit.
-pub fn lookup3_xy_with_conditional_negation<E: Engine, CS, Var: Copy>(
+pub fn lookup3_xy_with_conditional_negation<E: Engine, CS>(
     mut cs: CS,
-    bits: &[Boolean<Var>],
+    bits: &[Boolean],
     coords: &[(E::Fr, E::Fr)]
-) -> Result<(AllocatedNum<E, Var>, AllocatedNum<E, Var>), SynthesisError>
-    where CS: ConstraintSystem<E, Variable=Var>
+) -> Result<(AllocatedNum<E>, AllocatedNum<E>), SynthesisError>
+    where CS: ConstraintSystem<E>
 {
     assert_eq!(bits.len(), 3);
     assert_eq!(coords.len(), 4);
@@ -161,7 +161,7 @@ pub fn lookup3_xy_with_conditional_negation<E: Engine, CS, Var: Copy>(
         }
     )?;
 
-    let one = cs.one();
+    let one = CS::one();
 
     // Compute the coefficients for the lookup constraints
     let mut x_coeffs = [E::Fr::zero(); 4];
@@ -289,7 +289,7 @@ mod test {
 
         let window_size = 4;
 
-        let mut assignment = vec![Fr::zero(); (1 << window_size)];
+        let mut assignment = vec![Fr::zero(); 1 << window_size];
         let constants: Vec<_> = (0..(1 << window_size)).map(|_| Fr::rand(&mut rng)).collect();
 
         synth::<Bls12, _>(window_size, &constants, &mut assignment);
diff --git a/src/circuit/mod.rs b/src/circuit/mod.rs
index c36148704..45de18fd0 100644
--- a/src/circuit/mod.rs
+++ b/src/circuit/mod.rs
@@ -5,8 +5,8 @@ pub mod boolean;
 pub mod uint32;
 pub mod blake2s;
 pub mod num;
-pub mod mont;
 pub mod lookup;
+pub mod mont;
 pub mod pedersen_hash;
 
 use bellman::SynthesisError;
diff --git a/src/circuit/mont.rs b/src/circuit/mont.rs
index 85fa49531..81a2fcbee 100644
--- a/src/circuit/mont.rs
+++ b/src/circuit/mont.rs
@@ -26,12 +26,12 @@ use super::lookup::{
 
 use super::boolean::Boolean;
 
-pub struct EdwardsPoint<E: Engine, Var> {
-    pub x: AllocatedNum<E, Var>,
-    pub y: AllocatedNum<E, Var>
+pub struct EdwardsPoint<E: Engine> {
+    pub x: AllocatedNum<E>,
+    pub y: AllocatedNum<E>
 }
 
-impl<E: Engine, Var: Copy> Clone for EdwardsPoint<E, Var> {
+impl<E: Engine> Clone for EdwardsPoint<E> {
     fn clone(&self) -> Self {
         EdwardsPoint {
             x: self.x.clone(),
@@ -43,15 +43,14 @@ impl<E: Engine, Var: Copy> Clone for EdwardsPoint<E, Var> {
 /// Perform a fixed-base scalar multiplication with
 /// `by` being in little-endian bit order. `by` must
 /// be a multiple of 3.
-pub fn fixed_base_multiplication<E, Var, CS>(
+pub fn fixed_base_multiplication<E, CS>(
     mut cs: CS,
     base: FixedGenerators,
-    by: &[Boolean<Var>],
+    by: &[Boolean],
     params: &E::Params
-) -> Result<EdwardsPoint<E, Var>, SynthesisError>
-    where CS: ConstraintSystem<E, Variable=Var>,
-          E: JubjubEngine,
-          Var: Copy
+) -> Result<EdwardsPoint<E>, SynthesisError>
+    where CS: ConstraintSystem<E>,
+          E: JubjubEngine
 {
     // We're going to chunk the scalar into 3-bit windows,
     // so let's force the caller to supply the right number
@@ -90,10 +89,10 @@ pub fn fixed_base_multiplication<E, Var, CS>(
     Ok(result.get()?.clone())
 }
 
-impl<E: JubjubEngine, Var: Copy> EdwardsPoint<E, Var> {
+impl<E: JubjubEngine> EdwardsPoint<E> {
     /// This extracts the x-coordinate, which is an injective
     /// encoding for elements of the prime order subgroup.
-    pub fn into_num(&self) -> AllocatedNum<E, Var> {
+    pub fn into_num(&self) -> AllocatedNum<E> {
         self.x.clone()
     }
 
@@ -102,9 +101,9 @@ impl<E: JubjubEngine, Var: Copy> EdwardsPoint<E, Var> {
     pub fn conditionally_select<CS>(
         &self,
         mut cs: CS,
-        condition: &Boolean<Var>
+        condition: &Boolean
     ) -> Result<Self, SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+        where CS: ConstraintSystem<E>
     {
         // Compute x' = self.x if condition, and 0 otherwise
         let x_prime = AllocatedNum::alloc(cs.namespace(|| "x'"), || {
@@ -118,7 +117,7 @@ impl<E: JubjubEngine, Var: Copy> EdwardsPoint<E, Var> {
         // condition * x = x'
         // if condition is 0, x' must be 0
         // if condition is 1, x' must be x
-        let one = cs.one();
+        let one = CS::one();
         cs.enforce(
             || "x' computation",
             |lc| lc + self.x.get_variable(),
@@ -158,10 +157,10 @@ impl<E: JubjubEngine, Var: Copy> EdwardsPoint<E, Var> {
     pub fn mul<CS>(
         &self,
         mut cs: CS,
-        by: &[Boolean<Var>],
+        by: &[Boolean],
         params: &E::Params
     ) -> Result<Self, SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+        where CS: ConstraintSystem<E>
     {
         // Represents the current "magnitude" of the base
         // that we're operating over. Starts at self,
@@ -209,11 +208,11 @@ impl<E: JubjubEngine, Var: Copy> EdwardsPoint<E, Var> {
 
     pub fn interpret<CS>(
         mut cs: CS,
-        x: &AllocatedNum<E, Var>,
-        y: &AllocatedNum<E, Var>,
+        x: &AllocatedNum<E>,
+        y: &AllocatedNum<E>,
         params: &E::Params
     ) -> Result<Self, SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+        where CS: ConstraintSystem<E>
     {
         // -x^2 + y^2 = 1 + dx^2y^2
 
@@ -221,7 +220,7 @@ impl<E: JubjubEngine, Var: Copy> EdwardsPoint<E, Var> {
         let y2 = y.square(cs.namespace(|| "y^2"))?;
         let x2y2 = x2.mul(cs.namespace(|| "x^2 y^2"), &y2)?;
 
-        let one = cs.one();
+        let one = CS::one();
         cs.enforce(
             || "on curve check",
             |lc| lc - x2.get_variable()
@@ -242,7 +241,7 @@ impl<E: JubjubEngine, Var: Copy> EdwardsPoint<E, Var> {
         cs: CS,
         params: &E::Params
     ) -> Result<Self, SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+        where CS: ConstraintSystem<E>
     {
         self.add(cs, self, params)
     }
@@ -254,7 +253,7 @@ impl<E: JubjubEngine, Var: Copy> EdwardsPoint<E, Var> {
         other: &Self,
         params: &E::Params
     ) -> Result<Self, SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+        where CS: ConstraintSystem<E>
     {
         // Compute U = (x1 + y1) * (x2 + y2)
         let u = AllocatedNum::alloc(cs.namespace(|| "U"), || {
@@ -320,7 +319,7 @@ impl<E: JubjubEngine, Var: Copy> EdwardsPoint<E, Var> {
             }
         })?;
 
-        let one = cs.one();
+        let one = CS::one();
         cs.enforce(
             || "x3 computation",
             |lc| lc + one + c.get_variable(),
@@ -366,12 +365,12 @@ impl<E: JubjubEngine, Var: Copy> EdwardsPoint<E, Var> {
     }
 }
 
-pub struct MontgomeryPoint<E: Engine, Var> {
-    x: AllocatedNum<E, Var>,
-    y: AllocatedNum<E, Var>
+pub struct MontgomeryPoint<E: Engine> {
+    x: AllocatedNum<E>,
+    y: AllocatedNum<E>
 }
 
-impl<E: JubjubEngine, Var: Copy> MontgomeryPoint<E, Var> {
+impl<E: JubjubEngine> MontgomeryPoint<E> {
     /// Converts an element in the prime order subgroup into
     /// a point in the birationally equivalent twisted
     /// Edwards curve.
@@ -379,8 +378,8 @@ impl<E: JubjubEngine, Var: Copy> MontgomeryPoint<E, Var> {
         &self,
         mut cs: CS,
         params: &E::Params
-    ) -> Result<EdwardsPoint<E, Var>, SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+    ) -> Result<EdwardsPoint<E>, SynthesisError>
+        where CS: ConstraintSystem<E>
     {
         // Compute u = (scale*x) / y
         let u = AllocatedNum::alloc(cs.namespace(|| "u"), || {
@@ -425,7 +424,7 @@ impl<E: JubjubEngine, Var: Copy> MontgomeryPoint<E, Var> {
             }
         })?;
 
-        let one = cs.one();
+        let one = CS::one();
         cs.enforce(
             || "v computation",
             |lc| lc + self.x.get_variable()
@@ -446,8 +445,8 @@ impl<E: JubjubEngine, Var: Copy> MontgomeryPoint<E, Var> {
     /// on the curve. Useful for constants and
     /// window table lookups.
     pub fn interpret_unchecked(
-        x: AllocatedNum<E, Var>,
-        y: AllocatedNum<E, Var>
+        x: AllocatedNum<E>,
+        y: AllocatedNum<E>
     ) -> Self
     {
         MontgomeryPoint {
@@ -464,7 +463,7 @@ impl<E: JubjubEngine, Var: Copy> MontgomeryPoint<E, Var> {
         other: &Self,
         params: &E::Params
     ) -> Result<Self, SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+        where CS: ConstraintSystem<E>
     {
         // Compute lambda = (y' - y) / (x' - x)
         let lambda = AllocatedNum::alloc(cs.namespace(|| "lambda"), || {
@@ -508,7 +507,7 @@ impl<E: JubjubEngine, Var: Copy> MontgomeryPoint<E, Var> {
         })?;
 
         // (lambda) * (lambda) = (A + x + x' + x'')
-        let one = cs.one();
+        let one = CS::one();
         cs.enforce(
             || "evaluate xprime",
             |lc| lc + lambda.get_variable(),
@@ -555,7 +554,7 @@ impl<E: JubjubEngine, Var: Copy> MontgomeryPoint<E, Var> {
         mut cs: CS,
         params: &E::Params
     ) -> Result<Self, SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+        where CS: ConstraintSystem<E>
     {
         // Square x
         let xx = self.x.square(&mut cs)?;
@@ -585,7 +584,7 @@ impl<E: JubjubEngine, Var: Copy> MontgomeryPoint<E, Var> {
         })?;
 
         // (2.y) * (lambda) = (3.xx + 2.A.x + 1)
-        let one = cs.one();
+        let one = CS::one();
         cs.enforce(
             || "evaluate lambda",
             |lc| lc + self.y.get_variable()
diff --git a/src/circuit/num.rs b/src/circuit/num.rs
index f0255aa39..aca756276 100644
--- a/src/circuit/num.rs
+++ b/src/circuit/num.rs
@@ -8,7 +8,8 @@ use pairing::{
 use bellman::{
     SynthesisError,
     ConstraintSystem,
-    LinearCombination
+    LinearCombination,
+    Variable
 };
 
 use super::{
@@ -20,12 +21,12 @@ use super::boolean::{
    AllocatedBit
 };
 
-pub struct AllocatedNum<E: Engine, Var> {
+pub struct AllocatedNum<E: Engine> {
     value: Option<E::Fr>,
-    variable: Var
+    variable: Variable
 }
 
-impl<Var: Copy, E: Engine> Clone for AllocatedNum<E, Var> {
+impl<E: Engine> Clone for AllocatedNum<E> {
     fn clone(&self) -> Self {
         AllocatedNum {
             value: self.value,
@@ -34,12 +35,12 @@ impl<Var: Copy, E: Engine> Clone for AllocatedNum<E, Var> {
     }
 }
 
-impl<E: Engine, Var: Copy> AllocatedNum<E, Var> {
+impl<E: Engine> AllocatedNum<E> {
     pub fn alloc<CS, F>(
         mut cs: CS,
         value: F,
     ) -> Result<Self, SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>,
+        where CS: ConstraintSystem<E>,
               F: FnOnce() -> Result<E::Fr, SynthesisError>
     {
         let mut new_value = None;
@@ -60,8 +61,8 @@ impl<E: Engine, Var: Copy> AllocatedNum<E, Var> {
     pub fn into_bits_strict<CS>(
         &self,
         mut cs: CS
-    ) -> Result<Vec<Boolean<Var>>, SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+    ) -> Result<Vec<Boolean>, SynthesisError>
+        where CS: ConstraintSystem<E>
     {
         let bits = self.into_bits(&mut cs)?;
         Boolean::enforce_in_field::<_, _, E::Fr>(&mut cs, &bits)?;
@@ -72,8 +73,8 @@ impl<E: Engine, Var: Copy> AllocatedNum<E, Var> {
     pub fn into_bits<CS>(
         &self,
         mut cs: CS
-    ) -> Result<Vec<Boolean<Var>>, SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+    ) -> Result<Vec<Boolean>, SynthesisError>
+        where CS: ConstraintSystem<E>
     {
         let bit_values = match self.value {
             Some(value) => {
@@ -132,16 +133,16 @@ impl<E: Engine, Var: Copy> AllocatedNum<E, Var> {
 
     pub fn from_bits_strict<CS>(
         mut cs: CS,
-        bits: &[Boolean<Var>]
+        bits: &[Boolean]
     ) -> Result<Self, SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+        where CS: ConstraintSystem<E>
     {
         assert_eq!(bits.len(), E::Fr::NUM_BITS as usize);
 
         Boolean::enforce_in_field::<_, _, E::Fr>(&mut cs, bits)?;
 
-        let one = cs.one();
-        let mut lc = LinearCombination::<Var, E>::zero();
+        let one = CS::one();
+        let mut lc = LinearCombination::<E>::zero();
         let mut coeff = E::Fr::one();
         let mut value = Some(E::Fr::zero());
         for bit in bits.iter().rev() {
@@ -204,7 +205,7 @@ impl<E: Engine, Var: Copy> AllocatedNum<E, Var> {
         mut cs: CS,
         other: &Self
     ) -> Result<Self, SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+        where CS: ConstraintSystem<E>
     {
         let mut value = None;
 
@@ -235,7 +236,7 @@ impl<E: Engine, Var: Copy> AllocatedNum<E, Var> {
         &self,
         mut cs: CS
     ) -> Result<Self, SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+        where CS: ConstraintSystem<E>
     {
         let mut value = None;
 
@@ -266,7 +267,7 @@ impl<E: Engine, Var: Copy> AllocatedNum<E, Var> {
         &self,
         mut cs: CS
     ) -> Result<(), SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+        where CS: ConstraintSystem<E>
     {
         let inv = cs.alloc(|| "ephemeral inverse", || {
             let tmp = *self.value.get()?;
@@ -281,12 +282,11 @@ impl<E: Engine, Var: Copy> AllocatedNum<E, Var> {
         // Constrain a * inv = 1, which is only valid
         // iff a has a multiplicative inverse, untrue
         // for zero.
-        let one = cs.one();
         cs.enforce(
             || "nonzero assertion constraint",
             |lc| lc + self.variable,
             |lc| lc + inv,
-            |lc| lc + one
+            |lc| lc + CS::one()
         );
 
         Ok(())
@@ -299,9 +299,9 @@ impl<E: Engine, Var: Copy> AllocatedNum<E, Var> {
         mut cs: CS,
         a: &Self,
         b: &Self,
-        condition: &Boolean<Var>
+        condition: &Boolean
     ) -> Result<(Self, Self), SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+        where CS: ConstraintSystem<E>
     {
         let c = Self::alloc(
             cs.namespace(|| "conditional reversal result 1"),
@@ -314,11 +314,10 @@ impl<E: Engine, Var: Copy> AllocatedNum<E, Var> {
             }
         )?;
 
-        let one = cs.one();
         cs.enforce(
             || "first conditional reversal",
             |lc| lc + a.variable - b.variable,
-            |_| condition.lc(one, E::Fr::one()),
+            |_| condition.lc(CS::one(), E::Fr::one()),
             |lc| lc + a.variable - c.variable
         );
 
@@ -336,7 +335,7 @@ impl<E: Engine, Var: Copy> AllocatedNum<E, Var> {
         cs.enforce(
             || "second conditional reversal",
             |lc| lc + b.variable - a.variable,
-            |_| condition.lc(one, E::Fr::one()),
+            |_| condition.lc(CS::one(), E::Fr::one()),
             |lc| lc + b.variable - d.variable
         );
 
@@ -346,9 +345,9 @@ impl<E: Engine, Var: Copy> AllocatedNum<E, Var> {
     pub fn conditionally_negate<CS>(
         &self,
         mut cs: CS,
-        condition: &Boolean<Var>
+        condition: &Boolean
     ) -> Result<Self, SynthesisError>
-        where CS: ConstraintSystem<E, Variable=Var>
+        where CS: ConstraintSystem<E>
     {
         let r = Self::alloc(
             cs.namespace(|| "conditional negation result"),
@@ -365,11 +364,10 @@ impl<E: Engine, Var: Copy> AllocatedNum<E, Var> {
         // x - 2cx = r
         // (2x) * (c) = x - r
 
-        let one = cs.one();
         cs.enforce(
             || "conditional negation",
             |lc| lc + self.variable + self.variable,
-            |_| condition.lc(one, E::Fr::one()),
+            |_| condition.lc(CS::one(), E::Fr::one()),
             |lc| lc + self.variable - r.variable
         );
 
@@ -380,7 +378,7 @@ impl<E: Engine, Var: Copy> AllocatedNum<E, Var> {
         self.value
     }
 
-    pub fn get_variable(&self) -> Var {
+    pub fn get_variable(&self) -> Variable {
         self.variable
     }
 }
diff --git a/src/circuit/pedersen_hash.rs b/src/circuit/pedersen_hash.rs
index ee940a382..a405b7a45 100644
--- a/src/circuit/pedersen_hash.rs
+++ b/src/circuit/pedersen_hash.rs
@@ -10,12 +10,12 @@ use bellman::{
 };
 use super::lookup::*;
 
-pub fn pedersen_hash<E: JubjubEngine, CS, Var: Copy>(
+pub fn pedersen_hash<E: JubjubEngine, CS>(
     mut cs: CS,
-    bits: &[Boolean<Var>],
+    bits: &[Boolean],
     params: &E::Params
-) -> Result<EdwardsPoint<E, Var>, SynthesisError>
-    where CS: ConstraintSystem<E, Variable=Var>
+) -> Result<EdwardsPoint<E>, SynthesisError>
+    where CS: ConstraintSystem<E>
 {
     // Unnecessary if forced personalization is introduced
     assert!(bits.len() > 0);
@@ -116,7 +116,7 @@ mod test {
 
         let input: Vec<bool> = (0..(Fr::NUM_BITS * 2)).map(|_| rng.gen()).collect();
 
-        let input_bools: Vec<Boolean<_>> = input.iter().enumerate().map(|(i, b)| {
+        let input_bools: Vec<Boolean> = input.iter().enumerate().map(|(i, b)| {
             Boolean::from(
                 AllocatedBit::alloc(cs.namespace(|| format!("input {}", i)), Some(*b)).unwrap()
             )
@@ -143,7 +143,7 @@ mod test {
 
                 let mut cs = TestConstraintSystem::<Bls12>::new();
 
-                let input_bools: Vec<Boolean<_>> = input.iter().enumerate().map(|(i, b)| {
+                let input_bools: Vec<Boolean> = input.iter().enumerate().map(|(i, b)| {
                     Boolean::from(
                         AllocatedBit::alloc(cs.namespace(|| format!("input {}", i)), Some(*b)).unwrap()
                     )
diff --git a/src/circuit/test/mod.rs b/src/circuit/test/mod.rs
index 8e12ff713..ef042fe62 100644
--- a/src/circuit/test/mod.rs
+++ b/src/circuit/test/mod.rs
@@ -6,17 +6,13 @@ use pairing::{
 use bellman::{
     LinearCombination,
     SynthesisError,
-    ConstraintSystem
+    ConstraintSystem,
+    Variable,
+    Index
 };
 
 use std::collections::HashMap;
 
-#[derive(Debug, Copy, Clone)]
-pub enum Variable {
-    Input(usize),
-    Aux(usize)
-}
-
 #[derive(Debug)]
 enum NamedObject {
     Constraint(usize),
@@ -28,7 +24,12 @@ enum NamedObject {
 pub struct TestConstraintSystem<E: Engine> {
     named_objects: HashMap<String, NamedObject>,
     current_namespace: Vec<String>,
-    constraints: Vec<(LinearCombination<Variable, E>, LinearCombination<Variable, E>, LinearCombination<Variable, E>, String)>,
+    constraints: Vec<(
+        LinearCombination<E>,
+        LinearCombination<E>,
+        LinearCombination<E>,
+        String
+    )>,
     inputs: Vec<(E::Fr, String)>,
     aux: Vec<(E::Fr, String)>
 }
@@ -42,9 +43,9 @@ fn eval_lc<E: Engine>(
     let mut acc = E::Fr::zero();
 
     for &(var, ref coeff) in terms {
-        let mut tmp = match var {
-            Variable::Input(index) => inputs[index].0,
-            Variable::Aux(index) => aux[index].0
+        let mut tmp = match var.get_unchecked() {
+            Index::Input(index) => inputs[index].0,
+            Index::Aux(index) => aux[index].0
         };
 
         tmp.mul_assign(&coeff);
@@ -57,7 +58,7 @@ fn eval_lc<E: Engine>(
 impl<E: Engine> TestConstraintSystem<E> {
     pub fn new() -> TestConstraintSystem<E> {
         let mut map = HashMap::new();
-        map.insert("ONE".into(), NamedObject::Var(Variable::Input(0)));
+        map.insert("ONE".into(), NamedObject::Var(TestConstraintSystem::<E>::one()));
 
         TestConstraintSystem {
             named_objects: map,
@@ -97,8 +98,12 @@ impl<E: Engine> TestConstraintSystem<E> {
     pub fn set(&mut self, path: &str, to: E::Fr)
     {
         match self.named_objects.get(path) {
-            Some(&NamedObject::Var(Variable::Input(index))) => self.inputs[index].0 = to,
-            Some(&NamedObject::Var(Variable::Aux(index))) => self.aux[index].0 = to,
+            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)
         }
@@ -107,8 +112,12 @@ impl<E: Engine> TestConstraintSystem<E> {
     pub fn get(&mut self, path: &str) -> E::Fr
     {
         match self.named_objects.get(path) {
-            Some(&NamedObject::Var(Variable::Input(index))) => self.inputs[index].0,
-            Some(&NamedObject::Var(Variable::Aux(index))) => self.aux[index].0,
+            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)
         }
@@ -145,24 +154,35 @@ fn compute_path(ns: &[String], this: String) -> String {
 }
 
 impl<E: Engine> ConstraintSystem<E> for TestConstraintSystem<E> {
-    type Variable = Variable;
     type Root = Self;
 
-    fn one(&self) -> Self::Variable {
-        Variable::Input(0)
-    }
-
     fn alloc<F, A, AR>(
         &mut self,
         annotation: A,
         f: F
-    ) -> Result<Self::Variable, SynthesisError>
+    ) -> Result<Variable, SynthesisError>
         where F: FnOnce() -> Result<E::Fr, 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::Aux(index);
+        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<E::Fr, 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)
@@ -176,9 +196,9 @@ impl<E: Engine> ConstraintSystem<E> for TestConstraintSystem<E> {
         c: LC
     )
         where A: FnOnce() -> AR, AR: Into<String>,
-              LA: FnOnce(LinearCombination<Self::Variable, E>) -> LinearCombination<Self::Variable, E>,
-              LB: FnOnce(LinearCombination<Self::Variable, E>) -> LinearCombination<Self::Variable, E>,
-              LC: FnOnce(LinearCombination<Self::Variable, E>) -> LinearCombination<Self::Variable, E>
+              LA: FnOnce(LinearCombination<E>) -> LinearCombination<E>,
+              LB: FnOnce(LinearCombination<E>) -> LinearCombination<E>,
+              LC: FnOnce(LinearCombination<E>) -> LinearCombination<E>
     {
         let path = compute_path(&self.current_namespace, annotation().into());
         let index = self.constraints.len();
@@ -234,7 +254,7 @@ fn test_cs() {
 
     cs.set("a/var", Fr::from_str("4").unwrap());
 
-    let one = cs.one();
+    let one = TestConstraintSystem::<Bls12>::one();
     cs.enforce(
         || "eq",
         |lc| lc + a,
diff --git a/src/circuit/uint32.rs b/src/circuit/uint32.rs
index fc24a269d..ff3943377 100644
--- a/src/circuit/uint32.rs
+++ b/src/circuit/uint32.rs
@@ -18,13 +18,13 @@ use super::boolean::{
 /// Represents an interpretation of 32 `Boolean` objects as an
 /// unsigned integer.
 #[derive(Clone)]
-pub struct UInt32<Var> {
+pub struct UInt32 {
     // Least significant bit first
-    bits: Vec<Boolean<Var>>,
+    bits: Vec<Boolean>,
     value: Option<u32>
 }
 
-impl<Var: Copy> UInt32<Var> {
+impl UInt32 {
     /// Construct a constant `UInt32` from a `u32`
     pub fn constant(value: u32) -> Self
     {
@@ -53,7 +53,7 @@ impl<Var: Copy> UInt32<Var> {
         value: Option<u32>
     ) -> Result<Self, SynthesisError>
         where E: Engine,
-              CS: ConstraintSystem<E, Variable=Var>
+              CS: ConstraintSystem<E>
     {
         let values = match value {
             Some(mut val) => {
@@ -72,7 +72,10 @@ impl<Var: Copy> UInt32<Var> {
         let bits = values.into_iter()
                          .enumerate()
                          .map(|(i, v)| {
-                            Ok(Boolean::from(AllocatedBit::alloc(cs.namespace(|| format!("allocated bit {}", i)), v)?))
+                            Ok(Boolean::from(AllocatedBit::alloc(
+                                cs.namespace(|| format!("allocated bit {}", i)),
+                                v
+                            )?))
                          })
                          .collect::<Result<Vec<_>, SynthesisError>>()?;
 
@@ -83,7 +86,7 @@ impl<Var: Copy> UInt32<Var> {
     }
 
     /// Turns this `UInt32` into its little-endian byte order representation.
-    pub fn into_bits(&self) -> Vec<Boolean<Var>> {
+    pub fn into_bits(&self) -> Vec<Boolean> {
         self.bits.chunks(8)
                  .flat_map(|v| v.iter().rev())
                  .cloned()
@@ -92,7 +95,7 @@ impl<Var: Copy> UInt32<Var> {
 
     /// Converts a little-endian byte order representation of bits into a
     /// `UInt32`.
-    pub fn from_bits(bits: &[Boolean<Var>]) -> Self
+    pub fn from_bits(bits: &[Boolean]) -> Self
     {
         assert_eq!(bits.len(), 32);
 
@@ -157,7 +160,7 @@ impl<Var: Copy> UInt32<Var> {
         other: &Self
     ) -> Result<Self, SynthesisError>
         where E: Engine,
-              CS: ConstraintSystem<E, Variable=Var>
+              CS: ConstraintSystem<E>
     {
         let new_value = match (self.value, other.value) {
             (Some(a), Some(b)) => {
@@ -170,7 +173,11 @@ impl<Var: Copy> UInt32<Var> {
                             .zip(other.bits.iter())
                             .enumerate()
                             .map(|(i, (a, b))| {
-                                Boolean::xor(cs.namespace(|| format!("xor of bit {}", i)), a, b)
+                                Boolean::xor(
+                                    cs.namespace(|| format!("xor of bit {}", i)),
+                                    a,
+                                    b
+                                )
                             })
                             .collect::<Result<_, _>>()?;
 
@@ -186,7 +193,7 @@ impl<Var: Copy> UInt32<Var> {
         operands: &[Self]
     ) -> Result<Self, SynthesisError>
         where E: Engine,
-              CS: ConstraintSystem<E, Variable=Var>
+              CS: ConstraintSystem<E>
     {
         // Make some arbitrary bounds for ourselves to avoid overflows
         // in the scalar field
@@ -235,11 +242,11 @@ impl<Var: Copy> UInt32<Var> {
                         all_constants = false;
 
                         // Add coeff * (1 - bit) = coeff * ONE - coeff * bit
-                        lc = lc + (coeff, cs.one()) - (coeff, bit.get_variable());
+                        lc = lc + (coeff, CS::one()) - (coeff, bit.get_variable());
                     },
                     &Boolean::Constant(bit) => {
                         if bit {
-                            lc = lc + (coeff, cs.one());
+                            lc = lc + (coeff, CS::one());
                         }
                     }
                 }
@@ -266,7 +273,10 @@ impl<Var: Copy> UInt32<Var> {
         let mut i = 0;
         while max_value != 0 {
             // Allocate the bit
-            let b = AllocatedBit::alloc(cs.namespace(|| format!("result bit {}", i)), result_value.map(|v| (v >> i) & 1 == 1))?;
+            let b = AllocatedBit::alloc(
+                cs.namespace(|| format!("result bit {}", i)),
+                result_value.map(|v| (v >> i) & 1 == 1)
+            )?;
 
             // Subtract this bit from the linear combination to ensure the sums balance out
             lc = lc - (coeff, b.get_variable());
@@ -311,7 +321,7 @@ mod test {
         let mut rng = XorShiftRng::from_seed([0x5dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0653]);
 
         for _ in 0..1000 {
-            let mut v = (0..32).map(|_| Boolean::<()>::constant(rng.gen())).collect::<Vec<_>>();
+            let mut v = (0..32).map(|_| Boolean::constant(rng.gen())).collect::<Vec<_>>();
 
             let b = UInt32::from_bits(&v);
 
@@ -473,7 +483,7 @@ mod test {
 
         let mut num = rng.gen();
 
-        let a = UInt32::<()>::constant(num);
+        let a = UInt32::constant(num);
 
         for i in 0..32 {
             let b = a.rotr(i);