constantine/tests/math/t_bigints.nim

# Constantine
# Copyright (c) 2018-2019    Status Research & Development GmbH
# Copyright (c) 2020-Present Mamy André-Ratsimbazafy
# Licensed and distributed under either of
#   * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT).
#   * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0).
# at your option. This file may not be copied, modified, or distributed except according to those terms.

import
  # Standard library
  std/unittest,
  # Internal
  ../../constantine/math/io/io_bigints,
  ../../constantine/math/arithmetic,
  ../../constantine/platforms/abstractions,
  # Test utilities,
  support/canaries

echo "\n------------------------------------------------------\n"

proc mainArith() =
  suite "isZero" & " [" & $WordBitWidth & "-bit mode]":
    test "isZero for zero":
      var x: BigInt[128]
      check: x.isZero().bool
    test "isZero for non-zero":
      block:
        let x = fromHex(BigInt[128], "0x00000000000000000000000000000001")
        check: not x.isZero().bool
      block:
        let x = fromHex(BigInt[128], "0x00000000000000010000000000000000")
        check: not x.isZero().bool
      block:
        let x = fromHex(BigInt[128], "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")
        check: not x.isZero().bool

    test "isZero for zero (compile-time)":
      const x = BigInt[128]()
      check: static(x.isZero().bool)
    test "isZero for non-zero (compile-time)":
      block:
        const x = fromHex(BigInt[128], "0x00000000000000000000000000000001")
        check: static(not x.isZero().bool)
      block:
        const x = fromHex(BigInt[128], "0x00000000000000010000000000000000")
        check: static(not x.isZero().bool)
      block:
        const x = fromHex(BigInt[128], "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")
        check: static(not x.isZero().bool)


  suite "Arithmetic operations - Addition" & " [" & $WordBitWidth & "-bit mode]":
    test "Adding 2 zeros":
      var a = fromHex(BigInt[128], "0x00000000000000000000000000000000")
      let b = fromHex(BigInt[128], "0x00000000000000000000000000000000")
      let carry = a.cadd(b, CtTrue)
      check: a.isZero().bool

    test "Adding 1 zero - real addition":
      block:
        var a = fromHex(BigInt[128], "0x00000000000000000000000000000000")
        let b = fromHex(BigInt[128], "0x00000000000000000000000000000001")
        let carry = a.cadd(b, CtTrue)

        let c = fromHex(BigInt[128], "0x00000000000000000000000000000001")
        check:
          bool(a == c)
      block:
        var a = fromHex(BigInt[128], "0x00000000000000000000000000000001")
        let b = fromHex(BigInt[128], "0x00000000000000000000000000000000")
        let carry = a.cadd(b, CtTrue)

        let c = fromHex(BigInt[128], "0x00000000000000000000000000000001")
        check:
          bool(a == c)

    test "Adding 1 zero - fake addition":
      block:
        var a = fromHex(BigInt[128], "0x00000000000000000000000000000000")
        let b = fromHex(BigInt[128], "0x00000000000000000000000000000001")
        let carry = a.cadd(b, CtFalse)

        let c = a
        check:
          bool(a == c)
      block:
        var a = fromHex(BigInt[128], "0x00000000000000000000000000000001")
        let b = fromHex(BigInt[128], "0x00000000000000000000000000000000")
        let carry = a.cadd(b, CtFalse)

        let c = a
        check:
          bool(a == c)

    test "Adding non-zeros - real addition":
      block:
        var a = fromHex(BigInt[128], "0x00000000000000010000000000000000")
        let b = fromHex(BigInt[128], "0x00000000000000000000000000000001")
        let carry = a.cadd(b, CtTrue)

        let c = fromHex(BigInt[128], "0x00000000000000010000000000000001")
        check:
          bool(a == c)
      block:
        var a = fromHex(BigInt[128], "0x00000000000000000000000000000001")
        let b = fromHex(BigInt[128], "0x00000000000000010000000000000000")
        let carry = a.cadd(b, CtTrue)

        let c = fromHex(BigInt[128], "0x00000000000000010000000000000001")
        check:
          bool(a == c)

    test "Adding non-zeros - fake addition":
      block:
        var a = fromHex(BigInt[128], "0x00000000000000010000000000000000")
        let b = fromHex(BigInt[128], "0x00000000000000000000000000000001")
        let carry = a.cadd(b, CtFalse)

        let c = a
        check:
          bool(a == c)
      block:
        var a = fromHex(BigInt[128], "0x00000000000000000000000000000001")
        let b = fromHex(BigInt[128], "0x00000000000000010000000000000000")
        let carry = a.cadd(b, CtFalse)

        let c = a
        check:
          bool(a == c)

    test "Addition limbs carry":
      block:
        var a = fromHex(BigInt[128], "0x00000000FFFFFFFFFFFFFFFFFFFFFFFE")
        let b = fromHex(BigInt[128], "0x00000000000000000000000000000001")
        let carry = a.cadd(b, CtTrue)

        let c = fromHex(BigInt[128], "0x00000000FFFFFFFFFFFFFFFFFFFFFFFF")
        check:
          bool(a == c)
          not bool(carry)

      block:
        var a = fromHex(BigInt[128], "0x00000000FFFFFFFFFFFFFFFFFFFFFFFF")
        let b = fromHex(BigInt[128], "0x00000000000000000000000000000001")
        let carry = a.cadd(b, CtTrue)

        let c = fromHex(BigInt[128], "0x00000001000000000000000000000000")
        check:
          bool(a == c)
          not bool(carry)

  suite "BigInt + SecretWord" & " [" & $WordBitWidth & "-bit mode]":
    test "Addition limbs carry":
      block: # P256 / 2
        var a = BigInt[256].fromhex"0x7fffffff800000008000000000000000000000007fffffffffffffffffffffff"

        let expected = BigInt[256].fromHex"7fffffff80000000800000000000000000000000800000000000000000000000"

        discard a.add(One)
        check: bool(a == expected)

