import ivy_actions as act
import ivy_utils as utl
import ivy_logic_utils as lut
import tk_ui as ui
import ivy_logic as lg
import ivy_utils as iu
import ivy_module as im
import ivy_alpha
import ivy_art
import ivy_interp
import ivy_compiler
import ivy_isolate
import sys
diagnose = iu.BooleanParameter("diagnose", False)
def usage():
print "usage: \n {} file.ivy".format(sys.argv[0])
sys.exit(1)
def check_module():
# If user specifies an isolate, check it. Else, if any isolates
# are specificied in the file, check all, else check globally.
isolate = ivy_compiler.isolate.get()
with im.module.copy():
ivy_isolate.create_isolate(isolate) # ,ext='ext'
self.public_actions = set()
self.initializers = [] # list of name,action pairs
self.sig
"""
from collections import defaultdict
from itertools import chain
from ivy_printer import print_module
from ivy_actions import (AssignAction, Sequence, ChoiceAction, AssumeAction,
AssertAction, HavocAction, concat_actions)
import logic as lg
import ivy_logic_utils as ilu
import ivy_utils as iu
debug = iu.BooleanParameter("l2s_debug", False)
def forall(vs, body):
return lg.ForAll(vs, body) if len(vs) > 0 else body
def l2s(mod, lf):
# modify mod in place
# module pass helper funciton
def mod_pass(transform):
mod.labeled_conjs = [transform(x) for x in mod.labeled_conjs]
# TODO: what about axioms and properties?
for a in mod.public_actions:
import ivy_art
import ivy_interp
import ivy_compiler
import ivy_isolate
import ivy_ast
import ivy_theory as ith
import ivy_transrel as itr
import ivy_solver as islv
import ivy_fragment as ifc
import ivy_proof
import ivy_trace
import sys
from collections import defaultdict
diagnose = iu.BooleanParameter("diagnose", False)
coverage = iu.BooleanParameter("coverage", True)
checked_action = iu.Parameter("action", "")
opt_trusted = iu.BooleanParameter("trusted", False)
opt_mc = iu.BooleanParameter("mc", False)
opt_trace = iu.BooleanParameter("trace", False)
opt_separate = iu.BooleanParameter("separate", None)
def display_cex(msg, ag):
if diagnose.get():
import tk_ui as ui
iu.set_parameters({'mode': 'induction'})
ui.ui_main_loop(ag)
exit(1)
raise iu.IvyError(None, msg)
import ivy_actions as act
import ivy_utils as utl
import ivy_logic_utils as lut
import ivy_logic as lg
import ivy_utils as iu
import ivy_module as im
import ivy_alpha
import ivy_art
import ivy_interp
import ivy_compiler
import ivy_isolate
import ivy_ast
import sys
diagnose = iu.BooleanParameter("diagnose", False)
coverage = iu.BooleanParameter("coverage", True)
checked_action = iu.Parameter("action", "")
opt_trusted = iu.BooleanParameter("trusted", False)
def display_cex(msg, ag):
if diagnose.get():
import tk_ui as ui
iu.set_parameters({'mode': 'induction'})
ui.ui_main_loop(ag)
exit(1)
raise iu.IvyError(None, msg)
def check_properties():
# information on why a property is false.
class Counterexample(object):
def __init__(self, clauses, state, conc, msg):
self.clauses, self.state, self.msg, self.conc = clauses, state, msg, conc
def __nonzero__(self):
return False
########################################
#
# option to abstract the initial state
option_abs_init = iu.BooleanParameter("abs_init", False)
########################################
#
# The class of ARG's
class AnalysisGraph(object):
def __init__(self, module=None, pvars=[], initializer=None):
if module == None:
module = im.module # use the current module if not specified
self.domain = module
self.states = []
self.transitions = [] # TODO: redundant, remove
self.covering = []
self.pvars = pvars # TODO: remove this field
import ivy_dafny_compiler as dc
import ivy_solver as slv
import ivy_logic_utils as lu
import string
import ivy_ast
import ivy_utils as iu
import ivy_actions as ia
import ivy_alpha
import ivy_module as im
import ivy_theory as ith
import ivy_concept_space as ics
from ivy_ast import ASTContext
from collections import defaultdict
import ivy_printer
show_compiled = iu.BooleanParameter("show_compiled", False)
cone_of_influence = iu.BooleanParameter("coi", True)
filter_symbols = iu.BooleanParameter("filter_symbols", True)
create_imports = iu.BooleanParameter("create_imports", False)
enforce_axioms = iu.BooleanParameter("enforce_axioms", False)
def lookup_action(ast, mod, name):
if name not in mod.actions:
raise iu.IvyError(ast, "action {} undefined".format(name))
return mod.actions[name]
def add_mixins(mod,
actname,
action2,
import ivy_actions as act
import ivy_utils as utl
import ivy_logic_utils as lut
import tk_ui as ui
import ivy_logic as lg
import ivy_utils as iu
import ivy_module as im
import ivy_alpha
import ivy_art
import ivy_interp
import ivy_compiler
import ivy_isolate
import sys
diagnose = iu.BooleanParameter("diagnose", False)
coverage = iu.BooleanParameter("coverage", True)
def display_cex(msg, ag):
if diagnose.get():
ui.ui_main_loop(ag)
exit(1)
raise iu.IvyError(None, msg)
def check_properties():
if itp.false_properties():
if diagnose.get():
print "Some properties failed."
gui = ui.new_ui()
import ivy_logic
import ivy_dafny_compiler as dc
import ivy_solver as slv
import ivy_logic_utils as lu
import string
import ivy_ast
import ivy_utils as iu
import ivy_actions as ia
import ivy_alpha
import ivy_module as im
import ivy_theory as ith
import ivy_concept_space as ics
from ivy_ast import ASTContext
from collections import defaultdict
show_compiled = iu.BooleanParameter("show_compiled",False)
def lookup_action(ast,mod,name):
if name not in mod.actions:
raise iu.IvyError(ast,"action {} undefined".format(name))
return mod.actions[name]
def add_mixins(mod,actname,action2,assert_to_assume=lambda m:False,use_mixin=lambda:True,mod_mixin=lambda m:m):
# TODO: mixins need to be in a fixed order
assert hasattr(action2,'lineno'), action2
assert hasattr(action2,'formal_params'), action2
res = action2
for mixin in mod.mixins[actname]:
mixin_name = mixin.args[0].relname
action1 = lookup_action(mixin,mod,mixin_name)
assert hasattr(action1,'lineno')
import ivy_utils as iu
# <TODO> No such assumption as universe cannot be empty
# <TODO> support for enumerated sort
# <TODO> dictionary mapping Var to its assigned number
# <TODO> action Clause for positive sample is different from Neg sample
module = None
featureset = []
numVarFS = {
} # number of Variables(quant.) of each sort in feature set (invariant: equal to max number of quantified Var that could be present in CandInv)
numVarInv = {
} # number of variables of each sort in learned as well as previous invariant. Used for determining instance size
candInv = true_clauses()
coincide = false_clauses()
silent = False # if True then silent the print statement in sat checker (ivy backend)
enum = iu.BooleanParameter("enum", False)
'''
:returns a tuple containing universe and pure state.
pure state is again a tuple with 2nd element a clause repr that state
'''
def sampleUtil(mod, preclause, fcs, actname):
'''
a sample created by using z3 which satsfies preclauses and final condition(fcs) where transtion
function is obtained from action corresponding to actname
'''
action = mod.actions[actname]
ag = ivy_art.AnalysisGraph()
pre = itp.State()
pre.clauses = preclause
