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(): start = int(sys.argv[1]) try: end = int(sys.argv[2]) except: end = start x_range = range(start, end+1) y_range = [] p_range = [] #count_0s_range = [] i = start while i <= end: build_model_start = time() sat = FactorizationModel() number = i bin_number = bin(number)[2:] len_bin_number = len(bin_number) N = sat.add_integer('N', number, length=len_bin_number) l = len(N) P = sat.add_seq('P', l) Q = sat.add_seq('Q', l) sat.add_multiplication_without_trivial_factors(P, Q, N) build_model_duration = time() - build_model_start # sat.unit_propagate() # for j in [1]: # sat.resolution(j) # print 'resolution: %d' % j # print sat.clauses # sat.resolution(1) # sat.save_dimacs('data/%d.resolution_1.dimacs' % i) # sat.evaluation(1) # sat.save_dimacs('data/%d.evaluation_1.dimacs' % i) # sat.evaluation(-1) # sat.save_dimacs('data/%d.evaluation_-1.dimacs' % i) print 'Expected number of satisfied clauses:', sat.sat_expectation() solve_model_start = time() solution = sat.solve() solve_model_duration = time() - solve_model_start sat.save_dimacs('data/%d.dimacs' % i) formula_info = FormulaAnalyzer(sat.clauses) #print sat.clauses print 'Time for building: %f, Time for solving: %f, # of factors: %d, # of vars: %d, # of clauses: %d' % ( build_model_duration, solve_model_duration, factors_count(number), sat.vars_count(), sat.clauses_count() ) print 'Variables counts: %r' % formula_info.count_variables() literals_count = formula_info.count_literals() print 'Literal counts: %r' % literals_count try: print 'Positive/negative ratio: %f' % (literals_count['positive'] / float(literals_count['negative'])) except ZeroDivisionError: print 'Number of negative literals is 0' collisions_count = formula_info.count_collisions() y_range.append(collisions_count) print 'Collision count: %d' % collisions_count #count_0s_range.append(count_0s(i) + y_range[0] - count_0s(start)) sat_xor, solution_xor = solve_xor(sat) # sat_or, solution_or = solve_or(sat) print 'XOR SAT: %r' % sat_xor # print 'OR SAT: %r' % sat_or if sat_xor: print "Amazing ! - we've got a satisfiable XOR extension" if solution != 'UNSAT': p_range.append(0) factor1 = sat.get_decimal_value(P, solution) factor2 = sat.get_decimal_value(Q, solution) print '%d = %d * %d' % (number, factor1, factor2) if factor1 * factor2 != number: raise Exception("Bad factorization!") if factor1 == 1 or factor2 == 1: raise Exception("1 should not appear in prime factorization!") else: p_range.append(1) if factors_count(number) > 1: raise Exception("Number should not be treated as prime!") print '%d is prime' % number print '---------------------------------' i += 1 plt.title('Collisions count') plt.xlabel('N') plt.ylabel('Collisions') plt.scatter(x_range, y_range, c=p_range, cmap='gray') #plt.scatter(x_range, count_0s_range, c='red') plt.show()
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