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))