## 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:

Geoboard ShapesDissonant Numbers

$5$-smooth Totients