proc mainMul() =
  suite "Multi-precision multiplication" & " [" & $WordBitWidth & "-bit mode]":
    test "Same size operand into double size result":
      block:
        var r = canary(BigInt[256])
        let a = BigInt[128].fromHex"0x12345678FF11FFAA00321321CAFECAFE"
        let b = BigInt[128].fromHex"0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF"

        let expected = BigInt[256].fromHex"fd5bdef43d64113f371ab5d8843beca889c07fd549b84d8a5001a8f102e0722"

        r.prod(a, b)
        check: bool(r == expected)
        r.prod(b, a)
        check: bool(r == expected)

    test "Different size into large result":
      block:
        var r = canary(BigInt[200])
        let a = BigInt[29].fromHex"0x12345678"
        let b = BigInt[128].fromHex"0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF"

        let expected = BigInt[200].fromHex"fd5bdee65f787f665f787f665f787f65621ca08"

        r.prod(a, b)
        check: bool(r == expected)
        r.prod(b, a)
        check: bool(r == expected)

    test "Destination is properly zero-padded if multiplicands are too short":
      block:
        var r = BigInt[200].fromHex"0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDE"
        let a = BigInt[29].fromHex"0x12345678"
        let b = BigInt[128].fromHex"0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF"

        let expected = BigInt[200].fromHex"fd5bdee65f787f665f787f665f787f65621ca08"

        r.prod(a, b)
        check: bool(r == expected)
        r.prod(b, a)
        check: bool(r == expected)

