def setUp(self):
random.seed()
self.sample_size = 10
self.test_num = random.randrange(0, 2**6)
self.pool_dir = f'TEST_EXPERIMENT_{self.test_num:04X}'
self.n = 64
self.db = f'db_{self.test_num:04X}.db'
Formula.generate_formula_pool(self.pool_dir,
self.sample_size,
self.n,
4.2,
poolsize=3)
self.pool = list(
map(partial(os.path.join, self.pool_dir),
os.listdir(self.pool_dir)))
def setUp(self):
random.seed()
dirname = 'test_files'
num_vars = random.randrange(10,512)
samples = 5
Formula.generate_formula_pool(
dirname,
samples,
num_vars,
4.2,
poolsize=3,
)
self.formulae = [
Formula.generate_satisfiable_formula(num_vars, 4.2)
for _ in range(samples)
]
def setUp(self):
random.seed()
self.sample_size = 3
self.pool_dir = 'test_files'
number_formulae = 10
self.formulae = [
Formula.generate_satisfiable_formula(20, 4.2)
for _ in range(number_formulae)
]
def test_hardness(self):
n = 500
for i in range(0,self.cases):
f = Formula.generate_satisfiable_formula(n, 4.2)
atoms = 0
for var in range(1,n+1):
if len(f.get_occurrences(var)) > len(f.get_occurrences(-var)):
atoms += 1
atoms *= 2
a = Assignment(atoms, n)
self.assertFalse(f.is_satisfied_by(a))
def test_occurrences(self):
for i in range(0,self.cases):
f = Formula.generate_satisfiable_formula(500,4.2)
for i in range(1,501):
pos_occs = f.get_occurrences(i)
neg_occs = f.get_occurrences(-i)
# validate positive occurrences
for clause_idx in pos_occs:
self.assertTrue(i in f.clauses[clause_idx])
# validate negative occurrences
for clause_idx in neg_occs:
self.assertTrue(-i in f.clauses[clause_idx])
def test_occurrence_counting(self):
for i in range(0,self.cases):
f = Formula.generate_satisfiable_formula(500, 4.2)
occ_count = {}
for clause in f.clauses:
for lit in clause:
if lit in occ_count:
occ_count[lit] += 1
else:
occ_count[lit] = 1
for k,v in occ_count.items():
self.assertEqual(
len(f.get_occurrences(k)),
v
)
self.assertLessEqual(v, f.max_occs)
def setUp(self):
random.seed()
cases = 10
self.eps = 2**(-30)
self.n = 128
self.r = 4.2
self.significance_level = 0.01 if __debug__ else 0.05
self.sample_size = 1000
self.repeat = 100
self.max_failure = self.repeat * 0.2
self.jump_range = self.n // 10
self.formulae = [
Formula.generate_satisfiable_formula(self.n, self.r)
for _ in range(0, cases)
]
def setUp(self):
random.seed()
cases = 1 if __debug__ else 100
n = 64
r = 4.2
formulae = [
Formula.generate_satisfiable_formula(n, r)
for _ in range(0, cases)
]
self.solver_setup = dict(
max_flips=n * 5,
max_tries=100,
formulae=formulae,
cases=cases,
min_successes=cases // 100,
)
def test_random_creation_and_reading(self):
for i in range(0,self.cases):
f = Formula.generate_satisfiable_formula(500, 4.2)
self.assertEqual(f, Formula(dimacs = str(f)))
def test_satisfiable_assignment(self):
for i in range(0,self.cases):
n = random.randrange(10,1001)
r = random.randrange(20,42)/10
f = Formula.generate_satisfiable_formula(n,r)
self.assertTrue(f.is_satisfied_by(f.satisfying_assignment))
def test_random_creation(self):
for i in range(0,self.cases):
n = random.randrange(10,1001)
r = random.randrange(20,42)/10
f = Formula.generate_satisfiable_formula(n, r)
self.assertLess(f.num_clauses - n * r, 2)
def __init__(self,
input_files,
solver,
solver_params,
is_static,
repetition_of,
*init_database,
poolsize=1,
database='experiments.db'):
assert all([os.path.isfile(input_file) for input_file in input_files]),\
"input_files = {} is no List[str]".format(input_files)
assert isinstance(solver, str),\
"solver = {} :: {} is no str".format(solver, type(solver))
assert solver in SOLVERS,\
"solver = {} not in {}".format(solver, SOLVERS.keys())
assert isinstance(solver_params, dict),\
"solver_params = {} :: {} is no dict".format(solver_params, type(solver_params))
assert isinstance(poolsize, int),\
"poolsize = {} :: {} is no int".format(poolsize, type(poolsize))
assert poolsize > 0,\
"poolsize = {} <= 0".format(poolsize)
assert isinstance(database, str),\
"database = {} :: {} is no str"
assert all(isinstance(query, str) for query in init_database),\
"init_database = {} is not a list of str"
# get solver functions
self.solver = solver
self.solver_params = solver_params
self.repetition_of = repetition_of
# save poolsize
self.poolsize = poolsize
# save database file
self.database = database
# no results yet
self.results = None
with sqlite3.connect(self.database, timeout=60) as conn:
# init database, if not already done
c = conn.cursor()
c.execute(CREATE_EXPERIMENT)
c.execute(CREATE_FORMULA)
for statement in init_database:
c.execute(statement)
self.formulae = []
for file in input_files:
with open(file, 'r') as f:
formula = Formula(dimacs=f.read())
res = c.execute(
'SELECT formula_id FROM formula WHERE formula_file like ?',
(file, ))
res = list(res)
if not res:
c.execute(SAVE_FORMULA,
(file, formula.num_vars, formula.num_clauses,
str(formula.satisfying_assignment)))
formula_id = c.lastrowid
elif res:
formula_id, = res[0]
self.formulae.append((formula_id, formula))
c.execute(
SAVE_EXPERIMENT,
(self.repetition_of, solver, solver_params['noise_param'],
solver_params['max_tries'], solver_params['max_flips'],
len(input_files), is_static))
self.experiment_id = c.lastrowid
conn.commit()
die('SEED is not an integer')
elif flag == '--poolsize':
try:
poolsize = int(flags[flag_idx + 1])
flag_idx += 1
except ValueError:
die('POOLSIZE is not an integer')
if poolsize <= 0:
die('POOLSIZE must be greater than 0')
elif flag == '--verbose':
verbose = True
else:
die('What is this shit? {}'.format(flag))
flag_idx += 1
try:
Formula.generate_formula_pool(dir,
num,
num_vars,
ratio,
poolsize=poolsize,
verbose=verbose)
except Exception as e:
die('{}'.format(str(e)), system_error=True)
from src.solver.probsat import probsat_distribution
parser = argparse.ArgumentParser()
grp = parser.add_mutually_exclusive_group(required=True)
grp.add_argument('--gsat', action='store_true')
grp.add_argument('--walksat', action='store_true')
grp.add_argument('--probsat', action='store_true')
args = parser.parse_args()
PATH = [1,2,1,3,1,2,1,0]
FORMULA = Formula(
clauses=[[1, -2], [-1, 3], [2, 3], [1, 2]],
num_vars=3,
sat_assignment=Assignment(
atoms=[True, True, True],
num_vars=3,
),
)
ASSGNS = [0, 4, 6, 2, 3, 7, 5, 1]
def generate_probs(distribution, context):
assgn = Assignment([False, False, False], 3)
ctx = context(FORMULA, assgn)
probs = []
for i, a in zip(PATH, ASSGNS):
probs.append((a, distribution(ctx)))
if i > 0:
ctx.update(i)