def convert_type(T, ctx):
if T.is_tvar():
return z3.DeclareSort(T.name, ctx)
if T == NatType or T == IntType:
return z3.IntSort(ctx)
elif T == BoolType:
return z3.BoolSort(ctx)
elif T == RealType:
return z3.RealSort(ctx)
elif T.is_fun():
domainT = convert_type(T.domain_type(), ctx)
rangeT = convert_type(T.range_type(), ctx)
if isinstance(domainT, tuple):
raise Z3Exception("convert: unsupported type " + repr(T))
if isinstance(rangeT, tuple):
return tuple([domainT] + list(rangeT))
else:
return (domainT, rangeT)
elif T.is_tconst() and T.name == 'set':
domainT = convert_type(T.args[0], ctx)
if isinstance(domainT, tuple):
raise Z3Exception("convert: unsupported type " + repr(T))
return (domainT, convert_type(BoolType, ctx))
else:
raise Z3Exception("convert: unsupported type " + repr(T))
def main():
sort = z3.DeclareSort("S") # Unbounded number of distinct values...
# sort, _ = z3.EnumSort("S", ["x", "y"]) # Or bounded number of distinct values (here we have two).
columns = ["a", "b",
"c"] # All columns take values from the same sort, for now.
r1 = Table.create_symbolic("r1", sort, columns)
r2 = Table.create_symbolic("r2", sort, columns)
# Dear solver,
sol = z3.Solver()
# r1 and r2 are congruent under \pi_{a, b},
sol.add(congruent(r1, r2, lambda r: r.project(["a", "b"])))
# and are congruent under \pi_{b, c},
sol.add(congruent(r1, r2, lambda r: r.project(["b", "c"])))
# but are NOT congruent under \pi_{b} \sigma_{a == b == c};
sol.add(
z3.Not(
congruent(
r1, r2, lambda r: r.filter(lambda a, b, c: z3.And(
a == b, b == c)).project(["b"]))))
# is this possible?
res = sol.check()
if res == z3.sat:
print(sol.model())
else:
print(res)
def z3Sort(self, name):
"""Return the z3 Sort for the given name."""
name = str(name)
try:
return self._z3Sorts[name]
except KeyError:
sort = z3.DeclareSort(name)
self._z3Sorts[name] = sort
return sort
def uninterpretedsort(us):
s = z3_sorts.get(us.rep, None)
if s: return s
s = lookup_native(us.rep, sorts, "sort")
if s == None:
s = z3.DeclareSort(us.rep)
z3_sorts[us.rep] = s
z3_sorts_inv[get_id(s)] = us
return s
def type(self, type_name):
if type_name in self._types:
z3_type = self._types[type_name]
return self._types[type_name]
else:
# lets be bold here and assume that if a type is not known
# it is a user-defined or generic can be declared generically
z3_type = z3.DeclareSort(type_name)
self._types[type_name] = z3_type
return z3_type
def _to_z3(x):
"""
Convert a term or a sort to a Z3 object.
"""
print "<bhavya> _to_z3 called"
if x in _z3_interpreted:
return _z3_interpreted[x]
elif type(x) is UninterpretedSort:
if x not in _z3_uninterpreted_sorts:
_z3_uninterpreted_sorts[x] = z3.DeclareSort(x.name)
return _z3_uninterpreted_sorts[x]
elif type(x) is FunctionSort:
assert False, "FunctionSort's aren't converted to Z3"
elif type(x) in (Var, Const) and first_order_sort(x.sort):
return z3.Const(x.name + ':' + str(x.sort), to_z3(x.sort))
elif type(x) in (Var, Const) and type(x.sort) is FunctionSort and len(
x.sort.sorts) == 1:
# convert to first order
s = x.sort.sorts[0]
return z3.Const(x.name + ':' + str(s), to_z3(s))
elif type(x) in (Var, Const) and type(x.sort) is FunctionSort:
assert type(
x
) is Const, "Cannot convert high-order variables to Z3, only constants"
return z3.Function(x.name, *(to_z3(s) for s in x.sort))
elif type(x) is Apply and len(x.terms) == 0:
# convert application to use of first order symbol
return to_z3(x.func)
elif type(x) is Apply:
return to_z3(x.func)(*(to_z3(t) for t in x.terms))
elif type(x) in _z3_operators:
return _z3_operators[type(x)](*(to_z3(y) for y in x))
elif type(x) in _z3_quantifiers:
if len(x.variables) == 0:
return to_z3(x.body)
else:
return _z3_quantifiers[type(x)](
[to_z3(v) for v in x.variables],
to_z3(x.body),
)
else:
assert False, type(x)
def sort_to_z3(s: Union[syntax.Sort, syntax.SortDecl]) -> z3.SortRef:
if isinstance(s, syntax.UninterpretedSort):
assert s.decl is not None, str(s)
s = s.decl
if isinstance(s, syntax.SortDecl):
if s.z3 is None:
s.z3 = z3.DeclareSort(s.name)
return s.z3
elif isinstance(s, syntax._BoolSort):
return z3.BoolSort()
elif isinstance(s, syntax._IntSort):
return z3.IntSort()
else:
assert False
def _smt_sort(self, sort):
"""Correspondence between Maude and SMT sorts"""
smt_sort = self.sorts_table.get(sort)
if smt_sort is not None:
return smt_sort
# Array sort (if renamed or if the view names do not coincide
# with the name of the sorts, it must be introduced manually
# into sorts_table)
if str(sort).startswith('Array{'):
smt_sort = self._parse_array_type(str(sort))
# Custom sort
else:
smt_sort = smt.DeclareSort(str(sort))
self.sorts_table[sort] = smt_sort
return smt_sort
basic_simplifier = RewriteEngine()
always = lambda x: True
# TODO: rewriting needs to resolve references -
# you cannot just rewrite anything named "isfunc"
# Or can you? Because pure must be imported as * and names cannot be reassigned?
for (patt, repl, condition) in [
# # ('F(reduce(R, L, I))', 'reduce(R`, map(F, L), I)', reduce_fn_check),
]:
basic_simplifier.add(exprparse(patt), exprparse(repl), condition)
# expr = exprparse('IsTruthy(isint(c) and isint(d))')
# rewritten = basic_simplifier.rewrite(expr)
# print('rewrite engine test', unparse(expr), unparse(rewritten))
PyFunc = z3.DeclareSort('PyFunc')
Unk = z3.Datatype('Unk')
Unk.declare('none')
Unk.declare('bool', ('tobool', z3.BoolSort()))
Unk.declare('int', ('toint', z3.IntSort()))
Unk.declare('string', ('tostring', z3.StringSort()))
Unk.declare('func', ('tofunc', PyFunc))
Unk.declare('app', ('tl', Unk), ('hd', Unk))
Unk.declare('_') # empty tuple
Unk.declare('undef') # error value
(Unk, ) = z3.CreateDatatypes(Unk)
App = z3.Function('.', Unk, Unk, Unk)
class ZHolder():
pass
if self.__class__ is other.__class__:
return self.value < other.value
return NotImplemented
@dataclass
class CallAnalysis:
verification_status: Optional[
VerificationStatus] = None # None means "ignore"
messages: Sequence[AnalysisMessage] = ()
failing_precondition: Optional[ConditionExpr] = None
failing_precondition_reason: str = ""
realized_smt_exprs: Set[z3.ExprRef] = field(default_factory=set)
HeapRef = z3.DeclareSort("HeapRef")
SnapshotRef = NewType("SnapshotRef", int)
def model_value_to_python(value: z3.ExprRef) -> object:
if z3.is_string_value(value):
return value.as_string()
elif z3.is_real(value):
return float(value.as_fraction())
else:
return ast.literal_eval(repr(value))
def prefer_true(v: Any) -> bool:
if hasattr(v, "var") and z3.is_bool(v.var):
space = context_statespace()
try:
import z3 # type: ignore[import]
HAS_Z3 = True
# dynamic type
dyn = z3.DeclareSort('Dyn')
dyn_type = z3.Const('dyn', dyn)
# dimension
dim = z3.Datatype('dim')
dim.declare('dim', ('0', z3.IntSort()), ('1', z3.IntSort()))
dim = dim.create()
# tensors
tensor_type = z3.Datatype('TensorType')
tensor_type.declare('Dyn', ('dyn', dyn))
tensor_type.declare('tensor1', ('0', dim))
tensor_type.declare('tensor2', ('0', dim), ('1', dim))
tensor_type.declare('tensor3', ('0', dim), ('1', dim), ('2', dim))
tensor_type.declare('tensor4', ('0', dim), ('1', dim), ('2', dim),
('3', dim))
tensor_type = tensor_type.create()
# create dimension
D = dim.dim
z3_dyn = tensor_type.Dyn(dyn_type)
except ImportError:
HAS_Z3 = False
def __lt__(self, other):
if self.__class__ is other.__class__:
return self.value < other.value
return NotImplemented
@dataclass
class CallAnalysis:
verification_status: Optional[
VerificationStatus] = None # None means "ignore"
messages: Sequence[AnalysisMessage] = ()
failing_precondition: Optional[ConditionExpr] = None
failing_precondition_reason: str = ''
HeapRef = z3.DeclareSort('HeapRef')
SnapshotRef = NewType('SnapshotRef', int)
def model_value_to_python(value: z3.ExprRef) -> object:
if z3.is_string_value(value):
return value.as_string()
elif z3.is_real(value):
return float(value.as_fraction())
else:
return ast.literal_eval(repr(value))
class NotDeterministic(Exception):
pass
nodes = dict(zip(nodes, node_list))
# Addresses for this network
address, address_list = z3.EnumSort('Address', addresses)
addresses = dict(zip(addresses, address_list))
a = nodes['a']
b = nodes['b']
f1 = nodes['f1']
f2 = nodes['f2']
ip_a = addresses['ip_a']
ip_b = addresses['ip_b']
ip_f1 = addresses['ip_f1']
ip_f2 = addresses['ip_f2']
packet = z3.DeclareSort('packets')
port = z3.DeclareSort('ports')
body = z3.DeclareSort('body')
time = z3.IntSort()
event = z3.DeclareSort('event')
#src : E -> N
#dst : E -> N
#p : E -> P
#t : E -> T
src = z3.Function('src', event, node)
dst = z3.Function('dst', event, node)
p = z3.Function('p', event, packet)
t = z3.Function('t', event, time)
for _, member in members:
classes.add(member)
subclass = collections.defaultdict(list)
for cls in classes:
for base in cls.__bases__:
subclass[base].append(cls)
_MAP = subclass
return _MAP
def rebuild_subclass_map():
global _MAP
_MAP = None
PYTYPE_SORT = z3.DeclareSort('pytype_sort')
SMT_SUBTYPE_FN = z3.Function(
'pytype_sort_subtype', PYTYPE_SORT, PYTYPE_SORT, z3.BoolSort())
class SmtTypeRepository:
pytype_to_smt: Dict[Type, z3.ExprRef]
def __init__(self, solver: z3.Solver):
self.pytype_to_smt = {}
self.solver = solver
# preload a few:
for typ in (object, int, str):
self.get_type(typ)
def smt_issubclass(self, typ1: z3.ExprRef, typ2: z3.ExprRef) -> z3.ExprRef:
return SMT_SUBTYPE_FN(typ1, typ2)
def make_z3_sort(self, name):
z3_sort = z3.DeclareSort(name, self.context)
self.sort_dict[name] = z3_sort
return z3_sort
for _, member in members:
classes.add(member)
subclass = collections.defaultdict(list)
for cls in classes:
for base in cls.__bases__:
subclass[base].append(cls)
_MAP = subclass
return _MAP
def rebuild_subclass_map():
global _MAP
_MAP = None
PYTYPE_SORT = z3.DeclareSort("pytype_sort")
SMT_SUBTYPE_FN = z3.Function("pytype_sort_subtype", PYTYPE_SORT, PYTYPE_SORT,
z3.BoolSort())
class SymbolicTypeRepository:
pytype_to_smt: Dict[Type, z3.ExprRef]
def __init__(self, solver: z3.Solver):
self.pytype_to_smt = {}
self.solver = solver
# preload a few:
# TODO: this is expensive to do every iteration; can it be avoided?
for typ in (object, int, str):
self.get_type(typ)
#! /usr/bin/python
import sys
import os
from itertools import product
import z3
from z3 import ForAll
import re
T = z3.DeclareSort('T')
P = z3.IntSort()
OP_INPUT, \
OP_WEIGHT, \
OP_ANY, \
OP_CONV2D, \
OP_DROPOUT, \
OP_LINEAR, \
OP_POOL2D_MAX, \
OP_POOL2D_AVG, \
OP_RELU, \
OP_SIGMOID, \
OP_TANH, \
OP_BATCHNORM, \
OP_CONCAT, \
OP_SPLIT, \
OP_RESHAPE, \
OP_TRANSPOSE, \
OP_EW_ADD, \
def learn(sig: Signature, axioms: List[Formula], formula: Formula,
timeout: float, args: Any) -> LearningResult:
result = LearningResult(False, Or([]), Timer(timeout), Timer(timeout),
UnlimitedTimer())
S = SeparatorReductionV1 if args.separator == 'v1' else\
SeparatorReductionV2 if args.separator == 'v2' else\
GeneralizedSeparator if args.separator == 'generalized' else\
HybridSeparator if args.separator == 'hybrid' else\
SeparatorNaive
separator: Separator = S(sig,
quiet=args.quiet,
logic=args.logic,
epr_wrt_formulas=axioms +
[formula, Not(formula)])
env = Environment(sig)
s = z3.Solver()
for sort in sig.sorts:
sorts_to_z3[sort] = z3.DeclareSort(sort)
for const, sort in sig.constants.items():
z3.Const(const, sorts_to_z3[sort])
for rel, sorts in sig.relations.items():
z3_rel_func[rel] = z3.Function(rel, *[sorts_to_z3[x] for x in sorts],
z3.BoolSort())
for fun, (sorts, ret) in sig.functions.items():
z3_rel_func[fun] = z3.Function(fun, *[sorts_to_z3[x] for x in sorts],
sorts_to_z3[ret])
for ax in axioms:
s.add(toZ3(ax, env))
p_constraints: List[int] = []
n_constraints: List[int] = []
try:
while True:
with result.counterexample_timer:
if not args.quiet:
print("Checking formula")
if not args.no_cvc4:
r = find_model_or_equivalence_cvc4(
result.current, formula, env, s,
result.counterexample_timer)
else:
r = find_model_or_equivalence(result.current, formula, env,
s,
result.counterexample_timer)
result.counterexample_timer.check_time()
if r is None:
if not args.quiet:
print("formula matches!")
print(result.current)
# f = open("/tmp/out.fol", "w")
# f.write(str(sig))
# for m in result.models:
# f.write(str(m))
# f.close()
result.success = True
return result
with result.separation_timer:
ident = separator.add_model(r)
result.models.append(r)
if r.label.startswith("+"):
p_constraints.append(ident)
else:
n_constraints.append(ident)
if not args.quiet:
print("New model is:")
print(r)
print("Have new model, now have", len(result.models),
"models total")
if True:
c = separator.separate(pos=p_constraints,
neg=n_constraints,
imp=[],
max_clauses=args.max_clauses,
max_depth=args.max_depth,
timer=result.separation_timer,
matrix_timer=result.matrix_timer)
if c is None:
result.reason = "couldn't separate models under given restrictions"
break
if not args.quiet:
print("Learned new possible formula: ", c)
result.current = c
except TimeoutException:
result.reason = "timeout"
except RuntimeError as e:
print("Error:", e)
#raise e
result.reason = str(e)
return result
inames = " ".join( map(lambda _: get_new_var(prefix="i") ,range(0,quantity)) )
return z3.Ints(inames)
# Booleans
def newBool():
bname = get_new_var(prefix="b")
return z3.Bool(bname)
def newBools(quantity):
bnames = " ".join( map(lambda _: get_new_var(prefix="b") ,range(0,quantity)) )
return z3.Bools(bnames)
# Locations
Loc = z3.DeclareSort('Loc')
def newLoc():
lname = get_new_var(prefix="l")
return z3.Const(lname, Loc)
def newLocs(quantity):
lnames = " ".join( map(lambda _: get_new_var(prefix="l") ,range(0,quantity)) )
return z3.Consts(lnames, Loc)
# Destinations
Dest = z3.DeclareSort('Dest')
def newDest():
dname = get_new_var(prefix="d")
def __init__(self, name):
assert(isinstance(name, str))
super().__init__(z3.DeclareSort(name), QuantifiedSet)
import z3
Humain = z3.DeclareSort('Humain')
Socrate = z3.Const('Socrate', Humain)
is_Mortel = z3.Function('is_Mortel', Humain, z3.BoolSort())
is_Humain = z3.Function('is_Humain', Humain, z3.BoolSort())
s = z3.Solver()
x = z3.Const('x', Humain)
s.add(z3.ForAll(x, z3.Implies(is_Humain(x), is_Mortel(x))))
s.add(is_Humain(Socrate))
s.add(z3.Not(is_Mortel(Socrate)))
print(s.check())
print('-----')
z3.set_param(proof=True)
Humain = z3.DeclareSort('Humain')
Socrate = z3.Const('Socrate', Humain)
is_Mortel = z3.Function('is_Mortel', Humain, z3.BoolSort())
is_Humain = z3.Function('is_Humain', Humain, z3.BoolSort())
s = z3.Solver()
x, y, z = z3.Consts('x y z', Humain)
s.add(z3.ForAll(x, z3.Implies(is_Humain(x), is_Mortel(x))))
s.add(is_Humain(Socrate))
s.add(is_Mortel(Socrate))
print(s.check())
print(s.model())
