Calculating transitive closures - isabelle

Question

I have the following definition:
definition someRel :: "nat rel"
where
"someRel = {(1, 2), (2, 3), (3, 4), (4, 5)}"
I want to prove the following lemma:
lemma "someRel^*``{1}={1, 2, 3, 4, 5}"
I have devised the following proof:
proof
show "someRel^*``{1} ⊆ {1, 2, 3, 4, 5}"
proof
fix x
assume "x ∈ someRel⇧* `` {1}"
then show "x ∈ {1, 2, 3, 4, 5}"
using assms someRel_def by (auto elim: rtranclE)
qed
next
show "{1, 2, 3, 4, 5} ⊆ someRel^*``{1}"
proof
fix x
assume "x ∈ {1::nat, 2, 3, 4, 5}"
then show "x ∈ someRel⇧* `` {1}"
using assms someRel_def Image_singleton by (induction) blast+
qed
qed
This proof has the following issues:
The first part (show "someRel^*``{1} ⊆ {1, 2, 3, 4, 5}") is proved using the rule
rtranclE. This does not work if I add one more pair to the someRel relation (say the pair (6, 7))
The proof of the second part (show "{1, 2, 3, 4, 5} ⊆ someRel^*``{1}") does not terminate.
Can anyone suggest a better proof? That (a) allows for more pairs in the someRel relation and (b) that terminates.

Answer 1

It turns out that for your specific instance (and some slightly bigger ones I tried), the following suffices (found by first applying auto and then running sledgehammer on the remaining goals to identify useful facts, like converse_rtrancl_into_rtrancl here):
by (auto simp: someRel_def converse_rtrancl_into_rtrancl elim: rtranclE)
However, in general it might be a better idea to do one of the following:
device a tactic to prove such goals (by actually computing the involved transitive closure)
compute the transitive closure inside Isabelle/HOL (either via simp -- which might be slow -- or via eval -- which, as far as I know is kind of an oracle).
For the latter the AFP entry
Executable Transitive Closures might be of interest.
Update: I added an example of a simproc that computes images of finite transitive closures over finite sets by evaluation to the development version of the AFP. Instead of Executable Transitive Closures however, I based the example on
Executable Transitive Closures of Finite Relations. Your example can be found at the end of theory
Finite_Transitive_Closure_Simprocs (as soon as the AFP website is synchronized with the underlying mercurial repository).
Update: Note that the above mentioned simproc is specifically aimed at patterns of the form r^* `` x where the sets r and x are finite in the sense that they are given in finite set notation {x1, x2, ..., xN}. Thus, in order to fire on a specific goal you might have to add additional facts / simp rules / simprocs / ... in order to normalize an expression into this form.
Example: If you had the goal
"(converse someRel)^* `` {1} = {1}"
you would have to add rules that actually "apply" the converse operation on the given finite set. The following would do:
lemma [simp]:
"converse (insert (x, y) A) = insert (y, x) (converse A)"
by auto
Now the goal could be solved via
by (auto simp: someRel_def)

Answer 2

Adding to Chris' answer, here is a full version which uses the AFP-entry for transitive closures, and which does use code-simp instead of eval. code-simp is a bit slower than eval, but does not rely upon oracles.
theory Test
imports "$AFP/Transitive-Closure/Transitive_Closure_List_Impl"
begin
lemma to_memo_list: "(set xs)^* `` {a} = set (memo_list_rtrancl xs a)"
unfolding memo_list_rtrancl Image_def by auto
definition someRel :: "nat rel"
where
"someRel = {(1, 2), (2, 3), (3, 4), (4, 5), (5,3)}"
definition someRel_list :: "(nat × nat)list"
where
"someRel_list = [(1, 2), (2, 3), (3, 4), (4, 5), (5,3)]"
lemma someRel_list: "someRel = set someRel_list" by code_simp
lemma "someRel^*``{4}={3, 4, 5}"
unfolding someRel_list to_memo_list by code_simp
end