def main():
n = sys.argv[1]
f = Model.parse_dimacs('data/%s.dimacs' % n)
# approx_solve(f)
# analyze_entanglement(f)
entaglement_solve(f)
def main():
n = sys.argv[1]
f = Model.parse_dimacs('data/%s.dimacs' % n)
f.unit_propagate()
# create_interactions_graph(f.clauses, abs)
# create_interactions_graph(f.clauses, lambda x: x)
# create_interactions_graph_gt(f.clauses, abs)
# create_interactions_graph_gt(f.clauses, lambda x: x)
create_conflicts_graph(f.clauses)
def main():
n = sys.argv[1]
# f = Model.parse_dimacs('data/%s.dimacs' % n)
# f = Model.parse_dimacs('data/5_4_2_1_0.300000.dimacs')
f = Model.parse_dimacs('data/random_240_1000_0.500000.dimacs')
total_conflicts_count = 0
f.unit_propagate()
if f.clauses == []:
print 'SAT'
sys.exit(0)
elif f.clauses == [[]]:
print 'UNSAT'
sys.exit(0)
print 'f.clauses:', f.clauses
forbidden = set()
for clause in f.clauses:
set_from_clause = set()
for lit in clause:
forbidden.add(frozenset([lit, -lit]))
set_from_clause.add(-lit)
forbidden.add(frozenset(set_from_clause))
print 'forbidden:', forbidden
formula_info = FormulaAnalyzer(f.clauses)
variables_count = formula_info.count_variables()
print 'Variables counts: %r' % variables_count
# Gathering info about conflicts
for clause in forbidden:
mult = 1
for lit in clause:
mult *= variables_count[lit]
mult /= fact(len(clause))
print clause, ':', mult
total_conflicts_count += mult
print 'total_conflicts_count:', total_conflicts_count
# sys.exit(0)
# greedy(f, forbidden)
sorted(f, forbidden)
def main():
global d, total_conflicts_count
n = sys.argv[1]
f = Model.parse_dimacs('data/%s.dimacs' % n)
f.unit_propagate()
if f.clauses == [[]]:
print 'UNSAT'
sys.exit(0)
shuffle(f)
print 'f:', f
count_literals_top_line(f)
print 'd:', d
calculate_conflicts_count(f)
print 'total_conflicts_count:', total_conflicts_count
while True:
ret_val = swap_first_to_decrease_conflicts_count(f)
if ret_val is None:
break
calculate_conflicts_count(f)
def main():
n = sys.argv[1]
f = Model.parse_dimacs('data/%s.dimacs' % n)
f.unit_propagate()
# print 'units:', f.all_units
# print 'clauses:', f.clauses
while True:
if f.clauses == []:
print 'SAT'
break
elif f.clauses == [[]]:
print 'UNSAT'
break
orig_units = f.all_units
all_diff_units_common = set()
for var in f.vars_set():
diff_units_list = []
for lit in [-var, var]:
fc = Model()
fc.clauses = f.clauses[:]
fc.all_units = f.all_units.copy()
fc.evaluation(lit)
fc.unit_propagate()
diff_units = fc.all_units - orig_units
# print 'units on %r = %r' % (lit, diff_units)
diff_units_list.append(diff_units)
diff_units_common = diff_units_list[0] & diff_units_list[1]
# print 'common units on %r = %r' % (var, diff_units_common)
all_diff_units_common |= diff_units_common
# print 'all_diff_units_common:', all_diff_units_common
for lit in all_diff_units_common:
f.evaluation(lit)
f.unit_propagate()
# print 'clauses after evaluating', lit, ':', f.clauses
# print 'clauses:', f.clauses
if len(all_diff_units_common) == 0:
print len(f.clauses)
forbidden = set()
for clause in f.clauses:
set_from_clause = set()
for lit in clause:
forbidden.add(frozenset([lit, -lit]))
set_from_clause.add(-lit)
forbidden.add(frozenset(set_from_clause))
print 'forbidden:', forbidden
s = set()
for lit in f.clauses[0]:
s.add(frozenset([lit]))
# print s
for i in xrange(1, len(f.clauses)):
print 'i:', i
clause = f.clauses[i]
new_s = set()
for lit in clause:
for seq in s:
new_seq = seq | frozenset([lit])
for forbid in forbidden:
if forbid <= new_seq:
# print 'Forbidden clause:', forbid, 'detected inside of:', new_seq
break
else:
for nseq in new_s:
if nseq <= new_seq:
break
else:
new_s.add(new_seq)
s = new_s
print 'len(s):', len(s)
# print 's:', s
print s
break
def main():
n = sys.argv[1]
f = Model.parse_dimacs('data/%s.dimacs' % n)
greedy_solve(f)
def main():
# f = Model.parse_dimacs('data/binowa1.dimacs')
# f = Model.parse_dimacs('data/5_4_2_1_0.300000.dimacs')
# f = Model.parse_dimacs('data/10_7_4_3_0.300000.dimacs')
# f = Model.parse_dimacs('data/20_12_6_4_0.300000.dimacs')
# f = Model.parse_dimacs('data/random_100_1000_0.500000.dimacs')
# f = Model.parse_dimacs('data/random_170_1000_0.500000.dimacs')
# f = Model.parse_dimacs('data/random_200_1000_0.500000.dimacs')
# f = Model.parse_dimacs('data/random_220_1000_0.500000.dimacs')
# f = Model.parse_dimacs('data/random_230_1000_0.500000.dimacs')
# f = Model.parse_dimacs('data/random_240_1000_0.000000.dimacs')
# f = Model.parse_dimacs('data/random_240_1000_0.200000.dimacs')
# f = Model.parse_dimacs('data/random_240_1000_0.500000.dimacs')
# f = Model.parse_dimacs('data/random_240_1000_0.800000.dimacs')
f = Model.parse_dimacs('data/random_240_1000_1.000000.dimacs')
# f = Model.parse_dimacs('data/random_250_1000_0.500000.dimacs')
# f = Model.parse_dimacs('data/random_500_1000_0.500000.dimacs')
d = defaultdict(int)
c = Counter()
positive_counter = Counter()
avg_positive_count = 0
positive_vec = []
occurences_counter = 0
formula_info = FormulaAnalyzer(f.clauses)
print 'literals_count:', formula_info.count_literals()
variables_count = formula_info.count_variables()
print 'Variables counts: %r' % variables_count
l = len(set([abs(x) for x in variables_count.keys()]))
for i in xrange(l):
positive_counter[i] = 0
fixed_set = set()
total_count = 0
# Number of auxiliary variables that are appearing set the same way (fixed) in all satisfying assignments
fixed_set_count = 0
# Propagating units and adding units as clauses
# f.unit_propagate()
# print 'After unit propagation:'
# print f.clauses
# for unit in f.all_units:
# f.clauses.append([unit])
# print 'number of propagated units: ', len(f.all_units)
for solution in f.itersolve():
sol_tpl = tuple(solution)
d[sol_tpl] += 1
positive_count = len([x for x in sol_tpl if x > 0])
positive_vec.append(positive_count)
avg_positive_count += positive_count
positive_counter[positive_count] += 1
for elem in sol_tpl:
c[elem] += 1
if -elem not in c:
c[-elem] = 0
total_count += 1
if total_count > LIMIT:
break
# print solution
if total_count == 0:
print 'UNSAT'
sys.exit(-1)
for k, v in d.iteritems():
# print k, ':', v
pass
print 'len(d):', len(d)
print 'total_count:', total_count
print 'most_common:'
for k, v in c.most_common():
# print k, ':', v
if v == total_count:
fixed_set.add(k)
fixed_set_count += 1
print 'fixed_set_count:', fixed_set_count
print 'all_literals_count:', (len(c.keys()) + fixed_set_count) / 2
fixed_set_positive_count = len([x for x in fixed_set if x > 0])
print 'fixed_set_positive_count:', fixed_set_positive_count
print 'Average number of positive literals in solution:', float(avg_positive_count) / total_count
print 'min:', np.min(positive_vec)
print 'median:', np.median(positive_vec)
positive_vec_mean = np.mean(positive_vec)
print 'avg:', positive_vec_mean
print 'max:', np.max(positive_vec)
print 'std:', np.std(positive_vec)
print 'positive vars expected percentage:', positive_vec_mean / float(l)
graph_distribution(positive_counter)
graph_distribution(c)
# fixed_set_minus_all_units = fixed_set - f.all_units
# print 'fixed_set - f.all_units:', fixed_set_minus_all_units
# for lit in fixed_set_minus_all_units:
# f.evaluation(lit)
# f.unit_propagate()
# print 'After unit propagation and taking advantage of fixed set:'
# print f.clauses
print 'positive_counter:', positive_counter
def main():
n = sys.argv[1]
f = Model.parse_dimacs("data/%s.dimacs" % n)
products = []
number_of_clauses = []
x_range = []
i = 0
l = len(bin(int(n))[2:])
# for i in xrange(1, 3*l+1):
# i += 1
# x_range.append(i)
# number_of_clauses.append(len(f.clauses))
# f.resolution(i)
# f.unit_propagate()
# f.superset_elimination()
# print 'len(f.clauses):', len(f.clauses)
# print 'f.clauses after resolving N, P, Q variables:', f.clauses
while True:
i += 1
f.unit_propagate()
f.superset_elimination()
x_range.append(i)
number_of_clauses.append(len(f.clauses))
print "len(f.clauses):", len(f.clauses)
# print 'f.clauses:', f.clauses
if f.clauses == []:
print "SAT"
break
elif f.clauses == [[]]:
print "UNSAT"
break
formula_info = FormulaAnalyzer(f.clauses)
variables_count = formula_info.count_variables()
minimal_product = float("inf")
# print 'variables_count:', variables_count
for k in variables_count.keys():
kp = abs(k)
km = -kp
try:
positive_k = variables_count[kp]
except:
positive_k = 0
try:
negative_k = variables_count[km]
except:
negative_k = 0
product_k = negative_k * positive_k
# print k, negative_k, positive_k, product_k
if product_k < minimal_product:
minimal_product = product_k
resolution_var = kp
products.append(minimal_product)
print "Applying resolution on %d with product %d" % (resolution_var, minimal_product)
f.resolution(resolution_var)
# print 'Variables counts: %r' % formula_info.count_variables()
# plt.scatter(x_range[:-1], products)
plt.scatter(x_range, number_of_clauses)
plt.show()
def main():
n = sys.argv[1]
f = Model.parse_dimacs('data/%s.dimacs' % n)
print 'vars_count: %d' % f.vars_count()
print 'clauses_count: %d' % f.clauses_count()
print 'clauses/vars ratio: %f' % f.clauses_to_vars_ratio()
sys.exit(0)
# Converting to SAT-3CNF
# print f
# print 'Before conversion to SAT-3CNF:', f.clauses
# f.to_3cnf()
# print 'After conversion to SAT-3CNF:', f.clauses
# sys.exit(0)
d = defaultdict(int)
c = Counter()
positive_counter = Counter()
avg_positive_count = 0
positive_vec = []
decimals = defaultdict(list)
odd_clauses_count = [0] * len(f.clauses)
even_clauses_count = [0] * len(f.clauses)
occurences_counter = 0
intn = int(n)
l = len(bin(intn)[2:])
for i in xrange(4*l*l+3*l-1):
positive_counter[i] = 0
specific_clauses = f.clauses[:l-1]
# f.clauses = f.clauses[l-1:]
fixed_set = set()
total_count = 0
# Number of auxiliary variables that are appearing set the same way (fixed) in all satisfying assignments
fixed_set_count = 0
# Propagating units and adding units as clauses
# f.unit_propagate()
# print 'After unit propagation:'
# print f.clauses
# for unit in f.all_units:
# if abs(unit) >= l:
# f.clauses.append([unit])
# print 'number of propagated units: ', len(f.all_units)
parity_to_assignment = defaultdict(list)
print 'specific_clauses: ', specific_clauses
for solution in f.itersolve():
decval_n = _get_decimal_value(solution[:l])
decval_p = _get_decimal_value(solution[l:2*l])
decval_q = _get_decimal_value(solution[2*l:3*l])
# print decval_n
# sol_tpl = tuple(solution[l:])
sol_tpl = tuple(solution)
sol_set = set(solution)
d[sol_tpl] += 1
positive_count = len([x for x in sol_tpl if x > 0])
positive_vec.append(positive_count)
decimals[positive_count].append((decval_n, decval_p, decval_q))
total_odd = 0
total_even = 0
parity_str = ""
for i, clause in enumerate(f.clauses):
number_of_lits_in_sol = 0
for lit in clause:
if lit in sol_set:
number_of_lits_in_sol += 1
if number_of_lits_in_sol % 2 == 0:
parity_str += '0'
total_even += 1
even_clauses_count[i] += 1
else:
parity_str += '1'
total_odd += 1
odd_clauses_count[i] += 1
parity_to_assignment[parity_str].append(sol_tpl)
# print 'odd: %d, even: %d' % (total_odd, total_even)
avg_positive_count += positive_count
positive_counter[positive_count] += 1
for elem in sol_tpl:
c[elem] += 1
if -elem not in c:
c[-elem] = 0
total_count += 1
# print solution
print 'Parity to assignment::'
for k, v in parity_to_assignment.iteritems():
print k, '-->', v
print '# of distinct xorified formulas covering solution space: %d' % len(parity_to_assignment.keys())
sys.exit(0)
xor_clauses_file = open('xor_clauses_%d.cnf' % intn, 'w')
always_odd_or_even_count = 0
unit_clauses_count = 0
for i, clause in enumerate(f.clauses):
if len(clause) == 1:
unit_clauses_count += 1
if odd_clauses_count[i] == 0:
always_odd_or_even_count += 1
xor_clauses_file.write('x')
xor_clauses_file.write(str(-clause[0]) + ' ')
for j in xrange(1, len(clause)):
xor_clauses_file.write(str(clause[j]) + ' ')
xor_clauses_file.write('0\n')
elif even_clauses_count[i] == 0:
xor_clauses_file.write('x')
for j in xrange(len(clause)):
xor_clauses_file.write(str(clause[j]) + ' ')
xor_clauses_file.write('0\n')
always_odd_or_even_count += 1
else:
for j in xrange(len(clause)):
xor_clauses_file.write(str(clause[j]) + ' ')
xor_clauses_file.write('0\n')
print '%d, odd: %d, even: %d' % (i, odd_clauses_count[i], even_clauses_count[i])
print 'Percentage of always odd or even (crypto clauses): %f ' % (100 * float(always_odd_or_even_count) / len(f.clauses),)
print 'Percentage of unit clauses (with one literal only): %f ' % (100 * float(unit_clauses_count) / len(f.clauses),)
xor_clauses_file.close()
sys.exit(0)
for k, v in d.iteritems():
# print k, ':', v
pass
for k in sorted(decimals):
print k, ':', ['%d=%d*%d' % (x[0], x[1], x[2]) for x in decimals[k]] # [bin(x)[2:] for x in reversed(sorted(decimals[k]))]
print 'len(d):', len(d)
print 'total_count:', total_count
print 'most_common:'
for k, v in c.most_common():
# print k, ':', v
if v == total_count:
fixed_set.add(k)
fixed_set_count += 1
print 'fixed_set_count:', fixed_set_count
print 'all_literals_count:', (len(c.keys()) + fixed_set_count) / 2
fixed_set_positive_count = len([x for x in fixed_set if x > 0])
print 'fixed_set_positive_count:', fixed_set_positive_count
print 'Average number of positive literals in solution:', float(avg_positive_count) / total_count
print 'min:', np.min(positive_vec)
print 'median:', np.median(positive_vec)
positive_vec_mean = np.mean(positive_vec)
print 'avg:', positive_vec_mean
print 'max:', np.max(positive_vec)
print 'std:', np.std(positive_vec)
print 'positive vars expected percentage:', positive_vec_mean / _number_of_vars(l)
# sys.exit(0)
graph_distribution(positive_counter)
types_of_variables(l)
graph_distribution(c)
# fixed_set_minus_all_units = fixed_set - f.all_units
# print 'fixed_set - f.all_units:', fixed_set_minus_all_units
# for lit in fixed_set_minus_all_units:
# f.evaluation(lit)
# f.unit_propagate()
# print 'After unit propagation and taking advantage of fixed set:'
# print f.clauses
formula_info = FormulaAnalyzer(f.clauses)
print 'literals_count:', formula_info.count_literals()
print 'Variables counts: %r' % formula_info.count_variables()
print 'positive_counter:', positive_counter
def destroy(self, widget, data=None):
gtk.main_quit()
def delete_event(self, widget, event, data=None):
return False
def play(self):
gtk.main()
if __name__ == "__main__":
c0 = [[1, 2], [-1, 2], [3, -4]]
c1 = [[1, 2, 3], [1, 2, -3], [1, -2, 3], [1, -2, -3], [-1, 2, 3], [-1, 2, -3], [-1, -2, 3], [-1, -2, -3]]
c2 = [[1, 2, 3], [1, 2, -3], [1, -2, 3], [-1, 2, 3], [-1, 2, -3], [-1, -2, 3], [-1, -2, -3]]
n = sys.argv[1]
f = Model.parse_dimacs("data/%s.dimacs" % n)
f.unit_propagate()
# from gi.repository import Gdk as gdk
# screen = gdk.Screen.get_default()
# css_provider = gtk.CssProvider()
# css_provider.load_from_path('style.css')
# context = gtk.StyleContext()
# context.add_provider_for_screen(
# screen,
# css_provider,
# gtk.STYLE_PROVIDER_PRIORITY_USER
# )