def op_difference(left,right):
'''
:param left:
:type left: :class:`~ExprArg`
:param right:
:type right: :class:`~ExprArg`
:returns: :class:`~ExprArg`
Computes the set difference (left - - right)
'''
assert isinstance(left, ExprArg)
assert isinstance(right, ExprArg)
if left.getInts() or right.getInts():
sys.exit("FIXME ints diff")
matches = getSetInstancePairs(left,right)
newInstances = {}
for (sort,index) in matches.keys():
key = (sort,index)
((lexpr,lpol),(rexpr,rpol)) = matches[(sort,index)]
if rpol == Common.DEFINITELY_ON or lpol == Common.DEFINITELY_OFF:
#cases (-1, -1), (-1, 0), (-1, 1), (0, 1), (1, 1)
continue
elif rpol == Common.DEFINITELY_OFF:
#cases (0 , -1), (1, -1)
newInstances[key] = (lexpr, lpol)
else:
#rpol is unknown, lpol is unknown or on => new_pol is UNKNOWN
#cases (0, 0), (1, 0)
#if right is not on, then left, else sort.isOff
new_expr = SMTLib.SMT_If(SMTLib.createNot(rexpr), lexpr, sort.parentInstances)
newInstances[key] = (new_expr, Common.UNKNOWN)
return ExprArg(newInstances)
def op_difference(left, right):
'''
:param left:
:type left: :class:`~ExprArg`
:param right:
:type right: :class:`~ExprArg`
:returns: :class:`~ExprArg`
Computes the set difference (left - - right)
'''
assert isinstance(left, ExprArg)
assert isinstance(right, ExprArg)
if left.getInts() or right.getInts():
sys.exit("FIXME ints diff")
matches = getSetInstancePairs(left, right)
newInstances = {}
for (sort, index) in matches.keys():
key = (sort, index)
((lexpr, lpol), (rexpr, rpol)) = matches[(sort, index)]
if rpol == Common.DEFINITELY_ON or lpol == Common.DEFINITELY_OFF:
#cases (-1, -1), (-1, 0), (-1, 1), (0, 1), (1, 1)
continue
elif rpol == Common.DEFINITELY_OFF:
#cases (0 , -1), (1, -1)
newInstances[key] = (lexpr, lpol)
else:
#rpol is unknown, lpol is unknown or on => new_pol is UNKNOWN
#cases (0, 0), (1, 0)
#if right is not on, then left, else sort.isOff
new_expr = SMTLib.SMT_If(SMTLib.createNot(rexpr), lexpr,
sort.parentInstances)
newInstances[key] = (new_expr, Common.UNKNOWN)
return ExprArg(newInstances)
def compute_int_set(instances):
cons = []
for index in range(len(instances)):
(i, c) = instances[index]
cons.append(
mAnd(
c, *[
mOr(SMTLib.createNot(jc), SMTLib.SMT_NE(j, i))
for (j, jc) in instances[0:index]
]))
return cons
def op_not(arg):
'''
:param arg:
:type arg: :class:`~ExprArg`
:returns: :class:`~IntArg`
Boolean negation of arg.
'''
assert isinstance(arg, ExprArg)
val = arg.getBool()
return BoolArg(SMTLib.createNot(val))
def op_nin(left, right):
'''
:param left:
:type left: :class:`~ExprArg`
:param right:
:type right: :class:`~ExprArg`
:returns: :class:`~ExprArg`
Ensures that left is not a subset of right.
'''
assert isinstance(left, ExprArg)
assert isinstance(right, ExprArg)
expr = op_in(left, right)
return BoolArg(SMTLib.createNot(expr.pop_value()))
def op_nin(left,right):
'''
:param left:
:type left: :class:`~ExprArg`
:param right:
:type right: :class:`~ExprArg`
:returns: :class:`~ExprArg`
Ensures that left is not a subset of right.
'''
assert isinstance(left, ExprArg)
assert isinstance(right, ExprArg)
expr = op_in(left,right)
return BoolArg(SMTLib.createNot(expr.pop_value()))
def op_ne(left, right):
'''
:param left:
:type left: :class:`~ExprArg`
:param right:
:type right: :class:`~ExprArg`
:returns: :class:`~BoolArg`
Ensures that the left != right.
'''
assert isinstance(left, ExprArg)
assert isinstance(right, ExprArg)
expr = op_eq(left, right)
b = expr.getBool()
return BoolArg(SMTLib.createNot(b))
def op_ne(left,right):
'''
:param left:
:type left: :class:`~ExprArg`
:param right:
:type right: :class:`~ExprArg`
:returns: :class:`~BoolArg`
Ensures that the left != right.
'''
assert isinstance(left, ExprArg)
assert isinstance(right, ExprArg)
expr = op_eq(left, right)
b = expr.getBool()
return BoolArg(SMTLib.createNot(b))
def isOff(self, arg):
'''
Returns a Boolean Constraint stating whether or not the instance at the given index is *off*.
'''
return SMTLib.createNot(self.isOn(arg))
def isOff(self, arg):
'''
Returns a Boolean Constraint stating whether or not the instance at the given index is *off*.
'''
return SMTLib.createNot(self.isOn(arg))
def op_eq(left, right, cacheJoins=False, bc=None):
'''
:param left:
:type left: :class:`~ExprArg`
:param right:
:type right: :class:`~ExprArg`
:returns: :class:`~BoolArg`
Ensures that the left = right.
'''
assert isinstance(left, ExprArg)
assert isinstance(right, ExprArg)
if cacheJoins and bc:
#TODO CLEAN
left_key = None
right_key = None
keys = []
#asil allocation speedup, if both sides are sets, we can perform expression substitution in other constraints
#bc is the bracketed constraint to put the cache
for i in [left, right]:
if isinstance(i, JoinArg):
newkeys = Common.computeCacheKeys(i.flattenJoin())
#print(tuple(key))
keys = keys + newkeys
#need to return all keys during the progress of join, add flag?
#get the all keys
all_keys = i.checkIfJoinIsComputed(nonsupered=True,
getAllKeys=True)
#print(keys)
#print(all_keys)
keys = keys + all_keys
#sys.exit()
#print()
#print("GGGG right" + str(right.__class__))
#print(right.clafers)
if len(left.clafers) != len(right.clafers):
minJoinVal = left.clafers if len(left.clafers) < len(
right.clafers) else right.clafers
for i in keys:
#TODO make more robust (e.g. if multiple equalities exist for the same join key, aggregate expressions
bc.cache[i] = ExprArg(minJoinVal)
#print(i)
#print(minJoinVal)
#print(str(len(minJoinVal)) + " " + str(len(left.clafers)) + " " + str(len(right.clafers)))
#print(str(len(left.clafers)) + " " + str(len(right.clafers)))
cond = []
#int equality case
lints = [(e, c) for (e, c) in left.getInts() if str(c) != "False"]
rints = [(e, c) for (e, c) in right.getInts() if str(c) != "False"]
if lints or rints:
for (e, c) in lints:
#exists r in R s.t. e == r
expr = mOr(*[mAnd(rc, SMTLib.SMT_EQ(e, r)) for (r, rc) in rints])
if str(c) != "True":
expr = SMTLib.SMT_Implies(c, expr)
cond.append(expr)
for (e, c) in rints:
#exists l in L s.t. e == l
expr = mOr(*[mAnd(lc, SMTLib.SMT_EQ(e, l)) for (l, lc) in lints])
if str(c) != "True":
expr = SMTLib.SMT_Implies(c, expr)
cond.append(expr)
#clafer-set equality case
matches = getSetInstancePairs(left, right)
for ((lexpr, lpol), (rexpr, rpol)) in matches.values():
if lpol == Common.DEFINITELY_OFF and rpol == Common.DEFINITELY_OFF:
continue
elif lpol == Common.DEFINITELY_OFF:
cond.append(SMTLib.createNot(rexpr))
elif rpol == Common.DEFINITELY_OFF:
cond.append(SMTLib.createNot(lexpr))
else:
cond.append(SMTLib.SMT_Implies(lexpr, rexpr))
cond.append(SMTLib.SMT_Implies(rexpr, lexpr))
return BoolArg(mAnd(*cond))
def op_eq(left,right, cacheJoins=False, bc = None):
'''
:param left:
:type left: :class:`~ExprArg`
:param right:
:type right: :class:`~ExprArg`
:returns: :class:`~BoolArg`
Ensures that the left = right.
'''
assert isinstance(left, ExprArg)
assert isinstance(right, ExprArg)
if cacheJoins and bc:
#TODO CLEAN
left_key = None
right_key = None
keys = []
#asil allocation speedup, if both sides are sets, we can perform expression substitution in other constraints
#bc is the bracketed constraint to put the cache
for i in [left,right]:
if isinstance(i, JoinArg):
newkeys = Common.computeCacheKeys(i.flattenJoin())
#print(tuple(key))
keys = keys + newkeys
#need to return all keys during the progress of join, add flag?
#get the all keys
all_keys = i.checkIfJoinIsComputed(nonsupered=True, getAllKeys = True)
#print(keys)
#print(all_keys)
keys = keys+all_keys
#sys.exit()
#print()
#print("GGGG right" + str(right.__class__))
#print(right.clafers)
if len(left.clafers) != len(right.clafers):
minJoinVal = left.clafers if len(left.clafers) < len(right.clafers) else right.clafers
for i in keys:
#TODO make more robust (e.g. if multiple equalities exist for the same join key, aggregate expressions
bc.cache[i] = ExprArg(minJoinVal)
#print(i)
#print(minJoinVal)
#print(str(len(minJoinVal)) + " " + str(len(left.clafers)) + " " + str(len(right.clafers)))
#print(str(len(left.clafers)) + " " + str(len(right.clafers)))
cond = []
#int equality case
lints = [(e,c) for (e,c) in left.getInts() if str(c) != "False"]
rints = [(e,c) for (e,c) in right.getInts() if str(c) != "False"]
if lints or rints:
for (e,c) in lints:
#exists r in R s.t. e == r
expr = mOr(*[mAnd(rc, SMTLib.SMT_EQ(e,r)) for (r,rc) in rints])
if str(c) != "True":
expr = SMTLib.SMT_Implies(c, expr)
cond.append(expr)
for (e,c) in rints:
#exists l in L s.t. e == l
expr = mOr(*[mAnd(lc, SMTLib.SMT_EQ(e,l)) for (l,lc) in lints])
if str(c) != "True":
expr = SMTLib.SMT_Implies(c, expr)
cond.append(expr)
#clafer-set equality case
matches = getSetInstancePairs(left,right)
for ((lexpr, lpol),(rexpr, rpol)) in matches.values():
if lpol == Common.DEFINITELY_OFF and rpol == Common.DEFINITELY_OFF:
continue
elif lpol == Common.DEFINITELY_OFF:
cond.append(SMTLib.createNot(rexpr))
elif rpol == Common.DEFINITELY_OFF:
cond.append(SMTLib.createNot(lexpr))
else:
cond.append(SMTLib.SMT_Implies(lexpr, rexpr))
cond.append(SMTLib.SMT_Implies(rexpr, lexpr))
return BoolArg(mAnd(*cond))
def compute_int_set(instances):
cons = []
for index in range(len(instances)):
(i,c) = instances[index]
cons.append(mAnd(c, *[mOr(SMTLib.createNot(jc), SMTLib.SMT_NE(j,i)) for (j, jc) in instances[0:index]]))
return cons
def quant_no(exprs, ifConstraints):
condList = getQuantifierConditionList(exprs)
if ifConstraints:
condList = [mAnd(i, j) for i, j in zip(ifConstraints, condList)]
return SMTLib.createNot(mOr(*condList))
def quant_no(exprs, ifConstraints):
condList = getQuantifierConditionList(exprs)
if ifConstraints:
condList = [mAnd(i, j) for i,j in zip(ifConstraints, condList)]
return SMTLib.createNot(mOr(*condList))
