[STATEMENT]
lemma (in flowgraph) RU_precise: "(u,Ml,Me,h)\<in>RU_cs fg U
  \<Longrightarrow> \<exists>w s' c'.
    (([u],{#}),w,(s',c'))\<in>trcl (ntrp fg) \<and>
    atU U ({#s'#}+c') \<and>
    mon_loc fg w = Ml \<and>
    mon_env fg w = Me \<and>
    \<alpha>ah (map (\<alpha>nl fg) w) = h"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (u, Ml, Me, h) \<in> RU_cs fg U \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h
[PROOF STEP]
proof (induct rule: RU_cs.induct)
  \<comment> \<open>The @{text "RU_init"} constraint is trivially covered by the empty path\<close>
[PROOF STATE]
proof (state)
goal (3 subgoals):
 1. \<And>u. u \<in> U \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = {} \<and> mon_env fg w = {} \<and> \<alpha>ah (map (\<alpha>nl fg) w) = (\<lambda>a. {})
 2. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 3. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
case (RU_init u)
[PROOF STATE]
proof (state)
this:
u \<in> U

goal (3 subgoals):
 1. \<And>u. u \<in> U \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = {} \<and> mon_env fg w = {} \<and> \<alpha>ah (map (\<alpha>nl fg) w) = (\<lambda>a. {})
 2. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 3. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
u \<in> U

goal (1 subgoal):
 1. \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = {} \<and> mon_env fg w = {} \<and> \<alpha>ah (map (\<alpha>nl fg) w) = (\<lambda>a. {})
[PROOF STEP]
by (auto intro: exI[of _ "[]"])
[PROOF STATE]
proof (state)
this:
\<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = {} \<and> mon_env fg w = {} \<and> \<alpha>ah (map (\<alpha>nl fg) w) = (\<lambda>a. {})

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
next
  \<comment> \<open>Call constraint\<close>
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
case (RU_call u p u' v M P Ml Me h)
[PROOF STATE]
proof (state)
this:
(u, Call p, u') \<in> edges fg
proc_of fg v = p
(v, M, P) \<in> S_cs fg 0
(v, Ml, Me, h) \<in> RU_cs fg U
\<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h
mon_n fg u \<inter> Me = {}

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
(u, Call p, u') \<in> edges fg
proc_of fg v = p
(v, M, P) \<in> S_cs fg 0
(v, Ml, Me, h) \<in> RU_cs fg U
\<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h
mon_n fg u \<inter> Me = {}
[PROOF STEP]
obtain w s' c' where IHAPP: "(([v], {#}), w, s', c') \<in> trcl (ntrp fg)" "atU U ({#s'#} + c')" "mon_loc fg w = Ml" "mon_env fg w = Me" "\<alpha>ah (map (\<alpha>nl fg) w) = h"
[PROOF STATE]
proof (prove)
using this:
(u, Call p, u') \<in> edges fg
proc_of fg v = p
(v, M, P) \<in> S_cs fg 0
(v, Ml, Me, h) \<in> RU_cs fg U
\<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h
mon_n fg u \<inter> Me = {}

goal (1 subgoal):
 1. (\<And>w s' c'. \<lbrakk>(([v], {#}), w, s', c') \<in> trcl (ntrp fg); atU U ({#s'#} + c'); mon_loc fg w = Ml; mon_env fg w = Me; \<alpha>ah (map (\<alpha>nl fg) w) = h\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
(([v], {#}), w, s', c') \<in> trcl (ntrp fg)
atU U ({#s'#} + c')
mon_loc fg w = Ml
mon_env fg w = Me
\<alpha>ah (map (\<alpha>nl fg) w) = h

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
from RU_call.hyps(2) S_precise[OF RU_call.hyps(3), simplified] trss_bot_proc_const[where s="[]" and s'="[]", simplified]
[PROOF STATE]
proof (chain)
picking this:
proc_of fg v = p
\<exists>p c' w. (([entry fg p], {#}), w, [v], c') \<in> trcl (trss fg) \<and> P = {#} \<and> {#[entry fg p]. p \<in># P#} \<subseteq># c' \<and> M = mon_w fg w
(([?u], ?c), ?w, [?u'], ?c') \<in> trcl (trss fg) \<Longrightarrow> proc_of fg ?u = proc_of fg ?u'
[PROOF STEP]
obtain wsl ch where
    SLPATH: "(([entry fg p], {#}), wsl, [v], ch) \<in> trcl (trss fg)" "M = mon_w fg wsl"
[PROOF STATE]
proof (prove)
using this:
proc_of fg v = p
\<exists>p c' w. (([entry fg p], {#}), w, [v], c') \<in> trcl (trss fg) \<and> P = {#} \<and> {#[entry fg p]. p \<in># P#} \<subseteq># c' \<and> M = mon_w fg w
(([?u], ?c), ?w, [?u'], ?c') \<in> trcl (trss fg) \<Longrightarrow> proc_of fg ?u = proc_of fg ?u'

goal (1 subgoal):
 1. (\<And>wsl ch. \<lbrakk>(([entry fg p], {#}), wsl, [v], ch) \<in> trcl (trss fg); M = mon_w fg wsl\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by fastforce
[PROOF STATE]
proof (state)
this:
(([entry fg p], {#}), wsl, [v], ch) \<in> trcl (trss fg)
M = mon_w fg wsl

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
from trss_c_cases[OF SLPATH(1), simplified]
[PROOF STATE]
proof (chain)
picking this:
((\<And>s. s \<in># ch \<Longrightarrow> \<exists>p. s = [entry fg p] \<and> (\<exists>u v. (u, Spawn p, v) \<in> edges fg) \<and> initialproc fg p) \<Longrightarrow> ?P) \<Longrightarrow> ?P
[PROOF STEP]
have CHFMT: "\<And>s. s \<in># ch \<Longrightarrow> \<exists>p. s = [entry fg p] \<and> (\<exists>u v. (u, Spawn p, v) \<in> edges fg) \<and> initialproc fg p"
[PROOF STATE]
proof (prove)
using this:
((\<And>s. s \<in># ch \<Longrightarrow> \<exists>p. s = [entry fg p] \<and> (\<exists>u v. (u, Spawn p, v) \<in> edges fg) \<and> initialproc fg p) \<Longrightarrow> ?P) \<Longrightarrow> ?P

goal (1 subgoal):
 1. \<And>s. s \<in># ch \<Longrightarrow> \<exists>p. s = [entry fg p] \<and> (\<exists>u v. (u, Spawn p, v) \<in> edges fg) \<and> initialproc fg p
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
?s \<in># ch \<Longrightarrow> \<exists>p. ?s = [entry fg p] \<and> (\<exists>u v. (u, Spawn p, v) \<in> edges fg) \<and> initialproc fg p

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
with c_of_initial_no_mon
[PROOF STATE]
proof (chain)
picking this:
(\<And>s. s \<in># ?csp \<Longrightarrow> \<exists>p. s = [entry fg p] \<and> initialproc fg p) \<Longrightarrow> mon_c fg ?csp = {}
?s \<in># ch \<Longrightarrow> \<exists>p. ?s = [entry fg p] \<and> (\<exists>u v. (u, Spawn p, v) \<in> edges fg) \<and> initialproc fg p
[PROOF STEP]
have CHNOMON: "mon_c fg ch = {}"
[PROOF STATE]
proof (prove)
using this:
(\<And>s. s \<in># ?csp \<Longrightarrow> \<exists>p. s = [entry fg p] \<and> initialproc fg p) \<Longrightarrow> mon_c fg ?csp = {}
?s \<in># ch \<Longrightarrow> \<exists>p. ?s = [entry fg p] \<and> (\<exists>u v. (u, Spawn p, v) \<in> edges fg) \<and> initialproc fg p

goal (1 subgoal):
 1. mon_c fg ch = {}
[PROOF STEP]
by blast
    \<comment> \<open>From the constraints prerequisites, we can construct the first step\<close>
[PROOF STATE]
proof (state)
this:
mon_c fg ch = {}

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
have FS: "(([u],{#}),LCall p#wsl,([v,u'],ch))\<in>ntrs fg"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (([u], {#}), LCall p # wsl, [v, u'], ch) \<in> ntrs fg
[PROOF STEP]
proof (rule ntrs_step[where r="[]", simplified])
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. (([u], {#}), LCall p, [entry fg p, u'], {#}) \<in> trss fg
 2. (([entry fg p], {#}), wsl, [v], ch) \<in> trcl (trss fg)
[PROOF STEP]
from RU_call.hyps(1)
[PROOF STATE]
proof (chain)
picking this:
(u, Call p, u') \<in> edges fg
[PROOF STEP]
show "(([u], {#}), LCall p, [entry fg p, u'], {#}) \<in> trss fg"
[PROOF STATE]
proof (prove)
using this:
(u, Call p, u') \<in> edges fg

goal (1 subgoal):
 1. (([u], {#}), LCall p, [entry fg p, u'], {#}) \<in> trss fg
[PROOF STEP]
by (auto intro: trss_call)
[PROOF STATE]
proof (state)
this:
(([u], {#}), LCall p, [entry fg p, u'], {#}) \<in> trss fg

goal (1 subgoal):
 1. (([entry fg p], {#}), wsl, [v], ch) \<in> trcl (trss fg)
[PROOF STEP]
qed (rule SLPATH(1))
[PROOF STATE]
proof (state)
this:
(([u], {#}), LCall p # wsl, [v, u'], ch) \<in> ntrs fg

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
hence FSP: "(([u],{#}),LOC (LCall p#wsl),([v,u'],ch))\<in>ntrp fg"
[PROOF STATE]
proof (prove)
using this:
(([u], {#}), LCall p # wsl, [v, u'], ch) \<in> ntrs fg

goal (1 subgoal):
 1. (([u], {#}), LOC (LCall p # wsl), [v, u'], ch) \<in> ntrp fg
[PROOF STEP]
by (blast intro: gtrp_loc)
[PROOF STATE]
proof (state)
this:
(([u], {#}), LOC (LCall p # wsl), [v, u'], ch) \<in> ntrp fg

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
also
    \<comment> \<open>The rest of the path comes from the induction hypothesis, after adding the rest of the threads to the context\<close>
[PROOF STATE]
proof (state)
this:
(([u], {#}), LOC (LCall p # wsl), [v, u'], ch) \<in> ntrp fg

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
have "(([v, u'], ch), w, s' @ [u'], c' + ch) \<in> trcl (ntrp fg)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (([v, u'], ch), w, s' @ [u'], c' + ch) \<in> trcl (ntrp fg)
[PROOF STEP]
proof (rule ntrp_add_context[OF ntrp_stack_comp[OF IHAPP(1), where r="[u']"], where cn=ch, simplified])
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. mon_n fg u' \<inter> mon_env fg w = {}
 2. mon_ww fg (map le_rem_s w) \<inter> mon_c fg ch = {}
[PROOF STEP]
from RU_call.hyps(1,6) IHAPP(4)
[PROOF STATE]
proof (chain)
picking this:
(u, Call p, u') \<in> edges fg
mon_n fg u \<inter> Me = {}
mon_env fg w = Me
[PROOF STEP]
show "mon_n fg u' \<inter> mon_env fg w = {}"
[PROOF STATE]
proof (prove)
using this:
(u, Call p, u') \<in> edges fg
mon_n fg u \<inter> Me = {}
mon_env fg w = Me

goal (1 subgoal):
 1. mon_n fg u' \<inter> mon_env fg w = {}
[PROOF STEP]
by (auto simp add: mon_n_def edges_part)
[PROOF STATE]
proof (state)
this:
mon_n fg u' \<inter> mon_env fg w = {}

goal (1 subgoal):
 1. mon_ww fg (map le_rem_s w) \<inter> mon_c fg ch = {}
[PROOF STEP]
from CHNOMON
[PROOF STATE]
proof (chain)
picking this:
mon_c fg ch = {}
[PROOF STEP]
show "mon_ww fg (map le_rem_s w) \<inter> mon_c fg ch = {}"
[PROOF STATE]
proof (prove)
using this:
mon_c fg ch = {}

goal (1 subgoal):
 1. mon_ww fg (map le_rem_s w) \<inter> mon_c fg ch = {}
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
mon_ww fg (map le_rem_s w) \<inter> mon_c fg ch = {}

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
(([v, u'], ch), w, s' @ [u'], c' + ch) \<in> trcl (ntrp fg)

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
finally
[PROOF STATE]
proof (chain)
picking this:
(([u], {#}), LOC (LCall p # wsl) # w, s' @ [u'], c' + ch) \<in> trcl (ntrp fg)
[PROOF STEP]
have "(([u], {#}), LOC (LCall p # wsl) # w, s' @ [u'], c' + ch) \<in> trcl (ntrp fg)"
[PROOF STATE]
proof (prove)
using this:
(([u], {#}), LOC (LCall p # wsl) # w, s' @ [u'], c' + ch) \<in> trcl (ntrp fg)

goal (1 subgoal):
 1. (([u], {#}), LOC (LCall p # wsl) # w, s' @ [u'], c' + ch) \<in> trcl (ntrp fg)
[PROOF STEP]
.
    \<comment> \<open>It is straightforward to show that the new path satisfies the required properties for its monitors and acquisition history\<close>
[PROOF STATE]
proof (state)
this:
(([u], {#}), LOC (LCall p # wsl) # w, s' @ [u'], c' + ch) \<in> trcl (ntrp fg)

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
(([u], {#}), LOC (LCall p # wsl) # w, s' @ [u'], c' + ch) \<in> trcl (ntrp fg)

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
from IHAPP(2)
[PROOF STATE]
proof (chain)
picking this:
atU U ({#s'#} + c')
[PROOF STEP]
have "atU U ({# s'@[u'] #}+(c'+ch))"
[PROOF STATE]
proof (prove)
using this:
atU U ({#s'#} + c')

goal (1 subgoal):
 1. atU U ({#s' @ [u']#} + (c' + ch))
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
atU U ({#s' @ [u']#} + (c' + ch))

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
atU U ({#s' @ [u']#} + (c' + ch))

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
have "mon_loc fg (LOC (LCall p # wsl) # w) = mon fg p \<union> M \<union> Ml"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. mon_loc fg (LOC (LCall p # wsl) # w) = mon fg p \<union> M \<union> Ml
[PROOF STEP]
using SLPATH(2) IHAPP(3)
[PROOF STATE]
proof (prove)
using this:
M = mon_w fg wsl
mon_loc fg w = Ml

goal (1 subgoal):
 1. mon_loc fg (LOC (LCall p # wsl) # w) = mon fg p \<union> M \<union> Ml
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
mon_loc fg (LOC (LCall p # wsl) # w) = mon fg p \<union> M \<union> Ml

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
mon_loc fg (LOC (LCall p # wsl) # w) = mon fg p \<union> M \<union> Ml

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
have "mon_env fg (LOC (LCall p # wsl) # w) = Me"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. mon_env fg (LOC (LCall p # wsl) # w) = Me
[PROOF STEP]
using IHAPP(4)
[PROOF STATE]
proof (prove)
using this:
mon_env fg w = Me

goal (1 subgoal):
 1. mon_env fg (LOC (LCall p # wsl) # w) = Me
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
mon_env fg (LOC (LCall p # wsl) # w) = Me

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
mon_env fg (LOC (LCall p # wsl) # w) = Me

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
have "\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update h (mon fg p, M) (Ml \<union> Me)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
have "\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update (\<alpha>ah (map (\<alpha>nl fg) w)) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>nl fg) w))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update (\<alpha>ah (map (\<alpha>nl fg) w)) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>nl fg) w))
[PROOF STEP]
by (auto simp add: ah_update_cons)
[PROOF STATE]
proof (state)
this:
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update (\<alpha>ah (map (\<alpha>nl fg) w)) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>nl fg) w))

goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
also
[PROOF STATE]
proof (state)
this:
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update (\<alpha>ah (map (\<alpha>nl fg) w)) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>nl fg) w))

goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
have "\<dots> = ah_update h (mon fg p, M) (Ml \<union> Me)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>nl fg) w)) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>nl fg) w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>nl fg) w)) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>nl fg) w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
from IHAPP(5)
[PROOF STATE]
proof (chain)
picking this:
\<alpha>ah (map (\<alpha>nl fg) w) = h
[PROOF STEP]
have "\<alpha>ah (map (\<alpha>nl fg) w) = h"
[PROOF STATE]
proof (prove)
using this:
\<alpha>ah (map (\<alpha>nl fg) w) = h

goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>nl fg) w) = h
[PROOF STEP]
.
[PROOF STATE]
proof (state)
this:
\<alpha>ah (map (\<alpha>nl fg) w) = h

goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>nl fg) w)) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>nl fg) w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
\<alpha>ah (map (\<alpha>nl fg) w) = h

goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>nl fg) w)) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>nl fg) w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
from SLPATH(2)
[PROOF STATE]
proof (chain)
picking this:
M = mon_w fg wsl
[PROOF STEP]
have "(mon fg p, mon_w fg wsl) = (mon fg p, M)"
[PROOF STATE]
proof (prove)
using this:
M = mon_w fg wsl

goal (1 subgoal):
 1. (mon fg p, mon_w fg wsl) = (mon fg p, M)
[PROOF STEP]
by (simp add: mon_pl_of_\<alpha>nl)
[PROOF STATE]
proof (state)
this:
(mon fg p, mon_w fg wsl) = (mon fg p, M)

goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>nl fg) w)) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>nl fg) w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
(mon fg p, mon_w fg wsl) = (mon fg p, M)

goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>nl fg) w)) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>nl fg) w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
from IHAPP(3,4)
[PROOF STATE]
proof (chain)
picking this:
mon_loc fg w = Ml
mon_env fg w = Me
[PROOF STEP]
have "mon_pl (map (\<alpha>nl fg) w) = Ml \<union> Me"
[PROOF STATE]
proof (prove)
using this:
mon_loc fg w = Ml
mon_env fg w = Me

goal (1 subgoal):
 1. mon_pl (map (\<alpha>nl fg) w) = Ml \<union> Me
[PROOF STEP]
by (auto simp add: mon_pl_of_\<alpha>nl)
[PROOF STATE]
proof (state)
this:
mon_pl (map (\<alpha>nl fg) w) = Ml \<union> Me

goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>nl fg) w)) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>nl fg) w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
\<alpha>ah (map (\<alpha>nl fg) w) = h
(mon fg p, mon_w fg wsl) = (mon fg p, M)
mon_pl (map (\<alpha>nl fg) w) = Ml \<union> Me
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
\<alpha>ah (map (\<alpha>nl fg) w) = h
(mon fg p, mon_w fg wsl) = (mon fg p, M)
mon_pl (map (\<alpha>nl fg) w) = Ml \<union> Me

goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>nl fg) w)) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>nl fg) w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
ah_update (\<alpha>ah (map (\<alpha>nl fg) w)) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>nl fg) w)) = ah_update h (mon fg p, M) (Ml \<union> Me)

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
ah_update (\<alpha>ah (map (\<alpha>nl fg) w)) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>nl fg) w)) = ah_update h (mon fg p, M) (Ml \<union> Me)

goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
finally
[PROOF STATE]
proof (chain)
picking this:
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update h (mon fg p, M) (Ml \<union> Me)

goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
.
[PROOF STATE]
proof (state)
this:
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update h (mon fg p, M) (Ml \<union> Me)

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update h (mon fg p, M) (Ml \<union> Me)

goal (2 subgoals):
 1. \<And>u p u' v M P Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 0; (v, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([v], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; mon_n fg u \<inter> Me = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
 2. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
(([u], {#}), LOC (LCall p # wsl) # w, s' @ [u'], c' + ch) \<in> trcl (ntrp fg)
atU U ({#s' @ [u']#} + (c' + ch))
mon_loc fg (LOC (LCall p # wsl) # w) = mon fg p \<union> M \<union> Ml
mon_env fg (LOC (LCall p # wsl) # w) = Me
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
(([u], {#}), LOC (LCall p # wsl) # w, s' @ [u'], c' + ch) \<in> trcl (ntrp fg)
atU U ({#s' @ [u']#} + (c' + ch))
mon_loc fg (LOC (LCall p # wsl) # w) = mon fg p \<union> M \<union> Ml
mon_env fg (LOC (LCall p # wsl) # w) = Me
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # w)) = ah_update h (mon fg p, M) (Ml \<union> Me)

goal (1 subgoal):
 1. \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
\<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<union> Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
next
  \<comment> \<open>Spawn constraint\<close>
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
case (RU_spawn u p u' v M P q Ml Me h)
[PROOF STATE]
proof (state)
this:
(u, Call p, u') \<in> edges fg
proc_of fg v = p
(v, M, P) \<in> S_cs fg 1
q \<in># P
(entry fg q, Ml, Me, h) \<in> RU_cs fg U
\<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h
(mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
(u, Call p, u') \<in> edges fg
proc_of fg v = p
(v, M, P) \<in> S_cs fg 1
q \<in># P
(entry fg q, Ml, Me, h) \<in> RU_cs fg U
\<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h
(mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}
[PROOF STEP]
obtain w s' c' where IHAPP: "(([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg)" "atU U ({#s'#} + c')" "mon_loc fg w = Ml" "mon_env fg w = Me" "\<alpha>ah (map (\<alpha>nl fg) w) = h"
[PROOF STATE]
proof (prove)
using this:
(u, Call p, u') \<in> edges fg
proc_of fg v = p
(v, M, P) \<in> S_cs fg 1
q \<in># P
(entry fg q, Ml, Me, h) \<in> RU_cs fg U
\<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h
(mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}

goal (1 subgoal):
 1. (\<And>w s' c'. \<lbrakk>(([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg); atU U ({#s'#} + c'); mon_loc fg w = Ml; mon_env fg w = Me; \<alpha>ah (map (\<alpha>nl fg) w) = h\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
(([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg)
atU U ({#s'#} + c')
mon_loc fg w = Ml
mon_env fg w = Me
\<alpha>ah (map (\<alpha>nl fg) w) = h

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
from RU_spawn.hyps(2) S_precise[OF RU_spawn.hyps(3), simplified] trss_bot_proc_const[where s="[]" and s'="[]", simplified]
[PROOF STATE]
proof (chain)
picking this:
proc_of fg v = p
\<exists>p c' w. (([entry fg p], {#}), w, [v], c') \<in> trcl (trss fg) \<and> size P \<le> Suc 0 \<and> {#[entry fg p]. p \<in># P#} \<subseteq># c' \<and> M = mon_w fg w
(([?u], ?c), ?w, [?u'], ?c') \<in> trcl (trss fg) \<Longrightarrow> proc_of fg ?u = proc_of fg ?u'
[PROOF STEP]
obtain wsl ch where
    SLPATH: "(([entry fg p], {#}), wsl, [v], ch) \<in> trcl (trss fg)" "M = mon_w fg wsl" "size P \<le> 1" "(\<lambda>p. [entry fg p]) `# P \<subseteq># ch"
[PROOF STATE]
proof (prove)
using this:
proc_of fg v = p
\<exists>p c' w. (([entry fg p], {#}), w, [v], c') \<in> trcl (trss fg) \<and> size P \<le> Suc 0 \<and> {#[entry fg p]. p \<in># P#} \<subseteq># c' \<and> M = mon_w fg w
(([?u], ?c), ?w, [?u'], ?c') \<in> trcl (trss fg) \<Longrightarrow> proc_of fg ?u = proc_of fg ?u'

goal (1 subgoal):
 1. (\<And>wsl ch. \<lbrakk>(([entry fg p], {#}), wsl, [v], ch) \<in> trcl (trss fg); M = mon_w fg wsl; size P \<le> 1; {#[entry fg p]. p \<in># P#} \<subseteq># ch\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by fastforce
[PROOF STATE]
proof (state)
this:
(([entry fg p], {#}), wsl, [v], ch) \<in> trcl (trss fg)
M = mon_w fg wsl
size P \<le> 1
{#[entry fg p]. p \<in># P#} \<subseteq># ch

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
with RU_spawn.hyps(4)
[PROOF STATE]
proof (chain)
picking this:
q \<in># P
(([entry fg p], {#}), wsl, [v], ch) \<in> trcl (trss fg)
M = mon_w fg wsl
size P \<le> 1
{#[entry fg p]. p \<in># P#} \<subseteq># ch
[PROOF STEP]
obtain che where PFMT: "P={#q#}" "ch = {#[entry fg q]#} + che"
[PROOF STATE]
proof (prove)
using this:
q \<in># P
(([entry fg p], {#}), wsl, [v], ch) \<in> trcl (trss fg)
M = mon_w fg wsl
size P \<le> 1
{#[entry fg p]. p \<in># P#} \<subseteq># ch

goal (1 subgoal):
 1. (\<And>che. \<lbrakk>P = {#q#}; ch = {#[entry fg q]#} + che\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by (auto elim!: mset_size_le1_cases mset_le_addE)
[PROOF STATE]
proof (state)
this:
P = {#q#}
ch = {#[entry fg q]#} + che

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
from trss_c_cases[OF SLPATH(1), simplified]
[PROOF STATE]
proof (chain)
picking this:
((\<And>s. s \<in># ch \<Longrightarrow> \<exists>p. s = [entry fg p] \<and> (\<exists>u v. (u, Spawn p, v) \<in> edges fg) \<and> initialproc fg p) \<Longrightarrow> ?P) \<Longrightarrow> ?P
[PROOF STEP]
have CHFMT: "\<And>s. s \<in># ch \<Longrightarrow> \<exists>p. s = [entry fg p] \<and> (\<exists>u v. (u, Spawn p, v) \<in> edges fg) \<and> initialproc fg p"
[PROOF STATE]
proof (prove)
using this:
((\<And>s. s \<in># ch \<Longrightarrow> \<exists>p. s = [entry fg p] \<and> (\<exists>u v. (u, Spawn p, v) \<in> edges fg) \<and> initialproc fg p) \<Longrightarrow> ?P) \<Longrightarrow> ?P

goal (1 subgoal):
 1. \<And>s. s \<in># ch \<Longrightarrow> \<exists>p. s = [entry fg p] \<and> (\<exists>u v. (u, Spawn p, v) \<in> edges fg) \<and> initialproc fg p
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
?s \<in># ch \<Longrightarrow> \<exists>p. ?s = [entry fg p] \<and> (\<exists>u v. (u, Spawn p, v) \<in> edges fg) \<and> initialproc fg p

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
with c_of_initial_no_mon
[PROOF STATE]
proof (chain)
picking this:
(\<And>s. s \<in># ?csp \<Longrightarrow> \<exists>p. s = [entry fg p] \<and> initialproc fg p) \<Longrightarrow> mon_c fg ?csp = {}
?s \<in># ch \<Longrightarrow> \<exists>p. ?s = [entry fg p] \<and> (\<exists>u v. (u, Spawn p, v) \<in> edges fg) \<and> initialproc fg p
[PROOF STEP]
have CHNOMON: "mon_c fg ch = {}"
[PROOF STATE]
proof (prove)
using this:
(\<And>s. s \<in># ?csp \<Longrightarrow> \<exists>p. s = [entry fg p] \<and> initialproc fg p) \<Longrightarrow> mon_c fg ?csp = {}
?s \<in># ch \<Longrightarrow> \<exists>p. ?s = [entry fg p] \<and> (\<exists>u v. (u, Spawn p, v) \<in> edges fg) \<and> initialproc fg p

goal (1 subgoal):
 1. mon_c fg ch = {}
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
mon_c fg ch = {}

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
have FS: "(([u],{#}),LCall p#wsl,([v,u'],ch))\<in>ntrs fg"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (([u], {#}), LCall p # wsl, [v, u'], ch) \<in> ntrs fg
[PROOF STEP]
proof (rule ntrs_step[where r="[]", simplified])
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. (([u], {#}), LCall p, [entry fg p, u'], {#}) \<in> trss fg
 2. (([entry fg p], {#}), wsl, [v], ch) \<in> trcl (trss fg)
[PROOF STEP]
from RU_spawn.hyps(1)
[PROOF STATE]
proof (chain)
picking this:
(u, Call p, u') \<in> edges fg
[PROOF STEP]
show "(([u], {#}), LCall p, [entry fg p, u'], {#}) \<in> trss fg"
[PROOF STATE]
proof (prove)
using this:
(u, Call p, u') \<in> edges fg

goal (1 subgoal):
 1. (([u], {#}), LCall p, [entry fg p, u'], {#}) \<in> trss fg
[PROOF STEP]
by (auto intro: trss_call)
[PROOF STATE]
proof (state)
this:
(([u], {#}), LCall p, [entry fg p, u'], {#}) \<in> trss fg

goal (1 subgoal):
 1. (([entry fg p], {#}), wsl, [v], ch) \<in> trcl (trss fg)
[PROOF STEP]
qed (rule SLPATH(1))
[PROOF STATE]
proof (state)
this:
(([u], {#}), LCall p # wsl, [v, u'], ch) \<in> ntrs fg

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
hence FSP: "(([u],{#}),LOC (LCall p#wsl),([v,u'],ch))\<in>ntrp fg"
[PROOF STATE]
proof (prove)
using this:
(([u], {#}), LCall p # wsl, [v, u'], ch) \<in> ntrs fg

goal (1 subgoal):
 1. (([u], {#}), LOC (LCall p # wsl), [v, u'], ch) \<in> ntrp fg
[PROOF STEP]
by (blast intro: gtrp_loc)
[PROOF STATE]
proof (state)
this:
(([u], {#}), LOC (LCall p # wsl), [v, u'], ch) \<in> ntrp fg

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
also
[PROOF STATE]
proof (state)
this:
(([u], {#}), LOC (LCall p # wsl), [v, u'], ch) \<in> ntrp fg

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
have "(([v, u'], ch), map ENV (map le_rem_s w), [v,u'], che+({#s'#}+c')) \<in> trcl (ntrp fg)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (([v, u'], ch), map ENV (map le_rem_s w), [v, u'], che + ({#s'#} + c')) \<in> trcl (ntrp fg)
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. (([v, u'], ch), map ENV (map le_rem_s w), [v, u'], che + ({#s'#} + c')) \<in> trcl (ntrp fg)
[PROOF STEP]
from IHAPP(3,4)
[PROOF STATE]
proof (chain)
picking this:
mon_loc fg w = Ml
mon_env fg w = Me
[PROOF STEP]
have "mon_ww fg (map le_rem_s w) \<subseteq> Ml \<union> Me"
[PROOF STATE]
proof (prove)
using this:
mon_loc fg w = Ml
mon_env fg w = Me

goal (1 subgoal):
 1. mon_ww fg (map le_rem_s w) \<subseteq> Ml \<union> Me
[PROOF STEP]
by (auto simp add: mon_ww_of_le_rem)
[PROOF STATE]
proof (state)
this:
mon_ww fg (map le_rem_s w) \<subseteq> Ml \<union> Me

goal (1 subgoal):
 1. (([v, u'], ch), map ENV (map le_rem_s w), [v, u'], che + ({#s'#} + c')) \<in> trcl (ntrp fg)
[PROOF STEP]
with RU_spawn.hyps(1,2,7)
[PROOF STATE]
proof (chain)
picking this:
(u, Call p, u') \<in> edges fg
proc_of fg v = p
(mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}
mon_ww fg (map le_rem_s w) \<subseteq> Ml \<union> Me
[PROOF STEP]
have "(mon_n fg v \<union> mon_n fg u') \<inter> mon_ww fg (map le_rem_s w) = {}"
[PROOF STATE]
proof (prove)
using this:
(u, Call p, u') \<in> edges fg
proc_of fg v = p
(mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}
mon_ww fg (map le_rem_s w) \<subseteq> Ml \<union> Me

goal (1 subgoal):
 1. (mon_n fg v \<union> mon_n fg u') \<inter> mon_ww fg (map le_rem_s w) = {}
[PROOF STEP]
by (auto simp add: mon_n_def edges_part)
[PROOF STATE]
proof (state)
this:
(mon_n fg v \<union> mon_n fg u') \<inter> mon_ww fg (map le_rem_s w) = {}

goal (1 subgoal):
 1. (([v, u'], ch), map ENV (map le_rem_s w), [v, u'], che + ({#s'#} + c')) \<in> trcl (ntrp fg)
[PROOF STEP]
with ntr2ntrp[OF gtrp2gtr[OF IHAPP(1)], of "[v,u']" che] PFMT(2) CHNOMON
[PROOF STATE]
proof (chain)
picking this:
mon_c fg (add_mset [v, u'] che) \<inter> (mon_c fg {#[entry fg q]#} \<union> mon_ww fg (map le_rem_s w)) = {} \<Longrightarrow> (([v, u'], che + {#[entry fg q]#}), map ENV (map le_rem_s w), [v, u'], che + add_mset s' c') \<in> trcl (ntrp fg)
ch = {#[entry fg q]#} + che
mon_c fg ch = {}
(mon_n fg v \<union> mon_n fg u') \<inter> mon_ww fg (map le_rem_s w) = {}
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
mon_c fg (add_mset [v, u'] che) \<inter> (mon_c fg {#[entry fg q]#} \<union> mon_ww fg (map le_rem_s w)) = {} \<Longrightarrow> (([v, u'], che + {#[entry fg q]#}), map ENV (map le_rem_s w), [v, u'], che + add_mset s' c') \<in> trcl (ntrp fg)
ch = {#[entry fg q]#} + che
mon_c fg ch = {}
(mon_n fg v \<union> mon_n fg u') \<inter> mon_ww fg (map le_rem_s w) = {}

goal (1 subgoal):
 1. (([v, u'], ch), map ENV (map le_rem_s w), [v, u'], che + ({#s'#} + c')) \<in> trcl (ntrp fg)
[PROOF STEP]
by (auto simp add: union_ac mon_c_unconc)
[PROOF STATE]
proof (state)
this:
(([v, u'], ch), map ENV (map le_rem_s w), [v, u'], che + ({#s'#} + c')) \<in> trcl (ntrp fg)

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
(([v, u'], ch), map ENV (map le_rem_s w), [v, u'], che + ({#s'#} + c')) \<in> trcl (ntrp fg)

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
finally
[PROOF STATE]
proof (chain)
picking this:
(([u], {#}), LOC (LCall p # wsl) # map ENV (map le_rem_s w), [v, u'], che + ({#s'#} + c')) \<in> trcl (ntrp fg)
[PROOF STEP]
have "(([u], {#}), LOC (LCall p # wsl) # map ENV (map le_rem_s w), [v, u'], che + ({#s'#} + c')) \<in> trcl (ntrp fg)"
[PROOF STATE]
proof (prove)
using this:
(([u], {#}), LOC (LCall p # wsl) # map ENV (map le_rem_s w), [v, u'], che + ({#s'#} + c')) \<in> trcl (ntrp fg)

goal (1 subgoal):
 1. (([u], {#}), LOC (LCall p # wsl) # map ENV (map le_rem_s w), [v, u'], che + ({#s'#} + c')) \<in> trcl (ntrp fg)
[PROOF STEP]
.
[PROOF STATE]
proof (state)
this:
(([u], {#}), LOC (LCall p # wsl) # map ENV (map le_rem_s w), [v, u'], che + ({#s'#} + c')) \<in> trcl (ntrp fg)

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
(([u], {#}), LOC (LCall p # wsl) # map ENV (map le_rem_s w), [v, u'], che + ({#s'#} + c')) \<in> trcl (ntrp fg)

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
from IHAPP(2)
[PROOF STATE]
proof (chain)
picking this:
atU U ({#s'#} + c')
[PROOF STEP]
have "atU U ({#[v,u']#} + (che+({#s'#} + c')))"
[PROOF STATE]
proof (prove)
using this:
atU U ({#s'#} + c')

goal (1 subgoal):
 1. atU U ({#[v, u']#} + (che + ({#s'#} + c')))
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
atU U ({#[v, u']#} + (che + ({#s'#} + c')))

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
atU U ({#[v, u']#} + (che + ({#s'#} + c')))

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
have "mon_loc fg (LOC (LCall p # wsl) # map ENV (map le_rem_s w)) = mon fg p \<union> M"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. mon_loc fg (LOC (LCall p # wsl) # map ENV (map le_rem_s w)) = mon fg p \<union> M
[PROOF STEP]
using SLPATH(2)
[PROOF STATE]
proof (prove)
using this:
M = mon_w fg wsl

goal (1 subgoal):
 1. mon_loc fg (LOC (LCall p # wsl) # map ENV (map le_rem_s w)) = mon fg p \<union> M
[PROOF STEP]
by (auto simp del: map_map)
[PROOF STATE]
proof (state)
this:
mon_loc fg (LOC (LCall p # wsl) # map ENV (map le_rem_s w)) = mon fg p \<union> M

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
mon_loc fg (LOC (LCall p # wsl) # map ENV (map le_rem_s w)) = mon fg p \<union> M

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
have "mon_env fg (LOC (LCall p # wsl) # map ENV (map le_rem_s w)) = Ml \<union> Me"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. mon_env fg (LOC (LCall p # wsl) # map ENV (map le_rem_s w)) = Ml \<union> Me
[PROOF STEP]
using IHAPP(3,4)
[PROOF STATE]
proof (prove)
using this:
mon_loc fg w = Ml
mon_env fg w = Me

goal (1 subgoal):
 1. mon_env fg (LOC (LCall p # wsl) # map ENV (map le_rem_s w)) = Ml \<union> Me
[PROOF STEP]
by (auto simp add: mon_ww_of_le_rem simp del: map_map)
[PROOF STATE]
proof (state)
this:
mon_env fg (LOC (LCall p # wsl) # map ENV (map le_rem_s w)) = Ml \<union> Me

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
mon_env fg (LOC (LCall p # wsl) # map ENV (map le_rem_s w)) = Ml \<union> Me

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
have "\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
have "\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update (\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w))) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>n fg) (map le_rem_s w)))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update (\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w))) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>n fg) (map le_rem_s w)))
[PROOF STEP]
by (simp add: ah_update_cons o_assoc)
[PROOF STATE]
proof (state)
this:
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update (\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w))) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>n fg) (map le_rem_s w)))

goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
also
[PROOF STATE]
proof (state)
this:
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update (\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w))) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>n fg) (map le_rem_s w)))

goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
have "\<dots> = ah_update h (mon fg p, M) (Ml \<union> Me)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w))) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>n fg) (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w))) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>n fg) (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
from IHAPP(5)
[PROOF STATE]
proof (chain)
picking this:
\<alpha>ah (map (\<alpha>nl fg) w) = h
[PROOF STEP]
have "\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w)) = h"
[PROOF STATE]
proof (prove)
using this:
\<alpha>ah (map (\<alpha>nl fg) w) = h

goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>n fg) (map le_rem_s w)) = h
[PROOF STEP]
by (simp add: \<alpha>n_\<alpha>nl)
[PROOF STATE]
proof (state)
this:
\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w)) = h

goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w))) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>n fg) (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w)) = h

goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w))) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>n fg) (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
from SLPATH(2)
[PROOF STATE]
proof (chain)
picking this:
M = mon_w fg wsl
[PROOF STEP]
have "(mon fg p, mon_w fg wsl) = (mon fg p, M)"
[PROOF STATE]
proof (prove)
using this:
M = mon_w fg wsl

goal (1 subgoal):
 1. (mon fg p, mon_w fg wsl) = (mon fg p, M)
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
(mon fg p, mon_w fg wsl) = (mon fg p, M)

goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w))) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>n fg) (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
(mon fg p, mon_w fg wsl) = (mon fg p, M)

goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w))) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>n fg) (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
from IHAPP(3,4)
[PROOF STATE]
proof (chain)
picking this:
mon_loc fg w = Ml
mon_env fg w = Me
[PROOF STEP]
have "mon_pl (map (\<alpha>n fg) (map le_rem_s w)) = Ml \<union> Me"
[PROOF STATE]
proof (prove)
using this:
mon_loc fg w = Ml
mon_env fg w = Me

goal (1 subgoal):
 1. mon_pl (map (\<alpha>n fg) (map le_rem_s w)) = Ml \<union> Me
[PROOF STEP]
by (auto simp add: mon_pl_of_\<alpha>nl \<alpha>n_\<alpha>nl)
[PROOF STATE]
proof (state)
this:
mon_pl (map (\<alpha>n fg) (map le_rem_s w)) = Ml \<union> Me

goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w))) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>n fg) (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w)) = h
(mon fg p, mon_w fg wsl) = (mon fg p, M)
mon_pl (map (\<alpha>n fg) (map le_rem_s w)) = Ml \<union> Me
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w)) = h
(mon fg p, mon_w fg wsl) = (mon fg p, M)
mon_pl (map (\<alpha>n fg) (map le_rem_s w)) = Ml \<union> Me

goal (1 subgoal):
 1. ah_update (\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w))) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>n fg) (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
ah_update (\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w))) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>n fg) (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
ah_update (\<alpha>ah (map (\<alpha>n fg) (map le_rem_s w))) (mon fg p, mon_w fg wsl) (mon_pl (map (\<alpha>n fg) (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)

goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
finally
[PROOF STATE]
proof (chain)
picking this:
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)

goal (1 subgoal):
 1. \<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
.
[PROOF STATE]
proof (state)
this:
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)

goal (1 subgoal):
 1. \<And>u p u' v M P q Ml Me h. \<lbrakk>(u, Call p, u') \<in> edges fg; proc_of fg v = p; (v, M, P) \<in> S_cs fg 1; q \<in># P; (entry fg q, Ml, Me, h) \<in> RU_cs fg U; \<exists>w s' c'. (([entry fg q], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = Ml \<and> mon_env fg w = Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = h; (mon_n fg u \<union> mon fg p) \<inter> (Ml \<union> Me) = {}\<rbrakk> \<Longrightarrow> \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
(([u], {#}), LOC (LCall p # wsl) # map ENV (map le_rem_s w), [v, u'], che + ({#s'#} + c')) \<in> trcl (ntrp fg)
atU U ({#[v, u']#} + (che + ({#s'#} + c')))
mon_loc fg (LOC (LCall p # wsl) # map ENV (map le_rem_s w)) = mon fg p \<union> M
mon_env fg (LOC (LCall p # wsl) # map ENV (map le_rem_s w)) = Ml \<union> Me
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
(([u], {#}), LOC (LCall p # wsl) # map ENV (map le_rem_s w), [v, u'], che + ({#s'#} + c')) \<in> trcl (ntrp fg)
atU U ({#[v, u']#} + (che + ({#s'#} + c')))
mon_loc fg (LOC (LCall p # wsl) # map ENV (map le_rem_s w)) = mon fg p \<union> M
mon_env fg (LOC (LCall p # wsl) # map ENV (map le_rem_s w)) = Ml \<union> Me
\<alpha>ah (map (\<alpha>nl fg) (LOC (LCall p # wsl) # map ENV (map le_rem_s w))) = ah_update h (mon fg p, M) (Ml \<union> Me)

goal (1 subgoal):
 1. \<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
\<exists>w s' c'. (([u], {#}), w, s', c') \<in> trcl (ntrp fg) \<and> atU U ({#s'#} + c') \<and> mon_loc fg w = mon fg p \<union> M \<and> mon_env fg w = Ml \<union> Me \<and> \<alpha>ah (map (\<alpha>nl fg) w) = ah_update h (mon fg p, M) (Ml \<union> Me)

goal:
No subgoals!
[PROOF STEP]
qed