def verify_multiply_properties(start_num, end_num, step_num): for n in xrange(start_num, end_num + 1, step_num): # factor m into products of prime powers, and use multiplicative properties factor_list = factor_a_number(n, prime_list) num_of_diff_primes = len(factor_list) liouvi_n = liouvi_list[n - 1] liouvi_n_by_factor = 1 # handle all prime factors for i in range(0, num_of_diff_primes): p = factor_list[i][0] l = factor_list[i][1] liouv_p = liouvi_list[p - 1] # if l % 2 == 0: liouvi_p_power_l = 1 else: liouvi_p_power_l = liouv_p liouvi_n_by_factor *= liouvi_p_power_l print "n = %d, liouvi_n = %d, liouvi_n_by_factor = %d" % (n, liouvi_n, liouvi_n_by_factor) assert liouvi_n == liouvi_n_by_factor
def get_g_k_for_GBC_twi_prim(k, N, prime_list): # factor a number k to product of prime power # k = p1^r1*p2^r2*... factor_list = factor_a_number(k, prime_list) g_k = 1 count = len(factor_list) # using the multiplicative properties for x in range(count): p = factor_list[x][0] # prime p r = factor_list[x][1] # power of p if N % p != 0: g_p = 2 / float(p) else: g_p = 1 / float(p) # g_p_r = g(p)^r, because of multiplicative properties g_p_r = np.power(g_p, r) # multiplicative properties g_k *= g_p_r return g_k
def get_quadr_recip_using_multiplicative_properties(n, p, prime_list): check_p_is_prime = p in prime_list if(check_p_is_prime == False): print 'get_quadr_recip_using_multiplicative_properties only work for p is a prime, p %d'%(p) assert(0) if(gcd(n, p) >1): return 0 # first find reminder of m = n%p m = n%p # factor m into products of prime powers, and use multiplicative properties factor_list = factor_a_number(m, prime_list) tmp_qr = 1 count = len(factor_list) # using the multiplicative properties for x in range(count): # we can use either of the following methods to get (l | p) where l is a prime smaller than p # l = factor_list[x] # # We can further simplify the calculation by using quad_recip formula to reduce # (l | p) to (p | l) if NOT (l = 3 mod(4) and p = 3 mod(4)) # tmp2 = get_quadr_recip_brute_force(factor_list[x][0], p) # method 1 tmp2 = eul_criter(factor_list[x][0], p) # method 2 tmp3 = int(round(np.power(tmp2, factor_list[x][1] ))) tmp_qr *= tmp3 return tmp_qr
def check_c_contain_prime_factors_of_ab_gcd(ab_gcd, c): # for special case ab_gcd = 2, 3, 5, 7, we will do quick search. # we will not call factor_a_number() function. This will speed up program if(ab_gcd == 2) or (ab_gcd == 3) or (ab_gcd == 5) or (ab_gcd == 7): if (c%ab_gcd == 0): return 1 else: return 0 global g_primes_list # prime factors of ab_gcd must also be prime factor of c factor_list = factor_a_number(ab_gcd, g_primes_list) diff_prime_factor_cnt = len(factor_list) for i in range(diff_prime_factor_cnt): p = factor_list[i][0] # c must contain p as a factor if(c%p != 0): return 0 # pass all test, c contains all prime factors of ab_gcd return 1
def dirichi_char_for_n(n): prime_list = get_prime_list(n) factor_list = factor_a_number(n, prime_list) num_of_diff_primes = len(factor_list) # this will be a list of 2D matrix, each 2D matrix hold a dirich_char matrix for a prime dirich_char_mat_list =[] prim_char_stat_list = [] # handle all prime factor for i in range(0, num_of_diff_primes): p = factor_list[i][0] l = factor_list[i][1] dirich_char_p_mat, phi_p_l, coprime_list, prim_char_stat = dirich_char_power_p(p, l) print 'p = ', p, ', l = ', l, np.asarray(dirich_char_p_mat).shape dirich_char_mat_list.append(dirich_char_p_mat) prim_char_stat_list.append(prim_char_stat) print prim_char_stat # form a product of all of above matrix tmp_mat = np.eye(1) for i in range(0, num_of_diff_primes): tmp_mat = dirich_char_mat_product(tmp_mat, dirich_char_mat_list[i]) print 'n = ', n, ', matrix shape = ', np.asarray(tmp_mat).shape phi_p_n, coprime_list = eul_totie(n) # set initial default value for statistics count prim_char_stat_all = {} prim_char_stat_all['num_of_total_char'] = -1 prim_char_stat_all['num_of_prim_char'] = -1 prim_char_stat_all['num_of_non_prim_char'] = -1 # include principle char prim_char_stat_all['num_of_real_char'] = -1 num_of_total_char_all = 1 num_of_prim_char_all = 1 num_of_prim_char_real = 1 for i in range(0, num_of_diff_primes): num_of_total_char_all = num_of_total_char_all*prim_char_stat_list[i]['num_of_total_char'] num_of_prim_char_all = num_of_prim_char_all*prim_char_stat_list[i]['num_of_prim_char'] num_of_prim_char_real = num_of_prim_char_real*prim_char_stat_list[i]['num_of_real_char'] prim_char_stat_all['num_of_total_char'] = num_of_total_char_all prim_char_stat_all['num_of_prim_char'] = num_of_prim_char_all prim_char_stat_all['num_of_non_prim_char'] = num_of_total_char_all - num_of_prim_char_all prim_char_stat_all['num_of_real_char'] = num_of_prim_char_real print prim_char_stat_all return tmp_mat, phi_p_n, coprime_list, prim_char_stat_all
def jacob_sym(n, q, prime_list): # jacob_sym is only defined for odd number q. assert(q%2 == 1) # using formula of product to calculate jacob factor_list = factor_a_number(q, prime_list) tmp_jaco = 1 count = len(factor_list) for x in range(count): tmp2 = get_quadr_recip_brute_force(n, factor_list[x][0]) tmp3 = int(round(np.power(tmp2, factor_list[x][1] ))) tmp_jaco *= tmp3 return tmp_jaco
def krone_sym(a, n, prime_list): # print 'a = ', a, ', n = ', n # calculate (a/0) and return if(n == 0): if (a == 1) or (a == -1): tmp_krone = 1 else: tmp_krone = 0 return tmp_krone # calculate (a/-1) a_minus_1 = 1 if (n < 0): if(a >= 0 ): a_minus_1 = 1 else: a_minus_1 = -1 n_tmp = -n else: n_tmp = n tmp_krone = a_minus_1 if(n == 1) or (n == -1): tmp_krone = a_minus_1 return tmp_krone # print 'a_minus_1 = ', a_minus_1 # using formula of product to calculate krone_sym factor_list = factor_a_number(n_tmp, prime_list) count = len(factor_list) # i will become 1 if first prime factor is 2, otherwise, it will stay 0 i = 0 # calculate (a/2) if 2 is a factor of n a_2 = 1 # if 1st factor = 2, calculate (a/2) if(factor_list[0][0] == 2): # a is even if(a%2 == 0): tmp1 = 0 # a odd and 1 mod(8) or 7 mod(8) if(a%8 == 1 )or (a%8 == 7 ): tmp1 = 1 # a odd and 3 mod(8) or 5 mod(8) if(a%8 == 3 )or (a%8 == 5 ): tmp1 = -1 # get the power of (a/2)^factor_list[0][1] # if a is also even, this will deal with 0^x (where x is power factor). # a_2 = int(round(np.power(tmp1, factor_list[0][1] ))) # adjust the starting for other prime factor i = 1 # multiply a_2 tmp_krone *= a_2 # print 'a_2 = ', a_2 # get the rest of prime factor for x in range(i, count): tmp2 = get_quadr_recip_brute_force(a, factor_list[x][0]) tmp3 = int(round(np.power(tmp2, factor_list[x][1] ))) tmp_krone *= tmp3 # print 'tmp_krone = ', tmp_krone return tmp_krone