proc mainMulHigh() =
  suite "Multi-precision multiplication keeping only high words" & " [" & $WordBitWidth & "-bit mode]":
    test "Same size operand into double size result - discard first word":
      block:
        var r = canary(BigInt[256])
        let a = BigInt[128].fromHex"0x12345678FF11FFAA00321321CAFECAFE"
        let b = BigInt[128].fromHex"0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF"

        when WordBitWidth == 32:
          let expected = BigInt[256].fromHex"fd5bdef43d64113f371ab5d8843beca889c07fd549b84d8a5001a8f"
        else:
          let expected = BigInt[256].fromHex"fd5bdef43d64113f371ab5d8843beca889c07fd549b84d8"

        r.prodhighwords(a, b, 1)
        check: bool(r == expected)
        r.prodhighwords(b, a, 1)
        check: bool(r == expected)

    test "Same size operand into double size result - discard first 3 words":
      block:
        var r = canary(BigInt[256])
        let a = BigInt[128].fromHex"0x12345678FF11FFAA00321321CAFECAFE"
        let b = BigInt[128].fromHex"0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF"

        when WordBitWidth == 32:
          let expected = BigInt[256].fromHex"fd5bdef43d64113f371ab5d8843beca889c07fd"
        else:
          let expected = BigInt[256].fromHex"fd5bdef43d64113"

        r.prodhighwords(a, b, 3)
        check: bool(r == expected)
        r.prodhighwords(b, a, 3)
        check: bool(r == expected)

    test "All lower words trigger a carry":
      block:
        var r = canary(BigInt[256])
        let a = BigInt[256].fromHex"0xFFFFF000FFFFF111FFFFFFFAFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
        let b = BigInt[256].fromHex"0xFFFFFFFFFFFFF222FFFFFFFBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

        # Full product:
        # fffff000ffffe33500ddc21a00cf39720000810900000013fffffffffffffffe
        # 00000fff00001ccb000000090000000000000000000000000000000000000001
        let expected = BigInt[256].fromHex"0xfffff000ffffe33500ddc21a00cf39720000810900000013fffffffffffffffe"
        when WordBitWidth == 32:
          const startWord = 8
        else:
          const startWord = 4

        r.prodhighwords(a, b, startWord)
        check: bool(r == expected)
        r.prodhighwords(b, a, startWord)
        check: bool(r == expected)

    test "Different size into large result":
      block:
        var r = canary(BigInt[200])
        let a = BigInt[29].fromHex"0x12345678"
        let b = BigInt[128].fromHex"0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF"

        when WordBitWidth == 32:
          let expected = BigInt[200].fromHex"fd5bdee65f787f665f787f6"
        else:
          let expected = BigInt[200].fromHex"fd5bdee"

        r.prodhighwords(a, b, 2)
        check: bool(r == expected)
        r.prodhighwords(b, a, 2)
        check: bool(r == expected)

    test "Destination is properly zero-padded if multiplicands are too short":
      block:
        var r = BigInt[200].fromHex"0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDE"
        let a = BigInt[29].fromHex"0x12345678"
        let b = BigInt[128].fromHex"0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF"

        when WordBitWidth == 32:
          let expected = BigInt[200].fromHex"fd5bdee65f787f665f787f6"
        else:
          let expected = BigInt[200].fromHex"fd5bdee"

        r.prodhighwords(a, b, 2)
        check: bool(r == expected)
        r.prodhighwords(b, a, 2)
        check: bool(r == expected)

proc mainSquare() =
  suite "Multi-precision multiplication" & " [" & $WordBitWidth & "-bit mode]":
    test "Squaring is consistent with multiplication (rBits = 2*aBits)":
      block:
        let a = BigInt[200].fromHex"0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDE"

        var rmul, rsqr: BigInt[400]

        rmul.prod(a, a)
        rsqr.square(a)
        check: bool(rmul == rsqr)

    test "Squaring is consistent with multiplication (truncated)":
      block:
        let a = BigInt[200].fromHex"0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDE"

        var rmul, rsqr: BigInt[256]

        rmul.prod(a, a)
        rsqr.square(a)
        check: bool(rmul == rsqr)

