[STATEMENT]
lemma Red1_simulates_red0:
  assumes wf: "wf_J_prog P"
  and red: "P,t \<turnstile>0 \<langle>e1/es1, h\<rangle> -ta\<rightarrow> \<langle>e1'/es1', h'\<rangle>"
  and bisiml: "bisim_list1 (e1, es1) (ex2, exs2)"
  shows "\<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and>
        (if \<tau>Move0 P h (e1, es1)
         then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<epsilon> \<and> h = h'
         else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and>
                               (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and>
                               False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2', h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'', h'\<rangle> \<and>
                               \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')"
  (is "\<exists>ex2'' exs2'' . _ \<and> ?red ex2'' exs2''")
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
using red
[PROOF STATE]
proof (prove)
using this:
P,t \<turnstile>0 \<langle>e1/es1,h\<rangle> -ta\<rightarrow> \<langle>e1'/es1',h'\<rangle>

goal (1 subgoal):
 1. \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
proof(cases)
[PROOF STATE]
proof (state)
goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
case (red0Red XS')
[PROOF STATE]
proof (state)
this:
es1' = es1
extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', XS')\<rangle>
\<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
note [simp] = \<open>es1' = es1\<close>
    and red = \<open>extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', XS')\<rangle>\<close>
    and notsynth = \<open>\<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<close>
[PROOF STATE]
proof (state)
this:
es1' = es1
extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', XS')\<rangle>
\<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from bisiml
[PROOF STATE]
proof (chain)
picking this:
bisim_list1 (e1, es1) (ex2, exs2)
[PROOF STEP]
obtain E xs where ex2: "ex2 = (E, xs)"
    and bisim: "bisim [] e1 E xs" and fv: "fv e1 = {}"
    and length: "max_vars E \<le> length xs" and bsl: "bisim_list es1 exs2"
    and D: "\<D> e1 \<lfloor>{}\<rfloor>"
[PROOF STATE]
proof (prove)
using this:
bisim_list1 (e1, es1) (ex2, exs2)

goal (1 subgoal):
 1. (\<And>E xs. \<lbrakk>ex2 = (E, xs); bisim [] e1 E xs; fv e1 = {}; max_vars E \<le> length xs; bisim_list es1 exs2; \<D> e1 \<lfloor>{}\<rfloor>\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(auto elim!: bisim_list1_elim)
[PROOF STATE]
proof (state)
this:
ex2 = (E, xs)
bisim [] e1 E xs
fv e1 = {}
max_vars E \<le> length xs
bisim_list es1 exs2
\<D> e1 \<lfloor>{}\<rfloor>

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from bisim_max_vars[OF bisim] length red1_simulates_red_aux[OF wf red bisim] fv notsynth
[PROOF STATE]
proof (chain)
picking this:
max_vars e1 = max_vars E
max_vars E \<le> length xs
\<lbrakk>fv e1 \<subseteq> set []; lcl (h, Map.empty) \<subseteq>\<^sub>m [[] [\<mapsto>] xs]; length [] + max_vars e1 \<le> length xs; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P (hp (h, Map.empty)) aMvs\<rbrakk> \<Longrightarrow> \<exists>taa e2' XS'a. sim_move01 (compP1 P) t ta e1 E (hp (h, Map.empty)) xs taa e2' (hp (h', XS')) XS'a \<and> bisim [] e1' e2' XS'a \<and> lcl (h', XS') \<subseteq>\<^sub>m [[] [\<mapsto>] XS'a]
fv e1 = {}
\<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs
[PROOF STEP]
obtain ta' e2' xs' where sim: "sim_move01 (compP1 P) t ta e1 E h xs ta' e2' h' xs'"
    and bisim': "bisim [] e1' e2' xs'" and XS': "XS' \<subseteq>\<^sub>m Map.empty"
[PROOF STATE]
proof (prove)
using this:
max_vars e1 = max_vars E
max_vars E \<le> length xs
\<lbrakk>fv e1 \<subseteq> set []; lcl (h, Map.empty) \<subseteq>\<^sub>m [[] [\<mapsto>] xs]; length [] + max_vars e1 \<le> length xs; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P (hp (h, Map.empty)) aMvs\<rbrakk> \<Longrightarrow> \<exists>taa e2' XS'a. sim_move01 (compP1 P) t ta e1 E (hp (h, Map.empty)) xs taa e2' (hp (h', XS')) XS'a \<and> bisim [] e1' e2' XS'a \<and> lcl (h', XS') \<subseteq>\<^sub>m [[] [\<mapsto>] XS'a]
fv e1 = {}
\<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs

goal (1 subgoal):
 1. (\<And>ta' e2' xs'. \<lbrakk>sim_move01 (compP1 P) t ta e1 E h xs ta' e2' h' xs'; bisim [] e1' e2' xs'; XS' \<subseteq>\<^sub>m Map.empty\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
sim_move01 (compP1 P) t ta e1 E h xs ta' e2' h' xs'
bisim [] e1' e2' xs'
XS' \<subseteq>\<^sub>m Map.empty

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from sim_move01_into_Red1[OF sim, of es1 exs2]
[PROOF STATE]
proof (chain)
picking this:
if \<tau>Move0 (compP1 P) h (e1, es1) then \<tau>Red1't (compP1 P) t h ((E, xs), exs2) ((e2', xs'), exs2) \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h ((E, xs), exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 E = None \<or> ex2' = (E, xs) \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>(e2', xs')/exs2,h'\<rangle> \<and> \<not> \<tau>Move1 (compP1 P) h (ex2', exs2') \<and> ta_bisim01 ta ta'
[PROOF STEP]
have "?red (e2', xs') exs2"
[PROOF STATE]
proof (prove)
using this:
if \<tau>Move0 (compP1 P) h (e1, es1) then \<tau>Red1't (compP1 P) t h ((E, xs), exs2) ((e2', xs'), exs2) \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h ((E, xs), exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 E = None \<or> ex2' = (E, xs) \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>(e2', xs')/exs2,h'\<rangle> \<and> \<not> \<tau>Move1 (compP1 P) h (ex2', exs2') \<and> ta_bisim01 ta ta'

goal (1 subgoal):
 1. if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) ((e2', xs'), exs2) \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>(e2', xs')/exs2,h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta'
[PROOF STEP]
unfolding ex2
[PROOF STATE]
proof (prove)
using this:
if \<tau>Move0 (compP1 P) h (e1, es1) then \<tau>Red1't (compP1 P) t h ((E, xs), exs2) ((e2', xs'), exs2) \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h ((E, xs), exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 E = None \<or> ex2' = (E, xs) \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>(e2', xs')/exs2,h'\<rangle> \<and> \<not> \<tau>Move1 (compP1 P) h (ex2', exs2') \<and> ta_bisim01 ta ta'

goal (1 subgoal):
 1. if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h ((E, xs), exs2) ((e2', xs'), exs2) \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h ((E, xs), exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst (E, xs)) = None \<or> ex2' = (E, xs) \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>(e2', xs')/exs2,h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta'
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) ((e2', xs'), exs2) \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>(e2', xs')/exs2,h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta'

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) ((e2', xs'), exs2) \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>(e2', xs')/exs2,h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta'

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
{
[PROOF STATE]
proof (state)
this:
if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) ((e2', xs'), exs2) \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>(e2', xs')/exs2,h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta'

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
note bsl bisim'
[PROOF STATE]
proof (state)
this:
bisim_list es1 exs2
bisim [] e1' e2' xs'

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
bisim_list es1 exs2
bisim [] e1' e2' xs'

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from fv red_fv_subset[OF wf_prog_wwf_prog[OF wf] red]
[PROOF STATE]
proof (chain)
picking this:
fv e1 = {}
fv e1' \<subseteq> fv e1
[PROOF STEP]
have "fv e1' = {}"
[PROOF STATE]
proof (prove)
using this:
fv e1 = {}
fv e1' \<subseteq> fv e1

