def output_hint(state, step):
method = global_methods[step['method_name']]
res = method.display_step(state, step)
if '_goal' in step:
if step['_goal']:
goals = [printer.print_term(t) for t in step['_goal']]
res += pprint.KWRed(" goal ") + printer.commas_join(goals)
else:
res += pprint.KWGreen(" (solves)")
if '_fact' in step and len(step['_fact']) > 0:
facts = [printer.print_term(t) for t in step['_fact']]
res += pprint.KWGreen(" fact ") + printer.commas_join(facts)
return res
def testPrintSet(self):
A = Var("A", set.setT(Ta))
B = Var("B", set.setT(Ta))
x = Var("x", Ta)
test_data = [
(set.empty_set(Ta), "({}::'a set)", "(∅::'a set)"),
(set.mk_mem(x, A), "x MEM A", "x ∈ A"),
(set.mk_subset(A, B), "A SUB B", "A ⊆ B"),
(set.mk_inter(A, B), "A INTER B", "A ∩ B"),
(set.mk_union(A, B), "A UNION B", "A ∪ B"),
]
for t, s1, s2 in test_data:
self.assertEqual(printer.print_term(thy, t), s1)
self.assertEqual(printer.print_term(thy, t, unicode=True), s2)
def display_term(t):
"""Display parsed term."""
res = printer.print_term(t)
if not settings.highlight and settings.line_length is not None:
return '\n'.join(res)
else:
return res
def testParseUnicode(self):
test_data = [
("A ∧ B", "A & B"),
("A ∨ B", "A | B"),
("A ⟶ B ⟶ C", "A --> B --> C"),
("A ∧ B | C", "A & B | C"),
("¬A", "~A"),
("λx::'a. x", "%x::'a. x"),
("∀x::'a. P x", "!x. P x"),
("∃x::'a. P x", "?x. P x"),
("∀x::'a. P x ∧ Q x", "!x. P x & Q x"),
("(∀x::'a. P x) & Q y", "(!x. P x) & Q y"),
]
context.set_context('logic_base',
vars={
'A': 'bool',
'B': 'bool',
'C': 'bool',
'P': "'a => bool",
'Q': "'a => bool"
})
for s, ascii_s in test_data:
t = parser.parse_term(s)
self.assertIsInstance(t, Term)
with global_setting(unicode=False):
self.assertEqual(print_term(t), ascii_s)
def export_term(t):
"""Function for printing a term for export to json."""
with global_setting(unicode=True, line_length=80):
res = printer.print_term(t)
if len(res) == 1:
res = res[0]
return res
def run_test(self, thy_name, *, vars=None, svars=None, s, Ts):
context.set_context(thy_name, vars=vars, svars=svars)
t = parser.parse_term(s)
T = parser.parse_type(Ts)
self.assertIsInstance(t, Term)
self.assertEqual(t.checked_get_type(), T)
# with global_setting(unicode=False):
self.assertEqual(print_term(t), s)
def testPrintWithType(self):
test_data = [
(list.nil(Ta), "([]::'a list)"),
(eq(list.nil(Ta), list.nil(Ta)), "([]::'a list) = []"),
(all(a, eq(a, a)), "!a::'a. a = a"),
]
for t, s in test_data:
self.assertEqual(printer.print_term(thy, t), s)
def testPrintFunction(self):
test_data = [
(function.mk_fun_upd(f, a, b), "(f)(a := b)"),
(function.mk_fun_upd(f, a, b, b, a), "(f)(a := b, b := a)"),
]
thy = basic.load_theory('function')
for t, s in test_data:
self.assertEqual(printer.print_term(thy, t), s)
def testPrintString(self):
test_data = [
(string.mk_char('c'), "'c'"),
(string.mk_string("ab"), '"ab"'),
]
basic.load_theory('string')
for t, s in test_data:
self.assertEqual(printer.print_term(t), s)
def testInferType2(self):
thy = basic.load_theory('function')
test_data = [("(%x. 0)(1 := 7)", "nat => nat")]
for s, Ts in test_data:
t = parser.parse_term(thy, ctxt, s)
T = parser.parse_type(thy, Ts)
self.assertIsInstance(t, Term)
self.assertEqual(t.checked_get_type(), T)
self.assertEqual(print_term(thy, t), s)
def testBinary(self):
test_data = [
(nat.one, "1"),
(nat.bit0(nat.one), "2"),
(nat.bit1(nat.one), "3"),
(nat.Suc(nat.one), "Suc 1"),
]
for t, s in test_data:
self.assertEqual(printer.print_term(thy, t), s)
def testPrintWithType(self):
test_data = [
(list.nil(Ta), "([]::'a list)"),
(Eq(list.nil(Ta), list.nil(Ta)), "([]::'a list) = []"),
(Forall(a, Eq(a, a)), "!a::'a. a = a"),
]
with global_setting(unicode=False):
for t, s in test_data:
self.assertEqual(printer.print_term(t), s)
def print_extension(thy, ext):
"""Print given extension."""
if isinstance(ext, AxType):
return "Type " + ext.name
elif isinstance(ext, AxConstant):
return "Constant " + ext.name + " :: " + printer.print_type(
thy, ext.T, unicode=True)
elif isinstance(ext, Theorem):
return "Theorem " + ext.name + ": " + printer.print_term(
thy, ext.th.prop, unicode=True)
def __str__(self):
res = "Variables: " + ", ".join(v.name for v in self.vars) + "\n"
res += "States: " + ", ".join(v.name for v in self.states) + "\n"
res += "Number of rules: %d\n" % len(self.rules)
for i, rule in enumerate(self.rules):
_, guard, assigns = rule
assigns_str = ", ".join("%s := %s" % (str(k), str(v))
for k, v in assigns.items())
res += "%d: [%s] %s" % (i, printer.print_term(
self.thy, guard), assigns_str) + "\n"
res += "Number of invariants: %d\n" % len(self.invs)
for i, inv in enumerate(self.invs):
_, inv_term = inv
res += "%d: %s" % (i, printer.print_term(self.thy,
inv_term)) + "\n"
return res
def testPrintInterval(self):
m = Var("m", NatType)
n = Var("n", NatType)
test_data = [
(interval.mk_interval(m, n), "{m..n}"),
(interval.mk_interval(nat.one, m), "{1..m}"),
]
basic.load_theory('iterate')
for t, s in test_data:
self.assertEqual(printer.print_term(t), s)
def testPrintBinary(self):
m = Var("m", NatType)
test_data = [
(nat.one, "(1::nat)"),
(Nat(2), "(2::nat)"),
(Nat(3), "(3::nat)"),
(m + 1, "m + 1"),
]
for t, s in test_data:
self.assertEqual(printer.print_term(t), s)
def testPrintFunction(self):
test_data = [
(P(a), "P a"),
(P(f(a)), "P (f a)"),
(R(a,a), "R a a"),
(nn(conj(A,B)), "n (A & B)"),
(conj(nn(A), B), "n A & B"),
]
for t, s in test_data:
self.assertEqual(printer.print_term(thy, t), s)
def testPrintComb(self):
f = Var("f", TFun(Ta, Ta))
test_data = [
(P(a), "P a"),
(P(f(a)), "P (f a)"),
(R(a, a), "R a a"),
(nn(And(A, B)), "n (A & B)"),
(And(nn(A), B), "n A & B"),
]
with global_setting(unicode=False):
for t, s in test_data:
self.assertEqual(printer.print_term(t), s)
def testParseFunction(self):
thy = basic.load_theory('function')
test_data = [
("(f)(a := b)", "'a => 'a"),
("(f)(a := b, b := a)", "'a => 'a"),
]
for s, Ts in test_data:
t = parser.parse_term(thy, ctxt, s)
T = parser.parse_type(thy, Ts)
self.assertIsInstance(t, Term)
self.assertEqual(t.checked_get_type(), T)
self.assertEqual(print_term(thy, t), s)
def testParseTypedTerm(self):
test_data = [
("([]::'a list)", "'a list"),
("([]::nat list)", "nat list"),
("([]::'a list) = []", "bool"),
("!a::'a. a = a", "bool"),
]
for s, Ts in test_data:
t = parser.parse_term(thy, ctxt, s)
T = parser.parse_type(thy, Ts)
self.assertIsInstance(t, Term)
self.assertEqual(t.checked_get_type(), T)
self.assertEqual(print_term(thy, t), s)
def testPrintRename(self):
test_data = [
(Const("exists",
TFun(TFun(NatType, BoolType),
BoolType))(Abs("x", NatType,
nat.less(Bound(0), Var("x", NatType)))),
"?x1. x1 < x"),
(Abs("x", NatType, nat.less(Bound(0),
Var("x", NatType))), "%x1. x1 < x"),
]
with global_setting(unicode=False):
for t, s in test_data:
self.assertEqual(printer.print_term(t), s)
def add_theorem(self, name, th, prf):
"""Add a theorem with proof to the file."""
assert len(th.hyps) == 0, "add_theorem"
vars = dict((v.name, str(v.T)) for v in get_vars(th.prop))
data = {
"name": name,
"ty": "thm",
"prop": printer.print_term(self.thy, th.prop),
"vars": vars,
"num_gaps": 0,
"proof": sum([self.export_proof_json(item) for item in prf.items], []),
}
self.content.append(data)
def testPrintReal(self):
basic.load_theory('real')
m = Var("m", RealType)
test_data = [
(real.zero, "(0::real)"),
(real.one, "(1::real)"),
(Real(2), "(2::real)"),
(Real(3), "(3::real)"),
(real.plus(m, real.one), "m + 1"),
(real.plus(real.one, Real(2)), "(1::real) + 2"),
]
for t, s in test_data:
self.assertEqual(printer.print_term(t), s)
def testPrintInt(self):
basic.load_theory('int')
m = Var("m", IntType)
test_data = [
(Int(0), "(0::int)"),
(Int(1), "(1::int)"),
(Int(2), "(2::int)"),
(Int(3), "(3::int)"),
(m + 1, "m + 1"),
(Int(1) + 2, "(1::int) + 2"),
]
for t, s in test_data:
self.assertEqual(printer.print_term(t), s)
def testPrintUnicode(self):
test_data = [
(conj(A, B), "A ∧ B"),
(disj(A, B), "A ∨ B"),
(imp(A, B), "A ⟶ B"),
(abs(a, P(a)), "λa. P a"),
(all(a, P(a)), "∀a. P a"),
(exists(a, P(a)), "∃a. P a"),
(neg(A), "¬A"),
(nat.plus(m, n), "m + n"),
(nat.times(m, n), "m * n"),
]
for t, s in test_data:
self.assertEqual(printer.print_term(thy, t, unicode=True), s)
def testGerman(self):
sys = load_system("german")
log(sys)
subgoals = load_hints("german_hints")
failed = 0
for inv_id, rule_id, case_id, hint in subgoals:
goal, ans = sys.verify_subgoal(inv_id, rule_id, case_id, hint)
log(printer.print_term(sys.thy, goal), " --- ",
"OK" if ans else "FAIL")
if not ans:
failed += 1
log("Number failed: " + str(failed))
self.assertEqual(failed, 0)
def testPrintUnicode(self):
test_data = [
(And(A, B), "A ∧ B"),
(Or(A, B), "A ∨ B"),
(Implies(A, B), "A ⟶ B"),
(Lambda(a, P(a)), "λa. P a"),
(Forall(a, P(a)), "∀a. P a"),
(Exists(a, P(a)), "∃a. P a"),
(Not(A), "¬A"),
(Lambda(m, m + 2), "λm::nat. m + 2"),
(Lambda(m, m + n), "λm. m + n"),
]
with global_setting(unicode=True):
for t, s in test_data:
self.assertEqual(printer.print_term(t), s)
def testPrintHighlight(self):
"""Test highlight"""
# 0, 1, 2, 3 = NORMAL, BOUND, VAR, TVAR
test_data = [
(abs(a,P(a)), [('%',0),('a',1),('. ',0),('P ',2),('a',1)]),
(all(a,P(a)), [('!',0),('a',1),('. ',0),('P ',2),("a",1)]),
(all(a,all(b,conj(P(a),P(b)))), [('!',0),('a',1),('. !',0),('b',1),('. ',0),('P ',2),('a',1),(' & ',0),('P ',2),('b',1)]),
(exists(a,all(b,R(a,b))), [('?',0),("a",1),('. !',0),('b',1),('. ',0),('R ',2),('a b',1)]),
(exists(a,P(a)), [('?',0),('a',1),('. ',0),('P ',2),('a',1)]),
(disj(disj(A,B),C), [('(',0),('A',2),(' | ',0),('B',2),(') | ',0),('C',2)]),
(imp(imp(A,B),C), [('(',0),('A',2),(' --> ',0),('B',2),(') --> ',0),('C',2)]),
(abs(a,a), [('%',0),('a',1),('::',0),("'a",3),('. ',0),('a',1)]),
]
for t, s in test_data:
self.assertEqual(printer.print_term(thy, t, highlight=True), s)
def testPrintArithmetic(self):
test_data = [
(nat.plus(m, n), "m + n"),
(nat.plus(nat.plus(m, n), p), "m + n + p"),
(nat.plus(m, nat.plus(n, p)), "m + (n + p)"),
(nat.times(m, n), "m * n"),
(nat.times(nat.times(m, n), p), "m * n * p"),
(nat.times(m, nat.times(n, p)), "m * (n * p)"),
(nat.plus(m, nat.times(n, p)), "m + n * p"),
(nat.times(m, nat.plus(n, p)), "m * (n + p)"),
(nat.zero, "0"),
(nat.plus(nat.zero, nat.zero), "0 + 0"),
(nat.times(m, nat.zero), "m * 0"),
]
for t, s in test_data:
self.assertEqual(printer.print_term(thy, t), s)
def testPrintFunction(self):
f = Var("f", TFun(Ta, Ta))
Tb = TVar('b')
Tc = TVar('c')
g = Var('g', TFun(Tb, Tc))
h = Var('h', TFun(Ta, Tb))
test_data = [
(function.mk_fun_upd(f, a, b), "(f)(a := b)"),
(function.mk_fun_upd(f, a, b, b, a), "(f)(a := b, b := a)"),
(function.mk_comp(g, h), "g O h"),
(function.mk_comp(g, h)(a), "(g O h) a"),
(function.mk_const_fun(NatType, nat.zero), "%x::nat. (0::nat)"),
]
basic.load_theory('function')
with global_setting(unicode=False):
for t, s in test_data:
self.assertEqual(printer.print_term(t), s)