proc mainModular() =
  suite "Modular operations - small modulus" & " [" & $WordBitWidth & "-bit mode]":
    # Vectors taken from Stint - https://github.com/status-im/nim-stint
    test "100 mod 13":
      # Test 1 word and more than 1 word
      block:
        let a = BigInt[7].fromUint(100'u32)
        let m = BigInt[4].fromUint(13'u8)

        var r = canary(BigInt[4])
        r.reduce(a, m)
        let expected = BigInt[4].fromUint(100'u8 mod 13)
        doAssert bool(r == expected),
          "\n  r (low-level repr): " & $r &
          "\n  expected (ll repr): " & $expected

      block: #
        let a = BigInt[32].fromUint(100'u32)
        let m = BigInt[4].fromUint(13'u8)

        var r = canary(BigInt[4])
        r.reduce(a, m)
        let expected = BigInt[4].fromUint(100'u8 mod 13)
        doAssert bool(r == expected),
          "\n  r (low-level repr): " & $r &
          "\n  expected (ll repr): " & $expected

      block: #
        let a = BigInt[64].fromUint(100'u32)
        let m = BigInt[4].fromUint(13'u8)

        var r = canary(BigInt[4])
        r.reduce(a, m)
        let expected = BigInt[4].fromUint(100'u8 mod 13)
        doAssert bool(r == expected),
          "\n  r (low-level repr): " & $r &
          "\n  expected (ll repr): " & $expected

    test "2^64 mod 3":
      let a = BigInt[65].fromHex("0x10000000000000000")
      let m = BigInt[8].fromUint(3'u8)

      var r = canary(BigInt[8])
      r.reduce(a, m)
      let expected = BigInt[8].fromUint(1'u8)
      doAssert bool(r == expected),
        "\n  r (low-level repr): " & $r &
        "\n  expected (ll repr): " & $expected

    test "1234567891234567890 mod 10":
      let a = BigInt[64].fromUint(1234567891234567890'u64)
      let m = BigInt[8].fromUint(10'u8)

      var r = canary(BigInt[8])
      r.reduce(a, m)
      let expected = BigInt[8].fromUint(0'u8)
      doAssert bool(r == expected),
        "\n  r (low-level repr): " & $r &
        "\n  expected (ll repr): " & $expected

  suite "Modular operations - small modulus - Stint specific failures highlighted by property-based testing" & " [" & $WordBitWidth & "-bit mode]":
    # Vectors taken from Stint - https://github.com/status-im/nim-stint
    test "Modulo: 65696211516342324 mod 174261910798982":
      let u = 65696211516342324'u64
      let v = 174261910798982'u64

      let a = BigInt[56].fromUint(u)
      let m = BigInt[48].fromUint(v)

      var r = canary(BigInt[48])
      r.reduce(a, m)

      let expected = BigInt[48].fromUint(u mod v)
      doAssert bool(r == expected),
        "\n  r (low-level repr): " & $r &
        "\n  expected (ll repr): " & $expected

    test "Modulo: 15080397990160655 mod 600432699691":
      let u = 15080397990160655'u64
      let v = 600432699691'u64

      let a = BigInt[54].fromUint(u)
      let m = BigInt[40].fromUint(v)

      var r = canary(BigInt[40])
      r.reduce(a, m)

      let expected = BigInt[40].fromUint(u mod v)
      doAssert bool(r == expected),
        "\n  r (low-level repr): " & $r &
        "\n  expected (ll repr): " & $expected

proc mainNeg() =
  suite "Conditional negation" & " [" & $WordBitWidth & "-bit mode]":
    test "Conditional negation":
      block:
        var a = fromHex(BigInt[128], "0x12345678FF11FFAA00321321CAFECAFE")
        var b = fromHex(BigInt[128], "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF")

        let a2 = a
        let b2 = b

        a.cneg(CtTrue)
        b.cneg(CtTrue)

        discard a.add(a2)
        discard b.add(b2)

        check:
          bool(a.isZero)
          bool(b.isZero)

      block:
        var a = fromHex(BigInt[128], "0x12345678FF11FFAA00321321CAFECAFE")
        var b = fromHex(BigInt[128], "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF")

        let a2 = a
        let b2 = b

        a.cneg(CtFalse)
        b.cneg(CtFalse)

        check:
          bool(a == a2)
          bool(b == b2)

    test "Conditional negation with carries":
      block:
        var a = fromHex(BigInt[128], "0x12345678FF11FFAA00321321FFFFFFFF")
        var b = fromHex(BigInt[128], "0xFFFFFFFFFFFFFFFF0000000000000000")

        let a2 = a
        let b2 = b

        a.cneg(CtTrue)
        b.cneg(CtTrue)

        discard a.add(a2)
        discard b.add(b2)

        check:
          bool(a.isZero)
          bool(b.isZero)

      block:
        var a = fromHex(BigInt[128], "0x123456780000000000321321FFFFFFFF")
        var b = fromHex(BigInt[128], "0xFFFFFFFFFFFFFFFF0000000000000000")

        let a2 = a
        let b2 = b

        a.cneg(CtFalse)
        b.cneg(CtFalse)

        check:
          bool(a == a2)
          bool(b == b2)

    test "Conditional all-zero bit or all-one bit":
      block:
        var a = fromHex(BigInt[128], "0x00000000000000000000000000000000")
        var b = fromHex(BigInt[128], "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")

        let a2 = a
        let b2 = b

        a.cneg(CtTrue)
        b.cneg(CtTrue)

        discard a.add(a2)
        discard b.add(b2)

        check:
          bool(a.isZero)
          bool(b.isZero)

      block:
        var a = fromHex(BigInt[128], "0x00000000000000000000000000000000")
        var b = fromHex(BigInt[128], "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")

        let a2 = a
        let b2 = b

        a.cneg(CtFalse)
        b.cneg(CtFalse)

        check:
          bool(a == a2)
          bool(b == b2)

proc mainCopySwap() =
  suite "Copy and Swap" & " [" & $WordBitWidth & "-bit mode]":
    test "Conditional copy":
      block:
        var a = fromHex(BigInt[128], "0x12345678FF11FFAA00321321CAFECAFE")
        let b = fromHex(BigInt[128], "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF")

        var expected = a
        a.ccopy(b, CtFalse)

        check: bool(expected == a)

      block:
        var a = fromHex(BigInt[128], "0x00000000FFFFFFFFFFFFFFFFFFFFFFFF")
        let b = fromHex(BigInt[128], "0x00000000000000000000000000000001")

        var expected = b
        a.ccopy(b, CtTrue)

        check: bool(expected == b)

    test "Conditional swap":
      block:
        var a = fromHex(BigInt[128], "0x12345678FF11FFAA00321321CAFECAFE")
        var b = fromHex(BigInt[128], "0xDEADBEEFDEADBEEFDEADBEEFDEADBEEF")

        let eA = a
        let eB = b

        a.cswap(b, CtFalse)
        check:
          bool(eA == a)
          bool(eB == b)

      block:
        var a = fromHex(BigInt[128], "0x00000000FFFFFFFFFFFFFFFFFFFFFFFF")
        var b = fromHex(BigInt[128], "0x00000000000000000000000000000001")

        let eA = b
        let eB = a

        a.cswap(b, CtTrue)
        check:
          bool(eA == a)
          bool(eB == b)

proc mainModularInverse() =
  suite "Modular Inverse (with odd modulus)" & " [" & $WordBitWidth & "-bit mode]":
    # Note: We don't define multi-precision multiplication
    #       because who needs it when you have Montgomery?
    #       ¯\(ツ)/¯
    test "42^-1 (mod 2017) = 1969":
      block: # small int
        let a = BigInt[16].fromUint(42'u16)
        let M = BigInt[16].fromUint(2017'u16)

        let expected = BigInt[16].fromUint(1969'u16)
        var r = canary(BigInt[16])

        r.invmod(a, M)

        check: bool(r == expected)

      block: # huge int
        let a = BigInt[381].fromUint(42'u16)
        let M = BigInt[381].fromUint(2017'u16)

        let expected = BigInt[381].fromUint(1969'u16)
        var r = canary(BigInt[381])

        r.invmod(a, M)

        check: bool(r == expected)

    test "271^-1 (mod 383) = 106":
      block: # small int
        let a = BigInt[16].fromUint(271'u16)
        let M = BigInt[16].fromUint(383'u16)

        let expected = BigInt[16].fromUint(106'u16)
        var r = canary(BigInt[16])

        r.invmod(a, M)

        check: bool(r == expected)

      block: # huge int
        let a = BigInt[381].fromUint(271'u16)
        let M = BigInt[381].fromUint(383'u16)

        let expected = BigInt[381].fromUint(106'u16)
        var r = canary(BigInt[381])

        r.invmod(a, M)

        check: bool(r == expected)

    test "BN254_Modulus^-1 (mod BLS12_381)":
      let a = BigInt[381].fromHex("0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47")
      let M = BigInt[381].fromHex("0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab")

      let expected = BigInt[381].fromHex("0x0636759a0f3034fa47174b2c0334902f11e9915b7bd89c6a2b3082b109abbc9837da17201f6d8286fe6203caa1b9d4c8")

      var r = canary(BigInt[381])
      r.invmod(a, M)

      check: bool(r == expected)

    test "0^-1 (mod any) = 0 (need for tower of extension fields)":
      block:
        let a = BigInt[16].fromUint(0'u16)
        let M = BigInt[16].fromUint(2017'u16)

        let expected = BigInt[16].fromUint(0'u16)
        var r = canary(BigInt[16])

        r.invmod(a, M)

        check: bool(r == expected)

      block:
        let a = BigInt[381].fromUint(0'u16)
        let M = BigInt[381].fromHex("0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab")

        let expected = BigInt[381].fromUint(0'u16)
        var r = canary(BigInt[381])

        r.invmod(a, M)

        check: bool(r == expected)

mainArith()
mainMul()
mainMulHigh()
mainSquare()
mainModular()
mainNeg()
mainCopySwap()
mainModularInverse()