goal (1 subgoal):
 1. fv e1' = {}
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
fv e1' = {}

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
fv e1' = {}

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from red D
[PROOF STATE]
proof (chain)
picking this:
extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', XS')\<rangle>
\<D> e1 \<lfloor>{}\<rfloor>
[PROOF STEP]
have "\<D> e1' \<lfloor>dom XS'\<rfloor>"
[PROOF STATE]
proof (prove)
using this:
extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', XS')\<rangle>
\<D> e1 \<lfloor>{}\<rfloor>

goal (1 subgoal):
 1. \<D> e1' \<lfloor>dom XS'\<rfloor>
[PROOF STEP]
by(auto dest: red_preserves_defass[OF wf] split: if_split_asm)
[PROOF STATE]
proof (state)
this:
\<D> e1' \<lfloor>dom XS'\<rfloor>

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
with red_dom_lcl[OF red] \<open>fv e1 = {}\<close>
[PROOF STATE]
proof (chain)
picking this:
dom (lcl (h', XS')) \<subseteq> dom (lcl (h, Map.empty)) \<union> fv e1
fv e1 = {}
\<D> e1' \<lfloor>dom XS'\<rfloor>
[PROOF STEP]
have "\<D> e1' \<lfloor>{}\<rfloor>"
[PROOF STATE]
proof (prove)
using this:
dom (lcl (h', XS')) \<subseteq> dom (lcl (h, Map.empty)) \<union> fv e1
fv e1 = {}
\<D> e1' \<lfloor>dom XS'\<rfloor>

goal (1 subgoal):
 1. \<D> e1' \<lfloor>{}\<rfloor>
