Remainder of Polynomial Division

For positive integers $n$ and $m$, we define two polynomials $F_n(x) = x^n$ and $G_m(x) = (x-1)^m$.
We also define a polynomial $R_{n,m}(x)$ as the remainder of the division of $F_n(x)$ by $G_m(x)$.
For example, $R_{6,3}(x) = 15x^2 – 24x + 10$.
Let $C(n, m, d)$ be the absolute value of the coefficient of the $d$-th degree term of $R_{n,m}(x)$.
We can verify that $C(6, 3, 1) = 24$ and $C(100, 10, 4) = 227197811615775$.
Find $C(10^{13}, 10^{12}, 10^4) \bmod 999999937$.

To solve this problem, we will break it down into smaller steps and implement each step using Python code. Here’s a step-by-step solution:

Step 1: Generating Prime Numbers
First, we need a way to generate prime numbers. We can use the Sieve of Eratosthenes algorithm to efficiently generate all prime numbers up to a given limit.

“`python
def generate_primes(limit):
is_prime = [True] * (limit + 1)
is_prime[0] = is_prime[1] = False

for i in range(2, int(limit ** 0.5) + 1):
if is_prime[i]:
for j in range(i * i, limit + 1, i):
is_prime[j] = False

primes = [i for i in range(limit + 1) if is_prime[i]]
return primes
“`

Step 2: Concatenating Primes
Next, we need a function to concatenate the first `n` primes together.

“`python
def concatenate_primes(n, primes):
concatenated = “”
for i in range(n):
concatenated += str(primes[i])
return int(concatenated)
“`

Step 3: Concatenating Prime Multiples
We also need a function to concatenate `k` copies of the first `n` primes together.

“`python
def concatenate_prime_multiples(n, k, primes):
concatenated = “”
for i in range(k):
concatenated += str(concatenate_primes(n, primes))
return int(concatenated)
“`

Step 4: Finding Contiguous Integer-Substrings
To find all contiguous integer-substrings, we can convert the number to a string and iterate through all possible substrings.

“`python
def find_integer_substrings(num):
num_str = str(num)
substrings = []

for i in range(len(num_str)):
for j in range(i + 1, len(num_str) + 1):
substr = int(num_str[i:j])
substrings.append(substr)

return substrings
“`

Step 5: Summing the Integer-Substrings
Finally, we can sum all the integer-substrings and calculate the modulo.

“`python
def sum_integer_substrings(num):
substrings = find_integer_substrings(num)
return sum(substrings) % (10**9 + 7)
“`

Putting it all together:
To solve the given problem, we can call the above functions with appropriate arguments.

“`python
primes = generate_primes(10**6)
result = sum_integer_substrings(concatenate_prime_multiples(10**6, 10**12, primes))
print(result)
“`

Note: The code provided above assumes that the `generate_primes` function is given the limit as $10^6$, corresponding to the number of primes required for the calculation. However, the algorithm and code are applicable for any positive integer `limit`. Also, be aware that the code above may take a considerable amount of time to execute due to the large values involved.

More Answers: