def get_extension(self):
assert self.error is None, "get_extension"
res = []
res.append(
extension.Constant(self.name, self.type, ref_name=self.cname))
for rule in self.rules:
res.append(extension.Theorem(rule['name'], Thm([], rule['prop'])))
res.append(extension.Attribute(rule['name'], 'hint_backward'))
# Case rule
Targs, _ = self.type.strip_type()
vars = []
for i, Targ in enumerate(Targs):
vars.append(Var("_a" + str(i + 1), Targ))
P = Var("P", BoolType)
pred = Const(self.name, self.type)
assum0 = pred(*vars)
assums = []
for rule in self.rules:
prop = rule['prop']
As, C = prop.strip_implies()
eq_assums = [Eq(var, arg) for var, arg in zip(vars, C.args)]
assum = Implies(*(eq_assums + As), P)
for var in reversed(prop.get_vars()):
assum = Forall(var, assum)
assums.append(assum)
prop = Implies(*([assum0] + assums + [P]))
res.append(extension.Theorem(self.cname + "_cases", Thm([], prop)))
return res
def testUncheckedExtend(self):
"""Unchecked extension."""
id_const = Const("id", TFun(Ta,Ta))
id_def = Abs("x", Ta, Bound(0))
exts = [
extension.Constant("id", TFun(Ta, Ta)),
extension.Theorem("id_def", Thm([], Eq(id_const, id_def))),
extension.Theorem("id.simps", Thm([], Eq(id_const, x)))
]
self.assertEqual(theory.thy.unchecked_extend(exts), None)
self.assertEqual(theory.thy.get_term_sig("id"), TFun(Ta, Ta))
self.assertEqual(theory.get_theorem("id_def", svar=False), Thm([], Eq(id_const, id_def)))
self.assertEqual(theory.get_theorem("id.simps", svar=False), Thm([], Eq(id_const, x)))
def get_extension(self):
assert self.error is None, "get_extension"
res = []
res.append(extension.Theorem(self.name, Thm([], self.prop)))
for attr in self.attributes:
res.append(extension.Attribute(self.name, attr))
return res
def testCheckedExtend(self):
"""Checked extension: adding an axiom."""
id_simps = Eq(Comb(Const("id", TFun(Ta,Ta)), x), x)
exts = [extension.Theorem("id.simps", Thm([], id_simps))]
ext_report = theory.thy.checked_extend(exts)
self.assertEqual(theory.get_theorem("id.simps", svar=False), Thm([], id_simps))
self.assertEqual(ext_report.get_axioms(), [("id.simps", Thm([], id_simps))])
def get_extension(self):
assert self.error is None, "get_extension"
res = []
res.append(
extension.Constant(self.name, self.type, ref_name=self.cname))
res.append(extension.Theorem(self.cname + "_def", Thm([], self.prop)))
for attr in self.attributes:
res.append(extension.Attribute(self.cname + "_def", attr))
return res
def get_extension(self):
assert self.error is None, "get_extension"
res = []
res.append(
extension.Constant(self.name, self.type, ref_name=self.cname))
for i, rule in enumerate(self.rules):
th_name = self.cname + "_def_" + str(i + 1)
res.append(extension.Theorem(th_name, Thm([], rule['prop'])))
res.append(extension.Attribute(th_name, "hint_rewrite"))
return res
def add_invariant(self):
"""Add the invariant for the system in GCL."""
s = Var("s", gcl.stateT)
invC = Const("inv", TFun(gcl.stateT, BoolType))
inv_rhs = And(
*[gcl.convert_term(self.var_map, s, t) for _, t in self.invs])
prop = Eq(invC(s), inv_rhs)
exts = [
extension.Constant("inv", TFun(gcl.stateT, BoolType)),
extension.Theorem("inv_def", Thm([], prop))
]
theory.thy.unchecked_extend(exts)
def add_invariant(self):
"""Add the invariant for the system in GCL."""
s = Var("s", gcl.stateT)
invC = Const("inv", TFun(gcl.stateT, boolT))
inv_rhs = logic.mk_conj(
*[gcl.convert_term(self.var_map, s, t) for _, t in self.invs])
prop = Term.mk_equals(invC(s), inv_rhs)
exts = extension.TheoryExtension()
exts.add_extension(extension.AxConstant("inv", TFun(gcl.stateT,
boolT)))
exts.add_extension(extension.Theorem("inv_def", Thm([], prop)))
self.thy.unchecked_extend(exts)
def testCheckedExtend2(self):
"""Checked extension: proved theorem."""
id_const = Const("id", TFun(Ta,Ta))
id_def = Abs("x", Ta, Bound(0))
id_simps = Eq(id_const(x), x)
# Proof of |- id x = x from |- id = (%x. x)
prf = Proof()
prf.add_item(0, "theorem", args="id_def") # id = (%x. x)
prf.add_item(1, "subst_type", args=TyInst(a=TVar('a')), prevs=[0]) # id = (%x. x)
prf.add_item(2, "reflexive", args=x) # x = x
prf.add_item(3, "combination", prevs=[1, 2]) # id x = (%x. x) x
prf.add_item(4, "beta_conv", args=id_def(x)) # (%x. x) x = x
prf.add_item(5, "transitive", prevs=[3, 4]) # id x = x
exts = [
extension.Constant("id", TFun(Ta, Ta)),
extension.Theorem("id_def", Thm([], Eq(id_const, id_def))),
extension.Theorem("id.simps", Thm([], id_simps), prf)
]
ext_report = theory.thy.checked_extend(exts)
self.assertEqual(theory.get_theorem("id.simps", svar=False), Thm([], id_simps))
self.assertEqual(ext_report.get_axioms(), [('id_def', Thm([], Eq(id_const, id_def)))])
def parse_extension(thy, data):
"""Parse an extension in json format. Returns the resulting
extension as well as applying it to thy.
"""
ext = None
if data['ty'] == 'type.ax':
ext = extension.TheoryExtension()
ext.add_extension(extension.AxType(data['name'], len(data['args'])))
elif data['ty'] == 'def.ax':
T = parse_type(thy, data['type'])
ext = extension.TheoryExtension()
ext.add_extension(extension.AxConstant(data['name'], T))
elif data['ty'] == 'def':
T = parse_type(thy, data['type'])
thy.add_term_sig(data['name'], T) # Add this first, for parsing later.
ctxt = parse_vars(thy, data['vars'])
prop = parse_term(thy, ctxt, data['prop'])
ext = extension.TheoryExtension()
ext.add_extension(extension.AxConstant(data['name'], T))
ext.add_extension(
extension.Theorem(data['name'] + "_def", Thm([], prop)))
ext.add_extension(
extension.Attribute(data['name'] + "_def", 'hint_rewrite'))
elif data['ty'] == 'thm' or data['ty'] == 'thm.ax':
ctxt = parse_vars(thy, data['vars'])
prop = parse_term(thy, ctxt, data['prop'])
ext = extension.TheoryExtension()
ext.add_extension(extension.Theorem(data['name'], Thm([], prop)))
if 'hint_backward' in data and data['hint_backward'] == "true":
ext.add_extension(
extension.Attribute(data['name'], 'hint_backward'))
if 'hint_rewrite' in data and data['hint_rewrite'] == "true":
ext.add_extension(extension.Attribute(data['name'],
'hint_rewrite'))
if 'hint_forward' in data and data['hint_forward'] == 'true':
ext.add_extension(extension.Attribute(data['name'],
'hint_forward'))
elif data['ty'] == 'type.ind':
constrs = []
for constr in data['constrs']:
T = parse_type(thy, constr['type'])
constrs.append((constr['name'], T, constr['args']))
ext = induct.add_induct_type(data['name'], data['args'], constrs)
elif data['ty'] == 'def.ind':
T = parse_type(thy, data['type'])
thy.add_term_sig(data['name'], T) # Add this first, for parsing later.
rules = []
for rule in data['rules']:
ctxt = parse_vars(thy, rule['vars'])
prop = parse_term(thy, ctxt, rule['prop'])
rules.append(prop)
ext = induct.add_induct_def(data['name'], T, rules)
elif data['ty'] == 'def.pred':
T = parse_type(thy, data['type'])
thy.add_term_sig(data['name'], T) # Add this first, for parsing later.
rules = []
for rule in data['rules']:
ctxt = parse_vars(thy, rule['vars'])
prop = parse_term(thy, ctxt, rule['prop'])
rules.append((rule['name'], prop))
ext = induct.add_induct_predicate(data['name'], T, rules)
elif data['ty'] == 'macro':
ext = extension.TheoryExtension()
ext.add_extension(extension.Macro(data['name']))
elif data['ty'] == 'method':
ext = extension.TheoryExtension()
ext.add_extension(extension.Method(data['name']))
if ext:
thy.unchecked_extend(ext)
return None
def get_extension(self):
assert self.error is None, "get_extension"
res = []
# Add to type and term signature.
res.append(extension.TConst(self.name, len(self.args)))
for constr in self.constrs:
res.append(
extension.Constant(constr['name'],
constr['type'],
ref_name=constr['cname']))
# Add non-equality theorems.
for constr1, constr2 in itertools.combinations(self.constrs, 2):
# For each A x_1 ... x_m and B y_1 ... y_n, get the theorem
# ~ A x_1 ... x_m = B y_1 ... y_n.
argT1, _ = constr1['type'].strip_type()
argT2, _ = constr2['type'].strip_type()
lhs_vars = [Var(nm, T) for nm, T in zip(constr1['args'], argT1)]
rhs_vars = [Var(nm, T) for nm, T in zip(constr2['args'], argT2)]
A = Const(constr1['name'], constr1['type'])
B = Const(constr2['name'], constr2['type'])
lhs = A(*lhs_vars)
rhs = B(*rhs_vars)
neq = Not(Eq(lhs, rhs))
th_name = "%s_%s_%s_neq" % (self.name, constr1['name'],
constr2['name'])
res.append(extension.Theorem(th_name, Thm([], neq)))
# Add injectivity theorems.
for constr in self.constrs:
# For each A x_1 ... x_m with m > 0, get the theorem
# A x_1 ... x_m = A x_1' ... x_m' --> x_1 = x_1' & ... & x_m = x_m'
if constr['args']:
argT, _ = constr['type'].strip_type()
lhs_vars = [Var(nm, T) for nm, T in zip(constr['args'], argT)]
rhs_vars = [
Var(nm + "1", T) for nm, T in zip(constr['args'], argT)
]
A = Const(constr['name'], constr['type'])
assum = Eq(A(*lhs_vars), A(*rhs_vars))
concls = [
Eq(var1, var2) for var1, var2 in zip(lhs_vars, rhs_vars)
]
concl = And(*concls)
th_name = "%s_%s_inject" % (self.name, constr['name'])
res.append(
extension.Theorem(th_name, Thm([], Implies(assum, concl))))
# Add the inductive theorem.
tvars = [TVar(targ) for targ in self.args]
T = TConst(self.name, *tvars)
var_P = Var("P", TFun(T, BoolType))
ind_assums = []
for constr in self.constrs:
A = Const(constr['name'], constr['type'])
argT, _ = constr['type'].strip_type()
args = [Var(nm, T2) for nm, T2 in zip(constr['args'], argT)]
C = var_P(A(*args))
As = [
var_P(Var(nm, T2)) for nm, T2 in zip(constr['args'], argT)
if T2 == T
]
ind_assum = Implies(*(As + [C]))
for arg in reversed(args):
ind_assum = Forall(arg, ind_assum)
ind_assums.append(ind_assum)
ind_concl = var_P(Var("x", T))
th_name = self.name + "_induct"
res.append(
extension.Theorem(th_name,
Thm([], Implies(*(ind_assums + [ind_concl])))))
res.append(extension.Attribute(th_name, "var_induct"))
return res
