Define `U256` type

[lambdaclass]

Define `U256` type

[GianfrancoBazzani]

Here:
https://github.com/GianfrancoBazzani/lambdaworks/blob/fb61e11a73a326f0807bc8385e28d37eb737b6b3/math/src/unsigned_integer/element.rs#L1464

[ilitteri]

Here: https://github.com/GianfrancoBazzani/lambdaworks/blob/fb61e11a73a326f0807bc8385e28d37eb737b6b3/math/src/unsigned_integer/element.rs#L1464

I think that you've just found a bug. @MauroToscano @ajgara @schouhy take a look when you can and tell me if I'm mistaken.

I think that you should make the PR with the test passing and file an issue related to this so it can be studied later.

[GianfrancoBazzani]

Can i take it?

[ilitteri]

Can i take it?

Sure, we'd love it!

[GianfrancoBazzani]

Hi, thanks! Where should be implemented? in the same math/src/unsigned_integer/element.rs file?

[GianfrancoBazzani]

Hello :), in principle, I have done and tested. I defined a new type pub type U256 = UnsignedInteger<4>; (4 limbs * 64 = 256) and the tests for all implemented methods. There is only one test that I cannot pass,related with the multiplication.

Test code failing below:

#[test]
    fn mul_two_256_bit_integers_works_4() {
        let a = U256::from("15bf61fcf53a3f0ae1e8e555d");
        let b = U256::from("cbbc474761bb7995ff54e25fa5d5d0cde405e9f");
        let c_expected = U256::from(
            "114ec14db0c80d30b7dcb9c45948ef04cc149e612cb544f447b146553aff2ac3",
        );

        assert_eq!(a * b, c_expected);
    }

With error:

mul_two_256_bit_integers_works_4' panicked at 'UnsignedInteger multiplication overflow.'

The fact is if i use the mul method instead of * operator the tests passes fine, and if i debug the values there really is no overflow.

Test code passing below:

 #[test]
    fn mul_two_256_bit_integers_works_4() {
        let a = U256::from("15bf61fcf53a3f0ae1e8e555d");
        let b = U256::from("cbbc474761bb7995ff54e25fa5d5d0cde405e9f");
        let c_expected = U256::from(
            "114ec14db0c80d30b7dcb9c45948ef04cc149e612cb544f447b146553aff2ac3",
        );

        let (overflow, c) = U256::mul(&a, &b);
        dbg!(overflow);
        dbg!(c);
        assert_eq!(c, c_expected);
    }

with debug output:

overflow = UnsignedInteger { limbs: [ 0, 0, 0, 0,],}
c = UnsignedInteger {limbs: [1247146686250749232,13248668456779837188,14705552823470605556,5165987579446635203,]}

Question:
As can be seen there is any overflow. Since 'UnsignedInteger' implements the 'Mul' trait, shouldn't the mul method and the * operator behave the same?

[ilitteri]

Hi, thanks! Where should be implemented? in the same math/src/unsigned_integer/element.rs file?

It would be nice to add the line above the U384 definition.

EDIT: It's ok where you put it.

[ilitteri]

Hello :), in principle, I have done and tested. I defined a new type pub type U256 = UnsignedInteger<4>; (4 limbs * 64 = 256) and the tests for all implemented methods. There is only one test that I cannot pass,related with the multiplication.

Test code failing below:

#[test]
    fn mul_two_256_bit_integers_works_4() {
        let a = U256::from("15bf61fcf53a3f0ae1e8e555d");
        let b = U256::from("cbbc474761bb7995ff54e25fa5d5d0cde405e9f");
        let c_expected = U256::from(
            "114ec14db0c80d30b7dcb9c45948ef04cc149e612cb544f447b146553aff2ac3",
        );

        assert_eq!(a * b, c_expected);
    }

With error:

mul_two_256_bit_integers_works_4' panicked at 'UnsignedInteger multiplication overflow.'

The fact is if i use the mul method instead of * operator the tests passes fine, and if i debug the values there really is no overflow.

Test code passing below:

 #[test]
    fn mul_two_256_bit_integers_works_4() {
        let a = U256::from("15bf61fcf53a3f0ae1e8e555d");
        let b = U256::from("cbbc474761bb7995ff54e25fa5d5d0cde405e9f");
        let c_expected = U256::from(
            "114ec14db0c80d30b7dcb9c45948ef04cc149e612cb544f447b146553aff2ac3",
        );

        let (overflow, c) = U256::mul(&a, &b);
        dbg!(overflow);
        dbg!(c);
        assert_eq!(c, c_expected);
    }

with debug output:

overflow = UnsignedInteger { limbs: [ 0, 0, 0, 0,],}
c = UnsignedInteger {limbs: [1247146686250749232,13248668456779837188,14705552823470605556,5165987579446635203,]}

Question: As can be seen there is any overflow. Since 'UnsignedInteger' implements the 'Mul' trait, shouldn't the mul method and the * operator behave the same?

To answer your question, if I'm not mistaken, yes. I'll look into this, it could be a nice bug to issue.

Where can I find this code?

[schouhy]

Thanks for pointing this out! It should be fixed now. Let us know how it goes!

[ilitteri]

Resolved in #50