def test_gso_int_gram_enabled():
for int_type in int_types:
for m, n in dimensions:
A = make_integer_matrix(m, n, int_type=int_type)
for float_type in float_types:
M = GSO.Mat(copy(A), float_type=float_type)
assert M.int_gram_enabled is False
assert M.transform_enabled is False
M = GSO.Mat(copy(A), float_type=float_type, flags=GSO.INT_GRAM)
assert M.int_gram_enabled is True
assert M.transform_enabled is False
if m and n:
U = IntegerMatrix(m, m, int_type=int_type)
M = GSO.Mat(copy(A), U=U, float_type=float_type)
assert M.transform_enabled is True
assert M.inverse_transform_enabled is False
UinvT = IntegerMatrix(m, m, int_type=int_type)
M = GSO.Mat(copy(A),
U=U,
UinvT=UinvT,
float_type=float_type)
assert M.transform_enabled is True
assert M.inverse_transform_enabled is True
def test_bkz_gram_bkz_coherence():
"""
Test if BKZ is coherent if it is given a matrix A or its associated
Gram matrix A*A^T
We should have Gram(BKZ_basis(A)) = BKZ_Gram(Gram(A)).
"""
for m, n in dimensions:
if m < 2 or n < 2:
continue
for float_type in float_types:
A = make_integer_matrix(m, n)
G = tools.compute_gram(A)
GSO_A = GSO.Mat(A, float_type=float_type)
GSO_G = GSO.Mat(G, float_type=float_type, gram=True)
lll_obj_a = LLL.Reduction(GSO_A)
lll_obj_g = LLL.Reduction(GSO_G)
param = BKZ.Param(block_size=min(m, 40), strategies=BKZ.DEFAULT_STRATEGY)
bkz_a = BKZ.Reduction(GSO_A, lll_obj_a, param)
bkz_g = BKZ.Reduction(GSO_G, lll_obj_g, param)
bkz_a()
bkz_g()
G_updated = tools.compute_gram(A)
for i in range(m):
for j in range(i + 1):
assert G_updated[i, j] == G[i, j]
def main(n=150,
block_size=60,
float_type="d",
logq=40,
verbose=False,
seed=0xdeadbeef):
print "= n: %3d, β: %2d, bits: %3d, float_type: %s, seed: 0x%08x =" % (
n, block_size, logq, float_type, seed)
print
set_random_seed(seed)
A = IntegerMatrix.random(n, "qary", k=n // 2, bits=logq)
A = LLL.reduction(A)
params = BKZ.Param(block_size=block_size,
max_loops=4,
strategies=BKZ.DEFAULT_STRATEGY,
flags=BKZ.MAX_LOOPS | BKZ.VERBOSE)
bkz = BKZReduction(GSO.Mat(copy.copy(A), float_type=float_type))
bkz(params)
print bkz.trace
bkz2 = BKZ2(GSO.Mat(copy.copy(A), float_type=float_type))
bkz2(params)
print bkz2.trace
if verbose:
print
print bkz.trace.report()
def test_enum_gram_coherence():
"""
Test if the enumeration algorithm is consistent with the Gram matrices
The vectors returned by the enumeration should be the same wether a
lattice is given by its basis or by its Gram matrix
"""
dimensions = ((3, 3), (10, 10), (20, 20), (25, 25))
for m, n in dimensions:
for int_type in int_types:
A = make_integer_matrix(m, n, int_type=int_type)
LLL.reduction(A)
G = tools.compute_gram(A)
for float_type in float_types:
M_A = GSO.Mat(copy(A), float_type=float_type, gram=False)
M_G = GSO.Mat(copy(G), float_type=float_type, gram=True)
M_A.update_gso()
M_G.update_gso()
enum_obj_a = Enumeration(M_A, nr_solutions=min(m, 5))
shortest_vectors_a = enum_obj_a.enumerate(
0, M_A.d, M_A.get_r(0, 0), 0)
enum_obj_g = Enumeration(M_G, nr_solutions=min(m, 5))
shortest_vectors_g = enum_obj_g.enumerate(
0, M_G.d, M_G.get_r(0, 0), 0)
for i in range(len(shortest_vectors_a)):
assert shortest_vectors_a[i] == shortest_vectors_g[i]
def sample_r(d, lattice_type="qary", run_lll=False):
"""
Sample squared Gram-Schmidt norms of an LLL reduced lattice in dimension d.
:param d: lattice dimension
:param lattice_type: see module level documentation
:param run_lll: if ``True`` sample a matrix and run LLL
"""
if run_lll:
A = sample_matrix(d=d, lattice_type=lattice_type)
if d < 160:
M = GSO.Mat(A, float_type="d")
elif d < 320:
M = GSO.Mat(A, float_type="dd")
else:
M = GSO.Mat(A, float_type="qd")
M.update_gso()
return M.r()
else:
if lattice_type == "qary":
q = 2**30
elif lattice_type == "qary-lv":
q = 2**(10 * d)
else:
raise ValueError("Lattice type '%s' not supported." % lattice_type)
return [1.0219**(2 * (d - 2 * i - 1)) * q for i in range(d)]
def test_lll_gram_lll_coherence():
"""
Test if LLL is coherent if it is given a matrix A or its associated
Gram matrix A*A^T
We should have Gram(LLL_basis(A)) = LLL_Gram(Gram(A)).
"""
for m, n in dimensions:
for int_type in int_types:
A = make_integer_matrix(m, n)
G = tools.compute_gram(A)
for float_type in float_types:
M_A = GSO.Mat(A, float_type=float_type, gram=False)
lll_A = LLL.Reduction(M_A)
M_G = GSO.Mat(G, float_type=float_type, gram=True)
lll_G = LLL.Reduction(M_G)
# A modified in place
lll_A()
# G modified in place
lll_G()
G_updated = tools.compute_gram(A)
if (m, n) == (0, 0):
continue
for i in range(m):
for j in range(i + 1):
assert G_updated[i, j] == G[i, j]
def load_matrix_file(filepath,
randomize=False,
seed=None,
float_type="double"):
"""
Load matrix from file, LLL reduce (and randomize).
:param filepath: Load matrix from this file
:param randomize: Randomize the basis
:param seed: Seed for randomization
:returns: lattice basis and BKZ object
"""
A = IntegerMatrix.from_file(filepath)
A = LLL.reduction(A)
A = IntegerMatrix.from_matrix(A, int_type="long")
M = GSO.Mat(A, float_type=float_type)
bkz = BKZReduction(M)
if seed is not None:
FPLLL.set_random_seed(seed)
if randomize:
bkz.randomize_block(0, A.nrows, density=A.ncols // 4)
LLL.reduction(A)
M = GSO.Mat(A, float_type=float_type)
bkz = BKZReduction(M)
bkz.lll_obj() # to initialize bkz.M etc
return A, bkz
def main_pruning(filename, bs, cores):
try:
with open(filename, "rb") as f:
mat = pickle.load(f)
#print "len(mat)", len(mat)
#if (len(mat) > 1):
# mat = mat[0]
if isinstance(mat, IntegerMatrix):
Ainput = mat
else:
Ainput = IntegerMatrix.from_matrix(mat)
except:
Ainput = IntegerMatrix.from_file(filename)
Ainput_M = GSO.Mat(Ainput, float_type='double')
Ainput_M.update_gso()
r = [Ainput_M.get_r(i, i) for i in range(0, Ainput.nrows)]
L_Ainput_M = LLL.Reduction(Ainput_M)
L_Ainput_M()
#print r
A = IntegerMatrix.from_matrix(L_Ainput_M.M.B, int_type="long")
M = GSO.Mat(A, float_type="double")
bkzobj = BKZ2(M)
bkzobj.M.update_gso()
block_size = bs
r = [M.get_r(i, i) for i in range(0, block_size)]
radius = r[0] * 0.99
preproc_cost = 5000**(rank + 1)
pr0 = Pruning.run(radius,
NPS[block_size] * preproc_cost, [r],
0.1,
metric="probability",
float_type="double",
flags=Pruning.GRADIENT | Pruning.NELDER_MEAD)
print pr0.coefficients
"""
pruning = prune(radius, NPS[block_size] * preproc_cost, [r], 0.01,
metric="probability", float_type="double",
flags=Pruning.GRADIENT|Pruning.NELDER_MEAD)
cost = sum(pruning.detailed_cost) / NPS[block_size]
print "# [rank %d] cost %.1f, precost %.1f " % (rank, cost, preproc_cost)
"""
pr0_linear = pr0.LinearPruningParams(block_size, block_size - 2)
print pr0_linear.coefficients
return
def test_gso_init():
for m, n in dimensions:
A = make_integer_matrix(m, n)
for float_type in float_types:
M = GSO.Mat(copy(A), float_type=float_type)
del M
U = IntegerMatrix(m, m)
M = GSO.Mat(copy(A), U=U, float_type=float_type)
del M
UinvT = IntegerMatrix(m, m)
M = GSO.Mat(copy(A), U=U, UinvT=UinvT, float_type=float_type)
del M
def svp_time(seed, params, return_queue=None):
"""Run SVP reduction of AutoBKZ on ``A`` using ``params``.
:param A: a matrix
:param params: AutoBKZ parameters
:param queue: if not ``None``, the result is put on this queue.
"""
FPLLL.set_random_seed(seed)
A = IntegerMatrix.random(params.block_size, "qary", bits=30,
k=params.block_size//2, int_type="long")
M = GSO.Mat(A)
bkz = BKZ2(M)
tracer = BKZTreeTracer(bkz, start_clocks=True)
with tracer.context(("tour", 0)):
bkz.svp_reduction(0, params.block_size, params, tracer)
bkz.M.update_gso()
tracer.exit()
tracer.trace.data["|A_0|"] = A[0].norm()
if return_queue:
return_queue.put(tracer.trace)
else:
return tracer.trace
def test_gso_d():
for int_type in int_types:
for m, n in dimensions:
A = make_integer_matrix(m, n, int_type=int_type)
for float_type in float_types:
M = GSO.Mat(copy(A), float_type=float_type)
assert M.d == m
def svp_time(seed, params, return_queue=None):
"""Run SVP reduction of AutoBKZ on ``A`` using ``params``.
:param A: a matrix
:param params: AutoBKZ parameters
:param queue: if not ``None``, the result is put on this queue.
"""
FPLLL.set_random_seed(seed)
FPLLL.set_threads(params["threads"])
q = 33554393
k = params.block_size // 2
A = IntegerMatrix.random(params.block_size,
"qary",
q=q,
k=k,
int_type="long")
M = GSO.Mat(A)
bkz = BKZ2(M)
tracer = BKZTreeTracer(bkz, start_clocks=True)
with tracer.context(("tour", 0)):
bkz.svp_reduction(0, params.block_size, params, tracer)
bkz.M.update_gso()
tracer.exit()
log_delta = (log(A[0].norm()) - log(q) *
(k / float(params.block_size))) / float(params.block_size)
tracer.trace.data["delta"] = exp(log_delta)
if return_queue:
return_queue.put(tracer.trace)
else:
return tracer.trace
def test_lll_init():
for m, n in dimensions:
A = make_integer_matrix(m, n)
for float_type in float_types:
M = GSO.Mat(copy(A), float_type=float_type)
lll = LLL.Reduction(M)
del lll
def estimate(cls, M, squared_target_norm, max_loops=8):
"""
:param M:
:param squared_target_norm:
:param target_prob:
:returns: cost in CPU cycles
"""
try:
(_, d) = M
except TypeError:
try:
M.update_gso()
except AttributeError:
M = GSO.Mat(M)
M.update_gso()
d = M.d
_, block_size = USVPPredBKZEnum.estimate(M, squared_target_norm)
if block_size:
# TODO: this seems way too much
cost = max_loops * d * 2**float(
0.38191949470057696 * block_size -
32.71092701524247) * 3600 * 2 * 10**9
return cost, block_size
else:
return None, False
def osvp_time(seed, params, return_queue=None):
"""Run oSVP reduction on ``A`` using ``params``.
:param seed: random seed for matrix creation
:param params: BKZ parameters
:param return_queue: if not ``None``, the result is put on this queue.
"""
from cost import sample_matrix
A = sample_matrix(ceil(params.block_size * (1 + params["c"])), seed=seed)
M = GSO.Mat(A)
bkz = OBKZ(M, c=params["c"])
tracer = BKZTreeTracer(bkz, start_clocks=True)
with tracer.context(("tour", 0)):
bkz.svp_reduction(0, params.block_size, params, tracer)
bkz.M.update_gso()
tracer.exit()
tracer.trace.data["|A_0|"] = A[0].norm()
ppbs = params.strategies[params.block_size].preprocessing_block_sizes
tracer.trace.data["preprocessing_block_size"] = ppbs[0] if ppbs else 2
if return_queue:
return_queue.put(tracer.trace)
else:
return tracer.trace
def test_multisol():
A = make_integer_matrix()
m = GSO.Mat(A)
lll_obj = LLL.Reduction(m)
lll_obj()
solutions = []
solutions = Enumeration(m, nr_solutions=200).enumerate(0, 27, 48.5, 0)
assert len(solutions) == 126 / 2
for _, sol in solutions:
sol = IntegerMatrix.from_iterable(1, A.nrows,
map(lambda x: int(round(x)), sol))
sol = tuple((sol * A)[0])
dist = sum([x**2 for x in sol])
assert dist == 48
solutions = []
solutions = Enumeration(m, nr_solutions=126 / 2).enumerate(0, 27, 100., 0)
assert len(solutions) == 126 / 2
for _, sol in solutions:
sol = IntegerMatrix.from_iterable(1, A.nrows,
map(lambda x: int(round(x)), sol))
sol = tuple((sol * A)[0])
dist = sum([x**2 for x in sol])
assert dist == 48
def test_enum_init():
for int_type in int_types:
A = make_integer_matrix(20, 20, int_type=int_type)
for float_type in float_types:
M = GSO.Mat(copy(A), float_type=float_type)
enum_obj = Enumeration(M)
del enum_obj
def worker_process(seed, params, queue=None):
"""
This function is called to collect statistics.
:param A: basis
:param params: BKZ parameters
:param queue: queue used for communication
"""
FPLLL.set_random_seed(seed)
A = IntegerMatrix.random(params.block_size,
"qary",
bits=30,
k=params.block_size // 2,
int_type="long")
M = GSO.Mat(A)
bkz = CallbackBKZ(M) # suppresses initial LLL call
tracer = BKZTreeTracer(bkz, start_clocks=True)
with tracer.context(("tour", 0)):
bkz.svp_reduction(0, params.block_size, params, tracer)
M.update_gso()
tracer.exit()
try:
# close connection
params.strategies[params.block_size].connection.send(None)
except AttributeError:
pass
if queue:
queue.put(tracer.trace)
else:
return tracer.trace
def __init__(self, A):
"""Construct a new instance of the BKZ algorithm.
:param A: an integer matrix, a GSO object or an LLL object
"""
if isinstance(A, GSO.Mat):
L = None
M = A
A = M.B
elif isinstance(A, LLL.Reduction):
L = A
M = L.M
A = M.B
elif isinstance(A, IntegerMatrix):
L = None
M = None
A = A
else:
raise TypeError("Matrix must be IntegerMatrix but got type '%s'"%type(A))
if M is None and L is None:
# run LLL first, but only if a matrix was passed
wrapper = LLL.Wrapper(A)
wrapper()
self.A = A
if M is None:
self.M = GSO.Mat(A, flags=GSO.ROW_EXPO)
else:
self.M = M
if L is None:
self.lll_obj = LLL.Reduction(self.M, flags=LLL.DEFAULT)
else:
self.lll_obj = L
def test_callback_enum(d=40):
FPLLL.set_random_seed(0x1337)
A = LLL.reduction(IntegerMatrix.random(100, "qary", k=50, q=7681))
M = GSO.Mat(A)
M.update_gso()
# we are not imposing a constraint
enum_obj = Enumeration(M)
solutions = enum_obj.enumerate(0, d, 0.99*M.get_r(0, 0), 0)
max_dist, sol = solutions[0]
assert(A.multiply_left(sol)[0] != 2)
# now we do
def callback(new_sol_coord):
if A.multiply_left(new_sol_coord)[0] == 2:
return True
else:
return False
enum_obj = Enumeration(M, callbackf=callback)
solutions = enum_obj.enumerate(0, d, 0.99*M.get_r(0, 0), 0)
max_dist, sol = solutions[0]
assert(A.multiply_left(sol)[0] == 2)
def solve_hnp(samples):
d = len(samples)
q = order
B = IntegerMatrix(d + 2, d + 2)
for i in range(d):
t, u, v = samples[i]
scale = q / v
B[i, i] = q * scale
B[d, i] = t * scale
B[d + 1, i] = u * scale
B[d, d] = 1
B[d + 1, d + 1] = q
M = GSO.Mat(B)
L_red = LLL.Reduction(M)
bkzparam = BKZ.Param(block_size=20)
B_red = BKZ.Reduction(M, L_red, bkzparam)
B_red()
if B[1, d + 1] > 0:
x = -1 * B[1, d]
else:
x = B[1, d]
if x < 0:
x += q
private_value = 834818473318008049647448379209460658614088501345180055220225408308906924726
print x == private_value
priv = ec.derive_private_key(x, pub.curve, OSSL)
original = ec.derive_private_key(private_value, pub.curve, OSSL)
return priv, original
def babai_nearest_plane(A, w, **kwds):
"""Return lattice vector close to `v` using Babai's nearest plane algorithm.
:param A: **reduced** basis, an instance of `list` or `IntegerMatrix`
:param w: a tuple-like object
:param int_type: (default: 'mpz') an element of `fpylll.config.int_types`
:param float_type: (default: 'mpfr') an element of `fpylll.config.float_types`
:param int_gram: See docs of `GSO.MatGSO`
:param row_expo: See docs of `GSO.MatGSO`
"""
int_type = kwds.get('int_type', 'mpz')
if isinstance(A, list):
A = IntegerMatrix.from_matrix(A, int_type=int_type)
elif not isinstance(A, IntegerMatrix):
raise TypeError("Matrix `A` type '%s' unknown." % type(A))
float_type = kwds.get('float_type', 'mpfr')
flags = GSO.DEFAULT
if kwds.get('int_gram', False):
flags |= GSO.INT_GRAM
elif kwds.get('row_expo', False):
flags |= GSO.ROW_EXPO
M = GSO.Mat(A, flags=flags, float_type=float_type, update=True)
v = M.babai(w, gso=True)
return v
def __init__(self, A, tuners=None, recycle=True):
"""Construct a new instance of the BKZ algorithm.
:param A: an integer matrix, a GSO object or an LLL object
"""
self.recycle = recycle
if isinstance(A, LLL.Reduction):
L, M, B = A, A.M, A.M.B
elif isinstance(A, GSO.Mat):
L, M, B = None, A, A.B
elif isinstance(A, IntegerMatrix):
L, M, B = None, None, A
else:
raise TypeError(
"type of A must be in {IntegerMatrix, GSO.Mat, LLL.Reduction}, but got type '%s'"
% type(A))
if M is None and L is None:
wrapper = LLL.Wrapper(B)
wrapper()
if M is None:
M = GSO.Mat(B, flags=GSO.ROW_EXPO)
if L is None:
L = LLL.Reduction(M, flags=LLL.DEFAULT)
self.lll_obj, self.M, self.A = L, M, B
self.lll_obj()
if tuners is None:
self.tuners = [Tuner(b) for b in range(YOLO_MAX_BLOCK_SIZE)]
else:
self.tuners = tuners
self.tracer = BKZTreeTracer(self, verbosity=True)
def osvp_time(seed, params, return_queue=None):
"""Run oSVP reduction on ``A`` using ``params``.
:param seed: random seed for matrix creation
:param params: BKZ parameters
:param return_queue: if not ``None``, the result is put on this queue.
"""
from cost import sample_matrix
A = sample_matrix(ceil(params.block_size * (1 + params["c"])), seed=seed)
M = GSO.Mat(A)
bkz = ProcrastinatingBKZSimulation(M)
tracer = BKZSimulationTreeTracer(bkz)
with tracer.context(("tour", 0)):
bkz.svp_reduction(0, params.block_size, params, tracer)
tracer.exit()
r = tuple([2 ** (r_) for r_ in bkz.r])
tracer.trace.data["|A_0|"] = r[0]
ppbs = params.strategies[params.block_size].preprocessing_block_sizes
tracer.trace.data["preprocessing_block_size"] = ppbs[0] if ppbs else 2
if return_queue:
return_queue.put(tracer.trace)
else:
return tracer.trace
def __init__(self, A, preprocessing_levels=1, preprocessing_cutoff=45):
"""
Create a new BKZ Simulation object.
:param A: An integer matrix, a GSO object or a list of squared Gram-Schmidt norms.
:param preprocessing_levels: how many levels of preprocessing to simulate (slow!)
.. note :: Our internal representation is log2 norms of Gram-Schmidt vectors (not squared).
"""
if isinstance(A, GSO.Mat):
A.update_gso()
r = A.r()
self.r = [log(r_, 2) / 2.0 for r_ in r]
elif isinstance(A, LLL.Reduction):
A.M.update_gso()
r = A.M.r()
self.r = [log(r_, 2) / 2.0 for r_ in r]
elif isinstance(A, IntegerMatrix):
M = GSO.Mat(LLL.reduction(A))
M.update_gso()
r = M.r()
self.r = [log(r_, 2) / 2.0 for r_ in r]
else:
try:
self.r = [log(r_, 2) / 2.0 for r_ in A]
except TypeError:
raise TypeError("Unsupported type '%s'" % type(A))
self.preprocessing_levels = preprocessing_levels
self.preprocessing_cutoff = preprocessing_cutoff
def test_gso_coherence_gram_matrix():
"""
Test if the GSO is coherent if it is given a matrix A or its associated
Gram matrix A*A^T
"""
EPSILON = 0.0001
for m, n in dimensions:
for int_type in int_types:
# long is not tested for high dimensions because of integer overflow
if m > 20 and int_type == "long":
continue
A = make_integer_matrix(m, n, int_type=int_type).transpose()
G = tools.compute_gram(A)
for float_type in float_types:
M_A = GSO.Mat(copy(A),
float_type=float_type,
gram=False,
flags=GSO.INT_GRAM)
M_A.update_gso()
M_G = GSO.Mat(copy(G),
float_type=float_type,
gram=True,
flags=GSO.INT_GRAM)
M_G.update_gso()
# Check that the gram matrix coincide
for i in range(m):
for j in range(i):
assert M_A.get_int_gram(i, j) == G[i, j]
# Check if computations coincide
for i in range(m):
M_A.get_r(i, i) == pytest.approx(M_G.get_r(i, j),
rel=EPSILON)
for j in range(i):
assert (M_A.get_r(i,
j) == pytest.approx(M_G.get_r(i, j),
rel=EPSILON))
assert (M_A.get_mu(i, j) == pytest.approx(M_G.get_mu(
i, j),
rel=EPSILON))
def load_svp_challenge_r(d, seed=0):
"""
Load SVP Challenge in dimension `d` and ``seed``
:param d: dimension
:param seed: random seed
"""
A = load_svp_challenge(d, seed=seed)
if d < 160:
M = GSO.Mat(A, float_type="d")
elif d < 320:
M = GSO.Mat(A, float_type="dd")
else:
M = GSO.Mat(A, float_type="qd")
M.update_gso()
return M.r()
def insert_in_IntegerMatrix(self, A, v, kappa, block_size):
if (list(A[kappa]) == list(v)):
return
n = A.nrows
l = A.ncols
AA = IntegerMatrix(n + 1, l, int_type="long")
for i in xrange(kappa):
for j in xrange(l):
AA[i, j] = A[i, j]
for j in xrange(l):
AA[kappa, j] = v[j]
for i in xrange(kappa + 1, n + 1):
for j in xrange(l):
AA[i, j] = A[i - 1, j]
M = GSO.Mat(AA, float_type=TYPE)
M.update_gso()
bkz = BKZ2(M)
try:
bkz.lll_obj(kappa, kappa,
kappa + block_size + 1) # longer: 1 more row
except:
pass
index = 0
for i in range(kappa, kappa + block_size + 1):
if (AA[i].is_zero()):
index = i - kappa
break
for i in xrange(kappa + index):
for j in xrange(l):
A[i, j] = AA[i, j]
for i in xrange(kappa + index + 1, n + 1):
for j in xrange(l):
A[i - 1, j] = AA[i, j]
"""
for i in range(n):
bad = 0
for j in range(l):
if (A[i][j] == 0):
bad = bad + 1
if (bad == n):
print " inserting ", v
print " <<<<<<<<<<<<<<<<<<<<<< WRONG HERE at ", kappa, block_size, i
print A
print "old A is "
print AA_old
print "old A after lll is "
print AA
sys.exit(1)
"""
del bkz
del AA
del M
return
def main_cleanbkz_mpi_master(filename, bs, cores):
try:
with open(filename, "rb") as f:
mat = pickle.load(f)
#print "len(mat)", len(mat)
#if (len(mat) > 1):
# mat = mat[0]
if isinstance(mat, IntegerMatrix):
Ainput = mat
else:
Ainput = IntegerMatrix.from_matrix(mat)
except:
Ainput = IntegerMatrix.from_file(filename)
Ainput_M = GSO.Mat(Ainput, float_type='double')
Ainput_M.update_gso()
r = [Ainput_M.get_r(i, i) for i in range(0, Ainput.nrows)]
L_Ainput_M = LLL.Reduction(Ainput_M)
L_Ainput_M()
print r
A = IntegerMatrix.from_matrix(L_Ainput_M.M.B, int_type="long")
cleanbkz_mpi = CLEANBKZ_MPI(A, cores)
#cleanbkz_mpi = BKZ2(A)
cleanbkz_mpi.lll_obj()
cleanbkz_mpi.M.update_gso()
r = [
log(cleanbkz_mpi.M.get_r(i, i)) for i in range(0, cleanbkz_mpi.A.nrows)
]
print "# starting r "
print r
params = BKZ.Param(
block_size=bs,
max_loops=5000,
min_success_probability=.01,
flags=BKZ.BOUNDED_LLL, #|BKZ.DUMP_GSO,
dump_gso_filename="gso_output.file",
strategies="default.json")
cleanbkz_mpi(params=params, min_row=0)
#print "# done. found sv", cleanbkz_mpi.M.B[0]
# done send last end signal
for i in range(1, size):
comm.send(1, i, tag=999) # *** changed to send
cleanbkz_mpi.M.update_gso()
r2 = [
log(cleanbkz_mpi.M.get_r(i, i)) for i in range(0, cleanbkz_mpi.A.nrows)
]
print cleanbkz_mpi.A[0]
print "# ending r"
print r2
return
def test_bkz_init():
for m, n in dimensions:
A = make_integer_matrix(m, n)
for float_type in float_types:
M = GSO.Mat(copy(A), float_type=float_type)
lll_obj = LLL.Reduction(M)
param = BKZ.Param(block_size=3, strategies=BKZ.DEFAULT_STRATEGY)
bkz = BKZ.Reduction(M, lll_obj, param)
del bkz
