def euler69():
result = 1
i = 1
while result * prime(i) < 1000000:
result *= prime(i)
i += 1
print(result)
def find_tuncatable_primes(limit=100000):
primes = []
for x in range(5, limit):
prime = sympy.prime(x)
if check_trucations(prime):
primes.append(prime)
return primes
def opt_factorial_factors(factorial_n):
prime_factors = {}
for i in xrange(1, sympy.primepi(factorial_n) + 1):
p = sympy.prime(i)
k = prime_exponent(factorial_n, p)
prime_factors[p] = k
return prime_factors
def test_mat_inv_mul():
# Uses SymPy generated primes as matrix entries, so each entry in
# each matrix should be symbolic and unique, allowing proper comparison.
# Checks _mat_inv_mul against Matrix.inv / Matrix.__mul__.
from sympy import Matrix, prime
# going to form 3 matrices
# 1 n x n
# different n x n
# 1 n x 2n
n = 3
m1 = Matrix(n, n, lambda i, j: prime(i * n + j + 2))
m2 = Matrix(n, n, lambda i, j: prime(i * n + j + 5))
m3 = Matrix(n, n, lambda i, j: prime(i + j * n + 2))
assert _mat_inv_mul(m1, m2) == m1.inv() * m2
assert _mat_inv_mul(m1, m3) == m1.inv() * m3
def apply(self, n, evaluation):
'Prime[n_]'
n_int = n.to_python()
if isinstance(n_int, int) and n_int > 0:
return Integer(sympy.prime(n_int))
expr = Expression('Prime', n)
evaluation.message('Prime', 'intpp', expr)
return
def consecutive_primes_length(n):
if n not in sum_of_primes:
starting_prime_index = 1
starting_prime = sympy.prime(starting_prime_index)
while starting_prime <= n:
total = starting_prime
# print "Starting at", starting_prime
run_length = 1
while total <= n:
# print "\tTrying run length", run_length
if sympy.isprime(total):
sum_of_primes[total] = max(
[run_length, sum_of_primes[total]])
# print "\t", total, "Is the sum of", run_length, "primes"
run_length += 1
total += sympy.prime(starting_prime_index + run_length - 1)
starting_prime_index += 1
starting_prime = sympy.prime(starting_prime_index)
return sum_of_primes[n]
def test_mat_inv_mul():
# Just a quick test to check that KanesMethod._mat_inv_mul works as
# intended. Uses SymPy generated primes as matrix entries, so each entry in
# each matrix should be symbolic and unique, allowing proper comparison.
# Checks _mat_inv_mul against Matrix.inv / Matrix.__mul__.
from sympy import Matrix, prime
from sympy.physics.mechanics import ReferenceFrame, KanesMethod
# Just need to create an instance of KanesMethod to get to _mat_inv_mul
mat_inv_mul = KanesMethod(ReferenceFrame('N'), [1], [1])._mat_inv_mul
# going to form 3 matrices
# 1 n x n
# different n x n
# 1 n x 2n
n = 3
m1 = Matrix(n, n, lambda i, j: prime(i * n + j + 2))
m2 = Matrix(n, n, lambda i, j: prime(i * n + j + 5))
m3 = Matrix(n, n, lambda i, j: prime(i + j * n + 2))
assert mat_inv_mul(m1, m2) == m1.inv() * m2
assert mat_inv_mul(m1, m3) == m1.inv() * m3
def test_swinnerton_dyer_poly():
raises(ValueError, lambda: swinnerton_dyer_poly(0, x))
assert swinnerton_dyer_poly(1, x, polys=True) == Poly(x**2 - 2)
assert swinnerton_dyer_poly(1, x) == x**2 - 2
assert swinnerton_dyer_poly(2, x) == x**4 - 10*x**2 + 1
assert swinnerton_dyer_poly(
3, x) == x**8 - 40*x**6 + 352*x**4 - 960*x**2 + 576
# we only need to check that the polys arg works but
# we may as well test that the roots are correct
p = [sqrt(prime(i)) for i in range(1, 5)]
assert str([i.n(3) for i in
swinnerton_dyer_poly(4, polys=True).all_roots()]
) == str(sorted([Add(*i).n(3) for i in permute_signs(p)]))
def main():
import sympy
lucky_set = set()
i = 5
while True:
m = sympy.prime(i)
if is_truncatable(m):
lucky_set.add(m)
if len(lucky_set) == 11:
break
i = i + 1
print(lucky_set)
print(sum(lucky_set))
def FindPrimeMod4(numberOfPrimes):
#This method calculates given number of primes j, with condition j mod 4 = 3.
listOfPrimes = []
i = 1;
while (len(listOfPrimes) < numberOfPrimes):
prime = sympy.prime(i)
if(prime%4 == 3 and prime >= 600):
listOfPrimes.append(prime)
i = i + 1
# print("Lista znalezionych liczb pierwszych spełniających warunki:")
# for j in range(0, len(listOfPrimes)):
# print(listOfPrimes[j], " ", end="")
# print("\n")
return listOfPrimes
from sympy import prime print prime(10001) # CORRECT
import sympy
limit = 10000
primes = set([sympy.prime(n) for n in xrange(1, limit)])
double_squares = [2 * n * n for n in xrange(1, limit)]
odd_composites = [n for n in range(3, limit, 2) if n not in primes]
# print primes
# print double_squares
# print odd_composites
# for odd in odd_composites:
# found = False
# for p in filter(lambda x: x < odd, primes):
# if odd - p in double_squares:
# found = True
# if not found:
# print "Found one!", p
def search(targets, fast_growing_list, remainder_set):
for target in targets:
found = False
# print "target", target
for x in fast_growing_list:
# print "testing", x
if x > target:
# print x, target
break
if target - x in remainder_set:
def truncate_back(n):
back = []
for i in range(len(str(n)) - 1, 0, -1):
back.append(int(str(n)[:i]))
return back
i = 5
count = 11
total = 0
while count > 0:
flag = True
prime = sympy.prime(i)
if not sympy.isprime(int(str(prime)[0])) or not sympy.isprime(
int(str(prime)[-1])):
i += 1
continue
right = prime
left = 0
mult = 1
while right > 0 and flag:
left += mult * (right % 10)
flag = sympy.isprime(left) and sympy.isprime(right)
right //= 10
mult *= 10
if flag:
print(prime)
count -= 1
for p2 in primes:
if p1 != p2:
if p1 + p2 not in membership_set:
# print p1+p2, "Isn't prime"
return False
if p2 + p1 not in membership_set:
return False
# print p2+p1, "Isn't prime"
# return primes, "works"
return True
perm_set = []
primes = [str(sympy.prime(x)) for x in range(1, 10000)]
# print primes
primes_set = set([str(sympy.prime(x)) for x in range(1, 10000000)])
print "Starting search"
for x in primes:
new_sets = []
for perm in perm_set:
test_set = perm + [x]
if check_all_concats(test_set, primes_set):
new_sets.append(test_set)
if len(test_set) == 5:
print test_set
print sum(map(int, test_set))
perm_set += new_sets
from sympy import prime, isprime
limit = 100000
primes = [str(prime(x)) for x in range(1, limit)]
prime_set = set(primes)
for p in primes:
for char in p:
count = 0
for replacement in map(str, range(10)):
if p.replace(char, replacement) in prime_set:
count += 1
if count == 8:
print p
# print primes
# print "1234".replace("1","4")
import sympy print(sympy.prime(10001))
#!/usr/bin/env python
from sympy import prime
from itertools import count
# ((pn - 1)**n + (pn + 1)**n) / pn**2
# remainder is 2, 2p, 2, 6p, 2, 10p, ... per problem 120
# which is [2, 2*n*p, 2, 2*n*p, ...]
# only odd-numbered primes
for n in count(1, 2):
p = prime(n)
if 2 * n * p >= 1e10:
print(n, p, 2*n*p)
break
import math
import itertools
import numpy as np
from sympy import prime
list2 = []
result = 0
n = int(input())
for i in range(1, n + 1):
if (not (prime(i))):
for j in range(1, n):
for k in range(1, n):
# list2.append([i,j,k])
result += np.gcd.reduce((i, j, k))
# print(result ,i,k,j)
else:
result += (n * n) - 1
for i in range(1, n + 1):
if (prime(i)):
result += i
print(result)
#print(list2)
# Project Euler Problem #7 # What is the 10,001st prime number? import sympy print sympy.prime(10001)
# I am only interested in arctangents between 1/100 and 1/463
MIN_TERM = 100
MAX_TERM = 463
# Generate and factor a^2+1
factors = {}
for a in range(1, MAX_TERM + 1):
factors[a] = factorint(a**2 + 1)
# Generate primes of the form 4k+1
primes = []
i = 0
while True:
i += 1
p = prime(i)
if p > MAX_TERM:
break
if p % 4 == 1:
primes.append(p)
# Generate all 5-term combinations of primes
for x1 in range(0, len(primes)):
for x2 in range(x1 + 1, len(primes)):
for x3 in range(x2 + 1, len(primes)):
for x4 in range(x3 + 1, len(primes)):
for x5 in range(x4 + 1, len(primes)):
primes_subset = {2: True, primes[x1]: True, primes[x2]: True,
primes[x3]: True, primes[x4]: True, primes[x5]: True}
# Filter squares by selected primes
return crt(moduli, residues)[0], time.time() - start
print("___________MULTI-PRIME RSA____________")
p, q, r = sympy.randprime(100, 10000), sympy.randprime(100,
10000), sympy.randprime(
100, 10000)
# p = 3
# q = 5
# r = 7
print("p =", p)
print("q =", q)
print("r =", r)
n = get_n(p, q, r)
print("n =", n)
phi_n = phi(p, q, r)
print("phi(n) =", phi_n)
# e = sympy.randprime(3, 5)
e = 3
print("e =", e)
d = library_modular_inverse(e, phi(p, q, r))
print("d =", d)
x = sympy.prime(30) # n-th prime number
# print("y = enc(x) =", encryption())
y = modular_exponentiation(x, e, n)
computed_crt, t = library_CRT(e, d, p, q, y)
print("library CRT: ", computed_crt, '\n', "time = ", t, sep='')
computed_crt, t = our_CRT(e, d, p, q, y)
print("our CRT: ", computed_crt, '\n', "time = ", t, sep='')
# triples = [(1021, 1201, 2011), (1033, 1303, 3301), (1051, 5011, 5101), (1063, 3061, 6301), (1181, 1811, 8111), (1223, 2213, 3221), (1229, 2129, 9221), (1259, 2591, 9521), (1433, 3413, 4133), (1471, 1741, 7411), (1489, 8419, 8941), (1619, 6911, 9161), (1663, 6163, 6361), (1777, 7177, 7717), (1801, 8011, 8101), (2053, 2503, 5023), (2069, 2609, 6029), (2141, 2411, 4211), (2239, 2293, 3229), (2441, 4241, 4421), (2459, 2549, 4259), (2543, 4253, 4523), (2633, 3623, 6323), (2677, 2767, 6277), (2707, 7027, 7207), (2749, 4297, 4729), (2857, 5827, 8527), (3253, 5233, 5323), (3373, 3733, 7333), (3389, 8933, 9833), (3583, 3853, 8353), (3863, 6833, 8363), (4057, 4507, 5407), (4099, 4909, 9049), (4261, 4621, 6421), (4691, 6491, 9461), (4789, 4987, 7489), (4969, 6949, 9649), (5039, 5309, 5903), (5077, 7057, 7507), (5081, 5801, 8501), (5399, 5939, 9539), (5477, 7457, 7547), (5563, 5653, 6553), (5669, 6569, 6659), (6089, 8069, 8609), (6679, 6967, 7669), (6689, 6869, 8669), (7687, 7867, 8677), (8191, 9181, 9811), (9091, 9109, 9901)]
# for triple in triples:
# diff1 = triple[2] - triple[1]
# diff2 = triple[1] - triple[0]
# print diff1 == diff2, diff1, diff2, triple
# print prime_sets
# def contains_three_permutations(n, collection):
# for x in :
# print x, sympy.prime(x)
primes_of_interest = [sympy.prime(x) for x in range(169, 1230)]
def is_permutation(n1, n2):
return Counter(str(n1)) == Counter(str(n2))
for prime in primes_of_interest:
for second_prime in primes_of_interest:
if second_prime <= prime:
continue
if is_permutation(prime, second_prime):
third_prime = 2 * second_prime - prime
if third_prime in primes_of_interest:
if is_permutation(third_prime, second_prime):
print prime, second_prime, third_prime
from itertools import compress
def rwh_primes1v1(n):
""" Returns a list of primes < n for n > 2 """
sieve = bytearray([True]) * (n // 2)
for i in range(3, int(n**0.5) + 1, 2):
if sieve[i // 2]:
sieve[i * i // 2::i] = bytearray((n - i * i - 1) // (2 * i) + 1)
return [2, *compress(range(3, n, 2), sieve[1:])]
def rwh_primes1v2(n):
""" Returns a list of primes < n for n > 2 """
sieve = bytearray([True]) * (n // 2 + 1)
for i in range(1, int(n**0.5) // 2 + 1):
if sieve[i]:
sieve[2 * i * (i + 1)::2 * i +
1] = bytearray((n // 2 - 2 * i * (i + 1)) // (2 * i + 1) + 1)
return [2, *compress(range(3, n, 2), sieve[1:])]
rwh_primes1v1(100)
rwh_primes1v2(100)
# %%
import sympy as sp
sp.prime(6)
sp.prime(10001)
# Consider the divisors of 30: 1,2,3,5,6,10,15,30.
# It can be seen that for every divisor d of 30, d+30/d is prime.
# Find the sum of all positive integers n not exceeding 100 000 000
# such that for every divisor d of n, d+n/d is prime.
import numbthy
import sympy
def divisors(n):
return set(reduce(list.__add__,
([i, n // i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))
def is_prime_generator(n):
return n if all([sympy.isprime(d + n / d) for d in divisors(n)]) else 0
counter = 0
limit = 100000000
index = 1
n = 1
while n < limit:
n = sympy.prime(index) - 1
index += 1
counter += is_prime_generator(n)
print counter
num_blocks = len(ascii_chunks)
print('No. of blocks = ', num_blocks)
# Fixing the value of q based on blocksize using prime number theory
n = np.exp(-lambertw(-1 / blocksize, k=-1))
n = int(n.real)
q = sympy.ntheory.generate.nextprime(n, ith=1)
print('Q = ', q)
prime_list = []
count = 0
temp = []
while True:
if count == blocksize:
break
p = sympy.prime(random.randint(1, blocksize))
if p not in prime_list and mod_inverse(p, q**m) != None:
prime_list.append(p)
count += 1
print('Initial Primes List (shuffled): ', prime_list)
prime_list_permutations = get_prime_list_permutations(prime_list, num_blocks)
print(prime_list_permutations)
t1 = time.time()
print('\nEncrypted : ')
encrypted_cipher = []
for chunk in range(len(ascii_chunks)):
cipher = []
for c in range(len(ascii_chunks[chunk])):
rhs = Gcd(*(v for k,v in test_values.items()))
largs = list(lhs.args).sort()
rargs = list(rhs.args).sort()
assert largs == rargs
assert \
Gcd(x, y, z).subs(test_values).evalf() == \
gcd_list(tuple(v for k,v in test_values.items())).evalf()
assert \
Gcd(x, y, z).evalf(subs=test_values) == \
gcd_list(tuple(v for k,v in test_values.items())).evalf()
# test Prime
assert \
Prime(x).subs({x:4}) == \
Prime(4)
assert \
Prime(x).subs({x:5}).evalf() == \
Number(prime(5)).evalf()
assert \
Prime(x).evalf(subs={x:6}) == \
Number(prime(6)).evalf()
print("All tests successfully passed")
else:
print(
"The test script must be run from an interpreter, "
"instead of imported as a module."
)
def test_get_nth_prime():
"""Prime numbers are generated"""
assert sympy.prime(4) == 7
assert sympy.prime(9999999) == 179424671
with pytest.raises(ValueError):
assert sympy.prime(0)
# If a is exact power b return True else return False
def is_power(a, b):
return b**int(round(math.log(a, b))) == a
power = 10
# row, column
for e in range(3, power + 1):
total.write(e, 0, "p^" + str(e))
prop.write(e, 0, "p^" + str(e))
examples.set_column(1, 13, 30.0)
# Iterate through the primes
for k in range(1, 10):
p = prime(k)
if p > 4: power = 4
if p > 10: power = 3
if p > 20: power = 1
# Write p to each rows
total.write(0, k, p)
prop.write(0, k, p)
examples.write(0, k, p)
# Initialize counts
ired_count = 0
wi_count = 0
n = p**power
for i in range(n + 1):
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Jul 23 18:22:58 2020
@author: neel
"""
"""
Program to calculate 10,001st prime number
"""
import numpy
from sympy import prime
import time
#using sympy libraries
t = time.time()
primes = prime(10001)
print(primes)
print(time.time() - t)
def chk_prime(num):
if num == 1:
return False
i = 2
if not ((num + 1) % 6 == 0 or (num - 1) % 6 == 0):
return False
# This will loop from 2 to sqrt(x)
while i * i <= num:
if num % i == 0:
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
from sympy import prime print(prime(10001))
def gen_primes(n):
return list(sympy.primerange(0, sympy.prime(n) + 1))
# Problem 10 - Find the sum of all the primes below two million.
res10 = 0
from sympy import prime
for i in range(1,2000000):
if prime(i) > 2000000:
break
res10 += prime(i)
print("Answer for problem 10 is : " + "\n" + str(res10) + '\n')
if g != 1:
return None
else:
return x % m
plaintext = input('Enter a Message : ')
m = int(input('Enter a positive integer m : '))
ascii_values = []
for c in plaintext:
ascii_values.append(ord(c))
print('ASCII values : ', ascii_values)
q = sympy.prime(10 * len(plaintext) + 1)
print('q = ', q)
prime_list = []
count = 0
temp = []
while True:
if count == len(plaintext):
break
p = sympy.prime(random.randint(1, 10 * len(plaintext)))
if p not in prime_list and mod_inverse(p, q**m) != None:
prime_list.append(p)
count += 1
print('Primes : ', prime_list)
t1 = time.time()
prime = 1
while numberOfPrimes < n:
prime += 1
if isPrime(prime):
numberOfPrimes += 1
return prime
print(nthPrime(10001))
#Solution 2
# Pip install sympy first
from sympy import prime
x = prime(10001)
print(x)
#Solution 3
def nth_prime(n):
primes = [2]
num = 3
while len(primes) < n:
for i in primes:
if num % i == 0:
break
else:
primes.append(num)
from sympy import prime
from math import log
from sys import exit
""" The algorith is based on the idea that if n= p1^a1 * p2^a2 *... pk^ak then div(n) = (a1+1)(a2+1)(a3+1)..(ak+1). div(n) = 2**500500 then ai = 2^q - 1.
the basic idea is to compute the first 500500 prime and then eliminate the last ones and increment the power of the firsts when possible. """
n = 500500
arr = [[prime(i + 1), 1] for i in xrange(0, n)]
i = n - 1
j = 0
while 1:
if j == i:
p = 1
for k in xrange(0, i + 1):
p = (p * (arr[k][0]**(arr[k][1]))) % 500500507
print p
exit(0)
if arr[j][0]**(arr[j][1] + 1) < arr[i][0]:
arr[j][1] = arr[j][
1] * 2 + 1 #the power incrementation is a power of 2 so the div(n) remain 2**500500
i -= 1
j = 0
else:
j += 1
import sympy ans = sympy.prime(10001) print(ans) # Copyright Junipyr. All rights reserved. # https://github.com/Junipyr
clientnames.append(connection.getpeername()[1])
#send server public key
connection.send('public_key='+pb.exportKey()+'\n')
print 'server send RSA public key to client'
#receive client public key
data=connection.recv(1024)
data=data.replace("client_key=",'')
data=data.replace('\r\n','')
clientPublicKey[connection.getpeername()] =data
print 'server received client ',connection.getpeername()[1],' RSA public key'
#todo try to send a, q, y
q= sympy.prime(randint(10,100))
a= dh_a(q)
x= randint(3,q) #private
y=a**x%q #public key, need to send
print 'server send client: ',connection.getpeername()[1],'Diffie-Hellman a=',a,',q=',q,',y=',y,' encrypted by client ',connection.getpeername()[1],' RSA public key'
#session_key=(client_public_key)**(own_private_key)%q
DHellman=str(a)+' '+str(q)+' '+str(y) #here can use random, but keep difficult we use 1234
client_publickey=RSA.importKey(clientPublicKey[connection.getpeername()])
DHellman=str(client_publickey.encrypt(DHellman,32))
connection.send(DHellman)
DH_client_pu_key=connection.recv(1024)
DH_client_pu_key=eval(DH_client_pu_key)
DH_client_pu_key=pr.decrypt(DH_client_pu_key)
sessionkey=str(int(DH_client_pu_key)**x%q)
print 'server received client: ',connection.getpeername()[1],' pu:',DH_client_pu_key,' and compute seesion key:',sessionkey
def primeList(beg, n):
primeList = list()
for i in range(beg,n+beg):
primeList.append(prime(i))
return primeList
import sympy
def is_pandigital(n):
return sorted(str(n)) == [str(i) for i in xrange(1, len(str(n)) + 1)]
limit = 100000000
for i in xrange(1, 100000000):
prime = sympy.prime(i)
if i % (limit / 100) == 0:
print "Checked", i, "of", limit
if is_pandigital(prime):
print prime
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)
def PrimeGenerator():
i = 0
while True:
i += 1
yield prime(i)
# Problem 7 - What is the 10 001 st prime number?
from sympy import prime # Infinite list of prime numbers
print("Answer for problem 7 is : " + "\n" + str(prime(10001)) + "\n")
"""Project Euler 7 - 10001st prime url: https://projecteuler.net/problem=7 keywords: nth-prime status: complete """ import sympy print sympy.prime(10001)
def __init__(
self,
path: str,
philosophy: str = "democratic",
criterion: str = "mass",
data=None,
):
self.philosophy = philosophy
self.criterion = criterion
self.is_forced = False
assert self.philosophy in {"democratic", "stringent"}
assert self.criterion in {"mass", "dimension"}
if data is None:
self.path = path
# print("Initialising database...")
filenames = glob(os.path.join(self.path, "*.dat"))
mvdb_data = [dict(read_completions(f)) for f in filenames]
mv_dict = {k: v for d in mvdb_data for k, v in d.items()}
self.data = mv_dict
else:
self.path = None
self.is_ordered = True
self.data = data
# initialise prime dictionary
exotics = {}
counter = 1
for k, v in self.data.items():
for model in v:
for exotic in model.quantum_numbers:
if exotic not in exotics:
exotics[conjugate_field(exotic)] = prime(counter)
exotics[exotic] = prime(counter)
counter += 1
# dict mapping exotic field (str representation) to unique prime number
self.exotic_prime_dict = exotics
self.inv_exotic_prime_dict = {v: k for k, v in self.exotic_prime_dict.items()}
term_dict = {}
counter = 1
for k, v in self.data.items():
for model in v:
n_terms = len(model.head["terms"])
for i in range(n_terms):
# sort all of the terms by side effect
term = tuple(sorted(model.head["terms"][i]))
model.head["terms"][i] = term
if term not in term_dict:
# add conj term first so that when filtering you keep
# the unconjugated term
term_dict[conjugate_term(term)] = prime(counter)
term_dict[term] = prime(counter)
counter += 1
# dict mapping sorted tuple of strings representing interaction (and
# conjugate) to unique prime number
self.term_prime_dict = term_dict
self.inv_term_prime_dict = {v: k for k, v in self.term_prime_dict.items()}
# dict mapping operator label to neutrino-mass scale estimate
self.scale_dict = None
self.symbolic_scale_dict = None
# 2D array with number of models rejected from completions of jth
# ordered operator because a subset features in completions of ith
# ordered operator
self.filter_data = np.zeros([len(self.data), len(self.data)])
# diff2 = triple[1] - triple[0]
# print diff1 == diff2, diff1, diff2, triple
# print prime_sets
# def contains_three_permutations(n, collection):
# for x in :
# print x, sympy.prime(x)
primes_of_interest = [sympy.prime(x) for x in range(169, 1230)]
def is_permutation(n1, n2):
return Counter(str(n1)) == Counter(str(n2))
for prime in primes_of_interest:
for second_prime in primes_of_interest:
if second_prime <= prime:
continue
if is_permutation(prime, second_prime):
third_prime = 2 * second_prime - prime
if third_prime in primes_of_interest:
if is_permutation(third_prime, second_prime):
print prime, second_prime, third_prime
from sympy import prime
from sympy import nextprime
from sys import exit
""" by doing the math we find out that when n=2p , the remainder is 2, otherwise it's 2*n*Pn :D, alse, 2*n < Pn
for big n """
n = 7037
p = prime(7037)
while 1:
if (2*p*n) - 10**10 >0:
print n, 2*(prime(n-2))*(n-2)
exit(1)
p = nextprime(nextprime(p))
n+=2
from sympy import prime, isprime
limit = 100000
primes = [str(prime(x)) for x in range(1, limit)]
prime_set = set(primes)
for p in primes:
for char in p:
count = 0
for replacement in map(str, range(10)):
if p.replace(char, replacement) in prime_set:
count += 1
if count == 8:
print p
# print primes
# print "1234".replace("1","4")
from sympy import prime n = 10001 print(prime(n))
def primenth(n):
nth_prime = prime(n)
return nth_prime
import random
import math
from sympy import prime
#暗号化する平文
message = 19961031
########################
###### 公開鍵の作成 ######
########################
#素数配列の作成
for i in range(500, 600):
p_candidates = []
p_candidates.append(prime(i))
print(p_candidates)
q_candidates = []
q_candidates.append(prime(i + 100))
print(q_candidates)
#randomモジュールの関数でランダムに要素を1つ選択
p = random.choice(p_candidates)
q = random.choice(q_candidates)
#数Nを作成
N = p * q
#関数lcm(最小公倍数を求める)を用意
def lcm(x, y):
