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)
