def mOr(*args):
'''
Similar to mAnd
'''
args = list(args)
newArgs = []
while (args):
i = args.pop()
if isinstance(i, SMTLib.SMT_Or):
#print(i)
for j in i.children():
#print(j)
args.append(j)
continue
if i:
if isinstance(i, SMTLib.SMT_BoolConst):
if str(i) == "False":
continue
else:
return SMTLib.SMT_BoolConst(True)
newArgs.append(i)
if len(newArgs) == 0:
return SMTLib.SMT_BoolConst(False)
elif len(newArgs) == 1:
return newArgs[0]
else:
return SMTLib.SMT_Or(*newArgs)
def ConstraintNotDominatedByX(self, model):
"""
Creates a constraint preventing search in dominated regions.
"""
DisjunctionOrLessMetrics = list()
for i in range(len(self.metrics_variables)):
if self.metrics_objective_direction[i] == Common.METRICS_MAXIMIZE:
DisjunctionOrLessMetrics.append(
SMTLib.SMT_GT(
self.metrics_variables[i],
SMTLib.SMT_IntConst(
Common.evalForNum(
model, self.metrics_variables[i].convert(
self.cfr.solver.converter))))
) #model[self.metrics_variables[i]])
else:
DisjunctionOrLessMetrics.append(
SMTLib.SMT_LT(
self.metrics_variables[i],
SMTLib.SMT_IntConst(
Common.evalForNum(
model, self.metrics_variables[i].convert(
self.cfr.solver.converter))))
) #model[self.metrics_variables[i]])
return SMTLib.SMT_Or(*DisjunctionOrLessMetrics)
def createInstancesConstraintsAndFunctions(self):
for i in range(self.numInstances):
(lower, upper, extraAbsenceConstraint) = self.instanceRanges[i]
#lower == upper case (simpler)
if lower == upper:
constraint = SMTLib.SMT_EQ(self.instances[i],
SMTLib.SMT_IntConst(upper))
if extraAbsenceConstraint:
self.constraints.addInstanceConstraint(
SMTLib.SMT_Or(self.isOff(i), constraint))
else:
#TODO self.instances[i] = SMTLib.SMT_IntConst(lower)
self.constraints.addInstanceConstraint(constraint)
else:
#parent pointer is >= lower
self.constraints.addInstanceConstraint(
SMTLib.SMT_GE(self.instances[i],
SMTLib.SMT_IntConst(lower)))
constraint = SMTLib.SMT_LE(self.instances[i],
SMTLib.SMT_IntConst(upper))
if extraAbsenceConstraint:
#parent pointer is <= upper , or equal to parentInstances
self.constraints.addInstanceConstraint(
SMTLib.SMT_Or(self.isOff(i), constraint))
else:
#parent pointer is <= upper
self.constraints.addInstanceConstraint(constraint)
#sorted parent pointers (only consider things that are not part of an abstract)
if not self.beneathAnAbstract:
if i != self.numInstances - 1:
self.constraints.addInstanceConstraint(
SMTLib.SMT_LE(self.instances[i],
self.instances[i + 1]))
if not self.parent:
return
#if the parent is not live, then no child can point to it
for i in range(self.parent.numInstances):
for j in range(self.numInstances):
self.constraints.addInstanceConstraint(
SMTLib.SMT_Implies(
self.parent.isOff(i),
SMTLib.SMT_NE(self.instances[j],
SMTLib.SMT_IntConst(i))),
self.parent.known_polarity(i, local=True) !=
Common.DEFINITELY_ON)
def int_set_in(leftIntSort, rightIntSort):
(left_sort, left_mask) = leftIntSort
(right_sort, right_mask) = rightIntSort
cond = []
for i in left_mask.keys():
constraint = SMTLib.SMT_Or(
SMTLib.SMT_EQ(left_sort.cardinalityMask.get(i),
SMTLib.SMT_IntConst(0)),
SMTLib.SMT_Or(*[
SMTLib.SMT_And(
SMTLib.SMT_EQ(right_sort.cardinalityMask.get(j),
SMTLib.SMT_IntConst(1)),
SMTLib.SMT_EQ(right_mask.get(j), left_mask.get(i)))
for j in right_mask.keys()
]))
cond.append(constraint)
return (SMTLib.SMT_And(*cond))
def ConstraintMustDominatesX(self, model):
"""
Returns a constraint that a new instance has to be better than the instance represented by model in at least one dimension,
and better or equal in all the other ones.
"""
dominationDisjunction = []
i = 0
for dominatedByMetric in self.metrics_variables:
dominationConjunction = []
j = 0
if self.metrics_objective_direction[i] == Common.METRICS_MAXIMIZE:
dominationConjunction.append(
SMTLib.SMT_GT(
dominatedByMetric,
SMTLib.SMT_IntConst(
Common.evalForNum(
model,
dominatedByMetric.convert(
self.cfr.solver.converter)))))
else:
dominationConjunction.append(
SMTLib.SMT_LT(
dominatedByMetric,
SMTLib.SMT_IntConst(
Common.evalForNum(
model,
dominatedByMetric.convert(
self.cfr.solver.converter)))))
for AtLeastEqualInOtherMetric in self.metrics_variables:
if j != i:
if self.metrics_objective_direction[
j] == Common.METRICS_MAXIMIZE:
dominationConjunction.append(
SMTLib.SMT_GE(
AtLeastEqualInOtherMetric,
SMTLib.SMT_IntConst(
Common.evalForNum(
model,
AtLeastEqualInOtherMetric.convert(
self.cfr.solver.converter)))))
else:
dominationConjunction.append(
SMTLib.SMT_LE(
AtLeastEqualInOtherMetric,
SMTLib.SMT_IntConst(
Common.evalForNum(
model,
AtLeastEqualInOtherMetric.convert(
self.cfr.solver.converter)))))
j = 1 + j
i = 1 + i
dominationDisjunction.append(
SMTLib.SMT_And(*dominationConjunction))
constraintDominateX = SMTLib.SMT_Or(*dominationDisjunction)
return constraintDominateX
def preventSameModel(cfr, solver, model):
block = []
for i in cfr.cfr_sorts.values():
for j in i.instances:
block.append(
SMTLib.SMT_NE(j, SMTLib.SMT_IntConst(int(str(model[j.var])))))
if i.refs:
for j in i.refs:
try:
val = model[j.var]
except:
#happens if a primitive ref is totally unrestricted
continue
if not val:
continue
else:
block.append(SMTLib.SMT_NE(j, SMTLib.SMT_IntConst(val)))
if block == []:
solver.add(SMTLib.SMT_BoolConst(False))
else:
solver.add(SMTLib.SMT_Or(*block))
def quant_lone(exprs, ifConstraints):
return SMTLib.SMT_Or(quant_no(exprs, ifConstraints),
quant_one(exprs, ifConstraints))
