예제 #1
0
def task784():
    primeset = {2, 3, 5, 7, 11, 13}
    print(factoring_support.dumb_factor(12, primeset))
    print(factoring_support.dumb_factor(154, primeset))
    print(factoring_support.dumb_factor(2 * 3 * 3 * 3 * 11 * 11 * 13,
                                        primeset))
    print(factoring_support.dumb_factor(2 * 17, primeset))
    print(factoring_support.dumb_factor(2 * 3 * 5 * 7 * 19, primeset))
예제 #2
0
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)
예제 #3
0
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)
예제 #4
0
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
예제 #5
0
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)
예제 #6
0
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)
예제 #7
0
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)
예제 #8
0
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
예제 #9
0
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)
예제 #10
0
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)
예제 #11
0
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)
    '''
    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)
예제 #13
0
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)
예제 #14
0
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)
예제 #15
0
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)
예제 #16
0
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_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)
예제 #18
0
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)
예제 #19
0
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
예제 #20
0
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
예제 #21
0
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 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      
예제 #23
0
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)
예제 #24
0
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)
예제 #25
0
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 = []
    x = intsqrt(N)+2
    
    while len(roots) < len(primeset)+1:
        if len (dumb_factor(x**2-N, primeset)) != 0:
            roots.append(x)
            rowlist.append(make_Vec(primeset, dumb_factor(x**2-N, primeset)))
        x+=1
    return (roots, rowlist)
예제 #26
0
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
예제 #27
0
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)
예제 #28
0
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
    while len(roots) < len(primeset)+1:  # continue until 
        x = intsqrt(N) + i  
        if dumb_factor( x*x - N , primeset) != []:  # ask if x*x-N is unfactorable
            roots.append(x)   # if not, then append to root list
            # append to rowlist a vector mapping the parity of the exponent to an element in GF2 (1 or 0)
            # the elements in the domain of this vec are the primes in primeset
            rowlist.append(make_Vec(primeset, dumb_factor( x*x-N, primeset )))
        i += 1
    return roots, rowlist
예제 #29
0
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
    '''
    from itertools import count
    roots, rowlist = [], []
    for x in count(intsqrt(N) + 2):
        to_factor = x*x - N
        factored = dumb_factor(to_factor, primeset)
        if factored:
            roots.append(x)
            rowlist.append(make_Vec(primeset, factored))
        if len(roots) == len(primeset) + 1:
            break
    return (roots, rowlist)
예제 #30
0
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 = []
    for x in range(2, N):
        y = x + intsqrt(N)
        tmp = dumb_factor(y * y - N, primeset)
        if len(tmp) != 0:
            roots.append(y)
            rowlist.append(make_Vec(primeset, tmp))
        if len(roots) >= len(primeset) + 1:
            break
    return (roots, rowlist)
예제 #31
0
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=[]
    y=0
    b=0
    #c = []
    #d = []
    c=len(primeset) +1
    i =2
    #j=range(i)
    #for x in j:
    #    y=intsqrt(N)+x
    #    a=dumb_factor(y*y-N,primeset)
    #    if a!=[]:
    #        c.append(y)
    #        d.append(make_Vec(primeset,a))
            #i=i+len(c)+len(d)
    #for x in range(i):
    #for x in primeset:
    while( len(roots)<=c):
        if i!=0 and i!=1:
            y=intsqrt(N)+i
            i = i +1
            a=dumb_factor(y*y-N,primeset)
            if a!=[]:
                #c.append(y)
                #d.append(make_Vec(primeset,a))
                roots.append(y)
                
                rowlist.append(make_Vec(primeset,a))
    return (roots,rowlist)
예제 #32
0
def find_candidates(N, primeset):
    roots = []
    rowlist = []

    def can_be_factored_completely(x, primes):
        factors = factoring_support.dumb_factor(x, primes)
        return len(factors) > 0

    x = factoring_support.intsqrt(N) + 2
    while (len(roots) < len(primeset) + 1):
        candidate = x * x - N
        if can_be_factored_completely(candidate, primeset):
            roots.append(x)
            rowlist.append(
                make_Vec(primeset,
                         factoring_support.dumb_factor(candidate, primeset)))
        x += 1

    return roots, rowlist
예제 #33
0
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):
        test = dumb_factor(x * x - N, primeset)
        if len(test) > 0:
            roots += [x]
            rowlist += [make_Vec(primeset, test)]
        x += 1
    return (roots, rowlist)
예제 #34
0
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):
			test=dumb_factor(x*x-N,primeset)
			if len(test) > 0:
				roots += [x]
				rowlist += [make_Vec(primeset,test)]
			x+=1
		return (roots,rowlist)
예제 #35
0
def gcd(x, y):
    return x if y == 0 else gcd(y, x % y)


def int2GF2(x):
    return one if x % 2 == 1 else 0


def make_Vec(primeset, factors):
    d = primeset
    print(factors)
    f = dict(map(lambda x: (x[0], int2GF2(x[1])), factors))
    print(f)
    return Vec(d, f)


# N = [55,77,118,146771]
# print(root_method(N[1]))
# r = 12398280234912304
# s = 2752187456 #5504374912
# t = 9541094510
# a = r*s
# b = s*t
# print(gcd(a,b))
# print(dumb_factor(75,{2,3,5,7}))
factors = {2, 3, 5, 7, 11}
#print(int2GF2(3))
N = 2419
print(dumb_factor(N, factors))
print(make_Vec(factors, dumb_factor(N, factors)))
예제 #36
0
## Task 7.8.3

if PRINT_BOOK_TESTS:
    print("== 7.8.3 ==")
    n_3 = 367160330145890434494322103
    a_3 = 67469780066325164
    b_3 = 9429601150488992
    print((a_3**2 - b_3**2) % n_3 == 0)
    print(gcd(n_3, a_3 - b_3))

## Task 7.8.4

if PRINT_BOOK_TESTS:
    print("== 7.8.4 ==")
    prime_set = set([2, 3, 5, 7, 11, 13])
    print(dumb_factor(12, prime_set))
    print(dumb_factor(154, prime_set))
    print(dumb_factor(2*3*3*3*11*11*13, prime_set))
    print(dumb_factor(2*17, prime_set))
    print(dumb_factor(2*3*5*7*19, prime_set))
          

## Task 1
def int2GF2(i):
    '''
    Returns one if i is odd, 0 otherwise.

    Input:
        - i: an int
    Output:
        - one if i is congruent to 1 mod 2
예제 #37
0
assert d >= s
print(d, a/d, a/d * d) #holy shit Euclid was a smart cookie

#7.8.3
N = 367160330145890434494322103
a = 67469780066325164
b = 9429601150488992
c = (a*a - b*b )/N
print(c)
print(gcd(N, a-b))
#gdc of N and a-b is 19117318483477

#7.8.4
primeset = {2,3,5,7,11,13}
Ns = [12, 154, 2*3*3*3*11*11*11*13, 2*17,2*3*5*7*19]
[print(dumb_factor(x, primeset)) for x in Ns]
#correct answer for first 3, returned none for last two b/c 17 and 19 not in primeset


#7.8.5
def int2GF2(i):
    if i % 2 == 0:
        return 0
    else:
        return one

#7.8.6
def make_Vec(primeset, factors):
    return Vec(primeset,{factor[0]:int2GF2(factor[1]) for factor in factors})

print(make_Vec({2,3,5,7,11},[(3,1)]))
예제 #38
0
 def can_be_factored_completely(x, primes):
     factors = factoring_support.dumb_factor(x, primes)
     return len(factors) > 0