 # Multiplication gate on a vector

Hi,
I was curious how does one implement a multiplication gate between two vectors? Here what I mean is suppose one has
(1,2,3,4)*(1,0,0,1) = (1,0,0,4)
Any idea as to how I can do that?

Same as for any other type, which is to say, by providing an `impl std::ops::Add for MyMathVector`.

So you are saying, I can use something like, `std::ops::MulAssign` ?

The thing is, I kind of need to use the function `mul` from bellman/num.rs at main · zkcrypto/bellman · GitHub

I just don't understand the way to write it, I am getting quite a few errors.

Any help will be great.

What errors are you getting from what code?

1 Like

Hi, sorry for being so late.
But here is the code I am trying to implement.

``````fn multiply<Scalar: PrimeField, CS: ConstraintSystem<Scalar>>(
mut cs: CS,
a: &[Boolean], r: &[Boolean]
) -> Result<Vec<Boolean>, SynthesisError> {
// Flip endianness of each input byte
let input_1: Vec<_> = a
.chunks(8)
.map(|c| c.iter().rev())
.flatten()
.cloned()
.collect();
let input_2: Vec<_> = r
.chunks(8)
.map(|c| c.iter().rev())
.flatten()
.cloned()
.collect();
let mid = input_1.iter().zip(input_2)
.map(|(x, y)| &x.mul(&mut cs, &x, &y))
.collect::<Result<Vec<Scalar>, SynthesisError>>()?;

let res = mid.into_iter().enumerate().map(|(i, b)| {AllocatedBit::alloc(cs.namespace(|| format!("a bit {}", i)), b)
})// Convert the AllocatedBits into Booleans
.map(|b| b.map(Boolean::from))
.collect::<Result<Vec<_>, _>>()?;

Ok(res
//Ok(mid
.chunks(8)
.map(|c| c.iter().rev())
.flatten()
.cloned()
.collect())
}

``````

The errors I get are

``````error[E0599]: no method named `mul` found for reference `&Boolean` in the current scope
--> src/main.rs:84:22
|
84 |     .map(|(x, y)| &x.mul(&mut cs, &x, &y))

error[E0308]: mismatched types
--> src/main.rs:87:118
|
66 | fn multiply<Scalar: PrimeField, CS: ConstraintSystem<Scalar>>(
|           ------ this type parameter
...
87 |     let res = mid.into_iter().enumerate().map(|(i, b)| {AllocatedBit::alloc(cs.namespace(|| format!("a bit {}", i)), b)
|                                                                                                                      ^ expected enum `Option`, found type parameter `Scalar`
|
= note:        expected enum `Option<bool>`
found type parameter `Scalar`

error: aborting due to 2 previous errors; 4 warnings emitted

``````

I want to use the public function `mul` in bellman/num.rs at main · zkcrypto/bellman · GitHub to multiply two vectors such that (3,3,3,3)*(0,1,0,1) = (0,3,0,3)

I just don't actually know how exactly I should write it.