示例#1
0
def main4():
    print(crack_when_pq_close(23360947609))
    p = next_prime(2**128)
    print(p)
    q = next_prime(p)
    print(q)
    print(crack_when_pq_close(p * q))
def generate_pseudoprime(bases, min_bitsize=0):
    """
    Generates a pseudoprime which passes the Miller-Rabin primality test for the provided bases.
    :param bases: the bases
    :param min_bitsize: the minimum bitsize of the generated pseudoprime (default: 0)
    :return: a tuple containing the pseudoprime, as well as its 3 prime factors
    """
    bases.sort()
    k2 = next_prime(bases[-1])
    k3 = next_prime(k2)
    while True:
        residues = [inverse_mod(-k2, k3), inverse_mod(-k3, k2)]
        moduli = [k3, k2]
        s = _generate_s(bases, k2, k3)
        residue, modulus = _backtrack(s, bases, residues, moduli, 0)
        if residue and modulus:
            i = (2 ** (min_bitsize // 3)) // modulus
            while True:
                p1 = residue + i * modulus
                p2 = k2 * (p1 - 1) + 1
                p3 = k3 * (p1 - 1) + 1
                if is_prime(p1) and is_prime(p2) and is_prime(p3):
                    return p1 * p2 * p3, p1, p2, p3

                i += 1
        else:
            k3 = next_prime(k3)
示例#3
0
def main7():
    set_random_seed(0)
    p = next_prime(randrange(2**96))
    q = next_prime(randrange(2**97))
    n = p * q
    print(p, q, n)
    print(qsieve(n))
示例#4
0
def make_hash(p, N1, N2, np=20):
    plist = [next_prime(400000)]
    while len(plist) < np:
        plist.append(next_prime(plist[-1]))

    hashtab = {}
    nc = 0
    for E in cremona_optimal_curves(srange(N1, N2 + 1)):
        nc += 1
        h = hash1(p, E, plist)
        lab = E.label()
        if nc % 1000 == 0:
            print(lab)
        #print("{} has hash = {}".format(lab,h))
        if h in hashtab:
            hashtab[h].append(lab)
            #print("new set {}".format(hashtab[h]))
        else:
            hashtab[h] = [lab]

    ns = 0
    for s in hashtab.values():
        if len(s) > 1:
            ns += 1
            #print s
    print("{} sets of conjugate curves".format(ns))
    return hashtab
示例#5
0
def make_hash_many(plist, N1, N2, nq=20):
    qlist = [next_prime(400000)]
    while len(qlist) < nq:
        qlist.append(next_prime(qlist[-1]))

    hashtabs = dict([(p, dict()) for p in plist])
    nc = 0
    for E in cremona_optimal_curves(srange(N1, N2 + 1)):
        nc += 1
        lab = E.label()
        if nc % 1000 == 0:
            print(lab)
        h = hash1many(plist, E, qlist)

        for p in plist:
            hp = h[p]
            if hp in hashtabs[p]:
                hashtabs[p][hp].append(lab)
                print("p={}, new set {}".format(p, hashtabs[p][hp]))
            else:
                hashtabs[p][hp] = [lab]

    ns = dict([(p, len([v for v in hashtabs[p].values() if len(v) > 1]))
               for p in plist])
    for p in plist:
        print("p={}: {} nontrivial sets of congruent curves".format(p, ns[p]))
    return hashtabs
示例#6
0
文件: main.py 项目: staalezh/curves
    def make_base_field(self):
        if self.args.base_field != None:
            F = GF(self.args.base_field, 'F')
            self.field_traits.check(F)
            return F

        p = next_prime(2**self.args.num_bits)
        while not self.field_traits.check(GF(p, 'F'), nothrow=True):
            p = next_prime(p)

        return GF(p, 'F')
示例#7
0
def rsa(bits):
    # only prove correctness up to 1024bits
    proof = (bits <= 1024)
    p = next_prime(ZZ.random_element(2**(bits // 2 + 1)),
                   proof=proof)
    q = next_prime(ZZ.random_element(2**(bits // 2 + 1)),
                   proof=proof)
    n = p * q
    phi_n = (p - 1) * (q - 1)
    while True:
        e = ZZ.random_element(1, phi_n)
        if gcd(e, phi_n) == 1:
            break
    d = lift(Mod(e, phi_n)**(-1))
    return e, d, n
示例#8
0
def make_hash_SW(plist, N1=0, N2=999, nq=30, tate=False):
    """Here N1 and N2 are in [0..999] and refer to the batch number, where
    batch n has curves of conductor between n*10^5 and (n+1)*10^5

    plist is a list of primes so we can make several hash tables in parallel

    If tate=True then ignore curves unless ord_p(j(E))=-1
    """
    # Compute the first nq primes greater than the largest conductor:

    qlist = [next_prime((N2 + 1) * 10**5)]
    while len(qlist) < nq:
        qlist.append(next_prime(qlist[-1]))

    # Initialize hash tables for each p:

    hashtabs = dict([(p, dict()) for p in plist])
    nc = 0
    for N in range(N1, N2 + 1):
        print("Batch {}".format(N))
        for dat in SteinWatkinsAllData(N):
            nc += 1
            NE = dat.conductor
            E = EllipticCurve(dat.curves[0][0])
            assert E.conductor() == NE
            if tate and all(E.j_invariant().valuation(p) >= 0 for p in plist):
                continue
            lab = SW_label(E)
            if nc % 10000 == 0:
                print(lab)
            # if nc>10000:
            #     break
            h = hash1many(plist, E, qlist)
            for p in plist:
                if tate and E.j_invariant().valuation(p) >= 0:
                    continue
                hp = h[p]
                if hp in hashtabs[p]:
                    hashtabs[p][hp].append(lab)
                    print("p={}, new set {}".format(p, hashtabs[p][hp]))
                else:
                    hashtabs[p][hp] = [lab]

    ns = dict([(p, len([v for v in hashtabs[p].values() if len(v) > 1]))
               for p in plist])
    for p in plist:
        print("p={}: {} nontrivial sets of congruent curves".format(p, ns[p]))
    return hashtabs
示例#9
0
    def __init__(self,
                 signature=0,
                 weight=2,
                 level_limit=34,
                 rank_limit=4,
                 primes=None,
                 simple_color=None,
                 nonsimple_color=None,
                 reduction=True,
                 bound=0):
        """
            Initialize a SimpleModulesGraph containing finite quadratic modules of signature ``signature``.
            They are checked for being ``weight``-simple if their minimal number of generators
            is at most `rank_limit`.

            INPUT:
            - ``signature``: the signature of the modules
            - ``weight``: check for cusp forms of weight ``weight``
            - ``level_limit``: only check for anisotropic modules with level smaller than ``level_limit``
            - ``rank_limit``: an upper bound for the minimal number of generators
            - ``bound``: upper bound for the dimension (for considered being simple), default=0

            OUTPUT:
            A SimpleModulesGraph object. No computations are done after initialization.
            Start the computation using the method ``compute()``.
        """
        ###########################
        # basic parameters
        ###########################
        self._level_limit = Integer(level_limit)
        self._rank_limit = Integer(rank_limit)
        self._signature = Integer(signature) % 8
        self._weight = QQ(weight)
        self._reduction = reduction
        self._bound = bound
        #########################################################
        # Initialize the primes that need to be checked
        # According to Theorem 4.21 in [BEF],
        # in the worst case, we need to check primes p for which
        # prime_pol_simple(p, weight) <= bound.
        #########################################################
        if primes is None:
            p = 2
            while True:
                if prime_pol_simple(p, weight) > self._bound:
                    primes = list(prime_range(p))
                    break
                else:
                    p = next_prime(p)
        self._primes = primes
        self._simple_color = colors.darkred.rgb(
        ) if simple_color is None else simple_color
        self._nonsimple_color = colors.darkgreen.rgb(
        ) if nonsimple_color is None else nonsimple_color
        self._vertex_colors = dict()
        self._vertex_colors[self._simple_color] = list()
        self._vertex_colors[self._nonsimple_color] = list()
        self._heights = dict()  # a height function for plotting
        self._simple = list()  # will contain the list of k-simple modules
        super(SimpleModulesGraph, self).__init__()
示例#10
0
    def _rank(self, v):
        r"""
        Return a lower bound for the rank of the matrix U.
        """
        self._U[self._U_rank] = v

        K = self._U.base_ring()
        if K is QQ:
            return self._U.rank()

        k = K.residue_field(self._good_prime)
        try:
            self._Ubar[self._U_rank] = v.change_ring(k)
        except ValueError:
            # Some denominator in v is not a unit mod q.
            while True:
                from sage.all import next_prime
                self._good_prime = next_prime(self._good_prime.residue_field().characteristic())
                self._good_prime = K.ideal(self._good_prime).factor()[0][0]
                k = K.residue_field(self._good_prime)
                try:
                    self._Ubar = self._U.change_ring(k)
                except ValueError:
                    continue

        if self._Ubar.rank() == self._U_rank + 1:
            return self._U_rank + 1
        return self._U_rank
示例#11
0
def gen_instance(n, q, h, alpha=None, m=None, seed=None, s=None):
    """
    Generate FHE-style LWE instance

    :param n:     dimension
    :param q:     modulus
    :param alpha: noise rate (default: 8/q)
    :param h:     hamming weight of the secret (default: 2/3n)
    :param m:     number of samples (default: n)

    """
    if seed is not None:
        set_random_seed(seed)

    q = next_prime(ceil(q) - 1, proof=False)
    if alpha is None:
        stddev = 3.2
    else:
        stddev = alpha * q / sqrt(2 * pi)

    #RR = parent(alpha*q)
    #stddev = alpha*q/RR(sqrt(2*pi))

    if m is None:
        m = n
    K = GF(q, proof=False)

    while 1:
        A = random_matrix(K, m, n)
        if A.rank() == n:
            break

    if s is not None:
        c = A * s

    else:
        if h is None:
            s = random_vector(ZZ, n, x=-1, y=1)
        else:
            S = [-1, 1]
            s = [S[randint(0, 1)] for i in range(h)]
            s += [0 for _ in range(n - h)]
            shuffle(s)
            s = vector(ZZ, s)
        c = A * s

    D = DiscreteGaussian(stddev)

    for i in range(m):
        c[i] += D()

    u = random_vector(K, m)

    print '(A, c) is n-dim LWE samples (with secret s) / (A, u) is uniform samples'

    return A, c, u, s
def experiment(n=65,
               q=next_prime(ceil(2**9)),
               sigma=8,
               m=178,
               block_size=56,
               tours=6):
    alpha = sigma / q
    L, e = gen_instance(n, alpha, q, m)
    R, norms = run_instance(L, block_size, tours, e)
    return L, R, e, norms
示例#13
0
 def max_coefficient_in_db(self):
     r"""
     Check how many coefficients we can generate from the eigenvalues in the database.
     """
     from sage.all import next_prime
     rec = self.get_db_record()
     if rec is None:
         return 0
     prec_in_db = rec.get('prec')
     return next_prime(prec_in_db) - 1
示例#14
0
 def max_coefficient_in_db(self):
     r"""
     Check how many coefficients we can generate from the eigenvalues in the database.
     """
     from sage.all import next_prime
     rec = self.get_db_record()
     if rec is None:
         return 0
     prec_in_db = rec.get('prec')
     return next_prime(prec_in_db)-1
示例#15
0
 def max_coefficient_in_db(self):
     r"""
     Check how many coefficients we can generate from the eigenvalues in the database.
     """
     from sage.all import next_prime
     prec_in_db = list(self._file_collection.find(self.key_dict(), ['prec']))
     if len(prec_in_db) == 0:
         return 0
     max_prec_in_db = max(r['prec'] for r in prec_in_db)
     return next_prime(max_prec_in_db)-1
示例#16
0
 def max_coefficient_in_db(self):
     r"""
     Check how many coefficients we can generate from the eigenvalues in the database.
     """
     from sage.all import next_prime
     prec_in_db = list(self._file_collection.find(self.key_dict(), ['prec']))
     if len(prec_in_db) == 0:
         return 0
     max_prec_in_db = max(r['prec'] for r in prec_in_db)
     return next_prime(max_prec_in_db)-1
示例#17
0
 def max_coefficient_in_db(self):
     r"""
     Check how many coefficients we can generate from the eigenvalues in the database.
     """
     from sage.all import next_prime
     recs = self._collection.find({'hecke_orbit_label':self.hecke_orbit_label})
     if recs.count()==0:
         return 0
     prec_in_db = max(rec['prec'] for rec in recs)
     return next_prime(prec_in_db)-1
示例#18
0
 def max_coefficient_in_db(self):
     r"""
     Check how many coefficients we can generate from the eigenvalues in the database.
     """
     from sage.all import next_prime
     recs = self._file_collection.find(self.key_dict())
     if recs is None:
         return 0
     prec_in_db = max(rec['prec'] for rec in recs)
     return next_prime(prec_in_db)-1
示例#19
0
 def max_coefficient_in_db(self):
     r"""
     Check how many coefficients we can generate from the eigenvalues in the database.
     """
     from sage.all import next_prime
     recs = self._collection.find(
         {'hecke_orbit_label': self.hecke_orbit_label})
     if recs.count() == 0:
         return 0
     prec_in_db = max(rec['prec'] for rec in recs)
     return next_prime(prec_in_db) - 1
示例#20
0
    def __init__(self, surface):
        if isinstance(surface, TranslationSurface):
            base_ring = surface.base_ring()
            from flatsurf.geometry.pyflatsurf_conversion import to_pyflatsurf
            self._surface = to_pyflatsurf(surface)
        else:
            from flatsurf.geometry.pyflatsurf_conversion import sage_base_ring
            base_ring, _ = sage_base_ring(surface)
            self._surface = surface

        # A model of the vector space R² in libflatsurf, e.g., to represent the
        # vector associated to a saddle connection.
        self.V2 = pyflatsurf.vector.Vectors(base_ring)

        # We construct a spanning set of edges, that is a subset of the
        # edges that form a basis of H_1(S, Sigma; Z)
        # It comes together with a projection matrix
        t, m = self._spanning_tree()
        assert set(t.keys()) == set(f[0] for f in self._faces())
        self.spanning_set = []
        v = set(t.values())
        for e in self._surface.edges():
            if e.positive() not in v and e.negative() not in v:
                self.spanning_set.append(e)
        self.d = len(self.spanning_set)
        assert 3*self.d - 3 == self._surface.size()
        assert m.rank() == self.d
        m = m.transpose()
        # projection matrix from Z^E to H_1(S, Sigma; Z) in the basis
        # of spanning edges
        self.proj = matrix(ZZ, [r for r in m.rows() if not r.is_zero()])

        self.Omega = self._intersection_matrix(t, self.spanning_set)

        self.V = FreeModule(self.V2.base_ring(), self.d)
        self.H = matrix(self.V2.base_ring(), self.d, 2)
        for i in range(self.d):
            s = self._surface.fromHalfEdge(self.spanning_set[i].positive())
            self.H[i] = self.V2._isomorphic_vector_space(self.V2(s))
        self.Hdual = self.Omega * self.H

        # Note that we don't use Sage vector spaces because they are usually
        # way too slow (in particular we avoid calling .echelonize())
        self._U = matrix(self.V2._algebraic_ring(), self.d)
        
        if self._U.base_ring() is not QQ:
            from sage.all import next_prime
            self._good_prime = self._U.base_ring().ideal(next_prime(2**30)).factor()[0][0]
            self._Ubar = matrix(self._good_prime.residue_field(), self.d)

        self._U_rank = 0

        self.update_tangent_space_from_vector(self.H.transpose()[0])
        self.update_tangent_space_from_vector(self.H.transpose()[1])
示例#21
0
def dirichlet(R, euler_factors):
    PS = PowerSeriesRing(R)
    pef = zip(primes_first_n(len(euler_factors)), euler_factors)
    an_list_bound = next_prime(pef[-1][0])
    res = [1]*an_list_bound
    for p, ef in pef:
        k = RR(an_list_bound).log(p).floor()+1
        foo = (1/PS(ef)).padded_list(k)
        for i in range(1, k):
            res[p**i] = foo[i]
    extend_multiplicatively(res)
    return res
示例#22
0
def get_frob_list_HyperellipticCurve(f, h, bound=100):
    C = HyperellipticCurve(f, h)
    frob_list = []
    p = 2
    while p < bound:
        try:
            f = C.change_ring(GF(p)).frobenius_polynomial()
            if f.degree() == 2 * C.genus():
                frob_list.append([p, f.reverse()])
        except:
            pass
        p = next_prime(p)
    return frob_list
示例#23
0
    def __init__(self, signature=0, weight=2, level_limit=34, rank_limit=4, primes=None, simple_color=None, nonsimple_color=None,
                 reduction=True, bound=0):
        """
            Initialize a SimpleModulesGraph containing finite quadratic modules of signature ``signature``.
            They are checked for being ``weight``-simple if their minimal number of generators
            is at most `rank_limit`.

            INPUT:
            - ``signature``: the signature of the modules
            - ``weight``: check for cusp forms of weight ``weight``
            - ``level_limit``: only check for anisotropic modules with level smaller than ``level_limit``
            - ``rank_limit``: an upper bound for the minimal number of generators
            - ``bound``: upper bound for the dimension (for considered being simple), default=0

            OUTPUT:
            A SimpleModulesGraph object. No computations are done after initialization.
            Start the computation using the method ``compute()``.
        """
        ###########################
        # basic parameters
        ###########################
        self._level_limit = Integer(level_limit)
        self._rank_limit = Integer(rank_limit)
        self._signature = Integer(signature) % 8
        self._weight = QQ(weight)
        self._reduction = reduction
        self._bound = bound
        #########################################################
        # Initialize the primes that need to be checked
        # According to Theorem 4.21 in [BEF],
        # in the worst case, we need to check primes p for which
        # prime_pol_simple(p, weight) <= bound.
        #########################################################
        if primes is None:
            p = 2
            while True:
                if prime_pol_simple(p, weight) > self._bound:
                    primes = list(prime_range(p))
                    break
                else:
                    p = next_prime(p)
        self._primes = primes
        self._simple_color = colors.darkred.rgb() if simple_color is None else simple_color
        self._nonsimple_color = colors.darkgreen.rgb() if nonsimple_color is None else nonsimple_color
        self._vertex_colors = dict()
        self._vertex_colors[self._simple_color] = list()
        self._vertex_colors[self._nonsimple_color] = list()
        self._heights = dict() # a height function for plotting
        self._simple = list() # will contain the list of k-simple modules
        super(SimpleModulesGraph, self).__init__()
示例#24
0
def verify_curve(g, factorsRR_geom, bound = 300, RM_coeff = None):
    D = ZZ(g.discriminant());
    C = HyperellipticCurve(g)
    p = 3;
    ef = [];
    while p < bound:
        if D.mod(p) != ZZ(0):
            ef +=  [C.change_ring(GF(p)).frobenius_polynomial().list()]
            ef[-1].reverse()
        p = next_prime(p)
    rank_euler, _ =  upperrank(ef)
    rank_endo = rank_from_endo(factorsRR_geom)
    if factorsRR_geom ==  ['RR', 'RR'] and RM_coeff is not None:
        checkRM =  RM_and_notCM(ef, RM_coeff)
        return rank_endo == rank_euler and checkRM, rank_endo, rank_euler
    else:
        return rank_endo == rank_euler, rank_endo, rank_euler
示例#25
0
 def central_character_as_artin_rep(self):
     """
       Returns the central character, i.e., determinant character
       as a web character, but as an Artin representation
     """
     if self.dimension() == 1:
         return self
     if 'central_character_as_artin_rep' in self._data:
         return self._data['central_character_as_artin_rep']
     return ArtinRepresentation(self._data['Dets'][self.galorbindex() - 1])
     myfunc = self.central_char_function()
     # Get the Artin field
     nfgg = self.number_field_galois_group()
     # Get its artin reps
     arts = nfgg.ArtinReps()
     # Filter for 1-dim
     arts = [
         a for a in arts
         if ArtinRepresentation(str(a['Baselabel']) + "c1").dimension() == 1
     ]
     artfull = [
         ArtinRepresentation(str(a['Baselabel']) + "c" + str(a['GalConj']))
         for a in arts
     ]
     # hold = artfull
     # Loop as we evaluate at primes until there is only one left
     # Fix the return value to be what we want
     artfull = [[a, a.central_char_function(), 2 * a.character_field()]
                for a in artfull]
     n = 2 * self.character_field()
     p = 2
     hard_primes = self.hard_primes()
     while len(artfull) > 1:
         if p not in hard_primes:
             k = 0
             while k < len(artfull):
                 if n * artfull[k][1](
                         p, artfull[k][2]) == artfull[k][2] * myfunc(p, n):
                     k += 1
                 else:
                     # Quick deletion of k-th term
                     artfull[k] = artfull[-1]
                     del artfull[-1]
         p = next_prime(p)
     self._data['central_character_as_artin_rep'] = artfull[0][0]
     return artfull[0][0]
示例#26
0
def gen_fhe_instance(n, q, alpha=None, h=None, m=None, seed=None):
    """
    Generate FHE-style LWE instance

    :param n:     dimension
    :param q:     modulus
    :param alpha: noise rate (default: 8/q)
    :param h:     hamming weight of the secret (default: 2/3n)
    :param m:     number of samples (default: n)

    """
    if seed is not None:
        set_random_seed(seed)

    q = next_prime(ceil(q)-1, proof=False)
    if alpha is None:
        alpha = ZZ(8)/q

    n, alpha, q = preprocess_params(n, alpha, q)

    stddev = stddevf(alpha*q)

    if m is None:
        m = n
    K = GF(q, proof=False)
    A = random_matrix(K, m, n)

    if h is None:
        s = random_vector(ZZ, n, x=-1, y=1)
    else:
        S = [-1, 1]
        s = [S[randint(0, 1)] for i in range(h)]
        s += [0 for _ in range(n-h)]
        shuffle(s)
        s = vector(ZZ, s)
    c = A*s

    D = DiscreteGaussian(stddev)

    for i in range(m):
        c[i] += D()

    return A, c
示例#27
0
def gen_fhe_instance(n, q, alpha=None, h=None, m=None, seed=None):
    """
    Generate FHE-style LWE instance

    :param n:     dimension
    :param q:     modulus
    :param alpha: noise rate (default: 8/q)
    :param h:     hamming weight of the secret (default: 2/3n)
    :param m:     number of samples (default: n)

    """
    if seed is not None:
        set_random_seed(seed)

    q = next_prime(ceil(q) - 1, proof=False)
    if alpha is None:
        alpha = ZZ(8) / q

    n, alpha, q = preprocess_params(n, alpha, q)

    stddev = stddevf(alpha * q)

    if m is None:
        m = n
    K = GF(q, proof=False)
    A = random_matrix(K, m, n)

    if h is None:
        s = random_vector(ZZ, n, x=-1, y=1)
    else:
        S = [-1, 1]
        s = [S[randint(0, 1)] for i in range(h)]
        s += [0 for _ in range(n - h)]
        shuffle(s)
        s = vector(ZZ, s)
    c = A * s

    D = DiscreteGaussian(stddev)

    for i in range(m):
        c[i] += D()

    return A, c
示例#28
0
文件: g2LocSolv.py 项目: LMFDB/lmfdb
def InsolublePlaces(f,h=0):
    # List of primes at which the curve y²+h(x)*y=f(x) is not soluble
    # Assumes f and h have integer coefficients
    S = [] # List of primes at which not soluble
    # Get eqn of the form y²=F(x)
    F = f
    if h:
        F = 4*f + h**2
    # Do we have a rational point an Infty ?
    if F.degree()%2 or F.leading_coefficient().is_square():
        return []
    # Treat case of RR
    if F.leading_coefficient() < 0 and F.number_of_real_roots() == 0:
        S.append(0)
    # Remove squares from lc(F)
    d = F.degree()
    lc = F.leading_coefficient()
    t = F.variables()[0]
    a = lc.squarefree_part() # lc/a is a square
    a = lc//a
    Zx = PolynomialRing(ZZ,'x')
    F = Zx(a**(d-1) * F(t/a))
    # Find primes of bad reduction for our model
    D = F.disc()
    P = Set(D.prime_divisors())
    # Add primes at which Weil bounds do not guarantee a mod p point
    g = (d-2)//2
    Weil = []
    p = 2
    while (p+1)**2 <= 4 * g**2 * p:
        Weil.append(p)
        p = next_prime(p)
    P = P.union(Set(Weil))
    # Test for solubility
    for p in P:
        if not IsSolubleAt(F,p):
            S.append(p)
    S.sort()
    return S
示例#29
0
def InsolublePlaces(f, h=0):
    # List of primes at which the curve y²+h(x)*y=f(x) is not soluble
    # Assumes f and h have integer coefficients
    S = []  # List of primes at which not soluble
    # Get eqn of the form y²=F(x)
    F = f
    if h:
        F = 4 * f + h**2
    # Do we have a rational point an Infty ?
    if F.degree() % 2 or F.leading_coefficient().is_square():
        return []
    # Treat case of RR
    if F.leading_coefficient() < 0 and F.number_of_real_roots() == 0:
        S.append(0)
    # Remove squares from lc(F)
    d = F.degree()
    lc = F.leading_coefficient()
    t = F.variables()[0]
    a = lc.squarefree_part()  # lc/a is a square
    a = lc // a
    Zx = PolynomialRing(ZZ, 'x')
    F = Zx(a**(d - 1) * F(t / a))
    # Find primes of bad reduction for our model
    D = F.disc()
    P = Set(D.prime_divisors())
    # Add primes at which Weil bounds do not guarantee a mod p point
    g = (d - 2) // 2
    Weil = []
    p = 2
    while (p + 1)**2 <= 4 * g**2 * p:
        Weil.append(p)
        p = next_prime(p)
    P = P.union(Set(Weil))
    # Test for solubility
    for p in P:
        if not IsSolubleAt(F, p):
            S.append(p)
    S.sort()
    return S
def genCurve(bits):
    p = sg.next_prime(random.randint(2**(bits-1), 2**(bits)))

    order = 0
    while not(sg.is_prime(order)) or order == p or order == p+1:
        A = random.randint(1, 10**5)
        B = random.randint(1, 10**5)
        if (4*A**3 + 27*B**2) % p != 0:   ## Avoid singular curves ##
            E = sg.EllipticCurve(sg.GF(p), [A,B])
            order = E.cardinality()

    P = E.random_point()
    Q = E.random_point()

    f = open("curves.csv", "a")
    f.write(str(bits)+",")
    f.write(str(A)+",")
    f.write(str(B)+",")
    f.write(str(p)+",")
    f.write(str(order)+",")
    f.write(str(P.xy()[0])+","+str(P.xy()[1])+",")
    f.write(str(Q.xy()[0])+","+str(Q.xy()[1])+"\n")
    f.close()
示例#31
0
def genCurve(bits):
    p = sg.next_prime(random.randint(2**(bits - 1), 2**(bits)))

    order = 0
    while not (sg.is_prime(order)) or order == p or order == p + 1:
        A = random.randint(1, 10**5)
        B = random.randint(1, 10**5)
        if (4 * A**3 + 27 * B**2) % p != 0:  ## Avoid singular curves ##
            E = sg.EllipticCurve(sg.GF(p), [A, B])
            order = E.cardinality()

    P = E.random_point()
    Q = E.random_point()

    f = open("curves.csv", "a")
    f.write(str(bits) + ",")
    f.write(str(A) + ",")
    f.write(str(B) + ",")
    f.write(str(p) + ",")
    f.write(str(order) + ",")
    f.write(str(P.xy()[0]) + "," + str(P.xy()[1]) + ",")
    f.write(str(Q.xy()[0]) + "," + str(Q.xy()[1]) + "\n")
    f.close()
示例#32
0
 def central_character_as_artin_rep(self):
     """
       Returns the central character, i.e., determinant character
       as a web character, but as an Artin representation
     """
     if self.dimension() == 1:
         return self
     if 'central_character_as_artin_rep' in self._data:
         return self._data['central_character_as_artin_rep']
     myfunc = self.central_char_function()
     # Get the Artin field
     nfgg = self.number_field_galois_group()
     # Get its artin reps
     arts = nfgg.ArtinReps()
     # Filter for 1-dim
     arts = [a for a in arts if ArtinRepresentation(str(a['Baselabel'])+"c1").dimension()==1]
     artfull = [ArtinRepresentation(str(a['Baselabel'])+"c"+str(a['GalConj'])) for a in arts]
     # hold = artfull
     # Loop as we evaluate at primes until there is only one left
     # Fix the return value to be what we want
     artfull = [[a, a.central_char_function(),2*a.character_field()] for a in artfull]
     n = 2*self.character_field()
     p = 2
     disc = nfgg.discriminant()
     while len(artfull)>1:
         if (disc % p) != 0:
           k=0
           while k<len(artfull):
               if n*artfull[k][1](p,artfull[k][2]) == artfull[k][2]*myfunc(p,n):
                   k += 1
               else:
                   # Quick deletion of k-th term
                   artfull[k] = artfull[-1]
                   del artfull[-1]
         p = next_prime(p)
     self._data['central_character_as_artin_rep'] = artfull[0][0]
     return artfull[0][0]
示例#33
0
文件: lll.py 项目: niklasb/ctf-tools
        xs.append(1)
        xs = vector(xs)

        A = []
        for i in range(m):
            cs = [randrange(hi) for _ in range(n-1)]
            cs.append(-sum((x*c) for x, c in zip(xs, cs)))
            assert sum(c*x for c, x in zip(cs, xs)) == 0
            A.append(cs)

        assert xs == small_lgs(matrix(A))

        print '  Testing homogenous LGS modulo prime'
        hi = 2**128
        lo = 2**100
        p = next_prime(hi)

        n = 40 # num vars
        m = 35 # num equations
        xs = [randrange(lo) for _ in range(n)]
        xs = vector(xs)

        A = []
        for i in range(m):
            cs = [randrange(p) for _ in range(n-1)]
            last_c = -sum(c*x for c, x in zip(cs, xs)) * inverse_mod(xs[-1], p)
            cs.append(last_c % p)
            assert sum(c*x for c, x in zip(cs, xs))%p == 0
            A.append(cs)
        A = matrix(ZZ, A)
示例#34
0
def render_newform_webpage(label):
    try:
        newform = WebNewform.by_label(label)
    except (KeyError, ValueError) as err:
        return abort(404, err.args)
    info = to_dict(request.args)
    info['format'] = info.get('format',
                              'embed' if newform.dim > 1 else 'satake')
    p, maxp = 2, 10
    if info['format'] in ['satake', 'satake_angle']:
        while p <= maxp:
            if newform.level % p == 0:
                maxp = next_prime(maxp)
            p = next_prime(p)
    errs = []
    info['n'] = info.get('n', '2-%s' % maxp)
    try:
        info['CC_n'] = integer_options(info['n'], 1000)
    except (ValueError, TypeError) as err:
        info['n'] = '2-%s' % maxp
        info['CC_n'] = range(2, maxp + 1)
        if err.args and err.args[0] == 'Too many options':
            errs.append(r"Only \(a_n\) up to %s are available" %
                        (newform.cqexp_prec - 1))
        else:
            errs.append(
                "<span style='color:black'>n</span> must be an integer, range of integers or comma separated list of integers"
            )
    maxm = min(newform.dim, 20)
    info['m'] = info.get('m', '1-%s' % maxm)
    try:
        info['CC_m'] = integer_options(info['m'], 1000)
    except (ValueError, TypeError) as err:
        info['m'] = '1-%s' % maxm
        info['CC_m'] = range(1, maxm + 1)
        if err.args and err.args[0] == 'Too many options':
            errs.append(
                'Web interface only supports 1000 embeddings at a time.  Use download link to get more (may take some time).'
            )
        else:
            errs.append(
                "<span style='color:black'>Embeddings</span> must be an integer, range of integers or comma separated list of integers"
            )
    try:
        info['prec'] = int(info.get('prec', 6))
        if info['prec'] < 1 or info['prec'] > 15:
            raise ValueError
    except (ValueError, TypeError):
        info['prec'] = 6
        errs.append(
            "<span style='color:black'>Precision</span> must be a positive integer, at most 15 (for higher precision, use the download button)"
        )
    newform.setup_cc_data(info)
    if newform.cqexp_prec != 0 and max(info['CC_n']) >= newform.cqexp_prec:
        errs.append(r"Only \(a_n\) up to %s are available" %
                    (newform.cqexp_prec - 1))
    if errs:
        flash(Markup("<br>".join(errs)), "error")
    return render_template("cmf_newform.html",
                           info=info,
                           newform=newform,
                           properties2=newform.properties,
                           downloads=newform.downloads,
                           credit=credit(),
                           bread=newform.bread,
                           learnmore=learnmore_list(),
                           title=newform.title,
                           friends=newform.friends)
示例#35
0
def DirichletCoefficients(euler_factors, bound = None):
    """
    INPUT:
        - ``euler_factors`` -- a dictionary p --> Lp.list() where Lp \in 1 + ZZ[t]

    OUTPUT:
        A list of length bound + 1 -- [0, a1, a2, ... , a_bound]
            
    EXAMPLES:
        sage: E17a2_euler_factors = {2: [1, 1, 2], 3: [1, 0, 3], 5: [1, 2, 5], 7: [1, -4, 7], 11: [1, 0, 11], 13: [1, 2, 13], 17: [1, -1], 19: [1, 4, 19], 23: [1, -4, 23], 29: [1, -6, 29], 31: [1, -4, 31], 37: [1, 2, 37], 41: [1, 6, 41], 43: [1, -4, 43], 47: [1, 0, 47], 53: [1, -6, 53], 59: [1, 12, 59], 61: [1, 10, 61], 67: [1, -4, 67], 71: [1, 4, 71], 73: [1, 6, 73], 79: [1, -12, 79], 83: [1, 4, 83], 89: [1, -10, 89], 97: [1, -2, 97]}
        sage: A = DirichletCoefficients(E17a2_euler_factors, bound  = 99)
        sage: A == [0, 1, -1, 0, -1, -2, 0, 4, 3, -3, 2, 0, 0, -2, -4, 0, -1, 1, 3, -4, 2, 0, 0, 4, 0, -1, 2, 0, -4, 6, 0, 4, -5, 0, -1, -8, 3, -2, 4, 0, -6, -6, 0, 4, 0, 6, -4, 0, 0, 9, 1, 0, 2, 6, 0, 0, 12, 0, -6, -12, 0, -10, -4, -12, 7, 4, 0, 4, -1, 0, 8, -4, -9, -6, 2, 0, 4, 0, 0, 12, 2, 9, 6, -4, 0, -2, -4, 0, 0, 10, -6, -8, -4, 0, 0, 8, 0, 2, -9, 0]
            True

        sage: E33a3_euler_factors = {2: [1, -1, 2], 3: [1, 1], 5: [1, 2, 5], 7: [1, -4, 7], 11: [1, -1], 13: [1, 2, 13], 17: [1, 2, 17], 19: [1, 0, 19], 23: [1, -8, 23], 29: [1, 6, 29], 31: [1, 8, 31], 37: [1, -6, 37], 41: [1, 2, 41], 43: [1, 0, 43], 47: [1, -8, 47], 53: [1, -6, 53], 59: [1, 4, 59], 61: [1, -6, 61], 67: [1, 4, 67], 71: [1, 0, 71], 73: [1, 14, 73], 79: [1, 4, 79], 83: [1, -12, 83], 89: [1, 6, 89], 97: [1, -2, 97]}
        sage: A = DirichletCoefficients(E33a3_euler_factors, bound  = 99)
        sage: A == [0, 1, 1, -1, -1, -2, -1, 4, -3, 1, -2, 1, 1, -2, 4, 2, -1, -2, 1, 0, 2, -4, 1, 8, 3, -1, -2, -1, -4, -6, 2, -8, 5, -1, -2, -8, -1, 6, 0, 2, 6, -2, -4, 0, -1, -2, 8, 8, 1, 9, -1, 2, 2, 6, -1, -2, -12, 0, -6, -4, -2, 6, -8, 4, 7, 4, -1, -4, 2, -8, -8, 0, -3, -14, 6, 1, 0, 4, 2, -4, 2, 1, -2, 12, 4, 4, 0, 6, -3, -6, -2, -8, -8, 8, 8, 0, -5, 2, 9, 1]
            True
    """
    if bound is None:
        bound = next_prime( max(euler_factors.keys() ) ) - 1;
    degree = 0;
    for p, L in euler_factors.iteritems():
        if len(L) > degree + 1:
            degree = len(L) - 1;
    R = PolynomialRing(ZZ, degree, "a")
    S = PowerSeriesRing(R, default_prec = ceil(log(bound)/log(2))); 
    P = [1] + list(R.gens());
    recursion = (1/S(P)).list();
    
    A = [None]*(bound + 1);
    A[0] = 0;
    A[1] = 1;
    i = 1;
    # sieve through [1, bound]
    while i <= bound:
        if A[i] is None:
            #i is a prime
            if i in euler_factors:
                euler_i = euler_factors[i][1:];
            else:
                euler_i = [];
                
            euler_i += [0] * (degree - len(euler_i)); # fill with zeros if necessary            
            # deal with its powers
            r = 1;
            ipower = i # i^r
            while ipower <= bound:
                A[ipower] = recursion[r](euler_i)
                ipower *= i;
                r += 1;
            # deal with multiples of its powers by smaller numbers 
            for m in range(2, bound):
                if A[m] is not None and m%i != 0:
                    ipower = i
                    while m*ipower <= bound:
                        assert A[m*ipower] is None
                        A[m*ipower] = A[m] * A[ipower]
                        ipower *= i
        i += 1
    return A;
示例#36
0
    def _compute_simple_modules_graph_from_startpoint(self, s, p=None, cut_nonsimple_aniso=True, fast=1):
        # for forking this is necessary
        logger = get_logger(s)
        # print logger
        k = self._weight
        ###########################################################
        # Determine which primes need to be checked
        # According to the proof of Proposition XX in [BEF], we
        # only need to check primesnot dividing the 6*level(s),
        # for which prime_pol(s,p,k) <= 0.
        # For those primes, we check if there is any
        # k-simple fqm in s.C(p) and if not, we do not have to
        # consider p anymore.
        ###########################################################
        if p == None:
            p = 2
            N = Integer(6) * s.level()
            slp = N.prime_factors()
            for q in prime_range(next_prime(N) + 1):
                if not q in slp:
                    logger.info(
                        "Smallest prime not dividing 6*level({0}) = {1} is p = {2}".format(s, Integer(6) * s.level(), q))
                    p = q
                    break
            while prime_pol(s, p, k) <= 0 or p in slp:
                p = next_prime(p)
            p = uniq(prime_range(p) + slp)
        logger.info("Starting with s = {0} and primes = {1}".format(s, p))
        
        if isinstance(p, list):
            primes = p
        else:
            primes = [p]

        simple = s.is_simple(k, reduction = self._reduction, bound = self._bound)
        
        if not simple:
            logger.info("{0} is not simple.".format(s))

        # print simple
        s = FQM_vertex(s)
        # print s
        self.add_vertex(s)
        # print "added vertex ", s
        
        ############################################################
        # Starting from the list of primes we generated,
        # we now compute which primes we actually need to consider.
        # That is, the primes such that there is a fqm in s.C(p)
        # which is k-simple.
        ############################################################
        np = list()
        if cut_nonsimple_aniso and simple:
            for i in range(len(primes)):
                p = primes[i]
                fs = False
                for t in s.genus_symbol().C(p, False):
                    if t.is_simple(k, bound = self._bound):
                        fs = True
                        logger.debug("Setting fs = True")
                        break
                if fs:
                    np.append(p)
        primes = np
        # print "here", primes
        logger.info("primes for graph for {0}: {1}".format(s, primes))
        # if len(primes) == 0:
        #    return
        heights = self._heights
        h = 0
        if not heights.has_key(h):
            heights[h] = [s]
        else:
            if heights[h].count(s) == 0:
                heights[h].append(s)
        vertex_colors = self._vertex_colors
        nonsimple_color = self._nonsimple_color
        simple_color = self._simple_color
        # Bs contains the modules of the current level (= height = h)
        Bs = [s]
        # set the correct color for the vertex s
        if simple:
            if vertex_colors[simple_color].count(s) == 0:
                vertex_colors[simple_color].append(s)
        elif vertex_colors[nonsimple_color].count(s) == 0:
            vertex_colors[nonsimple_color].append(s)
        
        ###################################################
        # MAIN LOOP
        # we loop until we haven't found any simple fqm's
        ###################################################
        while simple:
            h = h + 1
            if not heights.has_key(h):
                heights[h] = list()
            # the list Bss will contain the k-simple modules of the next height level
            # recall that Bs contains the modules of the current height level
            Bss = list()
            simple = False
            # checklist = modules that we need to check for with .is_simple(k)
            # we assemble this list because afterwards
            # we check them in parallel
            checklist = []
            for s1 in Bs:
                Bs2 = list()
                for p in primes:
                    # check if we really need to check p for s1
                    # otherwise none of the fqm's in s1.C(p) are simple
                    # and we will not consider them.
                    if prime_pol(s1.genus_symbol(), p, k) <= 0:
                        Bs2 = Bs2 + s1.genus_symbol().C(p, False)
                    else:
                        logger.info(
                            "Skipping p = {0} for s1 = {1}".format(p, s1))
                        # print "Skipping p = {0} for s1 = {1}".format(p, s1)
                # print "Bs2 = ", Bs2
                # now we actually check the symbols in Bs2
                for s2 in Bs2:
                    if s2.max_rank() > self._rank_limit:
                        # we skip s2 if its minimal number of generators
                        # is > than the given rank_limit.
                        continue
                    s2 = FQM_vertex(s2)
                    skip = False
                    for v in self._heights[h]:
                        # we skip symbols that correspond to isomorphic modules
                        if v.genus_symbol().defines_isomorphic_module(s2.genus_symbol()):
                            skip = True
                            logger.debug(
                                "skipping {0} b/c isomorphic to {1}".format(s2.genus_symbol(), v.genus_symbol()))
                            s2 = v
                            break
                    if skip:
                        continue
                    if not skip:
                        self.add_vertex(s2)
                        heights[h].append(s2)
                    self.update_edges(s2, h, fast=fast)
                    # before using the actual dimension formula
                    # we check if there is already a non-k-simple neighbor
                    # (an incoming edge from a non-k-simple module)
                    # which would imply that s2 is not k-simple.
                    has_nonsimple_neighbor = False
                    for e in self.incoming_edges(s2):
                        if vertex_colors[nonsimple_color].count(e[0]) > 0:
                            has_nonsimple_neighbor = True
                            logger.debug(
                                "Has nonsimple neighbor: {0}".format(s2.genus_symbol()))
                            break
                    if has_nonsimple_neighbor:
                        #not simple
                        if not vertex_colors[nonsimple_color].count(s2) > 0:
                            vertex_colors[nonsimple_color].append(s2)
                    else:
                        checklist.append((s2, k, self._reduction, self._bound))
            logger.debug("checklist = {0}".format(checklist))
            # check the modules in checklist
            # for being k-simple
            # this is done in parallel
            # when a process returns
            # we add the vertex and give it its appropriate color
            if NCPUS1 == 1:
                checks = [([[s[0]]],check_simple(*s)) for s in checklist]
            else:
                checks = list(check_simple(checklist))
            logger.info("checks = {0}".format(checks))
            for check in checks:
                s2 = check[0][0][0]
                if check[1]:
                    simple = True
                    logger.info(
                        "Found simple module: {0}".format(s2.genus_symbol()))
                    Bss.append(s2)
                    if not vertex_colors[simple_color].count(s2) > 0:
                        vertex_colors[simple_color].append(s2)
                else:
                    if not vertex_colors[nonsimple_color].count(s2) > 0:
                        vertex_colors[nonsimple_color].append(s2)
            Bs = Bss
        simple = [v.genus_symbol() for v in vertex_colors[simple_color]]
        self._simple = uniq(simple)
Z = [0,]*len(X)
for i in range(len(X)):
    x = X[i]
    z = previous_prime(x)  # Returns z < x
    if is_prime(x):  # galois.prev_prime() returns z <= x
        z = x
    Z[i] = int(z)
d = {"X": X, "Z": Z}
save_pickle(d, FOLDER, "prev_prime.pkl")

set_seed(SEED + 304)
X = [random.randint(1, 100) for _ in range(20)] + [random.randint(100, 1_000_000) for _ in range(20)]
Z = [0,]*len(X)
for i in range(len(X)):
    x = X[i]
    z = next_prime(x)
    Z[i] = int(z)
d = {"X": X, "Z": Z}
save_pickle(d, FOLDER, "next_prime.pkl")

set_seed(SEED + 305)
X = [random.randint(-100, 100) for _ in range(20)] + [random.randint(100, 1_000_000_000) for _ in range(20)]
Z = [0,]*len(X)
for i in range(len(X)):
    x = X[i]
    z = is_prime(x)
    Z[i] = bool(z)
d = {"X": X, "Z": Z}
save_pickle(d, FOLDER, "is_prime.pkl")

# set_seed(SEED + 306)
示例#38
0
    def _compute_simple_modules_graph_from_startpoint(self,
                                                      s,
                                                      p=None,
                                                      cut_nonsimple_aniso=True,
                                                      fast=1):
        # for forking this is necessary
        logger = get_logger(s)
        # print logger
        k = self._weight
        ###########################################################
        # Determine which primes need to be checked
        # According to the proof of Proposition XX in [BEF], we
        # only need to check primesnot dividing the 6*level(s),
        # for which prime_pol(s,p,k) <= 0.
        # For those primes, we check if there is any
        # k-simple fqm in s.C(p) and if not, we do not have to
        # consider p anymore.
        ###########################################################
        if p == None:
            p = 2
            N = Integer(6) * s.level()
            slp = N.prime_factors()
            for q in prime_range(next_prime(N) + 1):
                if not q in slp:
                    logger.info(
                        "Smallest prime not dividing 6*level({0}) = {1} is p = {2}"
                        .format(s,
                                Integer(6) * s.level(), q))
                    p = q
                    break
            while prime_pol(s, p, k) <= 0 or p in slp:
                p = next_prime(p)
            p = uniq(prime_range(p) + slp)
        logger.info("Starting with s = {0} and primes = {1}".format(s, p))

        if isinstance(p, list):
            primes = p
        else:
            primes = [p]

        simple = s.is_simple(k, reduction=self._reduction, bound=self._bound)

        if not simple:
            logger.info("{0} is not simple.".format(s))

        # print simple
        s = FQM_vertex(s)
        # print s
        self.add_vertex(s)
        # print "added vertex ", s

        ############################################################
        # Starting from the list of primes we generated,
        # we now compute which primes we actually need to consider.
        # That is, the primes such that there is a fqm in s.C(p)
        # which is k-simple.
        ############################################################
        np = list()
        if cut_nonsimple_aniso and simple:
            for i in range(len(primes)):
                p = primes[i]
                fs = False
                for t in s.genus_symbol().C(p, False):
                    if t.is_simple(k, bound=self._bound):
                        fs = True
                        logger.debug("Setting fs = True")
                        break
                if fs:
                    np.append(p)
        primes = np
        # print "here", primes
        logger.info("primes for graph for {0}: {1}".format(s, primes))
        # if len(primes) == 0:
        #    return
        heights = self._heights
        h = 0
        if not heights.has_key(h):
            heights[h] = [s]
        else:
            if heights[h].count(s) == 0:
                heights[h].append(s)
        vertex_colors = self._vertex_colors
        nonsimple_color = self._nonsimple_color
        simple_color = self._simple_color
        # Bs contains the modules of the current level (= height = h)
        Bs = [s]
        # set the correct color for the vertex s
        if simple:
            if vertex_colors[simple_color].count(s) == 0:
                vertex_colors[simple_color].append(s)
        elif vertex_colors[nonsimple_color].count(s) == 0:
            vertex_colors[nonsimple_color].append(s)

        ###################################################
        # MAIN LOOP
        # we loop until we haven't found any simple fqm's
        ###################################################
        while simple:
            h = h + 1
            if not heights.has_key(h):
                heights[h] = list()
            # the list Bss will contain the k-simple modules of the next height level
            # recall that Bs contains the modules of the current height level
            Bss = list()
            simple = False
            # checklist = modules that we need to check for with .is_simple(k)
            # we assemble this list because afterwards
            # we check them in parallel
            checklist = []
            for s1 in Bs:
                Bs2 = list()
                for p in primes:
                    # check if we really need to check p for s1
                    # otherwise none of the fqm's in s1.C(p) are simple
                    # and we will not consider them.
                    if prime_pol(s1.genus_symbol(), p, k) <= 0:
                        Bs2 = Bs2 + s1.genus_symbol().C(p, False)
                    else:
                        logger.info("Skipping p = {0} for s1 = {1}".format(
                            p, s1))
                        # print "Skipping p = {0} for s1 = {1}".format(p, s1)
                # print "Bs2 = ", Bs2
                # now we actually check the symbols in Bs2
                for s2 in Bs2:
                    if s2.max_rank() > self._rank_limit:
                        # we skip s2 if its minimal number of generators
                        # is > than the given rank_limit.
                        continue
                    s2 = FQM_vertex(s2)
                    skip = False
                    for v in self._heights[h]:
                        # we skip symbols that correspond to isomorphic modules
                        if v.genus_symbol().defines_isomorphic_module(
                                s2.genus_symbol()):
                            skip = True
                            logger.debug(
                                "skipping {0} b/c isomorphic to {1}".format(
                                    s2.genus_symbol(), v.genus_symbol()))
                            s2 = v
                            break
                    if skip:
                        continue
                    if not skip:
                        self.add_vertex(s2)
                        heights[h].append(s2)
                    self.update_edges(s2, h, fast=fast)
                    # before using the actual dimension formula
                    # we check if there is already a non-k-simple neighbor
                    # (an incoming edge from a non-k-simple module)
                    # which would imply that s2 is not k-simple.
                    has_nonsimple_neighbor = False
                    for e in self.incoming_edges(s2):
                        if vertex_colors[nonsimple_color].count(e[0]) > 0:
                            has_nonsimple_neighbor = True
                            logger.debug("Has nonsimple neighbor: {0}".format(
                                s2.genus_symbol()))
                            break
                    if has_nonsimple_neighbor:
                        #not simple
                        if not vertex_colors[nonsimple_color].count(s2) > 0:
                            vertex_colors[nonsimple_color].append(s2)
                    else:
                        checklist.append((s2, k, self._reduction, self._bound))
            logger.debug("checklist = {0}".format(checklist))
            # check the modules in checklist
            # for being k-simple
            # this is done in parallel
            # when a process returns
            # we add the vertex and give it its appropriate color
            if NCPUS1 == 1:
                checks = [([[s[0]]], check_simple(*s)) for s in checklist]
            else:
                checks = list(check_simple(checklist))
            logger.info("checks = {0}".format(checks))
            for check in checks:
                s2 = check[0][0][0]
                if check[1]:
                    simple = True
                    logger.info("Found simple module: {0}".format(
                        s2.genus_symbol()))
                    Bss.append(s2)
                    if not vertex_colors[simple_color].count(s2) > 0:
                        vertex_colors[simple_color].append(s2)
                else:
                    if not vertex_colors[nonsimple_color].count(s2) > 0:
                        vertex_colors[nonsimple_color].append(s2)
            Bs = Bss
        simple = [v.genus_symbol() for v in vertex_colors[simple_color]]
        self._simple = uniq(simple)
示例#39
0
def get_type_1_primes(K, aux_prime_count=3, loop_curves=False):
    """Compute the type 1 primes"""

    C_K = K.class_group()
    aux_primes = [Q_2]
    prime_to_append = Q_2
    for _ in range(1, aux_prime_count):
        prime_to_append = next_prime(prime_to_append)
        aux_primes.append(prime_to_append)

    # We need at least one aux prime that splits to have provable termination

    my_legendre_symbols = set([legendre_symbol(K._D, p) for p in aux_primes])
    if 1 not in my_legendre_symbols:
        prime_to_append = next_prime(prime_to_append)
        while legendre_symbol(K._D, prime_to_append) != 1:
            prime_to_append = next_prime(prime_to_append)
        aux_primes.append(prime_to_append)

    D_dict = {}

    for q in aux_primes:
        frak_q = K.primes_above(q)[0]
        residue_field = frak_q.residue_field(names="z")
        residue_field_card = residue_field.cardinality()
        frak_q_class_group_order = C_K(frak_q).multiplicative_order()
        exponent = 12 * frak_q_class_group_order

        running_D = q
        if loop_curves:
            weil_polys = get_weil_polys(residue_field)
        else:
            weil_polys = R.weil_polynomials(2, residue_field_card)

        # First add the C((0,0), frak_q) terms
        for wp in weil_polys:
            D = get_C00(wp, residue_field_card, exponent)
            D = Integer(D)
            # If q splits then we know C((0,0),frak_q) is non-zero
            # so we can insist on only adding D if it is non-zero
            if legendre_symbol(K._D, q) == 1:
                if D != 0:
                    running_D = lcm(running_D, D)
            else:
                # Here we do not provably know that the integer is non-zero
                # so add it directly to the running_D
                running_D = lcm(running_D, D)

        # Put the other term in the lcm before adding to dictionary
        running_D = lcm(residue_field_card ** exponent - 1, running_D)
        D_dict[q] = running_D

    output = gcd(list(D_dict.values()))
    output = set(output.prime_divisors())

    # Add the bad formal immersion primes
    output = output.union(set(prime_range(62)), {71})

    # Sort and return
    output = list(output)
    output.sort()
    return output
示例#40
0
文件: test.py 项目: staalezh/curves
import sys

from random_curve_iterator import RandomCurveIterator
from sage.all import GF, next_prime

if __name__ == "__main__":
    p = next_prime(100)

    F = GF(p)

    count = 0
    for ec in RandomCurveIterator(F):
        if ec.cardinality() == p - 1:
            print(ec)
            sys.exit()
示例#41
0
nfcc = [int(z.order()) for z in nfcc]
nfcc = lcm(nfcc)
if not cfz.divides(nfcc):
    print("Failure " + str(cfz) + " divides " + str(nfcc) + " from " + label)
    sys.exit()
R, x = QQ['x'].objgen()
pol1 = R.cyclotomic_polynomial(nfcc)
K, z = NumberField(R.cyclotomic_polynomial(nfcc), 'z').objgen()
RR, y = K['y'].objgen()
zsmall = z**(nfcc / cfz)
allpols = [
    sum(y**k * sum(pp[k][j] * zsmall**j for j in range(len(pp[k])))
        for k in range(len(pp))) for pp in ar.local_factors_table()
]
allroots = [myroots(pp, nfcc, z) for pp in allpols]

outfile.write(str(nfcc) + "\n")
outfile.write(str(allroots) + "\n")
j = 0
p = 1
while j < bound:
    p = next_prime(p)
    outfile.write(str(ar.any_prime_to_cc_index(p)) + "\n")
    j += 1

#plist = [ar.any_prime_to_cc_index(p) for p in primes_first_n(bound)]
#for j in plist:
#    outfile.write(str(j)+"\n")

outfile.close()
示例#42
0
cfz = ZZ(cf)
nf = ar.nf()
nfcc = nf.conjugacy_classes()
nfcc = [int(z.order()) for z in nfcc]
nfcc = lcm(nfcc)
if not cfz.divides(nfcc):
    print "Failure "+str(cfz)+" divides "+str(nfcc)+" from "+label
    sys.exit()
R,x = QQ['x'].objgen()
pol1 = R.cyclotomic_polynomial(nfcc)
K,z=NumberField(R.cyclotomic_polynomial(nfcc),'z').objgen()
RR,y = K['y'].objgen()
zsmall = z**(nfcc/cfz)
allpols = [sum(y**k * sum(pp[k][j] * zsmall**j for j in range(len(pp[k]))) for k in range(len(pp))) for pp in ar.local_factors_table()]
allroots = [myroots(pp, nfcc, z) for pp in allpols]

outfile.write(str(nfcc)+"\n")
outfile.write(str(allroots)+"\n")
j=0
p=1
while j<bound:
    p = next_prime(p)
    outfile.write(str(ar.any_prime_to_cc_index(p))+"\n")
    j+=1
  
#plist = [ar.any_prime_to_cc_index(p) for p in primes_first_n(bound)]
#for j in plist:
#    outfile.write(str(j)+"\n")

outfile.close()