-
Notifications
You must be signed in to change notification settings - Fork 0
/
svp_challenge.py
executable file
·114 lines (88 loc) · 3.73 KB
/
svp_challenge.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
SVP Challenge Solver Command Line Client
"""
from __future__ import absolute_import
from __future__ import print_function
import copy
import logging
import pickle as pickler
from collections import OrderedDict
from fpylll.util import gaussian_heuristic
from g6k.algorithms.workout import workout
from g6k.siever import Siever
from g6k.utils.cli import parse_args, run_all, pop_prefixed_params
from g6k.utils.stats import SieveTreeTracer
from g6k.utils.util import load_svpchallenge_and_randomize, load_matrix_file, db_stats
from g6k.utils.util import sanitize_params_names, print_stats, output_profiles
import six
from six.moves import range
def asvp_kernel(arg0, params=None, seed=None):
logger = logging.getLogger('asvp')
# Pool.map only supports a single parameter
if params is None and seed is None:
n, params, seed = arg0
else:
n = arg0
params = copy.copy(params)
load_matrix = params.pop("load_matrix")
pump_params = pop_prefixed_params("pump", params)
workout_params = pop_prefixed_params("workout", params)
verbose = params.pop("verbose")
if verbose:
workout_params["verbose"] = True
challenge_seed = params.pop("challenge_seed")
if load_matrix is None:
A, _ = load_svpchallenge_and_randomize(n, s=challenge_seed, seed=seed)
if verbose:
print(("Loaded challenge dim %d" % n))
else:
A, _ = load_matrix_file(load_matrix)
if verbose:
print(("Loaded file '%s'" % load_matrix))
g6k = Siever(A, params, seed=seed)
tracer = SieveTreeTracer(g6k, root_label=("svp-challenge", n), start_clocks=True)
gh = gaussian_heuristic([g6k.M.get_r(i, i) for i in range(n)])
goal_r0 = (1.05**2) * gh
if verbose:
print(("gh = %f, goal_r0/gh = %f, r0/gh = %f" % (gh, goal_r0/gh, sum([x*x for x in A[0]])/gh)))
flast = workout(g6k, tracer, 0, n, goal_r0=goal_r0,
pump_params=pump_params, **workout_params)
tracer.exit()
stat = tracer.trace
stat.data["flast"] = flast
if verbose:
logger.info("sol %d, %s" % (n, A[0]))
norm = sum([x*x for x in A[0]])
if verbose:
logger.info("norm %.1f ,hf %.5f" % (norm**.5, (norm/gh)**.5))
return tracer.trace
def asvp():
"""
Run a Workout until 1.05-approx-SVP on matrices with dimensions in ``range(lower_bound, upper_bound, step_size)``.
"""
description = asvp.__doc__
args, all_params = parse_args(description,
load_matrix=None,
verbose=True,
challenge_seed=0,
workout__dim4free_dec=3)
stats = run_all(asvp_kernel, list(all_params.values()),
lower_bound=args.lower_bound,
upper_bound=args.upper_bound,
step_size=args.step_size,
trials=args.trials,
workers=args.workers,
seed=args.seed)
inverse_all_params = OrderedDict([(v, k) for (k, v) in six.iteritems(all_params)])
stats = sanitize_params_names(stats, inverse_all_params)
fmt = "{name:50s} :: n: {n:2d}, cputime {cputime:7.4f}s, walltime: {walltime:7.4f}s, flast: {flast:3.2f}, |db|: 2^{avg_max:.2f}"
profiles = print_stats(fmt, stats, ("cputime", "walltime", "flast", "avg_max"),
extractf={"avg_max": lambda n, params, stat: db_stats(stat)[0]})
output_profiles(args.profile, profiles)
if args.pickle:
pickler.dump(stats, open("svp-challenge-%d-%d-%d-%d.sobj" %
(args.lower_bound, args.upper_bound, args.step_size, args.trials), "wb"))
if __name__ == '__main__':
asvp()