def apply_proof(self, decls, proof):
""" Apply a proof to a list of goals, producing subgoals, or None if
the proof fails. """
with ia.ASTContext(proof):
if len(decls) == 0:
return []
if isinstance(proof, ia.SchemaInstantiation):
m = self.match_schema(decls[0], proof)
return None if m is None else m + decls[1:]
elif isinstance(proof, ia.LetTactic):
return self.let_tactic(decls, proof)
elif isinstance(proof, ia.ComposeTactics):
return self.compose_proofs(decls, proof.args)
elif isinstance(proof, ia.AssumeTactic):
return self.assume_tactic(decls, proof)
elif isinstance(proof, ia.ShowGoalsTactic):
return self.show_goals_tactic(decls, proof)
elif isinstance(proof, ia.DeferGoalTactic):
return self.defer_goal_tactic(decls, proof)
elif isinstance(proof, ia.DeferGoalTactic):
return self.defer_goal_tactic(decls, proof)
elif isinstance(proof, ia.LetTactic):
return self.let_tactic(decls, proof)
elif isinstance(proof, ia.IfTactic):
return self.if_tactic(decls, proof)
elif isinstance(proof, ia.NullTactic):
return decls
elif isinstance(proof, ia.PropertyTactic):
return self.property_tactic(decls, proof)
assert False, "unknown proof type {}".format(type(proof))
def compile_defn(df):
has_consts = any(not isinstance(p, ivy_ast.Variable)
for p in df.args[0].args)
sig = ivy_logic.sig.copy() if has_consts else ivy_logic.sig
with ivy_ast.ASTContext(df):
with sig:
for p in df.args[0].args:
if not isinstance(p, ivy_ast.Variable):
compile_const(p, sig)
if isinstance(df.args[1], ivy_ast.SomeExpr):
ifval = df.args[1].if_value() or df.args[1].params()[0]
elseval = df.args[1].else_value() or ifval
eqn = ivy_ast.Forall(
df.args[1].params(),
ivy_ast.Atom(
'=', (df.args[0],
ivy_ast.Ite(df.args[1].fmla(), ifval, elseval))))
fmla = sortify_with_inference(eqn)
args = [list(fmla.variables)[0], fmla.body.args[1].args[0]]
if df.args[1].if_value():
args.append(fmla.body.args[1].args[1])
if df.args[1].else_value():
args.append(fmla.body.args[1].args[2])
df = ivy_logic.Definition(fmla.body.args[0],
ivy_logic.Some(*args))
else:
eqn = ivy_ast.Atom('=', (df.args[0], df.args[1]))
eqn = sortify_with_inference(eqn)
df = ivy_logic.Definition(eqn.args[0], eqn.args[1])
return df
def compile_expr_vocab(expr,vocab):
with il.WithSymbols(vocab.symbols):
with il.WithSorts(vocab.sorts):
if isinstance(expr,ia.Atom) and expr.rep in il.sig.sorts:
return il.sig.sorts[expr.rep]
with il.top_sort_as_default():
with ia.ASTContext(expr):
expr = il.sort_infer_list([expr.compile()] + vocab.variables)[0]
return expr
