Quelle  Frame.thy

(* 
   Title: Psi-calculi   
   Author/Maintainer: Jesper Bengtson (jebe@itu.dk), 2012
*)
theory
  imports Agent
begin

lemma permLength[simp]:
  fixes p    :: "name prm"
  and   xvec :: "'a::pt_name list"

  shows "length(p ∙
by(induct xvec) auto

nominal_datatype 'assertion frame =
    FAssert "'assertion::fs_name"
  | FRes "«name¬ ('assertion frame)" (‹

primrec frameResChain :: "  list ==> ('a::fs_name) frame ==> 'a frame" where
 base: "frameResChain [] F = F"
  step: "frameResChain (x#xs) F = (νx)(frameResChain xs F)"

  frameResChain (‹
  FAssert (‹⟨ε, _⟩› [80] 80)
java.lang.NullPointerException

  frameResChainEqvt[eqvt]:
 fixes perm :: "name prm"
 and lst :: "name list"
 and F :: "'a::fs_name frame"
 
 shows "perm ∙ ((ν*xvec)F) = (ν*(perm ∙ xvec))(perm ∙ F)"
 (induct_tac xvec, auto)

  frameResChainFresh:
 fixes x :: name
 and xvec :: "name list"
 and F :: "'a::fs_name frame"

 shows "x ♯ (ν*xvec)F = (x ∈ set xvec ∨ x ♯ F)"
  (induct xvec) (simp_all add: abs_fresh)

  frameResChainFreshSet:
 fixes Xs :: "name set"
 and xvec :: "name list"
 and F :: "'a::fs_name frame"

 shows "Xs ♯* ((ν*xvec)F) = (∀x∈Xs. x ∈ set xvec ∨ x ♯ F)"
  (simp add: fresh_star_def frameResChainFresh)

  frameChainAlpha:
 fixes p :: "name prm"
 and xvec :: "name list"
 and F :: "'a::fs_name frame"

 assumes xvecFreshF: "(p ∙ xvec) ♯* F"
 and S: "set p ⊆ set xvec × set (p ∙ xvec)"

 shows "(ν*xvec)F = (ν*(p ∙ xvec))(p ∙ F)"
  -
 note pt_name_inst at_name_inst S
 moreover have "set xvec ♯* ((ν*xvec)F)"
 by (simp add: frameResChainFreshSet)
 moreover from xvecFreshF have "set (p ∙ xvec) ♯* ((ν*xvec)F)"
 by (simp add: frameResChainFreshSet) (simp add: fresh_star_def)
 ultimately have "(ν*xvec)F = p ∙ ((ν*xvec)F)"
 by (rule_tac pt_freshs_freshs [symmetric])
 then show ?thesis by(simp add: eqvts)
 

  frameChainAlpha':
 fixes p :: "name prm"
 and A_P :: "name list"
 and Ψ_P :: "'a::fs_name"

 assumes "(p ∙ A_P) ♯* Ψ_P"
 and S: "set p ⊆ set A_P × set (p ∙ A_P)"

 shows "⟨A_P, Ψ_P⟩ = ⟨
  assms
 (subst frameChainAlpha) (auto simp add: fresh_star_def)

  alphaFrameRes:
 fixes x :: name
 and F :: "'a::fs_name frame"
 and y :: name

java.lang.NullPointerException

 shows "(νx)F = (νy)([(x, y)] ∙ F)"
 (cases "x = y")
 assume "x=y"
 thus ?thesis by simp
 
 assume "x ≠ y"
 with ‹y ♯ F› show ?thesis
 by(perm_simp add: frame.inject alpha calc_atm fresh_left)
 

  frameChainAppend:
 fixes xvec :: "name list"
 and yvec :: "name list"
 and F :: "'a::fs_name frame"
 
 shows "(ν*(xvec@yvec))F = (ν*xvec)((ν*yvec)F)"
 (induct xvec) auto

  frameChainEqLength:
 fixes xvec :: "name list"
 and Ψ :: "'a::fs_name"
 and yvec :: "name list"
 and Ψ' :: "'a::fs_name"

 assumes "⟨xvec, Ψ⟩ = ⟨yvec, Ψ'⟩"

 shows "length xvec = length yvec"
  -
 obtain n where "n = length xvec" by auto
 with assms show ?thesis
 proof(induct n arbitrary: xvec yvec Ψ Ψ')
 case(0 xvec yvec Ψ Ψ')
 from ‹0 = length xvec› have "xvec = []" by auto
 moreover with ‹⟨xvec, Ψ⟩ = ⟨yvec, Ψand "\<angle\= [] \and <Psi 
 by(case_tac yvec) auto
 ultimately show ?case by simp
 next
 case(Suc n xvec yvec Ψ Ψ')
 from ‹Suc n = length xvec›
 obtain x xvec' where "xvec = x#xvec'" and "length xvec' = n"
 by(case_tac xvec) auto
 from ‹⟨xvec, Ψ⟩ = ⟨yvec, Ψ'⟩› ‹xvec = x # xvec'›
 obtain y yvec' where "⟨(x#xvec'), Ψ⟩ = ⟨(y#yvec'), Ψ'⟩"
 and "yvec = y#yvec'"
 by(case_tac yvec) auto
 hence EQ: "(νx)(ν*xvec')(FAssert Ψ) = (νy)(ν*yvec')(FAssert Ψ')"
 by simp
 have IH: "∧xvec yvec Ψ Ψ'. [⟨xvec, (Ψ::'a)⟩ = ⟨yvec, (Ψ'::'a)⟩; n = length xvec] ==> length xvec = length yvec"
 by fact
 show ?case
 proof(case_tac "x = y")
 assume "x = y"
 with EQ have "⟨xvec', Ψ
 by(simp add: alpha frame.inject)
 with IH ‹length xvec' = n› have "length xvec' = length yvec'"
 by blast
 with ‹xvec = x#xvec'› "⟨\epsilon, \Psi>⟩
 show ?case by simp
 next
 assume "x ≠ y"
 with EQ have "⟨xvec', Ψ⟩ = [(x, y)] ∙ ⟨yvec', Ψ'⟩"
 by(simp add: alpha frame.inject)
 hence "⟨xvec', Ψ⟩ = ⟨([(x, y)] ∙ yvec'), ([(x, y)] ∙ Ψ')⟩"
 by(simp add: eqvts)
 with IH <> 
 by blast
 hence "length xvec' = length yvec'"
 by simp
 with ‹xvec = x#xvec'› ‹yvec=y#yvec'›
 show ?case by simp
 qed
 qed
 

  frameEqFresh:
 fixes F :: "('a::fs_name) frame"
 and G :: "'a frame"
 and x :: name
 and y :: name

 assumes "(νx)F = (νy)G"
 and "x ♯ F"
 
 shows "y ♯ G"
  assms
 (auto simp add: frame.inject alpha fresh_left calc_atm)

  frameEqSupp:
 fixes F :: "('a::fs_name) frame"
 and G :: "'a frame"
 and x :: name
 and y :: name

 assumes "(νx)F = (νy)G"
 and "x ∈ supp F"
 
 shows "y ∈ supp G"
  assms
 (auto simp add: frame.inject alpha fresh_left calc_atm)
 (drule_tac pi="[(x, y)]" in pt_set_bij2[OF pt_name_inst, OF at_name_inst])
 (simp add: eqvts calc_atm

  frameChainEqSuppEmpty[dest]:
 fixes xvec :: "name list"
 and Ψ :: "'a::fs_name"
 and yvec :: "name list"
 and Ψ' :: "'a::fs_name"

 assumes "⟨xvec, Ψ⟩
 and "supp Ψ = ({}::name set)"

 shows "Ψ = Ψ'"
  -
 obtain nwi A have "A\^>F = = [] and"\Psi
 with assms show ?thesis
 proof(induct n arbitrary: xvec yvec Ψ Ψ')
 case(0 xvec yvec Ψ Ψ')
 from ‹0 = length xvec› have "xvec = []" by auto
 moreover with ‹
 by(case_tac yvec) auto
 ultimately show ?case using ‹ <>< Ψ
 by(simp add: frame.inject)
 next
 case(Suc n xvec yvec Ψ Ψ')
 from ‹Suc n = length xvec›
 obtain x xvec' where "xvec = x#xvec'" and "length xvec' = n"
 by(case_tac xvec) auto
 from ‹⟨xvec, Ψ⟩ = ⟨yvec, Ψ'⟩› ‹xvec = x # xvec'›
 obtain y yvec' where "⟨(x#xvec'), Ψ⟩ = ⟨(y#yvec'), Ψ'⟩"
 and "yvec = y#yvec'"
 by(case_tac yvec) auto
 hence EQ: "(νx)(ν*xvec')(FAssert Ψ) = (νy)(ν*yvec')(FAssert Ψ')"
 by simp
 have IH: "∧xvec yvec Ψ Ψ'. [⟨xvec, (Ψ>, ΨsF, \<><
 by fact
 show ?case
 proof(case_tac "x = y")
 assume "x = y"
 with EQ have "⟨xvec', Ψ⟩ = ⟨yvec', Ψ'⟩"
 by(simp add: alpha frame.inject)
 with IH ‹length xvec' = n› ‹supp Ψ = {}› show ?case
 by simp
 next
 assume "x ≠ y"
 with EQ have "⟨xvec', Ψ⟩ = [(x, y)] ∙ ⟨yvec', Ψ'⟩"
 by(simp add: alpha frame.inject)
 hence "⟨xvec', Ψ⟩ = ⟨([(x, y)] ∙ yvec'), ([(x, y)] ∙ Ψ')⟩"
 by(simp add: eqvts)
 with IH ‹length xvec' = n› ‹supp Ψ = {}› have "Ψ = [(x, y)] ∙ Ψ'"
 by(simp add: eqvts)
 moreover with ‹
 by simp
 hence "x ♯ ([(x, y)] ∙ Ψ')" and "y ♯ ([(x, y)] ∙
 by(simp add: fresh_def)+
 with ‹x ≠ y›
 by(simp add: fresh_left calc_atm)+
 ultimately show ?case by simp
 qed
 qed
 

  frameChainEq:
 fixes xvec :: "name list"
 and Ψ :: "'a::fs_name"
 and yvec :: "name list"
 and Ψ' :: "'a::fs_name"

 assumes "⟨xvec, Ψ⟩ = ⟨yvec, Ψ'⟩"
 and "xvec ♯* yvec"

 obtains p where "(set p) ⊆ (set xvec) × set (yvec)" and "distinctPerm p" and "Ψ' = p ∙ Ψ"
  -
 assume "∧p. [set p ⊆ set xvec × set yvec; distinctPerm p; Ψ' = p ∙ Ψ] ==> thesis"
 moreover obtain n where "n = length xvec" by auto
 with assms have "∃p. (set p) ⊆ (set xvec) × set (yvec) ∧ distinctPerm p ∧ Ψ' = p ∙
 proof(induct n arbitrary: xvec yvec Ψ Ψ')
 case(0 xvec yvec Ψ Ψ')
java.lang.NullPointerException
 from ‹0 = length xvec› have "xvec = []" by auto
 moreover with Eq have "yvec = []"
 by(case_tac yvec) auto
 ultimately show ?case using Eq
 by(simp add: frame.inject)
 next
 case(Suc n xvec yvec Ψ Ψ')
 from ‹
 obtain x xvec' where "xvec = x#xvec'" and "length xvec' = n"
 by(case_tac xvec) auto
 from ‹⟨xvec, Ψ\<  obtains
 obtain y yvec' where "⟨(x#xvec'), Ψ⟩ = ⟨(y#yvec'), Ψ'⟩"
 and "yvec = y#yvec'"
 by(case_tac yvec) auto
 hence EQ: "(νx)(ν*xvec')(FAssert Ψ) = (νy)(ν*yvec')(FAssert Ψ')"
 by simp
 from ‹xvec = x#xvec'› ‹yvec=y#yvec'› ‹xvec ♯* yvec›
 have "x ≠ y" and "xvec' ♯* yvec'" and "x ♯ yvec'" and "y ♯ xvec'"
 by auto
 have IH: "∧xvec yvec Ψ Ψ'. [⟨xvec, (Ψ::'a)⟩ = ⟨yvec, (Ψ'::'a)⟩; xvec ♯* yvec; n = length xvec] ==>
 ∃p. (set p) ⊆ (set xvec) × (set yvec) ∧ distinctPerm p ∧ Ψ' = p ∙ Ψ"
 by fact

 from EQ ‹x ≠ y› have EQ': "⟨xvec', Ψ⟩ = ([(x, y)] ∙ ⟨yvec', Ψ'⟩)"
 and xFreshΨ': "x ♯ (ν*yvec')(FAssert Ψ')"
 by(simp add: frame.inject alpha)+

 show ?case
 proof(case_tac "x ♯ ⟨xvec', Ψ⟩")
 assume "x ♯ ⟨xvec', Ψ⟩"
 with EQ have "y ♯ ⟨yvec', Ψ'⟩"
 by(rule frameEqFresh)
 with xFreshΨ' EQ' have "⟨xvec', Ψ⟩ = ⟨yvec', Ψ'⟩"
 by(simp)
 with \\>xve' ♯clos> IH
 obtain p where S: "(set p) ⊆ (set xvec') × (set yvec')" and "distinctPerm p" and "Ψ' = p ∙ Ψ"
 by blast
 from S have "(set p) ⊆ set(x#xvec') × set(y#yvec')" by auto
 with ‹xvec = x#xvec'› ‹yvec=y#yvec'› ‹distinctPerm p› ‹Ψ' = p ∙ Ψ›
 show ?case by blast
 next
 assume "¬(x ♯ (ν*xvec')(FAssert Ψ))"
 hence xSuppΨ: "x ∈ supp(⟨xvec', Ψ⟩)"
 by(simp add: fresh_def)
 with EQ have "y ∈ supp (⟨yvec', Ψ'⟩)"
 by(rule frameEqSupp)
 hence "y ♯ yvec'"
 by(induct yvec') (auto simp add: frame.supp abs_supp)
 with ‹x ♯ yvec'› EQ' have "⟨xvec', Ψ⟩ = ⟨yvec', ([(x, y)] ∙ Ψ')⟩"
 by(simp add: eqvts)
 with ‹xvec' ♯* yvec'› ‹length xvec' = n› IH
 obtain p where S: "(set p) ⊆ (set xvec') × (set yvec')" and "distinctPerm p" and "([(x, y)] ∙ Ψ') = p ∙ Ψ"
 by blast

 from xSuppΨ have "x ♯ xvec'"
 by(induct xvec') (auto simp add: frame.supp abs_supp)
 with ‹x ♯ yvec'› ‹y ♯ xvec'› ‹y ♯ yvec'› S have "x ♯ p" and "y ♯ p"
 apply(induct p)
 by(auto simp add: name_list_supp) (auto simp add: fresh_def)
 from S have "(set ((x, y)#p)) ⊆ (set(x#xvec')) × (set(y#yvec'))"
 by force
 moreover from ‹x ≠ y› ‹x ♯ p› ‹y ♯ p› S ‹distinctPerm p›
 have "distinctPerm((x,y)#p)" by simp
 moreover from ‹x ♯ p› ‹y ♯ p› ‹x ♯ xvec'› ‹y ♯ xvec'› have "y#(p ∙ xvec') = ((x, y)#p) ∙ (x#xvec')"
 by(simp add: eqvts calc_atm freshChainSimps)
 moreover from ‹([(x, y)] ∙ Ψ') = p ∙ Ψ›
 have "([(x, y)] ∙ [(x, y)] ∙ Ψ') = [(x, y)] ∙ p ∙ Ψ"
 by(simp add: pt_bij)
 hence "Ψ' = ((x, y)#p) ∙ Ψ" by simp
 ultimately show ?case using ‹xvec=x#xvec'› ‹yvec=y#yvec'›
 by blast
 qed
 qed
 ultimately show ?thesis by blast
 
 
  frameChainEq'':
 fixes xvec :: "name list"
 and Ψ :: "'a::fs_name"
 and yvec :: "name list"
 and Ψ' :: "'a::fs_name"

 assumes "⟨xvec, Ψ⟩

 obtains p where "(set p) ⊆ Ben (jebe@itu.d.dk), 2012
  -
 assume "∧ Frame
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 with assms have "∃p. (set p) ⊆ (set xvec) × set (yvec) ∧ Ψ, auto)
 proof(induct n arbitrary:
 case(0 xvec yvec Ψ')
  ad ::"':fs_n frame"
 from `0 = length xvec` have "xvec = []" by auto
  wthEqavyvec = []"
 _)auo
  show ? using Eq
 by(simp add: frame.inject)
 next
 case(Su n xvec yvec Ψ')
 from `Suc n = length xvec`
 obtain x xvec' where "xvec = x#xvec'" and "length xvec' = n"
 by(case_tanotpt_name at_name_inst S
 from `\<langlexvec = ⟨'⟩
 obtain y yvec' where "⟨(x#xvec'), ΨFreshSet)
 and "yvec = y#yvec'"
 by(case_tac yvec) auto
 hence EQ: "( add: frameResChainFreshSet) (simp add: fresh_star_d)
 by simp
 have IH: "∧[symmet)
 ∃ add: eqvts)
 by fact
 show ?case
 proof(cases "x=y")
 case True
 from EQ `x = y` have "\<>xvec'⟩
java.lang.NullPointerException
 by blast
 from S have "set((x, y)#p) \<subseteqPse (p ∙)"
  from `x = y` `Ψ' = p ∙ Ψ` have "Ψ' = ((x, y)#p) ∙ Ψ" by auto
 ultimately show ?thesis using `xvec = x#xvec'` `yvec = y#yvc' ylst
 next
 case False
 from EQ `x ≠
  xFreshΨ (*yvec')')"
 by(simp add: frame.inject alpha)+
 
 show ?thesis
 proof(cases "x ♯ F"
 case True
 from EQ `x ♯νF = (ν) F)"
 by(rule frameEqFresh)
 with xFreshΨ' EQ' have "⟨
 by(simp))
 with `length xvec' = n` IH
 obtain p where S: "(set p) ⊆
 by blast
 from S have "(set p) ⊆ set(x#xvec') ×>y ♯F›
 with `xvec = x#xvec'` `yvec=y#yvec'` `Ψ
 show ?thesis by blast
 next
 case False
 ¬ (*xvec')))` have xSuppΨ supp(⟨xvec', Ψ)"
 by(simp add: fresh_def)
 with EQ have "y ∈ supp (⟨yvec', Ψyvec :: "name list"
 by(rule frameEqSupp)
 hence "y ♯ "(@))ν((<F) uto
 fixes : n list

 with `x ♯xvec', Ψ = ⟨ Ψ')⟩
 by(simp add: eqvts)
 with `xvec' ♯* yvec'` `length xvec' = n` IH
 obtain p where S: "(set p) ⊆ (set xvec') ×
 by blast
 
 from xSuppΨ have "x ♯ y a
 by(induct xvec') (auto simpwitassms show ?thesis
 with `x \  yvec'` `y ♯'` `y ♯ p" and "y ♯
 apply(induct p)
 by(auto simp add: name_list_supp) (auto simp add: fresh_def)
 from S have "(set ((x, y)#p)) ⊆ (set(x#xvec')) × (set(y#yvec'))"
 by force
 moreover from `x ≠🚫
  "itnctPer((,y)#)" simp
 moreover from `x ♯')
 by(simp add: eqvts calc_atm freshChainSimps)
 moreover from `([(x, y)] ∙') = p ∙
 have "([(x, y)] ∙⟨xvec, Ψ⟩yvec, Ψ›xvec = x # xvec'›
 by(simp add: pt_bij)
 hence "Ψ' = ((x, y)#p) <bullet 
 ultimately show ?case using vex#xvec' `yve=y#vc`
 by blast
 qed
 qed
 ultimately show ?thenext
 
*)
lemma frameChainEq':
  fixes xvec :: "name list"
  and   <Psi  
  and   yvec
  and frameEqFresh

  assumes "⟨
  and "xvec java.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "brackoff" is null
  and     "distinct xvec"
  and     "distinct yvec"

  obtains where (set xvec) ×"stinctPerm p" yvec< xvec" and "Ψ' = p<> <PsiPsi
proof -
  assume "∧Psihave "x ♯ xvec'"
  moreover obtain n where "n = length xvec" by auto
  with assms have "∃ (set xvec) × distinctPerm p ∧ xvec ∧ Ψ"
  proof(induct n arbitrary: xvec yvec 🚫 Ψ')
    case(0 xvec yvec Ψ Ψ
    have Eq: "⟨x ♯ p›y ♯ p›x ♯ xvec'› "a <>\langle\^>F', \<Psi\
    from ‹
    moreover : pti)
      by(case_t
    ultimately show ?case using Eq
      by(simp add: frame.inject)
  next
    case(Suc n xvec yvec Ψ Ψ')
    from ‹Suc n = length xveby bl ba
    obtain x xvec' where "xvec = x#qed
      by(case_tac xvec) auto
    from \<open>\<langle>xvec, \<Psi>\<rangle> = \<langle>"
    obtain y yvec' where "\<langle>(x#xvec'), \<Psi>\<rangle> = \<langle>(y#yvec'), \<
      and "yvec = y#yvec'"
      by(se_tacuto
    hence EQ: "\<lparr>\<nu>x\<rparr>\<lparr>\<nu>*xvec'\<rparr>(FAssert have\xvec, \<Psi>\<rangleyvec, \<Psi>'\<ranglefact
      by simp
    from \<open>xvec             p. (set p) \<subseteq>et\>)and \<Psi>' = p \<Psi>"
    have "x \<noteq> y" and "xvec' \<sharp>* yvec'" and                       >: "x \<sharp> \<lparr>\*yvec'\<rparr>(FAssert Psi')"
      by uto
    from \<open>distinct xvec\<closevein supp (\<langle>yvec', \<Psi>'\<rangle>)"
      
    have IH: "\<And>xvec ec \<Psi> \<Psi><>\<langle>xvec, (\<Psi>::'a)\<rangle> = \<langle>yvec, (\<Psi>'::'a)\<rangle>; xvec \<sharp>* yvec; distinct xvec; distinct yvec; n = length xvec\<rbrakk> \<Longrightarrow> \<exists>p. (set p) \<subseteq> (set xvec) \<times> (set yvec) \<and> distinctPerm\>    \bulletxvec \<and> \<Psi>' = p \<bullet> \<Psi>"
      by fact
    from EQ \<openhence "\lparr>\>\<>\<lparr>\<>*xvec'\<(FAssert \<Psi>) = \<\<lparr>\<>*'\>( \Psi
      by(simp add: frame.inject alpha eqvts)
    with \<open>xvec' \<sharp>* yvec'\<close> \<open>distinct xvec'\<close> \<open>distinct yvec'\<close> \<open>length xvec' = n\<close> IH
    obtain p where S: "(set p) \<subseteq> (set xvec') \<times> (set yvec')" and "distinctPerm p" and "yvec' = p \<bullet> xvec'" and "[(x, y)] \<bullet> \<Psi>' = p \<bullet> \<Psi>"
      by metis
    from S have "set((x, y)#p) \<subseteq> set(x#xvec') \<times> set(y#yvec')" by auto
    moreover from \<open <> xvec\<close\en<sharp> yvec'< \<open>y \<sharp> xvec'\<close> \<open>y \<sharp> yvec'\<close> S have "x \<sharp> p" and "y \<sharp> p"
      (tp
      by(auto simp add: name_list_supp) (auto simp add: fresh_def) 

    with S \<open>distinctPerm p\<close> \<open>x \<noteq> y\<close> have "distinctPerm((x, y)#p)" by auto
    moreover from \<open>yvec' = p \<bulletxvecec\close \<open>x \<sharp> p\<close> \<open>y \<sharp> p\<closeopen \<sharp> xvec'\<close> \<open>y \<sharp> xvec'\<close> have "(y#yvec') = ((x, y#\>x#xvec')"
      by(simp add: freshChainSimps calc_atm)
    moreover from \<open>([(x, y)] \<bullet> \<Psi>' p \<bullet \<Psi>\<close>
   have "([(x, y)] \<bullet> [(x, y)] \<> \<Psi') = [(x, ] \>p \<bullet> \<Psi>"
      by(simp add:    case(Cons a A\\<subjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    hence "\<Psi>' =     from<>(#<subF) \<sharp>* C\<close> have "a \<sharp> C" and "<>\*mp
      by simp
    ultimately
      by blast
  qed
  ultimately show         from Eq have "<(a#A\<^sub>F), \<Psi>\<^sub>F\<rangle> = \<langle(a#A\<^sub>F'),Psi<^sub>F\<rangle>" by(simp add: frame.inject)


lemma frameEq[simp]:
  fixes A\<^sub>F :: "name list"
  and   \<Psi>  :: "'a::fs_name"
  and   \<Psi>'  :a

  shows "\<langle>A\<^sub>F, \<Psi>\<rangle> = \<langle>\<epsilon>, hence A\<^sub>F'" apply(simp add: fresh_def)
  and<><epsilon>, \<Psi>'\<rangle> = \<langle>A\<^sub>F, \<Psi>\rangle= (A\<^sub>F = [] \<and> \<Psi> = \<Psi>')"
proof -
  {
    assume "\<langle>A\<^sub>F, \<Psi>\<rangle> = \<from<open\<And>C. \<exists>A\<^sub>F \<Psi>\<^sub>F. =langleA\<^sub>\><^sub>F \<and> A\F \<sharp>* C<
    hence A: "\langle>A\<sub>F, \<Psi>\<rangle> = \<langle>[], \<Psi>'\<rangle>" by simp
    hence "length A\<^sub>F = length ([]::name list)"
      by(rule frameChainEqLength)
    with A have "A\<^sub>F = []" and "\<Psi> = \<Psi>'" by(auto simp add: frame.inject)
  }
  thus "\<langle>A\<^sub>F, \<Psi>\<rangle> = \<langle>\<epsilon>, \<Psi>'\<rangle> = (A\<^sub>F = [] \<and> \<Psi> = \<Psi>'and:e
  and  "\langle\<epsilon>, \<Psi>'\<rangle> = \<langle<, \<Psi\rangle= (A\<^sub>F = [] \<and> \<Psi> <')"
    by auto
qed

lemma distinctFrame:
  A<subF :: "name list"
  and   \<Psi>\<^sub>F :: "'a::fs_namename
  and   C  :: "'b::fs_name"
  
  assumes "A\<^sub>F \<sharp>* C"

  obtains A\<^sub>F' where  "\<langle>A\<^sub>F, \<Psi>\<^sub>F\<rangle> = \<(pdef
proof -
  assume "\<And>A\<^sub>F'. \<lbrakk>\<langle>A\<^sub>F, \<Psi>\<^sub>F\<rangle> = \<langle>A\<^sub>F', \<Psi>\<^sub>F\<rangle>; distinct A\<^sub>F'; A\<^sub>F' \<sharp>* C\<rbrakk> \<Longrightarrow> thesis"
  moreover from assms have "\<exists>A\<^sub>F'. \<langle>A\<^sub>F, \<Psi>\<^sub>fromSuc n = length A\<^sub>F\<close>
  proof(induct A\<^sub>
    case Nil
    thus ?case by simp
  next
    case(Cons a A\<^sub>F)
    entainn\>' where Eq: "\<langle>A\<^sub>F, \<Psi>\<^sub>F\rangle=<>\<^sub>F', \<Psi^F\<rangle>" and "distinct A\<^sub>F  A<F' \<sharp>* C" by force
       from \<open(a#A\<^sub>F) \<sharp>* C<close "a \<sharp> C" and "A\<^sub>F \<sharp>* C" by simp+

    proof(case_tac "a \<sharp> \<langle>A\<^sub>F', \<Psi>\<^sub>F\<rangle>")moreover from\<>ys \<sharp>* \<phi>\<close> have "([(x, y)]bullet ys>* ([(x, y)] \<bullet> \<phi
      assume "a \<sharp> \<langle>A\<^sub>F assms
      obtain b::name where "b \assumes<>\<^sub>F, \<Psi>\<^sub>F\<rangle> \<urnstilesubF \<Phi>"
      have "\<langle>(a#A\<^sub>F), \<Psi>\<^subandname
      proof -
        from Eq have "\<langle>(a#A\<^sub>F), \<Psi>\<^sub>F\<rangle> = \<langle>(a#A\<^sub>F'), \<Psi>\<^sub>F\<rangle>" 
        moreover from \<openb\sharp \<Psi>\<^sub>F\<close> have "\<dots> = \<lparr>\<b\<rparr>([(,]\> \<lparr>\<nu>*A\<^sub>F'\rparr>(FAssert \<Psi>\<^sub>F)begin
          by(force intro: alphaFrameRes simp add: frameResChainFresh)
        ultimately show ?thesis using F) \<hookrightarrow>\<^sub( <> G)"
          by(simp add: frameResChainFresh)
      qed
      moreover from \<open>distinct A\^ubF'\<close> \<open>b \<sharp> A\<^sub>F'\<close> have "distinct(b#A\<^sub>F')" by simp
      moreover from \<open>A\<^sub>F' \<sharp>* C\<close> \<open>b \<sharp> ( Eq_def introatImpClosed
      ultimately show ?case by blast
    next
      from Eq have "\<langle>(a#A\<^sub>F)<^>G= <ullet) \<hookrightarrowightarrow^F (p \<bullet> G))"
      moreover assume "\<not>(asharp \<langle>A\<^sub>F', \<Psi>\<^sub>F\<rangle>)"
      hence "a \<sharp> A\<^sub>F'" apply(simp add: fresh_def)
        by(induct A\<^sub>F') (auto simp add: supp_list_nil supp_list_cons supp_atm frame.supp abs_supp)
      with \<open>distinct A\<^sub>F'\<close> have "distinct(a#A\<^sub>F')" by simp
      moreover from \<open>A\<^sub>F' \<sharp>* Cshows\<^sub>F F"
      ultimately show ?case by blast
    qed
  qed
  ultimately show ?thesis using \<open>A\<^sub>F \<sharp>* C\<close>
    by blast
qed

lemmamejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  fixes F  :: "('ajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  and   C  :: "'b ::fs_name"

  obtains A\<^sub>F \<Psi>\<^sub>F where "F = \<langle>A\<^sub>F, \<Psi>\<^sub>F\<rangle>" and "distinct A\<^sub>F" and "A\<^sub>F \<sharp>* C"
proof - "nfinite(y Py\and> \not?Qy \<si> \and \<>(Qy <Psi>)"bysimp :set_diff_eq
  assume "\<And>A\<^sub>F \<Psi>\<^sub>F. \<lbrakk>F = \<langle>
  verve \<>A\<^sub>F \<Psi>\<^sub>F. F = \<>\<^sub>F, \<Psi>\<^sub\>\<and> A\<^sub>F <* C"
  proof(nominal_induct F avoiding: C rule: frame.strong_induct)
    (Assert <><subF
    have "FAssert \<Psi>\<^sub>F = \<langle>[],and amejava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    moreover andractFrame') <htarrowame
showcasebyforce
  next
    case(FRes a F)
    from \<open>\<And>C. \<exists>A\<^sub>F \<Psi>\<^sub>F. F = \<langle>A\<^sub>F, \<Psi>\<^sub>F\<rangle> \<and> A\<^sub>F \<sharp>* C\<close>
     A\<^sub>F\Psi>\^sub>F  where "F  <langle>A\<^sub>, \<Psi\<sub>F<rangle>  "A\^sub> \sharp>* "
      by blast
({
      by simp+
    thus ?case by blast
  qed
  ultimately show ?thesis
    by(auto, rule_tac distinctFrame) auto
qed

locale assertionAux = 
  fixes SCompose :: "'b::fs_name \<Rightarrow> 'b \<Rightarrow> 'b"   (infixr \<open>\<otimes>\<close> 80)
  and   SImp     :: "'b \<Rightarrow> 'c::fs_name \<Rightarrow> bool" (\<open>_ \<turnstile> _\<close> [70, 70] 70)
  andttom'                        \<bottom>\<close> 90) 
  and   SChanEq  :: "'a::fs_name \<Rightarrow> 'a \<Rightarrow> 'c"   (\<open>_ \<leftrightarrow> _\<close> [java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

 vt\>p:me.\ullet(\<Psi> \<turnstile> \<Phi>) = (p \<bullet> \<Psi>) \<turnstile> (p \<bullet> \<Phi>)"
  and     statEqvt'[eqvt]:  "\<And>p::name prm. p \<bullet> (\<Psi> \<showslbrakkxvec \<sharp>* F; xvec \sharp* G\<rbrakk> \<Longrightarrow> xvec \<sharp>*ergeFrameme
  and     statEqvt''[eqvt]: "\<And>p::name prm. p \<bullet> (M \<leftrightarrow> N) = (p \<bullet> M) \<leftrightarrow> (p \<bullet  andsharp I \<Longrightarrow> x \<sharp> extractFrame' 
  rmBottom]"Andp:name .(p\<> SBottom == SBottomjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80

begin

lemmaosed
  fixes \<Psi> :: 'b
  and   \<phi> :: 'c
  and   p :: "name prm"
  
  assumes "\<Psi> \<turnstile> \<phi>"

  shows "(p \<bullet> \<Psi>) \<turnstileby( meResChainFreshfresh_star_def
using assms statEqvt
by(simp add: perm_bool)

lemma compSupp:
  fixes \<Psi>  :: 'b
  and   \<Psi>' :: 'b

  showsupp(<> \<otimes> \<Psi>')::name set) \<subseteq> ((supp \<Psi>) \<union> (supp \<Psi>'))"
proof(auto simp add: eqvts supp_def)
  fix x::name
  let ?P = "\<lambda>y. ([(x,
  let ?Q = "\<lambda>yand <sharp*(<bottom>\<^sub>F)"
  assume "finite {y. ?Q y \<Psi>'}"and   : java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
very\<Psi" initeP"
  hence "infinite({y. ?P(y)} - {y. ?Q y \<Psi>})" by(rule Diff_infinite_finitehence "infinitey?
  ultimately have "infinite(({y. ?P(y)} - {y. ?Q y \<Psi>}) - {y. ?Q y \<Psi>'})" by(rule Diff_infinite_finite)
  hence "infinite({y. ?P(y) \<and> \<not>(?Q y \<Psi>   "A^F \<sharp>* xvec \<Longrightarrow> xvec \<sharp*\\<^sub>F"
  moreover have "{y. ?P(y) \<and> \<not>(?Q y \<Psi>) \<and> \<not> (?Q y \<Psi>')} = {}" by auto
  ultimately have "infinite {}" by(drule_tacte_congjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  thus False by simp
qed

lemma chanEqSupp:
  fixes M :: 'a
  and   N :: 'a

  shows "(supp(M \<leftrightarrow> N)::name set) \  and   \Psi><F:java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
proof(  add:  supp_def)
  fix x::name
  let ?P = "\<>.[(\bullet>  [(x, y)] \<bullet\> N"
  let ?Q = \<ambda ,<> M<> M"
  assume "finite {y. ?Q y N}"
  moreover assume "finite {y. ?Q y M}" and "infinite {y. ?P(y)}"
  hence "infinite({y. ?P(y)} - {y. ?Q y M})" by(rule Diff_infinite_finite)
  ultimately have "infinite(({y. ?P(y)} - {y. ?Q y M}) - {y. ?Q y N})" obtainwhere\sharp phi>" and "y \<sharp> F" and "x \<noteq> y"
  hence "infinite({y. ?P(y) \<and> \<not>(?Q y M) \<and> \<not> (?Q y N)})" by(simp add: set_diff_eq)
  moreover have "{y. ?P(y) \<and> \<not>(?Q y M) \<and> \<not> (?Q y N)} = {}" by auto
  ultimately have "infinite {}" by(drule_tac Infinite_cong) auto
  thus False by simp
qed

lemma freshComp[intro]:
  fixes x  :: name
  and   \<Psi>  :: 'b
  and   \<Psi>' :: 'b

  assumes "x \<sharp> \<Psi>"
  and     "x \<sharp> \<Psi>'

  shows "x \<sharp> \<Psi> \<otimes> \<Psi>'"
using assms compSupp
by(auto simp add: fresh_def)

lemma freshCompChain[intro]:
  fixes xvec  :: "name list"
  and   Xs    :: "name  \<nu>x\<rparrhookrightarrow\<^sub> \<nu>x\<arrG
  and   \<Psi>     :: 'b
  and   \<Psi>'    ::b

  shows "\<lbrakk>xvec \<sharp>* \<Psi>; xvec \<sharp>* \<Psi>'\<rbrakk> \<Longrightarrow> xvec \<sharp>* (\<Psi> \<otimes> \<Psi>')"
  and   "\<lbrakk>Xs \<sharp>* \<Psi>; Xs \<sharp>* \<Psi>'\<rbrakk> \<Longrightarrow> Xs \<sharp>* (\<Psi> \<otimes> \<Psi>byuleFrame
by(auto simp add: fresh_star_def)

lemma freshChanEq[intro]:
  fixes x :: name
  and   M:a
  and   N :: 'a

  assumes "x \<sharp> M"
  and     "x \<sharp> N"

  shows "x \<sharp> M \<leftrightarrow> N"
using assms chanEqSupp
by(auto simp add: assume" <> y"

lemma freshChanEqChain[intro]:
  fixes xvec :: "name list"
  and   Xs   :: "name set"
  and   M    :: 'a
            : java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

  shows "\<lbrakk>xvec \<sharp>* M; xvec \<sharp>* N\<rbrakk> \<Longrightarrow> xvec \<sharp>* (M \<leftrightarrow> N)"
  and   "\<lbrakk>Xs \<sharp>* M; Xs \<sharp>* N\<rbrakk> \<Longrightarrow> Xs \<sharp>* (M \<leftrightarrow> N)"
by(auto simp add: fresh_star_def)

lemma suppBottom[simp]:
  shows      "Xs   \<harp*\bottom)
by(auto simp add: supp_def permBottom)

lemma freshBottom[simp]:
  fixes x :: name
  
  shows    ultimately have A:\<lparr><nu>x\<rparr>(\<lparr>\<nu>y\<rparr>F)= <>\x'\<rparr>(\lparr\<nu>y'\<rparr>(\<rrnu>*A\<^sub><(FAssert([(x, x')] <>[andM a
by(simp add: fresh_def)

lemma freshBottoChain[simp]:
  fixes xvec :: "name list"
  and   Xs   :: "name set"

  shows "xvec \<sharp>* (\<bottom>)"
  and   "Xs   \<sharp>* (\<bottom>)"
by(auto simp add: fresh_star_def      by(rule_tac alphaFrameRes) (simp addabs_freshresh_left

lemma chanEqClosed:
  fixes \<Psi> :: 'b
  and   M :: 'a
  and   N :: 'a
     :"namemerm"
 
  assumes "\<    from \<openx' \<sharp> <phi>close \<open>y' \<sharp> \<phi>\<close> \<open>A\<^sub>F \<sharp>*

  shows "(p \<bullet> \<Psi>) \<turnstile> (p \<bullet> M) \<leftrightarrow> (p \<bullet> N)"
proof -
  from \<open>\<Psi> \<turnstile> M \<leftrightarrow> N\<close> have "(p \<bullet> \<Psi>) \<turnstile> p \<bullet> (M \<leftrightarrow> N)"
    by(rule statClosed)
  thus ?thesis by(simp add: eqvts)
qed

definition
  AssertionStatImp :: "'b \<Rightarrow> 'b \<Rightarrow> bool" (infix \<open>\<hookrightarrow>  shows"nsertAssertionlparr<nu>*xvec\<rparr>P)) \<Psi> \<hookrightarrow>\<^sub<*xvec\<>extractFrame)"
  where "(\<Psi> \<hookrightarrow> \<Psi>

definition
  AssertionStatEq :: "'b \<Rightarrow> 'b \<Rightarrowboolnfix \<open>\<simeq>\<close0
  where "(\<Psi> \<simeq> \<Psi>') \<equiv> \<Psi> \<hookrightarrow> \<Psi>' \<and> \<Psi>' \<hookrightarrow> \<Psi>"

lemma statImpEnt:
  fixes \<Psi>  :: 'b
  and   \<Psi>' :: 'b
  and   \<Phi>  :: 'c

  assumes "\<Psi> \<hookrightarrow> \<Psi>'"
  and     "\<Psi> \<turnstile> \<Phi>"

  shows "\<Psi>' \<turnstile> \<Phi>java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
usingassmss
by(simp add: AssertionStatImp_def)

lemma statEqEntjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  fixes \<Psi>  :: 'b
  and   \<Psi>' :'
  and   \<Phi>  :: 'c

  assumes "\<Psi> \<simeq> \<Psi>'"
  and     "\<Psi> \<turnstile> \<Phi>"

  shows "\<Psi>' \<turnstile> \<Phi>"
using assms
by(auto simp add: AssertionStatEq_def intro: statImpEnt)

lemma AssertionStatImpClosed:
  fixes \<Psi>  :'java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  and   \<Psi>' :: 'b
  and   p  :: "name prm"

  assumes "\<Psi> \<hookrightarrow> \<Psi>'"

  shows "(p \<bullet> \<Psi>) \      by(simp addeqvtshaFrameRes)
proof(auto simpadd: AssertionStatImp_def
  fix \<phi>
  assume "(p \<bullet> \<Psi>) \<turnstilewith<open>\<Psi>\<close> \<open>y \sharp \<Psi>\<close> have< = \<otimes, ] \<Psi>\<^subbysimp ts
  hence "\<Psi> \<turnstile> rev p \<bullet> \<phi>" by(drule_tac p="rev p" in statClosed) auto
  with \<open>\<Psi> \<hookrightarrow> \<Psi>'\<close> have "\<Psi>' \<turnstile> rev p \<bullet> \<phi>" by(simp add:
  thus "(p \<bullet> \<Psi>')roof -
qed

lemma AssertionStatEqClosed:
  fixes \<Psi>  :: 'b
  and   \<Psi>' :: 'b
  and   p  :: "name prm"

  assumes" \<simeq> \<Psi>'"

  shows "(p \<bullet> \<Psi)\> (p \<bullet> \<Psi>')"
using assms
by(auto simp add: AssertionStatEq_def intro: AssertionStatImpClosed)

lemma AssertionStatImpEqvt[eqvt]:
  fixes \<Psi>  :: 'b
  and   \<Psi>' :: 'b
  and   p::namerm

  shows "(p \bullet(\<Psi> \<hookrightarrow> \<Psi>')) = ((p \<bullet> \<Psi (p \<bullet> \<Psi>))
by(simp add: AssertionStatImp_def eqvts)

lemma AssertionStatEqEqvt[eqvt]:
  fixes \<Psi>  :: 'b
  and   \<Psi>' :: 'b
  and   p  :: "name prm"

  shows "(p \<bullet> (\<Psi> \<simeq> \<Psi>' <pen([(x, y)] \<bullet> \<Psi>\<^sub>F\<^sub>G) = \<Psi>\<^sub>F \<otimes> \<Psi>>\<close> have "(( bullet[(x, y)] \<bullet> \<Psi>\<^sub>F\<sub [ < (\<Psi>\<^sub>F  \<Psi>\<^sub>
by(simp add: AssertionStatEq_def eqvts)

lemma AssertionStatImpRefl[simp]:
  fixes \<Psi> :: 'b

  shows "\<Psi> \<hookrightarrow> \<Psi>"
by(simp add: AssertionStatImp_def)

lemma AssertionStatEqRefl[simp]:
    with \<>\<Psi <hookrightarrow>\Psi'\close have "Psi' \<turnstile  p\> phi"by(impadd:AssertionStatImp_def)

  shows "\<Psi> \<simeq> \<Psi>"
by(simp add: AssertionStatEq_def)

lemma AssertionStatEqSym:
  fixes \<Psi>   :: 'b
  and   \<Psi>'  :: 'b

  assumes "\<Psi> \<simeq> \<Psi>'"

  shows "\<Psi>' \<simeq> \<Psi>"
using assms
by(auto simp add: AssertionStatEq_def)

lemma AssertionStatImpTrans:
  fixes \<Psi>es \>: b
  and   \<Psi>'  :: 'b
  and   \<Psi>'' :: 'b

  assumes "\<Psi> \<hookrightarrow> \<Psi>'"
  and     "\<Psi>' \<hookrightarrow> \<Psi>''"

  shows "\<Psi> \<hookrightarrow> \<Psi>''"
using assms
by(simp add: AssertionStatImp_def)

lemma AssertionStatEqTrans:
  fixes \<Psi>   :: 'b
  and   \<Psi>'  :: 'b
  and   \<Psi>'' :: 'b

assumesPsi <simeq>\Psi"
  and     "\<Psi>' \<simeq> \<Psi>''"

  shows "\<Psi> \<simeq> \<Psi>''"
using assms
by(auto simp add: AssertionStatEq_def intro: AssertionStatImpTrans)

definition 
  FrameImp :: "'b::fs_name frame \<Rightarrow> 'c \<Rightarrow> bool"   (infixl \<open>\<turnstile>\<^sub>F\<close> 70)
  where "(F \<turnstile>\<^sub>F \<Phi>) = (\<exists>A\<^sub>F \<Psi>\<^sub>F. F = \<langle>A\<^sub>F, \ obtain ^G \<Psi>\<^sub>G where G >\<^sub>G, \<Psi>\<>G\rangleandAG \<sharp>* \<Psi>\>F A^G \<sharp>* A\<^sub>

lemma frameImpI:
  fixes F  :: "'b frame"
  
  and   A\<^sub>F :: "name list"
  and   \<Psi>\<^sub>F :: 'b

  assumes "F = \<langle>A\<^sub>F, \<Psi>\<^sub>F\<rangle>"
  and     "A\<^sub>F \<sharp>* \<phi>"
  and     "\<Psi>\<^sub>F \<turnstile> \<phi>"

  shows "F \<turnstile>\<^sub>F \<phi>"
using assms: (a, )java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
by(force simp add: FrameImp_def)

lemma frameImpAlphaEnt:
  fixes A\<^sub>F  :: "name list"
  and   \<Psi>\<^sub>F  :: 'b
  and   A\<^sub>F' :: "name list"
  and   \<Psi>\<^sub>F' :: 'b
  and   \<phi>   :: 'c

  assumes "\<langle>A\<^sub>F, \<Psi>\<^sub>F\<rangle> = \<langle>A\<^sub>F', \<Psi>\<^sub>F'\<rangle>" 
  and     "A\<^subF \<harp>*<phi>"
  and     "A\<^sub>F' \<sharp>* \<phi>"
  and     "\<Psi>\<^sub>F' \<turnstile> \<phi>"

  shows "\<Psi>\<bytac=(A^ubP \<Psi>\<^sub>P)" in freshFrame) auto
proof -
  from \<open>\<langle>A\<^sub>F, \<Psi>\<^sub>F\<rangle> = \<langle>A\<^sub>F', \<Psi>\<^sub>F'\<rangle>\<close>
  obtain n where "n = length A\<^sub>F" by blast
  moreover from \<open>\<langle>A\<^sub>F, \<Psi>\<^sub>F\<rangle> = \<langle>A\<^sub>F', \<Psi>\<^sub>F'\<rangle>\<close>
  have "length A\<^sub>F = length A\<^sub>F'"
    by(rule frameChainEqLength)
imately show ?thesis using assms
  proof(induct n arbitrary: A\<^sub>F A\<^sub>F' \<Psi>\<^sub>F' rule:natnduct)
    case(zero A\<^sub>F A\<^sub>F' \<Psi>\<^sub>F')
    thus ?case by(auto simp add: frame.inject)
  next
    case(Suc n A\<^sub>F A\<^sub>F' \<Psi>\^F')
java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 48
    obtain x xs where "A\<^sub>F = x#xs" and "n = length xs"
      by(case_tac A\<^sub>F) auto
    from \<open>\<langle>A\<^sub>F, \<Psi>\<^sub>F\<rangle> = \<langle>A\<^sub>F', \<Psi>\<^sub>F'\<rangle>\<close> \<open>A\<^sub>F = x # xs\<close>
    obtain y ys where "\<langle>(x#xs), \<Psi>\<^sub>F\<rangle> = \<langle>(y#ys), \<Psi>\<^sub>F'\<rangle>" and "A\<^sub>F' = y#ys"
      by(case_tac A\<^sub>F') auto
    hence EQ: "\<lparr>\<nu>x\<rparr>\<lparr>\<nu>*xs\<rparr>(FAssert \<Psi>\<^sub>F) = \<lparr>\<nu>y\<rparr>\<lparr>\<nu>*ys\<rparr>(FAssert \<Psi>\<^sub>F')"
      by simp
    from \<open>A\<^sub>F = x # xs\<close> \<open>A\<^sub>F' = y # ys\<close> \<open>length A\<^sub>F = length A\<^sub>F'\<close> \<open>A\<^sub>F \<sharp>* \<phi>\<close> \<open>A\<^sub>F' \<sharp>* \<phi>\<close>
    have "length xs = length ys" and "xs \<sharp>* \<phi>" and "ys \<sharp>* \<phi>" and "x \<sharp> \<phi>" and "y \<sharp> \<phi>" 
      by auto
    
    have IH: "\<And>xs ys \<Psi>\<^sub>F'. \<lbrakk>n = length xs; length xs = length ys; \<langle>xs, \<Psi>\<^sub>F\<rangle> = \<langle>ys, (\<Psi>\<^sub>F'::'b)\<rangle>; xs \<sharp>* \<phi>; ys \<sharp>* \<phi>; \<Psi>\<^sub>F' \<turnstile> \<phi>\<rbrakk> \<Longrightarrow> \<Psi>\<^sub>F       EQ"\<langle>xs, \<Psi>\<^sub>F\<rangle> = \<langle>ys, \<Psi>\<^sub>F'\<rangle>" by(simp add: alpha frame.inject)
      by fact
    show ?case
    proof(case_tac "x = y")
      assume "x = y"
      with EQ have "\<langle>xs, \<Psi>\<^sub>F\<rangle> = \<langle>ys, \<Psi>\<^sub>F'\<rangle>" by(simp add: alpha frame.inject)
      with IH \<open>n = length xs\<close> \<open>length xs = length ys\<close> \<open>xs \<sharp>* \<phi>\<close>  \<open>ys \<sharp>* \<phi>\<close> \<open>\<Psi>\<^sub>F' \<turnstile> \<phi>\<closeassumexnoteq 
      show ?case by blast
    next
      assume "x \<noteq> y"
      with EQ have "\<langle>xs, \<Psi>\<^sub>F\<rangle> = [(x, y)] \<bullet> \<langle>ys, \<Psi>\<^sub>F'\<rangle>" by(simp add: alpha frame.inject)
      hence "\<langle>xs, \<Psi>\<^sub>F\<rangle> = \<langle>([(x, y)] \<bullet> ys), ([(x, y)] \<bullet> \<Psi>\<^sub>F')\<rangle>" by(simp add: eqvts)
      moreover from \<open>length xs = length ys\<close> have "length xs = length([(x, y)] \<bullet> ys)"
        by auto
      moreover from \<open>ys \<sharp>* \<phi>\<close> have "([(x, y)] \<bullet> ys) \<sharp>* ([(x, y)] \<bullet> \<phi>)"
        by(simp add: fresh_star_bij)
      with \<open>x \<sharp> \<phi>\<close> \<open>y \<sharp> \<phi>\<close> have "([(x, y)] \<bullet> ys) \<sharp>* \<phi>"
        by simp
      moreover with \<open>\<Psi>\<^sub>F' \<turnstile> \<phi>\<close> have "([(x, y)] \<bullet> \<Psi>\<^sub>F') \<turnstile> ([(x, y)] \<bullet> \<phi>)"
        by(simp add: statClosed)
      with \<open>x \<sharp> \<phi>\<close> \<open>y \<sharp> \<phi>\<close> have "([(x, y)] \<bullet> \<Psi>\<^sub>F') \<turnstile> \<phi>"
        by simp
      ultimately show ?case using IH \<open>n = length xs\<close> \<open>xs \<sharp>* \<phi>\<close>
        by blast
    qed
  qed
qed

lemma frameImpEAux:
fixes: "' frame"
  and   \<Phi>  :: 'c

  assumes  "F \<turnstile>\<^sub>F \<Phi>"
  and      "F = \<langle>A\<^sub>F, \<Psi>\<^sub>F\<rangle>"
  and      "A\<^sub>F \<sharp>* \<Phi>"
  
  shows "\<Psi>\<^sub>F \<turnstile> \<Phi>"
using assms
by(auto simp add: FrameImp_def dest: frameImpAlphaEnt)

lemma frameImpE:
  fixes F  :: "'b frame"
  and   \<Phi>  :: 'c

  assumes  "\<langle>A\<^sub>F, \<Psi>\<^sub>F\<rangle> \<turnstile>\<^sub>F \<Phi>"
  and      "A\<^sub>F \<sharp>* \<Phi>"
  
  shows "\<Psi>\<^sub>F \<turnstile> \<Phi>"
using assms
by(auto elim: frameImpEAux)

lemma frameImpClosed:
  fixes F :: "'b frame"
  and   \<Phi> :: 'c
  and   p :: "name prm"

   "<><^subF <>

  shows "(p \<bullet> F) \<turnstile>\<^sub>F (p \<bullet> \<Phi>)"
using assms
by(force simp add: FrameImp_def eqvts pt_fresh_star_bij[OF pt_name_inst, OF at_name_inst]
         intro: statClosed)

lemma frameImpEqvt[eqvt]:
  fixes F :: "'b frame"
  and   \<Phi> :: 'c
  and   p :: "name prm"

et(\turnstile><subF\Phi)  ( \bullet>F <>\<subF(p\ \)
proof -
  have "F \<turnstile>\<^sub>F \<Phi> \<Longrightarrow> (p \<bullet> F) \<turnstile>\<^sub>F (p \<bullet> \<Phi>)"
    by(rule frameImpClosed)
  moreover have "(p \<bullet> F) \<turnstile>\<^sub>F (p \<bullet> \<Phi>) \<Longrightarrow> F \<turnstile>\<^sub>F \<Phi>"
    by(drule_tac p = "rev p" in frameImpClosed) simp
  ultimately show ?thesis
    by(auto simp add: perm_bool)
qed

lemma frameImpEmpty[simp]:
  fixes \<Psi> :: 'b
 c

  shows "\<langle>\<epsilon>, \<Psi>\<rangle> \<turnstile>\<^sub>F \<phi> = \<Psi> \<turnstile> \<phi>" 
by(auto simp add: FrameImp_def)

definition
  FrameStatImp :: "'b frame \<Rightarrow> 'b frame\<Rightarrow> bool" (infix \<open>\<hookrightarrow>\<^sub>F\<close> 70)
  where "(F \<hookrightarrow>\<^sub>F G) \<equiv> (\<forall>\<phi>. F \<turnstile>\<^sub>F \<phi> \<longrightarrow> G \<turnstile>\<^sub>F \<phi>)"

definition
  FrameStatEq :: "'b frame \<Rightarrow> 'b frame\<Rightarrow> bool" (infix \<open>\<simeq>\<^sub>F\<close> 70)
  where "(F \<simeq>\<^sub>F G) \<equiv> F \<hookrightarrow>\<^sub>F G \<and> G \<hookrightarrow>\<^sub>F F"

lemma FrameStatImpClosed:
  fixes F :: "'b frame"
  and   G :: "'b frame"
  and   p :: "name prm"

  assumes "F \<hookrightarrow>\<^sub>F G"

  shows "(p \<bullet> F) \<hookrightarrow>\<^sub>F (p \<bullet> G)"
proof(auto simp add: FrameStatImp_def)
  fix \<phi>
  assume "(p \<bullet> F) \<turnstile>\<^sub>F \<phi>"
  hence "F \<turnstile>\<^sub>F rev p \<bullet> \<phi>" by(drule_tac p="rev p" in frameImpClosed) auto
  with \<open>F \<hookrightarrow>\<^sub>F G\<close> have "G \<turnstile>\<^sub>F rev p \<bullet> \<phi>" by(simp add: FrameStatImp_def)
  thus "(p \<bullet> G) \<turnstile>\<^sub>F \<phi>" by(drule_tac p=p in frameImpClosed) auto
qed

lemma FrameStatEqClosed:
  fixes F :: "'b frame"
  and   G :: "'b frame"
  and   p :: "name prm"

  assumes "F \<simeq>\<^sub>F G"

  shows "(p \<bullet> F) \<simeq>\<^sub>F (p \<bullet> G)"
using assms
by(auto simp add: FrameStatEq_def intro: FrameStatImpClosed)

lemma FrameStatImpEqvt[eqvt]:
  fixes F :: "'b frame"
  and   G :: "'b frame"
  and   p :: "name prm"

  shows "(p \<bullet> (F \<hookrightarrow>\<^sub>F G)) = ((p \<bullet> F) \<hookrightarrow>\<^sub>F (p \<bullet> G))"
by(simp add: FrameStatImp_def eqvts)

lemma FrameStatEqEqvt[eqvt]:
  fixes F :: "'b frame"
  and   G :: "'b frame"
  and   p :: "name prm"

  shows "(p \<bullet> (F \<simeq>\<^sub>F G)) = ((p \<bullet> F) \<simeq>\<^sub>F (p \<bullet> G))"
by(simp add: FrameStatEq_def eqvts)

lemma FrameStatImpRefl[simp]:
   F: ' frame"

  shows "F \<hookrightarrow>\<^sub>F F"
by(simp add: FrameStatImp_def)

lemma FrameStatEqRefl[simp]:
  fixes F :: "'b frame"

  shows "F \<simeq>\<^sub>F F"
by(simp add: FrameStatEq_def)

lemma FrameStatEqSym:
  fixes F  :: "'b frame"
  and   G  :: "'b frame"

  assumes "F \<simeq>\<^sub>F G"

  shows "G \<simeq>\<^sub>F F"
using assms
by(auto simp add: FrameStatEq_def)

lemma FrameStatImpTrans:
  fixes F :: "'b frame"
  and   G :: "'b frame" 
  and   H :: "'b frame"

  assumes "F \<hookrightarrow>\<^sub>F G"
  and     "G \<hookrightarrow>\<^sub>F H"

  shows "F \<hookrightarrow>\<^sub>F H"
using assms
by(simp add: FrameStatImp_def)

lemma FrameStatEqTrans:
  fixes F :: "'b frame"
  and   G :: "'b frame"
  and   H :: "'b frame"

  assumes "F \<simeq>\<^sub>F G"
  and     "G \<simeq>\<^sub>F H"

  shows "F \<simeq>\<^sub>F H"
using assms
by(auto simp add: FrameStatEq_def intro: FrameStatImpTrans)

lemma fsCompose[simp]: "finite((supp SCompose)::name set)"
by(simp add: supp_def perm_fun_def eqvts)

nominal_primrec 
   insertAssertion :: "'b frame \<Rightarrow> 'b \<Rightarrow> 'b frame"
where
  "insertAssertion (FAssert \<Psi>) \<Psi>' = FAssert (\<Psi>' \<otimes> \<Psi>)"
| "x \<sharp> \<Psi>' \<Longrightarrow> insertAssertion (\<lparr>\<nu>x\<rparr>F) \<Psi>' = \<lparr>\<nu>x\<rparr>(insertAssertion F \<Psi>')"
apply(finite_guess add: fsCompose)+
apply(rule TrueI)+
apply(simp add: abs_fresh)
apply(rule supports_fresh[of "supp \<Psi>'"])
apply(force simp add: perm_fun_def eqvts fresh_def[symmetric] supports_def)
apply(simp add: fs_name1)
apply(simp add: fresh_def[symmetric]) shows "F \simeq\sub>F Hjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
apply(fresh_guess)+
done

lemma insertAssertionEqvt[eqvt]:
  fixes p :: "name prm"
  and   F :: "'b frame"
  and   \<Psi> :: 'b

  shows "p \<bullet> (insertAssertion F \<Psi>) = insertAssertion (p \<bullet> F) (p \<bullet> \<Psi>)"
by(nominal_induct F avoiding: p \<Psi> rule: frame.strong_induct)
  (auto simp add: at_prm_fresh[OF at_name_inst] 
                  pt_fresh_perm_app[OF pt_name_inst, OF at_name_inst] eqvts)


nominal_primrec 
   mergeFrame :: "'b frame \<Rightarrow> 'b frame \<Rightarrow> 'b frame"
where
  "mergeFrame (FAssert \<Psi>) G = insertAssertion G \<Psi>"
| "x \<sharp> G \<Longrightarrow> mergeFrame (\<lparr>\<nu>x\<rparr>F) G = \<lparr>\<nu>x\<rparr>(mergeFrame F G)"
apply(finite_guess add: fsCompose)+
apply(rule TrueI)+
apply(simp add: abs_fresh)
apply(simp add: fs_name1)
apply(rule supports_fresh[of "supp G"])
apply(force simp add: perm_fun_def eqvts fresh_def[symmetric] supports_def)
apply(simp add: fs_name1)
apply(simp
apply(fresh_guess)+
done

notation mergeFrame (infixr \<open>\<otimes>\<^sub>F\<close> 80)

abbreviation
  frameBottomJudge (\<open>\<bottom>\<^sub>F\<close>) where "\<bottom>\<^sub>F \<equiv> (FAssert SBottom)"

lemma mergeFrameEqvt[eqvt]:
  fixes p :: "name prm"
  and   F :: "'b frame"
  and   G :: "'b frame"

  shows "p \<bullet> (mergeFrame F G) = mergeFrame (p \<bullet> F) (p \<bullet> G)"
by(nominal_induct F avoiding: p G rule: frame.strong_induct)
  (auto simp add: at_prm_fresh[OF at_name_inst] 
                  pt_fresh_perm_app[OF pt_name_inst, OF at_name_inst] eqvts)

nominal_primrec
    extractFrame   :: "('a, 'b, 'c) psi \<Rightarrow> 'b frame"
and extractFrame'  :: "('a, 'b, 'c) input \<Rightarrow> 'b frame"
and extractFrame'' :: "('a, 'b, 'c) psiCase \<Rightarrow> 'b frame"

where
  "extractFrame (\<zero>) =  \<langle>\<epsilon>, \<bottom>java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
| "extractFrame (M\<lparr>I) = \<langle>\<epsilon>, \<bottom>\<rangle>"
| "extractFrame (M\<langle>N\<rangle>.P) = \<langle>\<epsilon>, \<bottom>\<rangle>"
| "extractFrame (Case C) = \<langle>\<epsilon>, \<bottom>\<rangle>"
| "extractFrame (P \<parallel> Q) = (extractFrame P) \<otimes>\<^sub>F (extractFrame Q)"
| "extractFrame ((\<lbrace>\<Psi>\<rbrace>::('a, 'b, 'c) psi))  fixes p :: nameprm

| "extractFrame (\<lparr>\<nu>x\<rparr>P) = \<lparr>\<nu>x\<rparr>(extractFrame P)"
| "extractFrame (!P) = \<langle>\<epsilon>, \<bottom>\<rangle>" 

| "extractFrame' ((Trm M P)::('a::fs_name, 'b::fs_name, 'c::fs_name) input) = \<langle>\<epsilon>, \<bottom>\<rangle>" 
| "extractFrame' (Bind x I) = \<langle>\<epsilon>, \<bottom>\<rangle>" 

| "extractFrame'' (\<bottom>\<^sub>c::('a::fs_name, 'b::fs_name, 'c::fs_name) psiCase) = \<langle>\<epsilon>, \<bottom>\<rangle>" 
| "extractFrame'' (\<box>\<Phi> \<Rightarrow> P C) = \<langle>\<epsilon>, \<bottom>\<rangle>" 
apply(finite_guess add: fsCompose)+
apply(rule TrueI)+
apply(simp add: abs_fresh)+
apply(fresh_guess add: freshBottom)+
apply(rule supports_fresh[of "{}"])
apply(force simp add: perm_fun_def eqvts fresh_def[symmetric] supports_def)
apply(simp add: fs_name1)
apply(simp add: fresh_def[symmetric])
apply(fresh_guess add: freshBottom)+
apply(rule supports_fresh[of "{}"])
apply(force simp add: perm_fun_def eqvts fresh_def[symmetric] supports_def)
apply(simp add: fs_name1)
applysimpadd:fresh_def[symmetric)
apply(fresh_guess add: freshBottom)+
done

lemmas extractFrameSimps = extractFrame_extractFrame'_extractFrame''.simps

lemma extractFrameEqvt[eqvt]:
  fixes p :: "name prm"
  and   P :: "('a, 'b, 'c) psi"
  and   I :: "('a, 'b, 'c) input"
  and   C :: "('a, 'b, 'c) psiCase"

  shows "p \<bullet> (extractFrame P) = extractFrame (p \<bullet> P)"
  and   "p \<bullet> (extractFrame' I) =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  and   "p \<bullet> (extractFrame'' C) = extractFrame'' (p \<bullet> C)"
by(nominal_induct P and I and C avoiding: p rule: psi_input_psiCase.strong_inducts)
   (auto simp add: at_prm_fresh[OF at_name_inst] eqvts permBottom
                  pt_fresh_perm_app[OF pt_name_inst, OF at_name_inst])

lemma insertAssertionFresh[intro]:
  fixes F :: "'b frame"
  and   \<Psi> :: 'b
  and   x :: name

  assumes "x \<sharp> F"
  and     "x \<sharp> \<Psi>"

  shows "x \<sharp> (insertAssertion F \<Psi>)"
using assms
by(apply( : fresh_defsymmetric])
  (auto simp add: abs_fresh)

lemma insertAssertionFreshChain[intro]:
  fixes F    :: "'b frame"
  and   \<Psi>    :: 'b
  and   xvec :: "name list"
  and   Xs   :: "name set"

  shows "\<lbrakk>xvec \<sharp>* F; xvec \<sharp>* \<Psi>\<rbrakk> \<Longrightarrow> xvec \<sharp>* (insertAssertion F \<Psi>)"
  and   "\<lbrakk>Xs \<sharp>* F; Xs \<sharp>* \<Psi>\<rbrakk> \<Longrightarrow> Xs \<sharp>* (insertAssertion F \<Psi>)"
by(auto simp add: fresh_star_def)

lemma mergeFrameFresh[intro]:
  fixes F :: "'b frame"
  and   G :: "'b frame"
  and   x :: name

  shows "\<lbrakk>x \<sharp> F; x \<sharp> G\<rbrakk> \<Longrightarrow> x \<sharp> (mergeFrame F G)"
by(nominal_induct F avoiding: x G rule: frame.strong_induct)
  (auto simp add: abs_fresh)

lemma mergeFrameFreshChain[intro]:
  fixes F    :: "'b frame"
  and   G    :: "'b frame"
  and   xvec :: "name list"
  and   Xs   :: "name set"

  shows "\<lbrakk>xvec \<sharp>* F; xvec \<sharp>* G\<rbrakk> \<Longrightarrow> xvec \<sharp>* (mergeFrame F G)"
  and   "\<lbrakk>Xs \<sharp>* F; Xs \<sharp>* G\<rbrakk> \<Longrightarrow> Xs \<sharp>* (mergeFrame F G)"
by(auto simp add: fresh_star_def)

lemma extractFrameFresh:
  fixes P :: "('a, 'b, 'c) psi"
  and   I :: "('a, 'b, 'c) input"
  and   C :: "('a, 'b, 'c) psiCase"
  and   x :: name

  shows "x \<sharp> P \<Longrightarrow> x \<sharp> extractFrame P"
  and   "x \<sharp> I \<Longrightarrow> x \<sharp> extractFrame' I"
  and   "x \<sharp> C \<Longrightarrow> x \<sharp> extractFrame'' C"
by(nominal_induct P and I and C avoiding: x rule: psi_input_psiCase.strong_inducts)
  (auto simp add: abs_fresh)

lemma extractFrameFreshChain:
  fixes P    :: "('a, 'b, 'c) psi"
  and   I    :: "('a, 'b, 'c) input"
  and   C    :: "('a, 'b, 'c) psiCase"
  and   xvec :: "name list"
  and   Xs   :: "name set"

  shows "xvec \<sharp>* P \<Longrightarrow> xvec \<sharp>* extractFrame P"
  and   "xvec \<sharp>* I \<Longrightarrow> xvec \<sharp>* extractFrame' I"
  and   "xvec \<sharp>* C \<Longrightarrow> xvec \<sharp>* extractFrame'' C"
  and   "Xs \<sharp>* P \<Longrightarrow> Xs \<sharp>* extractFrame P"
  and   "Xs \<sharp>* I \<Longrightarrow> Xs \<sharp>* extractFrame' I"
  and   "Xs \<sharp>* C \<Longrightarrow> Xs \<sharp>* extractFrame'' C"
by(auto simp add: fresh_star_def intro: extractFrameFresh)


lemma guardedFrameSupp[simp]:
  fixes P :: "('a, 'b, 'c) psi"
  and   I :: "('a, 'b, 'c) input"
  and   C :: "('a, 'b, 'c) psiCase"
  and   x :: name 

  shows "guarded P \<Longrightarrow> x \<sharp> (extractFrame P)"
  and   "guarded' I \<Longrightarrow> x \<sharp> (extractFrame' I)"
  and   "guarded'' C \<Longrightarrow> x \<sharp> (extractFrame'' C)"
by(nominal_induct P and I and C arbitrary: x rule: psi_input_psiCase.strong_inducts)
  (auto simp add: frameResChainFresh abs_fresh)

lemma frameResChainFresh': 
  fixes xvec :: "name list"
  and   yvec :: "name list"
  and   F    :: "'b frame"

  shows "(xvec \<sharp>* (\<lparr>\<nu>*yvec\<rparr>F)) = (\<forall>x \<in> set xvec. x \<in> set yvec \<or> x \<sharp> F)"
by(simp add: frameResChainFresh fresh_star_def)

lemma frameChainFresh[simp]:
  fixes xvec :: "name list"
  and   \<Psi>    :: 'b
  Xs: name "

  shows "xvec \<sharp>* (FAssert \<Psi>) = xvec \<sharp>* \<Psi>"
  and   "Xs \<sharp>* (FAssert \<Psi>) = Xs \<sharp>* \<Psi>"
by(simp add: fresh_star_def)+

lemma frameResChainFresh''[simp]:
  fixes xvec :: "name list"
  and   yvec :: "name list"
  and   F    :: "'b frame"
  
  assumes "xvec \<sharp>* yvec"

  shows "xvec \<sharp>* (\<lparr>\<nu>*yvec\<rparr>F) = xvec \<sharp>* F"

using assms
by(simp_all add: frameResChainFresh')
  (auto simp add: fresh_star_def fresh_def name_list_supp)

lemma frameResChainFresh'''[simp]:
  fixes x    :: name
  and   xvec :: "name list"
  and   F    :: "'b frame"
  
  assumes "x \<sharp> xvec"

  shows "x \<sharp> (\<lparr>\<nu>*xvec\<rparr>F) = x \<sharp> F"
using assms
by(induct xvec) (auto simp add: abs_fresh)

lemma FFreshBottom[simp]:
  fixes xvec :: "name list"
  and   Xs   :: "name set"

  shows "xvec \<sharp>* (\<bottom>\<^sub>Fby(ominal_induct P and I and  arbitrary: x rule:psi_input_psiCase.strong_inducts
  and   "Xs \<sharp>* (\<bottom>\<^sub>F)"
by(auto simp add: fresh_star_def)

lemma SFreshBottom[simp]:
  fixes xvec :: "name list"
  and   Xs   :: "name set"

  shows "xvec \<sharp>* (SBottom)"
  and   "Xs \<sharp>* (SBottom)"
by(auto simp add: fresh_star_def)
(*
lemma freshChainComp[simp]:
  fixes xvec :: "name list"
  and   Xs   :: "name set"
  and   \<Psi>    :: 'b
     \si'  : b

  shows "xvec \<sharp>* (\<Psi> \<otimes> \<Psi>') = ((xvec \<sharp>* \<Psi>) \<and> xvec \<sharp>* \<Psi>')"
  and   "Xs \<sharp>* (\<Psi> \<otimes> \<Psi>') = ((Xs   and   Xs   : " 
by(auto simp add: fresh_star_def)
*)
lemma freshFrameDest[dest]:
  fixes A_F    :: "name list"
  and   Ψ_F   :: 'b
  and   xvec  :: "name list"

  assumes "xvec ♯* (⟨A_F, Ψ_F⟩)"

  shows "xvec ♯* A_F ==> xvec ♯* Ψ_F"
  and   "A_F ♯* xvec ==> xvec ♯* Ψ_F"
proof -
  from assms have "(set xvec) ♯* (⟨A_F, Ψ_F⟩)"
    simp
  moreover assume "xvec ♯* A_F"
  ultimately show "xvec ♯* Ψassms
    by(simp add: frameResChainFreshSet) (force simp add: fresh_def name_list_supp fresh_star_def)
next
  from assms have "(set xvec) ♯* (⟨A_F, Ψ_F⟩)"
    by(simp add: fresh_star_def)
  moreover assume "A_F ♯
  ultimately show java.lang.NullPointerException
    by(simp add: frameResChainFreshSet) (force simp add: fresh_def name_list_supp fresh_star_def)
qed

lemma insertAssertionSimps[simp]:
  fixes A_F :: "name list"
  and Ψ_F :: 'b
  and Ψ :: 'b
  
  assumes "A_F ♯* Ψ"

  shows "insertAssertion (⟨A_F, Ψ_F⟩) Ψ lemma[simp
using assms
by(induct A_F arbitrary: F) auto

lemma mergeFrameSimps[simp]:
  fixes Ajava.lang.NullPointerException
  and   Ψ_F :: 'b
  and   Ψ  :: 'b

  assumes "A_F ♯* Ψ"

  shows "(⟨A_F, Ψ_F⟩) ⊗_F ⟨ε, Ψ⟩ = ⟨A_F, Ψ_F ⊗: name list"
using assms
by(induct A_F arbitrary: F) auto

lemma mergeFrames[simp]:
  fixes A_F  :: "name list"
  and   Ψ_F :: 'b
  and   A_G  :: "name list"
  and   Ψ_G :: 'b

  assumes "A_F ♯* A_G"
  and     "A_F ♯* Ψ_G"
  and     "A_G ♯* Ψ_F"

  shows "(⟨A_F, Ψ_F⟩) ⊗_F (⟨A_G, Ψ_G⟩) = (⟨(A_F@A_G), Ψ_F ⊗ Ψ_G⟩)"
using assms
by(induct A_F) auto

lemma frameImpResFreshLeft:
  fixes F :: "'b frame"
  and   x :: name
  
  assumes "x ♯ F"

  shows "(νx)F ↪_F F"
proof(auto simp add: FrameStatImp_defassumes  sharpA_F<>"
  fix φ::'c
  obtain A<sub\Psi<sub Feq "= \langle<sub>F,\Psi\^bF<rangl>"dA_* (x, 🚫
    by(rule freshFrame)
  from java.lang.NullPointerException
 obtain y where "y ♯) \sharp(<>A₎
 by(generate_fresh "name", auto)
 
 assume "(νx)F ⊨_F φ"
 with ‹y ♯ F› have "(νy)([(x, y)] ∙ F) ⊨_F φ" by(simp add: alphaFrameRes)
 with ‹
 with Feq have "⟨(y#A_F), Ψ_F⟩ xvec) ♯A_F⟩)"
 with Feq ‹
 by(force intro: frameImpI dest: frameImpE simp del: frameResChain.simps)
 

  frameImpResFreshRight:
 fixes F :: "'b frame"
 and x :: name
 
 assumes "x ♯ F"

 shows "F ↪_\nu>x\rparr"
 (auto simp add: FrameStatImp_def)
 fix φ::'c
 A^su>F Ψ_F where Feq: "F = ⟨F, Ψ_F⟩F ♯
 by(rule freshFrame)
 from <A\_F ♯ have "x ♯F" and "A_* φ" by simp+
 obtain y where "y ♯ φ" and "y ♯ F" and "x ≠ y"
 by(generate_fresh "name", auto)
 
 assume "F ⊨_F φ"
 with Feq ‹A_F ♯* φ› ‹y ♯ φ› have "⟨(y#A_F), Ψ_F⟩ ⊨_F φ"
 by(force intro: frameImpI dest: frameImpE simp del: frameResChain.simps)
 moreover with ‹y ♯ F› ‹x ♯ F› Feq show "(νx)F ⊨_F φ"
 by(subst alphaFrameRes) auto
 

  frameResFresh:
 fixes F :: "'b frame"
 and x :: name
 
 assumes "x ♯ anand ΨF :: 'b

 shows "(νx)F ≃_F F"
  assms
 (auto simp add: FrameStatEq_def intro: frameImpResFreshLeft frameImpResFreshRight)

  frameImpResPres:
 fixes F :: "'b frame"
 and G :: "'b frame"
 and x :: name
 
java.lang.NullPointerException

 shows "(νx)F ↪_F (νx)G"
 (auto simp add: FrameStatImp_def)
 fix φ::'c
 obtain A_F Ψ_F where Feq: "F = ⟨A_F, Ψ_F⟩" and "A_F ♯F ♯* Ψ
 by(rule freshFrame)
 from ‹A_F ♯* (x, φ)› have "x ♯ A_F" and "A_F ♯* φ" by simp+
 obtain y where "y ♯A_F⟩⊗F (⟨G, Ψ) = (⟨F@A_F ⊗G⟩
 and "x ≠ y" and "y ♯ φ"
 by(generate_fresh "name", auto)
 assume "(νx)F ⊨_F φ"
 with ‹y ♯ F› have "(:
 with Feq ‹F›y ♯ A have "⟨(y#A ΨF⟩ ⊨" by(simp add: eqvts)
 with ‹
 by(force intro: frameImpI dest: frameImpE simp del: frameResChain.simps)
 hence "([(x, y)] ∙ ⟨A_F, [(x, y)] ∙ Ψ_F⟩) ⊨_F ([(x, y)] ∙ φ)"
 by(rule frameImpClosed)
 with ‹x ♯ A_F› ‹y ♯ A₍auto simp add: FrameSt)
 by(simp add: eqvts)
 with ‹ have "G ⊨F [(x, y)] ∙" by(simp add: FrameStatImp_)
 
 obtain A_G Ψ_AG⟩" and "A_* (x, y, φ
 by(rule freshFrame)
 from ‹A_G ♯* (x, y, φ)› have "x ♯ A_G" and "y ♯ A_G" and "A_G ♯* φ" by simp+
 from ‹G ⊨_F [(x, y)] ∙ φ› have "([(x, y)] ∙
 rule frameImpClosed)
 with Geq ‹x ♯ A_G› ‹
 with ‹y ♯ φ› ‹A_G ♯* φ› have "⟨(y#A_G), [(x, y)] ∙ Ψ_G⟩ ⊨_F φ"
 by(force intro: frameImpI dest: frameImpE simp del: frameResChain.simps)
 with ‹y ♯ G› ‹x ♯ A_G› ‹y ♯ A_G› Geq show "(νx)G ⊨_F φ"
 by(subst alphaFrameRes) (fastforce simp add: eqvts)+
 

  frameResPres:
 fixes F :: "'b frame"
 and G :: "'b frame"
 and x :: name
 
 assumes "F ≃_F G"

 shows "(νx)F ≃_F (νx)G"
 
 (auto simp add: FrameStatEq_ assumes "x \<\<

  frameImpResComm:
 fixes x :: name
 and y :: name
 and F :: "'b frame"

 shows "(νx)((νy)F) ↪_F (νy)((νx)F)"
 by(rule freshFrame)
 assume x = yy"
 thus ?thesis by simp
 
 assume "x ≠ y"
 show ?thesis
 proof(auto simp add: FrameStatImp_def)
 fix φ::'c
 obtain A_F Ψ_F where Feq: "F = ⟨A_F, Ψ_F⟩" and "A_F ♯* (x, y, φ)"
 by(rule freshFrame)
 then have "x ♯ A_F" and "y ♯ A_F" and "A_F ♯* φ" by simp+

 obtain x'::name where "x' ≠(force intro: rameImpI dest: frameI simp ddel:: fra.simps)
 by(generate_fresh "name") auto
 obtain y'::name where "y' ≠ x" and "y' ≠ y" and "y' ≠ x'" and "y' ♯ F" and "y' ♯ φ" and "y' ♯ A_F"
 generate_fresh"na") aut
 
 from ‹y' ♯ F›
 by(simp add: alphaFrameRes)
 moreover from ‹x' ♯ F› ‹x' ≠ y› ‹x :: name
 by(rule_tac alphaFrameRes) (simp add: abs_fresh fresh_left)
 moreover with ‹y' ≠ x'› ‹
 by(simp add: eqvts calc_atm)
 ultimately have A: "(νx)((νy)F)= (νx')((νy')((lparr>\nurparr>F>F ≃
 using Feq ‹x ♯ A_F›
 by(simp add: eqvts)

 from ‹x' ♯ F› have "(νy)((ν
 by(simp add: alphaFrameRes)
 moreover from ‹y' ♯
 by(rule_tac alphaFrameRes) (simp add: abs_fresh fresh_left)
 moreover with ‹y' ≠ x'› ‹x' ≠ y› have "… ::name
 by(simp add: eqvts calc_atm)
 x' \noteq\close\<>'
 have "… = (νy')((νx')([(x, x')] ∙ [(y, y')] ∙ F))"
 apply(simp add: eqvts)
 by(subst perm_compose) (simp add: calc_atm)
java.lang.NullPointerException
 using Feq ‹x ♯ A_F› ‹x' ♯ A_F› ‹y ♯ A_F› ‹simp add: FrFrameSta)
 by(simp add: eqvts)

 from ‹x' ♯ φ› ‹y' ♯ φ› ‹A_F ♯* φ›
java.lang.NullPointerException
 by(force dest: frameImpE intro: frameImpI simp del: frameResChain.simps)
 with A B have "((νx)((νy)F)) ⊨_F φ = ((νy)((νx)F)) ⊨_F φ"
 by simp
 moreover assume "((νx)((νy)F)) ⊨_F φ"
 ultimately show "((νy)((νx)F)) ⊨_F φ" by simp
 qed
 

  frameResComm:
 fixes x :: name
 and y :: name
 and F :: "'b frame"

 shows "(νx)((νy)F) ≃_F (νy)((νx)F)"
 (auto simp add: FrameStatEq_def intro: frameImpResComm)

  frameImpResCommLeft':
 
 and xvec :: "name list"
 and F :: "'b frame"

 shows "(νx)((ν*xvec)F) ↪_F (ν*xvec)((νx)F)"
 (induct xvec) (auto intro: frameImpResComm FrameStatImpTrans frameImpResPres)

  frameImpResCommRight':
 fixes x :: name
 and xvec :: "name list"
 and F :: "'b frame"

 shows "(ν*xvec)((νx)F) ↪_F (νx)((ν*xvec)F)"
 (induct xvec) (auto intro: frameImpResComm FrameStatImpTrans frameImpResPres)

  frameResComm':
 fixes x :: name
 and xvec :: "name list"
 and F :: "'b frame"

 shows "(νx)((ν*xvec)F) ≃_F (ν*xvec)((νx)F)"
 (induct xvec) (auto intro: frameResComm FrameStatEqTrans frameResPres)

  frameImpChainComm:
 fixes xvec :: "name list"
 and yvec :: "name list"
 and F :: "'b frame"

 shows "(ν*xvec)((ν*yvec)F) ↪_F (ν*yvec)((ν*xvec)F)"
 (induct xvec) (auto intro: frameImpResCommLeft' FrameStatImpTrans frameImpResPres)

  frameResChainComm:
 fixes xvec :: "name list"
 and yvec :: "name list"
 and F :: "'b frame"

 shows "(ν*xvec)((ν*yvec) wiwith ‹
 (induct xvec) (auto intro: frameResComm' FrameStatEqTrans frameResPres)

  frameImpNilStatEq[simp]:
 fixes Ψ :: 'b
 and Ψ' :: 'b

 shows "(⟨ε, Ψ⟩ ↪_F ⟨ε, Ψ'⟩) = (Ψ ↪ Ψ')"
 (simp add: FrameStatImp_def AssertionStatImp_def FrameImp_def)


  frameNilStatEq[simp]:
 fixes Ψ :: 'b
 and Ψ' :: 'b

 shows "(\<langle  
 (simp add: FrameStatEq_def AssertionStatEq_def FrameImp_def)

  extractFrameChainStatImp:
 fixes xvec :: "name list"
 and P :: "('a, 'b, 'c) psi"

 shows "extractFrame((ν*xvec)P) ↪_F (ν*xvec)(extractFrame P)"
 (induct xvec) (auto intro: frameImpResPres)

  extractFrameChainStatEq:
 fixes xvec :: "name list"
  b 'c) ppsi"

 shows "extractFrame((
 (inb shows "\< "

  insertAssertionExtractFrameFreshImp:
 fixes xvec :: "name list"
 and Ψ :: 'b
 and P :: "('a, 'b, 'c) psi"

 assumes "xvec ♯

 shows "insertAssertion(extractFrame((ν*xvec)P)) Ψ ↪_noteq
  assms
 (induct xvec) (auto intro: frameImpResPres)

  insertAssertionExtractFrameFresh:
 fixes xvec :: "name list"
 and Ψ :: 'b
 and P :: "('a, 'b, 'c) psi"

 assumes "xvec ♯* Ψ"

 shows "insertAssertion(extractFrame((ν*xvec)P)) Ψ ≃_F (ν*xvec)(insertAssertion (extractFrame P) Ψ)"
  assms
 (induct xvec) (auto intro: frameResPres)

  frameImpResChainPres:
 fixes F :: "'b frame"
 and G :: "'b frame"
 and xvec :: "name list"

 assumes "F ↪_F G"

 shows "(ν*xvec)F ↪_F (ν*xvec)G"
  assms
 (induct xvec) (auto intro: frameImpResPres)

  frameResChainPres:
 fixes F :: "'b frame"
 and G :: "'b frame"
 and xvec :: "name list"



 shows "(ν*xvec)F ≃_F (ν*xvec)G"
  assms
 (induct xvec) (auto intro: frameResPres)

  insertAssertionE:
 fixes F :: "('b::fs_name) frame"
 and Ψ :: 'b
 and Ψ' :: 'b
 and A_F :: "name list"

 assumes "insertAssertion F Ψ = ⟨A_F, Ψ'⟩"
 and "A_F ♯* F"
 and "A_F ♯* Ψ"
 and "distinctA🚫

 obtains Ψ_F where "F = ⟨A_F, Ψ_F⟩" and "Ψ: eq
  -
 assume A: "∧Ψ_F. [F = ⟨A_F, Ψ_F⟩; Ψ' = Ψ ⊗\lparr\<>[
 from assms have "∃Ψ_F. F = ⟨A_F, Ψ_F⟩ ∧ Ψ' = Ψ ⊗ Ψ_F"
 proof(nominal_induct F avoiding: Ψ A_F Ψ' rule: frame.strong_induct)
 case(FAssert Ψ A_F Ψ')
  ?ase by auto
 next
 case(FRes x F Ψ A_F Ψ')
 from ‹insertAssertion ((νx)F) Ψ = ⟨A_F, Ψ'⟩› ‹x ♯ Ψ›
 obtain y A_F' where "A_F = y#A_F'" by(induct A_F) auto
 with ‹insertAssertion ((νx)F) Ψ = ⟨A_F, Ψ'⟩› ‹y' ≠ y›,y')] <> 
 have A: "insertAssertion F Ψ = ⟨([(x, y)] ∙ A_F'), [(x, y)] ∙ Ψ'⟩"
 by(simp add: frame.inject alpha eqvts)
 from ‹A_F = y#A_F'› ‹A_F ♯* Ψ› have "y ♯<><
 from ‹distinct A_F› ‹A_F = y#A_F'› have "y ♯ A_F'" and "distinct A_F'" by auto
 from ‹A_F ♯* ((νx)F)› ‹x ♯ A_F› ‹A_F = y#A_F'›
 apply -
 apply(auto simp add: abs_fresh)
 apply(hypsubst_thin)
 apply(subst fresh_star_def)
 apply(erule rev_mp)
 
 apply(clarify)
 apply(erule_tac x=xa in ballE)
 apply(simp add: abs_fresh)
 apply auto
 by(simp add: fresh_def name_list_supp)
 with ‹x ♯ A_F'› ‹
 from ‹A_F' ♯* Ψ
 with ‹
 with ‹∧Ψ A_F Ψ'. [insertAssertion F Ψ = ⟨A_F, Ψ'⟩; A_F ♯* F; A_F ♯* Ψ; distinct A_F] ==> ∃Ψ_F. F = ⟨A_F, Ψ_F⟩#y#A_F<> \<>"
 ‹([(x, y)] ∙ A_F') ♯* F› ‹distinct A_F'› ‹x ♯ A_F'› ‹y ♯ A_F'›
 obtain Ψ_F where Feq: "F = ⟨A_F', Ψ_F⟩" and Ψeq: "([(x, y)] ∙ Ψ') = Ψ ⊗ Ψ_F"
 by force
 
 from Feq have "(νx)F = ⟨(x#A_F'), Ψ_F⟩" by(simp add: frame.inject)
 (orce d fraintro:: fram simp del: frame.simps)
 hence "(νx)F = ⟨A_F, [(x, y)] ∙ Ψ_nu>x) 🚫
 by(simp add: eqvts calc_atm alphaFrameRes)

 moreover from Ψeq have "[(x, y)] ∙ ([(x, y)] ∙ Ψ') = [(x, y)] ∙ (Ψ ⊗ Ψ_F)"
 by simp
 with ‹x ♯ Ψ› ‹y ♯ Ψ› have "Ψ' = Ψ ⊗ ([(x, y)] ∙ Ψ_F)" by(simp add: eqvts)
 ultimately show ?case
 by blast
 qed
 with A show ?thesis
 by blast
 

  mergeFrameE:
 fixes F :: "'b frame"
 and G :: "'b frame"
 and A_FG :: "name list"
 and Ψ_FG :: 'b

 assumes "mergeFrame F G = ⟨A_FG, Ψ_FG⟩"
 and "distinct A_FG"
 and "A_FG ♯
 and "A_F\<lemma 

java.lang.NullPointerException
  -
java.lang.NullPointerException
 from assms have "∃A_F Ψ_F A_G Ψ_G. A_FG = A_F@A_G ∧ Ψ_FG = Ψ_F ⊗ Ψ_G ∧ F = ⟨A_F, Ψ_F⟩ ∧ G = ⟨A_G, Ψ_G⟩ ∧ A_F ♯* Ψ_G ∧ A_G ♯* Ψ_F"
 proof(nominal_induct F avoiding: G A_FG Ψ_FG rule: frame.strong_induct)
 case(FAssert Ψ G A_FG Ψ_FG)
 thus ?case
 apply auto
 apply(rule_tac x="[]" in exI)
 by(drule_tac insertAssertionE) auto
 next
 case(FRes x F G A_FG Ψ_FG)
 from ‹mergeFrame ((νx)F) G = ⟨A_FG, Ψ_FG⟩› ‹x ♯ G›
 obtain y A_FG' where "A_FG = y#A_FG'" by(induct A_FG) auto
 with ‹A_FG ♯* ((νx)F)› ‹x ♯ A_FG› have "A_FG' ♯* F" and "x ♯ A_FG'"
 by(auto simp add: supp_list_cons fresh_star_def fresh_def name_list_supp abs_supp frame.supp)
java.lang.NullPointerException
java.lang.NullPointerException
 apply(auto simp add: abs_fresh frameResChainFreshSet)
 apply(hypsubst_thin)
 by(induct A_FG') (auto simp add: abs_fresh)
 from ‹distinct A_FG› ‹A_FG = y#A_FG'› have "y ♯ A_FG'" and "distinct A_FG'" by auto
 
 with ‹A_FG = y#A_FG'› ‹: "'b frame"
 have "mergeFrame F G = ⟨
 by(simp add: frame.inject alpha eqvts)
 with ‹distinct A_FG'› ‹A_FG' ♯* F› ‹A_FG' ♯* G›
 ‹∧G A_FG Ψ_FG. [mergeFrame F G = ⟨A_FG, Ψ_FG⟩; distinct A_FG; A_FG ♯* F; A_FG ♯* G] ==> ∃A_F Ψ_F A_G Ψ_G. A_FG = A_F@A_G ∧ Ψ_FG = Ψ_F ⊗ Ψ_G ∧ F = ⟨A_F, Ψ_F⟩ ∧ G = ⟨A_G, Ψ_G⟩ ∧ A_F ♯* Ψ_G ∧ A_G ♯* Ψ_F›
java.lang.NullPointerException
 by metis

 from ‹
java.lang.NullPointerException
 with ‹y ♯ G›
 by auto
 from ‹([(x, y)] ∙ Ψ_FG) = Ψ_F ⊗ Ψ_G› have "([(x, y)] ∙ [(x, y)] ∙ Ψ\   :
 by simp
 with ‹x ♯ Ψ_G› ‹y ♯ Ψ_G› have "Ψ_FG = ([(x, y)] ∙ Ψ_F) ⊗ Ψ_G" by(simp add: eqvts)
 moreover from FrF have "([(x, y)] ∙ F) = [(x, y)] ∙ ⟨A_F, Ψ_F⟩" by simp
 with ‹x ♯ A_F› ‹y ♯ A_F› have "([(x, y)] ∙ F) = ⟨A_F, [(x, y)] ∙ Ψ_F⟩" by(simp add: eqvts)
java.lang.NullPointerException
 with ‹
 moreover with ‹A_G ♯* Ψ_F› have "([(x, y)] ∙ A_G) ♯* ([(x, y)] ∙ Ψ_F)" by(simp add: pt_fresh_star_bij[OF pt_name_inst, OF at_name_inst])
 with ‹
 moreover from ‹A_F ♯* Ψ_G› ‹y ♯ Ψ_G› have "(y#A_F) ♯* Ψ_G" by simp
 ultimately show ?case using FrG
 by blast
 qed
 with A show ?thesis by blast
 

  mergeFrameRes1[simp]:
 fixes A_F :: "name list"
 and Ψ_F :: 'b
 and x :: name
 and A_G :: "name list"
 and Ψ_G :: 'b
 
  A\sub🚫
 and "A_F ♯* A_G"
 and "x ♯ A_F"
 and "x ♯ Ψ_F"
 and "A_G ♯* Ψ_F"
 
 shows "(⟨A_F, Ψ_F⟩) ⊗_F ((νx)(⟨A_G nd \<Psi'
  assms
 (fold frameResChain.simps)
 (rule mergeFrames) auto

  mergeFrameRes2[simp]:
 fixes A )
 and Ψ_F :: 'b
 and x :: name
 and A_G :: "name list"
 and Ψ_G :: 'b
 
 assumes "A_F ♯
java.lang.NullPointerException
 and "x ♯
 and "x ♯ Ψ_F"
 and "A_G ♯* Ψ_F"
 
 shows "(⟨A_F, Ψ_F⟩) ⊗_F ((νx)(⟨A_G, Ψ_G⟩)) = (⟨(A_F@x#A_G), Ψ_F ⊗ Ψ_G⟩)"
  assms
 (fold frameResChain.simps)
 (rule mergeFrames) auto

  insertAssertionResChain[simp]:
 fixes xvec :: "name list"
 and F :: "'b frame"
 and Ψ :: 'b

 assumes "xvec ♯* Ψ"

 shows "insertAssertion ((ν*xvec)F) Ψ = (ν*xvec)(insertAssertion F Ψ)"
  assms
 (induct xvec) auto

  extractFrameResChain[simp]:
 fixes xvec :: "name list"
 and P :: "('a, 'b, 'c) psi"

 shows "extractFrame((ν*xvec)P) = (ν*xvec) x) (auto intro: frame)
 (induct xvec) auto

  frameResFreshChain:
 fixes xvec :: "name list"
 and F :: "'b frame"

 assumes "xvec ♯* F"

 shows "(ν*xvec)F ≃_F F"
  assms
 (induct xvec)
 case Nil
 thus ?case by simp
 
 case(Cons x xvec)
 thus ?case
 by auto (metis frameResPres frameResFresh FrameStatEqTrans)
 

 

  assertion = assertionAux SCompose SImp SBottom SChanEq
 for SCompose :: "'b::fs_name \<Rightarrow  
 and SImp :: "'b ==> 'c::fs_name ==> bool"
 and SBottom :: 'b
 and SChanEq :: "'a::fs_name ==> 'a ==> 'c" +

 
 and chanEqTrans: "[SImp Ψ (SChanEq M N); SImp Ψ (SChanEq N L)] ==> SImp Ψ (SChanEq M L)"
 and Composition: "assertionAux.AssertionStatEq SImp Ψ Ψ' ==> assertionAux.AssertionStatEq SImp (SCompose Ψ Ψ'') (SCompose Ψ' Ψ'')"
 and Identity: "assertionAux.AssertionStatEq SImp (SCompose Ψ SBottom) Ψ"
 and Associativity: "assertionAux.AssertionStatEq SImp (SCompose (SCompose Ψ Ψ') Ψ'') (SCompose Ψ (SCompose Ψ' Ψ''))"
 and Commutativity: "assertionAux.AssertionStatEq SImp (SCompose Ψ Ψ') (SCompose Ψ' Ψ)"

 

  SCompose (infixr ‹b"
  SImp (‹_ ⊨ _› [85, 85] 85)
  SChanEq (‹_ ↔ _› [90, 90] 90)
  SBottom (‹⊥› 90)

  compositionSym:
 fixes Ψ :: 'b
 and Ψ' :: 'b
 and Ψ'' :: 'b

 assumes "Ψ ≃ Ψ'"

 shows "Ψ'' ⊗
  -
 have "Ψ'' ⊗ Ψ ≃ Ψ ⊗ Ψ''" by(rule Commutativity fixe F ::"'b ff"
 moreover from assm aand G :: 'b fra"
 moreover have "Ψ' ⊗ Ψ'' ≃ Ψ'' ⊗: "name list"
 ultimately show ?thesis by(blast intro: AssertionStatEqTrans)
 

  Composition':
 fixes Ψ :: 'b
 and Ψ' :: 'b
 and Ψ'' :: 'b
 and Ψ''' :: 'b

 assumes "Ψ ≃
 and "Ψ'' ≃ Ψ'''"
 
 shows "Ψ ⊗
  assms
 (metis Composition Commutativity AssertionStatEqTrans)
 

  composition':
 fixes Ψ :: 'b
 and Ψ' :: 'b
 and Ψ'' :: 'b
 and Ψ''' :: 'b

 assumes "Ψ ≃ Ψ'"

 shows "(Ψ ⊗ Ψ'') ⊗ Ψ''' ≃ (Ψ' ⊗ Ψ'') ⊗ Ψ'''"
  -
 have "(Ψ ⊗ Ψ'') ⊗ Ψ''' ≃ Ψ ⊗ (Ψ'' ⊗ Ψ''')"
 by(rule Associativity)
 moreover from assms have "Ψ ⊗ (Ψ'' ⊗ Ψ''') ≃ Ψ' ⊗ (Ψ'' ⊗ Ψ''')"
 by(rule Composition)
 moreover have "Ψ' ⊗ (Ψ'' ⊗ Ψ''') ≃ (Ψ' ⊗ Ψ'') ⊗ Ψ'''"
 by(rule Associativity[THEN AssertionStatEqSym])
 ultimately show ?thesis by(blast dest: AssertionStatEqTrans)
 

  associativitySym:
 fixes Ψ :: 'b
 and Ψ' :: 'b
 and Ψ'' :: 'b
 
 shows "(Ψ ⊗ Ψ') ⊗ Ψ'' ≃ (Ψ ⊗ Ψ'') ⊗ Ψ'"
  -
 have "(Ψ ⊗ Ψ') ⊗ Ψ'' ≃ Ψ ⊗ (Ψ' ⊗ Ψ'')"
 by(rule Associativity)
 moreover have "Ψ ⊗ (Ψ' ⊗ Ψ'') ≃ Ψ ⊗ (Ψ'' ⊗ Ψ')"
 by(rule compositionSym[OF Commutativity])
 moreover have "Ψ ⊗ (Ψ'' ⊗ Ψ') ≃ (Ψ ⊗ Ψ'') ⊗ Ψ'"
 by(rule AssertionStatEqSym[OF Associativity])
 ultimately show ?thesis
 by(blast dest: AssertionStatEqTrans)
 
 
  frameChanEqSym:
 fixes F :: "'b frame"
 and M :: 'a
 and N :: 'a

 assumes "F ⊨_F M ↔ N"
 
 shows "F ⊨_F N ↔ M"
  assms
 (auto simp add: FrameImp_def)
 (force intro: chanEqSym simp add: FrameImp_def)

  frameChanEqTrans:
 fixes F :: "'b frame"
 and M :: 'a
 and N :: 'a

 assumes "F ⊨_F M ↔ N"
 and "F ⊨_F N ↔ L"
 
 shows "F ⊨_F M ↔ L"
  -
 obtain A_F Ψ_F where "F = ⟨A_F, Ψ_F⟩" and "A_F ♯* (M, N, L)"
 by(rule freshFrame)
 with assms show ?thesis
 by(force dest: frameImpE intro: frameImpI chanEqTrans)

*)
lemma frameIntAssociativity:>where#<subA<sub auto
  fixes A_F  :: "name list"
  and   Ψ   :: 'b
  and   Ψ'  :: 'b
  and   Ψ'' :: 'b

  shows "⟨A_F, (Ψ ⊗ Ψ') ⊗ Ψ''⟩ ≃_F ⟨A_F, Ψ ⊗ (Ψ' ⊗ Ψ'')⟩"
by(induct A_F) (auto intro: Associativity frameResPres)

lemma frameIntCommutativity:
  fixes A_F  :: "name list"
  and   Ψ   :: 'b
  and   Ψ'  :: 'b

  shows "⟨A_F, Ψ ⊗ Ψ'⟩ ≃_F ⟨A = ⟨F', (, )] \\bu \Psi'<rangle>"
by(induct A_F) (auto intro: Commutativity frameResPres)

lemma frameIntIdentity:
  fixes A_F :: "name list"
  and   Ψ_F :: 'b 

  shows "⟨A_F, Ψ_F ⊗ SBottom⟩ ≃_F ⟨A_F, Ψ_F⟩"
y A\subF) autoframeResPres

lemma frameIntComposition:
  fixes Ψ  :: 'b
  and   Ψ' :: 'b
  and   A_F :: "name list"
  and   Ψ_F :: 'b

  assumes "Ψ ≃ Ψ'"

  shows "⟨A_F, Ψ ⊗ Ψ_F⟩ ≃_F ⟨A_F, Ψ' ⊗ Ψ_F⟩"
using assms
by(induct A_F) (auto intro: Composition frameResPres)

lemma frameIntCompositionSym:
  fixes Ψ  :: 'b
  and   Ψ' :: 'b
  and   A_F :: "name list"
  and   Ψ_F :: 'b

  assumes "Ψ ≃ Ψ'"

  shows "⟨A_F, Ψ_F ⊗ Ψ⟩ ≃_F ⟨A_F, Ψ_F ⊗ Ψ'⟩"
using assms
by(induct A_F) (auto intro: compositionSym frameResPres)

lemma frameCommutativity:
  fixes F :: "'b frame"
  and   G :: "'b frame"

  shows "F ⊗_F G ≃_F G ⊗_F F"
proof -
  obtain A_<<^> sharpy\sharp<>"
    by(rule freshFrame)
  moreover obtain A_G Ψ_G where "G = ⟨A_G, Ψ_G⟩" and "A_G ♯* Ψ_F" and "A_G ♯* A_F"
    by(rule_tac C="(A_F, Ψ_F)" in freshFrame) auto
  moreover from ‹A_F ♯* G› ‹G = ⟨A_G, Ψ_G⟩› ‹A_G ♯* A_F› have "A_F ♯* Ψ_G"
    by auto
  ultimately show ?thesis
    by auto (metis FrameStatEqTrans frameChainAppend frameResChainComm frameIntCommutativity)
qed
  
lemma frameScopeExt:
  fixes x :: name
  and   F :: "'b frame"
  and   G :: "'b frame"

  assumes "x ♯ F"

  shows "(νx)(F ⊗_F G) ≃_F F ⊗_F ((νx)G)"
proof -
  have "(νx)(F ⊗_F G) ≃_F (νx)(G ⊗_F F)"
    by(metis frameResPres frameCommutativity)
  with ‹x ♯ F› have "(νx)(F ⊗_F G) ≃_F ((νx)G) ⊗_F F"
    by simp
  moreover have "((νx)G) ⊗_F F ≃_F F ⊗_F ((νx)G)"
    by(rule frameCommutativity)
  ultimately show ?thesis by(rule FrameStatEqTrans)
qed

lemma insertDoubleAssertionStatEq:
  fixes F  :: "'b frame"
  and   Ψ  :: 'b
  and   Ψ' :: 'b

  shows "insertAssertion(insertAssertion F Ψ) Ψ' ≃_F (insertAssertion F) (Ψ ⊗ Ψ')"
proof -
  obtain A_F Ψ_F where "F = ⟨A_F, Ψ_F⟩" and "A_F ♯* Ψ" and "A_F ♯* Ψ'" and "A_F ♯* (Ψ ⊗ Ψ')"
    by(rule_tac C="(Ψ, Ψ')" in freshFrame) auto
  thus ?thesis
    by auto (metis frameIntComposition Commutativity frameIntAssociativity FrameStatEqTrans FrameStatEqSym)
qed

lemma guardedStatEq:
  fixes P  :: "('a, 'b, 'c) psi"
  and   I  :: "('a, 'b, 'c) input"
  and   C  :: "('a, 'b, 'c) psiCase"
^ " "
  and   Ψ_P :: 'b

  shows "[guarded P; extractFrame P = ⟨A_P, Ψ_P⟩] ==> Ψ_P ≃ ⊥ ∧ supp Ψ_P = ({}::name set)"
  and   "[guarded' I; extractFrame' I = ⟨A_P, Ψ_P⟩] ==> Ψ_P ≃ ⊥ ∧ supp Ψ_P = ({}::name set)"
  and   "[guarded'' C; extractFrame'' C = ⟨A_P, Ψ_P⟩] ==> Ψ_P ≃ ⊥ ∧ supp Ψ_P = ({}::name set)"
proof(nominal_induct P and I and C arbitrary: A_P Ψ_P rule: psi_input_psiCase.strong_inducts)
  case(PsiNil A_P Ψ_P)
  thus ?case by simp
next
  case(Output M N P A_P Ψ_P)
  thus ?case by simp
next
  case(Input M In  A_P Ψ_P)
  thus ?case by simp
next
  case(Case psiCase A_P Ψ_P)
  thus ?case by simp
next
  case(Par P Q A_PQ Ψ_PQ)
  from ‹guarded(P ∥ Q)› have "guarded P" and "guarded Q" by simp+
  obtain A_P Ψ_P where FrP: "extractFrame P = ⟨A_P, Ψ_P⟩" and "A_P ♯* Q" by(rule freshFrame)
  obtain A_Q Ψ_Q where FrQ: "extractFrame Q = ⟨A_Q, Ψ_Q⟩" and "A_Q ♯* A_P" and "A_Q ♯* Ψ_P" 
    by(rule_tac C="(A_P, Ψ_P)" in freshFrame) auto
  
  from ‹∧A_P Ψ_P. [guarded P; extractFrame P = ⟨A_P, Ψ_P⟩] ==> Ψ_P ≃ ⊥ ∧ (supp Ψ_P = ({}::name set))› ‹guarded P› FrP
  have "Ψ_P ≃ ⊥" and "supp Ψ_P = ({}::name set)" by simp+
  from ‹∧A_Q Ψ_Q. [guarded Q; extractFrame Q = ⟨A_Q, Ψ_Q⟩] ==> Ψ_Q ≃ ⊥ ∧ (supp Ψ_Q = ({}::name set))› ‹guarded Q› FrQ
  have "Ψ_Q ≃ ⊥" and "supp Ψ_Q = ({}::name set)" by simp+
  
  from ‹A_P ♯* Q› FrQ ‹A_Q ♯* A_P› have "A_P ♯* Ψ_Q" by(drule_tac extractFrameFreshChain) auto
  with ‹A_Q ♯* A_P› java.lang.NullPointerException
 by auto
 with ‹supp Ψ_P = {}› ‹supp Ψ_Q = {}› compSupp have "Ψ_PQ = Ψ_P ⊗ Ψ_Q"
 by blast
 moreover from ‹Ψ_P ≃ ⊥› ‹Ψ_Q ≃ ⊥› have "Ψ_P ⊗ Ψ_Q ≃ ⊥"
 by(metis Composition Identity Associativity Commutativity AssertionStatEqTrans)
 ultimately show ?case using ‹supp Ψ_P = {}› ‹supp Ψ_Q = {}› compSupp
 by blast
 
 case(Res x P A_xP Ψ_xP)
 from ‹guarded((νx)P)› have "guarded P" by simp
 moreover obtain A_P Ψ_P where FrP: "extractFrame P = ⟨A_P, Ψ_P⟩" by(rule freshFrame)
 moreover note ‹∧A_P Ψ_P. [guarded P; extrac apply(subst fresh_star_)
 ultimately have "Ψ_P ≃ ⊥" and "supp Ψ_P = ({}::name set)" by auto
 from FrP ‹extractFrame((νx)P) = ⟨A_xP, Ψ_xP⟩› have "⟨(x#A_P), Ψ_P⟩ = ⟨A_xP, Ψ_xP⟩" by simp
 with ‹supp Ψ_P = {}› have "Ψ_P = Ψ_xP" by(auto simp del: frameResChain.simps)
 with ‹Ψ_P ≃ ⊥› ‹supp Ψ_P = {}› show ?case
 by simp
 
 case(Assert Ψ A_P Ψ_P)
 thus ?case by simp
 
 case(Bang P A_P Ψ_P)
 thus ?case by simp
 
 case(Trm M P)
 thus ?case by simp
 
 case(Bind x I)
 thus ?case by simp
 
 case EmptyCase
 thus ?case by simp
 
 case(Cond φ P psiCase)
 thus ?case by simp