def test_shared_nodes_in_different_branches(self):
tree = self.tree
root = tree.nodes[0]
gen = mock_generator(('ay', 1.0), ('ax', 2.0))
prover_util.try_tactics(root, 10, 0, 10, MOCK_PREMISE_SET, gen)
self.assertEqual(len(tree.nodes), 3)
self.assertEqual(str(tree.nodes[1].goal.conclusion), 'cx')
self.assertEqual(str(tree.nodes[2].goal.conclusion), 'cy')
gen = mock_generator(('rz', 1.0))
prover_util.try_tactics(tree.nodes[1], 10, 0, 10, MOCK_PREMISE_SET,
gen)
self.assertEqual(len(tree.nodes), 4)
self.assertEqual(tree.nodes[3].closed, None)
self.assertEqual(tree.nodes[2].closed, None)
self.assertEqual(tree.nodes[1].closed, False)
self.assertEqual(tree.nodes[0].closed, False)
gen = mock_generator(('rz', 1.0))
prover_util.try_tactics(tree.nodes[2], 10, 0, 10, MOCK_PREMISE_SET,
gen)
self.assertEqual(len(tree.nodes), 4)
self.assertEqual(len(tree.nodes[3].parents), 2)
self.assertEqual(tree.nodes[3].closed, None)
self.assertEqual(tree.nodes[2].closed, False)
self.assertEqual(tree.nodes[1].closed, False)
self.assertEqual(tree.nodes[0].closed, False)
gen = mock_generator(('c', 1.0))
prover_util.try_tactics(tree.nodes[3], 10, 0, 10, MOCK_PREMISE_SET,
gen)
self.assertEqual(len(tree.nodes), 4)
self.assertEqual(tree.nodes[3].closed, True)
self.assertEqual(tree.nodes[2].closed, True)
self.assertEqual(tree.nodes[1].closed, True)
self.assertEqual(tree.nodes[0].closed, True)
proof_search_tree.check_tree_consistency(tree)
self.check_log_consistency()
def test_apply_one_and_close(self):
tree = self.tree
root = tree.nodes[0]
gen = mock_generator(('axy', 1.0))
prover_util.try_tactics(root, 10, 0, 10, MOCK_PREMISE_SET, gen)
self.assertEqual(len(tree.nodes), 2)
node = tree.nodes[1]
gen = mock_generator(('c', 1.0))
prover_util.try_tactics(node, 10, 0, 10, MOCK_PREMISE_SET, gen)
self.assertEqual(len(tree.nodes), 2)
self.assertEqual(tree.nodes[1].closed, True)
self.assertEqual(tree.nodes[0].closed, True)
proof_search_tree.check_tree_consistency(tree)
self.check_log_consistency()
def prove_one(self, tree: proof_search_tree.ProofSearchTree,
task: proof_assistant_pb2.ProverTask) -> Optional[Text]:
"""Searches for a proof via BFS.
Args:
tree: Search tree with a single goal node to be proved.
task: ProverTask to be performed.
Returns:
None on success and error message on failure.
"""
root = tree.nodes[0]
nodes_explored = 0
# Note that adding new node to the tree might re-enable previous nodes
# for tactic applications, if they were marked to be ignored by
# failing sibling nodes.
tree.cur_index = 0
while not self.timed_out(
) and not root.closed and not root.failed and (
nodes_explored < self.options.max_explored_nodes):
if tree.cur_index >= len(tree.nodes):
return 'BFS: All nodes are failed or ignored.'
node = tree.nodes[tree.cur_index]
tree.cur_index += 1
if node.ignore or node.failed or node.closed or node.processed:
continue
nodes_explored += 1
# Note that the following function might change tree.cur_index
# (if a node that was ignored suddenly becomes subgoal of a new
# tactic application).
prover_util.try_tactics(node, self.options.max_top_suggestions,
self.options.min_successful_branches,
self.options.max_successful_branches,
task.premise_set, self.action_gen,
self.prover_options.tactic_timeout_ms)
root_status = ' '.join([
p[0] for p in [('closed', root.closed), ('failed', root.failed)]
if p[1]
])
tf.logging.info('Timeout: %s root status: %s explored: %d',
str(self.timed_out()), root_status, nodes_explored)
if self.timed_out():
return 'BFS: Timeout.'
elif root.failed:
return 'BFS: Root Failed.'
elif nodes_explored >= self.options.max_explored_nodes and not root.closed:
return 'BFS: Node limit reached.'
def test_apply_one_tactic(self):
tree = self.tree
root = tree.nodes[0]
gen = mock_generator(('axy', 1.0))
prover_util.try_tactics(root, 10, 0, 10, MOCK_PREMISE_SET, gen)
self.assertEqual(len(tree.nodes), 2)
for i, node in enumerate(tree.nodes):
self.assertEqual(node.index, i)
node = tree.nodes[1]
self.assertEqual(len(node.parents), 1)
self.assertEqual(str(node.goal.conclusion), 'cxy')
self.assertEqual(len(root.successful_attempts), 1)
self.assertEqual(len(root.failed_attempts), 0)
self.assertEqual(root.closed, False)
self.assertEqual(node.closed, None)
proof_search_tree.check_tree_consistency(tree)
self.check_log_consistency()
def prove_one(self, tree: proof_search_tree.ProofSearchTree,
task: proof_assistant_pb2.ProverTask) -> Optional[Text]:
"""Searches for a proof without backtracking.
Args:
tree: Search tree with a single goal node to be proved.
task: ProverTask to be performed.
Returns:
None on success and error message on failure.
"""
root = tree.nodes[0]
budget = NO_BACKTRACK_SEARCH_NODES
cur_index = 0
while not root.closed and not self.timed_out():
if cur_index >= len(tree.nodes):
# This situation can happen only if the tactics succeed, but end up
# reconstructing an earlier node.
return 'NoBacktrack: Loop.'
node = tree.nodes[cur_index]
cur_index += 1
prover_util.try_tactics(node, budget, 0, 1, task.premise_set,
self.action_gen,
self.prover_options.tactic_timeout_ms)
if not node.successful_attempts:
return (
'NoBacktrack: No successful tactic applications within '
'limit %d' % budget)
else:
if len(node.successful_attempts) != 1:
tf.logging.info('%d successful attempts.',
len(node.successful_attempts))
for tac_app in node.successful_attempts:
tf.logging.info('attempt: %s', tac_app.tactic)
assert len(node.successful_attempts) == 1
budget -= len(node.failed_attempts) + 1
if not root.closed:
if self.timed_out():
return 'Timed out.'
else:
return 'NoBacktrack: Could not find proof.'
def test_apply_two_in_a_row_and_close(self):
tree = self.tree
root = tree.nodes[0]
gen = mock_generator(('axy', 1.0))
prover_util.try_tactics(root, 10, 0, 10, MOCK_PREMISE_SET, gen)
self.assertEqual(len(tree.nodes), 2)
node = tree.nodes[1]
gen = mock_generator(('az', 1.0))
prover_util.try_tactics(node, 10, 0, 10, MOCK_PREMISE_SET, gen)
self.assertEqual(len(tree.nodes), 3)
node = tree.nodes[2]
self.assertEqual(str(node.goal.conclusion), 'cxyz')
gen = mock_generator(('c', 1.0))
prover_util.try_tactics(node, 10, 0, 10, MOCK_PREMISE_SET, gen)
self.assertEqual(len(tree.nodes), 3)
self.assertEqual(tree.nodes[2].closed, True)
self.assertEqual(tree.nodes[1].closed, True)
self.assertEqual(tree.nodes[0].closed, True)
proof_search_tree.check_tree_consistency(tree)
self.check_log_consistency()
def test_apply_two_different_and_close_one(self):
tree = self.tree
root = tree.nodes[0]
gen = mock_generator(('ay', 1.0), ('ax', 2.0))
prover_util.try_tactics(root, 10, 0, 10, MOCK_PREMISE_SET, gen)
self.assertEqual(len(tree.nodes), 3)
self.assertEqual(str(tree.nodes[1].goal.conclusion), 'cx')
self.assertEqual(str(tree.nodes[2].goal.conclusion), 'cy')
gen = mock_generator(('c', 1.0))
prover_util.try_tactics(tree.nodes[1], 10, 0, 10, MOCK_PREMISE_SET,
gen)
self.assertEqual(tree.nodes[2].closed, None)
self.assertEqual(tree.nodes[1].closed, True)
self.assertEqual(tree.nodes[0].closed, True)
gen = mock_generator(('c', 1.0))
prover_util.try_tactics(tree.nodes[2], 10, 0, 10, MOCK_PREMISE_SET,
gen)
self.assertEqual(tree.nodes[2].closed, True)
self.assertEqual(tree.nodes[0].closed, True)
proof_search_tree.check_tree_consistency(tree)
self.check_log_consistency()
def test_apply_two_in_parallel_and_close_both(self):
tree = self.tree
root = tree.nodes[0]
gen = mock_generator(('bxy', 1.0))
prover_util.try_tactics(root, 10, 0, 10, MOCK_PREMISE_SET, gen,
PER_TACTIC_TIMEOUT_MS)
self.assertEqual(len(tree.nodes), 3)
self.assertEqual(str(tree.nodes[1].goal.conclusion), 'cx')
self.assertEqual(str(tree.nodes[2].goal.conclusion), 'cy')
gen = mock_generator(('c', 1.0))
prover_util.try_tactics(tree.nodes[1], 10, 0, 10, MOCK_PREMISE_SET,
gen, PER_TACTIC_TIMEOUT_MS)
self.assertEqual(tree.nodes[2].closed, None)
self.assertEqual(tree.nodes[1].closed, True)
self.assertEqual(tree.nodes[0].closed, False)
gen = mock_generator(('c', 1.0))
prover_util.try_tactics(tree.nodes[2], 10, 0, 10, MOCK_PREMISE_SET,
gen, PER_TACTIC_TIMEOUT_MS)
self.assertEqual(tree.nodes[2].closed, True)
self.assertEqual(tree.nodes[0].closed, True)
proof_search_tree.check_tree_consistency(tree)
self.check_log_consistency()
