def update_conjs(self):
mod = self
for i, cax in enumerate(mod.labeled_conjs):
fmla = cax.formula
csname = 'conjecture:' + str(i)
variables = list(lu.used_variables_ast(fmla))
sort = il.RelationSort([v.sort for v in variables])
sym = il.Symbol(csname, sort)
space = ics.NamedSpace(il.Literal(0, fmla))
mod.concept_spaces.append((sym(*variables), space))
def conjecture(self, ax):
fmla = sortify_with_inference(ax)
try:
self.domain.conjs.append(formula_to_clauses(fmla))
except ValueError:
raise IvyError(ax, "conjecture must be a clause")
# Make a conecpt space from the conjecture
csname = 'conjecture:' + str(len(self.domain.conjs))
variables = list(lu.used_variables_ast(fmla))
sort = ivy_logic.RelationSort([v.sort for v in variables])
sym = ivy_logic.Symbol(csname, sort)
space = NamedSpace(ivy_logic.Literal(0, fmla))
self.domain.concept_spaces.append((sym(*variables), space))
def function_model_to_clauses(h,f):
sort = f.sort
rng = sort.rng
res = []
fterm = fun_inst(f)
if isinstance(rng,ivy_logic.EnumeratedSort) and not use_z3_enums:
for c in rng.defines():
eq = ivy_logic._eq_lit(fterm,ivy_logic.Constant(ivy_logic.Symbol(c,rng)))
# print "function_model_to_clauses: {}".format(eq)
get_lit_facts(h,eq,res)
# non-enumerated function types
else:
lit = ivy_logic.Literal(1,fun_eq_inst(f))
get_lit_facts(h,lit,res)
# print "fun facts: {}".format([str(r) for r in res])
return res
def relation_model_to_clauses(h, r, n):
lit = ivy_logic.Literal(1, rel_inst(r))
res = []
get_lit_facts(h, lit, res)
get_lit_facts(h, ~lit, res)
return res
def eval(self, fmla):
""" Evaluate a formula in the model. Variables are interpreted universally. """
vs, tups = self.check(ivy_logic.Literal(0, fmla))
return not tups
def create_isolate(iso, mod=None, **kwargs):
mod = mod or im.module
# treat initializers as exports
after_inits = mod.mixins["init"]
del mod.mixins["init"]
mod.exports.extend(
ivy_ast.ExportDef(ivy_ast.Atom(a.mixer()), ivy_ast.Atom(''))
for a in after_inits)
# check all mixin declarations
for name, mixins in mod.mixins.iteritems():
for mixin in mixins:
with ASTContext(mixins):
action1, action2 = (lookup_action(mixin, mod, a.relname)
for a in mixin.args)
# check all the delagate declarations
for dl in mod.delegates:
lookup_action(dl.args[0], mod, dl.delegated())
if dl.delegee() and dl.delegee() not in mod.hierarchy:
raise iu.IvyError(dl.args[1],
"{} is not a module instance".format(name))
# check all the export declarations
for exp in mod.exports:
expname = exp.args[0].rep
if expname not in mod.actions:
raise iu.IvyError(exp, "undefined action: {}".format(expname))
# create the import actions, if requested
extra_with = []
extra_strip = {}
if create_imports.get():
newimps = []
for imp in mod.imports:
if imp.args[1].rep == '':
impname = imp.args[0].rep
if impname not in mod.actions:
raise iu.IvyError(imp,
"undefined action: {}".format(impname))
action = mod.actions[impname]
if not (type(action) == ia.Sequence and not action.args):
raise iu.IvyError(
imp,
"cannot import implemented action: {}".format(impname))
extname = 'imp__' + impname
call = ia.CallAction(
*([ivy_ast.Atom(extname, action.formal_params)] +
action.formal_returns))
call.formal_params = action.formal_params
call.formal_returns = action.formal_returns
call.lineno = action.lineno
mod.actions[impname] = call
mod.actions[extname] = action
newimps.append(
ivy_ast.ImportDef(ivy_ast.Atom(extname), imp.args[1]))
extra_with.append(ivy_ast.Atom(impname))
# extra_with.append(ivy_ast.Atom(extname))
if iso and iso in mod.isolates:
ps = mod.isolates[iso].params()
extra_strip[impname] = [a.rep for a in ps]
extra_strip[extname] = [a.rep for a in ps]
else:
newimps.append(imp)
mod.imports = newimps
mixers = set()
for ms in mod.mixins.values():
for m in ms:
mixers.add(m.mixer())
# Determine the mixin order (as a side effect on module.mixins)
get_mixin_order(iso, mod)
# Construct an isolate
if iso:
isolate_component(mod,
iso,
extra_with=extra_with,
extra_strip=extra_strip)
else:
if mod.isolates and cone_of_influence.get():
raise iu.IvyError(None, 'no isolate specified on command line')
# apply all the mixins in no particular order
for name, mixins in mod.mixins.iteritems():
for mixin in mixins:
action1, action2 = (lookup_action(mixin, mod, a.relname)
for a in mixin.args)
mixed = ia.apply_mixin(mixin, action1, action2)
mod.actions[mixin.args[1].relname] = mixed
# find the globally exported actions (all if none specified, for compat)
if mod.exports:
mod.public_actions.clear()
for e in mod.exports:
if not e.scope(): # global export
mod.public_actions.add(e.exported())
else:
for a in mod.actions:
mod.public_actions.add(a)
# Create one big external action if requested
for name in mod.public_actions:
mod.actions[name].label = name
ext = kwargs['ext'] if 'ext' in kwargs else ext_action.get()
if ext is not None:
ext_acts = [mod.actions[x] for x in sorted(mod.public_actions)]
ext_act = ia.EnvAction(*ext_acts)
mod.public_actions.add(ext)
mod.actions[ext] = ext_act
# Check native interpretations of symbols
slv.check_compat()
# Make concept spaces from the conjecture
for i, cax in enumerate(mod.labeled_conjs):
fmla = cax.formula
csname = 'conjecture:' + str(i)
variables = list(lu.used_variables_ast(fmla))
sort = ivy_logic.RelationSort([v.sort for v in variables])
sym = ivy_logic.Symbol(csname, sort)
space = ics.NamedSpace(ivy_logic.Literal(0, fmla))
mod.concept_spaces.append((sym(*variables), space))
ith.check_theory()
# get rid of useless actions
cone = get_mod_cone(mod)
if cone_of_influence.get():
for a in list(mod.actions):
if a not in cone:
del mod.actions[a]
else:
for a in list(mod.actions):
if a not in cone and not a.startswith('ext:') and a not in mixers:
ea = 'ext:' + a
if ea in mod.actions and ea not in cone:
if ia.has_code(mod.actions[a]):
iu.warn(mod.actions[a],
"action {} is never called".format(a))
fix_initializers(mod, after_inits)
# show the compiled code if requested
if show_compiled.get():
ivy_printer.print_module(mod)
def create_isolate(iso,mod = None,**kwargs):
mod = mod or im.module
# check all mixin declarations
for name,mixins in mod.mixins.iteritems():
for mixin in mixins:
with ASTContext(mixins):
action1,action2 = (lookup_action(mixin,mod,a.relname) for a in mixin.args)
# check all the delagate declarations
for dl in mod.delegates:
lookup_action(dl.args[0],mod,dl.delegated())
if dl.delegee() and dl.delegee() not in mod.hierarchy:
raise iu.IvyError(dl.args[1],"{} is not a module instance".format(name))
# Determine the mixin order (as a side effect on module.mixins)
get_mixin_order(iso,mod)
# Construct an isolate
if iso:
isolate_component(mod,iso)
else:
if mod.isolates:
raise iu.IvyError(None,'no isolate specified on command line')
# apply all the mixins in no particular order
for name,mixins in mod.mixins.iteritems():
for mixin in mixins:
action1,action2 = (lookup_action(mixin,mod,a.relname) for a in mixin.args)
mixed = ia.apply_mixin(mixin,action1,action2)
mod.actions[mixin.args[1].relname] = mixed
# find the globally exported actions (all if none specified, for compat)
if mod.exports:
mod.public_actions.clear()
for e in mod.exports:
if not e.scope(): # global export
mod.public_actions.add(e.exported())
else:
for a in mod.actions:
mod.public_actions.add(a)
# Create one big external action if requested
ext = kwargs['ext'] if 'ext' in kwargs else ext_action.get()
if ext is not None:
ext_acts = [mod.actions[x] for x in sorted(mod.public_actions)]
ext_act = ia.EnvAction(*ext_acts)
mod.public_actions.add(ext);
mod.actions[ext] = ext_act;
# Check native interpretations of symbols
slv.check_compat()
# Make concept spaces from the conjecture
for i,cax in enumerate(mod.labeled_conjs):
fmla = cax.formula
csname = 'conjecture:'+ str(i)
variables = list(lu.used_variables_ast(fmla))
sort = ivy_logic.RelationSort([v.sort for v in variables])
sym = ivy_logic.Symbol(csname,sort)
space = ics.NamedSpace(ivy_logic.Literal(0,fmla))
mod.concept_spaces.append((sym(*variables),space))
ith.check_theory()
if show_compiled.get():
for x,y in mod.actions.iteritems():
print iu.pretty("action {} = {}".format(x,y))
