/*@ Import Lean
import Algorithms.lucas_theorem.lean.helper_lib
open scoped SimpleC
*/

/*
 * Compute C(n + m, n) modulo a prime p with Lucas' theorem.
 *
 * The problem guarantees
 *
 *   1 <= n, m, p <= 100000
 *
 * and that p is prime.  For this verification example, all arithmetic used by
 * the program is additionally assumed to stay within the signed int range.
 *
 * Input/output handling is intentionally left to the caller.  The function
 * lucas_theorem is the algorithmic entry point for one test case.
 */

/*@ Extern Coq
      (ModularPower : Z -> Z -> Z -> Z -> Prop)
 */
/*@ Extern Coq
      (PrimeForLucas : Z -> Prop)
      (DigitBinomialMachineSafe : Z -> Z -> Z -> Prop)
      (BinomialDigitResidue : Z -> Z -> Z -> Z -> Prop)
      (LucasMachineSafe : Z -> Z -> Z -> Prop)
      (LucasBinomialResidue : Z -> Z -> Z -> Z -> Prop)
 */
/*@ Extern Coq
      (DigitProductProgress : Z -> Z -> Z -> Z -> Z -> Z -> Prop)
      (LucasProgress : Z -> Z -> Z -> Z -> Z -> Z -> Prop)
 */

int modular_power(int base, int exponent, int modulus)
/*@ Require
      0 <= base && base < modulus &&
      0 <= exponent && 2 <= modulus && emp
    Ensure
      0 <= __return && __return < modulus &&
      ModularPower(base, exponent, modulus, __return) && emp
 */;

/*
 * Compute C(upper, lower) modulo prime, where
 * 0 <= lower <= upper < prime.
 *
 * Because every factor in lower! is nonzero modulo prime, Fermat's little
 * theorem gives lower!^(prime - 2) as its modular inverse.
 */
int binomial_digit_mod_prime(int upper, int lower, int prime)
/*@ Require
      PrimeForLucas(prime) &&
      0 <= lower && lower <= upper && upper < prime &&
      2 <= prime && prime <= 100000 &&
      DigitBinomialMachineSafe(upper, lower, prime) && emp
    Ensure
      0 <= __return && __return < prime@pre &&
      BinomialDigitResidue(upper@pre, lower@pre, prime@pre, __return) && emp
 */
{
    if (lower > upper) {
        return 0;
    }

    if (lower > upper - lower) {
        lower = upper - lower;
    }

    int numerator = 1;
    int denominator = 1;

    /*@ Inv Assert
          upper == upper@pre && prime == prime@pre &&
          PrimeForLucas(prime@pre) &&
          0 <= lower@pre && lower@pre <= upper@pre &&
          upper@pre < prime@pre &&
          2 <= prime@pre && prime@pre <= 100000 &&
          ((lower == lower@pre &&
            lower@pre <= upper@pre - lower@pre) ||
           (lower == upper@pre - lower@pre &&
            lower@pre > upper@pre - lower@pre)) &&
          0 <= lower && lower <= upper@pre - lower &&
          1 <= i && i <= lower + 1 &&
          0 <= numerator && numerator < prime@pre &&
          0 <= denominator && denominator < prime@pre &&
          DigitBinomialMachineSafe(upper@pre, lower@pre, prime@pre) &&
          DigitProductProgress(upper@pre, lower, prime@pre,
            i, numerator, denominator) && emp
     */
    for (int i = 1; i <= lower; ++i) {
        int factor = upper - lower + i;
        int numerator_product = numerator * factor;
        int denominator_product = denominator * i;

        numerator = numerator_product % prime;
        denominator = denominator_product % prime;
    }

    /*@ Assert
          upper == upper@pre && prime == prime@pre &&
          PrimeForLucas(prime@pre) &&
          0 <= lower@pre && lower@pre <= upper@pre &&
          upper@pre < prime@pre &&
          2 <= prime@pre && prime@pre <= 100000 &&
          ((lower == lower@pre &&
            lower@pre <= upper@pre - lower@pre) ||
           (lower == upper@pre - lower@pre &&
            lower@pre > upper@pre - lower@pre)) &&
          0 <= lower && lower <= upper@pre - lower &&
          0 <= numerator && numerator < prime@pre &&
          0 <= denominator && denominator < prime@pre &&
          0 <= prime@pre - 2 &&
          DigitBinomialMachineSafe(upper@pre, lower@pre, prime@pre) &&
          DigitProductProgress(upper@pre, lower, prime@pre,
            lower + 1, numerator, denominator) && emp
     */
    int inverse = modular_power(denominator, prime - 2, prime);
    int answer = numerator * inverse;
    return answer % prime;
}

int lucas_theorem(int n, int m, int prime)
/*@ Require
      1 <= n && n <= 100000 &&
      1 <= m && m <= 100000 &&
      2 <= prime && prime <= 100000 &&
      PrimeForLucas(prime) &&
      LucasMachineSafe(n, m, prime) && emp
    Ensure
      0 <= __return && __return < prime@pre &&
      LucasBinomialResidue(n@pre, m@pre, prime@pre, __return) && emp
 */
{
    int upper = n + m;
    int lower = n;
    int result = 1;

    /*@ Inv Assert
          n == n@pre && m == m@pre && prime == prime@pre &&
          1 <= n@pre && n@pre <= 100000 &&
          1 <= m@pre && m@pre <= 100000 &&
          2 <= prime@pre && prime@pre <= 100000 &&
          PrimeForLucas(prime@pre) &&
          LucasMachineSafe(n@pre, m@pre, prime@pre) &&
          0 <= lower && lower <= upper &&
          upper <= n@pre + m@pre && n@pre + m@pre <= 200000 &&
          0 <= result && result < prime@pre &&
          LucasProgress(n@pre + m@pre, n@pre, prime@pre,
            upper, lower, result) && emp
     */
    while (upper > 0 || lower > 0) {
        int upper_digit = upper % prime;
        int lower_digit = lower % prime;

        if (lower_digit > upper_digit) {
            return 0;
        }

        /*@ Assert
              n == n@pre && m == m@pre && prime == prime@pre &&
              1 <= n@pre && n@pre <= 100000 &&
              1 <= m@pre && m@pre <= 100000 &&
              2 <= prime@pre && prime@pre <= 100000 &&
              PrimeForLucas(prime@pre) &&
              LucasMachineSafe(n@pre, m@pre, prime@pre) &&
              0 < upper && 0 <= lower && lower <= upper &&
              upper <= n@pre + m@pre && n@pre + m@pre <= 200000 &&
              upper_digit == upper % prime@pre &&
              lower_digit == lower % prime@pre &&
              0 <= lower_digit && lower_digit <= upper_digit &&
              upper_digit < prime@pre &&
              0 <= result && result < prime@pre &&
              DigitBinomialMachineSafe(
                upper_digit, lower_digit, prime@pre) &&
              LucasProgress(n@pre + m@pre, n@pre, prime@pre,
                upper, lower, result) && emp
         */
        int digit_binomial =
            binomial_digit_mod_prime(upper_digit, lower_digit, prime);
        int product = result * digit_binomial;
        result = product % prime;

        upper /= prime;
        lower /= prime;
    }

    return result;
}