def solveToken(eq):
eq = eq.strip()
# Request for a new token.
token, eq = getToken(eq)
if token is None: return None, eq
# If the variable is a negation, Create a negated
# variable. Return the relevant variable obj and the
# remaining string
if token[0] == '!':
return (-Variable(token[1:].strip()), eq)
# If no negation is present, return just the variable
if re.match(r'^[\w]', token):
return (Variable(token.strip()), eq)
# If the token is a bracketed group, recursively
# solve it
if token[0] == '(':
return (solve(token[1:-1]), eq)
# This should ideally never be encountered
print("I failed: ", token, eq)
exit(0)
def fromstring(self, s):
self.varname_dict = {}
self.varobj_dict = {}
lines = s.split("\n")
# Throw away comments and empty lines
new_lines = []
for l in lines:
l = l.strip()
if l[0] != 'c' and l != "":
new_lines.append(l)
_, _, varz, clauses = new_lines[0].split(" ")
varz, clauses = int(varz), int(clauses)
c = Cnf()
lines = new_lines[1:]
c.dis = frozenset(
frozenset(
map(
lambda vn: Variable("v" + vn.strip(" \t\r\n-"), vn[0] ==
'-'),
line.split(" ")[:-1])) for line in lines)
for i in xrange(1, varz + 1):
stri = str(i)
vo = Variable('v' + stri)
self.varname_dict[vo] = stri
self.varobj_dict[stri] = vo
return c
def solve(eq):
solution = Minisat().solve(eq)
assert solution.success and not solution.error, 'ERR: Failed to solve'
result = 1 << N - 1 if solution[Variable('0')] else 0
for i in range(1, N):
result |= 1 << i - 1 if (solution[Variable(str(i))]) else 0
return result
def reduce_AMO_sequential(items, _assign_id=[0]):
""" At most one 'sequential' encoding (Sinz)
Based on count-and-compare hardware.
Example (where a-d are items; X1-X2 are extra variables):
~a | X1
~b | X2 & ~X1 | X2 & ~b | ~X1 (repeat)
~c | ~X2
Setting a to True, forces X1 to be True. X1 as True X2 to true and b
to false. Thus propagating as X2 to True forces c to False.
items: A list of variables, or cnfs (must have two or more items)
_assign_id: Internal counter, don't replace
"""
nitems = [-i for i in items]
extra_vars = []
nextra_vars = []
for _ in range(len(items)-1):
v = Variable("SEQ" + str(_assign_id[0]))
extra_vars.append(v)
nextra_vars.append(-v)
_assign_id[0] += 1
cnf = (nitems[0] | extra_vars[0]) & (nitems[-1] | nextra_vars[-1])
for i in range(1, len(items)-1):
cnf &= ((nitems[i] | extra_vars[i]) &
(nextra_vars[i-1] | extra_vars[i]) &
(nitems[i] | nextra_vars[i-1]))
return cnf
def get_variable(name):
if name in variables:
var = variables[name]
else:
var = Variable(name)
variables[name] = var
return var
def genKey():
# return random.getrandbits(k)
# return 2**256-1 #since we want all 1s
variables = [Variable(str(i)) for i in xrange(k)] #all the 3sat variables
return "1" * k, variables
def reversedStep(x):
variables = []
for i in range(N):
variables.append(Variable(str(i)))
exp = Variable('None')
for i in range(N):
if (x >> i) & 1:
exp &= (variables[i] & -variables[(i + 1) % N] & -variables[(i + 2) % N]) | (-variables[i] & variables[(i + 1) % N]) | (-variables[i] & variables[(i + 2) % N])
else:
exp &= (-variables[i] & -variables[(i + 1) % N] & -variables[(i + 2) % N]) | (variables[i] & variables[(i + 1) % N]) | (variables[i] & variables[(i + 2) % N])
solver = Minisat()
solution = solver.solve(exp)
if solution.success:
return arrayToInt(solution, variables)
def encode(Sp, Sm, k):
"""Write NFA induction as SAT
Input: examples, counter-examples, and an integer
Output: boolean formula (Cnf), variables y and z"""
idx = Idx(0)
Sigma = alphabet(Sp | Sm)
Q = range(k)
P = prefixes(Sp | Sm)
P.remove("")
x = dict(((w, q), Variable(idx + 1)) for w in P for q in Q)
y = dict(((a, p, q), Variable(idx + 1)) for a in Sigma for p in Q
for q in Q)
z = dict((q, Variable(idx + 1)) for q in Q)
st = [] # subject to (i.e. constraints)
# The empty word inclusion
if "" in Sp: st.append(z[0])
if "" in Sm: st.append(-z[0])
# Acceptance of examples
for w in Sp - {""}:
st.append(reduce(or_, (x[w, q] & z[q] for q in Q)))
# Rejection of counter-examples
for w in Sm - {""}:
for q in Q:
st.append(-x[w, q] | -z[q])
# Single-symbol prefixes inclusion
for a in P & Sigma:
for q in Q:
st.append(-(x[a, q] ^ y[a, 0, q]))
# Multi-symbol prefixes inclusion
for w in P:
if len(w) >= 2:
v, a = w[:-1], w[-1]
for q in Q:
st.append(x[w, q] >> reduce(or_, (x[v, r] & y[a, r, q]
for r in Q)))
for r in Q:
st.append((x[v, r] & y[a, r, q]) >> x[w, q])
return (reduce(and_, st), y, z)
def build_model(self):
nproc = self._instance.nproc
nmach = self._instance.nmach
nserv = self._instance.nserv
nneigh = len(self._instance.N)
nloc = len(self._instance.L)
P = self._instance.P
M = self._instance.M
S = self._instance.S
N = self._instance.N
L = self._instance.L
io = DimacsCnf()
self.x = np.empty((nproc, nmach), dtype=object)
for p in P:
for m in M:
self.x[p, m] = Variable('x[%d,%d]' % (p, m))
# proc alloc
all_proc_expr = Cnf()
for p in P:
p_expr1 = Cnf()
p_expr2 = Cnf()
p_expr3 = Cnf()
for m1 in M:
if any(self._instance.R[p] > self._instance.C[m1]):
p_expr1 &= -self.x[p, m1]
else:
p_expr1 |= self.x[p, m1]
for m2 in range(m1 + 1, nmach):
p_expr2 &= self.x[p, m1] >> -self.x[p, m2]
all_proc_expr &= p_expr1 & p_expr2 & p_expr3
self.global_expr &= all_proc_expr
# conflict
all_conflict_expr = Cnf()
for m in M:
for s in S:
if len(S[s]) == 1: continue
conflict_expr = Cnf()
for p1 in range(len(S[s])):
for p2 in range(p1 + 1, len(S[s])):
conflict_expr &= self.x[S[s][p1],
m] >> -self.x[S[s][p2], m]
all_conflict_expr &= conflict_expr
self.global_expr &= all_conflict_expr
def __init__(self, roster = [], equipment = [], portfolio = {}):
self.roster = {r: Variable(r) for r in roster}
self.equipment = {e: Variable(e) for e in equipment}
self.holdings = {a:
[self.equipment[r] for r in portfolio[a]] for a in portfolio}
list_diff = lambda xs,ys : list(set(xs).difference(set(ys)))
self.neg_holdings = {a:
list_diff(self.equipment.keys(), portfolio[a]) for a in self.holdings}
self.neg_holdings = {a: [self.equipment[r] for r in self.neg_holdings[a]] for a in self.neg_holdings}
self.roster_expression = reduce(lambda a,b: a|b, self.roster.values())
self.equip_expression = reduce(lambda a,b: a|b, self.equipment.values())
zs = []
for a in self.neg_holdings:
xs = reduce(lambda a,b:a|b,self.neg_holdings[a])
xs = self.roster[a] >> -xs
zs = zs + [xs]
self.res_expression = reduce(lambda a,b:a&b, zs)
self.expression = self.roster_expression & self.res_expression & self.equip_expression
def createVariables(self):
"""
Allocate 2 dictionaries:
- boolean variables
- action variable
"""
self.boolean_variables = defaultdict(dict)
for step in range(self.horizon + 1):
for fluent in self.boolean_fluents:
var_name = utils.makeName(fluent, step)
self.boolean_variables.update({var_name: Variable(var_name)})
self.action_variables = defaultdict(dict)
for step in range(self.horizon):
for a in self.actions:
action_name = utils.makeName(a.name, step)
self.action_variables.update(
{action_name: Variable(action_name)})
def reduce_AMO_product(items, _assign_id=[0]):
""" At most one 'product' encoding (Chen)
Which I believe to be the best, once a large number is involved >25
Assign each var to a point in a p*q grid, (Pi, Qj).
Forcing that value of Pi and Qi to be True. Each point will differ
by either P or Q (or both).
As such this can be applied recursively, by allowing at most one
of the P's and one of the Q's to be set. Once the number of P or Q is
small, another encoding can be used.
items: A list of variables, or cnfs (must have two or more items)
_assign_id: Internal counter, don't replace
"""
# Find two numbers p, q such that p*q >= len(items)
p = int(math.ceil(math.sqrt(len(items))))
if p * (p-1) >= len(items):
q = p-1
else:
q = p
assert p*q >= len(items)
# Allocate variables for q and p
qs = []
ps = []
nitems = [-i for i in items]
for _ in range(q):
qs.append(Variable("PRD" + str(_assign_id[0])))
_assign_id[0] += 1
for _ in range(p):
ps.append(Variable("PRD" + str(_assign_id[0])))
_assign_id[0] += 1
cnf = Cnf()
i = 0 # Iterate item counter
for vp in ps:
for vq in qs:
if i >= len(items):
break
cnf &= (nitems[i] | vp) & (nitems[i] | vq)
i += 1
return reduce_AMO(ps) & reduce_AMO(qs) & cnf
def test_sat_lib(self):
"""Sanity check: (x1 v -x2), (-x2), (-x1), (x3 v x1 x x2)"""
cnf = Cnf()
x1 = Variable('x1')
x2 = Variable('x2')
x3 = Variable('x3')
solver = Minisat()
solution = solver.solve(cnf)
if not solution.success:
self.fail("Something seriously wrong with this library.")
true_literals = [x3]
false_literals = [x1, x2]
for lit in true_literals:
self.assertTrue(solution[lit])
for lit in false_literals:
self.assertFalse(solution[lit])
def __init__(self, i,j):
self.i = i
self.j = j
self.p = []
self.f = Cnf()
self.s = Cnf()
for d in range(9):
temp = 'p' + str(i) + str(j) + str(d+1)
#print temp
self.p.append(Variable(temp))
#create first case -- it must be filled
self.f |= self.p[d]
def solve(eq):
eq = eq.strip()
if eq == '': return Cnf()
op = re.findall(r'^(\^\^|\|\||\?\?)', eq)
if op:
op = op[0]
if op == '||':
var, eq = getToken(eq[2:])
assert var[0] == '(' and var[-1] == ')'
result = all_or(var)
elif op == '^^':
var, eq = getToken(eq[2:])
assert var[0] == '(' and var[-1] == ')'
result = all_xor(var)
elif op == '??':
var, eq = getToken(eq[2:])
assert var[0] == '(' and var[-1] == ')'
result = at_most(var)
return result & solve(eq)
op = re.findall(r'^[\w]+\s*\?', eq)
if op:
op = op[0]
eq = eq[len(op):]
var1 = Variable(op[:-1].strip())
var2, eq = solveToken(eq)
return (var1 >> var2) & solve(eq)
op = re.findall(r'^[\w]+', eq)
if op:
op = op[0]
eq = eq[len(op):]
var = Variable(op.strip())
return var & solve(eq)
# This should ideally never be encountered
print("I failed", eq)
exit(1)
def touch_variable(name, map):
"""
Find variable map[name] if it exists else create one and map it.
:param name: key to mapper
:param map: mapping of name to Variable
:return: variable found or created
"""
if name in map:
var = map[name]
else:
var = Variable(name)
map[name] = var
return var
def main():
all_origin_number = {}
for i in range(9):
while True:
row_input = input('please input ' + str(i + 1) + ' row: ')
if valid_input(row_input):
break
for j in range(9):
if row_input[j] != 'n':
all_origin_number[(i, j)] = int(row_input[j]) - 1
all_variable = [[[
Variable('v' + str(i) + str(j) + str(k)) for k in range(9)
] for j in range(9)] for i in range(9)]
true_var = Variable('v_true')
exp = true_var
exp = exp & all_element(all_variable, true_var)
exp = exp & valid_all(all_variable, true_var)
for keys in all_origin_number.keys():
exp = exp & all_variable[keys[0]][keys[1]][all_origin_number[keys]]
solver = Minisat()
solution = solver.solve(exp)
if solution.success:
for i in range(9):
print('row' + str(i + 1) + ': ', end='')
for j in range(9):
for index, var in enumerate(all_variable[i][j]):
if solution[var]:
print(index + 1, end='')
break
print('\n', end='')
else:
print('no solution')
def __init__(self, numVariables, numClauses):
self.numVariables = numVariables
self.numLiterals = 2 * numVariables
self.numClauses = numClauses
# satispy Variables
self.variables = [Variable(str(i)) for i in range(numVariables)]
# Array of arrays (clauses)
# Literal 2n represents variable n, whereas literal (2n + 1) represents variable -n
self.formula = []
# Total number of variables actually used in formula
self.variablesInFormula = []
self.solution = []
def generate(numVariables, k, numClauses):
# TODO: assert numVariables < k * numClauses?
# Total number of possible literals
numLiterals = 2 * numVariables
# Literal 2n represents variable n, whereas literal (2n + 1) represents variable -n
formula = [sample(range(numLiterals), k) for _ in range(numClauses)]
# Get total number of variables actually used in formula
variablesInFormula = set([literal / 2 for clause in formula for literal in clause])
variables = [Variable(str(i)) for i in range(numVariables)]
# Build CNF
cnf = Cnf()
for clause in formula:
# Build DNF
dnf = Cnf()
for literal in clause:
# Get variable using literal index
variable = variables[literal / 2]
# Again, negate variable as described above
dnf |= variable if literal % 2 == 0 else -variable
# Append DNF clause
cnf &= dnf
solver = Minisat()
solution = solver.solve(cnf)
for dis in cnf.dis:
for var in dis:
print var.name
print var.inverted
# TODO: consider external representation for 'formula'
if solution.success:
return (formula, [solution[variables[i]] for i in variablesInFormula])
else:
return (formula, None)
def reduce_AMO_binary(items, _assign_id=[0]):
""" At most one 'binary' encoding (Prestwich) aka. 'bitwise'
Example (where a-d are items; X1-X2 are extra variables):
-a|-X1 -b| X1 -c|-X1 d|X1
-a|-X2 -b|-X2 -c| X1 d|X1
As soon a var is set True ~var becomes False so the X clause must
become True. This forces all X's to a value of either True of False.
In the case of a this is b1=False b2=False which can be shortened to
00, b set true becomes 01, c 10, d 11. I.e. increasing binary
numbers, which are unique; therefore will conflict if two vars are
set to True.
Clauses: n * log2(n)
Extra Vars: log2(n)
Only sees a win over naive with 8+ vars. 7 is equal.
items: A list of variables, or cnfs (must have two or more items)
assign_id: Internal counter, don't replace
NOTE: This method is less efficient than sequential and product.
However in-case something matters in the future.
"""
mask = 1
nitems = [-i for i in items]
cnf = Cnf()
# 8 items mask
while (mask << 1) < len(items):
v = Variable("BIN" + str(_assign_id[0]))
_assign_id[0] += 1
nv = -v
for i in range(len(items)):
if i & mask:
cnf &= nitems[i] | v
else:
cnf &= nitems[i] | nv
mask <<= 1
return cnf
def tostring(self, cnf):
"""Convert Cnf object ot Dimacs cnf string
cnf: Cnf object
In the converted Cnf there will be only numbers for
variable names. The conversion guarantees that the
variables will be numbered alphabetically.
"""
self.varname_dict = {}
self.varobj_dict = {}
varis = set()
for d in cnf.dis:
for v in d:
varis.add(v.name)
ret = "p cnf %d %d" % (len(varis), len(cnf.dis))
varis = dict(
list(
zip(sorted(list(varis)),
list(map(str, list(range(1,
len(varis) + 1)))))))
for v in varis:
vo = Variable(v)
self.varname_dict[vo] = varis[v]
self.varobj_dict[varis[v]] = vo
for d in cnf.dis:
ret += "\n"
vnamelist = []
for v in d:
vnamelist.append(("-" if v.inverted else "") + varis[v.name])
ret += " ".join(vnamelist) + " 0"
return ret
def solve(self, expr):
"""Takes a list of dependent and conflicting packages
and returns whether the current configuration is satisfiable."""
dependent = [p for p in expr if '-' not in p]
conflicting = [p[1:] for p in expr if '-' in p]
# Generate set of unique package variables.
variables = {}
for var in set(dependent + conflicting):
variables[var] = Variable(var)
# Generate 'CNF' logical expression from dependencies
# and conflicts.
expr = Cnf()
for con in dependent:
v = variables[con]
expr = expr & v
for con in conflicting:
v = variables[con]
expr = expr & -v
# Calculate the satisfiability of the input variables.
valid, param = self._check_satisfiability(variables, expr)
if valid:
logging.debug(
"Logical expression, {}, is satisfiable with parameters, {}.".
format(expr, param))
else:
logging.debug(
"Logical expression, {} , is unsatisfiable.".format(expr))
return valid, param
def solve(num_wizards, num_constraints, wizards, constraints, constraintDiction):
"""
Write your algorithm here.
Input:
num_wizards: Number of wizards
num_constraints: Number of constraints
wizards: An array of wizard names, in no particular order
constraints: A 2D-array of constraints,
where constraints[0] may take the form ['A', 'B', 'C']i
Output:
An array of wizard names in the ordering your algorithm returns
"""
maxVal = 0
maxRet = wizards
#constraintDict = {}
iteration = 0
while True:
constraintToVariable = dict()
exp = None
g1 = Graph(num_wizards)
g2 = Graph(num_wizards)
for constraint in constraints:
wiz1 = constraint[0]
wiz2 = constraint[1]
wiz3 = constraint[2]
clause1 = wiz3 + " " + wiz1
clause2 = wiz3 + " " + wiz2
clause3 = wiz1 + " " + wiz3
clause4 = wiz2 + " " + wiz3
g1.addEdge(wiz3, wiz1)
g1.addEdge(wiz3, wiz2)
g2.addEdge(wiz1, wiz3)
g2.addEdge(wiz2, wiz3)
if clause1 in constraintToVariable:
v1 = constraintToVariable[clause1]
else:
constraintToVariable[clause1] = Variable(clause1)
v1 = constraintToVariable[clause1]
if clause2 in constraintToVariable:
v2 = constraintToVariable[clause2]
else:
constraintToVariable[clause2] = Variable(clause2)
v2 = constraintToVariable[clause2]
if clause3 in constraintToVariable:
v3 = constraintToVariable[clause3]
else:
constraintToVariable[clause3] = Variable(clause3)
v3 = constraintToVariable[clause3]
if clause4 in constraintToVariable:
v4 = constraintToVariable[clause4]
else:
constraintToVariable[clause4] = Variable(clause4)
v4 = constraintToVariable[clause4]
literal = ((v1 & v2 & -v3 & -v4) ^ (v3 & v4 & -v1 & -v2))
if exp is None:
exp = literal
else:
exp = exp & literal
solver = Minisat()
solution = solver.solve(exp)
if solution.success:
graph = dict()
g = Graph(num_wizards)
for wizard in wizards:
graph[wizard] = set()
for constraint in constraintToVariable:
v = constraintToVariable[constraint]
if solution[v] == True:
# print(v)
w = str(v).split()
vertexU = w[0]
vertexV = w[1]
graph[vertexU].add(vertexV)
g.addEdge(vertexU, vertexV)
cycle = False
try: topological(graph)
except ValueError: cycle = True
if cycle:
graph[vertexU].remove(vertexV)
graph[vertexV].add(vertexU)
cycle = False
try: topSortGraph = topological(graph)
except ValueError: cycle = True
graph = {}
if not cycle:
ans = list(topSortGraph)
comp = checkConstraintsWithList(constraints, ans)
if comp > maxVal:
maxVal = comp
maxRet = ans
if iteration > 100:
return az(maxRet,constraintDiction) #maxRet
# print(comp)
iteration += 1
shuffle(wizards)
shuffle(constraints)
from satispy import Variable, Cnf
from satispy.solver import Minisat
solver = Minisat()
file = open('testes.txt')
x = [[[0 for k in range(4)] for j in range(4)] for i in range(4)]
for i in range(4):
for j in range(4):
for k in range(4):
x[i][j][k] = Variable('x_'+str(i)+str(j)+'_'+str(k))
sudoku = file.readline()
n = 1
while sudoku != '':
########################################################################################
########################################################################################
## Escreva aqui o código gerador da formula CNF que representa o Sudoku codificado na ##
## variavel 'sudoku'. Nao se esqueca que o codigo deve estar no escopo do 'while' ##
## acima e deve guardar a formula CNF na variavel 'cnf'. ##
########################################################################################
########################################################################################
cnf = Cnf()
#Configurando o sudoku como uma matriz dos números passados
def r_sat_step(x):
eq = Variable('eq')
for i in range(0, N):
eq &= get_formula(get_bit(x, i), i % N, (i + 1) % N, (i + 2) % N)
return solve(eq)
def get_formula(bit, c, b, a):
a, b, c = Variable(str(a)), Variable(str(b)), Variable(str(c))
if bit:
return (-a & -b & c) | (b & -c) | (a & -c)
else:
return (-a & -b & -c) | (b & c) | (a & c)
graph.append(nums)
graph_file.close()
return graph
graph = readGraphFile()
exp = Cnf()
c1 = dict()
c2 = dict()
c3 = dict()
# one of the three colors for a vertex
for vertex in range(VERTICES):
c1[vertex] = Variable('edge%dhasColor1' % vertex)
c2[vertex] = Variable('edge%dhasColor2' % vertex)
c3[vertex] = Variable('edge%dhasColor3' % vertex)
# one of three
exp &= c1[vertex] | c2[vertex] | c3[vertex]
exp &= c1[vertex] | -c2[vertex] | -c3[vertex]
exp &= -c1[vertex] | c2[vertex] | -c3[vertex]
exp &= -c1[vertex] | -c2[vertex] | c3[vertex]
# not same color on one edge
for edge in graph:
begin = edge[0]
end = edge[1]
exp &= -c1[begin] | -c1[end]
exp &= -c2[begin] | -c2[end]
team= n
week =n-1
period=int(n/2)
exp = Cnf()
sol={}
#Creation des variables :
for w in range(week):
sol[w]={}
for p in range(period):
sol[w][p]=[]
for length_team in range(team):
v0 = Variable(str(w)+str(p)+str(length_team))
sol[w][p].append(v0)
#C1 Une équipe joue contre une autre
for w in range(week):
for p in range(period):
c = Cnf()
for t in range(team):
for t2 in range(t+1, team):
c |= (sol[w][p][t]&sol[w][p][t2]) #C1-3 Au moins deux équipe
for t3 in range(t2+1, team):
exp &= ( (sol[w][p][t] & sol[w][p][t2] )>> -sol[w][p][t3]) #Pas plus de deux équipes
from satispy import Variable
from satispy.solver import Minisat
v1 = Variable('v1')
v2 = Variable('v2')
v3 = Variable('v3')
exp = v1 & v2 | v3
solver = Minisat()
solution = solver.solve(exp)
if solution.error != False:
print "Error:"
print solution.error
elif solution.success:
print "Found a solution:"
print v1, solution[v1]
print v2, solution[v2]
print v3, solution[v3]
else:
print "The expression cannot be satisfied"
def sat(instance):
expr = Cnf()
nproc = instance.nproc
nmach = instance.nmach
nserv = instance.nserv
nneigh = len(instance.N)
nloc = len(instance.L)
P = instance.P
M = instance.M
S = instance.S
N = instance.N
L = instance.L
print(" %10.3f creating vars - x" % (time() - all_start))
x = np.empty((nproc, nmach), dtype=object)
for p in P:
for m in M:
x[p, m] = Variable('x[%d,%d]' % (p, m))
print(" %10.3f creating vars - h" % (time() - all_start))
h = np.empty((nserv, nneigh), dtype=object)
for s in S:
for n in N:
h[s, n] = Variable('h[%d,%d]' % (s, n))
print(" %10.3f creating vars - o" % (time() - all_start))
o = np.empty((nserv, nloc), dtype=object)
for s in S:
for l in L:
o[s, l] = Variable('o[%d,%d]' % (s, l))
print(" %10.3f H[s,n]" % (time() - all_start))
for s in S:
#print(" %10.3f H[%6d,n]" %( time() - all_start,s))
for n in N:
pres_expr = Cnf()
for p in S[s]:
for m in N[n]:
pres_expr |= x[p, m]
expr &= h[s, n] >> pres_expr
expr &= pres_expr >> h[s, n]
for sd in instance.sdep[s]:
expr &= h[s, n] >> h[sd, n]
print(" %10.3f O[s,l]" % (time() - all_start))
for s in S:
#print(" %10.3f O[%6d,l]" %( time() - all_start,s))
if instance.delta[s] == 1: continue
for l in L:
pres_expr = Cnf()
for p in S[s]:
for m in L[l]:
pres_expr |= x[p, m]
expr &= o[s, l] >> pres_expr
expr &= pres_expr >> o[s, l]
print(" %10.3f X[p,m]" % (time() - all_start))
for p in P:
#print(" %10.3f X[%6d, m]" %( time() - all_start, p))
p_constr1 = Cnf()
p_constr2 = Cnf()
for m in M:
p_constr1 |= x[p, m]
for m2 in range(m + 1, nmach):
p_constr2 &= x[p, m] >> -x[p, m2]
expr &= p_constr1 & p_constr2
print(" %10.3f X[p,m] - conflito" % (time() - all_start))
for m in M:
for s in S:
conf_constr = Cnf()
if len(S[s]) == 1: continue
for i1 in range(len(S[s])):
for i2 in range(i1 + 1, len(S[s])):
conf_constr &= x[S[s][i1], m] >> -x[S[s][i2], m]
expr &= conf_constr
print(" %10.3f solving" % (time() - all_start))
io = DimacsCnf()
#s = io.tostring(expr)
#print(s)
solver = Minisat('minisat %s %s')
solution = solver.solve(expr)
print(" %10.3f done" % (time() - all_start))
if not solution.success:
print(" %10.3f sem solucao" % (time() - all_start))
exit(0)
print(" %10.3f solucao" % (time() - all_start))
xsol = np.empty((nproc, nmach), dtype=np.int32)
for p in P:
for m in M:
#print(p,m,solution[x[p,m]])
#print(io.varname(x[p,m]))
xsol[p, m] = solution[x[p, m]]
print(xsol)
print(np.all(xsol.sum(axis=1) == 1))
for m in M:
print(instance.mach_validate(m, xsol[:, m]))