def mAnd(*args): ''' Short for MaybeAnd. Helper Function to simplify formulas passed to Z3, but mostly to make debugging output more comprehensible. Only applies the And function if there are actually multiple arguments. ''' args = list(args) newArgs = [] while (args): i = args.pop() if isinstance(i, SMTLib.SMT_And): for j in i.children(): args.append(j) continue if i: if str(i) == "True": continue if str(i) == "False": return SMTLib.SMT_BoolConst(False) newArgs.append(i) if len(newArgs) == 0: return SMTLib.SMT_BoolConst(True) elif len(newArgs) == 1: return newArgs[0] else: return SMTLib.SMT_And(*newArgs)
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 addSubSortConstraints(self, sub): #the super cannot exist without the sub, and vice-versa for i in range(sub.numInstances): self.constraints.addInheritanceConstraint( SMTLib.SMT_And( SMTLib.SMT_Implies(self.isOn(i + sub.indexInSuper), sub.isOn(i)), SMTLib.SMT_Implies(sub.isOn(i), self.isOn(i + sub.indexInSuper))))
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 ConstraintEqualToX(self, model): """ Returns a Constraint that a new instance, can't be dominated by the instance represented by model. (it can't be worst in any objective). """ EqualMetrics = list() for i in range(len(self.metrics_variables)): EqualMetrics.append( SMTLib.SMT_EQ( self.metrics_variables[i], Common.evalForNum(model, self.metrics_variables[i]))) return SMTLib.SMT_And(EqualMetrics)
def addRefConstraints(self): if not self.refSort: return elif isinstance(self.refSort, PrimitiveType) and self.refSort.type == "real": self.refs = SMTLib.SMT_RealVector(self.element.uid + "_ref", self.numInstances) elif isinstance(self.refSort, PrimitiveType): self.refs = SMTLib.SMT_IntVector(self.element.uid + "_ref", self.numInstances) else: self.refs = SMTLib.SMT_IntVector( self.element.uid + "_ref", self.numInstances, bits=self.getBits(self.refSort.parentInstances + 1)) if not isinstance(self.refSort, PrimitiveType): for i in range(self.numInstances): #refs pointer is >= 0 self.constraints.addRefConstraint( SMTLib.SMT_GE(self.refs[i], SMTLib.SMT_IntConst(0))) #ref pointer is <= upper card of ref parent self.constraints.addRefConstraint( SMTLib.SMT_LE( self.refs[i], SMTLib.SMT_IntConst(self.refSort.numInstances))) #if integer refs, zero out refs that do not have live parents, #if clafer refs, set equal to ref.parentInstances if not live #reference symmetry breaking if not self.element.isAbstract: for i in range(self.numInstances - 1): for j in range(i + 1, self.numInstances): if isinstance(self.refSort, PrimitiveType): self.constraints.addRefConstraint( SMTLib.SMT_Implies( SMTLib.SMT_EQ(self.instances[i], self.instances[j]), SMTLib.SMT_LE(self.refs[i], self.refs[j]))) else: self.constraints.addRefConstraint( SMTLib.SMT_Implies( mAnd( SMTLib.SMT_NE( self.refs[i], SMTLib.SMT_IntConst( self.refSort.numInstances)), SMTLib.SMT_EQ(self.instances[i], self.instances[j])), SMTLib.SMT_LE(self.refs[i], self.refs[j]))) for i in range(self.numInstances): if isinstance(self.refSort, PrimitiveType): if self.refSort == "integer": self.constraints.addRefConstraint( SMTLib.SMT_Implies( self.isOff(i), SMTLib.SMT_EQ(self.refs[i], SMTLib.SMT_IntConst(0))), self.known_polarity(i, local=True) != Common.DEFINITELY_ON) elif self.refSort == "string": if Options.STRING_CONSTRAINTS: self.constraints.addRefConstraint( SMTLib.SMT_Implies( self.isOff(i), SMTLib.SMT_EQ(self.refs[i], self.cfr.EMPTYSTRING)), self.known_polarity(i, local=True) != Common.DEFINITELY_ON) else: self.constraints.addRefConstraint( SMTLib.SMT_Implies( self.isOff(i), SMTLib.SMT_EQ(self.refs[i], SMTLib.SMT_IntConst(0))), self.known_polarity(i, local=True) != Common.DEFINITELY_ON) else: self.constraints.addRefConstraint( SMTLib.SMT_Implies( self.isOff(i), SMTLib.SMT_EQ(self.refs[i], SMTLib.SMT_IntConst(0))), self.known_polarity(i, local=True) != Common.DEFINITELY_ON) else: if self.known_polarity(i, local=True) != Common.DEFINITELY_ON: self.constraints.addRefConstraint( SMTLib.SMT_If( self.isOff(i), SMTLib.SMT_EQ( self.refs[i], SMTLib.SMT_IntConst( self.refSort.numInstances)), SMTLib.SMT_NE( self.refs[i], SMTLib.SMT_IntConst( self.refSort.numInstances)))) else: self.constraints.addRefConstraint( SMTLib.SMT_NE( self.refs[i], SMTLib.SMT_IntConst(self.refSort.numInstances))) #if refsort.full does not exist, create it if not self.refSort.full: self.refSort.full = lambda x: mOr(*[ SMTLib.SMT_And( SMTLib.SMT_EQ(x, SMTLib.SMT_IntConst(i)), self.refSort.isOn(i)) for i in range(self.refSort.numInstances) ]) #the clafer that the reference points to must be "on" self.constraints.addRefConstraint( SMTLib.SMT_Implies( SMTLib.SMT_NE( self.refs[i], SMTLib.SMT_IntConst(self.refSort.numInstances)), self.refSort.full(self.refs[i])))