def close_primes_attack(self, quantity=2):
middle = int_root(quantity, self.n)
if sympy.isprime(middle):
primes_base = [middle]
for i in range(quantity):
primes = primes_base[:]
for j in range(i): # previous
primes = [sympy.prevprime(primes[0])] + primes
for j in range(quantity - i - 1): # next
primes = primes + [sympy.nextprime(primes[-1])]
n = functools.reduce(operator.mul, primes)
if n == self.n:
return primes
else:
primes_base = [sympy.prevprime(middle), sympy.nextprime(middle)]
for i in range(1, quantity):
primes = primes_base[:]
for j in range(i - 1): # previous
primes = [sympy.prevprime(primes[0])] + primes
for j in range(quantity - i - 1): # next
primes = primes + [sympy.nextprime(primes[-1])]
n = functools.reduce(operator.mul, primes)
if n == self.n:
return primes
return None
def init_second_screen():
self.remove_widget(self.first_screen)
p = self.p_choice
q = self.q_choice
self.n = p * q
phi = (p - 1) * (q - 1)
e = sy.prevprime(int(phi / 2))
while (sy.gcd(e, phi) != 1):
e = sy.nextprime(e)
if (e > phi):
e = sy.nextprime(e % phi)
d = sy.invert(e, phi)
self.key_pub.text = "Public key (e, n) = (" + str(e) + "," + str(
self.n) + ")"
self.key_pri.text = "Private key (d, n) = (" + str(d) + "," + str(
self.n) + ")"
if (len(self.key_pub.text) > 100):
self.key_pub.text = "Public key (e, n) = \n(" + str(
e) + ",\n" + str(self.n) + ")"
if (len(self.key_pri.text) > 100):
self.key_pri.text = "Private key (d, n) = \n(" + str(
d) + ",\n" + str(self.n) + ")"
self.rsa_crack.bind(on_press=crack_rsa)
self.add_widget(self.second_screen)
def general_collatz_orbit(term, k=3, upper_bound=10**10000):
"""Generaliztion proposed by
Zhang Zhongfu and Yang Shiming
and found in
http://web.mit.edu/rsi/www/pdfs/papers/2004/2004-lesjohn.pdf
Returns a list of numbers in the collatz
tree from term -> 1, the cycle, or the terms less than the upper bound
Simple check for each through last term
if convergent: last term = 1
if cycle: last term = first term
if violate upper bound: last term is inf"""
current = term
orbit = [current]
while True:
divisor_success = False
p = k
while True:
try:
p = prevprime(p)
except:
break
if current % p == 0:
divisor_success = True
current = current // p
if not divisor_success:
current = k * current + 1
if current in orbit:
orbit.append(current)
return orbit
orbit.append(current)
if current == 1:
return orbit
if current > upper_bound:
orbit.append(inf)
return orbit
def check_general_collatz(term, k=3, upper_bound=10**10000):
"""Generaliztion proposed by
Zhang Zhongfu and Yang Shiming
and found in
http://web.mit.edu/rsi/www/pdfs/papers/2004/2004-lesjohn.pdf"""
current = term
repeat_check = {current}
while True:
divisor_success = False
p = k
while True:
try:
p = prevprime(p)
except:
break
if current % p == 0:
divisor_success = True
current = current // p
if not divisor_success:
current = k * current + 1
if current in repeat_check:
return False
repeat_check.add(current)
if current == 1:
return True
if current > upper_bound:
return None
def general_collatz_tree(M, k=3, root=1):
'''I am SO truly sorry for the running time
of this algorithm. It has no choice but to be
exponential due to tree growth
Generalization for all Collatz Trees'''
tree = Graph()
tree.add_vertex(root)
frontier = Queue()
frontier.push(root)
primes = []
p = k
while True:
try:
p = prevprime(p)
except:
break
primes.append(p)
while len(tree) < M:
x = frontier.pop()
for i in range(len(primes) + 1):
for tup in combinations(primes, i):
y = x
for prime in tup:
y = y * prime
if y not in tree:
tree.add_vertex(y)
tree.add_edge(x, y)
frontier.push(y)
if (x - 1) % k == 0:
y = (x - 1) // k
if y not in tree:
tree.add_vertex(y)
tree.add_edge(x, y)
frontier.push(y)
return tree
def main():
start = 7654321
while True:
prevp = prevprime(start)
if set(str(prevp)) == set('1234567'):
return prevp
else:
start = prevp
def prime_to_bv(self, p):
import sympy
pp = sympy.prevprime(p)
end = p - 1
start = pp
bv = UncertainBitVector(p.bit_length(), start)
bv = bv ^ UncertainBit("X").repeat((start ^ end).bit_length())
return bv
def nextprime(value):
if value >= 1:
return sp.nextprime(value)
elif value == (0 or -1):
return 1
elif value == -2:
return -1
else:
negative = sp.prevprime(-value)
return negative * -1
def prevprime(value):
if value > 2:
return sp.prevprime(value)
elif value == (0 or 1):
return -1
elif value == 2:
return 1
else:
negative = sp.nextprime(abs(value))
return negative * -1
def general_collatz_single_iteration(term, k=3):
current = term
divisor_success = False
p = k
while True:
try:
p = prevprime(p)
except:
break
if current % p == 0:
divisor_success = True
current = current // p
if not divisor_success:
current = k * current + 1
return current
def factor_int(modulus):
lol = int("%d" % sqrt(modulus))
next = lol
nexts = []
for i in range(10):
next = nextprime(next)
nexts.append(next)
prev = lol
for i in range(10):
prev = prevprime(prev)
for next in nexts:
if prev * next == modulus:
return (prev, next)
def run(self):
global exitFlag
start = int(
math.ceil(self.n**(0.5) * (self.threadID / self.threadCount)))
stop = int(
math.floor(self.n**(0.5) *
((self.threadID - 1) / self.threadCount)))
candidate_root = start
if (stop == 0):
stop = 3
while (self.n % candidate_root != 0 and candidate_root > stop
and exitFlag == 0):
candidate_root = sy.prevprime(candidate_root)
if (self.n % candidate_root == 0):
exitFlag = 1
self.found = candidate_root
def lsh(data, bands):
r = data.shape[0] / bands
largestPrime = prevprime(2**31 - 1)
print "Num of Bands", bands, "r", r
nusers = data.shape[1]
# make new array
sigMatA = np.zeros((bands, nusers), dtype=np.float64) # b x num of users
newData = data.reshape(bands, r, nusers)
a = np.random.randint(largestPrime, size=(bands, r, 1))
a = np.repeat(a, nusers, axis=2)
b = np.random.randint(largestPrime, size=(bands, r, 1))
b = np.repeat(b, nusers, axis=2)
new = (a * newData + b) % largestPrime
sigMatA = np.sum(new, axis=(1))
return sigMatA
def run(self):
global exitFlag
self.found = 0
start_time = perf_counter()
start = int(
math.ceil(self.n**(0.5) * (self.threadID / self.threadCount)))
stop = int(
math.floor(self.n**(0.5) *
((self.threadID - 1) / self.threadCount)))
candidate_root = start
if (stop == 0):
stop = 3
while (self.n % candidate_root != 0 and candidate_root > stop
and exitFlag == 0):
if ((perf_counter() - start_time) > self.max_time):
self.found = -1
break
candidate_root = sy.prevprime(candidate_root)
if (self.n % candidate_root == 0):
exitFlag = 1
self.found = candidate_root
return [False, True][n]
elif not n & 1:
return False
else:
s, d = 0, n - 1
while not d & 1:
s += 1
d >>= 1
for _ in repeat(None, t):
if isComposite(randrange(2, n)):
return False
return True
#Mersenne list without 3
def MersenneNumber(n):
temp = (2**j - 1 for j in range(3, 1234, 2)
if isPrime(j) and isPrime(2**j - 1))
return [temp.next() for i in range(n)]
# temp = ( 2**j - 1 for j in range(3,1234,2) if sympy.isprime(j) and sympy.isprime(2**j-1))
if __name__ == "__main__":
print "(Greatest prime smaller than first n Mersenne primes)"
n = input("n (n < 15) = ")
A = [3]
A += MersenneNumber(n - 1)
for i in A:
print sympy.prevprime(i)
def get_test_input(_min, _max, max_list_len, _type):
test_list = list()
test_item = list()
test_item2 = list()
test_item3 = list()
test_item4 = list()
test_list.append(list())
rand = 0
prime = 0
prime_n = 0
prev_prime = 0
next_prime = 0
# Random number test case
for i in range(max_list_len + 1):
rand = random.randrange(_min, _max + 1)
test_item.append(rand)
test_list.append(test_item)
test_item = []
for i in range(max_list_len + 1):
num = i**2
if num <= _max:
test_item.append(num)
else:
break
for j in range(i, max_list_len + 1):
test_item.append(test_item[j % i])
test_list.append(test_item)
test_item = []
for i in range(max_list_len + 1):
num = i**3
if num <= _max:
test_item.append(num)
else:
break
for j in range(i, max_list_len + 1):
test_item.append(test_item[j % i])
test_list.append(test_item)
test_item = []
for i in range(max_list_len + 1):
num = i**4
if num <= _max:
test_item.append(num)
else:
break
for j in range(i, max_list_len + 1):
test_item.append(test_item[j % i])
test_list.append(test_item)
test_item = []
if _min < 0:
for i in range(max_list_len + 1):
rand = random.randrange(_min, 0)
test_item.append(rand)
test_list.append(test_item)
test_item = []
for i in range(max_list_len + 1):
test_item.append(0)
test_list.append(test_item)
test_item = []
for i in range(max_list_len + 1):
prime = sympy.primerange(_min, _max + 1)
prime_n = sympy.prime(n)
prev_prime = sympy.prevprime(n)
next_prime = sympy.nextprime(n)
test_item.append(prime)
test_item2.append(prime_n)
test_item3.append(prev_prime)
test_item4.append(next_prime)
test_list.append(test_item)
test_list.append(test_item2)
test_list.append(test_item3)
test_list.append(test_item4)
test_item = []
test_item2 = []
test_item3 = []
test_item4 = []
for item in test_list:
print("test_list", item)
import sympy sympy.isprime(5) list(sympy.primerange(0, 100)) sympy.randprime(0, 100) sympy.randprime(0, 100) sympy.prime(3) sympy.prevprime(50) sympy.nextprime(50) list(sympy.sieve.primerange(0, 100))
import sympy as sp
n = int(input())
counter = 0
while n >= 2:
counter += 1
n = n - sp.prevprime(n + 1)
if (n == 1):
print(counter + 1)
else:
print(counter)
def knj_factorize(n):
curr = math.floor(n ** 0.5)
while curr > 1:
if n % curr == 0:
return (curr, int(n / curr))
curr = sympy.prevprime(curr)
import sympy
arr = list(sympy.primerange(2, 200))
for i in arr:
if (sympy.isprime(2**i - 1)):
print sympy.prevprime(2**i - 1)
plt.plot(base_b_seq(1000, 19))
# In[8]:
from sympy import prevprime
# Maximum of b_k(n) out to a moderately large n.
max_base = 40
maxima = [(k, max(base_b_seq(50000, k))) for k in range(2, max_base + 1)]
# Maximum looks suspiciously like k^3.
plt.figure(figsize=(10, 5))
plt.plot([maximum for _, maximum in maxima],
label=r"empirical maximum of $a_b(n)$")
plt.plot([k**3 for k in range(2, max_base + 1)], label=r"$b^3$")
[(k, prevprime(k**3), max) for k, max in maxima[1:]]
plt.legend()
# # Conjectures
#
# Let $a(n) = \max_k b_n(k)$, if such a maximum exists.
#
# 1. (Mine) $a(n) <= n^3$ for all $n$. (Maybe even $\limsup_n a(n) / n^3 = 1$, if I'm feeling bold.)
# 2. (Neil Sloane) $a(n) = n - 1$ iff $n - 1$ is $1$ or an odd prime.
#
# ## What we know
#
# Neil's conjecture is (at least) two-thirds of the way correct.
#
# **Proposition.** $a(n) = n - 1$ if $n - 1$ is $1$ or an odd prime.
#
import sympy
print('5 is a Prime Number',sympy.isprime(5))
print(list(sympy.primerange(0,100))
print(sympy.randprime(0,100)) #Output 83
print(sympy.randprime(0,100)) #Output 41
print(sympy.prime(3)) #Output 5
print(sympy.prevprime(50)) #Output 47
print(sympy.nextprime(50)) #Output 53
# lastprime = pakke
if (pakke in kastedepakker):
continue
if (str('7') in str(pakke)):
#for i in range(lastprime, pakke+1):
# if isPrime(i):
# lastprime = i
##fantprime = False
##i = pakke
##while not fantprime:
## if isPrime(i):
## lastprime = i
## fantprime = True
## else:
## i -= 1
lastprime = sympy.prevprime(pakke + 1)
nLevertepakker = pakke - len(kastedepakker)
kastedepakker.extend(allepakker[pakke:pakke + lastprime + 1])
#Slow?
#levertepakker = numpy.setdiff1d(allepakker, kastedepakker)
#print("Antall leverte pakker: ", len(levertepakker))
print("Antall leverte pakker: ", nLevertepakker)
#print(levertepakker)
import sympy as sy
g = int(input())
ans = 0
if sy.isprime(g):
ans = 1
else:
while g > 0:
close = sy.prevprime(g)
if g - close == 1:
g -= 1
close = sy.prevprime(g)
g += 1
ans += 1
g = g - close
if sy.isprime(g) == 1:
ans += 1
break
print(ans)
import sympy as sp
import math as m
num = 600851475143
i = m.sqrt(num)
while (True):
if (num % i == 0 and sp.isprime(i)):
print(i)
break
else:
i = sp.prevprime(i)
def is_perm(n, d):
s = str(n)
r = str(d[n])
if sorted(s) == sorted(r):
return True
return False
res = []
start = time.time()
i = 3163
flag = False
while True:
#print(i)
for j in primerange(prevprime(i), 10000000 / i):
memo[i * j] = phi(i * j)
if is_perm(i * j, memo):
res.append((i * j / memo[i * j], i * j))
if len(res) > 10:
flag = True
if time.time() - start > 10:
print(i, len(memo))
start = time.time()
if flag:
break
i = prevprime(i)
print(len(res), len(memo))
res.sort()
print(res[0])
