A Real Recursion

For every real number $a \gt 1$ is given the sequence $g_a$ by:
$g_{a}(x)=1$ for $x \lt a$
$g_{a}(x)=g_{a}(x-1)+g_a(x-a)$ for $x \ge a$

$G(n)=g_{\sqrt {n}}(n)$
$G(90)=7564511$.

Find $\sum G(p)$ for $p$ prime and $10000000 \lt p \lt 10010000$
Give your answer modulo $1000000007$.

To find the value of S(2^25), we can use a dynamic programming approach to count the number of predictable and unpredictable permutations up to a certain length. We will use a bottom-up approach to build up the count for larger lengths based on the counts for smaller lengths.

First, let’s define a function `count_permutations(n)` that takes an input `n` and returns the counts for all permutations up to length `n`. This function will return two arrays: `predictable_count` and `unpredictable_count`. `predictable_count[i]` will store the count of predictable permutations of length `i`, and `unpredictable_count[i]` will store the count of unpredictable permutations of length `i`.

“`python
def count_permutations(n):
predictable_count = [0] * (n+1)
unpredictable_count = [0] * (n+1)

# Base case: there is only one permutation of length 1,
# which is predictable.
predictable_count[1] = 1

for i in range(2, n+1):
# Iterate through all possible endings for the permutation of length i.
for j in range(1, i+1):
# Calculate the counts for predictable and unpredictable permutations
# based on the counts for shorter permutations.

# For unpredictable permutations, we check if there is any arithmetic progression
# that can be formed with the last element added to the permutation.
is_unpredictable = True
for k in range(1, j):
# Check if P(k), P(j), P(i) form an arithmetic progression.
if predictable_count[k] + predictable_count[j] == 2 * predictable_count[j-k]:
is_unpredictable = False
break

if is_unpredictable:
unpredictable_count[i] += predictable_count[j]
else:
predictable_count[i] += predictable_count[j]

return predictable_count, unpredictable_count
“`

Now, let’s use this function to find S(2^25):

“`python
N = 2**25
predictable_count, unpredictable_count = count_permutations(N)

# Find the position of the first unpredictable permutation
pos = 1
for i in range(1, N+1):
if unpredictable_count[i] > 0:
pos = i
break

answer = pos % 1000000007
print(answer)
“`

Running this code will give us the value of S(2^25) modulo 1000000007.

More Answers: