本文整理汇总了Python中pycosat.solve函数的典型用法代码示例。如果您正苦于以下问题:Python solve函数的具体用法?Python solve怎么用?Python solve使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了solve函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: sat
def sat(self, additional=None, includeIf=False, names=False, limit=0):
"""
Calculate a SAT solution for the current clause set.
Returned is the list of those solutions. When the clauses are
unsatisfiable, an empty list is returned.
"""
if self.unsat:
return None
if not self.m:
return set() if names else []
if additional:
additional = list(map(lambda x: tuple(map(self.varnum, x)), additional))
clauses = chain(self.clauses, additional)
else:
clauses = self.clauses
try:
solution = pycosat.solve(clauses, vars=self.m, prop_limit=limit)
except TypeError:
# pycosat 0.6.1 should not require this; pycosat 0.6.0 did, but we
# have made conda dependent on pycosat 0.6.1. However, issue #2276
# suggests that some people are still seeing this behavior even when
# pycosat 0.6.1 is installed. Until we can understand why, this
# needs to stay. I still don't want to invoke it unnecessarily,
# because for large clauses lists it is slow.
clauses = list(map(list, clauses))
solution = pycosat.solve(clauses, vars=self.m, prop_limit=limit)
if solution in ("UNSAT", "UNKNOWN"):
return None
if additional and includeIf:
self.clauses.extend(additional)
if names:
return set(nm for nm in (self.indices.get(s) for s in solution) if nm and nm[0] != '!')
return solution
示例2: sat
def sat(self, additional=None, includeIf=False, names=False, limit=0):
"""
Calculate a SAT solution for the current clause set.
Returned is the list of those solutions. When the clauses are
unsatisfiable, an empty list is returned.
"""
if self.unsat:
return None
if not self.m:
return set() if names else []
clauses = self.clauses
if additional:
def preproc(eqs):
def preproc_(cc):
for c in cc:
c = self.names.get(c, c)
if c is False:
continue
yield c
if c is True:
break
for cc in eqs:
cc = tuple(preproc_(cc))
if not cc:
yield cc
break
if cc[-1] is not True:
yield cc
additional = list(preproc(additional))
if additional:
if not additional[-1]:
return None
clauses = chain(clauses, additional)
try:
solution = pycosat.solve(clauses, vars=self.m, prop_limit=limit)
except TypeError:
# pycosat 0.6.1 should not require this; pycosat 0.6.0 did, but we
# have made conda dependent on pycosat 0.6.1. However, issue #2276
# suggests that some people are still seeing this behavior even when
# pycosat 0.6.1 is installed. Until we can understand why, this
# needs to stay. I still don't want to invoke it unnecessarily,
# because for large clauses lists it is slow.
clauses = list(map(list, clauses))
solution = pycosat.solve(clauses, vars=self.m, prop_limit=limit)
if solution in ("UNSAT", "UNKNOWN"):
return None
if additional and includeIf:
self.clauses.extend(additional)
if names:
return set(nm for nm in (self.indices.get(s) for s in solution) if nm and nm[0] != "!")
return solution
示例3: pycoSAT
def pycoSAT(expr):
"""Check satisfiability of an expression.
Given a CNF expression, returns a model that causes the input expression
to be true. Returns false if it cannot find a satisfible model.
A model is simply a dictionary with Expr symbols as keys with corresponding values
that are booleans: True if that symbol is true in the model and False if it is
false in the model.
Calls the pycosat solver: https://pypi.python.org/pypi/pycosat
>>> ppsubst(pycoSAT(A&~B))
{A: True, B: False}
>>> pycoSAT(P&~P)
False
"""
assert is_valid_cnf(expr), "{} is not in CNF.".format(expr)
clauses = conjuncts(expr)
# Load symbol dictionary
symbol_dict = mapSymbolAndIndices(clauses)
# Convert Expr to integers
clauses_int = exprClausesToIndexClauses(clauses, symbol_dict)
model_int = pycosat.solve(clauses_int)
if model_int == 'UNSAT' or model_int == 'UNKNOWN':
return False
model = indexModelToExprModel(model_int, symbol_dict)
return model
示例4: solve
def solve(grid):
#solve a Sudoku problem
clauses = sudoku_clauses()
for i in range(1, 10):
for j in range(1, 10):
d = grid[i - 1][j - 1]
# For each digit already known, a clause (with one literal).
if d:
clauses.append([v(i, j, d)])
# Print number SAT clause
numclause = len(clauses)
print "P CNF " + str(numclause) +"(number of clauses)"
# solve the SAT problem
start = time.time()
sol = set(pycosat.solve(clauses))
end = time.time()
print("Time: "+str(end - start))
def read_cell(i, j):
# return the digit of cell i, j according to the solution
for d in range(1, 10):
if v(i, j, d) in sol:
return d
for i in range(1, 10):
for j in range(1, 10):
grid[i - 1][j - 1] = read_cell(i, j)
示例5: solve
def solve(sudoku_mat, sudoku_sz):
# Setting params (size, size-square, root-size)
set_params(sudoku_sz)
# Adding all clauses to the list clause_set
clause_set = sudoku_vals(sudoku_mat);
for i in range(sudo_size):
row_clause(i, clause_set)
col_clause(i, clause_set)
element_clause(clause_set)
for i in range(sudo_size_sqrt):
for j in range(sudo_size_sqrt):
block_clause(i*sudo_size_sqrt,j*sudo_size_sqrt,clause_set)
print len(clause_set)
# We would also like to print a cnf file 'sudoku.cnf' of the clauses so we canconveniently use it with other SAT solvers
outfile = file('sudoku.cnf','w')
outfile.write('p cnf '+str(sudo_size**3)+' '+str(len(clause_set)))
for clause in clause_set:
string = ''
for var in clause:
string = string + str(var) + ' '
string = string[:-1]
outfile.write('\n'+string+' 0')
# Solving the sudoku using pycosat SAT solver for python, which is based on PicoSAT
sol = set(pycosat.solve(clause_set))
# Editing the original matrix to reflect the solved sudoku
def read_cell(i,j):
for d in range(1,sudo_size+1):
if v(i,j,d) in sol:
return d
for i in range(sudo_size):
for j in range(sudo_size):
sudoku_mat[i][j] = read_cell(i,j)
示例6: sat
def sat(clauses):
"""
Calculate a SAT solution for `clauses`.
Returned is the list of those solutions. When the clauses are
unsatisfiable, an empty list is returned.
"""
try:
import pycosat
except ImportError:
sys.exit('Error: could not import pycosat (required for dependency '
'resolving)')
try:
pycosat.itersolve({(1,)})
except TypeError:
# Old versions of pycosat require lists. This conversion can be very
# slow, though, so only do it if we need to.
clauses = list(map(list, clauses))
solution = pycosat.solve(clauses)
if solution == "UNSAT" or solution == "UNKNOWN": # wtf https://github.com/ContinuumIO/pycosat/issues/14
return []
# XXX: If solution == [] (i.e., clauses == []), the result will have
# boolean value of False even though the clauses are not unsatisfiable)
return solution
示例7: sat
def sat(self, additional=None, includeIf=False, names=False, limit=0):
"""
Calculate a SAT solution for the current clause set.
Returned is the list of those solutions. When the clauses are
unsatisfiable, an empty list is returned.
"""
if self.unsat:
return None
if not self.m:
return set() if names else []
if additional:
additional = list(map(lambda x: tuple(map(self.varnum, x)), additional))
clauses = chain(self.clauses, additional)
else:
clauses = self.clauses
clauses = list(clauses)
solution = pycosat.solve(clauses, vars=self.m, prop_limit=limit)
if solution in ("UNSAT", "UNKNOWN"):
return None
if additional and includeIf:
self.clauses.extend(additional)
if names:
return set(nm for nm in (self.indices.get(s) for s in solution) if nm and nm[0] != '!')
return solution
示例8: pycoSAT
def pycoSAT(expr_list):
"""Check satisfiability of an expression list.
Given a list of CNF expressions, returns a model that causes all input expressions
to be true. Returns false if it cannot find a satisfible model.
A model is simply a dictionary with Expr symbols as keys with corresponding values
that are booleans: True if that symbol is true in the model and False if it is
false in the model.
Each CNF expression in the input list should be relatively short. Long expression
will cause this method to become incredibly slow.
Calls the pycosat solver: https://pypi.python.org/pypi/pycosat
>>> ppsubst(pycoSAT([A&~B]))
{A: True, B: False}
>>> pycoSAT([P&~P])
False
"""
clauses = []
for expr in expr_list:
clauses += conjuncts(expr)
# Load symbol dictionary
symbol_dict = mapSymbolAndIndices(clauses)
# Convert Expr to integers
clauses_int = exprClausesToIndexClauses(clauses, symbol_dict)
model_int = pycosat.solve(clauses_int)
if model_int == 'UNSAT' or model_int == 'UNKNOWN':
return False
model = indexModelToExprModel(model_int, symbol_dict)
return model
示例9: solve
def solve(grid):
"""
solve a Sudoku grid inplace
"""
clauses = sudoku_clauses()
for i in range(1, 10):
for j in range(1, 10):
d = grid[i - 1][j - 1]
# For each digit already known, a clause (with one literal).
# Note:
# We could also remove all variables for the known cells
# altogether (which would be more efficient). However, for
# the sake of simplicity, we decided not to do that.
if d:
clauses.append([v(i, j, d)])
# solve the SAT problem
start = time.clock()
sol = set(pycosat.solve(clauses))
t = time.clock() - start
print 'pycosat clauses:', len(clauses), ' solution time:', t
def read_cell(i, j):
# return the digit of cell i, j according to the solution
for d in range(1, 10):
if v(i, j, d) in sol:
return d
for i in range(1, 10):
for j in range(1, 10):
grid[i - 1][j - 1] = read_cell(i, j)
示例10: sat
def sat(self, formula=None):
if formula:
added_clause, new_atoms = self._add(formula)
ret = pycosat.solve(self.cnfs)
if formula:
self._roll_back(added_clause, new_atoms)
# FIXME
return ret not in ('UNSAT', 'UNKNOWN')
示例11: solve_nqueen
def solve_nqueen(board, NUM_ROWS, NUM_COLUMNS):
nqueen_clauses = get_nqueen_clauses(NUM_ROWS, NUM_COLUMNS)
solution = set(pycosat.solve(nqueen_clauses))
for row in range(1,NUM_ROWS+1):
for column in range(1,NUM_COLUMNS+1):
board[row-1][column-1] = get_cell_solution(solution,row, column)
示例12: py_itersolve
def py_itersolve(clauses):
while True:
sol = pycosat.solve(clauses)
if isinstance(sol, list):
yield sol
clauses.append([-x for x in sol])
else: # no more solutions -- stop iteration
return
示例13: solve
def solve(self):
solution = pycosat.solve(self.clauses)
if solution == 'UNSAT':
return 'UNSAT'
else:
#print solution
solution = [x for x in solution if -x not in self.all_units]
solution.extend(list(self.all_units))
return sorted(list(set(solution)), key=abs)
示例14: _solve_sat
def _solve_sat(self,cnf):
"""
Calls the SAT solver.
"""
start = time.time()
sol = pycosat.solve(cnf)
elapsed = time.time()-start
if self.verbose:
print('\t- Took %.3f ms to solve SAT problem.'%(1000.0*elapsed))
return sol
示例15: solve
def solve(n):
global N
N = n
clauses = queens_clauses()
# solve the SAT problem
sol = set(pycosat.solve(clauses))
for i in range(N):
print ''.join('Q' if v(i, j) in sol else '.' for j in range(N))
print n, len(clauses)