pub fn new_u32(&mut self, v: &Variable) -> Vec<Variable>
    where
        F: IsPrimeField,
    {
        let bits: Vec<_> = (0..32).map(|_| self.new_boolean()).collect();
        let mut aux_vars: Vec<Variable> = Vec::new();
        let hint_function = |v: &FE<F>| {
            if v.representative() & 1.into() == 1.into() {
                FE::one()
            } else {
                FE::zero()
            }
        };

        let hint = Some(Hint {
            function: hint_function,
            input: Column::O,
            output: Column::R,
        });
        // t1 := 2 b_0 + b_1
        let t_0 = self.linear_combination(
            &bits[0],
            FE::from(2),
            &bits[1],
            FE::one(),
            FE::zero(),
            hint.clone(),
        );
        aux_vars.push(t_0);
        for bit in bits.iter().take(32).skip(2) {
            // t_i := 2 t_{i-1} + b_i
            let t_i = self.linear_combination(
                aux_vars.last().unwrap(),
                FE::from(2),
                bit,
                FE::one(),
                FE::zero(),
                hint.clone(),
            );
            aux_vars.push(t_i);
        }
        self.assert_eq(v, aux_vars.last().unwrap());
        bits
    }
Returns 32 new variables `[b31, b30,..., b1, b0]` constrained to take either
`0` or `1` values and to represent the binary decomposition
of the representative of the value of `v`:
`v = b0 + b1 * 2 + b2 * 2^2 + ... + b31 * 2^31`.
crates/provers/plonk/src/constraint_system/types.rs