def pthpowers(self, p, Bound):
"""
Find the indices of proveably all pth powers in the recurrence sequence bounded by Bound.
Let `u_n` be a binary recurrence sequence. A ``p`` th power in `u_n` is a solution
to `u_n = y^p` for some integer `y`. There are only finitely many ``p`` th powers in
any recurrence sequence [SS].
INPUT:
- ``p`` - a rational prime integer (the fixed p in `u_n = y^p`)
- ``Bound`` - a natural number (the maximum index `n` in `u_n = y^p` that is checked).
OUTPUT:
- A list of the indices of all ``p`` th powers less bounded by ``Bound``. If the sequence is degenerate and there are many ``p`` th powers, raises ``ValueError``.
EXAMPLES::
sage: R = BinaryRecurrenceSequence(1,1) #the Fibonacci sequence
sage: R.pthpowers(2, 10**30) # long time (7 seconds) -- in fact these are all squares, c.f. [BMS06]
[0, 1, 2, 12]
sage: S = BinaryRecurrenceSequence(8,1) #a Lucas sequence
sage: S.pthpowers(3,10**30) # long time (3 seconds) -- provably finds the indices of all 3rd powers less than 10^30
[0, 1, 2]
sage: Q = BinaryRecurrenceSequence(3,3,2,1)
sage: Q.pthpowers(11,10**30) # long time (7.5 seconds)
[1]
If the sequence is degenerate, and there are are no ``p`` th powers, returns `[]`. Otherwise, if
there are many ``p`` th powers, raises ``ValueError``.
::
sage: T = BinaryRecurrenceSequence(2,0,1,2)
sage: T.is_degenerate()
True
sage: T.is_geometric()
True
sage: T.pthpowers(7,10**30)
Traceback (most recent call last):
...
ValueError: The degenerate binary recurrence sequence is geometric or quasigeometric and has many pth powers.
sage: L = BinaryRecurrenceSequence(4,0,2,2)
sage: [L(i).factor() for i in range(10)]
[2, 2, 2^3, 2^5, 2^7, 2^9, 2^11, 2^13, 2^15, 2^17]
sage: L.is_quasigeometric()
True
sage: L.pthpowers(2,10**30)
[]
NOTE: This function is primarily optimized in the range where ``Bound`` is much larger than ``p``.
"""
#Thanks to Jesse Silliman for helpful conversations!
#Reset the dictionary of good primes, as this depends on p
self._PGoodness = {}
#Starting lower bound on good primes
self._ell = 1
#If the sequence is geometric, then the `n`th term is `a*r^n`. Thus the
#property of being a ``p`` th power is periodic mod ``p``. So there are either
#no ``p`` th powers if there are none in the first ``p`` terms, or many if there
#is at least one in the first ``p`` terms.
if self.is_geometric() or self.is_quasigeometric():
no_powers = True
for i in range(1, 6 * p + 1):
if _is_p_power(self(i), p):
no_powers = False
break
if no_powers:
if _is_p_power(self.u0, p):
return [0]
return []
else:
raise ValueError(
"The degenerate binary recurrence sequence is geometric or quasigeometric and has many pth powers."
)
#If the sequence is degenerate without being geometric or quasigeometric, there
#may be many ``p`` th powers or no ``p`` th powers.
elif (self.b**2 + 4 * self.c) == 0:
#This is the case if the matrix F is not diagonalizable, ie b^2 +4c = 0, and alpha/beta = 1.
alpha = self.b / 2
#In this case, u_n = u_0*alpha^n + (u_1 - u_0*alpha)*n*alpha^(n-1) = alpha^(n-1)*(u_0 +n*(u_1 - u_0*alpha)),
#that is, it is a geometric term (alpha^(n-1)) times an arithmetic term (u_0 + n*(u_1-u_0*alpha)).
#Look at classes n = k mod p, for k = 1,...,p.
for k in range(1, p + 1):
#The linear equation alpha^(k-1)*u_0 + (k+pm)*(alpha^(k-1)*u1 - u0*alpha^k)
#must thus be a pth power. This is a linear equation in m, namely, A + B*m, where
A = (alpha**(k - 1) * self.u0 + k *
(alpha**(k - 1) * self.u1 - self.u0 * alpha**k))
B = p * (alpha**(k - 1) * self.u1 - self.u0 * alpha**k)
#This linear equation represents a pth power iff A is a pth power mod B.
if _is_p_power_mod(A, p, B):
raise ValueError(
"The degenerate binary recurrence sequence has many pth powers."
)
return []
#We find ``p`` th powers using an elementary sieve. Term `u_n` is a ``p`` th
#power if and only if it is a ``p`` th power modulo every prime `\\ell`. This condition
#gives nontrivial information if ``p`` divides the order of the multiplicative group of
#`\\Bold(F)_{\\ell}`, i.e. if `\\ell` is ` 1 \mod{p}`, as then only `1/p` terms are ``p`` th
#powers modulo `\\ell``.
#Thus, given such an `\\ell`, we get a set of necessary congruences for the index modulo the
#the period of the sequence mod `\\ell`. Then we intersect these congruences for many primes
#to get a tight list modulo a growing modulus. In order to keep this step manageable, we
#only use primes `\\ell` that are have particularly smooth periods.
#Some congruences in the list will remain as the modulus grows. If a congruence remains through
#7 rounds of increasing the modulus, then we check if this corresponds to a perfect power (if
#it does, we add it to our list of indices corresponding to ``p`` th powers). The rest of the congruences
#are transient and grow with the modulus. Once the smallest of these is greater than the bound,
#the list of known indices corresponding to ``p`` th powers is complete.
else:
if Bound < 3 * p:
powers = []
ell = p + 1
while not is_prime(ell):
ell = ell + p
F = GF(ell)
a0 = F(self.u0)
a1 = F(self.u1) #a0 and a1 are variables for terms in sequence
bf, cf = F(self.b), F(self.c)
for n in range(Bound): # n is the index of the a0
#Check whether a0 is a perfect power mod ell
if _is_p_power_mod(a0, p, ell):
#if a0 is a perfect power mod ell, check if nth term is ppower
if _is_p_power(self(n), p):
powers.append(n)
a0, a1 = a1, bf * a1 + cf * a0 #step up the variables
else:
powers = [
] #documents the indices of the sequence that provably correspond to pth powers
cong = [
0
] #list of necessary congruences on the index for it to correspond to pth powers
Possible_count = {
} #keeps track of the number of rounds a congruence lasts in cong
#These parameters are involved in how we choose primes to increase the modulus
qqold = 1 #we believe that we know complete information coming from primes good by qqold
M1 = 1 #we have congruences modulo M1, this may not be the tightest list
M2 = p #we want to move to have congruences mod M2
qq = 1 #the largest prime power divisor of M1 is qq
#This loop ups the modulus.
while True:
#Try to get good data mod M2
#patience of how long we should search for a "good prime"
patience = 0.01 * _estimated_time(
lcm(M2, p * next_prime_power(qq)), M1, len(cong), p)
tries = 0
#This loop uses primes to get a small set of congruences mod M2.
while True:
#only proceed if took less than patience time to find the next good prime
ell = _next_good_prime(p, self, qq, patience, qqold)
if ell:
#gather congruence data for the sequence mod ell, which will be mod period(ell) = modu
cong1, modu = _find_cong1(p, self, ell)
CongNew = [
] #makes a new list from cong that is now mod M = lcm(M1, modu) instead of M1
M = lcm(M1, modu)
for k in range(M // M1):
for i in cong:
CongNew.append(k * M1 + i)
cong = set(CongNew)
M1 = M
killed_something = False #keeps track of when cong1 can rule out a congruence in cong
#CRT by hand to gain speed
for i in list(cong):
if not (
i % modu in cong1
): #congruence in cong is inconsistent with any in cong1
cong.remove(i) #remove that congruence
killed_something = True
if M1 == M2:
if not killed_something:
tries += 1
if tries == 2: #try twice to rule out congruences
cong = list(cong)
qqold = qq
qq = next_prime_power(qq)
M2 = lcm(M2, p * qq)
break
else:
qq = next_prime_power(qq)
M2 = lcm(M2, p * qq)
cong = list(cong)
break
#Document how long each element of cong has been there
for i in cong:
if i in Possible_count:
Possible_count[i] = Possible_count[i] + 1
else:
Possible_count[i] = 1
#Check how long each element has persisted, if it is for at least 7 cycles,
#then we check to see if it is actually a perfect power
for i in Possible_count:
if Possible_count[i] == 7:
n = Integer(i)
if n < Bound:
if _is_p_power(self(n), p):
powers.append(n)
#check for a contradiction
if len(cong) > len(powers):
if cong[len(powers)] > Bound:
break
elif M1 > Bound:
break
return powers
def pthpowers(self, p, Bound):
"""
Find the indices of proveably all pth powers in the recurrence sequence bounded by Bound.
Let `u_n` be a binary recurrence sequence. A ``p`` th power in `u_n` is a solution
to `u_n = y^p` for some integer `y`. There are only finitely many ``p`` th powers in
any recurrence sequence [SS].
INPUT:
- ``p`` - a rational prime integer (the fixed p in `u_n = y^p`)
- ``Bound`` - a natural number (the maximum index `n` in `u_n = y^p` that is checked).
OUTPUT:
- A list of the indices of all ``p`` th powers less bounded by ``Bound``. If the sequence is degenerate and there are many ``p`` th powers, raises ``ValueError``.
EXAMPLES::
sage: R = BinaryRecurrenceSequence(1,1) #the Fibonacci sequence
sage: R.pthpowers(2, 10**30) # long time (7 seconds) -- in fact these are all squares, c.f. [BMS06]
[0, 1, 2, 12]
sage: S = BinaryRecurrenceSequence(8,1) #a Lucas sequence
sage: S.pthpowers(3,10**30) # long time (3 seconds) -- provably finds the indices of all 3rd powers less than 10^30
[0, 1, 2]
sage: Q = BinaryRecurrenceSequence(3,3,2,1)
sage: Q.pthpowers(11,10**30) # long time (7.5 seconds)
[1]
If the sequence is degenerate, and there are are no ``p`` th powers, returns `[]`. Otherwise, if
there are many ``p`` th powers, raises ``ValueError``.
::
sage: T = BinaryRecurrenceSequence(2,0,1,2)
sage: T.is_degenerate()
True
sage: T.is_geometric()
True
sage: T.pthpowers(7,10**30)
Traceback (most recent call last):
...
ValueError: The degenerate binary recurrence sequence is geometric or quasigeometric and has many pth powers.
sage: L = BinaryRecurrenceSequence(4,0,2,2)
sage: [L(i).factor() for i in range(10)]
[2, 2, 2^3, 2^5, 2^7, 2^9, 2^11, 2^13, 2^15, 2^17]
sage: L.is_quasigeometric()
True
sage: L.pthpowers(2,10**30)
[]
NOTE: This function is primarily optimized in the range where ``Bound`` is much larger than ``p``.
"""
#Thanks to Jesse Silliman for helpful conversations!
#Reset the dictionary of good primes, as this depends on p
self._PGoodness = {}
#Starting lower bound on good primes
self._ell = 1
#If the sequence is geometric, then the `n`th term is `a*r^n`. Thus the
#property of being a ``p`` th power is periodic mod ``p``. So there are either
#no ``p`` th powers if there are none in the first ``p`` terms, or many if there
#is at least one in the first ``p`` terms.
if self.is_geometric() or self.is_quasigeometric():
no_powers = True
for i in range(1,6*p+1):
if _is_p_power(self(i), p) :
no_powers = False
break
if no_powers:
if _is_p_power(self.u0,p):
return [0]
return []
else :
raise ValueError("The degenerate binary recurrence sequence is geometric or quasigeometric and has many pth powers.")
#If the sequence is degenerate without being geometric or quasigeometric, there
#may be many ``p`` th powers or no ``p`` th powers.
elif (self.b**2+4*self.c) == 0 :
#This is the case if the matrix F is not diagonalizable, ie b^2 +4c = 0, and alpha/beta = 1.
alpha = self.b/2
#In this case, u_n = u_0*alpha^n + (u_1 - u_0*alpha)*n*alpha^(n-1) = alpha^(n-1)*(u_0 +n*(u_1 - u_0*alpha)),
#that is, it is a geometric term (alpha^(n-1)) times an arithmetic term (u_0 + n*(u_1-u_0*alpha)).
#Look at classes n = k mod p, for k = 1,...,p.
for k in range(1,p+1):
#The linear equation alpha^(k-1)*u_0 + (k+pm)*(alpha^(k-1)*u1 - u0*alpha^k)
#must thus be a pth power. This is a linear equation in m, namely, A + B*m, where
A = (alpha**(k-1)*self.u0 + k*(alpha**(k-1)*self.u1 - self.u0*alpha**k))
B = p*(alpha**(k-1)*self.u1 - self.u0*alpha**k)
#This linear equation represents a pth power iff A is a pth power mod B.
if _is_p_power_mod(A, p, B):
raise ValueError("The degenerate binary recurrence sequence has many pth powers.")
return []
#We find ``p`` th powers using an elementary sieve. Term `u_n` is a ``p`` th
#power if and only if it is a ``p`` th power modulo every prime `\\ell`. This condition
#gives nontrivial information if ``p`` divides the order of the multiplicative group of
#`\\Bold(F)_{\\ell}`, i.e. if `\\ell` is ` 1 \mod{p}`, as then only `1/p` terms are ``p`` th
#powers modulo `\\ell``.
#Thus, given such an `\\ell`, we get a set of necessary congruences for the index modulo the
#the period of the sequence mod `\\ell`. Then we intersect these congruences for many primes
#to get a tight list modulo a growing modulus. In order to keep this step manageable, we
#only use primes `\\ell` that are have particularly smooth periods.
#Some congruences in the list will remain as the modulus grows. If a congruence remains through
#7 rounds of increasing the modulus, then we check if this corresponds to a perfect power (if
#it does, we add it to our list of indices corresponding to ``p`` th powers). The rest of the congruences
#are transient and grow with the modulus. Once the smallest of these is greater than the bound,
#the list of known indices corresponding to ``p`` th powers is complete.
else:
if Bound < 3 * p :
powers = []
ell = p + 1
while not is_prime(ell):
ell = ell + p
F = GF(ell)
a0 = F(self.u0); a1 = F(self.u1) #a0 and a1 are variables for terms in sequence
bf, cf = F(self.b), F(self.c)
for n in range(Bound): # n is the index of the a0
#Check whether a0 is a perfect power mod ell
if _is_p_power_mod(a0, p, ell) :
#if a0 is a perfect power mod ell, check if nth term is ppower
if _is_p_power(self(n), p):
powers.append(n)
a0, a1 = a1, bf*a1 + cf*a0 #step up the variables
else :
powers = [] #documents the indices of the sequence that provably correspond to pth powers
cong = [0] #list of necessary congruences on the index for it to correspond to pth powers
Possible_count = {} #keeps track of the number of rounds a congruence lasts in cong
#These parameters are involved in how we choose primes to increase the modulus
qqold = 1 #we believe that we know complete information coming from primes good by qqold
M1 = 1 #we have congruences modulo M1, this may not be the tightest list
M2 = p #we want to move to have congruences mod M2
qq = 1 #the largest prime power divisor of M1 is qq
#This loop ups the modulus.
while True:
#Try to get good data mod M2
#patience of how long we should search for a "good prime"
patience = 0.01 * _estimated_time(lcm(M2,p*next_prime_power(qq)), M1, len(cong), p)
tries = 0
#This loop uses primes to get a small set of congruences mod M2.
while True:
#only proceed if took less than patience time to find the next good prime
ell = _next_good_prime(p, self, qq, patience, qqold)
if ell:
#gather congruence data for the sequence mod ell, which will be mod period(ell) = modu
cong1, modu = _find_cong1(p, self, ell)
CongNew = [] #makes a new list from cong that is now mod M = lcm(M1, modu) instead of M1
M = lcm(M1, modu)
for k in range(M // M1):
for i in cong:
CongNew.append(k * M1 + i)
cong = set(CongNew)
M1 = M
killed_something = False #keeps track of when cong1 can rule out a congruence in cong
#CRT by hand to gain speed
for i in list(cong):
if not (i % modu in cong1): #congruence in cong is inconsistent with any in cong1
cong.remove(i) #remove that congruence
killed_something = True
if M1 == M2:
if not killed_something:
tries += 1
if tries == 2: #try twice to rule out congruences
cong = list(cong)
qqold = qq
qq = next_prime_power(qq)
M2 = lcm(M2,p*qq)
break
else :
qq = next_prime_power(qq)
M2 = lcm(M2,p*qq)
cong = list(cong)
break
#Document how long each element of cong has been there
for i in cong:
if i in Possible_count:
Possible_count[i] = Possible_count[i] + 1
else :
Possible_count[i] = 1
#Check how long each element has persisted, if it is for at least 7 cycles,
#then we check to see if it is actually a perfect power
for i in Possible_count:
if Possible_count[i] == 7:
n = Integer(i)
if n < Bound:
if _is_p_power(self(n),p):
powers.append(n)
#check for a contradiction
if len(cong) > len(powers):
if cong[len(powers)] > Bound:
break
elif M1 > Bound:
break
return powers
