Boolean vectors AND gate


I was curious how does one implement an AND gate between two boolean vectors ? Here what I mean is suppose one has
(0110,1110) and (1111,0000) = (0110,0000)
Any idea as to how I can do that?

Thanks in advance!

It's the & operator - same as in many other languages like for example C++. The trait for it is called BitAnd, if you'd need to use it in generic context.

So I think you'd use that operator on integers and implement it on your boolean vectors - unsure what exactly they will be - using that.

You can do this using the bitwise & operator. For example, if your bits are stored in integer types, you can use it like this:

let a = 0b0110_1110;
let b = 0b1111_0000;

let c = a & b;
assert_eq!(c, 0b0110_0000);

If your boolean or integer values are stored in vectors or arrays, you can iterate over them and apply the & operator to each element:

fn and(a: &[bool], b: &[bool]) -> Vec<bool> {
    // This simple implementation assumes both inputs have the same length.
    assert_eq!(a.len(), b.len());
    a.iter().zip(b).map(|(x, y)| x & y).collect()

Crates like bitvec provide compact boolean vectors that implement BitAnd, so you can use the & operator on them directly.

1 Like

Thanks that helps!

I have used the exact line as you had said.

    mut cs: CS,
    a: &[Boolean], r: &[Boolean]
) -> Result<Vec<Boolean>, SynthesisError> {
    // Flip endianness of each input byte
    let input_1: Vec<_> = a
        .map(|c| c.iter().rev())
    let input_2: Vec<_> = r
        .map(|c| c.iter().rev())

    let mid = input_1.iter().zip(input_2).map(|(x, y)| x & y).collect();

    // Flip endianness of each output byte
        .map(|c| c.iter().rev())

But I still get the error,

error[E0369]: no implementation for `&Boolean & Boolean`
  --> src/
62 |     let mid = input_1.iter().zip(input_2).map(|(x, y)| x & y).collect();
   |                                                        - ^ - Boolean
   |                                                        |
   |                                                        &Boolean

error: aborting due to previous error; 1 warning emitted

For more information about this error, try `rustc --explain E0369`.
error: could not compile `multiply`

I don't understand how exactly can I fix it. Please let me know.

Where is the type Boolean defined?

So Boolean is part of Bellman library,


From the bellman docs we can see that Boolean does not implement the standard BitAnd trait, but it does have its own and() method. Instead of (x & y), you can write:

Boolean::and(cs, x, y).unwrap()

If you want to propagate the error instead of unwrapping, something like this should work:

let mid = input_1.iter().zip(input_2).map(|(x, y)| {
    Boolean::and(cs, x, y)
}).collect::<Result<Vec<Boolean>, SynthesisError>>()?;

Avoid the unwrap by writing

.map(|(x, y)| Boolean::and(cs, x, y)).collect()?;

actually, you probably need to write

.map(|(x, y)| Boolean::and(&mut cs, x, y)).collect()?;
1 Like

Alright I am trying these options, I first wrote Boolean::and but now that I see the syntax you have written, think I was wrong, I will get back in a bit

So below is the piece of code that has stopped giving the error but now I have another problem here.


    let mid = input_1.iter().zip(input_2).map(|(x, y)| Boolean::and(&mut cs, &x, &y)).collect()?;

The error I get is

error[E0282]: type annotations needed
  --> src/
62 |     let mid = input_1.iter().zip(input_2).map(|(x, y)| Boolean::and(&mut cs, &x, &y)).collect()?;
   |         --- consider giving `mid` a type
67 |       Ok(mid
   |          ^^^ cannot infer type
   = note: type must be known at this point

But for this code I am referring to bellman - Rust . But I don't see them here giving a data type, am I missing something ? Please let me know.


Try annotating the .collect() call like this:

let mid = input_1.iter().zip(input_2)
    .map(|(x, y)| Boolean::and(&mut cs, &x, &y))
    .collect::<Result<Vec<Boolean>, SynthesisError>>()?;

Thanks a lot, that works perfectly now, the way I wanted. Just curious as to I still don't understand how is the error fixed ?

Iterator::collect is a generic function defined as:

pub fn collect<B>(self) -> B
    B: FromIterator<Self::Item>, 

which returns B by calling:


but since FromIterator can be implemented for various different types, (such as Vec<T> and String) if rust can't infer the return type, it doesn't know which type from_iter is called on, and so you must declare the type yourself.

// this also works because rust now knows that `B` in `collect::<B>()` == `Result<Vec<Boolean>, SynthesisError>`
let mid: Result<Vec<Boolean>, SynthesisError> = input_1.iter().zip(input_2)
    .map(|(x, y)| Boolean::and(&mut cs, &x, &y))

Thanks I understand