[STATEMENT]
lemma lift_CFG:
  assumes wf:"CFGExit_wf sourcenode targetnode kind valid_edge Entry get_proc
  get_return_edges procs Main Exit Def Use ParamDefs ParamUses"
  and pd:"Postdomination sourcenode targetnode kind valid_edge Entry get_proc
  get_return_edges procs Main Exit"
  shows "CFG src trg knd
  (lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit) NewEntry
  (lift_get_proc get_proc Main)
  (lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind)
  procs Main"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. CFG src trg knd (lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit) NewEntry (lift_get_proc get_proc Main) (lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind) procs Main
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. CFG src trg knd (lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit) NewEntry (lift_get_proc get_proc Main) (lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind) procs Main
[PROOF STEP]
interpret CFGExit_wf sourcenode targetnode kind valid_edge Entry get_proc
    get_return_edges procs Main Exit Def Use ParamDefs ParamUses
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. CFGExit_wf sourcenode targetnode kind valid_edge Entry get_proc get_return_edges procs Main Exit Def Use ParamDefs ParamUses
[PROOF STEP]
by(rule wf)
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. CFG src trg knd (lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit) NewEntry (lift_get_proc get_proc Main) (lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind) procs Main
[PROOF STEP]
interpret Postdomination sourcenode targetnode kind valid_edge Entry get_proc
    get_return_edges procs Main Exit
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. Postdomination sourcenode targetnode kind valid_edge Entry get_proc get_return_edges procs Main Exit
[PROOF STEP]
by(rule pd)
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. CFG src trg knd (lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit) NewEntry (lift_get_proc get_proc Main) (lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind) procs Main
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. CFG src trg knd (lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit) NewEntry (lift_get_proc get_proc Main) (lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind) procs Main
[PROOF STEP]
proof
[PROOF STATE]
proof (state)
goal (25 subgoals):
 1. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; trg a = NewEntry\<rbrakk> \<Longrightarrow> False
 2. lift_get_proc get_proc Main NewEntry = Main
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; src a = NewEntry\<rbrakk> \<Longrightarrow> False
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src a = src a'; trg a = trg a'\<rbrakk> \<Longrightarrow> a = a'
 5. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 6. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 8. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
A total of 25 subgoals...
[PROOF STEP]
fix a
[PROOF STATE]
proof (state)
goal (25 subgoals):
 1. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; trg a = NewEntry\<rbrakk> \<Longrightarrow> False
 2. lift_get_proc get_proc Main NewEntry = Main
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; src a = NewEntry\<rbrakk> \<Longrightarrow> False
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src a = src a'; trg a = trg a'\<rbrakk> \<Longrightarrow> a = a'
 5. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 6. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 8. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
A total of 25 subgoals...
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "trg a = NewEntry"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
trg a = NewEntry

goal (25 subgoals):
 1. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; trg a = NewEntry\<rbrakk> \<Longrightarrow> False
 2. lift_get_proc get_proc Main NewEntry = Main
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; src a = NewEntry\<rbrakk> \<Longrightarrow> False
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src a = src a'; trg a = trg a'\<rbrakk> \<Longrightarrow> a = a'
 5. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 6. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 8. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
A total of 25 subgoals...
[PROOF STEP]
thus False
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
trg a = NewEntry

goal (1 subgoal):
 1. False
[PROOF STEP]
by(fastforce elim:lift_valid_edge.cases)
[PROOF STATE]
proof (state)
this:
False

goal (24 subgoals):
 1. lift_get_proc get_proc Main NewEntry = Main
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; src a = NewEntry\<rbrakk> \<Longrightarrow> False
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src a = src a'; trg a = trg a'\<rbrakk> \<Longrightarrow> a = a'
 4. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 5. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 7. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 8. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 9. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
A total of 24 subgoals...
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (24 subgoals):
 1. lift_get_proc get_proc Main NewEntry = Main
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; src a = NewEntry\<rbrakk> \<Longrightarrow> False
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src a = src a'; trg a = trg a'\<rbrakk> \<Longrightarrow> a = a'
 4. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 5. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 7. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 8. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 9. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
A total of 24 subgoals...
[PROOF STEP]
show "lift_get_proc get_proc Main NewEntry = Main"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. lift_get_proc get_proc Main NewEntry = Main
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
lift_get_proc get_proc Main NewEntry = Main

