def random_Dirichletwebpage():
modulus = randint(1, 9999)
number = randint(1, modulus - 1)
while gcd(modulus, number) > 1:
number = randint(1, modulus - 1)
return redirect(
url_for('.render_Dirichletwebpage',
modulus=str(modulus),
number=str(number)))
def test_karatsuba_multiplication(base_ring, maxdeg1, maxdeg2,
ref_mul=lambda f, g: f._mul_generic(g), base_ring_random_elt_args=[],
numtests=10, verbose=False):
"""
Test univariate karatsuba multiplication against other multiplication algorithms.
EXAMPLES:
First check that random tests are reproducible::
sage: import sage.rings.tests
sage: sage.rings.tests.test_karatsuba_multiplication(ZZ, 6, 5, verbose=True, seed=42)
test_karatsuba_multiplication: ring=Univariate Polynomial Ring in x over Integer Ring, threshold=2
(2*x^6 - x^5 - x^4 - 3*x^3 + 4*x^2 + 4*x + 1)*(4*x^4 + x^3 - 2*x^2 - 20*x + 3)
(16*x^2)*(x^2 - 41*x + 1)
(-x + 1)*(x^2 + 2*x + 8)
(-x^6 - x^4 - 8*x^3 - x^2 - 4*x + 3)*(-x^3 - x^2)
(2*x^2 + x + 1)*(x^4 - x^3 + 3*x^2 - x)
(-x^3 + x^2 + x + 1)*(4*x^2 + 76*x - 1)
(6*x + 1)*(-5*x - 1)
(-x^3 + 4*x^2 + x)*(-x^5 + 3*x^4 - 2*x + 5)
(-x^5 + 4*x^4 + x^3 + 21*x^2 + x)*(14*x^3)
(2*x + 1)*(12*x^3 - 12)
Test Karatsuba multiplication of polynomials of small degree over some common rings::
sage: for C in [QQ, ZZ[I], ZZ[I, sqrt(2)], GF(49, 'a'), MatrixSpace(GF(17), 3)]:
....: sage.rings.tests.test_karatsuba_multiplication(C, 10, 10)
Zero-tests over ``QQbar`` are currently very slow, so we test only very small examples::
sage.rings.tests.test_karatsuba_multiplication(QQbar, 3, 3, numtests=2)
Larger degrees (over ``ZZ``, using FLINT)::
sage: sage.rings.tests.test_karatsuba_multiplication(ZZ, 1000, 1000, ref_mul=lambda f,g: f*g, base_ring_random_elt_args=[1000])
Some more aggressive tests::
sage: for C in [QQ, ZZ[I], ZZ[I, sqrt(2)], GF(49, 'a'), MatrixSpace(GF(17), 3)]:
....: sage.rings.tests.test_karatsuba_multiplication(C, 10, 10) # long time
sage: sage.rings.tests.test_karatsuba_multiplication(ZZ, 10000, 10000, ref_mul=lambda f,g: f*g, base_ring_random_elt_args=[100000])
"""
from sage.all import randint, PolynomialRing
threshold = randint(0, min(maxdeg1,maxdeg2))
R = PolynomialRing(base_ring, 'x')
if verbose:
print "test_karatsuba_multiplication: ring={}, threshold={}".format(R, threshold)
for i in range(numtests):
f = R.random_element(randint(0, maxdeg1), *base_ring_random_elt_args)
g = R.random_element(randint(0, maxdeg2), *base_ring_random_elt_args)
if verbose:
print " ({})*({})".format(f, g)
if ref_mul(f, g) - f._mul_karatsuba(g, threshold) != 0:
raise ValueError("Multiplication failed")
return
def test_ae_equivalence(N, verbose=False):
from timeit import default_timer
false_negatives = 0
false_positives = 0
n_tested = 10
for i in xrange(0, n_tested):
# checking if linearly equivalent permutations are identified
f = random_permutation(N)
A = rand_linear_permutation(N)
a = randint(0, 2**N - 1)
B = rand_linear_permutation(N)
b = randint(0, 2**N - 1)
g = [
oplus(apply_bin_mat(f[apply_bin_mat(oplus(x, a), A)], B), b)
for x in xrange(0, 2**N)
]
computation_start = default_timer()
result = affine_equivalence(f, g)
computation_end = default_timer()
elapsed = computation_end - computation_start
if len(result) > 1:
if not check_affine_equivalence(f, g, result[0], result[1],
result[2], result[3]):
false_negatives += 1
if verbose:
print("[FAIL] wrong affine permutations")
else:
if verbose:
print("[success] AE {:0.4f}".format(elapsed))
else:
false_negatives += 1
if verbose:
print("[FAIL] AE {:0.4f}s (nothing found)".format(elapsed))
# checking if non-affine equivalent functions are identified
g = random_permutation(N)
result = affine_equivalence(f, g)
if len(result) == 0:
if verbose:
print("[success] non-AE {:0.4f}s".format(elapsed))
else:
if check_affine_equivalence(f, g, result[0], result[1], result[2],
result[3]):
if verbose:
print("[success] act.AE {:0.4f}".format(elapsed))
else:
false_positives += 1
if verbose:
print("[FAIL] matrices found for non-LE permutations")
print(
"* testing if AE functions are identified correctly (with correct affine permutations)"
)
print_result(n_tested - false_negatives, n_tested)
print("* testing if NON-LE functions are identified correctly")
print_result(n_tested - false_positives, n_tested)
def test_nose(cls=Kyber,
l=None,
t=128,
seed=0xdeadbeef,
proof=False,
worst_case=True):
"""
Test correctness of the Sneeze/Snort gadget for normal form MLWE parameters.
TESTS::
sage: test_nose(MiniKyber)
sage: test_nose(MiniPseudoLima, seed=1, worst_case=False)
sage: test_nose(MiniKyber, l = Nose.prec(MiniKyber)-1)
Traceback (most recent call last):
...
AssertionError
sage: test_nose(MiniPseudoLima, l = Nose.prec(MiniPseudoLima)-1, seed=1, worst_case=False)
Traceback (most recent call last):
...
AssertionError
.. note :: An ``AssertionError`` if final key does not match original.
"""
if seed is not None:
set_random_seed(seed)
R, x = PolynomialRing(ZZ, "x").objgen()
D = BinomialDistribution
# TODO ce
n, q, eta, k, f = cls.n, cls.q, cls.eta, cls.k, R(cls.f)
Rq = PolynomialRing(GF(q), "x")
if not l:
l = Nose.prec(cls)
l = ceil(l)
for _ in range(t):
if worst_case:
a = vector(Rq, k, [[q // 2 + randint(0, 1) for _ in range(n)]
for i in range(k)]) # noqa
s = vector(R, k, [[((-1)**randint(0, 1)) * eta for _ in range(n)]
for i in range(k)])
e = R([((-1)**randint(0, 1)) * eta for _ in range(n)])
else:
a = vector(Rq, k,
[Rq.random_element(degree=n - 1) for i in range(k)])
s = vector(R, k, [[D(eta) for _ in range(n)] for i in range(k)])
e = R([D(eta) for _ in range(n)])
b = (a * s + e) % f
bb = Rq(Nose.muladd(cls, a, s, e, l=l))
assert (b == bb)
def basis_of_simple_closed_curves(self):
from sage.graphs.digraph import DiGraph
from sage.all import randint
n = self._origami.nb_squares()
C = self.chain_space()
G = DiGraph(multiedges=True, loops=True, implementation='c_graph')
for i in xrange(2 * n):
G.add_edge(self._starts[i], self._ends[i], i)
waiting = [0]
gens = []
reps = [None] * G.num_verts()
reps[0] = C.zero()
while waiting:
x = waiting.pop(randint(0, len(waiting) - 1))
for v0, v1, e in G.outgoing_edges(x):
if reps[v1] is not None:
gens.append(reps[v0] + C.gen(e) - reps[v1])
else:
reps[v1] = reps[v0] + C.gen(e)
waiting.append(v1)
return gens
def find_element_of_order(k,r):
"""
Description:
Finds a random element of order k in Z_r^*
Input:
k - integer such that r % k == 1
r - prime
Output:
h - element of order k in Z_r^*
"""
assert r % k == 1
h = 0
def order(h,k,p):
bool = True
g = h
for i in range(1,k):
bool = bool and g != 1
g = Mod(g * h, p)
bool = bool and g == 1
return bool
while not order(h,k,r): # expected number of iterations is k/euler_phi(k)
h = power_mod(randint(2, r-1), (r-1)//k, r)
return h
def find_element_of_order(k, r):
"""
Description:
Finds a random element of order k in Z_r^*
Input:
k - integer such that r % k == 1
r - prime
Output:
h - element of order k in Z_r^*
"""
assert r % k == 1
h = 0
def order(h, k, p):
bool = True
g = h
for i in range(1, k):
bool = bool and g != 1
g = Mod(g * h, p)
bool = bool and g == 1
return bool
while not order(h, k,
r): # expected number of iterations is k/euler_phi(k)
h = power_mod(randint(2, r - 1), (r - 1) // k, r)
return h
def test_fast_multiplier(verbose=False):
print("testing fast linear mappings")
all_good = True
n, m = 8, 4
for index_L in xrange(0, 10):
m += 1
L = rand_linear_function(n, m)
L_map = FastLinearMapping(L)
if verbose:
print "--- ", L_map.input_size(), L_map.output_size()
for index_x in xrange(0, 8):
x = randint(1, 2**n - 1)
y = apply_bin_mat(x, L)
y_prime = L_map(x)
if verbose:
print y, y_prime
if y != y_prime:
all_good = False
break
if verbose:
if all_good:
print("[SUCCESS]")
else:
print("[FAIL]")
return all_good
def basis_of_simple_closed_curves(self):
from sage.graphs.digraph import DiGraph
from sage.all import randint
n = self._origami.nb_squares()
C = self.chain_space()
G = DiGraph(multiedges=True,loops=True,implementation='c_graph')
for i in xrange(2*n):
G.add_edge(self._starts[i], self._ends[i], i)
waiting = [0]
gens = []
reps = [None] * G.num_verts()
reps[0] = C.zero()
while waiting:
x = waiting.pop(randint(0,len(waiting)-1))
for v0,v1,e in G.outgoing_edges(x):
if reps[v1] is not None:
gens.append(reps[v0] + C.gen(e) - reps[v1])
else:
reps[v1] = reps[v0] + C.gen(e)
waiting.append(v1)
return gens
def time_search_loop(p):
y = random_vector(F, n)
g = random_matrix(F, p, n).rows()
scalars = [ [ Fstar[randint(0,q-2)] for i in range(p) ]
for s in range(100) ]
before = process_time()
for m in scalars:
e = y - sum(m[i]*g[i] for i in range(p))
return (process_time() - before)/100.
def random_url():
routes = [
"L/",
"L/",
"L/",
"ModularForm/GL2/Q/holomorphic/",
"ModularForm/GL2/Q/Maass/",
"ModularForm/GL2/TotallyReal/",
"ModularForm/GL2/ImaginaryQuadratic/",
"EllipticCurve/Q/",
"EllipticCurve/",
"Genus2Curve/Q/",
"HigherGenus/C/Aut/",
"Variety/Abelian/Fq/",
"NumberField/",
"LocalNumberField/",
"Character/Dirichlet/",
"ArtinRepresentation/",
"GaloisGroup/",
"SatoTateGroup/"
]
if is_beta():
routes += [
"ModularForm/GSp/Q/",
"Belyi/",
"Motive/Hypergeometric/Q/",
"Lattice/"
]
route = routes[randint(0,len(routes)-1)]
if route == "ModularForm/GL2/Q/holomorphic/":
ind = randint(0,1)
if ind == 0:
route += "random"
else:
route += "random_space"
elif route == "Motive/Hypergeometric/Q/":
ind = randint(0,1)
if ind == 0:
route += "random_motive"
else:
route += "random_family"
else:
route += "random"
return route
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 time_search_loop(p):
y = random_vector(F, n)
g = random_matrix(F, p, n).rows()
scalars = [ [ Fstar[randint(0,q-2)] for i in range(p) ]
for s in range(100) ]
before = time.clock()
for m in scalars:
e = y - sum(m[i]*g[i] for i in range(p))
errs = e.hamming_weight()
return (time.clock() - before)/100.
def time_search_loop(p):
y = random_vector(F, n)
g = random_matrix(F, p, n).rows()
scalars = [[Fstar[randint(0, q - 2)] for i in range(p)]
for s in range(100)]
before = time.clock()
for m in scalars:
e = y - sum(m[i] * g[i] for i in range(p))
errs = e.hamming_weight()
return (time.clock() - before) / 100.
def test_conrey(nranges=[(20, 100), (200, 1000), (500, 500000)]):
for n, r in nranges:
for i in range(n):
q = randint(1, r)
print("n, r, i, q = {}, {}, {}, {}".format(n, r, i, q))
G = DirichletGroup_conrey(q)
inv = G.invariants()
cinv = tuple([Mod(g, q).multiplicative_order() for g in G.gens()])
try:
assert prod(inv) == G.order()
assert q <= 2 or G.zeta_order() == inv[0]
assert cinv == inv
except:
print('group error')
return q, inv, G
if q > 2:
m = 0
while gcd(m, q) != 1:
m = randint(1, q)
chi = G[m]
n = randint(1, q)
try:
assert chi.multiplicative_order() == Mod(
m, q).multiplicative_order()
if gcd(n, q) != 1:
try:
assert chi.logvalue(n) == -1
except:
print('non unit value error')
return chi, n, r
elif q < 10 ^ 6:
try:
ref = chi.sage_character()(n).n().real()
new = N(chi(n).real)
assert abs(ref - new) < 1e-5
except:
print('unit value error')
return chi, n
except:
print('char error')
return chi, n, r
def test_bn(num_tests):
# finds num_tests BN curves with random bit sizes;
# checks that each curve found is a suitable curve
print('testing BN...')
fail = 0
for i in range(0, num_tests):
num_bits = randint(50,100)
num_curves = randint(1, 20)
try:
curves = bn.make_curve(num_bits, num_curves)
assert len(curves) == num_curves
for q,t,r,k,D in curves:
assert utils.is_suitable_curve(q,t,r,k,D, num_bits)
except AssertionError as e:
fail+=1
if fail == 0:
print('test passed')
return True
else:
print("failed %.2f" %(100*fail/num_tests) + "% of tests!")
return False
def test_bn(num_tests):
# finds num_tests BN curves with random bit sizes;
# checks that each curve found is a suitable curve
print('testing BN...')
fail = 0
for i in range(0, num_tests):
num_bits = randint(50, 100)
num_curves = randint(1, 20)
try:
curves = bn.make_curve(num_bits, num_curves)
assert len(curves) == num_curves
for q, t, r, k, D in curves:
assert utils.is_suitable_curve(q, t, r, k, D, num_bits)
except AssertionError as e:
fail += 1
if fail == 0:
print('test passed')
return True
else:
print("failed %.2f" % (100 * fail / num_tests) + "% of tests!")
return False
def random_point(self):
"""
Return a random closed point on the curve.
"""
F = self.function_field()
F0 = self.rational_function_field()
R = F0._ring
f = R.random_element(degree=(1,3)).factor()[0][0](F0.gen())
v0 = F0.valuation(f)
V = v0.extensions(F)
v = V[randint(0, len(V)-1)]
return PointOnSmoothProjectiveCurve(self, v)
def run(num_bits, k):
"""
Description:
Runs the Dupont-Enge-Morain method multiple times until a valid curve is found
Input:
num_bits - number of bits
k - an embedding degree
Output:
(q,t,r,k,D) - an elliptic curve;
if no curve is found, the algorithm returns (0,0,0,k,0)
"""
j, r, q, t = 0, 0, 0, 0
num_generates = 512
h = num_bits / (euler_phi(k))
tried = [(0, 0)] # keep track of random values tried for efficiency
for i in range(0, num_generates):
D = 0
y = 0
while (D, y) in tried: # find a pair that we have not tried
D = -randint(1,
1024) # pick a small D so that the CM method is fast
D = fundamental_discriminant(D)
m = 0.5 * (h - log(-D).n() / (2 * log(2)).n())
if m < 1:
m = 1
y = randint(floor(2**(m - 1)), floor(2**m))
tried.append((D, y))
q, t, r, k, D = method(num_bits, k, D, y) # run DEM
if q != 0 and t != 0 and r != 0 and k != 0 and D != 0: # found an answer, so output it
assert is_valid_curve(q, t, r, k, D), 'Invalid output'
return q, t, r, k, D
return 0, 0, 0, k, 0 # found nothing
def test_ec(num_tests, num_bits, debug=False):
print('testing EC chain...')
func_start = time.time()
fail = 0
for i in range(0, num_tests):
try:
k = randint(5, 20)
r = 0
while not (r % k == 1 and is_prime(r)):
r = random_prime(2**(num_bits - 1), 2**num_bits)
k_vector = [k]
k_vector.append(randint(5, 20))
k_vector.append(randint(5, 20))
curves = ec.new_chain(r, k_vector)
assert ec.is_chain(curves)
except AssertionError as e:
fail += 1
if fail == 0:
print('test passed')
return True
else:
print("failed %.2f" % (100 * fail / num_tests) + "% of tests!")
return False
def test_ec(num_tests,num_bits, debug=False):
print('testing EC chain...')
func_start = time.time()
fail = 0
for i in range(0, num_tests):
try:
k = randint(5,20)
r = 0
while not (r % k == 1 and is_prime(r)):
r = random_prime(2**(num_bits-1), 2**num_bits)
k_vector = [k]
k_vector.append(randint(5,20))
k_vector.append(randint(5,20))
curves = ec.new_chain(r, k_vector)
assert ec.is_chain(curves)
except AssertionError as e:
fail += 1
if fail == 0:
print('test passed')
return True
else:
print("failed %.2f" %(100*fail/num_tests) + "% of tests!")
return False
def run(num_bits,k):
"""
Description:
Runs the Dupont-Enge-Morain method multiple times until a valid curve is found
Input:
num_bits - number of bits
k - an embedding degree
Output:
(q,t,r,k,D) - an elliptic curve;
if no curve is found, the algorithm returns (0,0,0,k,0)
"""
j,r,q,t = 0,0,0,0
num_generates = 512
h = num_bits/(euler_phi(k))
tried = [(0,0)] # keep track of random values tried for efficiency
for i in range(0,num_generates):
D = 0
y = 0
while (D,y) in tried: # find a pair that we have not tried
D = -randint(1, 1024) # pick a small D so that the CM method is fast
D = fundamental_discriminant(D)
m = 0.5*(h - log(-D).n()/(2*log(2)).n())
if m < 1:
m = 1
y = randint(floor(2**(m-1)), floor(2**m))
tried.append((D,y))
q,t,r,k,D = method(num_bits,k,D,y) # run DEM
if q != 0 and t != 0 and r != 0 and k != 0 and D != 0: # found an answer, so output it
assert is_valid_curve(q,t,r,k,D), 'Invalid output'
return q,t,r,k,D
return 0,0,0,k,0 # found nothing
def test_segment_intersect():
from flatsurf.geometry.polygon import segment_intersect
for _ in range(4096):
us = (randint(-4, 4), randint(-4, 4))
ut = (randint(-4, 4), randint(-4, 4))
vs = (randint(-4, 4), randint(-4, 4))
vt = (randint(-4, 4), randint(-4, 4))
if us == ut or vs == vt:
continue
ans1 = segment_intersect((us,ut),(vs,vt))
ans2 = segment_intersect((ut,us),(vs,vt))
ans3 = segment_intersect((us,ut),(vt,vs))
ans4 = segment_intersect((ut,us),(vt,vs))
ans5 = segment_intersect((vs,vt),(us,ut))
ans6 = segment_intersect((vt,vs),(us,ut))
ans7 = segment_intersect((vs,vt),(ut,us))
ans8 = segment_intersect((vt,vs),(ut,us))
assert (ans1 == ans2 == ans3 == ans4 == ans5 == ans6 == ans7 == ans8), (us, ut, vs, vt, ans1, ans2, ans3, ans4, ans5, ans6, ans7, ans8)
def random_split_primes(field, primes = 1, bits = 62, seed = None, relative_ext = None):
# input:
# * Number Field
# * number of split primes in the field
# * number of bits desired in each prime
# * random "seed"
# * optionally we might also require that a certain polynomial splits completely over the split primes
# Output a list [(p, root)] where:
# * p is a partially split prime in the number field (and fully split in the relative extension)
# * a root of the defining polynomial mod p
lower_bound = 2 ** (bits - 1);
if seed is None:
k = randint(1,2 ** (bits - 2) )
else:
k = 0;
p = lower_bound + 1 + 2*k;
if field is QQ:
f = [0, 1]
else:
f = field.defining_polynomial().list()
output = [];
ps = [];
if relative_ext is not None:
f_relative = relative_ext.list();
while len(output) < primes:
while not is_pseudoprime(p):
p += 2;
FF = FiniteField(p);
FFz = PolynomialRing(FF, "z");
roots = FFz(f).roots()
if len(roots) > 0: #== f.degree():
root = roots[0][0].lift();
if relative_ext is not None:
if len(FFz( reduce_list_split(f_relative, (p, root)) ).roots()) == len(f_relative) - 1:
output.append((p, root));
ps.append(p);
else:
output.append((p, root));
ps.append(p);
p += 2;
return output;
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
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
def test_dem2(num_tests,num_bits,k, debug=False):
# runs dupont enge morain method num_tests times;
# each test uses a fixed embedding degree k
print('testing DEM...')
fail = 0
k2 = k
for i in range(0, num_tests):
if not k2:
k = randint(5,20)
try:
q,t,r,k,D = dem.run(num_bits,k)
assert utils.is_suitable_curve(q,t,r,k,D,num_bits)
except AssertionError as e:
fail += 1
if fail == 0:
print('test passed')
return True
else:
print("failed %.2f" %(100*fail/num_tests) + "% of tests!")
return False
def test_cm(num_tests,num_bits, debug=False):
# runs CM method num_tests times;
# each test uses a random output from the CP method with a num_bits bit prime
print('testing CM...')
fail = 0
for i in range(0, num_tests):
try:
k = randint(5,50)
r,k,D = cp.gen_params_from_bits(num_bits,k)
q,t,r,k,D = cp.run(r,k,D)
E = cm.make_curve(q,t,r,k,D)
assert E
assert cm.test_curve(q,t,r,k,D,E)
except AssertionError as e:
fail += 1
if fail == 0:
print('test passed')
return True
else:
print("failed %.2f" %(100*fail/num_tests) + "% of tests!")
return False
def test_cm(num_tests, num_bits, debug=False):
# runs CM method num_tests times;
# each test uses a random output from the CP method with a num_bits bit prime
print('testing CM...')
fail = 0
for i in range(0, num_tests):
try:
k = randint(5, 50)
r, k, D = cp.gen_params_from_bits(num_bits, k)
q, t, r, k, D = cp.run(r, k, D)
E = cm.make_curve(q, t, r, k, D)
assert E
assert cm.test_curve(q, t, r, k, D, E)
except AssertionError as e:
fail += 1
if fail == 0:
print('test passed')
return True
else:
print("failed %.2f" % (100 * fail / num_tests) + "% of tests!")
return False
def test_cp2(num_tests,num_bits,k, debug=False):
# runs CP method num_tests times;
# uses the same embedding degree k for every test
print('testing CP...')
fail = 0
k2 = k
for i in range(0, num_tests):
if not k2:
k = randint(5,50)
try:
r,k,D = cp.gen_params_from_bits(num_bits, k)
assert cp.test_promise(r,k,D)
q,t,r,k,D = cp.run(r,k,D)
assert utils.is_suitable_curve(q,t,r,k,D,num_bits)
except AssertionError as e:
fail += 1
if fail == 0:
print('test passed')
return True
else:
print("failed %.2f" %(100*fail/num_tests) + "% of tests!")
return False
def BinomialDistribution(eta):
r = 0
for i in range(eta):
r += randint(0, 1) - randint(0, 1)
return r
def random_Dirichletwebpage():
modulus = randint(1,9999)
number = randint(1,modulus-1)
while gcd(modulus,number) > 1:
number = randint(1,modulus-1)
return redirect(url_for('.render_Dirichletwebpage', modulus=str(modulus), number=str(number)))