[PROOF STEP]
by(auto elim!: D_mono' simp add: hyperset_defs)
[PROOF STATE]
proof (state)
this:
\<D> e1' \<lfloor>{}\<rfloor>

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
\<D> e1' \<lfloor>{}\<rfloor>

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from sim
[PROOF STATE]
proof (chain)
picking this:
sim_move01 (compP1 P) t ta e1 E h xs ta' e2' h' xs'
[PROOF STEP]
have "length xs = length xs'" "max_vars e2' \<le> max_vars E"
[PROOF STATE]
proof (prove)
using this:
sim_move01 (compP1 P) t ta e1 E h xs ta' e2' h' xs'

goal (1 subgoal):
 1. length xs = length xs' &&& max_vars e2' \<le> max_vars E
[PROOF STEP]
by(auto dest: sim_move01_preserves_len sim_move01_max_vars_decr)
[PROOF STATE]
proof (state)
this:
length xs = length xs'
max_vars e2' \<le> max_vars E

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
with length
[PROOF STATE]
proof (chain)
picking this:
max_vars E \<le> length xs
length xs = length xs'
max_vars e2' \<le> max_vars E
[PROOF STEP]
have length': "max_vars e2' \<le> length xs'"
[PROOF STATE]
proof (prove)
using this:
max_vars E \<le> length xs
length xs = length xs'
max_vars e2' \<le> max_vars E

goal (1 subgoal):
 1. max_vars e2' \<le> length xs'
[PROOF STEP]
by(auto)
[PROOF STATE]
proof (state)
this:
max_vars e2' \<le> length xs'

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
bisim_list es1 exs2
bisim [] e1' e2' xs'
fv e1' = {}
\<D> e1' \<lfloor>{}\<rfloor>
max_vars e2' \<le> length xs'
[PROOF STEP]
have "bisim_list1 (e1', es1) ((e2', xs'), exs2)"
[PROOF STATE]
proof (prove)
using this:
bisim_list es1 exs2
bisim [] e1' e2' xs'
fv e1' = {}
\<D> e1' \<lfloor>{}\<rfloor>
max_vars e2' \<le> length xs'

goal (1 subgoal):
 1. bisim_list1 (e1', es1) ((e2', xs'), exs2)
[PROOF STEP]
by(rule bisim_list1I)
[PROOF STATE]
proof (state)
this:
bisim_list1 (e1', es1) ((e2', xs'), exs2)

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
bisim_list1 (e1', es1) ((e2', xs'), exs2)

goal (3 subgoals):
 1. \<And>xs'. \<lbrakk>es1' = es1; extTA2J0 P,P,t \<turnstile> \<langle>e1,(h, Map.empty)\<rangle> -ta\<rightarrow> \<langle>e1',(h', xs')\<rangle>; \<forall>aMvs. call e1 = \<lfloor>aMvs\<rfloor> \<longrightarrow> synthesized_call P h aMvs\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 3. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) ((e2', xs'), exs2) \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>(e2', xs')/exs2,h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta'
bisim_list1 (e1', es1) ((e2', xs'), exs2)
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) ((e2', xs'), exs2) \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>(e2', xs')/exs2,h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta'
bisim_list1 (e1', es1) ((e2', xs'), exs2)

goal (1 subgoal):
 1. \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
using ex2
[PROOF STATE]
proof (prove)
using this:
if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) ((e2', xs'), exs2) \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>(e2', xs')/exs2,h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta'
bisim_list1 (e1', es1) ((e2', xs'), exs2)
ex2 = (E, xs)

goal (1 subgoal):
 1. \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
by(simp split del: if_split)(rule exI conjI|assumption)+
[PROOF STATE]
proof (state)
this:
\<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
case (red0Call a M vs U Ts T pns body D)
[PROOF STATE]
proof (state)
this:
ta = \<lbrace>\<rbrace>
e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body
es1' = e1 # es1
h' = h
call e1 = \<lfloor>(a, M, vs)\<rfloor>
typeof_addr h a = \<lfloor>U\<rfloor>
P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D
length vs = length pns
length Ts = length pns

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
note [simp] = \<open>ta = \<epsilon>\<close> \<open>h' = h\<close>
    and es1' = \<open>es1' = e1 # es1\<close>
    and e1' = \<open>e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body\<close>
    and call = \<open>call e1 = \<lfloor>(a, M, vs)\<rfloor>\<close>
    and ha = \<open>typeof_addr h a = \<lfloor>U\<rfloor>\<close>
    and sees = \<open>P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D\<close>
    and len = \<open>length vs = length pns\<close> \<open>length Ts = length pns\<close>
[PROOF STATE]
proof (state)
this:
ta = \<lbrace>\<rbrace>
h' = h
es1' = e1 # es1
e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body
call e1 = \<lfloor>(a, M, vs)\<rfloor>
typeof_addr h a = \<lfloor>U\<rfloor>
P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D
length vs = length pns
length Ts = length pns

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from bisiml
[PROOF STATE]
proof (chain)
picking this:
bisim_list1 (e1, es1) (ex2, exs2)
[PROOF STEP]
obtain E xs where ex2: "ex2 = (E, xs)"
    and bisim: "bisim [] e1 E xs" and fv: "fv e1 = {}"
    and length: "max_vars E \<le> length xs" and bsl: "bisim_list es1 exs2"
    and D: "\<D> e1 \<lfloor>{}\<rfloor>"
[PROOF STATE]
proof (prove)
using this:
bisim_list1 (e1, es1) (ex2, exs2)

goal (1 subgoal):
 1. (\<And>E xs. \<lbrakk>ex2 = (E, xs); bisim [] e1 E xs; fv e1 = {}; max_vars E \<le> length xs; bisim_list es1 exs2; \<D> e1 \<lfloor>{}\<rfloor>\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(auto elim!: bisim_list1_elim)
[PROOF STATE]
proof (state)
this:
ex2 = (E, xs)
bisim [] e1 E xs
fv e1 = {}
max_vars E \<le> length xs
bisim_list es1 exs2
\<D> e1 \<lfloor>{}\<rfloor>

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from bisim_call_Some_call1[OF bisim call, of "compP1 P" t h] length
[PROOF STATE]
proof (chain)
picking this:
length [] + max_vars E \<le> length xs \<Longrightarrow> \<exists>e'' xs'. \<tau>red1'r (compP1 P) t h (E, xs) (e'', xs') \<and> call1 e'' = \<lfloor>(a, M, vs)\<rfloor> \<and> bisim [] e1 e'' xs' \<and> take (length []) xs = take (length []) xs'
max_vars E \<le> length xs
[PROOF STEP]
obtain e' xs' where red: "\<tau>red1'r (compP1 P) t h (E, xs) (e', xs')"
    and "call1 e' = \<lfloor>(a, M, vs)\<rfloor>" "bisim [] e1 e' xs'"
    and "take 0 xs = take 0 xs'"
[PROOF STATE]
proof (prove)
using this:
length [] + max_vars E \<le> length xs \<Longrightarrow> \<exists>e'' xs'. \<tau>red1'r (compP1 P) t h (E, xs) (e'', xs') \<and> call1 e'' = \<lfloor>(a, M, vs)\<rfloor> \<and> bisim [] e1 e'' xs' \<and> take (length []) xs = take (length []) xs'
max_vars E \<le> length xs

goal (1 subgoal):
 1. (\<And>e' xs'. \<lbrakk>\<tau>red1'r (compP1 P) t h (E, xs) (e', xs'); call1 e' = \<lfloor>(a, M, vs)\<rfloor>; bisim [] e1 e' xs'; take 0 xs = take 0 xs'\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<tau>red1'r (compP1 P) t h (E, xs) (e', xs')
call1 e' = \<lfloor>(a, M, vs)\<rfloor>
bisim [] e1 e' xs'
take 0 xs = take 0 xs'

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
let ?e1' = "blocks (this # pns) (Class D # Ts) (Addr a # vs) body"
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
let ?e2' = "blocks1 0 (Class D#Ts) (compE1 (this # pns) body)"
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
let ?xs2' = "Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value"
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
let ?exs2' = "(e', xs') # exs2"
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
have "\<tau>Red1'r (compP1 P) t h ((E, xs), exs2) ((e', xs'), exs2)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<tau>Red1'r (compP1 P) t h ((E, xs), exs2) ((e', xs'), exs2)
[PROOF STEP]
using red
[PROOF STATE]
proof (prove)
using this:
\<tau>red1'r (compP1 P) t h (E, xs) (e', xs')

goal (1 subgoal):
 1. \<tau>Red1'r (compP1 P) t h ((E, xs), exs2) ((e', xs'), exs2)
[PROOF STEP]
by(rule \<tau>red1r_into_\<tau>Red1r)
[PROOF STATE]
proof (state)
this:
\<tau>Red1'r (compP1 P) t h ((E, xs), exs2) ((e', xs'), exs2)

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
\<tau>Red1'r (compP1 P) t h ((E, xs), exs2) ((e', xs'), exs2)

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
{
[PROOF STATE]
proof (state)
this:
\<tau>Red1'r (compP1 P) t h ((E, xs), exs2) ((e', xs'), exs2)

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
note \<open>call1 e' = \<lfloor>(a, M, vs)\<rfloor>\<close>
[PROOF STATE]
proof (state)
this:
call1 e' = \<lfloor>(a, M, vs)\<rfloor>

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
call1 e' = \<lfloor>(a, M, vs)\<rfloor>

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
note ha
[PROOF STATE]
proof (state)
this:
typeof_addr h a = \<lfloor>U\<rfloor>

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
typeof_addr h a = \<lfloor>U\<rfloor>

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
have "compP1 P \<turnstile> class_type_of U sees M:Ts \<rightarrow> T = map_option (\<lambda>(pns, body). compE1 (this # pns) body) \<lfloor>(pns, body)\<rfloor> in D"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. compP1 P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = map_option (\<lambda>(pns, body). compE1 (this # pns) body) \<lfloor>(pns, body)\<rfloor> in D
[PROOF STEP]
using sees
[PROOF STATE]
proof (prove)
using this:
P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D

goal (1 subgoal):
 1. compP1 P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = map_option (\<lambda>(pns, body). compE1 (this # pns) body) \<lfloor>(pns, body)\<rfloor> in D
[PROOF STEP]
unfolding compP1_def
[PROOF STATE]
proof (prove)
using this:
P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D

goal (1 subgoal):
 1. compP (\<lambda>C M Ts T (pns, body). compE1 (this # pns) body) P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = map_option (\<lambda>(pns, body). compE1 (this # pns) body) \<lfloor>(pns, body)\<rfloor> in D
[PROOF STEP]
by(rule sees_method_compP)
[PROOF STATE]
proof (state)
this:
compP1 P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = map_option (\<lambda>(pns, body). compE1 (this # pns) body) \<lfloor>(pns, body)\<rfloor> in D

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
hence sees': "compP1 P \<turnstile> class_type_of U sees M:Ts \<rightarrow> T = \<lfloor>compE1 (this # pns) body\<rfloor> in D"
[PROOF STATE]
proof (prove)
using this:
compP1 P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = map_option (\<lambda>(pns, body). compE1 (this # pns) body) \<lfloor>(pns, body)\<rfloor> in D

goal (1 subgoal):
 1. compP1 P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>compE1 (this # pns) body\<rfloor> in D
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
compP1 P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>compE1 (this # pns) body\<rfloor> in D

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
compP1 P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>compE1 (this # pns) body\<rfloor> in D

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from len
[PROOF STATE]
proof (chain)
picking this:
length vs = length pns
length Ts = length pns
[PROOF STEP]
have "length vs = length Ts"
[PROOF STATE]
proof (prove)
using this:
length vs = length pns
length Ts = length pns

goal (1 subgoal):
 1. length vs = length Ts
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
length vs = length Ts

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
call1 e' = \<lfloor>(a, M, vs)\<rfloor>
typeof_addr h a = \<lfloor>U\<rfloor>
compP1 P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>compE1 (this # pns) body\<rfloor> in D
length vs = length Ts
[PROOF STEP]
have "False,compP1 P,t \<turnstile>1 \<langle>(e', xs')/exs2,h\<rangle> -\<epsilon>\<rightarrow> \<langle>(?e2', ?xs2')/?exs2', h\<rangle>"
[PROOF STATE]
proof (prove)
using this:
call1 e' = \<lfloor>(a, M, vs)\<rfloor>
typeof_addr h a = \<lfloor>U\<rfloor>
compP1 P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>compE1 (this # pns) body\<rfloor> in D
length vs = length Ts

goal (1 subgoal):
 1. False,compP1 P,t \<turnstile>1 \<langle>(e', xs')/exs2,h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)/(e', xs') # exs2,h\<rangle>
[PROOF STEP]
by(rule red1Call)
[PROOF STATE]
proof (state)
this:
False,compP1 P,t \<turnstile>1 \<langle>(e', xs')/exs2,h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)/(e', xs') # exs2,h\<rangle>

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
False,compP1 P,t \<turnstile>1 \<langle>(e', xs')/exs2,h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)/(e', xs') # exs2,h\<rangle>

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
have "\<tau>Move1 P h ((e', xs'), exs2)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<tau>Move1 P h ((e', xs'), exs2)
[PROOF STEP]
using \<open>call1 e' = \<lfloor>(a, M, vs)\<rfloor>\<close> ha sees
[PROOF STATE]
proof (prove)
using this:
call1 e' = \<lfloor>(a, M, vs)\<rfloor>
typeof_addr h a = \<lfloor>U\<rfloor>
P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D

goal (1 subgoal):
 1. \<tau>Move1 P h ((e', xs'), exs2)
[PROOF STEP]
by(auto simp add: synthesized_call_def \<tau>external'_def dest: sees_method_fun dest!: \<tau>move1_not_call1[where P=P and h=h])
[PROOF STATE]
proof (state)
this:
\<tau>Move1 P h ((e', xs'), exs2)

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
False,compP1 P,t \<turnstile>1 \<langle>(e', xs')/exs2,h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)/(e', xs') # exs2,h\<rangle>
\<tau>Move1 P h ((e', xs'), exs2)
[PROOF STEP]
have "\<tau>Red1' (compP1 P) t h ((e', xs'), exs2) ((?e2', ?xs2'), ?exs2')"
[PROOF STATE]
proof (prove)
using this:
False,compP1 P,t \<turnstile>1 \<langle>(e', xs')/exs2,h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)/(e', xs') # exs2,h\<rangle>
\<tau>Move1 P h ((e', xs'), exs2)

goal (1 subgoal):
 1. \<tau>Red1' (compP1 P) t h ((e', xs'), exs2) ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<tau>Red1' (compP1 P) t h ((e', xs'), exs2) ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
\<tau>Red1' (compP1 P) t h ((e', xs'), exs2) ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
\<tau>Red1'r (compP1 P) t h ((E, xs), exs2) ((e', xs'), exs2)
\<tau>Red1' (compP1 P) t h ((e', xs'), exs2) ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)
[PROOF STEP]
have "\<tau>Red1't (compP1 P) t h ((E, xs), exs2) ((?e2', ?xs2'), ?exs2')"
[PROOF STATE]
proof (prove)
using this:
\<tau>Red1'r (compP1 P) t h ((E, xs), exs2) ((e', xs'), exs2)
\<tau>Red1' (compP1 P) t h ((e', xs'), exs2) ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)

goal (1 subgoal):
 1. \<tau>Red1't (compP1 P) t h ((E, xs), exs2) ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)
[PROOF STEP]
by(rule rtranclp_into_tranclp1)
[PROOF STATE]
proof (state)
this:
\<tau>Red1't (compP1 P) t h ((E, xs), exs2) ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
\<tau>Red1't (compP1 P) t h ((E, xs), exs2) ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
{
[PROOF STATE]
proof (state)
this:
\<tau>Red1't (compP1 P) t h ((E, xs), exs2) ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from red
[PROOF STATE]
proof (chain)
picking this:
\<tau>red1'r (compP1 P) t h (E, xs) (e', xs')
[PROOF STEP]
have "length xs' = length xs"
[PROOF STATE]
proof (prove)
using this:
\<tau>red1'r (compP1 P) t h (E, xs) (e', xs')

goal (1 subgoal):
 1. length xs' = length xs
[PROOF STEP]
by(rule \<tau>red1r_preserves_len)
[PROOF STATE]
proof (state)
this:
length xs' = length xs

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
length xs' = length xs

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from red
[PROOF STATE]
proof (chain)
picking this:
\<tau>red1'r (compP1 P) t h (E, xs) (e', xs')
[PROOF STEP]
have "max_vars e' \<le> max_vars E"
[PROOF STATE]
proof (prove)
using this:
\<tau>red1'r (compP1 P) t h (E, xs) (e', xs')

goal (1 subgoal):
 1. max_vars e' \<le> max_vars E
[PROOF STEP]
by(rule \<tau>red1r_max_vars)
[PROOF STATE]
proof (state)
this:
max_vars e' \<le> max_vars E

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
length xs' = length xs
max_vars e' \<le> max_vars E
[PROOF STEP]
have "max_vars e' \<le> length xs'"
[PROOF STATE]
proof (prove)
using this:
length xs' = length xs
max_vars e' \<le> max_vars E

goal (1 subgoal):
 1. max_vars e' \<le> length xs'
[PROOF STEP]
using length
[PROOF STATE]
proof (prove)
using this:
length xs' = length xs
max_vars e' \<le> max_vars E
max_vars E \<le> length xs

goal (1 subgoal):
 1. max_vars e' \<le> length xs'
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
max_vars e' \<le> length xs'

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
max_vars e' \<le> length xs'

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
with bsl \<open>bisim [] e1 e' xs'\<close> fv D
[PROOF STATE]
proof (chain)
picking this:
bisim_list es1 exs2
bisim [] e1 e' xs'
fv e1 = {}
\<D> e1 \<lfloor>{}\<rfloor>
max_vars e' \<le> length xs'
[PROOF STEP]
have "bisim_list (e1 # es1) ?exs2'"
[PROOF STATE]
proof (prove)
using this:
bisim_list es1 exs2
bisim [] e1 e' xs'
fv e1 = {}
\<D> e1 \<lfloor>{}\<rfloor>
max_vars e' \<le> length xs'

goal (1 subgoal):
 1. bisim_list (e1 # es1) ((e', xs') # exs2)
[PROOF STEP]
using \<open>call e1 = \<lfloor>(a, M, vs)\<rfloor>\<close> \<open>call1 e' = \<lfloor>(a, M, vs)\<rfloor>\<close>
[PROOF STATE]
proof (prove)
using this:
bisim_list es1 exs2
bisim [] e1 e' xs'
fv e1 = {}
\<D> e1 \<lfloor>{}\<rfloor>
max_vars e' \<le> length xs'
call e1 = \<lfloor>(a, M, vs)\<rfloor>
call1 e' = \<lfloor>(a, M, vs)\<rfloor>

goal (1 subgoal):
 1. bisim_list (e1 # es1) ((e', xs') # exs2)
[PROOF STEP]
by(rule bisim_listCons)
[PROOF STATE]
proof (state)
this:
bisim_list (e1 # es1) ((e', xs') # exs2)

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
hence "bisim_list1 (e1', es1') ((?e2', ?xs2'), ?exs2')"
[PROOF STATE]
proof (prove)
using this:
bisim_list (e1 # es1) ((e', xs') # exs2)

goal (1 subgoal):
 1. bisim_list1 (e1', es1') ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)
[PROOF STEP]
unfolding e1' es1'
[PROOF STATE]
proof (prove)
using this:
bisim_list (e1 # es1) ((e', xs') # exs2)

goal (1 subgoal):
 1. bisim_list1 (blocks (this # pns) (Class D # Ts) (Addr a # vs) body, e1 # es1) ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)
[PROOF STEP]
proof(rule bisim_list1I)
[PROOF STATE]
proof (state)
goal (4 subgoals):
 1. bisim [] (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
 2. fv (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) = {}
 3. \<D> (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) \<lfloor>{}\<rfloor>
 4. max_vars (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) \<le> length (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
from wf_prog_wwf_prog[OF wf] sees
[PROOF STATE]
proof (chain)
picking this:
wwf_J_prog P
P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D
[PROOF STEP]
have "wf_mdecl wwf_J_mdecl P D (M,Ts,T,\<lfloor>(pns,body)\<rfloor>)"
[PROOF STATE]
proof (prove)
using this:
wwf_J_prog P
P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D

goal (1 subgoal):
 1. wf_mdecl wwf_J_mdecl P D (M, Ts, T, \<lfloor>(pns, body)\<rfloor>)
[PROOF STEP]
by(rule sees_wf_mdecl)
[PROOF STATE]
proof (state)
this:
wf_mdecl wwf_J_mdecl P D (M, Ts, T, \<lfloor>(pns, body)\<rfloor>)

goal (4 subgoals):
 1. bisim [] (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
 2. fv (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) = {}
 3. \<D> (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) \<lfloor>{}\<rfloor>
 4. max_vars (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) \<le> length (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
hence fv': "fv body \<subseteq> set pns \<union> {this}"
[PROOF STATE]
proof (prove)
using this:
wf_mdecl wwf_J_mdecl P D (M, Ts, T, \<lfloor>(pns, body)\<rfloor>)

goal (1 subgoal):
 1. fv body \<subseteq> set pns \<union> {this}
[PROOF STEP]
by(auto simp add: wf_mdecl_def)
[PROOF STATE]
proof (state)
this:
fv body \<subseteq> set pns \<union> {this}

goal (4 subgoals):
 1. bisim [] (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
 2. fv (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) = {}
 3. \<D> (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) \<lfloor>{}\<rfloor>
 4. max_vars (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) \<le> length (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
fv body \<subseteq> set pns \<union> {this}

goal (4 subgoals):
 1. bisim [] (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
 2. fv (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) = {}
 3. \<D> (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) \<lfloor>{}\<rfloor>
 4. max_vars (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) \<le> length (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
from \<open>P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D\<close>
[PROOF STATE]
proof (chain)
picking this:
P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D
[PROOF STEP]
have "\<not> contains_insync body"
[PROOF STATE]
proof (prove)
using this:
P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D

goal (1 subgoal):
 1. \<not> contains_insync body
[PROOF STEP]
by(auto dest!: sees_wf_mdecl[OF wf] WT_expr_locks simp add: wf_mdecl_def contains_insync_conv)
[PROOF STATE]
proof (state)
this:
\<not> contains_insync body

goal (4 subgoals):
 1. bisim [] (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
 2. fv (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) = {}
 3. \<D> (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) \<lfloor>{}\<rfloor>
 4. max_vars (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) \<le> length (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
fv body \<subseteq> set pns \<union> {this}
\<not> contains_insync body
[PROOF STEP]
have "bisim ([this] @ pns) body (compE1 ([this] @ pns) body) ?xs2'"
[PROOF STATE]
proof (prove)
using this:
fv body \<subseteq> set pns \<union> {this}
\<not> contains_insync body

goal (1 subgoal):
 1. bisim ([this] @ pns) body (compE1 ([this] @ pns) body) (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
by -(rule compE1_bisim, auto)
[PROOF STATE]
proof (state)
this:
bisim ([this] @ pns) body (compE1 ([this] @ pns) body) (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)

goal (4 subgoals):
 1. bisim [] (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
 2. fv (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) = {}
 3. \<D> (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) \<lfloor>{}\<rfloor>
 4. max_vars (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) \<le> length (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
with \<open>length vs = length pns\<close> \<open>length Ts = length pns\<close>
[PROOF STATE]
proof (chain)
picking this:
length vs = length pns
length Ts = length pns
bisim ([this] @ pns) body (compE1 ([this] @ pns) body) (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
have "bisim ([] @ [this]) (blocks pns Ts vs body) (blocks1 (Suc 0) Ts (compE1 (this # pns) body)) ?xs2'"
[PROOF STATE]
proof (prove)
using this:
length vs = length pns
length Ts = length pns
bisim ([this] @ pns) body (compE1 ([this] @ pns) body) (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)

goal (1 subgoal):
 1. bisim ([] @ [this]) (blocks pns Ts vs body) (blocks1 (Suc 0) Ts (compE1 (this # pns) body)) (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
by -(drule blocks_bisim,auto simp add: nth_append)
[PROOF STATE]
proof (state)
this:
bisim ([] @ [this]) (blocks pns Ts vs body) (blocks1 (Suc 0) Ts (compE1 (this # pns) body)) (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)

goal (4 subgoals):
 1. bisim [] (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
 2. fv (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) = {}
 3. \<D> (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) \<lfloor>{}\<rfloor>
 4. max_vars (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) \<le> length (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
from bisimBlockSomeNone[OF this, of "Addr a" "Class D"]
[PROOF STATE]
proof (chain)
picking this:
(Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value) ! length [] = Addr a \<Longrightarrow> bisim [] {this:Class D=\<lfloor>Addr a\<rfloor>; blocks pns Ts vs body} {length []:Class D=None; blocks1 (Suc 0) Ts (compE1 (this # pns) body)} (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
show "bisim [] ?e1' ?e2' ?xs2'"
[PROOF STATE]
proof (prove)
using this:
(Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value) ! length [] = Addr a \<Longrightarrow> bisim [] {this:Class D=\<lfloor>Addr a\<rfloor>; blocks pns Ts vs body} {length []:Class D=None; blocks1 (Suc 0) Ts (compE1 (this # pns) body)} (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)

goal (1 subgoal):
 1. bisim [] (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
bisim [] (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)

goal (3 subgoals):
 1. fv (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) = {}
 2. \<D> (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) \<lfloor>{}\<rfloor>
 3. max_vars (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) \<le> length (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
from fv' len
[PROOF STATE]
proof (chain)
picking this:
fv body \<subseteq> set pns \<union> {this}
length vs = length pns
length Ts = length pns
[PROOF STEP]
show "fv ?e1' = {}"
[PROOF STATE]
proof (prove)
using this:
fv body \<subseteq> set pns \<union> {this}
length vs = length pns
length Ts = length pns

goal (1 subgoal):
 1. fv (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) = {}
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
fv (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) = {}

goal (2 subgoals):
 1. \<D> (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) \<lfloor>{}\<rfloor>
 2. max_vars (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) \<le> length (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
from wf sees
[PROOF STATE]
proof (chain)
picking this:
wf_J_prog P
P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D
[PROOF STEP]
have "wf_mdecl wf_J_mdecl P D (M,Ts,T,\<lfloor>(pns,body)\<rfloor>)"
[PROOF STATE]
proof (prove)
using this:
wf_J_prog P
P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D

goal (1 subgoal):
 1. wf_mdecl wf_J_mdecl P D (M, Ts, T, \<lfloor>(pns, body)\<rfloor>)
[PROOF STEP]
by(rule sees_wf_mdecl)
[PROOF STATE]
proof (state)
this:
wf_mdecl wf_J_mdecl P D (M, Ts, T, \<lfloor>(pns, body)\<rfloor>)

goal (2 subgoals):
 1. \<D> (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) \<lfloor>{}\<rfloor>
 2. max_vars (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) \<le> length (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
hence "\<D> body \<lfloor>set pns \<union> {this}\<rfloor>"
[PROOF STATE]
proof (prove)
using this:
wf_mdecl wf_J_mdecl P D (M, Ts, T, \<lfloor>(pns, body)\<rfloor>)

goal (1 subgoal):
 1. \<D> body \<lfloor>set pns \<union> {this}\<rfloor>
[PROOF STEP]
by(auto simp add: wf_mdecl_def)
[PROOF STATE]
proof (state)
this:
\<D> body \<lfloor>set pns \<union> {this}\<rfloor>

goal (2 subgoals):
 1. \<D> (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) \<lfloor>{}\<rfloor>
 2. max_vars (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) \<le> length (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
with \<open>length vs = length pns\<close> \<open>length Ts = length pns\<close>
[PROOF STATE]
proof (chain)
picking this:
length vs = length pns
length Ts = length pns
\<D> body \<lfloor>set pns \<union> {this}\<rfloor>
[PROOF STEP]
have "\<D> (blocks pns Ts vs body) \<lfloor>dom [this \<mapsto> Addr a]\<rfloor>"
[PROOF STATE]
proof (prove)
using this:
length vs = length pns
length Ts = length pns
\<D> body \<lfloor>set pns \<union> {this}\<rfloor>

goal (1 subgoal):
 1. \<D> (blocks pns Ts vs body) \<lfloor>dom [this \<mapsto> Addr a]\<rfloor>
[PROOF STEP]
by(auto)
[PROOF STATE]
proof (state)
this:
\<D> (blocks pns Ts vs body) \<lfloor>dom [this \<mapsto> Addr a]\<rfloor>

goal (2 subgoals):
 1. \<D> (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) \<lfloor>{}\<rfloor>
 2. max_vars (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) \<le> length (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
thus "\<D> ?e1' \<lfloor>{}\<rfloor>"
[PROOF STATE]
proof (prove)
using this:
\<D> (blocks pns Ts vs body) \<lfloor>dom [this \<mapsto> Addr a]\<rfloor>

goal (1 subgoal):
 1. \<D> (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) \<lfloor>{}\<rfloor>
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<D> (blocks (this # pns) (Class D # Ts) (Addr a # vs) body) \<lfloor>{}\<rfloor>

goal (1 subgoal):
 1. max_vars (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) \<le> length (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
from len
[PROOF STATE]
proof (chain)
picking this:
length vs = length pns
length Ts = length pns
[PROOF STEP]
show "max_vars ?e2' \<le> length ?xs2'"
[PROOF STATE]
proof (prove)
using this:
length vs = length pns
length Ts = length pns

goal (1 subgoal):
 1. max_vars (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) \<le> length (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)
[PROOF STEP]
by(auto simp add: blocks1_max_vars)
[PROOF STATE]
proof (state)
this:
max_vars (blocks1 0 (Class D # Ts) (compE1 (this # pns) body)) \<le> length (Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value)

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
bisim_list1 (e1', es1') ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
bisim_list1 (e1', es1') ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
have "\<tau>Move0 P h (e1, es1)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<tau>Move0 P h (e1, es1)
[PROOF STEP]
using call ha sees
[PROOF STATE]
proof (prove)
using this:
call e1 = \<lfloor>(a, M, vs)\<rfloor>
typeof_addr h a = \<lfloor>U\<rfloor>
P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D

goal (1 subgoal):
 1. \<tau>Move0 P h (e1, es1)
[PROOF STEP]
by(fastforce simp add: synthesized_call_def  \<tau>external'_def dest: sees_method_fun \<tau>move0_callD[where P=P and h=h])
[PROOF STATE]
proof (state)
this:
\<tau>Move0 P h (e1, es1)

goal (2 subgoals):
 1. \<And>a M vs U Ts T pns body D. \<lbrakk>ta = \<lbrace>\<rbrace>; e1' = blocks (this # pns) (Class D # Ts) (Addr a # vs) body; es1' = e1 # es1; h' = h; call e1 = \<lfloor>(a, M, vs)\<rfloor>; typeof_addr h a = \<lfloor>U\<rfloor>; P \<turnstile> class_type_of U sees M: Ts\<rightarrow>T = \<lfloor>(pns, body)\<rfloor> in D; length vs = length pns; length Ts = length pns\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
 2. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
\<tau>Red1't (compP1 P) t h ((E, xs), exs2) ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)
bisim_list1 (e1', es1') ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)
\<tau>Move0 P h (e1, es1)
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
\<tau>Red1't (compP1 P) t h ((E, xs), exs2) ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)
bisim_list1 (e1', es1') ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)
\<tau>Move0 P h (e1, es1)

goal (1 subgoal):
 1. \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
using ex2 \<open>call e1 = \<lfloor>(a, M, vs)\<rfloor>\<close>
[PROOF STATE]
proof (prove)
using this:
\<tau>Red1't (compP1 P) t h ((E, xs), exs2) ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)
bisim_list1 (e1', es1') ((blocks1 0 (Class D # Ts) (compE1 (this # pns) body), Addr a # vs @ replicate (max_vars (compE1 (this # pns) body)) undefined_value), (e', xs') # exs2)
\<tau>Move0 P h (e1, es1)
ex2 = (E, xs)
call e1 = \<lfloor>(a, M, vs)\<rfloor>

goal (1 subgoal):
 1. \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
by(simp del: \<tau>Move1.simps)(rule exI conjI|assumption)+
[PROOF STATE]
proof (state)
this:
\<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
case (red0Return e)
[PROOF STATE]
proof (state)
this:
es1 = e # es1'
ta = \<lbrace>\<rbrace>
e1' = inline_call e1 e
h' = h
final e1

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
note es1 = \<open>es1 = e # es1'\<close> and e1' = \<open>e1' = inline_call e1 e\<close>
    and [simp] = \<open>ta = \<epsilon>\<close> \<open>h' = h\<close>
    and fin = \<open>final e1\<close>
[PROOF STATE]
proof (state)
this:
es1 = e # es1'
e1' = inline_call e1 e
ta = \<lbrace>\<rbrace>
h' = h
final e1

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from bisiml es1
[PROOF STATE]
proof (chain)
picking this:
bisim_list1 (e1, es1) (ex2, exs2)
es1 = e # es1'
[PROOF STEP]
obtain E' xs' E xs exs' aMvs where ex2: "ex2 = (E', xs')" and exs2: "exs2 = (E, xs) # exs'"
    and bisim': "bisim [] e1 E' xs'"
    and bisim: "bisim [] e E xs"
    and fv: "fv e = {}"
    and length: "max_vars E \<le> length xs"
    and bisiml: "bisim_list es1' exs'"
    and D: "\<D> e \<lfloor>{}\<rfloor>"
    and call: "call e = \<lfloor>aMvs\<rfloor>"
    and call1: "call1 E = \<lfloor>aMvs\<rfloor>"
[PROOF STATE]
proof (prove)
using this:
bisim_list1 (e1, es1) (ex2, exs2)
es1 = e # es1'

goal (1 subgoal):
 1. (\<And>E' xs' E xs exs' aMvs. \<lbrakk>ex2 = (E', xs'); exs2 = (E, xs) # exs'; bisim [] e1 E' xs'; bisim [] e E xs; fv e = {}; max_vars E \<le> length xs; bisim_list es1' exs'; \<D> e \<lfloor>{}\<rfloor>; call e = \<lfloor>aMvs\<rfloor>; call1 E = \<lfloor>aMvs\<rfloor>\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(fastforce elim: bisim_list1_elim)
[PROOF STATE]
proof (state)
this:
ex2 = (E', xs')
exs2 = (E, xs) # exs'
bisim [] e1 E' xs'
bisim [] e E xs
fv e = {}
max_vars E \<le> length xs
bisim_list es1' exs'
\<D> e \<lfloor>{}\<rfloor>
call e = \<lfloor>aMvs\<rfloor>
call1 E = \<lfloor>aMvs\<rfloor>

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
let ?e2' = "inline_call E' E"
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from \<open>final e1\<close> bisim'
[PROOF STATE]
proof (chain)
picking this:
final e1
bisim [] e1 E' xs'
[PROOF STEP]
have "final E'"
[PROOF STATE]
proof (prove)
using this:
final e1
bisim [] e1 E' xs'

goal (1 subgoal):
 1. final E'
[PROOF STEP]
by(auto)
[PROOF STATE]
proof (state)
this:
final E'

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
hence red': "False,compP1 P,t \<turnstile>1 \<langle>ex2/exs2, h\<rangle> -\<epsilon>\<rightarrow> \<langle>(?e2', xs)/exs', h\<rangle>"
[PROOF STATE]
proof (prove)
using this:
final E'

goal (1 subgoal):
 1. False,compP1 P,t \<turnstile>1 \<langle>ex2/exs2,h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(inline_call E' E, xs)/exs',h\<rangle>
[PROOF STEP]
unfolding ex2 exs2
[PROOF STATE]
proof (prove)
using this:
final E'

goal (1 subgoal):
 1. False,compP1 P,t \<turnstile>1 \<langle>(E', xs')/(E, xs) # exs',h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(inline_call E' E, xs)/exs',h\<rangle>
[PROOF STEP]
by(rule red1Return)
[PROOF STATE]
proof (state)
this:
False,compP1 P,t \<turnstile>1 \<langle>ex2/exs2,h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(inline_call E' E, xs)/exs',h\<rangle>

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
False,compP1 P,t \<turnstile>1 \<langle>ex2/exs2,h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(inline_call E' E, xs)/exs',h\<rangle>

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
have "\<tau>Move0 P h (e1, es1) = \<tau>Move1 P h ((E', xs'), exs2)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<tau>Move0 P h (e1, es1) = \<tau>Move1 P h ((E', xs'), exs2)
[PROOF STEP]
using \<open>final e1\<close> \<open>final E'\<close>
[PROOF STATE]
proof (prove)
using this:
final e1
final E'

goal (1 subgoal):
 1. \<tau>Move0 P h (e1, es1) = \<tau>Move1 P h ((E', xs'), exs2)
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<tau>Move0 P h (e1, es1) = \<tau>Move1 P h ((E', xs'), exs2)

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
\<tau>Move0 P h (e1, es1) = \<tau>Move1 P h ((E', xs'), exs2)

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
{
[PROOF STATE]
proof (state)
this:
\<tau>Move0 P h (e1, es1) = \<tau>Move1 P h ((E', xs'), exs2)

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
note bisiml
[PROOF STATE]
proof (state)
this:
bisim_list es1' exs'

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
bisim_list es1' exs'

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from bisim' fin bisim
[PROOF STATE]
proof (chain)
picking this:
bisim [] e1 E' xs'
final e1
bisim [] e E xs
[PROOF STEP]
have "bisim [] (inline_call e1 e) (inline_call E' E) xs"
[PROOF STATE]
proof (prove)
using this:
bisim [] e1 E' xs'
final e1
bisim [] e E xs

goal (1 subgoal):
 1. bisim [] (inline_call e1 e) (inline_call E' E) xs
[PROOF STEP]
using call
[PROOF STATE]
proof (prove)
using this:
bisim [] e1 E' xs'
final e1
bisim [] e E xs
call e = \<lfloor>aMvs\<rfloor>

goal (1 subgoal):
 1. bisim [] (inline_call e1 e) (inline_call E' E) xs
[PROOF STEP]
by(rule bisim_inline_call)(simp add: fv)
[PROOF STATE]
proof (state)
this:
bisim [] (inline_call e1 e) (inline_call E' E) xs

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
bisim [] (inline_call e1 e) (inline_call E' E) xs

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from fv_inline_call[of e1 e] fv fin
[PROOF STATE]
proof (chain)
picking this:
fv (inline_call e1 e) \<subseteq> fv e \<union> fv e1
fv e = {}
final e1
[PROOF STEP]
have "fv (inline_call e1 e) = {}"
[PROOF STATE]
proof (prove)
using this:
fv (inline_call e1 e) \<subseteq> fv e \<union> fv e1
fv e = {}
final e1

goal (1 subgoal):
 1. fv (inline_call e1 e) = {}
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
fv (inline_call e1 e) = {}

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
fv (inline_call e1 e) = {}

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
from fin
[PROOF STATE]
proof (chain)
picking this:
final e1
[PROOF STEP]
have "\<D> (inline_call e1 e) \<lfloor>{}\<rfloor>"
[PROOF STATE]
proof (prove)
using this:
final e1

goal (1 subgoal):
 1. \<D> (inline_call e1 e) \<lfloor>{}\<rfloor>
[PROOF STEP]
using call D
[PROOF STATE]
proof (prove)
using this:
final e1
call e = \<lfloor>aMvs\<rfloor>
\<D> e \<lfloor>{}\<rfloor>

goal (1 subgoal):
 1. \<D> (inline_call e1 e) \<lfloor>{}\<rfloor>
[PROOF STEP]
by(rule defass_inline_call)
[PROOF STATE]
proof (state)
this:
\<D> (inline_call e1 e) \<lfloor>{}\<rfloor>

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
\<D> (inline_call e1 e) \<lfloor>{}\<rfloor>

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
have "max_vars ?e2' \<le> max_vars E + max_vars E'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. max_vars (inline_call E' E) \<le> max_vars E + max_vars E'
[PROOF STEP]
by(rule inline_call_max_vars1)
[PROOF STATE]
proof (state)
this:
max_vars (inline_call E' E) \<le> max_vars E + max_vars E'

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
with \<open>final E'\<close> length
[PROOF STATE]
proof (chain)
picking this:
final E'
max_vars E \<le> length xs
max_vars (inline_call E' E) \<le> max_vars E + max_vars E'
[PROOF STEP]
have "max_vars ?e2' \<le> length xs"
[PROOF STATE]
proof (prove)
using this:
final E'
max_vars E \<le> length xs
max_vars (inline_call E' E) \<le> max_vars E + max_vars E'

goal (1 subgoal):
 1. max_vars (inline_call E' E) \<le> length xs
[PROOF STEP]
by(auto elim!: final.cases)
[PROOF STATE]
proof (state)
this:
max_vars (inline_call E' E) \<le> length xs

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
bisim_list es1' exs'
bisim [] (inline_call e1 e) (inline_call E' E) xs
fv (inline_call e1 e) = {}
\<D> (inline_call e1 e) \<lfloor>{}\<rfloor>
max_vars (inline_call E' E) \<le> length xs
[PROOF STEP]
have "bisim_list1 (inline_call e1 e, es1') ((?e2', xs), exs')"
[PROOF STATE]
proof (prove)
using this:
bisim_list es1' exs'
bisim [] (inline_call e1 e) (inline_call E' E) xs
fv (inline_call e1 e) = {}
\<D> (inline_call e1 e) \<lfloor>{}\<rfloor>
max_vars (inline_call E' E) \<le> length xs

goal (1 subgoal):
 1. bisim_list1 (inline_call e1 e, es1') ((inline_call E' E, xs), exs')
[PROOF STEP]
by(rule bisim_list1I)
[PROOF STATE]
proof (state)
this:
bisim_list1 (inline_call e1 e, es1') ((inline_call E' E, xs), exs')

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
bisim_list1 (inline_call e1 e, es1') ((inline_call E' E, xs), exs')

goal (1 subgoal):
 1. \<And>e. \<lbrakk>es1 = e # es1'; ta = \<lbrace>\<rbrace>; e1' = inline_call e1 e; h' = h; final e1\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
False,compP1 P,t \<turnstile>1 \<langle>ex2/exs2,h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(inline_call E' E, xs)/exs',h\<rangle>
\<tau>Move0 P h (e1, es1) = \<tau>Move1 P h ((E', xs'), exs2)
bisim_list1 (inline_call e1 e, es1') ((inline_call E' E, xs), exs')
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
False,compP1 P,t \<turnstile>1 \<langle>ex2/exs2,h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(inline_call E' E, xs)/exs',h\<rangle>
\<tau>Move0 P h (e1, es1) = \<tau>Move1 P h ((E', xs'), exs2)
bisim_list1 (inline_call e1 e, es1') ((inline_call E' E, xs), exs')

goal (1 subgoal):
 1. \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
using e1' \<open>final e1\<close> \<open>final E'\<close> ex2
[PROOF STATE]
proof (prove)
using this:
False,compP1 P,t \<turnstile>1 \<langle>ex2/exs2,h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(inline_call E' E, xs)/exs',h\<rangle>
\<tau>Move0 P h (e1, es1) = \<tau>Move1 P h ((E', xs'), exs2)
bisim_list1 (inline_call e1 e, es1') ((inline_call E' E, xs), exs')
e1' = inline_call e1 e
final e1
final E'
ex2 = (E', xs')

goal (1 subgoal):
 1. \<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')
[PROOF STEP]
apply(simp del: \<tau>Move0.simps \<tau>Move1.simps)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<lbrakk>False,compP (\<lambda>C M Ts T (pns, body). compE1 (this # pns) body) P,t \<turnstile>1 \<langle>(E', xs')/exs2,h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(inline_call E' E, xs)/exs',h\<rangle>; \<tau>Move0 P h (e1, es1) = \<tau>Move1 P h ((E', xs'), exs2); bisim_list1 (inline_call e1 e, es1') ((inline_call E' E, xs), exs'); e1' = inline_call e1 e; final e1; final E'; ex2 = (E', xs')\<rbrakk> \<Longrightarrow> \<exists>ex2'' exs2''. (\<tau>Move1 P h ((E', xs'), exs2) \<longrightarrow> bisim_list1 (inline_call e1 e, es1') (ex2'', exs2'') \<and> \<tau>Red1't (compP (\<lambda>C M Ts T (pns, y). compE1 (this # pns) y) P) t h ((E', xs'), exs2) (ex2'', exs2'')) \<and> (\<not> \<tau>Move1 P h ((E', xs'), exs2) \<longrightarrow> bisim_list1 (inline_call e1 e, es1') (ex2'', exs2'') \<and> (\<exists>ex2' exs2'. \<tau>Red1'r (compP (\<lambda>C M Ts T (pns, y). compE1 (this # pns) y) P) t h ((E', xs'), exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 E' = None \<or> ex2' = (E', xs') \<and> exs2' = exs2) \<and> False,compP (\<lambda>C M Ts T (pns, y). compE1 (this # pns) y) P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>ex2''/exs2'',h\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2')))
[PROOF STEP]
apply(rule exI conjI impI|assumption)+
[PROOF STATE]
proof (prove)
goal (2 subgoals):
 1. \<lbrakk>False,compP (\<lambda>C M Ts T (pns, body). compE1 (this # pns) body) P,t \<turnstile>1 \<langle>(E', xs')/exs2,h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(inline_call E' E, xs)/exs',h\<rangle>; \<tau>Move0 P h (e1, es1) = \<tau>Move1 P h ((E', xs'), exs2); bisim_list1 (inline_call e1 e, es1') ((inline_call E' E, xs), exs'); e1' = inline_call e1 e; final e1; final E'; ex2 = (E', xs'); \<tau>Move1 P h ((E', xs'), exs2)\<rbrakk> \<Longrightarrow> \<tau>Red1't (compP (\<lambda>C M Ts T (pns, y). compE1 (this # pns) y) P) t h ((E', xs'), exs2) ((inline_call E' E, xs), exs')
 2. \<lbrakk>False,compP (\<lambda>C M Ts T (pns, body). compE1 (this # pns) body) P,t \<turnstile>1 \<langle>(E', xs')/exs2,h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(inline_call E' E, xs)/exs',h\<rangle>; \<tau>Move0 P h (e1, es1) = \<tau>Move1 P h ((E', xs'), exs2); bisim_list1 (inline_call e1 e, es1') ((inline_call E' E, xs), exs'); e1' = inline_call e1 e; final e1; final E'; ex2 = (E', xs')\<rbrakk> \<Longrightarrow> \<not> \<tau>Move1 P h ((E', xs'), exs2) \<longrightarrow> bisim_list1 (inline_call e1 e, es1') ((inline_call E' E, xs), exs') \<and> (\<exists>ex2' exs2'. \<tau>Red1'r (compP (\<lambda>C M Ts T (pns, y). compE1 (this # pns) y) P) t h ((E', xs'), exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 E' = None \<or> ex2' = (E', xs') \<and> exs2' = exs2) \<and> False,compP (\<lambda>C M Ts T (pns, y). compE1 (this # pns) y) P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(inline_call E' E, xs)/exs',h\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2'))
[PROOF STEP]
apply(rule tranclp.r_into_trancl, simp)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<lbrakk>False,compP (\<lambda>C M Ts T (pns, body). compE1 (this # pns) body) P,t \<turnstile>1 \<langle>(E', xs')/exs2,h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(inline_call E' E, xs)/exs',h\<rangle>; \<tau>Move0 P h (e1, es1) = \<tau>Move1 P h ((E', xs'), exs2); bisim_list1 (inline_call e1 e, es1') ((inline_call E' E, xs), exs'); e1' = inline_call e1 e; final e1; final E'; ex2 = (E', xs')\<rbrakk> \<Longrightarrow> \<not> \<tau>Move1 P h ((E', xs'), exs2) \<longrightarrow> bisim_list1 (inline_call e1 e, es1') ((inline_call E' E, xs), exs') \<and> (\<exists>ex2' exs2'. \<tau>Red1'r (compP (\<lambda>C M Ts T (pns, y). compE1 (this # pns) y) P) t h ((E', xs'), exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 E' = None \<or> ex2' = (E', xs') \<and> exs2' = exs2) \<and> False,compP (\<lambda>C M Ts T (pns, y). compE1 (this # pns) y) P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -\<lbrace>\<rbrace>\<rightarrow> \<langle>(inline_call E' E, xs)/exs',h\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2'))
[PROOF STEP]
apply blast
[PROOF STATE]
proof (prove)
goal:
No subgoals!
[PROOF STEP]
done
[PROOF STATE]
proof (state)
this:
\<exists>ex2'' exs2''. bisim_list1 (e1', es1') (ex2'', exs2'') \<and> (if \<tau>Move0 P h (e1, es1) then \<tau>Red1't (compP1 P) t h (ex2, exs2) (ex2'', exs2'') \<and> ta = \<lbrace>\<rbrace> \<and> h = h' else \<exists>ex2' exs2' ta'. \<tau>Red1'r (compP1 P) t h (ex2, exs2) (ex2', exs2') \<and> (call e1 = None \<or> call1 (fst ex2) = None \<or> ex2' = ex2 \<and> exs2' = exs2) \<and> False,compP1 P,t \<turnstile>1 \<langle>ex2'/exs2',h\<rangle> -ta'\<rightarrow> \<langle>ex2''/exs2'',h'\<rangle> \<and> \<not> \<tau>Move1 P h (ex2', exs2') \<and> ta_bisim01 ta ta')

goal:
No subgoals!
[PROOF STEP]
qed