goal (23 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; src a = NewEntry\<rbrakk> \<Longrightarrow> False
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src a = src a'; trg a = trg a'\<rbrakk> \<Longrightarrow> a = a'
 3. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 4. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 6. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
A total of 23 subgoals...
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (23 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; src a = NewEntry\<rbrakk> \<Longrightarrow> False
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src a = src a'; trg a = trg a'\<rbrakk> \<Longrightarrow> a = a'
 3. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 4. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 6. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
A total of 23 subgoals...
[PROOF STEP]
fix a Q r p fs
[PROOF STATE]
proof (state)
goal (23 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; src a = NewEntry\<rbrakk> \<Longrightarrow> False
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src a = src a'; trg a = trg a'\<rbrakk> \<Longrightarrow> a = a'
 3. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 4. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 6. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
A total of 23 subgoals...
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs" and "src a = NewEntry"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
src a = NewEntry

goal (23 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; src a = NewEntry\<rbrakk> \<Longrightarrow> False
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src a = src a'; trg a = trg a'\<rbrakk> \<Longrightarrow> a = a'
 3. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 4. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 6. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
A total of 23 subgoals...
[PROOF STEP]
thus False
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
src a = NewEntry

goal (1 subgoal):
 1. False
[PROOF STEP]
by(fastforce elim:lift_valid_edge.cases)
[PROOF STATE]
proof (state)
this:
False

goal (22 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src a = src a'; trg a = trg a'\<rbrakk> \<Longrightarrow> a = a'
 2. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 3. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 5. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 8. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 9. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
A total of 22 subgoals...
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (22 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src a = src a'; trg a = trg a'\<rbrakk> \<Longrightarrow> a = a'
 2. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 3. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 5. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 8. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 9. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
A total of 22 subgoals...
[PROOF STEP]
fix a a'
[PROOF STATE]
proof (state)
goal (22 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src a = src a'; trg a = trg a'\<rbrakk> \<Longrightarrow> a = a'
 2. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 3. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 5. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 8. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 9. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
A total of 22 subgoals...
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'"
      and "src a = src a'" and "trg a = trg a'"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
src a = src a'
trg a = trg a'

goal (22 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src a = src a'; trg a = trg a'\<rbrakk> \<Longrightarrow> a = a'
 2. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 3. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 5. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 8. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 9. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
A total of 22 subgoals...
[PROOF STEP]
thus "a = a'"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
src a = src a'
trg a = trg a'

goal (1 subgoal):
 1. a = a'
[PROOF STEP]
proof(induct rule:lift_valid_edge.induct)
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src e = src a'; trg e = trg a'\<rbrakk> \<Longrightarrow> e = a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src e = src a'; trg e = trg a'\<rbrakk> \<Longrightarrow> e = a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src e = src a'; trg e = trg a'\<rbrakk> \<Longrightarrow> e = a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src e = src a'; trg e = trg a'\<rbrakk> \<Longrightarrow> e = a'
[PROOF STEP]
case lve_edge
[PROOF STATE]
proof (state)
this:
valid_edge a_
sourcenode a_ \<noteq> Entry \<or> targetnode a_ \<noteq> Exit
e_ = (Node (sourcenode a_), kind a_, Node (targetnode a_))
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
src e_ = src a'
trg e_ = trg a'

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src e = src a'; trg e = trg a'\<rbrakk> \<Longrightarrow> e = a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src e = src a'; trg e = trg a'\<rbrakk> \<Longrightarrow> e = a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src e = src a'; trg e = trg a'\<rbrakk> \<Longrightarrow> e = a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src e = src a'; trg e = trg a'\<rbrakk> \<Longrightarrow> e = a'
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
valid_edge a_
sourcenode a_ \<noteq> Entry \<or> targetnode a_ \<noteq> Exit
e_ = (Node (sourcenode a_), kind a_, Node (targetnode a_))
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
src e_ = src a'
trg e_ = trg a'

goal (1 subgoal):
 1. e_ = a'
[PROOF STEP]
by -(erule lift_valid_edge.cases,auto dest:edge_det)
[PROOF STATE]
proof (state)
this:
e_ = a'

goal (3 subgoals):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src e = src a'; trg e = trg a'\<rbrakk> \<Longrightarrow> e = a'
 2. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src e = src a'; trg e = trg a'\<rbrakk> \<Longrightarrow> e = a'
 3. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; src e = src a'; trg e = trg a'\<rbrakk> \<Longrightarrow> e = a'
[PROOF STEP]
qed(auto elim:lift_valid_edge.cases)
[PROOF STATE]
proof (state)
this:
a = a'

goal (21 subgoals):
 1. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 2. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 4. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
A total of 21 subgoals...
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (21 subgoals):
 1. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 2. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 4. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
A total of 21 subgoals...
[PROOF STEP]
fix a Q r f
[PROOF STATE]
proof (state)
goal (21 subgoals):
 1. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 2. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 4. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
A total of 21 subgoals...
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f

goal (21 subgoals):
 1. \<And>a Q r f. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f\<rbrakk> \<Longrightarrow> False
 2. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 4. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
A total of 21 subgoals...
[PROOF STEP]
thus False
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q:r\<hookrightarrow>\<^bsub>Main\<^esub>f

goal (1 subgoal):
 1. False
[PROOF STEP]
by(fastforce elim:lift_valid_edge.cases dest:Main_no_call_target)
[PROOF STATE]
proof (state)
this:
False

goal (20 subgoals):
 1. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 3. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 8. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
A total of 20 subgoals...
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (20 subgoals):
 1. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 3. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 8. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
A total of 20 subgoals...
[PROOF STEP]
fix a Q' f'
[PROOF STATE]
proof (state)
goal (20 subgoals):
 1. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 3. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 8. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
A total of 20 subgoals...
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'

goal (20 subgoals):
 1. \<And>a Q' f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'\<rbrakk> \<Longrightarrow> False
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 3. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 8. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
A total of 20 subgoals...
[PROOF STEP]
thus False
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'

goal (1 subgoal):
 1. False
[PROOF STEP]
by(fastforce elim:lift_valid_edge.cases dest:Main_no_return_source)
[PROOF STATE]
proof (state)
this:
False

goal (19 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 2. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 10. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
A total of 19 subgoals...
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (19 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 2. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 10. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
A total of 19 subgoals...
[PROOF STEP]
fix a Q r p fs
[PROOF STATE]
proof (state)
goal (19 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 2. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 10. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
A total of 19 subgoals...
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (19 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>ins outs. (p, ins, outs) \<in> set procs
 2. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 10. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
A total of 19 subgoals...
[PROOF STEP]
thus "\<exists>ins outs. (p, ins, outs) \<in> set procs"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. \<exists>ins outs. (p, ins, outs) \<in> set procs
[PROOF STEP]
by(fastforce elim:lift_valid_edge.cases intro:callee_in_procs)
[PROOF STATE]
proof (state)
this:
\<exists>ins outs. (p, ins, outs) \<in> set procs

goal (18 subgoals):
 1. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 9. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
A total of 18 subgoals...
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (18 subgoals):
 1. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 9. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
A total of 18 subgoals...
[PROOF STEP]
fix a
[PROOF STATE]
proof (state)
goal (18 subgoals):
 1. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 9. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
A total of 18 subgoals...
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "intra_kind (knd a)"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
intra_kind (knd a)

goal (18 subgoals):
 1. \<And>a. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; intra_kind (knd a)\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 9. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
A total of 18 subgoals...
[PROOF STEP]
thus "lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
intra_kind (knd a)

goal (1 subgoal):
 1. lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)
[PROOF STEP]
by(fastforce elim:lift_valid_edge.cases intro:get_proc_intra
                  simp:get_proc_Entry get_proc_Exit)
[PROOF STATE]
proof (state)
this:
lift_get_proc get_proc Main (src a) = lift_get_proc get_proc Main (trg a)

goal (17 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 8. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 9. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
A total of 17 subgoals...
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (17 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 8. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 9. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
A total of 17 subgoals...
[PROOF STEP]
fix a Q r p fs
[PROOF STATE]
proof (state)
goal (17 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 8. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 9. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
A total of 17 subgoals...
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (17 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (trg a) = p
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 8. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 9. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
A total of 17 subgoals...
[PROOF STEP]
thus "lift_get_proc get_proc Main (trg a) = p"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. lift_get_proc get_proc Main (trg a) = p
[PROOF STEP]
by(fastforce elim:lift_valid_edge.cases intro:get_proc_call)
[PROOF STATE]
proof (state)
this:
lift_get_proc get_proc Main (trg a) = p

goal (16 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 7. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
A total of 16 subgoals...
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (16 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 7. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
A total of 16 subgoals...
[PROOF STEP]
fix a Q' p f'
[PROOF STATE]
proof (state)
goal (16 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 7. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
A total of 16 subgoals...
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (16 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> lift_get_proc get_proc Main (src a) = p
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 7. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 10. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
A total of 16 subgoals...
[PROOF STEP]
thus "lift_get_proc get_proc Main (src a) = p"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (1 subgoal):
 1. lift_get_proc get_proc Main (src a) = p
[PROOF STEP]
by(fastforce elim:lift_valid_edge.cases intro:get_proc_return)
[PROOF STATE]
proof (state)
this:
lift_get_proc get_proc Main (src a) = p

goal (15 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 6. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
A total of 15 subgoals...
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (15 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 6. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
A total of 15 subgoals...
[PROOF STEP]
fix a Q r p fs
[PROOF STATE]
proof (state)
goal (15 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 6. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
A total of 15 subgoals...
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (15 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 6. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
A total of 15 subgoals...
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
obtain ax where "valid_edge ax" and "kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
      and "sourcenode ax \<noteq> Entry \<or> targetnode ax \<noteq> Exit"
      and "src a = Node (sourcenode ax)" and "trg a = Node (targetnode ax)"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. (\<And>ax. \<lbrakk>valid_edge ax; kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; sourcenode ax \<noteq> Entry \<or> targetnode ax \<noteq> Exit; src a = Node (sourcenode ax); trg a = Node (targetnode ax)\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(fastforce elim:lift_valid_edge.cases)
[PROOF STATE]
proof (state)
this:
valid_edge ax
kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
sourcenode ax \<noteq> Entry \<or> targetnode ax \<noteq> Exit
src a = Node (sourcenode ax)
trg a = Node (targetnode ax)

goal (15 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 6. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
A total of 15 subgoals...
[PROOF STEP]
from \<open>valid_edge ax\<close> \<open>kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
have all:"\<forall>a'. valid_edge a' \<and> targetnode a' = targetnode ax \<longrightarrow>
               (\<exists>Qx rx fsx. kind a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. \<forall>a'. valid_edge a' \<and> targetnode a' = targetnode ax \<longrightarrow> (\<exists>Qx rx fsx. kind a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
[PROOF STEP]
by(auto dest:call_edges_only)
[PROOF STATE]
proof (state)
this:
\<forall>a'. valid_edge a' \<and> targetnode a' = targetnode ax \<longrightarrow> (\<exists>Qx rx fsx. kind a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)

goal (15 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 6. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
A total of 15 subgoals...
[PROOF STEP]
{
[PROOF STATE]
proof (state)
this:
\<forall>a'. valid_edge a' \<and> targetnode a' = targetnode ax \<longrightarrow> (\<exists>Qx rx fsx. kind a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)

goal (15 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 6. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
A total of 15 subgoals...
[PROOF STEP]
fix a'
[PROOF STATE]
proof (state)
goal (15 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 6. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
A total of 15 subgoals...
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'"
        and "trg a' = trg a"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
trg a' = trg a

goal (15 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 6. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
A total of 15 subgoals...
[PROOF STEP]
hence "\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
trg a' = trg a

goal (1 subgoal):
 1. \<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
proof(induct rule:lift_valid_edge.induct)
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>aa e. \<lbrakk>valid_edge aa; sourcenode aa \<noteq> Entry \<or> targetnode aa \<noteq> Exit; e = (Node (sourcenode aa), kind aa, Node (targetnode aa)); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
case (lve_edge ax' e)
[PROOF STATE]
proof (state)
this:
valid_edge ax'
sourcenode ax' \<noteq> Entry \<or> targetnode ax' \<noteq> Exit
e = (Node (sourcenode ax'), kind ax', Node (targetnode ax'))
trg e = trg a

goal (4 subgoals):
 1. \<And>aa e. \<lbrakk>valid_edge aa; sourcenode aa \<noteq> Entry \<or> targetnode aa \<noteq> Exit; e = (Node (sourcenode aa), kind aa, Node (targetnode aa)); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
note [simp] = \<open>e = (Node (sourcenode ax'), kind ax', Node (targetnode ax'))\<close>
[PROOF STATE]
proof (state)
this:
e = (Node (sourcenode ax'), kind ax', Node (targetnode ax'))

goal (4 subgoals):
 1. \<And>aa e. \<lbrakk>valid_edge aa; sourcenode aa \<noteq> Entry \<or> targetnode aa \<noteq> Exit; e = (Node (sourcenode aa), kind aa, Node (targetnode aa)); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
from \<open>trg e = trg a\<close> \<open>trg a = Node (targetnode ax)\<close>
[PROOF STATE]
proof (chain)
picking this:
trg e = trg a
trg a = Node (targetnode ax)
[PROOF STEP]
have "targetnode ax' = targetnode ax"
[PROOF STATE]
proof (prove)
using this:
trg e = trg a
trg a = Node (targetnode ax)

goal (1 subgoal):
 1. targetnode ax' = targetnode ax
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
targetnode ax' = targetnode ax

goal (4 subgoals):
 1. \<And>aa e. \<lbrakk>valid_edge aa; sourcenode aa \<noteq> Entry \<or> targetnode aa \<noteq> Exit; e = (Node (sourcenode aa), kind aa, Node (targetnode aa)); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
with \<open>valid_edge ax'\<close> all
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax'
\<forall>a'. valid_edge a' \<and> targetnode a' = targetnode ax \<longrightarrow> (\<exists>Qx rx fsx. kind a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
targetnode ax' = targetnode ax
[PROOF STEP]
have "\<exists>Qx rx fsx. kind ax' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax'
\<forall>a'. valid_edge a' \<and> targetnode a' = targetnode ax \<longrightarrow> (\<exists>Qx rx fsx. kind a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
targetnode ax' = targetnode ax

goal (1 subgoal):
 1. \<exists>Qx rx fsx. kind ax' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
\<exists>Qx rx fsx. kind ax' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx

goal (4 subgoals):
 1. \<And>aa e. \<lbrakk>valid_edge aa; sourcenode aa \<noteq> Entry \<or> targetnode aa \<noteq> Exit; e = (Node (sourcenode aa), kind aa, Node (targetnode aa)); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
\<exists>Qx rx fsx. kind ax' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx

goal (1 subgoal):
 1. \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx

goal (3 subgoals):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 2. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 3. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (3 subgoals):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 2. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 3. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
case (lve_Entry_edge e)
[PROOF STATE]
proof (state)
this:
e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)
trg e = trg a

goal (3 subgoals):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 2. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 3. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
from \<open>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<close> \<open>trg e = trg a\<close>
          \<open>trg a = Node (targetnode ax)\<close>
[PROOF STATE]
proof (chain)
picking this:
e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)
trg e = trg a
trg a = Node (targetnode ax)
[PROOF STEP]
have "targetnode ax = Entry"
[PROOF STATE]
proof (prove)
using this:
e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)
trg e = trg a
trg a = Node (targetnode ax)

goal (1 subgoal):
 1. targetnode ax = Entry
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
targetnode ax = Entry

goal (3 subgoals):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 2. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 3. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
with \<open>valid_edge ax\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
targetnode ax = Entry
[PROOF STEP]
have False
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
targetnode ax = Entry

goal (1 subgoal):
 1. False
[PROOF STEP]
by(rule Entry_target)
[PROOF STATE]
proof (state)
this:
False

goal (3 subgoals):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 2. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 3. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
False

goal (1 subgoal):
 1. \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx

goal (2 subgoals):
 1. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
case (lve_Exit_edge e)
[PROOF STATE]
proof (state)
this:
e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)
trg e = trg a

goal (2 subgoals):
 1. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
from \<open>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<close> \<open>trg e = trg a\<close>
          \<open>trg a = Node (targetnode ax)\<close>
[PROOF STATE]
proof (chain)
picking this:
e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)
trg e = trg a
trg a = Node (targetnode ax)
[PROOF STEP]
have False
[PROOF STATE]
proof (prove)
using this:
e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)
trg e = trg a
trg a = Node (targetnode ax)

goal (1 subgoal):
 1. False
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
False

goal (2 subgoals):
 1. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
False

goal (1 subgoal):
 1. \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx

goal (1 subgoal):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
case (lve_Entry_Exit_edge e)
[PROOF STATE]
proof (state)
this:
e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)
trg e = trg a

goal (1 subgoal):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
from \<open>e = (NewEntry,(\<lambda>s. False)\<^sub>\<surd>,NewExit)\<close> \<open>trg e = trg a\<close>
          \<open>trg a = Node (targetnode ax)\<close>
[PROOF STATE]
proof (chain)
picking this:
e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)
trg e = trg a
trg a = Node (targetnode ax)
[PROOF STEP]
have False
[PROOF STATE]
proof (prove)
using this:
e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)
trg e = trg a
trg a = Node (targetnode ax)

goal (1 subgoal):
 1. False
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
False

goal (1 subgoal):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); trg e = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
False

goal (1 subgoal):
 1. \<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<exists>Qx rx fsx. knd e = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx

goal (15 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 6. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
A total of 15 subgoals...
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
\<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?a'2; trg ?a'2 = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd ?a'2 = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx

goal (15 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 6. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 10. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
A total of 15 subgoals...
[PROOF STEP]
thus "\<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and>
               trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)"
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?a'2; trg ?a'2 = trg a\<rbrakk> \<Longrightarrow> \<exists>Qx rx fsx. knd ?a'2 = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx

goal (1 subgoal):
 1. \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<longrightarrow> (\<exists>Qx rx fsx. knd a' = Qx:rx\<hookrightarrow>\<^bsub>p\<^esub>fsx)

goal (14 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 5. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
A total of 14 subgoals...
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (14 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 5. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
A total of 14 subgoals...
[PROOF STEP]
fix a Q' p f'
[PROOF STATE]
proof (state)
goal (14 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 5. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
A total of 14 subgoals...
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (14 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 5. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
A total of 14 subgoals...
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
obtain ax where "valid_edge ax" and "kind ax = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'"
      and "sourcenode ax \<noteq> Entry \<or> targetnode ax \<noteq> Exit"
      and "src a = Node (sourcenode ax)" and "trg a = Node (targetnode ax)"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (1 subgoal):
 1. (\<And>ax. \<lbrakk>valid_edge ax; kind ax = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'; sourcenode ax \<noteq> Entry \<or> targetnode ax \<noteq> Exit; src a = Node (sourcenode ax); trg a = Node (targetnode ax)\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(fastforce elim:lift_valid_edge.cases)
[PROOF STATE]
proof (state)
this:
valid_edge ax
kind ax = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
sourcenode ax \<noteq> Entry \<or> targetnode ax \<noteq> Exit
src a = Node (sourcenode ax)
trg a = Node (targetnode ax)

goal (14 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 5. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
A total of 14 subgoals...
[PROOF STEP]
from \<open>valid_edge ax\<close> \<open>kind ax = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
kind ax = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
have all:"\<forall>a'. valid_edge a' \<and> sourcenode a' = sourcenode ax \<longrightarrow>
            (\<exists>Qx fx. kind a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
kind ax = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (1 subgoal):
 1. \<forall>a'. valid_edge a' \<and> sourcenode a' = sourcenode ax \<longrightarrow> (\<exists>Qx fx. kind a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
[PROOF STEP]
by(auto dest:return_edges_only)
[PROOF STATE]
proof (state)
this:
\<forall>a'. valid_edge a' \<and> sourcenode a' = sourcenode ax \<longrightarrow> (\<exists>Qx fx. kind a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)

goal (14 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 5. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
A total of 14 subgoals...
[PROOF STEP]
{
[PROOF STATE]
proof (state)
this:
\<forall>a'. valid_edge a' \<and> sourcenode a' = sourcenode ax \<longrightarrow> (\<exists>Qx fx. kind a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)

goal (14 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 5. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
A total of 14 subgoals...
[PROOF STEP]
fix a'
[PROOF STATE]
proof (state)
goal (14 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 5. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
A total of 14 subgoals...
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'"
        and "src a' = src a"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
src a' = src a

goal (14 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 5. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
A total of 14 subgoals...
[PROOF STEP]
hence "\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
src a' = src a

goal (1 subgoal):
 1. \<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
proof(induct rule:lift_valid_edge.induct)
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>aa e. \<lbrakk>valid_edge aa; sourcenode aa \<noteq> Entry \<or> targetnode aa \<noteq> Exit; e = (Node (sourcenode aa), kind aa, Node (targetnode aa)); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
case (lve_edge ax' e)
[PROOF STATE]
proof (state)
this:
valid_edge ax'
sourcenode ax' \<noteq> Entry \<or> targetnode ax' \<noteq> Exit
e = (Node (sourcenode ax'), kind ax', Node (targetnode ax'))
src e = src a

goal (4 subgoals):
 1. \<And>aa e. \<lbrakk>valid_edge aa; sourcenode aa \<noteq> Entry \<or> targetnode aa \<noteq> Exit; e = (Node (sourcenode aa), kind aa, Node (targetnode aa)); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
note [simp] = \<open>e = (Node (sourcenode ax'), kind ax', Node (targetnode ax'))\<close>
[PROOF STATE]
proof (state)
this:
e = (Node (sourcenode ax'), kind ax', Node (targetnode ax'))

goal (4 subgoals):
 1. \<And>aa e. \<lbrakk>valid_edge aa; sourcenode aa \<noteq> Entry \<or> targetnode aa \<noteq> Exit; e = (Node (sourcenode aa), kind aa, Node (targetnode aa)); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
from \<open>src e = src a\<close> \<open>src a = Node (sourcenode ax)\<close>
[PROOF STATE]
proof (chain)
picking this:
src e = src a
src a = Node (sourcenode ax)
[PROOF STEP]
have "sourcenode ax' = sourcenode ax"
[PROOF STATE]
proof (prove)
using this:
src e = src a
src a = Node (sourcenode ax)

goal (1 subgoal):
 1. sourcenode ax' = sourcenode ax
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
sourcenode ax' = sourcenode ax

goal (4 subgoals):
 1. \<And>aa e. \<lbrakk>valid_edge aa; sourcenode aa \<noteq> Entry \<or> targetnode aa \<noteq> Exit; e = (Node (sourcenode aa), kind aa, Node (targetnode aa)); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
with \<open>valid_edge ax'\<close> all
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax'
\<forall>a'. valid_edge a' \<and> sourcenode a' = sourcenode ax \<longrightarrow> (\<exists>Qx fx. kind a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
sourcenode ax' = sourcenode ax
[PROOF STEP]
have "\<exists>Qx fx. kind ax' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax'
\<forall>a'. valid_edge a' \<and> sourcenode a' = sourcenode ax \<longrightarrow> (\<exists>Qx fx. kind a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
sourcenode ax' = sourcenode ax

goal (1 subgoal):
 1. \<exists>Qx fx. kind ax' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
\<exists>Qx fx. kind ax' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx

goal (4 subgoals):
 1. \<And>aa e. \<lbrakk>valid_edge aa; sourcenode aa \<noteq> Entry \<or> targetnode aa \<noteq> Exit; e = (Node (sourcenode aa), kind aa, Node (targetnode aa)); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
\<exists>Qx fx. kind ax' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx

goal (1 subgoal):
 1. \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx

goal (3 subgoals):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 2. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 3. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (3 subgoals):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 2. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 3. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
case (lve_Entry_edge e)
[PROOF STATE]
proof (state)
this:
e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)
src e = src a

goal (3 subgoals):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 2. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 3. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
from \<open>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<close> \<open>src e = src a\<close>
          \<open>src a = Node (sourcenode ax)\<close>
[PROOF STATE]
proof (chain)
picking this:
e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)
src e = src a
src a = Node (sourcenode ax)
[PROOF STEP]
have False
[PROOF STATE]
proof (prove)
using this:
e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)
src e = src a
src a = Node (sourcenode ax)

goal (1 subgoal):
 1. False
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
False

goal (3 subgoals):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 2. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 3. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
False

goal (1 subgoal):
 1. \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx

goal (2 subgoals):
 1. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
case (lve_Exit_edge e)
[PROOF STATE]
proof (state)
this:
e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)
src e = src a

goal (2 subgoals):
 1. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
from \<open>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<close> \<open>src e = src a\<close>
          \<open>src a = Node (sourcenode ax)\<close>
[PROOF STATE]
proof (chain)
picking this:
e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)
src e = src a
src a = Node (sourcenode ax)
[PROOF STEP]
have "sourcenode ax = Exit"
[PROOF STATE]
proof (prove)
using this:
e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)
src e = src a
src a = Node (sourcenode ax)

goal (1 subgoal):
 1. sourcenode ax = Exit
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
sourcenode ax = Exit

goal (2 subgoals):
 1. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
with \<open>valid_edge ax\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
sourcenode ax = Exit
[PROOF STEP]
have False
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
sourcenode ax = Exit

goal (1 subgoal):
 1. False
[PROOF STEP]
by(rule Exit_source)
[PROOF STATE]
proof (state)
this:
False

goal (2 subgoals):
 1. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
False

goal (1 subgoal):
 1. \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx

goal (1 subgoal):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
case (lve_Entry_Exit_edge e)
[PROOF STATE]
proof (state)
this:
e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)
src e = src a

goal (1 subgoal):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
from \<open>e = (NewEntry,(\<lambda>s. False)\<^sub>\<surd>,NewExit)\<close> \<open>src e = src a\<close>
          \<open>src a = Node (sourcenode ax)\<close>
[PROOF STATE]
proof (chain)
picking this:
e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)
src e = src a
src a = Node (sourcenode ax)
[PROOF STEP]
have False
[PROOF STATE]
proof (prove)
using this:
e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)
src e = src a
src a = Node (sourcenode ax)

goal (1 subgoal):
 1. False
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
False

goal (1 subgoal):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); src e = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
False

goal (1 subgoal):
 1. \<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<exists>Qx fx. knd e = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx

goal (14 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 5. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
A total of 14 subgoals...
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
\<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?a'2; src ?a'2 = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd ?a'2 = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx

goal (14 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 5. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 8. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 9. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 10. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
A total of 14 subgoals...
[PROOF STEP]
thus "\<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and>
               src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)"
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?a'2; src ?a'2 = src a\<rbrakk> \<Longrightarrow> \<exists>Qx fx. knd ?a'2 = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx

goal (1 subgoal):
 1. \<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<forall>a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<longrightarrow> (\<exists>Qx fx. knd a' = Qx\<hookleftarrow>\<^bsub>p\<^esub>fx)

goal (13 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 4. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 8. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 9. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 10. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
A total of 13 subgoals...
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (13 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 4. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 8. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 9. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 10. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
A total of 13 subgoals...
[PROOF STEP]
fix a Q r p fs
[PROOF STATE]
proof (state)
goal (13 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 4. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 8. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 9. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 10. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
A total of 13 subgoals...
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (13 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 4. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 7. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 8. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 9. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 10. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
A total of 13 subgoals...
[PROOF STEP]
thus "lift_get_return_edges get_return_edges valid_edge
      sourcenode targetnode kind a \<noteq> {}"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}
[PROOF STEP]
proof(induct rule:lift_valid_edge.induct)
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
[PROOF STEP]
case (lve_edge ax e)
[PROOF STATE]
proof (state)
this:
valid_edge ax
sourcenode ax \<noteq> Entry \<or> targetnode ax \<noteq> Exit
e = (Node (sourcenode ax), kind ax, Node (targetnode ax))
knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
[PROOF STEP]
from \<open>e = (Node (sourcenode ax), kind ax, Node (targetnode ax))\<close>
        \<open>knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<close>
[PROOF STATE]
proof (chain)
picking this:
e = (Node (sourcenode ax), kind ax, Node (targetnode ax))
knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
have "kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
[PROOF STATE]
proof (prove)
using this:
e = (Node (sourcenode ax), kind ax, Node (targetnode ax))
knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
[PROOF STEP]
with \<open>valid_edge ax\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
have "get_return_edges ax \<noteq> {}"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. get_return_edges ax \<noteq> {}
[PROOF STEP]
by(rule get_return_edge_call)
[PROOF STATE]
proof (state)
this:
get_return_edges ax \<noteq> {}

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
get_return_edges ax \<noteq> {}
[PROOF STEP]
obtain ax' where "ax' \<in> get_return_edges ax"
[PROOF STATE]
proof (prove)
using this:
get_return_edges ax \<noteq> {}

goal (1 subgoal):
 1. (\<And>ax'. ax' \<in> get_return_edges ax \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
ax' \<in> get_return_edges ax

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
[PROOF STEP]
with \<open>e = (Node (sourcenode ax), kind ax, Node (targetnode ax))\<close> \<open>valid_edge ax\<close>
[PROOF STATE]
proof (chain)
picking this:
e = (Node (sourcenode ax), kind ax, Node (targetnode ax))
valid_edge ax
ax' \<in> get_return_edges ax
[PROOF STEP]
have "(Node (sourcenode ax'),kind ax',Node (targetnode ax')) \<in>
        lift_get_return_edges get_return_edges valid_edge
        sourcenode targetnode kind e"
[PROOF STATE]
proof (prove)
using this:
e = (Node (sourcenode ax), kind ax, Node (targetnode ax))
valid_edge ax
ax' \<in> get_return_edges ax

goal (1 subgoal):
 1. (Node (sourcenode ax'), kind ax', Node (targetnode ax')) \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e
[PROOF STEP]
by(fastforce intro:lift_get_return_edgesI)
[PROOF STATE]
proof (state)
this:
(Node (sourcenode ax'), kind ax', Node (targetnode ax')) \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
(Node (sourcenode ax'), kind ax', Node (targetnode ax')) \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e

goal (1 subgoal):
 1. lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
[PROOF STEP]
by fastforce
[PROOF STATE]
proof (state)
this:
lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}

goal (3 subgoals):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 2. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
 3. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind e \<noteq> {}
[PROOF STEP]
qed simp_all
[PROOF STATE]
proof (state)
this:
lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a \<noteq> {}

goal (12 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 3. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 9. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 10. distinct_fst procs
A total of 12 subgoals...
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (12 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 3. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 9. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 10. distinct_fst procs
A total of 12 subgoals...
[PROOF STEP]
fix a a'
[PROOF STATE]
proof (state)
goal (12 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 3. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 9. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 10. distinct_fst procs
A total of 12 subgoals...
[PROOF STEP]
assume "a' \<in> lift_get_return_edges get_return_edges valid_edge
      sourcenode targetnode kind a"
      and "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
[PROOF STATE]
proof (state)
this:
a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a

goal (12 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 3. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 6. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 7. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 8. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 9. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 10. distinct_fst procs
A total of 12 subgoals...
[PROOF STEP]
thus "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'"
[PROOF STATE]
proof (prove)
using this:
a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a

goal (1 subgoal):
 1. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
[PROOF STEP]
proof (induct rule:lift_get_return_edges.induct)
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit e'
[PROOF STEP]
case (lift_get_return_edgesI ax a' e')
[PROOF STATE]
proof (state)
this:
a = (Node (sourcenode ax), kind ax, Node (targetnode ax))
valid_edge ax
a' \<in> get_return_edges ax
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit e'
[PROOF STEP]
from \<open>valid_edge ax\<close> \<open>a' \<in> get_return_edges ax\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
a' \<in> get_return_edges ax
[PROOF STEP]
have "valid_edge a'"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
a' \<in> get_return_edges ax

goal (1 subgoal):
 1. valid_edge a'
[PROOF STEP]
by(rule get_return_edges_valid)
[PROOF STATE]
proof (state)
this:
valid_edge a'

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit e'
[PROOF STEP]
from \<open>valid_edge ax\<close> \<open>a' \<in> get_return_edges ax\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
a' \<in> get_return_edges ax
[PROOF STEP]
obtain Q r p fs
        where "kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
a' \<in> get_return_edges ax

goal (1 subgoal):
 1. (\<And>Q r p fs. kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(fastforce dest!:only_call_get_return_edges)
[PROOF STATE]
proof (state)
this:
kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit e'
[PROOF STEP]
with \<open>valid_edge ax\<close> \<open>a' \<in> get_return_edges ax\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
a' \<in> get_return_edges ax
kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
obtain Q' f'
        where "kind a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
a' \<in> get_return_edges ax
kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. (\<And>Q' f'. kind a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f' \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(fastforce dest!:call_return_edges)
[PROOF STATE]
proof (state)
this:
kind a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit e'
[PROOF STEP]
from \<open>valid_edge a'\<close> \<open>kind a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge a'
kind a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
have "get_proc(sourcenode a') = p"
[PROOF STATE]
proof (prove)
using this:
valid_edge a'
kind a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (1 subgoal):
 1. get_proc (sourcenode a') = p
[PROOF STEP]
by(rule get_proc_return)
[PROOF STATE]
proof (state)
this:
get_proc (sourcenode a') = p

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit e'
[PROOF STEP]
have "sourcenode a' \<noteq> Entry"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. sourcenode a' \<noteq> Entry
[PROOF STEP]
proof
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. sourcenode a' = Entry \<Longrightarrow> False
[PROOF STEP]
assume "sourcenode a' = Entry"
[PROOF STATE]
proof (state)
this:
sourcenode a' = Entry

goal (1 subgoal):
 1. sourcenode a' = Entry \<Longrightarrow> False
[PROOF STEP]
with get_proc_Entry \<open>get_proc(sourcenode a') = p\<close>
[PROOF STATE]
proof (chain)
picking this:
get_proc Entry = Main
get_proc (sourcenode a') = p
sourcenode a' = Entry
[PROOF STEP]
have "p = Main"
[PROOF STATE]
proof (prove)
using this:
get_proc Entry = Main
get_proc (sourcenode a') = p
sourcenode a' = Entry

goal (1 subgoal):
 1. p = Main
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
p = Main

goal (1 subgoal):
 1. sourcenode a' = Entry \<Longrightarrow> False
[PROOF STEP]
with \<open>kind a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<close>
[PROOF STATE]
proof (chain)
picking this:
kind a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
p = Main
[PROOF STEP]
have "kind a' = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'"
[PROOF STATE]
proof (prove)
using this:
kind a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
p = Main

goal (1 subgoal):
 1. kind a' = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
kind a' = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'

goal (1 subgoal):
 1. sourcenode a' = Entry \<Longrightarrow> False
[PROOF STEP]
with \<open>valid_edge a'\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge a'
kind a' = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'
[PROOF STEP]
show False
[PROOF STATE]
proof (prove)
using this:
valid_edge a'
kind a' = Q'\<hookleftarrow>\<^bsub>Main\<^esub>f'

goal (1 subgoal):
 1. False
[PROOF STEP]
by(rule Main_no_return_source)
[PROOF STATE]
proof (state)
this:
False

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
sourcenode a' \<noteq> Entry

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit e'
[PROOF STEP]
with \<open>e' = (Node (sourcenode a'), kind a', Node (targetnode a'))\<close>
        \<open>valid_edge a'\<close>
[PROOF STATE]
proof (chain)
picking this:
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
valid_edge a'
sourcenode a' \<noteq> Entry
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
valid_edge a'
sourcenode a' \<noteq> Entry

goal (1 subgoal):
 1. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit e'
[PROOF STEP]
by(fastforce intro:lve_edge)
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit e'

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'

goal (11 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 2. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 8. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 9. distinct_fst procs
 10. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
A total of 11 subgoals...
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (11 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 2. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 8. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 9. distinct_fst procs
 10. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
A total of 11 subgoals...
[PROOF STEP]
fix a a'
[PROOF STATE]
proof (state)
goal (11 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 2. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 8. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 9. distinct_fst procs
 10. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
A total of 11 subgoals...
[PROOF STEP]
assume "a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode
      targetnode kind a"
      and "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
[PROOF STATE]
proof (state)
this:
a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a

goal (11 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
 2. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 5. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 6. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 7. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 8. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 9. distinct_fst procs
 10. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
A total of 11 subgoals...
[PROOF STEP]
thus "\<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
[PROOF STATE]
proof (prove)
using this:
a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a

goal (1 subgoal):
 1. \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
proof (induct rule:lift_get_return_edges.induct)
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
case (lift_get_return_edgesI ax a' e')
[PROOF STATE]
proof (state)
this:
a = (Node (sourcenode ax), kind ax, Node (targetnode ax))
valid_edge ax
a' \<in> get_return_edges ax
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
from \<open>valid_edge ax\<close> \<open>a' \<in> get_return_edges ax\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
a' \<in> get_return_edges ax
[PROOF STEP]
have "\<exists>Q r p fs. kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
a' \<in> get_return_edges ax

goal (1 subgoal):
 1. \<exists>Q r p fs. kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
by(rule only_call_get_return_edges)
[PROOF STATE]
proof (state)
this:
\<exists>Q r p fs. kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
with \<open>a = (Node (sourcenode ax), kind ax, Node (targetnode ax))\<close>
[PROOF STATE]
proof (chain)
picking this:
a = (Node (sourcenode ax), kind ax, Node (targetnode ax))
\<exists>Q r p fs. kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
a = (Node (sourcenode ax), kind ax, Node (targetnode ax))
\<exists>Q r p fs. kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. \<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<exists>Q r p fs. knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (10 subgoals):
 1. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 7. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 8. distinct_fst procs
 9. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 10. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (10 subgoals):
 1. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 7. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 8. distinct_fst procs
 9. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 10. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
fix a Q r p fs a'
[PROOF STATE]
proof (state)
goal (10 subgoals):
 1. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 7. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 8. distinct_fst procs
 9. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 10. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
assume "a' \<in> lift_get_return_edges get_return_edges
      valid_edge sourcenode targetnode kind a" and "knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
      and "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
[PROOF STATE]
proof (state)
this:
a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a

goal (10 subgoals):
 1. \<And>a Q r p fs a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 4. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 5. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 6. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 7. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 8. distinct_fst procs
 9. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 10. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
thus "\<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'"
[PROOF STATE]
proof (prove)
using this:
a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a

goal (1 subgoal):
 1. \<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
proof (induct rule:lift_get_return_edges.induct)
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd e' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
case (lift_get_return_edgesI ax a' e')
[PROOF STATE]
proof (state)
this:
a = (Node (sourcenode ax), kind ax, Node (targetnode ax))
valid_edge ax
a' \<in> get_return_edges ax
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd e' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
from \<open>a = (Node (sourcenode ax), kind ax, Node (targetnode ax))\<close>
        \<open>knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<close>
[PROOF STATE]
proof (chain)
picking this:
a = (Node (sourcenode ax), kind ax, Node (targetnode ax))
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
have "kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
[PROOF STATE]
proof (prove)
using this:
a = (Node (sourcenode ax), kind ax, Node (targetnode ax))
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd e' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
with \<open>valid_edge ax\<close> \<open>a' \<in> get_return_edges ax\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
a' \<in> get_return_edges ax
kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
have "\<exists>Q' f'. kind a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
a' \<in> get_return_edges ax
kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. \<exists>Q' f'. kind a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
by -(rule call_return_edges)
[PROOF STATE]
proof (state)
this:
\<exists>Q' f'. kind a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>Q' f'. knd e' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
with \<open>e' = (Node (sourcenode a'), kind a', Node (targetnode a'))\<close>
[PROOF STATE]
proof (chain)
picking this:
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
\<exists>Q' f'. kind a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
\<exists>Q' f'. kind a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (1 subgoal):
 1. \<exists>Q' f'. knd e' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<exists>Q' f'. knd e' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<exists>Q' f'. knd a' = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (9 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 6. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 7. distinct_fst procs
 8. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 9. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (9 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 6. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 7. distinct_fst procs
 8. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 9. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
fix a Q' p f'
[PROOF STATE]
proof (state)
goal (9 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 6. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 7. distinct_fst procs
 8. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 9. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (9 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 3. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 4. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 5. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 6. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 7. distinct_fst procs
 8. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 9. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
thus "\<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and>
      (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges
      valid_edge sourcenode targetnode kind a'"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (1 subgoal):
 1. \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
proof(induct rule:lift_valid_edge.induct)
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
case (lve_edge a e)
[PROOF STATE]
proof (state)
this:
valid_edge a
sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit
e = (Node (sourcenode a), kind a, Node (targetnode a))
knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
from \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close>
        \<open>knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<close>
[PROOF STATE]
proof (chain)
picking this:
e = (Node (sourcenode a), kind a, Node (targetnode a))
knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
have "kind a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'"
[PROOF STATE]
proof (prove)
using this:
e = (Node (sourcenode a), kind a, Node (targetnode a))
knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (1 subgoal):
 1. kind a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
kind a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
with \<open>valid_edge a\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge a
kind a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
have "\<exists>!a'. valid_edge a' \<and> (\<exists>Q r fs. kind a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and>
        a \<in> get_return_edges a'"
[PROOF STATE]
proof (prove)
using this:
valid_edge a
kind a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (1 subgoal):
 1. \<exists>!a'. valid_edge a' \<and> (\<exists>Q r fs. kind a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> get_return_edges a'
[PROOF STEP]
by(rule return_needs_call)
[PROOF STATE]
proof (state)
this:
\<exists>!a'. valid_edge a' \<and> (\<exists>Q r fs. kind a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> get_return_edges a'

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
\<exists>!a'. valid_edge a' \<and> (\<exists>Q r fs. kind a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> get_return_edges a'
[PROOF STEP]
obtain a' Q r fs where "valid_edge a'" and "kind a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
        and "a \<in> get_return_edges a'"
        and imp:"\<forall>x. valid_edge x \<and> (\<exists>Q r fs. kind x = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and>
        a \<in> get_return_edges x \<longrightarrow> x = a'"
[PROOF STATE]
proof (prove)
using this:
\<exists>!a'. valid_edge a' \<and> (\<exists>Q r fs. kind a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> get_return_edges a'

goal (1 subgoal):
 1. (\<And>a' Q r fs. \<lbrakk>valid_edge a'; kind a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; a \<in> get_return_edges a'; \<forall>x. valid_edge x \<and> (\<exists>Q r fs. kind x = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> get_return_edges x \<longrightarrow> x = a'\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(fastforce elim:ex1E)
[PROOF STATE]
proof (state)
this:
valid_edge a'
kind a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
a \<in> get_return_edges a'
\<forall>x. valid_edge x \<and> (\<exists>Q r fs. kind x = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> get_return_edges x \<longrightarrow> x = a'

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
let ?e' = "(Node (sourcenode a'),kind a',Node (targetnode a'))"
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
have "sourcenode a' \<noteq> Entry"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. sourcenode a' \<noteq> Entry
[PROOF STEP]
proof
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. sourcenode a' = Entry \<Longrightarrow> False
[PROOF STEP]
assume "sourcenode a' = Entry"
[PROOF STATE]
proof (state)
this:
sourcenode a' = Entry

goal (1 subgoal):
 1. sourcenode a' = Entry \<Longrightarrow> False
[PROOF STEP]
with \<open>valid_edge a'\<close> \<open>kind a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge a'
kind a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
sourcenode a' = Entry
[PROOF STEP]
show False
[PROOF STATE]
proof (prove)
using this:
valid_edge a'
kind a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
sourcenode a' = Entry

goal (1 subgoal):
 1. False
[PROOF STEP]
by(rule Entry_no_call_source)
[PROOF STATE]
proof (state)
this:
False

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
sourcenode a' \<noteq> Entry

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
with \<open>valid_edge a'\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge a'
sourcenode a' \<noteq> Entry
[PROOF STEP]
have "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?e'"
[PROOF STATE]
proof (prove)
using this:
valid_edge a'
sourcenode a' \<noteq> Entry

goal (1 subgoal):
 1. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
by(fastforce intro:lift_valid_edge.lve_edge)
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
from \<open>kind a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<close>
[PROOF STATE]
proof (chain)
picking this:
kind a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
have "knd ?e' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
[PROOF STATE]
proof (prove)
using this:
kind a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. knd (Node (sourcenode a'), kind a', Node (targetnode a')) = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
knd (Node (sourcenode a'), kind a', Node (targetnode a')) = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
knd (Node (sourcenode a'), kind a', Node (targetnode a')) = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
from \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close>
        \<open>valid_edge a'\<close> \<open>a \<in> get_return_edges a'\<close>
[PROOF STATE]
proof (chain)
picking this:
e = (Node (sourcenode a), kind a, Node (targetnode a))
valid_edge a'
a \<in> get_return_edges a'
[PROOF STEP]
have "e \<in> lift_get_return_edges get_return_edges valid_edge
        sourcenode targetnode kind ?e'"
[PROOF STATE]
proof (prove)
using this:
e = (Node (sourcenode a), kind a, Node (targetnode a))
valid_edge a'
a \<in> get_return_edges a'

goal (1 subgoal):
 1. e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
by(fastforce intro:lift_get_return_edgesI)
[PROOF STATE]
proof (state)
this:
e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
{
[PROOF STATE]
proof (state)
this:
e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
fix x
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit x"
          and "\<exists>Q r fs. knd x = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
          and "e \<in> lift_get_return_edges get_return_edges valid_edge
          sourcenode targetnode kind x"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit x
\<exists>Q r fs. knd x = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind x

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
from \<open>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit x\<close>
          \<open>\<exists>Q r fs. knd x = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<close>
[PROOF STATE]
proof (chain)
picking this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit x
\<exists>Q r fs. knd x = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
obtain y where "valid_edge y"
          and "x = (Node (sourcenode y), kind y, Node (targetnode y))"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit x
\<exists>Q r fs. knd x = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. (\<And>y. \<lbrakk>valid_edge y; x = (Node (sourcenode y), kind y, Node (targetnode y))\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(fastforce elim:lift_valid_edge.cases)
[PROOF STATE]
proof (state)
this:
valid_edge y
x = (Node (sourcenode y), kind y, Node (targetnode y))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
with \<open>e \<in> lift_get_return_edges get_return_edges valid_edge
          sourcenode targetnode kind x\<close> \<open>valid_edge a\<close>
          \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close>
[PROOF STATE]
proof (chain)
picking this:
e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind x
valid_edge a
e = (Node (sourcenode a), kind a, Node (targetnode a))
valid_edge y
x = (Node (sourcenode y), kind y, Node (targetnode y))
[PROOF STEP]
have "x = ?e'"
[PROOF STATE]
proof (prove)
using this:
e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind x
valid_edge a
e = (Node (sourcenode a), kind a, Node (targetnode a))
valid_edge y
x = (Node (sourcenode y), kind y, Node (targetnode y))

goal (1 subgoal):
 1. x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
proof(induct rule:lift_get_return_edges.induct)
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>a a'a e'. \<lbrakk>x = (Node (sourcenode a), kind a, Node (targetnode a)); valid_edge a; a'a \<in> get_return_edges a; e' = (Node (sourcenode a'a), kind a'a, Node (targetnode a'a)); valid_edge a; e' = (Node (sourcenode a), kind a, Node (targetnode a)); valid_edge y; x = (Node (sourcenode y), kind y, Node (targetnode y))\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
case (lift_get_return_edgesI ax ax' e)
[PROOF STATE]
proof (state)
this:
x = (Node (sourcenode ax), kind ax, Node (targetnode ax))
valid_edge ax
ax' \<in> get_return_edges ax
e = (Node (sourcenode ax'), kind ax', Node (targetnode ax'))
valid_edge a
e = (Node (sourcenode a), kind a, Node (targetnode a))
valid_edge y
x = (Node (sourcenode y), kind y, Node (targetnode y))

goal (1 subgoal):
 1. \<And>a a'a e'. \<lbrakk>x = (Node (sourcenode a), kind a, Node (targetnode a)); valid_edge a; a'a \<in> get_return_edges a; e' = (Node (sourcenode a'a), kind a'a, Node (targetnode a'a)); valid_edge a; e' = (Node (sourcenode a), kind a, Node (targetnode a)); valid_edge y; x = (Node (sourcenode y), kind y, Node (targetnode y))\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
from \<open>valid_edge ax\<close> \<open>ax' \<in> get_return_edges ax\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
ax' \<in> get_return_edges ax
[PROOF STEP]
have "valid_edge ax'"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
ax' \<in> get_return_edges ax

goal (1 subgoal):
 1. valid_edge ax'
[PROOF STEP]
by(rule get_return_edges_valid)
[PROOF STATE]
proof (state)
this:
valid_edge ax'

goal (1 subgoal):
 1. \<And>a a'a e'. \<lbrakk>x = (Node (sourcenode a), kind a, Node (targetnode a)); valid_edge a; a'a \<in> get_return_edges a; e' = (Node (sourcenode a'a), kind a'a, Node (targetnode a'a)); valid_edge a; e' = (Node (sourcenode a), kind a, Node (targetnode a)); valid_edge y; x = (Node (sourcenode y), kind y, Node (targetnode y))\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
from \<open>e = (Node (sourcenode ax'), kind ax', Node (targetnode ax'))\<close>
            \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close>
[PROOF STATE]
proof (chain)
picking this:
e = (Node (sourcenode ax'), kind ax', Node (targetnode ax'))
e = (Node (sourcenode a), kind a, Node (targetnode a))
[PROOF STEP]
have "sourcenode a = sourcenode ax'" and "targetnode a = targetnode ax'"
[PROOF STATE]
proof (prove)
using this:
e = (Node (sourcenode ax'), kind ax', Node (targetnode ax'))
e = (Node (sourcenode a), kind a, Node (targetnode a))

goal (1 subgoal):
 1. sourcenode a = sourcenode ax' &&& targetnode a = targetnode ax'
[PROOF STEP]
by simp_all
[PROOF STATE]
proof (state)
this:
sourcenode a = sourcenode ax'
targetnode a = targetnode ax'

goal (1 subgoal):
 1. \<And>a a'a e'. \<lbrakk>x = (Node (sourcenode a), kind a, Node (targetnode a)); valid_edge a; a'a \<in> get_return_edges a; e' = (Node (sourcenode a'a), kind a'a, Node (targetnode a'a)); valid_edge a; e' = (Node (sourcenode a), kind a, Node (targetnode a)); valid_edge y; x = (Node (sourcenode y), kind y, Node (targetnode y))\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
with \<open>valid_edge a\<close> \<open>valid_edge ax'\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge a
valid_edge ax'
sourcenode a = sourcenode ax'
targetnode a = targetnode ax'
[PROOF STEP]
have [simp]:"a = ax'"
[PROOF STATE]
proof (prove)
using this:
valid_edge a
valid_edge ax'
sourcenode a = sourcenode ax'
targetnode a = targetnode ax'

goal (1 subgoal):
 1. a = ax'
[PROOF STEP]
by(rule edge_det)
[PROOF STATE]
proof (state)
this:
a = ax'

goal (1 subgoal):
 1. \<And>a a'a e'. \<lbrakk>x = (Node (sourcenode a), kind a, Node (targetnode a)); valid_edge a; a'a \<in> get_return_edges a; e' = (Node (sourcenode a'a), kind a'a, Node (targetnode a'a)); valid_edge a; e' = (Node (sourcenode a), kind a, Node (targetnode a)); valid_edge y; x = (Node (sourcenode y), kind y, Node (targetnode y))\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
from \<open>x = (Node (sourcenode ax), kind ax, Node (targetnode ax))\<close>
            \<open>\<exists>Q r fs. knd x = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<close>
[PROOF STATE]
proof (chain)
picking this:
x = (Node (sourcenode ax), kind ax, Node (targetnode ax))
\<exists>Q r fs. knd x = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
have "\<exists>Q r fs. kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
[PROOF STATE]
proof (prove)
using this:
x = (Node (sourcenode ax), kind ax, Node (targetnode ax))
\<exists>Q r fs. knd x = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. \<exists>Q r fs. kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<exists>Q r fs. kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. \<And>a a'a e'. \<lbrakk>x = (Node (sourcenode a), kind a, Node (targetnode a)); valid_edge a; a'a \<in> get_return_edges a; e' = (Node (sourcenode a'a), kind a'a, Node (targetnode a'a)); valid_edge a; e' = (Node (sourcenode a), kind a, Node (targetnode a)); valid_edge y; x = (Node (sourcenode y), kind y, Node (targetnode y))\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
with \<open>valid_edge ax\<close> \<open>ax' \<in> get_return_edges ax\<close> imp
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
ax' \<in> get_return_edges ax
\<forall>x. valid_edge x \<and> (\<exists>Q r fs. kind x = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> get_return_edges x \<longrightarrow> x = a'
\<exists>Q r fs. kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
have "ax = a'"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
ax' \<in> get_return_edges ax
\<forall>x. valid_edge x \<and> (\<exists>Q r fs. kind x = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> get_return_edges x \<longrightarrow> x = a'
\<exists>Q r fs. kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. ax = a'
[PROOF STEP]
by fastforce
[PROOF STATE]
proof (state)
this:
ax = a'

goal (1 subgoal):
 1. \<And>a a'a e'. \<lbrakk>x = (Node (sourcenode a), kind a, Node (targetnode a)); valid_edge a; a'a \<in> get_return_edges a; e' = (Node (sourcenode a'a), kind a'a, Node (targetnode a'a)); valid_edge a; e' = (Node (sourcenode a), kind a, Node (targetnode a)); valid_edge y; x = (Node (sourcenode y), kind y, Node (targetnode y))\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
with \<open>x = (Node (sourcenode ax), kind ax, Node (targetnode ax))\<close>
[PROOF STATE]
proof (chain)
picking this:
x = (Node (sourcenode ax), kind ax, Node (targetnode ax))
ax = a'
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
x = (Node (sourcenode ax), kind ax, Node (targetnode ax))
ax = a'

goal (1 subgoal):
 1. x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
x = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
x = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
\<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?x2; \<exists>Q r fs. knd ?x2 = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind ?x2\<rbrakk> \<Longrightarrow> ?x2 = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode a'), kind a', Node (targetnode a'))
knd (Node (sourcenode a'), kind a', Node (targetnode a')) = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind (Node (sourcenode a'), kind a', Node (targetnode a'))
\<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?x2; \<exists>Q r fs. knd ?x2 = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind ?x2\<rbrakk> \<Longrightarrow> ?x2 = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode a'), kind a', Node (targetnode a'))
knd (Node (sourcenode a'), kind a', Node (targetnode a')) = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind (Node (sourcenode a'), kind a', Node (targetnode a'))
\<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?x2; \<exists>Q r fs. knd ?x2 = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs; e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind ?x2\<rbrakk> \<Longrightarrow> ?x2 = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (1 subgoal):
 1. \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
by(blast intro:ex1I)
[PROOF STATE]
proof (state)
this:
\<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'

goal (3 subgoals):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 2. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
 3. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> e \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'
[PROOF STEP]
qed simp_all
[PROOF STATE]
proof (state)
this:
\<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> (\<exists>Q r fs. knd a' = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs) \<and> a \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a'

goal (8 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 5. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 6. distinct_fst procs
 7. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 8. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (8 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 5. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 6. distinct_fst procs
 7. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 8. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
fix a a'
[PROOF STATE]
proof (state)
goal (8 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 5. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 6. distinct_fst procs
 7. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 8. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
assume "a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode
      targetnode kind a"
      and "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
[PROOF STATE]
proof (state)
this:
a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a

goal (8 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 2. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 3. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 4. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 5. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 6. distinct_fst procs
 7. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 8. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
thus "\<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and>
      src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>"
[PROOF STATE]
proof (prove)
using this:
a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a

goal (1 subgoal):
 1. \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
proof(induct rule:lift_get_return_edges.induct)
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
case (lift_get_return_edgesI ax a' e')
[PROOF STATE]
proof (state)
this:
a = (Node (sourcenode ax), kind ax, Node (targetnode ax))
valid_edge ax
a' \<in> get_return_edges ax
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
from \<open>valid_edge ax\<close> \<open>a' \<in> get_return_edges ax\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
a' \<in> get_return_edges ax
[PROOF STEP]
obtain ax' where "valid_edge ax'" and "sourcenode ax' = targetnode ax"
        and "targetnode ax' = sourcenode a'" and "kind ax' = (\<lambda>cf. False)\<^sub>\<surd>"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
a' \<in> get_return_edges ax

goal (1 subgoal):
 1. (\<And>ax'. \<lbrakk>valid_edge ax'; sourcenode ax' = targetnode ax; targetnode ax' = sourcenode a'; kind ax' = (\<lambda>cf. False)\<^sub>\<surd>\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(fastforce dest:intra_proc_additional_edge)
[PROOF STATE]
proof (state)
this:
valid_edge ax'
sourcenode ax' = targetnode ax
targetnode ax' = sourcenode a'
kind ax' = (\<lambda>cf. False)\<^sub>\<surd>

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
let ?ex = "(Node (sourcenode ax'), kind ax', Node (targetnode ax'))"
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
have "targetnode ax \<noteq> Entry"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. targetnode ax \<noteq> Entry
[PROOF STEP]
proof
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. targetnode ax = Entry \<Longrightarrow> False
[PROOF STEP]
assume "targetnode ax = Entry"
[PROOF STATE]
proof (state)
this:
targetnode ax = Entry

goal (1 subgoal):
 1. targetnode ax = Entry \<Longrightarrow> False
[PROOF STEP]
with \<open>valid_edge ax\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
targetnode ax = Entry
[PROOF STEP]
show False
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
targetnode ax = Entry

goal (1 subgoal):
 1. False
[PROOF STEP]
by(rule Entry_target)
[PROOF STATE]
proof (state)
this:
False

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
targetnode ax \<noteq> Entry

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
with \<open>sourcenode ax' = targetnode ax\<close>
[PROOF STATE]
proof (chain)
picking this:
sourcenode ax' = targetnode ax
targetnode ax \<noteq> Entry
[PROOF STEP]
have "sourcenode ax' \<noteq> Entry"
[PROOF STATE]
proof (prove)
using this:
sourcenode ax' = targetnode ax
targetnode ax \<noteq> Entry

goal (1 subgoal):
 1. sourcenode ax' \<noteq> Entry
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
sourcenode ax' \<noteq> Entry

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
with \<open>valid_edge ax'\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax'
sourcenode ax' \<noteq> Entry
[PROOF STEP]
have "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?ex"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax'
sourcenode ax' \<noteq> Entry

goal (1 subgoal):
 1. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode ax'), kind ax', Node (targetnode ax'))
[PROOF STEP]
by(fastforce intro:lve_edge)
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode ax'), kind ax', Node (targetnode ax'))

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
with \<open>e' = (Node (sourcenode a'), kind a', Node (targetnode a'))\<close>
        \<open>a = (Node (sourcenode ax), kind ax, Node (targetnode ax))\<close>
        \<open>e' = (Node (sourcenode a'), kind a', Node (targetnode a'))\<close>
        \<open>sourcenode ax' = targetnode ax\<close> \<open>targetnode ax' = sourcenode a'\<close>
        \<open>kind ax' = (\<lambda>cf. False)\<^sub>\<surd>\<close>
[PROOF STATE]
proof (chain)
picking this:
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
a = (Node (sourcenode ax), kind ax, Node (targetnode ax))
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
sourcenode ax' = targetnode ax
targetnode ax' = sourcenode a'
kind ax' = (\<lambda>cf. False)\<^sub>\<surd>
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode ax'), kind ax', Node (targetnode ax'))
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
a = (Node (sourcenode ax), kind ax, Node (targetnode ax))
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
sourcenode ax' = targetnode ax
targetnode ax' = sourcenode a'
kind ax' = (\<lambda>cf. False)\<^sub>\<surd>
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode ax'), kind ax', Node (targetnode ax'))

goal (1 subgoal):
 1. \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = trg a \<and> trg a'' = src a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>

goal (7 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 4. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 5. distinct_fst procs
 6. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 7. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (7 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 4. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 5. distinct_fst procs
 6. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 7. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
fix a a'
[PROOF STATE]
proof (state)
goal (7 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 4. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 5. distinct_fst procs
 6. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 7. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
assume "a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode
      targetnode kind a"
      and "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
[PROOF STATE]
proof (state)
this:
a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a

goal (7 subgoals):
 1. \<And>a a'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
 2. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 3. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 4. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 5. distinct_fst procs
 6. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 7. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
thus "\<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and>
      src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>"
[PROOF STATE]
proof (prove)
using this:
a' \<in> lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind a
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a

goal (1 subgoal):
 1. \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
proof(induct rule:lift_get_return_edges.induct)
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
case (lift_get_return_edgesI ax a' e')
[PROOF STATE]
proof (state)
this:
a = (Node (sourcenode ax), kind ax, Node (targetnode ax))
valid_edge ax
a' \<in> get_return_edges ax
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
from \<open>valid_edge ax\<close> \<open>a' \<in> get_return_edges ax\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
a' \<in> get_return_edges ax
[PROOF STEP]
obtain ax' where "valid_edge ax'" and "sourcenode ax' = sourcenode ax"
        and "targetnode ax' = targetnode a'" and "kind ax' = (\<lambda>cf. False)\<^sub>\<surd>"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
a' \<in> get_return_edges ax

goal (1 subgoal):
 1. (\<And>ax'. \<lbrakk>valid_edge ax'; sourcenode ax' = sourcenode ax; targetnode ax' = targetnode a'; kind ax' = (\<lambda>cf. False)\<^sub>\<surd>\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(fastforce dest:call_return_node_edge)
[PROOF STATE]
proof (state)
this:
valid_edge ax'
sourcenode ax' = sourcenode ax
targetnode ax' = targetnode a'
kind ax' = (\<lambda>cf. False)\<^sub>\<surd>

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
let ?ex = "(Node (sourcenode ax'), kind ax', Node (targetnode ax'))"
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
from \<open>valid_edge ax\<close> \<open>a' \<in> get_return_edges ax\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
a' \<in> get_return_edges ax
[PROOF STEP]
obtain Q r p fs where "kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
a' \<in> get_return_edges ax

goal (1 subgoal):
 1. (\<And>Q r p fs. kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(fastforce dest!:only_call_get_return_edges)
[PROOF STATE]
proof (state)
this:
kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
have "sourcenode ax \<noteq> Entry"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. sourcenode ax \<noteq> Entry
[PROOF STEP]
proof
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. sourcenode ax = Entry \<Longrightarrow> False
[PROOF STEP]
assume "sourcenode ax = Entry"
[PROOF STATE]
proof (state)
this:
sourcenode ax = Entry

goal (1 subgoal):
 1. sourcenode ax = Entry \<Longrightarrow> False
[PROOF STEP]
with \<open>valid_edge ax\<close> \<open>kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
sourcenode ax = Entry
[PROOF STEP]
show False
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
kind ax = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
sourcenode ax = Entry

goal (1 subgoal):
 1. False
[PROOF STEP]
by(rule Entry_no_call_source)
[PROOF STATE]
proof (state)
this:
False

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
sourcenode ax \<noteq> Entry

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
with \<open>sourcenode ax' = sourcenode ax\<close>
[PROOF STATE]
proof (chain)
picking this:
sourcenode ax' = sourcenode ax
sourcenode ax \<noteq> Entry
[PROOF STEP]
have "sourcenode ax' \<noteq> Entry"
[PROOF STATE]
proof (prove)
using this:
sourcenode ax' = sourcenode ax
sourcenode ax \<noteq> Entry

goal (1 subgoal):
 1. sourcenode ax' \<noteq> Entry
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
sourcenode ax' \<noteq> Entry

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
with \<open>valid_edge ax'\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax'
sourcenode ax' \<noteq> Entry
[PROOF STEP]
have "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?ex"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax'
sourcenode ax' \<noteq> Entry

goal (1 subgoal):
 1. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode ax'), kind ax', Node (targetnode ax'))
[PROOF STEP]
by(fastforce intro:lve_edge)
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode ax'), kind ax', Node (targetnode ax'))

goal (1 subgoal):
 1. \<And>aa a' e'. \<lbrakk>a = (Node (sourcenode aa), kind aa, Node (targetnode aa)); valid_edge aa; a' \<in> get_return_edges aa; e' = (Node (sourcenode a'), kind a', Node (targetnode a')); lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a\<rbrakk> \<Longrightarrow> \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
with \<open>e' = (Node (sourcenode a'), kind a', Node (targetnode a'))\<close>
        \<open>a = (Node (sourcenode ax), kind ax, Node (targetnode ax))\<close>
        \<open>e' = (Node (sourcenode a'), kind a', Node (targetnode a'))\<close>
        \<open>sourcenode ax' = sourcenode ax\<close> \<open>targetnode ax' = targetnode a'\<close>
        \<open>kind ax' = (\<lambda>cf. False)\<^sub>\<surd>\<close>
[PROOF STATE]
proof (chain)
picking this:
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
a = (Node (sourcenode ax), kind ax, Node (targetnode ax))
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
sourcenode ax' = sourcenode ax
targetnode ax' = targetnode a'
kind ax' = (\<lambda>cf. False)\<^sub>\<surd>
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode ax'), kind ax', Node (targetnode ax'))
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
a = (Node (sourcenode ax), kind ax, Node (targetnode ax))
e' = (Node (sourcenode a'), kind a', Node (targetnode a'))
sourcenode ax' = sourcenode ax
targetnode ax' = targetnode a'
kind ax' = (\<lambda>cf. False)\<^sub>\<surd>
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode ax'), kind ax', Node (targetnode ax'))

goal (1 subgoal):
 1. \<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg e' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<exists>a''. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'' \<and> src a'' = src a \<and> trg a'' = trg a' \<and> knd a'' = (\<lambda>cf. False)\<^sub>\<surd>

goal (6 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 3. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 4. distinct_fst procs
 5. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 6. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (6 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 3. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 4. distinct_fst procs
 5. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 6. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
fix a Q r p fs
[PROOF STATE]
proof (state)
goal (6 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 3. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 4. distinct_fst procs
 5. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 6. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (6 subgoals):
 1. \<And>a Q r p fs. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
 2. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 3. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 4. distinct_fst procs
 5. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 6. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
thus "\<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and>
      src a' = src a \<and> intra_kind (knd a')"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')
[PROOF STEP]
proof(induct rule:lift_valid_edge.induct)
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
case (lve_edge a e)
[PROOF STATE]
proof (state)
this:
valid_edge a
sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit
e = (Node (sourcenode a), kind a, Node (targetnode a))
knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
from \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close> \<open>knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<close>
[PROOF STATE]
proof (chain)
picking this:
e = (Node (sourcenode a), kind a, Node (targetnode a))
knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
have "kind a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs"
[PROOF STATE]
proof (prove)
using this:
e = (Node (sourcenode a), kind a, Node (targetnode a))
knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. kind a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
kind a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
with \<open>valid_edge a\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge a
kind a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
[PROOF STEP]
have "\<exists>!a'. valid_edge a' \<and> sourcenode a' = sourcenode a \<and>
        intra_kind(kind a')"
[PROOF STATE]
proof (prove)
using this:
valid_edge a
kind a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs

goal (1 subgoal):
 1. \<exists>!a'. valid_edge a' \<and> sourcenode a' = sourcenode a \<and> intra_kind (kind a')
[PROOF STEP]
by(rule call_only_one_intra_edge)
[PROOF STATE]
proof (state)
this:
\<exists>!a'. valid_edge a' \<and> sourcenode a' = sourcenode a \<and> intra_kind (kind a')

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
\<exists>!a'. valid_edge a' \<and> sourcenode a' = sourcenode a \<and> intra_kind (kind a')
[PROOF STEP]
obtain a' where "valid_edge a'" and "sourcenode a' = sourcenode a"
        and "intra_kind(kind a')"
        and imp:"\<forall>x. valid_edge x \<and> sourcenode x = sourcenode a \<and> intra_kind(kind x)
        \<longrightarrow> x = a'"
[PROOF STATE]
proof (prove)
using this:
\<exists>!a'. valid_edge a' \<and> sourcenode a' = sourcenode a \<and> intra_kind (kind a')

goal (1 subgoal):
 1. (\<And>a'. \<lbrakk>valid_edge a'; sourcenode a' = sourcenode a; intra_kind (kind a'); \<forall>x. valid_edge x \<and> sourcenode x = sourcenode a \<and> intra_kind (kind x) \<longrightarrow> x = a'\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(fastforce elim:ex1E)
[PROOF STATE]
proof (state)
this:
valid_edge a'
sourcenode a' = sourcenode a
intra_kind (kind a')
\<forall>x. valid_edge x \<and> sourcenode x = sourcenode a \<and> intra_kind (kind x) \<longrightarrow> x = a'

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
let ?e' = "(Node (sourcenode a'), kind a', Node (targetnode a'))"
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
have "sourcenode a \<noteq> Entry"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. sourcenode a \<noteq> Entry
[PROOF STEP]
proof
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. sourcenode a = Entry \<Longrightarrow> False
[PROOF STEP]
assume "sourcenode a = Entry"
[PROOF STATE]
proof (state)
this:
sourcenode a = Entry

goal (1 subgoal):
 1. sourcenode a = Entry \<Longrightarrow> False
[PROOF STEP]
with \<open>valid_edge a\<close> \<open>kind a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge a
kind a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
sourcenode a = Entry
[PROOF STEP]
show False
[PROOF STATE]
proof (prove)
using this:
valid_edge a
kind a = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs
sourcenode a = Entry

goal (1 subgoal):
 1. False
[PROOF STEP]
by(rule Entry_no_call_source)
[PROOF STATE]
proof (state)
this:
False

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
sourcenode a \<noteq> Entry

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
with \<open>sourcenode a' = sourcenode a\<close>
[PROOF STATE]
proof (chain)
picking this:
sourcenode a' = sourcenode a
sourcenode a \<noteq> Entry
[PROOF STEP]
have "sourcenode a' \<noteq> Entry"
[PROOF STATE]
proof (prove)
using this:
sourcenode a' = sourcenode a
sourcenode a \<noteq> Entry

goal (1 subgoal):
 1. sourcenode a' \<noteq> Entry
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
sourcenode a' \<noteq> Entry

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
with \<open>valid_edge a'\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge a'
sourcenode a' \<noteq> Entry
[PROOF STEP]
have "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?e'"
[PROOF STATE]
proof (prove)
using this:
valid_edge a'
sourcenode a' \<noteq> Entry

goal (1 subgoal):
 1. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
by(fastforce intro:lift_valid_edge.lve_edge)
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
from \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close>
        \<open>sourcenode a' = sourcenode a\<close>
[PROOF STATE]
proof (chain)
picking this:
e = (Node (sourcenode a), kind a, Node (targetnode a))
sourcenode a' = sourcenode a
[PROOF STEP]
have "src ?e' = src e"
[PROOF STATE]
proof (prove)
using this:
e = (Node (sourcenode a), kind a, Node (targetnode a))
sourcenode a' = sourcenode a

goal (1 subgoal):
 1. src (Node (sourcenode a'), kind a', Node (targetnode a')) = src e
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
src (Node (sourcenode a'), kind a', Node (targetnode a')) = src e

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
src (Node (sourcenode a'), kind a', Node (targetnode a')) = src e

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
from \<open>intra_kind(kind a')\<close>
[PROOF STATE]
proof (chain)
picking this:
intra_kind (kind a')
[PROOF STEP]
have "intra_kind (knd ?e')"
[PROOF STATE]
proof (prove)
using this:
intra_kind (kind a')

goal (1 subgoal):
 1. intra_kind (knd (Node (sourcenode a'), kind a', Node (targetnode a')))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
intra_kind (knd (Node (sourcenode a'), kind a', Node (targetnode a')))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
intra_kind (knd (Node (sourcenode a'), kind a', Node (targetnode a')))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
{
[PROOF STATE]
proof (state)
this:
intra_kind (knd (Node (sourcenode a'), kind a', Node (targetnode a')))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
fix x
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit x"
          and "src x = src e" and "intra_kind (knd x)"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit x
src x = src e
intra_kind (knd x)

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
from \<open>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit x\<close>
[PROOF STATE]
proof (chain)
picking this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit x
[PROOF STEP]
have "x = ?e'"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit x

goal (1 subgoal):
 1. x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
proof(induct rule:lift_valid_edge.cases)
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>a e. \<lbrakk>x = e; valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a))\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 4. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
case (lve_edge ax ex)
[PROOF STATE]
proof (state)
this:
x = ex
valid_edge ax
sourcenode ax \<noteq> Entry \<or> targetnode ax \<noteq> Exit
ex = (Node (sourcenode ax), kind ax, Node (targetnode ax))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>x = e; valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a))\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 4. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
from \<open>intra_kind (knd x)\<close> \<open>x = ex\<close> \<open>src x = src e\<close>
            \<open>ex = (Node (sourcenode ax), kind ax, Node (targetnode ax))\<close>
            \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close>
[PROOF STATE]
proof (chain)
picking this:
intra_kind (knd x)
x = ex
src x = src e
ex = (Node (sourcenode ax), kind ax, Node (targetnode ax))
e = (Node (sourcenode a), kind a, Node (targetnode a))
[PROOF STEP]
have "intra_kind (kind ax)" and "sourcenode ax = sourcenode a"
[PROOF STATE]
proof (prove)
using this:
intra_kind (knd x)
x = ex
src x = src e
ex = (Node (sourcenode ax), kind ax, Node (targetnode ax))
e = (Node (sourcenode a), kind a, Node (targetnode a))

goal (1 subgoal):
 1. intra_kind (kind ax) &&& sourcenode ax = sourcenode a
[PROOF STEP]
by simp_all
[PROOF STATE]
proof (state)
this:
intra_kind (kind ax)
sourcenode ax = sourcenode a

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>x = e; valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a))\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 4. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
with \<open>valid_edge ax\<close> imp
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
\<forall>x. valid_edge x \<and> sourcenode x = sourcenode a \<and> intra_kind (kind x) \<longrightarrow> x = a'
intra_kind (kind ax)
sourcenode ax = sourcenode a
[PROOF STEP]
have "ax = a'"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
\<forall>x. valid_edge x \<and> sourcenode x = sourcenode a \<and> intra_kind (kind x) \<longrightarrow> x = a'
intra_kind (kind ax)
sourcenode ax = sourcenode a

goal (1 subgoal):
 1. ax = a'
[PROOF STEP]
by fastforce
[PROOF STATE]
proof (state)
this:
ax = a'

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>x = e; valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a))\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 4. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
with \<open>x = ex\<close> \<open>ex = (Node (sourcenode ax), kind ax, Node (targetnode ax))\<close>
[PROOF STATE]
proof (chain)
picking this:
x = ex
ex = (Node (sourcenode ax), kind ax, Node (targetnode ax))
ax = a'
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
x = ex
ex = (Node (sourcenode ax), kind ax, Node (targetnode ax))
ax = a'

goal (1 subgoal):
 1. x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
x = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (3 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (3 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
case (lve_Entry_edge ex)
[PROOF STATE]
proof (state)
this:
x = ex
ex = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)

goal (3 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
with \<open>src x = src e\<close>
            \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close>
[PROOF STATE]
proof (chain)
picking this:
src x = src e
e = (Node (sourcenode a), kind a, Node (targetnode a))
x = ex
ex = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)
[PROOF STEP]
have False
[PROOF STATE]
proof (prove)
using this:
src x = src e
e = (Node (sourcenode a), kind a, Node (targetnode a))
x = ex
ex = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)

goal (1 subgoal):
 1. False
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
False

goal (3 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
False

goal (1 subgoal):
 1. x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
x = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (2 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
case (lve_Exit_edge ex)
[PROOF STATE]
proof (state)
this:
x = ex
ex = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)

goal (2 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
with \<open>src x = src e\<close>
            \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close>
[PROOF STATE]
proof (chain)
picking this:
src x = src e
e = (Node (sourcenode a), kind a, Node (targetnode a))
x = ex
ex = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)
[PROOF STEP]
have "sourcenode a = Exit"
[PROOF STATE]
proof (prove)
using this:
src x = src e
e = (Node (sourcenode a), kind a, Node (targetnode a))
x = ex
ex = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)

goal (1 subgoal):
 1. sourcenode a = Exit
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
sourcenode a = Exit

goal (2 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
with \<open>valid_edge a\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge a
sourcenode a = Exit
[PROOF STEP]
have False
[PROOF STATE]
proof (prove)
using this:
valid_edge a
sourcenode a = Exit

goal (1 subgoal):
 1. False
[PROOF STEP]
by(rule Exit_source)
[PROOF STATE]
proof (state)
this:
False

goal (2 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
False

goal (1 subgoal):
 1. x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
x = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (1 subgoal):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
case (lve_Entry_Exit_edge ex)
[PROOF STATE]
proof (state)
this:
x = ex
ex = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)

goal (1 subgoal):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
with \<open>src x = src e\<close>
            \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close>
[PROOF STATE]
proof (chain)
picking this:
src x = src e
e = (Node (sourcenode a), kind a, Node (targetnode a))
x = ex
ex = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)
[PROOF STEP]
have False
[PROOF STATE]
proof (prove)
using this:
src x = src e
e = (Node (sourcenode a), kind a, Node (targetnode a))
x = ex
ex = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)

goal (1 subgoal):
 1. False
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
False

goal (1 subgoal):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
False

goal (1 subgoal):
 1. x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
x = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
x = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
\<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?x2; src ?x2 = src e; intra_kind (knd ?x2)\<rbrakk> \<Longrightarrow> ?x2 = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode a'), kind a', Node (targetnode a'))
src (Node (sourcenode a'), kind a', Node (targetnode a')) = src e
intra_kind (knd (Node (sourcenode a'), kind a', Node (targetnode a')))
\<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?x2; src ?x2 = src e; intra_kind (knd ?x2)\<rbrakk> \<Longrightarrow> ?x2 = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode a'), kind a', Node (targetnode a'))
src (Node (sourcenode a'), kind a', Node (targetnode a')) = src e
intra_kind (knd (Node (sourcenode a'), kind a', Node (targetnode a')))
\<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?x2; src ?x2 = src e; intra_kind (knd ?x2)\<rbrakk> \<Longrightarrow> ?x2 = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (1 subgoal):
 1. \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
by(blast intro:ex1I)
[PROOF STATE]
proof (state)
this:
\<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')

goal (3 subgoals):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q:r\<hookrightarrow>\<^bsub>p\<^esub>fs\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src e \<and> intra_kind (knd a')
[PROOF STEP]
qed simp_all
[PROOF STATE]
proof (state)
this:
\<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> src a' = src a \<and> intra_kind (knd a')

goal (5 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 2. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 3. distinct_fst procs
 4. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 5. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (5 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 2. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 3. distinct_fst procs
 4. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 5. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
fix a Q' p f'
[PROOF STATE]
proof (state)
goal (5 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 2. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 3. distinct_fst procs
 4. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 5. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (5 subgoals):
 1. \<And>a Q' p f'. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
 2. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 3. distinct_fst procs
 4. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 5. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
thus "\<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and>
      trg a' = trg a \<and> intra_kind (knd a')"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
knd a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (1 subgoal):
 1. \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')
[PROOF STEP]
proof(induct rule:lift_valid_edge.induct)
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
case (lve_edge a e)
[PROOF STATE]
proof (state)
this:
valid_edge a
sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit
e = (Node (sourcenode a), kind a, Node (targetnode a))
knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
from \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close> \<open>knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<close>
[PROOF STATE]
proof (chain)
picking this:
e = (Node (sourcenode a), kind a, Node (targetnode a))
knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
have "kind a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'"
[PROOF STATE]
proof (prove)
using this:
e = (Node (sourcenode a), kind a, Node (targetnode a))
knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (1 subgoal):
 1. kind a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
kind a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
with \<open>valid_edge a\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge a
kind a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
[PROOF STEP]
have "\<exists>!a'. valid_edge a' \<and> targetnode a' = targetnode a \<and>
        intra_kind(kind a')"
[PROOF STATE]
proof (prove)
using this:
valid_edge a
kind a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'

goal (1 subgoal):
 1. \<exists>!a'. valid_edge a' \<and> targetnode a' = targetnode a \<and> intra_kind (kind a')
[PROOF STEP]
by(rule return_only_one_intra_edge)
[PROOF STATE]
proof (state)
this:
\<exists>!a'. valid_edge a' \<and> targetnode a' = targetnode a \<and> intra_kind (kind a')

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
\<exists>!a'. valid_edge a' \<and> targetnode a' = targetnode a \<and> intra_kind (kind a')
[PROOF STEP]
obtain a' where "valid_edge a'" and "targetnode a' = targetnode a"
        and "intra_kind(kind a')"
        and imp:"\<forall>x. valid_edge x \<and> targetnode x = targetnode a \<and> intra_kind(kind x)
        \<longrightarrow> x = a'"
[PROOF STATE]
proof (prove)
using this:
\<exists>!a'. valid_edge a' \<and> targetnode a' = targetnode a \<and> intra_kind (kind a')

goal (1 subgoal):
 1. (\<And>a'. \<lbrakk>valid_edge a'; targetnode a' = targetnode a; intra_kind (kind a'); \<forall>x. valid_edge x \<and> targetnode x = targetnode a \<and> intra_kind (kind x) \<longrightarrow> x = a'\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(fastforce elim:ex1E)
[PROOF STATE]
proof (state)
this:
valid_edge a'
targetnode a' = targetnode a
intra_kind (kind a')
\<forall>x. valid_edge x \<and> targetnode x = targetnode a \<and> intra_kind (kind x) \<longrightarrow> x = a'

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
let ?e' = "(Node (sourcenode a'), kind a', Node (targetnode a'))"
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
have "targetnode a \<noteq> Exit"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. targetnode a \<noteq> Exit
[PROOF STEP]
proof
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. targetnode a = Exit \<Longrightarrow> False
[PROOF STEP]
assume "targetnode a = Exit"
[PROOF STATE]
proof (state)
this:
targetnode a = Exit

goal (1 subgoal):
 1. targetnode a = Exit \<Longrightarrow> False
[PROOF STEP]
with \<open>valid_edge a\<close> \<open>kind a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge a
kind a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
targetnode a = Exit
[PROOF STEP]
show False
[PROOF STATE]
proof (prove)
using this:
valid_edge a
kind a = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'
targetnode a = Exit

goal (1 subgoal):
 1. False
[PROOF STEP]
by(rule Exit_no_return_target)
[PROOF STATE]
proof (state)
this:
False

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
targetnode a \<noteq> Exit

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
with \<open>targetnode a' = targetnode a\<close>
[PROOF STATE]
proof (chain)
picking this:
targetnode a' = targetnode a
targetnode a \<noteq> Exit
[PROOF STEP]
have "targetnode a' \<noteq> Exit"
[PROOF STATE]
proof (prove)
using this:
targetnode a' = targetnode a
targetnode a \<noteq> Exit

goal (1 subgoal):
 1. targetnode a' \<noteq> Exit
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
targetnode a' \<noteq> Exit

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
with \<open>valid_edge a'\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge a'
targetnode a' \<noteq> Exit
[PROOF STEP]
have "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?e'"
[PROOF STATE]
proof (prove)
using this:
valid_edge a'
targetnode a' \<noteq> Exit

goal (1 subgoal):
 1. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
by(fastforce intro:lift_valid_edge.lve_edge)
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
from \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close>
        \<open>targetnode a' = targetnode a\<close>
[PROOF STATE]
proof (chain)
picking this:
e = (Node (sourcenode a), kind a, Node (targetnode a))
targetnode a' = targetnode a
[PROOF STEP]
have "trg ?e' = trg e"
[PROOF STATE]
proof (prove)
using this:
e = (Node (sourcenode a), kind a, Node (targetnode a))
targetnode a' = targetnode a

goal (1 subgoal):
 1. trg (Node (sourcenode a'), kind a', Node (targetnode a')) = trg e
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
trg (Node (sourcenode a'), kind a', Node (targetnode a')) = trg e

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
trg (Node (sourcenode a'), kind a', Node (targetnode a')) = trg e

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
from \<open>intra_kind(kind a')\<close>
[PROOF STATE]
proof (chain)
picking this:
intra_kind (kind a')
[PROOF STEP]
have "intra_kind (knd ?e')"
[PROOF STATE]
proof (prove)
using this:
intra_kind (kind a')

goal (1 subgoal):
 1. intra_kind (knd (Node (sourcenode a'), kind a', Node (targetnode a')))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
intra_kind (knd (Node (sourcenode a'), kind a', Node (targetnode a')))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
intra_kind (knd (Node (sourcenode a'), kind a', Node (targetnode a')))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
{
[PROOF STATE]
proof (state)
this:
intra_kind (knd (Node (sourcenode a'), kind a', Node (targetnode a')))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
fix x
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit x"
          and "trg x = trg e" and "intra_kind (knd x)"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit x
trg x = trg e
intra_kind (knd x)

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
from \<open>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit x\<close>
[PROOF STATE]
proof (chain)
picking this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit x
[PROOF STEP]
have "x = ?e'"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit x

goal (1 subgoal):
 1. x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
proof(induct rule:lift_valid_edge.cases)
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>a e. \<lbrakk>x = e; valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a))\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 4. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
case (lve_edge ax ex)
[PROOF STATE]
proof (state)
this:
x = ex
valid_edge ax
sourcenode ax \<noteq> Entry \<or> targetnode ax \<noteq> Exit
ex = (Node (sourcenode ax), kind ax, Node (targetnode ax))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>x = e; valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a))\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 4. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
from \<open>intra_kind (knd x)\<close> \<open>x = ex\<close> \<open>trg x = trg e\<close>
            \<open>ex = (Node (sourcenode ax), kind ax, Node (targetnode ax))\<close>
            \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close>
[PROOF STATE]
proof (chain)
picking this:
intra_kind (knd x)
x = ex
trg x = trg e
ex = (Node (sourcenode ax), kind ax, Node (targetnode ax))
e = (Node (sourcenode a), kind a, Node (targetnode a))
[PROOF STEP]
have "intra_kind (kind ax)" and "targetnode ax = targetnode a"
[PROOF STATE]
proof (prove)
using this:
intra_kind (knd x)
x = ex
trg x = trg e
ex = (Node (sourcenode ax), kind ax, Node (targetnode ax))
e = (Node (sourcenode a), kind a, Node (targetnode a))

goal (1 subgoal):
 1. intra_kind (kind ax) &&& targetnode ax = targetnode a
[PROOF STEP]
by simp_all
[PROOF STATE]
proof (state)
this:
intra_kind (kind ax)
targetnode ax = targetnode a

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>x = e; valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a))\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 4. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
with \<open>valid_edge ax\<close> imp
[PROOF STATE]
proof (chain)
picking this:
valid_edge ax
\<forall>x. valid_edge x \<and> targetnode x = targetnode a \<and> intra_kind (kind x) \<longrightarrow> x = a'
intra_kind (kind ax)
targetnode ax = targetnode a
[PROOF STEP]
have "ax = a'"
[PROOF STATE]
proof (prove)
using this:
valid_edge ax
\<forall>x. valid_edge x \<and> targetnode x = targetnode a \<and> intra_kind (kind x) \<longrightarrow> x = a'
intra_kind (kind ax)
targetnode ax = targetnode a

goal (1 subgoal):
 1. ax = a'
[PROOF STEP]
by fastforce
[PROOF STATE]
proof (state)
this:
ax = a'

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>x = e; valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a))\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 4. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
with \<open>x = ex\<close> \<open>ex = (Node (sourcenode ax), kind ax, Node (targetnode ax))\<close>
[PROOF STATE]
proof (chain)
picking this:
x = ex
ex = (Node (sourcenode ax), kind ax, Node (targetnode ax))
ax = a'
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
x = ex
ex = (Node (sourcenode ax), kind ax, Node (targetnode ax))
ax = a'

goal (1 subgoal):
 1. x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
x = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (3 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (3 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
case (lve_Entry_edge ex)
[PROOF STATE]
proof (state)
this:
x = ex
ex = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)

goal (3 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
with \<open>trg x = trg e\<close>
            \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close>
[PROOF STATE]
proof (chain)
picking this:
trg x = trg e
e = (Node (sourcenode a), kind a, Node (targetnode a))
x = ex
ex = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)
[PROOF STEP]
have "targetnode a = Entry"
[PROOF STATE]
proof (prove)
using this:
trg x = trg e
e = (Node (sourcenode a), kind a, Node (targetnode a))
x = ex
ex = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)

goal (1 subgoal):
 1. targetnode a = Entry
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
targetnode a = Entry

goal (3 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
with \<open>valid_edge a\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge a
targetnode a = Entry
[PROOF STEP]
have False
[PROOF STATE]
proof (prove)
using this:
valid_edge a
targetnode a = Entry

goal (1 subgoal):
 1. False
[PROOF STEP]
by(rule Entry_target)
[PROOF STATE]
proof (state)
this:
False

goal (3 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 3. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
False

goal (1 subgoal):
 1. x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
x = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (2 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
case (lve_Exit_edge ex)
[PROOF STATE]
proof (state)
this:
x = ex
ex = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)

goal (2 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
with \<open>trg x = trg e\<close>
            \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close>
[PROOF STATE]
proof (chain)
picking this:
trg x = trg e
e = (Node (sourcenode a), kind a, Node (targetnode a))
x = ex
ex = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)
[PROOF STEP]
have False
[PROOF STATE]
proof (prove)
using this:
trg x = trg e
e = (Node (sourcenode a), kind a, Node (targetnode a))
x = ex
ex = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)

goal (1 subgoal):
 1. False
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
False

goal (2 subgoals):
 1. \<And>e. \<lbrakk>x = e; e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
 2. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
False

goal (1 subgoal):
 1. x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
x = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (1 subgoal):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
case (lve_Entry_Exit_edge ex)
[PROOF STATE]
proof (state)
this:
x = ex
ex = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)

goal (1 subgoal):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
with \<open>trg x = trg e\<close>
            \<open>e = (Node (sourcenode a), kind a, Node (targetnode a))\<close>
[PROOF STATE]
proof (chain)
picking this:
trg x = trg e
e = (Node (sourcenode a), kind a, Node (targetnode a))
x = ex
ex = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)
[PROOF STEP]
have False
[PROOF STATE]
proof (prove)
using this:
trg x = trg e
e = (Node (sourcenode a), kind a, Node (targetnode a))
x = ex
ex = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)

goal (1 subgoal):
 1. False
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
False

goal (1 subgoal):
 1. \<And>e. \<lbrakk>x = e; e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit)\<rbrakk> \<Longrightarrow> x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
False

goal (1 subgoal):
 1. x = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
x = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
x = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
\<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?x2; trg ?x2 = trg e; intra_kind (knd ?x2)\<rbrakk> \<Longrightarrow> ?x2 = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (4 subgoals):
 1. \<And>a e. \<lbrakk>valid_edge a; sourcenode a \<noteq> Entry \<or> targetnode a \<noteq> Exit; e = (Node (sourcenode a), kind a, Node (targetnode a)); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 4. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode a'), kind a', Node (targetnode a'))
trg (Node (sourcenode a'), kind a', Node (targetnode a')) = trg e
intra_kind (knd (Node (sourcenode a'), kind a', Node (targetnode a')))
\<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?x2; trg ?x2 = trg e; intra_kind (knd ?x2)\<rbrakk> \<Longrightarrow> ?x2 = (Node (sourcenode a'), kind a', Node (targetnode a'))
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit (Node (sourcenode a'), kind a', Node (targetnode a'))
trg (Node (sourcenode a'), kind a', Node (targetnode a')) = trg e
intra_kind (knd (Node (sourcenode a'), kind a', Node (targetnode a')))
\<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit ?x2; trg ?x2 = trg e; intra_kind (knd ?x2)\<rbrakk> \<Longrightarrow> ?x2 = (Node (sourcenode a'), kind a', Node (targetnode a'))

goal (1 subgoal):
 1. \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
by(blast intro:ex1I)
[PROOF STATE]
proof (state)
this:
\<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')

goal (3 subgoals):
 1. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. True)\<^sub>\<surd>, Node Entry); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 2. \<And>e. \<lbrakk>e = (Node Exit, (\<lambda>s. True)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
 3. \<And>e. \<lbrakk>e = (NewEntry, (\<lambda>s. False)\<^sub>\<surd>, NewExit); knd e = Q'\<hookleftarrow>\<^bsub>p\<^esub>f'\<rbrakk> \<Longrightarrow> \<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg e \<and> intra_kind (knd a')
[PROOF STEP]
qed simp_all
[PROOF STATE]
proof (state)
this:
\<exists>!a'. lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a' \<and> trg a' = trg a \<and> intra_kind (knd a')

goal (4 subgoals):
 1. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 2. distinct_fst procs
 3. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 4. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 2. distinct_fst procs
 3. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 4. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
fix a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 2. distinct_fst procs
 3. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 4. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
assume "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a"
      and "lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'"
      and "knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1" and "knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2"
[PROOF STATE]
proof (state)
this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1
knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2

goal (4 subgoals):
 1. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 2. distinct_fst procs
 3. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 4. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1
knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2
[PROOF STEP]
obtain x x' where "valid_edge x"
      and a:"a = (Node (sourcenode x),kind x,Node (targetnode x))" and "valid_edge x'"
      and a':"a' = (Node (sourcenode x'),kind x',Node (targetnode x'))"
[PROOF STATE]
proof (prove)
using this:
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a
lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'
knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1
knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2

goal (1 subgoal):
 1. (\<And>x x'. \<lbrakk>valid_edge x; a = (Node (sourcenode x), kind x, Node (targetnode x)); valid_edge x'; a' = (Node (sourcenode x'), kind x', Node (targetnode x'))\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(auto elim!:lift_valid_edge.cases)
[PROOF STATE]
proof (state)
this:
valid_edge x
a = (Node (sourcenode x), kind x, Node (targetnode x))
valid_edge x'
a' = (Node (sourcenode x'), kind x', Node (targetnode x'))

goal (4 subgoals):
 1. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 2. distinct_fst procs
 3. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 4. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
with \<open>knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1\<close> \<open>knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<close>
[PROOF STATE]
proof (chain)
picking this:
knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1
knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2
valid_edge x
a = (Node (sourcenode x), kind x, Node (targetnode x))
valid_edge x'
a' = (Node (sourcenode x'), kind x', Node (targetnode x'))
[PROOF STEP]
have "kind x = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1" and "kind x' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2"
[PROOF STATE]
proof (prove)
using this:
knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1
knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2
valid_edge x
a = (Node (sourcenode x), kind x, Node (targetnode x))
valid_edge x'
a' = (Node (sourcenode x'), kind x', Node (targetnode x'))

goal (1 subgoal):
 1. kind x = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1 &&& kind x' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2
[PROOF STEP]
by simp_all
[PROOF STATE]
proof (state)
this:
kind x = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1
kind x' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2

goal (4 subgoals):
 1. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 2. distinct_fst procs
 3. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 4. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
with \<open>valid_edge x\<close> \<open>valid_edge x'\<close>
[PROOF STATE]
proof (chain)
picking this:
valid_edge x
valid_edge x'
kind x = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1
kind x' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2
[PROOF STEP]
have "targetnode x = targetnode x'"
[PROOF STATE]
proof (prove)
using this:
valid_edge x
valid_edge x'
kind x = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1
kind x' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2

goal (1 subgoal):
 1. targetnode x = targetnode x'
[PROOF STEP]
by(rule same_proc_call_unique_target)
[PROOF STATE]
proof (state)
this:
targetnode x = targetnode x'

goal (4 subgoals):
 1. \<And>a a' Q\<^sub>1 r\<^sub>1 p fs\<^sub>1 Q\<^sub>2 r\<^sub>2 fs\<^sub>2. \<lbrakk>lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a; lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit a'; knd a = Q\<^sub>1:r\<^sub>1\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>1; knd a' = Q\<^sub>2:r\<^sub>2\<hookrightarrow>\<^bsub>p\<^esub>fs\<^sub>2\<rbrakk> \<Longrightarrow> trg a = trg a'
 2. distinct_fst procs
 3. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 4. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
with a a'
[PROOF STATE]
proof (chain)
picking this:
a = (Node (sourcenode x), kind x, Node (targetnode x))
a' = (Node (sourcenode x'), kind x', Node (targetnode x'))
targetnode x = targetnode x'
[PROOF STEP]
show "trg a = trg a'"
[PROOF STATE]
proof (prove)
using this:
a = (Node (sourcenode x), kind x, Node (targetnode x))
a' = (Node (sourcenode x'), kind x', Node (targetnode x'))
targetnode x = targetnode x'

goal (1 subgoal):
 1. trg a = trg a'
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
trg a = trg a'

goal (3 subgoals):
 1. distinct_fst procs
 2. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 3. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (3 subgoals):
 1. distinct_fst procs
 2. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 3. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
from unique_callers
[PROOF STATE]
proof (chain)
picking this:
distinct_fst procs
[PROOF STEP]
show "distinct_fst procs"
[PROOF STATE]
proof (prove)
using this:
distinct_fst procs

goal (1 subgoal):
 1. distinct_fst procs
[PROOF STEP]
.
[PROOF STATE]
proof (state)
this:
distinct_fst procs

goal (2 subgoals):
 1. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 2. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 2. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
fix p ins outs
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 2. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
assume "(p, ins, outs) \<in> set procs"
[PROOF STATE]
proof (state)
this:
(p, ins, outs) \<in> set procs

goal (2 subgoals):
 1. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct ins
 2. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
from distinct_formal_ins[OF this]
[PROOF STATE]
proof (chain)
picking this:
distinct ins
[PROOF STEP]
show "distinct ins"
[PROOF STATE]
proof (prove)
using this:
distinct ins

goal (1 subgoal):
 1. distinct ins
[PROOF STEP]
.
[PROOF STATE]
proof (state)
this:
distinct ins

goal (1 subgoal):
 1. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
fix p ins outs
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
assume "(p, ins, outs) \<in> set procs"
[PROOF STATE]
proof (state)
this:
(p, ins, outs) \<in> set procs

goal (1 subgoal):
 1. \<And>p ins outs. (p, ins, outs) \<in> set procs \<Longrightarrow> distinct outs
[PROOF STEP]
from distinct_formal_outs[OF this]
[PROOF STATE]
proof (chain)
picking this:
distinct outs
[PROOF STEP]
show "distinct outs"
[PROOF STATE]
proof (prove)
using this:
distinct outs

goal (1 subgoal):
 1. distinct outs
[PROOF STEP]
.
[PROOF STATE]
proof (state)
this:
distinct outs

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
CFG src trg knd (lift_valid_edge valid_edge sourcenode targetnode kind Entry Exit) NewEntry (lift_get_proc get_proc Main) (lift_get_return_edges get_return_edges valid_edge sourcenode targetnode kind) procs Main

goal:
No subgoals!
[PROOF STEP]
qed