def root_method(n): a = intsqrt(n) + 1 test = intsqrt(a**2 - n) while not (test**2 == (a**2 - n)): a = a + 1 test = intsqrt(a**2 - n) return (a, test)
def root_method(N): a = intsqrt(N) b2 = 1 b = 0 while (b*b != b2): a += 1 b2 = a*a-N b = intsqrt(b2) return a-b
def root_method(N): a = intsqrt(N) if a*a < N: a = a + 1 while True: b=intsqrt(a*a - N) if b*b == a*a - N: return a-b a=a+1
def root_method(N): a = intsqrt(N) while a*a - N < 0: a += 1 while (a*a-N) != intsqrt(a*a-N)*intsqrt(a*a-N): a += 1 b = intsqrt(a*a-N) return a-b
def root_method(N): a = intsqrt(N) if a * a < N: a = a + 1 while True: b = intsqrt(a * a - N) if b * b == a * a - N: return a - b a = a + 1
def root_method(N): a = intsqrt(N) + 1 for i in range(a, N + 1): b = intsqrt(i**2 - N) if b % 1 == 0: print(b) return i - b
def root_method(N): """ 1. initialize integer a to be an integer greater than root(N) 2. check if root(a^2 - N) is an integer 3. is so, let b = root(a^2 - N). return a - b. 4. If not, repeat with the next greater value of a. """ a = math.floor(factoring_support.intsqrt(N)) + 1 while True: b = factoring_support.intsqrt(a**2 - N) if is_integer(b): return a - b a += 1
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = [] rowlist = [] size = len(primeset) + 1 t=2 count=0 while count < size: a=intsqrt(N)+t factors = dumb_factor(a*a-N, primeset) if len(factors) > 0: roots.append(a) rowlist.append(make_Vec(primeset,factors)) count = count + 1 t=t+1 return (roots, rowlist)
def find_a_and_b(v, roots, N): ''' Input: - a {0,1,..., n-1}-vector v over GF(2) where n = len(roots) - a list roots of integers - an integer N to factor Output: a pair (a,b) of integers such that a*a-b*b is a multiple of N (if v is correctly chosen) ''' alist = [] d=[] for k, v in v.f.items(): if v == one: d.append(k) for n, root in enumerate(roots): if n in d: alist.append(root) a = prod(alist) c = prod(x*x -N for x in alist) b = intsqrt(c) if b*b == c: return a, b
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' s = intsqrt(N)+2 roots = [] rowlist = [] while True: if len(roots) > len(primeset): break result = dumb_factor(s*s-N, primeset) if len(result)> 0: roots.append(s) rowlist.append(make_Vec(primeset, result)) s = s+1 return (roots, rowlist)
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = [] rowlists = [] target_count = len(primeset) + 1 x = intsqrt(N) + 2 while (len(roots) < target_count): factors = dumb_factor(x * x - N, primeset) if len(factors) > 0: v = make_Vec(primeset, factors) roots.append(x) rowlists.append(v) x = x + 1 return (roots, rowlists)
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots=[] rowlist = [] i = 2 k=0 while k < len(primeset)+1: x = intsqrt(N)+i T = dumb_factor(x*x - N, primeset) if T != []: roots.append(x) factors = T row = make_Vec(primeset, factors) rowlist.append(row) k +=1 i +=1 return roots, rowlist
def find_a_and_b(v, roots, N): ''' Input: - a {0,1,..., n-1}-vector v over GF(2) where n = len(roots) - a list roots of integers - an integer N to factor Output: a pair (a,b) of integers such that a*a-b*b is a multiple of N (if v is correctly chosen) ''' alist = [] d = [] for k, v in v.f.items(): if v == one: d.append(k) for n, root in enumerate(roots): if n in d: alist.append(root) a = prod(alist) c = prod(x * x - N for x in alist) b = intsqrt(c) if b * b == c: return a, b
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = list() rowlist = list() count = 0 i = 2 while count < len(primeset) + 1: x = intsqrt(N) + i df = dumb_factor(x*x -N,primeset) if len(df) != 0: roots.append(x) rowlist.append(make_Vec(primeset,df)) count +=1 i += 1 return (roots,rowlist) pass
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' x = intsqrt(N) + 2 roots = [] rowlist = [] while len(roots) <= len(primeset): y = x*x - N tmprow = dumb_factor(y, primeset) if tmprow != []: roots.append(x) rowlist.append(make_Vec(primeset, tmprow)) x += 1 return (roots, rowlist)
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = [] rowlist = [] i = 2 k = 0 while k < len(primeset) + 1: x = intsqrt(N) + i T = dumb_factor(x * x - N, primeset) if T != []: roots.append(x) factors = T row = make_Vec(primeset, factors) rowlist.append(row) k += 1 i += 1 return roots, rowlist
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = [] rowlist = [] x = intsqrt(N) + 1 while True: x += 1 factors = dumb_factor(x*x - N, primeset) if factors != []: roots.append(x) rowlist.append(make_Vec(primeset, factors)) if len(roots) > len(primeset): return (roots, rowlist)
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = [] rowlist = [] increment = 2 while len(roots) < len(primeset) + 1: x = intsqrt(N) + increment increment += 1 xx_minus_n = x ** 2 - N factors = dumb_factor(xx_minus_n, primeset) if factors: roots.append(x) rowlist.append(make_Vec(primeset, factors)) return (roots, rowlist)
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' a_list = [] a_factor_vecs = [] a = intsqrt(N) + 2 while (len(a_list) <= len(primeset)): prime_factors = dumb_factor(a**2 - N, primeset) if (len(prime_factors) > 0): a_list.append(a) ##print(len(a_list), a) a_factor_vecs.append(make_Vec(primeset, prime_factors)) a = a + 1 return (a_list, a_factor_vecs)
def root_method(N): '''(int) -> int Return first integer that is equal to sqrt(a*a - N), where a is another integer greater than sqrt(N). >>> root_method(77) 2 ''' a = intsqrt(N) if a*a < N: a += 1 while True: diff = a*a - N b = intsqrt(diff) if b*b == diff: return a-b a += 1
def root_method(N): '''(int) -> int Return first integer that is equal to sqrt(a*a - N), where a is another integer greater than sqrt(N). >>> root_method(77) 2 ''' a = intsqrt(N) if a * a < N: a += 1 while True: diff = a * a - N b = intsqrt(diff) if b * b == diff: return a - b a += 1
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = [] rowlist = [] i = 2 base = intsqrt(N) while len(roots) < len(primeset)+1: x = base + i testFac = dumb_factor(x*x-N, primeset) if len(testFac) > 0: roots.append(x) rowlist.append(make_Vec(primeset, testFac)) i += 1 return (roots, rowlist)
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = [] rowlist = [] base = intsqrt(N) + 1 while (len(roots) <= len(primeset)): ## len(roots) == len(primeset) + 1 base += 1 df = dumb_factor(base**2 - N, primeset) if df == []: continue roots.append(base) rowlist.append(make_Vec(primeset, df)) return (roots, rowlist)
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = [] rowlist = [] count = 0 x = intsqrt(N) + 1 while count < len(primeset) + 1: # start with value = (previous+1) x = x + 1 while True: factors = dumb_factor(x*x - N, primeset) # if can be factored if len(factors) != 0: factors_GF2 = make_Vec(primeset, factors) roots.append(x) rowlist.append(factors_GF2) break # if not else: x = x + 1 count = count + 1 return roots,rowlist
def find_a_and_b(v, roots, N): alist = [roots[i] for i in v.D if v[i] == one] a = prod(alist) c = prod([x * x - N for x in alist]) b = intsqrt(c) assert b * b == c return (a, b)
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = [] rowlist = [] base = intsqrt(N) + 1 while(len(roots) <= len(primeset)): ## len(roots) == len(primeset) + 1 base += 1 df = dumb_factor(base**2 - N,primeset) if df == []: continue roots.append(base) rowlist.append(make_Vec(primeset,df)) return (roots,rowlist)
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a tuple(roots, rowlist) - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = list() rowlist = list() i = 2 while len(roots) < len(primeset) + 1: x = intsqrt(N) + i factors = dumb_factor(x**2 - N, primeset) vec = make_Vec(primeset,factors) if len(factors) > 0 and len(vec.f) > 0: roots.append(x) rowlist.append(vec) i += 1 return (roots,rowlist)
def find_a_and_b(v, roots, N): ''' Input: - a {0,1,..., n-1}-vector v over GF(2) where n = len(roots) - a list roots of integers - an integer N to factor Output: a pair (a,b) of integers such that a*a-b*b is a multiple of N (if v is correctly chosen) Example: >>> roots = [51, 52, 53, 58, 61, 62, 63, 67, 68, 71, 77, 79] >>> N = 2419 >>> v = Vec({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},{1: one, 2: one, 11: one, 5: one}) >>> find_a_and_b(v, roots, N) (13498888, 778050) >>> v = Vec({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},{0: 0, 1: 0, 10: one, 2: one}) >>> find_a_and_b(v, roots, N) (4081, 1170) ''' chosen_xes = [] for label in v.D: if v[label] != 0: chosen_xes.append(roots[label]) a = 1 b = 1 for x in chosen_xes: a *= x b *= x**2 - N b = intsqrt(b) return a, b
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = [] rowlist = [] x = intsqrt(N)+2 while len(roots) <= len(primeset): xSquareMinN = x*x - N factorPair = dumb_factor(xSquareMinN , primeset) if len(factorPair) > 0: vecF = make_Vec(primeset, factorPair) roots.append(x) rowlist.append(vecF) x += 1 return (roots, rowlist)
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = list() rowlist = list() x = intsqrt(N) + 2 while (len(roots) < (len(primeset) + 1)): dumb_factored = dumb_factor(x**2 - N, primeset) if len(dumb_factored) != 0: roots = roots + [x] rowlist = rowlist + [make_Vec(primeset, dumb_factored)] x += 1 return roots, rowlist
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = [] rowlist = [] size = len(primeset) + 1 t = 2 count = 0 while count < size: a = intsqrt(N) + t factors = dumb_factor(a * a - N, primeset) if len(factors) > 0: roots.append(a) rowlist.append(make_Vec(primeset, factors)) count = count + 1 t = t + 1 return (roots, rowlist)
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = [] rowlist = [] x = intsqrt(N) + 1 while True: x += 1 factors = dumb_factor(x * x - N, primeset) if factors != []: roots.append(x) rowlist.append(make_Vec(primeset, factors)) if len(roots) > len(primeset): return (roots, rowlist)
def find_a_and_b(v, roots, N): ''' Input: - a {0,1,..., n-1}-vector v over GF(2) where n = len(roots) - a list roots of integers - an integer N to factor Output: a pair (a,b) of integers such that a*a-b*b is a multiple of N (if v is correctly chosen) Example: >>> roots = [51, 52, 53, 58, 61, 62, 63, 67, 68, 71, 77, 79] >>> N = 2419 >>> v = Vec({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},{1: one, 2: one, 11: one, 5: one}) >>> find_a_and_b(v, roots, N) (13498888, 778050) >>> v = Vec({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},{0: 0, 1: 0, 10: one, 2: one}) >>> find_a_and_b(v, roots, N) (4081, 1170) ''' alist = [roots[x] for x in range(len(roots)) if v[x]] a = prod(alist) c = prod([x**2 - N for x in alist]) b = intsqrt(c) assert b * b == c return (a, b)
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = [] rowlist = [] i = 2 base = intsqrt(N) while len(roots) < len(primeset) + 1: x = base + i testFac = dumb_factor(x * x - N, primeset) if len(testFac) > 0: roots.append(x) rowlist.append(make_Vec(primeset, testFac)) i += 1 return (roots, rowlist)
def find_a_and_b(v, roots, N): ''' Input: - a {0,1,..., n-1}-vector v over GF(2) where n = len(roots) - a list roots of integers - an integer N to factor Output: a pair (a,b) of integers such that a*a-b*b is a multiple of N (if v is correctly chosen) Example: >>> roots = [51, 52, 53, 58, 61, 62, 63, 67, 68, 71, 77, 79] >>> N = 2419 >>> v = Vec({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},{1: one, 2: one, 11: one, 5: one}) >>> find_a_and_b(v, roots, N) (13498888, 778050) >>> v = Vec({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},{0: 0, 1: 0, 10: one, 2: one}) >>> find_a_and_b(v, roots, N) (4081, 1170) ''' chosen_xes = [] for label in v.D: if v[label] != 0: chosen_xes.append(roots[label]) a = 1 b = 1 for x in chosen_xes: a *= x b *= x**2-N b = intsqrt(b) return a,b
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = [] rowlist = [] total = len(primeset) + 1 a = intsqrt(N) + 2 while len(roots) < total: row = dumb_factor(a * a - N, primeset) if not row: a += 1 continue roots.append(a) rowlist.append(make_Vec(primeset, row)) a += 1 return (roots, rowlist)
def root_method(N): a = intsqrt(N) print(a) while True: a += 1 b = sqrt(a * a - N) if b == int(b): return (a - b, a + int(b))
def find_candidates(N, primeset): roots = [] rowlist = [] x = intsqrt(N) + 2 while len(roots) < len(primeset) + 1: factors = dumb_factor(x * x - N, primeset) if len(factors) > 0: roots.append(x) rowlist.append(make_Vec(primeset, factors)) x += 1 return roots, rowlist
def find_a_and_b(M,roots,N, row): v = M[row] alist = [roots[k] for (k,v) in v.f.items() if v == one] a = prod(alist) c = prod({a*a - N for a in alist}) b = intsqrt(c) if b * b == c: return a,b else: row -= 1 return find_a_and_b(M,roots,N,row)
def root_method(N): from math import sqrt a_fail = True loop_max = 2 * N loop_count = 0 b = -1 if intsqrt(N) < sqrt(N): a = intsqrt(N) + 1 else: a = intsqrt(N) while (a_fail and loop_count < loop_max): if intsqrt(a**2 - N) == sqrt(a**2 - N): b = intsqrt(a**2 - N) a_fail = False if a_fail: a += 1 loop_count += 1 if b == -1: a = "Error: Root Not Found" return a, b
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a tuple (roots, rowlist) - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) Example: >>> from factoring_support import primes >>> N = 2419 >>> primeset = primes(32) >>> roots, rowlist = find_candidates(N, primeset) >>> set(roots) == set([51, 52, 53, 58, 61, 62, 63, 67, 68, 71, 77, 79]) True >>> D = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31} >>> set(rowlist) == set([Vec(D,{2: one, 13: one, 7: one}),\ Vec(D,{3: one, 19: one, 5: one}),\ Vec(D,{2: one, 3: one, 5: one, 13: one}),\ Vec(D,{3: one, 5: one, 7: one}),\ Vec(D,{7: one, 2: one, 3: one, 31: one}),\ Vec(D,{3: one, 19: one}),\ Vec(D,{2: one, 31: one}),\ Vec(D,{2: one, 5: one, 23: one}),\ Vec(D,{5: one}),\ Vec(D,{3: one, 2: one, 19: one, 23: one}),\ Vec(D,{2: one, 3: one, 5: one, 13: one}),\ Vec(D,{2: one, 3: one, 13: one})]) True ''' count = 0 x = intsqrt(N) + 1 prime_num = len(primeset) roots = [] rowlist = [] while count < prime_num + 1: x += 1 dumb_factor_res = dumb_factor(x * x - N, primeset) if not dumb_factor_res: continue f = make_Vec(primeset, dumb_factor_res) roots.append(x) rowlist.append(f) count += 1 return roots, rowlist
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a tuple (roots, rowlist) - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) Example: >>> from factoring_support import primes >>> N = 2419 >>> primeset = primes(32) >>> roots, rowlist = find_candidates(N, primeset) >>> set(roots) == set([51, 52, 53, 58, 61, 62, 63, 67, 68, 71, 77, 79]) True >>> D = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31} >>> set(rowlist) == set([Vec(D,{2: one, 13: one, 7: one}),\ Vec(D,{3: one, 19: one, 5: one}),\ Vec(D,{2: one, 3: one, 5: one, 13: one}),\ Vec(D,{3: one, 5: one, 7: one}),\ Vec(D,{7: one, 2: one, 3: one, 31: one}),\ Vec(D,{3: one, 19: one}),\ Vec(D,{2: one, 31: one}),\ Vec(D,{2: one, 5: one, 23: one}),\ Vec(D,{5: one}),\ Vec(D,{3: one, 2: one, 19: one, 23: one}),\ Vec(D,{2: one, 3: one, 5: one, 13: one}),\ Vec(D,{2: one, 3: one, 13: one})]) True ''' count = 0 x = intsqrt(N) + 1 prime_num = len(primeset) roots = [] rowlist = [] while count < prime_num + 1: x += 1 dumb_factor_res = dumb_factor(x*x-N, primeset) if not dumb_factor_res: continue f = make_Vec(primeset, dumb_factor_res) roots.append(x) rowlist.append(f) count += 1 return roots, rowlist
def root_method(N): a = intsqrt(N) for i in range (a+1, N): d = i*i - N if d < 0: continue else: b = sqrt(d) #print(str(i) + ':' + str(b)) if b%1 == 0: return int(i-b) return None
def find_a_and_b(v, roots, N): ''' Input: - a {0,1,..., n-1}-vector v over GF(2) where n = len(roots) - a list roots of integers - an integer N to factor Output: a pair (a,b) of integers such that a*a-b*b is a multiple of N (if v is correctly chosen) ''' af = [roots[idx] for idx in v.D if v[idx] == one] bf = [x**2 - N for x in af] return (prod(af),intsqrt(prod(bf)))
def find_candidates(N, primeset): roots = [] rowlist = [] x = intsqrt(N) + 1 while (True): x += 1 factors = dumb_factor(x * x - N, primeset) if len(factors) > 0: roots.append(x) rowlist.append(make_Vec(primeset, factors)) if len(roots) >= len(primeset) + 1: break return (roots, rowlist)
def find_a_and_b(v, roots, N): ''' Input: - a {0,1,..., n-1}-vector v over GF(2) where n = len(roots) - a list roots of integers - an integer N to factor Output: a pair (a,b) of integers such that a*a-b*b is a multiple of N (if v is correctly chosen) ''' af = [roots[idx] for idx in v.D if v[idx] == one] bf = [x**2 - N for x in af] return (prod(af), intsqrt(prod(bf)))
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a tuple (roots, rowlist) - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) Example: >>> from factoring_support import primes >>> N = 2419 >>> primeset = primes(32) >>> roots, rowlist = find_candidates(N, primeset) >>> set(roots) == set([51, 52, 53, 58, 61, 62, 63, 67, 68, 71, 77, 79]) True >>> D = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31} >>> set(rowlist) == set([Vec(D,{2: one, 13: one, 7: one}),\ Vec(D,{3: one, 19: one, 5: one}),\ Vec(D,{2: one, 3: one, 5: one, 13: one}),\ Vec(D,{3: one, 5: one, 7: one}),\ Vec(D,{7: one, 2: one, 3: one, 31: one}),\ Vec(D,{3: one, 19: one}),\ Vec(D,{2: one, 31: one}),\ Vec(D,{2: one, 5: one, 23: one}),\ Vec(D,{5: one}),\ Vec(D,{3: one, 2: one, 19: one, 23: one}),\ Vec(D,{2: one, 3: one, 5: one, 13: one}),\ Vec(D,{2: one, 3: one, 13: one})]) True ''' # initialization roots = [] rowlist = [] x = intsqrt(N) + 1 goal = len(primeset) + 1 while True: x += 1 cdiff = x*x - N dumb_list = dumb_factor(cdiff, primeset) if len(dumb_list) > 0: roots.append(x) rowlist.append(make_Vec(primeset, dumb_list)) if len(roots) == goal: break return(roots, rowlist)
def find_candidates(N, primeset): for x in primeset: intsqrt(2419) + x ''' Input: - N: an int to factor - primeset: a set of primes, >>> primes(32) {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31} Output: - a list [roots, rowlist] - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) ''' roots = [] rowlist = [] for x in primeset: intsqrt(2419) + x return [roots,rowlist]
def find_candidates(N, primeset): ''' Input: - N: an int to factor - primeset: a set of primes Output: - a tuple (roots, rowlist) - roots: a list a_0, a_1, ..., a_n where a_i*a_i - N can be factored over primeset - rowlist: a list such that rowlist[i] is a primeset-vector over GF(2) corresponding to a_i such that len(roots) = len(rowlist) and len(roots) > len(primeset) Example: >>> from factoring_support import primes >>> N = 2419 >>> primeset = primes(32) >>> roots, rowlist = find_candidates(N, primeset) >>> set(roots) == set([51, 52, 53, 58, 61, 62, 63, 67, 68, 71, 77, 79]) True >>> D = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31} >>> set(rowlist) == set([Vec(D,{2: one, 13: one, 7: one}),\ Vec(D,{3: one, 19: one, 5: one}),\ Vec(D,{2: one, 3: one, 5: one, 13: one}),\ Vec(D,{3: one, 5: one, 7: one}),\ Vec(D,{7: one, 2: one, 3: one, 31: one}),\ Vec(D,{3: one, 19: one}),\ Vec(D,{2: one, 31: one}),\ Vec(D,{2: one, 5: one, 23: one}),\ Vec(D,{5: one}),\ Vec(D,{3: one, 2: one, 19: one, 23: one}),\ Vec(D,{2: one, 3: one, 5: one, 13: one}),\ Vec(D,{2: one, 3: one, 13: one})]) True ''' roots = [] rowlist = [] target = len(primeset) + 1 x = intsqrt(N) + 1 while (len(roots) < target and len(rowlist) < target): x = x + 1 result = dumb_factor(x * x - N, primeset) if (result != []): roots.append(x) rowlist.append(make_Vec(primeset, result)) return (roots, rowlist)
def find_a_and_b(v, roots, N): ''' Input: - a {0,1,..., n-1}-vector v over GF(2) where n = len(roots) - a list roots of integers - an integer N to factor Output: a pair (a,b) of integers such that a*a-b*b is a multiple of N (if v is correctly chosen) ''' alist = [ roots[i] for i in range(len(roots)) if v[i] != 0 ] a = prod(alist) c = prod( { x*x - N for x in alist } ) b = intsqrt(c) return (a, b)
def find_a_and_b(v, roots, N): """ a vector v the list roots the integer N to factor computes a pair of integers such that a**2 - b**2 is a multiple of N """ alist = [roots[i] for i in v.D if v[i] != 0] a = factoring_support.prod(alist) c = factoring_support.prod([x * x - N for x in alist]) assert (c > 0) b = factoring_support.intsqrt(c) assert (b * b == c) return (a, b)
def find_a_and_b(v, roots, N): ''' Input: - a {0,1,..., n-1}-vector v over GF(2) where n = len(roots) - a list roots of integers - an integer N to factor Output: a pair (a,b) of integers such that a*a-b*b is a multiple of N (if v is correctly chosen) ''' n=len(roots) l = [roots[k] for k in range(n) if k in v.f and v.f[k]] b = prod([root*root-N for root in l]) a = prod([root for root in l]) return (a,intsqrt(b))
def find_a_and_b(v, roots, N): ''' Input: - a {0,1,..., n-1}-vector v over GF(2) where n = len(roots) - a list roots of integers - an integer N to factor Output: a pair (a,b) of integers such that a*a-b*b is a multiple of N (if v is correctly chosen) ''' alist = [roots[i] for i in v.D if v[i] == one] a = prod(alist) c = prod({x * x - N for x in alist}) b = intsqrt(c) return (a, b)
def find_a_and_b(v, roots, N): ''' Input: - a {0,1,..., n-1}-vector v over GF(2) where n = len(roots) - a list roots of integers - an integer N to factor Output: a pair (a,b) of integers such that a*a-b*b is a multiple of N (if v is correctly chosen) ''' alist = [roots[index] for index in range(len(roots)) if v[index] == one] ##print(alist) a = prod(alist) b = intsqrt(prod([root**2-N for root in alist])) return (a,b)