def testSubst(self): test_data = [ (STa, Tb), (STb, Ta), (TFun(STa, Tb), TFun(Tb, Tb)), (TFun(STa, STb), TFun(Tb, Ta)), (TConst("list", STa), TConst("list", Tb)), ] for T, res in test_data: self.assertEqual(T.subst(TyInst(a=Tb, b=Ta)), res)
def testReprType(self): test_data = [ (Ta, "TVar(a)"), (TConst("bool"), "TConst(bool, [])"), (TConst("list", Ta), "TConst(list, [TVar(a)])"), (TConst("tree", Ta, Tb), "TConst(tree, [TVar(a), TVar(b)])"), (TConst("fun", Ta, Tb), "TConst(fun, [TVar(a), TVar(b)])"), ] for T, repr_T in test_data: self.assertEqual(repr(T), repr_T)
def testParseType(self): test_data = [ ("(declare-sort utt$16 0)", TConst("utt$16")), ("(declare-fun x0 () Int)", Var("x0", IntType)), ("(declare-fun prt () Bool)", Var("prt", BoolType)), ("(declare-fun Concat_16_10_6 (utt$10 utt$6 ) utt$16)", Var("Concat_16_10_6", TFun(TConst("utt$10"), TConst("utt$6"), TConst("utt$16")))) ] for v, v_res in test_data: v = parse_type(v) self.assertEqual(v, v_res)
def testCheckTypeFail(self): test_data = [ TConst("bool", Ta), TConst("bool", Ta, Ta), TConst("fun"), TConst("fun", Ta), TConst("fun", Ta, Ta, Ta), TFun(TConst("bool", Ta), TConst("bool")), TFun(TConst("bool"), TConst("bool", Ta)), TConst("random") ] for T in test_data: self.assertRaises(TheoryException, theory.thy.check_type, T)
def testParseTypeInd(self): test_data = [ ("cons (x ::'a) (xs ::'a list)", { 'name': 'cons', 'type': [TVar('a'), TConst('list', TVar('a'))], 'args': ['x', 'xs'] }), ] basic.load_theory('list') for s, res in test_data: self.assertEqual(parser.parse_ind_constr(s), res)
def get_display(self): Targs = [TVar(arg) for arg in self.args] T = TConst(self.name, *Targs) constrs = [] for constr in self.constrs: argsT, _ = constr['type'].strip_type() res = pprint.N(constr['name']) for i, arg in enumerate(constr['args']): res += pprint.N(' (' + arg + ' :: ') + printer.print_type( argsT[i]) + pprint.N(')') constrs.append(res) return { 'ty': 'type.ind', 'type': printer.print_type(T), 'constrs': constrs if settings.highlight else '\n'.join(constrs) }
basic.load_theory('list') A = Var("A", BoolType) B = Var("B", BoolType) C = Var("C", BoolType) Ta = TVar("a") a = Var("a", Ta) b = Var("b", Ta) P = Var("P", TFun(Ta, BoolType)) Q = Var("Q", TFun(Ta, BoolType)) R = Var("R", TFun(Ta, Ta, BoolType)) nn = Var("n", TFun(BoolType, BoolType)) m = Var("m", NatType) n = Var("n", NatType) p = Var("p", NatType) xs = Var("xs", TConst("list", Ta)) ys = Var("ys", TConst("list", Ta)) zs = Var("zs", TConst("list", Ta)) mk_if = logic.mk_if class PrinterTest(unittest.TestCase): def testPrintLogical(self): test_data = [ # Variables (SVar("P", BoolType), "?P"), (a, "a"), # Equality and implies (Eq(a, b), "a = b"), (Implies(A, B), "A --> B"),
def ListType(T): return TConst("list", T)
def setT(T): return TConst("set", T)
# Author: Bohua Zhan from kernel.type import TFun, TConst, NatType from kernel.term import Term, Const, Binary from data.list import ListType, mk_literal_list, is_literal_list, dest_literal_list """Utility functions for characters and strings.""" charT = TConst("char") stringT = TConst("string") Char = Const("Char", TFun(NatType, charT)) String = Const("String", TFun(ListType(charT), stringT)) def mk_char(c): """Given a Python string of length 1, return the corresponding HOL character. """ assert isinstance( c, str) and len(c) == 1, "mk_char: expect a string of length 1" return Char(Binary(ord(c))) def mk_string(s): """Given a Python string, return the corresponding HOL string.""" assert isinstance(s, str), "mk_string: expect a string" return String(mk_literal_list([mk_char(c) for c in s], charT)) def is_char(t):
def type(self, *args): return TConst(str(args[-1]), *args[:-1])
# Author: Bohua Zhan """Utility functions for GCL (Guarded Command Language).""" from kernel.type import TFun, TConst, BoolType, NatType from kernel import term from kernel.term import Term, Const, Eq, Binary from logic import basic from logic import logic from data import function thy = basic.load_theory("gcl") varType = TConst("varType") Ident = Const("Ident", TFun(NatType, varType)) Para = Const("Para", TFun(varType, NatType, varType)) scalarValue = TConst("scalarValue") NatV = Const("NatV", TFun(NatType, scalarValue)) BoolV = Const("BoolV", TFun(BoolType, scalarValue)) stateT = TFun(varType, scalarValue) def convert_term(var_map, s, t): """Convert term t with given var_map and state s. Examples: given var_map {a: 0, b: 1}, where a is a function and b is a scalar. convert_term(var_map, s, b) = s (Ident 1) convert_term(var_map, s, a(i)) = s (Para (Ident 0) i)
def testPrintType(self): test_data = [ (Ta, "'a"), (TVar("ab"), "'ab"), (TConst("bool"), "bool"), (TConst("list", Ta), "'a list"), (TConst("list", TConst("list", Ta)), "'a list list"), (TConst("tree", Ta, Tb), "('a, 'b) tree"), (TFun(Ta, Tb), "'a => 'b"), (TFun(Ta, Tb, Tc), "'a => 'b => 'c"), (TFun(TFun(Ta, Tb), Tc), "('a => 'b) => 'c"), (TFun(TConst("list", Ta), Tb), "'a list => 'b"), (TFun(Ta, TConst("list", Tb)), "'a => 'b list"), (TConst("list", TFun(Ta, Tb)), "('a => 'b) list"), (TConst("list", TConst("list", TFun(Ta, Tb))), "('a => 'b) list list"), (TFun(TConst("list", Ta), TConst("list", Tb)), "'a list => 'b list"), (TConst("list", TFun(TConst("list", Ta), Tb)), "('a list => 'b) list"), ] for T, str_T in test_data: with global_setting(unicode=False): self.assertEqual(str(T), str_T)
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
def get_display(self): Targs = [TVar(arg) for arg in self.args] T = TConst(self.name, *Targs) return {'ty': 'type.ax', 'type': printer.print_type(T)}
def comT(T): return TConst("com", T)
from kernel.thm import Thm from kernel.macro import Macro from kernel.theory import register_macro from logic import logic from logic.logic import apply_theorem from logic.tactic import MacroTactic from data import nat from data import function from logic.conv import arg_conv from kernel.proofterm import ProofTerm from server.method import Method, register_method from syntax import pprint, settings """Automation for arithmetic expressions.""" aexpT = TConst("aexp") N = Const("N", TFun(NatType, aexpT)) V = Const("V", TFun(NatType, aexpT)) Plus = Const("Plus", TFun(aexpT, aexpT, aexpT)) Times = Const("Times", TFun(aexpT, aexpT, aexpT)) avalI = Const("avalI", TFun(TFun(NatType, NatType), aexpT, NatType, BoolType)) @register_macro('prove_avalI') class prove_avalI_macro(Macro): """Prove a theorem of the form avalI s t n.""" def __init__(self): self.level = 10 self.sig = Term
def netT(T): return TConst("net", T)