Question

You may import the following library functions in your module:

from fractions import gcd

from math import log

from math import floor

'You may also use:

• the built-in pow() function to compute modular exponents efficiently (i.e., ak mod n can be written in Python as pow(a,k,n)),

You may also need to import your hw3 (will be attached below)

5. Implement a function makePrime(d) that takes a single integer argument d where d >= 1 and returns a probably prime number that has exactly d digits. Your implementation should be sufficiently efficient to produce an output for d = 100 in a reasonably short amount of time. Implementations that perform an exponentially large exhaustive search, even if the algorithm is mathematically correct, will not earn full credit.

>>> makePrime(2)

47

>>> makePrime(100) 3908330587430939367983163094172482420761782436265274101479718696329311615357177668931627057438461519

hw3 functions

def closest(t, ks):
"""takes 2 arguments a target t and list of ints ks and returns in k in
ks that is closes to t"""
return min(ks, key=lambda p: abs(p-t))

def findCoprime(m):
"""takes a single positive int m and returns an int b where b > 1 and b is
coprime with m""""
for i in range(2,x):
if math.gcd(i, x) == 1:
return i

def randByIndex(m, i):
"""takes 2 positive integer arguments m represents the upper bound of random numbers
generated and i represents a index specifying which random number in the sqeuence
should be generated"""
return (i * findCoprime(n)) % n

Answer 1

from fractions import gcd
from math import log

'''
Z = all integers

Problem 1(a)
4 * x + 1 = 9 (mod 17)
4 * x = 8 (mod 17)
4 * x = 4 * 2 (mod 17)
x = 2 (mod 17)
Solution: x = 2 + 17Z

Problem 1(b)
x = -6 (mod 13)
x = 7 (mod 13)
Solution: x = 7 + 13Z

Problem 1(c)
40 * x = 5 (mod 8)
0 * x = 5 (mod 8)      # x * 0 must equal 0
Solution: NONE

Problem 1(d)
3 * x + 1 = 1 (mod 3)
3 * x = 0 (mod 3)
0 * x = 0 (mod 3)    
Solutions: x in {0 + 3Z, 1 + 3Z, 2 + 3Z}

Problem 1(e)
5 * x + 7 = 13 (mod 29)
5 * x = 6 (mod 29)
5 * x = 35 (mod 29)    
5 * x = 5 * 7 (mod 29)
x = 7 (mod 29)           #can cancel because 29 is prime and 5 = 0 (mod 29)
Solution: x = 7 + 29Z

Problem 1(f)
1 + 2 * x = 2 (mod 10)
2 * x = 1 (mod 10)
Solution: NONE

Problem 1(g)
17 * x + 11 = 300 (mod 389)
17 * x = 289 (mod 389)
17 * x = 17 * 17 (mod 389)
x = 17 (mod 389)            #can cancel 17 on both sides because 389 is prime)
Solution: x = 17 + 389Z

Problem 1(h)
650472472230302 * x = 1 (mod 8910581811374)
0 * x = 1 (mod 8910581811374)
Solution: NONE

Problem 1(i)
48822616 * x = 14566081015752 (mod 3333333333333333333333333)
48822616 * x = 48822616 * 298347 (mod 3333333333333333333333333)    #48822616 and 3333333333333333333333333
x = 298347 (mod 3333333333333333333333333)                          #are coprime, cancel 48822616 on both sides
Solution: x = 298347 + 3333333333333333333333333Z
'''

#--------------------------------------------------------------------------

# Problem 2
def closest(t, ks):
k = ks[0]
diff = abs(t-ks[0])
for y in ks:
      if abs(t-y) < diff:
          diff = abs(t-y)
          k = y
return k

#--------------------------------------------------------------------------

# Problem 3a
# Gather coprimes into a list, then return closest to (4/7)*m
def findCoprime(m):
coprimes = list()

# Method for odd numbers
if m % 2 == 1:
    k = int(log((4/7)*m, 2))
    coprimes.extend([pow(2,k),pow(2,k+1),pow(2,k-1)])

# Method for all numbers
# Find coprime close to (1/2)m, then stop iteration
for b in range( (m//2)+1, m ):
    if gcd(m, (b // gcd(m, b))) == 1:
      coprimes.extend([(b//gcd(m,b))])
      break

# Method for all numbers
p = 4*m//7
#if(p < 3): p = 3            # p must be in {3,...,m-1}
while( gcd(p-1,m) != 1 ):   # not coprime
    p = (p * gcd(p-1,m))
coprimes.append((p-1) % m)

return closest(((m*4)//7)+1,coprimes)

#--------------------------------------------------------------------------

# Problem 3b
# Do not need to find closest coprime to (4/7)*m
# ...because findCoprime(m) already does
def randByIndex(m,i):
b = findCoprime(m)
return( (b*i) % m )

#--------------------------------------------------------------------------

#Probelm 4
def probablePrime(m):
for k in set(range(1,m.bit_length()+1)):
    if randByIndex(m,k)>1: a = randByIndex(m,k)
    if (m%a)==0: return False
    if gcd(a,m) != 1: return False
    if pow(a,m-1,m) != 1: return False
return True

#--------------------------------------------------------------------------

#Problem 5
def makePrime(d):
#number of primes with d-digits
numPrimes = ((pow(10,d))//(log(pow(10,d)))) - ((pow(10,d-1)+1)//(log(pow(10,d-1)+1)))

#chance of being prime
chancePrime = numPrimes/((pow(10,d)+1) - pow(10,d-1))

#number of random numbers we need to check
kk = int(1/chancePrime) + 1

i = 1 #counter to iterate through random index list

# multiply kk by 10 to increase chances of randomly finding prime number
for k in set(range(0,kk*10)):   
    n = 0
    while(n == 0):
      if( randByIndex(pow(10,d),i) >= pow(10,d-1) ):
        n = randByIndex(pow(10,d),i)
        i = i + 1
        break
      i = i + 1
    if probablePrime(n): return n