def testDatatypeList(self):
basic.load_theory('logic_base')
list_item = items.parse_item({
"args": ["a"],
"constrs": [{
"args": [],
"name": "nil",
"type": "'a list"
}, {
"args": ["x", "xs"],
"name": "cons",
"type": "'a => 'a list => 'a list"
}],
"name":
"list",
"ty":
"type.ind"
})
self.assertIsNone(list_item.error)
ext = list_item.get_extension()
theory.thy.unchecked_extend(ext)
ext_output = [
"Type list 1", "Constant nil :: 'a list",
"Constant cons :: 'a => 'a list => 'a list",
"Theorem list_nil_cons_neq: ~([] = x # xs)",
"Theorem list_cons_inject: x # xs = x1 # xs1 --> x = x1 & xs = xs1",
"Theorem list_induct: P [] --> (!x1. !xs. P xs --> P (x1 # xs)) --> P x",
"Attribute list_induct [var_induct]"
]
with global_setting(unicode=False):
self.assertEqual(printer.print_extensions(ext),
'\n'.join(ext_output))
def testDatatypeProd(self):
basic.load_theory('logic_base')
prod_item = items.parse_item({
"args": ["a", "b"],
"constrs": [{
"args": ["a", "b"],
"name": "Pair",
"type": "'a => 'b => ('a, 'b) prod"
}],
"name":
"prod",
"ty":
"type.ind"
})
self.assertIsNone(prod_item.error)
ext = prod_item.get_extension()
theory.thy.unchecked_extend(ext)
ext_output = [
"Type prod 2", "Constant Pair :: 'a => 'b => ('a, 'b) prod",
"Theorem prod_Pair_inject: Pair a b = Pair a1 b1 --> a = a1 & b = b1",
"Theorem prod_induct: (!a. !b. P (Pair a b)) --> P x",
"Attribute prod_induct [var_induct]"
]
with global_setting(unicode=False):
self.assertEqual(printer.print_extensions(ext),
'\n'.join(ext_output))
def testPredEven(self):
basic.load_theory('nat', limit=('def', 'one'))
even_item = items.parse_item({
"name":
"even",
"rules": [{
"name": "even_zero",
"prop": "even 0"
}, {
"name": "even_Suc",
"prop": "even n --> even (Suc (Suc n))"
}],
"ty":
"def.pred",
"type":
"nat => bool"
})
self.assertIsNone(even_item.error)
ext = even_item.get_extension()
theory.thy.unchecked_extend(ext)
ext_output = [
"Constant even :: nat => bool", "Theorem even_zero: even 0",
"Attribute even_zero [hint_backward]",
"Theorem even_Suc: even n --> even (Suc (Suc n))",
"Attribute even_Suc [hint_backward]",
"Theorem even_cases: even _a1 --> (_a1 = 0 --> P) --> (!n. _a1 = Suc (Suc n) --> even n --> P) --> P"
]
with global_setting(unicode=False):
self.assertEqual(printer.print_extensions(ext),
'\n'.join(ext_output))
def testDatatypeNat(self):
basic.load_theory('logic_base')
nat_item = items.parse_item({
"args": [],
"constrs": [{
"args": [],
"name": "zero",
"type": "nat"
}, {
"args": ["n"],
"name": "Suc",
"type": "nat => nat"
}],
"name":
"nat",
"ty":
"type.ind"
})
self.assertIsNone(nat_item.error)
ext = nat_item.get_extension()
theory.thy.unchecked_extend(ext)
ext_output = [
"Type nat 0", "Constant zero :: nat", "Constant Suc :: nat => nat",
"Theorem nat_zero_Suc_neq: ~(0 = Suc n)",
"Theorem nat_Suc_inject: Suc n = Suc n1 --> n = n1",
"Theorem nat_induct: P 0 --> (!n. P n --> P (Suc n)) --> P x",
"Attribute nat_induct [var_induct]"
]
with global_setting(unicode=False):
self.assertEqual(printer.print_extensions(ext),
'\n'.join(ext_output))
def testFunPlus(self):
basic.load_theory('nat', limit=('def', 'one'))
plus_item = items.parse_item({
"name":
"plus",
"rules": [{
"prop": "0 + n = n"
}, {
"prop": "Suc m + n = Suc (m + n)"
}],
"ty":
"def.ind",
"type":
"nat ⇒ nat ⇒ nat"
})
self.assertIsNone(plus_item.error)
ext = plus_item.get_extension()
theory.thy.unchecked_extend(ext)
ext_output = [
"Constant plus :: nat => nat => nat",
"Theorem plus_def_1: 0 + n = n",
"Attribute plus_def_1 [hint_rewrite]",
"Theorem plus_def_2: Suc m + n = Suc (m + n)",
"Attribute plus_def_2 [hint_rewrite]"
]
with global_setting(unicode=False):
self.assertEqual(printer.print_extensions(ext),
'\n'.join(ext_output))
def load_theory_cache(filename, username="******"):
"""Load the content of the given theory into cache.
Return the theory cache as a dictionary.
"""
if username not in theory_cache:
load_metadata(username)
cache = theory_cache[username][filename]
timestamp = os.path.getmtime(user_file(filename, username))
if 'timestamp' in cache and timestamp == cache['timestamp']:
# No need to update cache
return cache
# Load all required macros and methods for this file.
# Make table for this later.
if filename == 'logic':
from prover import z3wrapper
if filename == 'expr':
from data import expr
if filename == 'real':
from data import real
if filename == 'hoare':
from imperative import imp
# Load all imported theories
depend_list = get_import_order(cache['imports'], username)
with theory.fresh_theory():
for prev_name in depend_list:
prev_cache = load_theory_cache(prev_name, username)
for item in prev_cache['content']:
if item.error is None:
theory.thy.unchecked_extend(item.get_extension())
# Use this theory to parse the content of current theory
cache['timestamp'] = timestamp
data = load_json_data(filename, username)
cache['content'] = []
for index, item in enumerate(data['content']):
item = items.parse_item(item)
cache['content'].append(item)
if item.error is None:
exts = item.get_extension()
theory.thy.unchecked_extend(exts)
for ext in exts:
if ext.is_constant():
name = ext.ref_name
else:
name = ext.name
item_index[username][(ext.ty, name)] = (filename,
timestamp, index)
return cache
def check_theory(filename, username='******', rewrite=False):
"""Check the theory with the given name."""
start_time = time.perf_counter()
data = basic.load_json_data(filename, username)
basic.load_theory(filename, limit='start', username=username)
res = []
stat = {'OK': 0, 'NoSteps': 0, 'Failed': 0, 'Partial': 0,
'ProofOK': 0, 'ProofFail': 0, 'ParseOK': 0, 'ParseFail': 0, 'EditFail': 0}
content = []
for raw_item in data['content']:
item = items.parse_item(raw_item)
if item.error:
e = item.error
item_res = {
'ty': item.ty,
'name': item.name,
'status': 'ParseFail',
'err_type': e.__class__.__name__,
'err_str': str(e),
'trace': item.trace
}
else:
exts = item.get_extension()
old_thy = copy.copy(theory.thy)
theory.thy.unchecked_extend(exts)
new_thy = theory.thy
# Check consistency with edit_item
with global_setting(unicode=True, highlight=False):
edit_item = item.get_display()
theory.thy = old_thy
item2 = items.parse_edit(edit_item)
if item.ty == 'thm':
item2.proof = item.proof
item2.steps = item.steps
item2.num_gaps = item.num_gaps
if item2.error or item != item2:
item_res = {
'ty': item.ty,
'name': item.name,
'status': 'EditFail'
}
elif item.ty == 'thm':
item_res = check_proof(item, rewrite=rewrite)
item_res['ty'] = 'thm'
item_res['name'] = item.name
else:
item_res = {
'ty': item.ty,
'name': item.name,
'status': 'ParseOK'
}
theory.thy = new_thy
stat[item_res['status']] += 1
res.append(item_res)
if rewrite:
content.append(item.export_json())
if rewrite:
data['content'] = content
with open(basic.user_file(filename, username), 'w+', encoding='utf-8') as f:
json.dump(data, f, indent=4, ensure_ascii=False, sort_keys=True)
stat['exec_time'] = time.perf_counter() - start_time
return {
'data': res,
'stat': stat
}