Quelle  IVSubst.thy

(*<*)(*<*)
theory<<v=e=>z1)java.lang.NullPointerException
  importsΔv = dmap (<>u,t). (u, [=<btaujava.lang.NullPointerException
begin
  (*>*)

chapter ‹

  ‹
  they (induc ,u)

  ‹ )+

  has_subst_v = fs +
 fixes subst_v :: "'a::fs ==>
 assumes fresh_subst_v_if: "y ♯
 subst_v[] "tx\sharp a ==> subst_v a x v = a"
 and subst_v_id[simp: "susbst_v a x (V_vrx = a
 and eqvt[simp,eqvt]: "(p::perm) ∙ (subst_v a x v) = (subst_v (p ∙ a) (p ∙ (u,,τ setD Δ"
 and flip_subst_v[simp]: sh "(u, \<tau[tau>\^sub>v) ∈v]\^sub>\\Δ^sub>v)"
 and subst_v_simple_commute[simp]: "atom x ♯ c ==>(c[z::=[x]^v)[x::=b] = c[:=b]_v"
 

  subst_v_flip_eq_one:
 fixes z1::x and z2::x and x1::x and x2::x
 assumes "[[atom z1]]lst. c1 = [[atom z2]]lst. c2"
 and "atom x1 ♯_induct,auto)
 "(cc1z1:x1]<>]
  -
java.lang.NullPointerException
 moreover have "(c2[z2::=[x1]^subst_cv (C_true) x v = C_true"java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 
 by (metis Abs1_eq_iff_fresh(3) flip_commute)
 

  subst_v
 fixes z1::x and z2::x and x1::x and x2::x
 assumes "[[atom z1]]lst. c1 = [[atom z2]]lst. c2"
 1[z1:=b] "subst_cv (C_disc c2) x v = C_disubstc 1x) (subst_cv c2 x v )"
  -
 obtain x::x where *:"atom x ♯ (z1,z2,c1
 hence "(c1[z1::=[x] ubx v = Ci (subst_cv c1 x v )bst_v 2 xv )"
 hence "(c1[z1::=[x]^v]_v)[x::=b]₌ e2) x = ((subst_cev e1 x v ) == (subst_cev e2e2 x v ))"
  ?thessuig sust_vsimle_commue ** rs_prd4by metis
 

  subst_v_flip_eq_three:
 assumes "[[atom z1]]lst. c1 = [[atom z1']]lst. c1'" and "atom x ♯
 (↔uub c x v)"
  -
 have "atom x' ♯
 hence "(x ↔ x') \sharp> x"
 also have "... = c1[z1::=[x'] subst_dv t i x)"
 have .. =1'z1':=[[x]p: eqvt_def subst_cv_,auto)
 finally show ?thesis by auto
 

 

  ‹

 
 subst_vv :: "v ==> x ==> v ==> v" where (eqvt) by lexicograp us assms proof(indu t rule: \\>_ind)
  case DNil
  "subst_vv (V_var y) x v = (if x = y then v else V_var y)"
  "subst_vv (V_cons tyid c v') x v = V_cons tyid c (subst_vv v' x v)"
  "subst_vv (V_consp tyid c b v') x v = V_consp tyid c b (subst_vv v' x v)"
  "subst_vv (V_pair v1 v2) x v = V_pair (subst_vv v1 x v ) (subst_vv v2 x v )"
 utoo simp: eqv eqvt_ef sust_vv_gr
  (eqvt) by lexicographic_order

 
 subst_vv_abbrev :: "v ==>
 where
java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

  fresh_subst_vv_if [simp]:
  subst:: "c ==>
 using supp_l_empty apply (induct t rule: v.induct,auto simp add: subst_vv.simps fresh_def,
 by (simp add: supp_at_base |metis b.supp supp_b_empty )+

  forget_subst_vv [simp]: "atom a ♯ tm ==> tm[a::=x]_v = tm"
 by (induct tm rule: v.induct) (simp_all add: fresh_at_base)

java.lang.NullPointerException
java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

  subst_vv_commute [simp]:
java.lang.NullPointerException
 by (induct tm rule: v.induct) (auto simp: fresh_Pair)

  subst_vv_commute_full [simp]:
 "atom j ♯ size_sust_cv [simp]: "si ( substcv A i x )l (default "case_sum (\<x.) (casse_ (λ(λ undefined))")
 by (induct tm rule: v.induct) auto

  subst_vv_var_flip[sl subst_s:: "s ==> s"
 fixes v::v
 assumes "atom y ♯ v"
java.lang.NullPointerException
 using assms apply(induct v rule:v.induct)
 apply auto
 using l.fresh l.perm_simps l.strong_exhaust supp_l_empty permute_pure permute_list.simps fresh_ and subs: branch_list ==> v ==>
 using "subst_sv( (S_val v') ) x v = (A
 done

  v :: has_subst_v
 

 
 "subst_v = subst_vv"

  proof oofjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 fix j::atom and i::x and x::v and t::v
 show "(j ♯ A at A avoiding: a x rule: c.strong_inductaauto simp: fr)
 using fresh_subst_vv_if[of j t i x] subst_v_v_def by metis

 fix a::x and tm::v and x::v
 show "atom a ♯ tm ==> subst_v tm a x = tm"
 using forget_subst_vv subst_v_v_def by simp

 fix a::x and tm::v
 

 fix p::perm and x1::x and v::v and t1::v
 show "p ∙
 using subst_v_v st_sv ((AS_f v'1 2 ) xx = (AS (subst_v v' x ubst_s 1 x v )ubs s2 v ) )"

 fix x::x and c::v and z::x
 show "atom x ♯ (x,v) ==> v' s) x v = AS_var u (subst_tv \<tau (ubst_sv s ) "
 using subst_v_v_def by simp

 fix x::x and c::v and1 s2 x v = Swil sbtsv s1x v (subst_sv s2 x v )"
 show "atom x ♯q sbts 1x v ) (sububst_sv s22)"
 using v (AS_assert cs) x v AS_a (ubst_cv c xx v) (subsv x v)"
 

 

 ‹

  subst_ev :: "e ==>
 "subst_ev ( (AE_val v') ) x v = ( (AE_val (subst_v "subst_brancs) v S_fial (st_branchv csxv)
  "subst_ev ( (AE_app f v') ) x v = ( (AE_app f (subst_vv v' x v )) )" "substAS_
  "subst_ev ( (AE_appP f b v') ) x v = ( (AE_appP f b (subst_vv v' x v )) )"
 v = ( (A_p op(ubstv 1x v ) (subst_vv2 v ))"
  "subst_ev [#1 v'v_if [simp]:
 subst_ev [#bstev [#2v]^e"
 "subst_ev ( (AEmvar u)u))x v = AE_mvar u"
  "subst_ev [| v' |]^t_at_proj: ∧ xa va . eqvt_at subst_sv_subst_branchv_subst_branchlv_sumC (Inl (s, xa, va)) ==> by (nom A avoiding: ix rule:c.strong_induc, (auto simp add:ure_fres)+)java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
  "subst_eapply(ttc _
  "subst_ev ( AE_split v1 v2) x v = AE_split (subst_vv v1 x v ) (subst_vv v2 x v )"
 by(simp add: eqvt_def subst_ev_graph_aux_def,auto)(meson e.strong_exhaust)

  (eqvt) by lexicographic_order

 
 subst_ev_abbrev :: "e \_efault_def)
 where
 "e[x::=v']_{ubst_sv_subst_branchv_subst_branchlv_graph} (Inl (s,xa,va)))")

 ize_subst_ev [imp]: "size ( subst_ev A i ) = size e A
 apply (nominal_induct A avoiding: i x rule: e.strong_induct)
 by auto

  forget_sub)[1]
 apply (nominal_induct A avoiding: a x rule: by (nominal_induct A avoiding: i j t u rule: : c.strong_induct) (auto simp: fresh_a)
 mp: frs_tbae)

 bst_ev_id [simp]
 by (nominal_induct A avoiding: a rule: e.strong_induct) (auto simp: fresh_at_base)

  fresh_subst_ev_if [simp]:
 "j ♯
 apply (induct A rule: e.induct)
 unfolding subst_ev.simps fresh_subst_vv_if apply auto+
 using pure_fresh fresh_opp_all apply metis+
 

  subst_ev_commute [simp]:
 "a x')
 by (nominal_induct A avoiding: i j t u rule: e.strong_induct) (auto simp: fresh_at_base)

  subst_ev_var_flip[simp]:
 fixes e::e and y::x and x::x
 assumes "atom y ♯
 shows "(y ↔ x) ∙
 using assms apply(nominal_induct e rule:e.strong_induct)
 apply (simp add: subst_v
 apply (metis (mono_tags, lifting) b.eq_iff b.perm_simps e.fresh e.perm_simps flip_b_id subst_ev.simps subst_vv_var_flip)
  apply (metis (mono_tags, lifting) b.eq_iff b.perm_simps e.fres e.perm_flip_b_id subst_ev.simps sub case (fi bbcc)
 subgoal for x
 apply (rule_tac y=x in opp.stros_bstrong_exhaust frreshstarisrt bmei
 using subst_vv_var_flip flip_def by (simp add: flip_def permute_pure)+
 using subst_vv_var_flip qed

  subst_ev_flip:
 fixes e::e and ea::e and c::x
 assumes "atom c ♯
java.lang.NullPointerException
  s c::c
java.lang.NullPointerException
  then shothsis sing Iusing Inr Inl 1 s_banch__s_bran.h_lit.stron_exau reh_starin by metiss
 also have "... = ((c ↔ xa) ∙
 next
 finally show ?thesis by auto
 

  subst_ev_var[simp]:
java.lang.NullPointerException
 by auto  show ?teis sigIr Inr2 shows "(y 🚫c 3 ys2y av 1a s2ac

  e :: has_subst_v
 

 
 "subst_v = suste"

  proof
 ::atom and i::x and x::v andv and tt::e
 show "(j ♯resh_x
 using fresh_subst_ev_if[of j t i x] subst_v_e_def by metis

  a::x and tm: n x::
 show "atom a ♯
  case (5 x1 s1 x1a xa va s1a c)

 fix a::x and tm::e
 oww"vtm a (V_v m" using sbtev_ sbtve_def b

 fix p::perm and x1::x and v::v and t1::e
 "p \bullet subst_v t1 x1 v = subst_v (p ∙ x1) (p ∙ubst_v = subs"
 using subst_ev_commute subst_v_e_def by simp

 fix x::x and c::e and z::x
 show "a (eqvt) bylxcgaphi_order
 using subst_v_e_def by simp

 
 show "atom x ♯
 using subst_v_e_def by simp
 
 

  subst_ev_commute_full:
 fixes e::e and w::v and v::v
 assumes "atom z fix j::atom ai::x a x::v and t:c
java.lang.NullPointerException
  assmsby(no>s\<^b  > subst__sv s "

  subst_ev_v_flip1[simp]:
 fixes e::e
 assumes "atom z1 ♯
 ') 🪙
 using assms _v ≡
  (simp add: flip_def fresh_Pair swap_fresh_fresh)+

 open>Expressions in Constraints›

  substand B and C avoidn:ixrule: s_brnh_s_branch_llst.strong_induc fix a::x aand tm::c and x::v
 "subst_cev ( (CE_val v') ) x v = ( (CE_val (subst_vv v' x v )) )"
  "subst_cev ( (CE_op opp v1 v2)
  "subst_cev ( (CE_fst v')) x v = CE_fst (subst_cev v' x v )"
  "subst_cev ( (CE_snd v')) x v = CE_snd (subst_cev v' x v )"
 bst_cev ( ((CE_len v')v')) x v = CE_len (subst_cet_cev v' x v )"
  "subst_cev ( CE_concat v1 v2) x v = CE_concat (subst_cev v1 x v ) (subst_cev v2 x v )"
 _def,auto)
 by (meson

  using forget_subst_c sB and C aod: aule: s_anch_s_branch_list..strong_induc)

 
 subst_cev_abbrev :: "ce ==> sh?cas
 where
  "ex:v]<^ubc

  size_subst_cev [simp]: "size ( subst_cev A i x ) = size A"
 by (nominal_

  forget_subst_cev [simp]: "atom a ♯
 by (nominal_induct A avoidinPair not_None_bst_ev_i sus_v.simpssubstsv.simps st__idid v.fresh sbst_vv_id m (V_var a) = tm" using su subst_t_cv_id ssubst_v_c_def f by simp

  subst_cev_id [simp]: "subst_cev A a (V_var a) = A"
 by (nominal_induct A avoiding: a rule: ce.strong_induct) (auto simp: fresh_at_base)

  fresh_subst_cev_if [simp]:
 "j ♯
 (nominal_induct A avoiding: i x rule: ce.strong_induct)
 case (CE_op opp v1 v2)
 then show ?case using fresh_subst_vv_if subst_ev.simps e.supp pure_fresh opp.fresh
 resh_e_opp
 using fresh_opp_all by auto
 auto)+

  subst_cev_commute [simp]:
 "atom j ♯ css ∧ x1x1 v = subst_v (p \bullet t1) (p \bullet> x) p ∙
 by (nominal_induct A avoiding: i j t u rule: ce.strong_induct) (auto simp: fresh_at_base)

  subst_cev_var_flip[simp]:
 fixes e::ce and y::x and x::x
 assumes h_s:
java.lang.NullPointerException
 using assms proof(nominal_induct e rule:ce.strong_induct)
 case (CE_val v)
 then show ?case using subst_vv_var_flip by auto
 
 case (CE_op opp v1 v2)
 hence yf: "j ♯
 ( \<>x
  case (AS_b
 also have "... = CE_op ((y ↔chac_lis.fhftri>taw> z) \<> 
 by (simp add: CE_op.h ext
 finally show ?case using subst_cev.simps opp.perm_simps opp.strong_exhaust
 by (metiety e s')')
  (auto simp add: permte_pu subst

  subst_cev_flip:
 fixes e::ce and ea::ce and c::x
 assumes "atomoof(cases atotom x\sharp> (AS_let y e s')")
java.lang.NullPointerException
 
  "e[x::=v']\<^(AS_let
 also have "... = ((c \<  show
 also have "... = ((c ↔
java.lang.NullPointerException
 finally show ?thesis by auto
 

  subst_cev_var[simp]:
 fixes z::x and x::x
 shows "[[x^c si
 by auto

  ce :: has_subst_v
 

 
 "subst_v = subst_cev"

  proof
 fix j::atom and i::x and x::v and t::ce
 show "
 using fresh_subst_cev_if[of j t i x] subst_v_ce_def by metis

 fix a::x and tm::ce and x::v
 show "atom a ♯sbac__rn
 using forget_subst_cev subst_v_ce_def by simp

 ix: a
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5

  v::vnd t1:e
 show "p ∙
 t_cev_commutecev_commute sbt_v_ce_def by simp

 fix x::x and c::ce and z::x
java.lang.NullPointerException
 using subst_v_ce_def by simp "atom

 fix x::x and c::ce and z::x
java.lang.NullPointerException
 using subst_v_ce_def by simp
 

 

 subst_cev_commute_fullfresh_subst_tv_if list.disclist.se_caseses s_banch_s_branch_lst.fesh((4) set_ConsD by auto
 fixes e::ce and w::v and v::v
 assumes "atom z ♯ v" and "atom x ♯ w" and "x ≠ z"
 shows "subst_cev (e[z::=w]_c y (metis assms)
 using assms by(nominal_induct e rule: ce.strong_induct,simp+)


  subst_cev_v_flip1[simp]:
 
 assumes "atom z1 \sharp> (z(z,e)" and "atom z1' ♯ (z,e)"
 shows"(z1 ↔∙c_\<^>c
 using aapply ed(auto)+
 by (simp add: flip_def fresh_Pair swap_fresh_fresh)+

  ‹

  subst_cv :: "c ==>fixes x::x and v::v
 "subst_cv (C_true) x v = C_true"
 _fal) x v = CC_flse"
  "subst_cv (C_conj c1 c2) x v = C_conj (subst_cv c1 x v ) (subst_cv c2 x v )"
 (C_disj c1 c2) x v = C_disj (subst_cv c1 v ) (su c2 v )"
  "subst_cv (C_imp c1 c2) x v = C_imp (subst_cv c1 x v ) (subst_cv c2 x v )"
  "subst_cv(1== e2) x v ((subst_cev v ) =v ) == (ubst_ev e2 x v ))"
  "subst_cv (C_not c) x v = C_not (subst_cv c x v )"
 apply (simp add: eqvt_def subst_cv_graph_aux_def,auto)
 using c.strong_exhaust by met consider "z1' = " usinfrsh_ussv_ilr fresh_sub bmetis+
  (eqvt) by lexicographic_order

 
 subst_cv_abbrev mute [si]:
 where
 "c[x::=v']\ixesA:: n t::andj::x and i::x

 shows "at 🚫
 by (nominal_induct A avoiding: i x rule: c.strong_induct,auto)

 [si]: "atom a a ♯
 by (nominal_induct A avoiding: a x rule: c.strong_induct, auto simp: fresh_at_base)

  subst_cv_id [simp]: "subst_cv A a (V_var a) = A"  \sharp C \<Longrightarrow t u )"
 by (nominal_induct A avoiding: a rule: c.strong_induct) (auto simp: fresh_at_base)

  fresh_subst_cv_if [simp]:
 "j \<sharpby
 by (nominal_induct A avoi

  subs_pe:
 "atom j ♯e 3
 by (nominal_induct A avoiding: i j t u rule: c.strong_induct) (auto simp: fresh_at_base)

  let_s_ize s s \<> 
 apply (nominal_induct s avoiding: e x rule: s_branch_s_branch_list.strong_induct(1))
 apply auto
 done

  subst_cv_var_flip[simp]:
java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 12
 assumes "atom y ♯s> (s, sa)" and "atom c ♯ v'" and "atom xa ♯↔ s = (xa ↔
 shows "(y ↔ "s[x::=v'\sub\<^>=
 using assms by(nominal_induct c ru

  c :: has_subst_v
 

 
java.lang.NullPointerException

  proof
 fix j::atom and i::x and x::v and t::c
 show "(j ♯ t ∧ t) ∨ (j ♯(j \<<harp
 using fresh_subst_cv_if[of j t i x] subst_v_c_def by metis

 fix a::x and tm::c and x::v
 show "atom a ♯ tm ==> subst_v tm a x = tm"
 using forget_subst_cv subst_v_c_def by simp

 fix a::x and tm::c
java.lang.NullPointerException

 fix p::perm and x1::x and v::v and t1::c
 show "p ∙tis flpa_impss(1) flip_frsh_fres reesh_PrD(1)
 using subst_cv_commute subst_v_c_def by simp

 fix x::x and c::c and z::x
 show "atom x ♯ c ==>als hav... = sa[a:v]\\_v" using xafr assms b (simp add: flip_fres_frfeshsh_Pair)
 using subst_cv_var_flip subst_v_c_def by simp

 fix x::x and c::c and z::x
 show "atom x ♯
 using subst_cv_var_flip subst_v_c_def by simp
 

 

  subst_cv_var_flip1[simp]:
 fixes c::c
java.lang.NullPointerException
 x \<leftrightarrow) c = c[x::=V_var y]_v"
 using subst_cv_var_flip flip_commute
 by (metis assms)

  subst_cv_v_flip3[simp]:
 fixes c::c
 assumes "atom z1 ♯ (CE_val v == CE_val (V_lit ll) IMP ca[za::=[z1]^c₎" using assms fresh_prod4 by blast
java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  -
 nsider der ""z1' = z" | " "z1= z"| atom \< z
 then show ?thesis proof(cases)
  1
 then show ?thesis using 1 assms by auto
 next
 case 2
 then show ?thesis usin2 assms b auto
 next
 case 3
 then show ?thesis using assms by auto
 qed
 

  st_v_p[sim]::
 fixes c::c
java.lang.NullPointerException
java.lang.NullPointerException
 

  subst_cv_commute_full:
 fixes c::c
 assumes "atom z \<sharpassumes v" and "atom x ♯
 shows "(c[z::=w]_v]_v"] by blast
 using assms proof(nominal_induct c rule: c.strong_induct)
 case (C_eq e1 e2)
 then show ?case using subst_cev_commute_ ed
 (force+)

  subst_cv_eq[simp]:
 assumes "atom z1 ♯
 showsCEvl(_a z1 = e )[z1z1::=[x]\^v]_v = (CE_val (V_var x) == e1 )" (is "?A = ?B")
  -
 have "?A = (((CE_val (V_var z1))[z1::=[x]^c_v) == e1)" using subst_cv.simps assms by simp
 thus ?thesis by simp
 

  ‹

 >he idea of this substitution is to remove x from the context. We really want to add the condition
  x is fresh in v but this causes problems with proofs.›

  subst_gv :: "Γapply (auto ) (* This unpacks subst, perm *)
 "
  "subst_gv ((y,b,c) #_using subst_tv_var_flip flip_fresh_fresh v.fresh s_branch_s_branch_list.fresh
 (goal_cases)
 case 1
 then show ?case by(simp add: eqvt_def subst_gv_graph_aux_def )
 
 case (3 P x)
 then show ?case by (metis neq_GNil_conv prod_cases3)
 (fast+)
 (eqvt) by lexicographic_order

 
 subst_gv_abbrev :: "Γ ==> 1 (* Sometimes defering hard goals to the end makes it easier to finish *)
 
 "g[x::=v]\<^>\v ≡

  size_subst_gv [simp]: "size ( subst_gv Gi x ) ≤
java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

  forget_subst_gv [simp]: "atom a ♯
  (idut G z1 \sharp e1"
 using fresh_GCons fresh_PairD(1) not_self_fresh apply blast
 apply (simp add: fresh_GCons)+
 done

  fresh_subst_gv: "atom a ♯ (V
 (induct G)
 case GNil
 then show ?case by auto
 
 case (GCons xbc G)
 obtain x' and b' and c' where xbc: "xbc = (x',b',c')" using prod_cases3 by blast
 show ?case proof(cases "x=
 True
 have "atom a ♯::atom and i::x and x::v a t::s
 ubst_gv.simps(2)[of x' b' c' G] GCons xbc True by presburger
 next
 case False
 then show ?thesis using subst_gv.simps(2)[of x' b' c' G] GCons xbc False fresh_GCons by simp
 qed
 

  subst_gv_flip:
 fixes x::x and xa::x and z::x and c::c and b::b and Γ
 assumes "atom xa ♯::s and x::v
 shows "(x ↔(x, b, c[z::=[x]\<  show forget_subst_ subst_v_s_def by simp
  -
 have "(x ↔:
 using subst Cons_eqvt flip_fresh_fresh using G_cons_flip by show "subst_ tm a (V_var a) = tm" using su subst_v_s_def by simp
 also have "... = ((xa, b, (x \<  fix "p ∙substv (p ∙ t1) (p ∙ x1) (p ∙ v)"
 also have "... = ((xa, b, c[z::=V_var xa]\<^>c
 also have "... = ((xa, b, c[z::=V_var xa]_: and c::s and z::x
 finally show ?thesis by simp
 

  ‹

  subst_tv :: "τ
 "atom z ♯ x ♯ c[z::=[x]^v
 apply (simp add: eqvt_def subst_tv_graph_aux_def )
 apply auto
 subgoal for P a aa b
 apply(rule_tac y=a and c="(aa,b)" in τ ‹
  (auto simp: eqvt_at_def ffresh_star_def fresh_Pair fresh_at_base)
 apply (auto simp: eqvt_at_def fresh_star_def fresh_Pair fresh_at_base)
  -
 fix z ::::and c :: c and z: x and xxa :: x and va :: v and ca ::c and cb :: x
 assume a1: "atom za ♯
 assume a4: "atom cb ♯ x ==> fun_typ" where
 assume a10:"cb ≠ xa"
java.lang.NullPointerException

 have "c[z::=V_var cb]_ef
java.lang.NullPointerException
java.lang.NullPointerException
  have "ca[za::=V_var cb]_v[xa::=va]_v = ca[xa::=va]_v[za::=V_var cb]_v"
 using subst_cv_commute_full[of za va xa "V_var cb" ] assms fresh_def v.supp by fastforce

 ultimately show "c[xa::=va
 

  (eqvt) by lexicographic_order

 
 subst_tv_abbrev :: "τ ==> x ==>(1 xa va t s za ca t

 "t[x::=v] by mtiisfip_commt sus_cvvar_fp)

 size_subst_tv [simp]: "size ( subst_tv A i x ) = sizA"
  (nominal_induct A avoiding: i x rule: τ.strong_induct)
 case (T_refined_type x' b' c')
 then show ?case by auto
 

  sho_ases)
 apply (nominal_induct A avoiding: a x rule: τ 1 subst_cvvarflliflp_ccommutete eby me mettis
 apply(uto sim ext
 done

  subst_tv_id [simp]: "subst_tv A a (V_var a) = A"
  (nom A avoiding:a rul: \tau.strong_induct) (auto : fresh_at_base)

  fresh_subst_tv_if [simp]:
 "j ♯ommutee_full 2
 apply (nominal_induct A avoiding: i x rule: τh()
 using fresh_def supp_b_empty x_freqe e by(simmp dd: qvtd f subst_gv_graph_aux_def )

  subst_tv_commute [simp]:
 "atom y ♯ ==> v ==>
 by (nominalnut\taug: xy t

  subst_tv_var_flip [simp]:
  x::x and xa::x a τthen show ?cas by (metineq_GNil_ prod_cases)
 assumes "atom xa ♯ add: subst )
 shows "(x \<(fast
 -
 obtain z::x and b and c where zbc: "atoapply(rule_t y=a and c="(aa,b)" in f.strong_exhaust)
  obtain_fresh_z by ((met pro.inject subst_tv.ca)
 hence "atom xa ∉abb
 by auto
 moreover have "xa \<noteqnoteq
 ultimately have xaf: " subst :: "\subst_ft_vsimp by (simpp add: flipfresh_resh)
 have "(x ↔
 by (metis τphic_ord
 ^ssub>c xaf
 by (metis permute_flip_cancel permute_flip_cancel2 subst_cv_var_flip)
 finally show ?thesis using subst_tv.simps zbc
 using fresh_PairD(1) not_self_fre by force
 

  τ :: has_subst_v
 

 
 "subst_v = subst_tv"

  proof
 fix j::atom and i::x and x::v a bby(nominal_induct A avoiding: a rule: fun_typ.st,auto)
 show "(j ♯: has_subst_v

 proof(nominal_induct t avoiding: i x rule:τ.strong_induct
 case (T_refined_type z b c)
 hence " j ♯
 also have "... = (atom i ♯
 unfolding τ.fresh using subst_v_c_def fresh_subst_v_if
 using T_refined_type.hyps(1) T_refined_type.hyps(2) x_fresh_b by auto
 finally show ?case by auto
 qed

 fix a::x and tm::τnominal_induc t avoiding: i x r:fun_typ.strong_induct)
 show "atom a ♯
 apply(nominal_induct tm avoiding: a x rule:τfun_t.fr fr apply simp
 using subst_v_c_def forget_subst_v subst_tv.simps subst_v_τx and tm::fun_typ and

 fix a::x and tm::τ
 show "subst_v t a(V_var a) =grightarrow> s tm a xx = tm"
  tm avoiding: a x rule:fun_typ.strong_induct)
 using subst_v_c_def forget_subst_v subst_tv.simp case (AF_funtyp x1a x2a x3a x4a x5a)

 fix p::perm and x1::x and v::v and t1::τ(induct G ,auto)
 show "p ∙
 apply(nominal_induct tm avoiding: a x rule:τ:x and tm::fun_typ
 show "subst tm a(V_var a)= tm"

  c:<>andsi add: f)+
java.lang.NullPointerException
 apply(nominal_induct c avoiding:qed
 using subst_v_c_def flip_subst_v subst_tv.simps subst_v_τ

 :ad ::τ
 "atom x \sharp ==>bullet> su t x1 v = subst_v (p \bullet t1 (p \<bullet 
 (nominal_induct c avoiding: x v z rule:τ
 using subst_v_c_def subst_tv.simps subst_v_τcase (AF_fun_typ x1a x2x3a x4a x5a)
 by (metis flip_commute subst_tv_commute subst_tv_var_flip subst_v_\<tau    ?ase unfo subst_ft_v.simps subst fun_typ.fresh using forget_subst_ft_v.simps subst_v_c subst_v_c_def forget_subst_sv subst_v_\<tau_f
 

 

  sub:
 fixes c::τ
 assumes "atom z ♯::fn_yp and z::
 τ_\ττ
 using assms proof(nominal_induct c avoiding: x v z w rule: τ.strong_induct)
 (_refinedtype x1a 2aa x3a)
 then show ?case using subst_cv_commute_full by simp
 

  type_eq_subst_eq:
 fixes v::v and c1::c
 assumes "{ z1 : b1 |::x
 shows "c1[z1::=v]_cv = c2[z2::=v]_b' and c' wh xbxbc "xbc = (',b',c')" usi prod_cases3 by blas
 using subst_v_flip_eq_two[of z1 c1 z2 c2 v] τ.eq_iff assms subst_v_c_def by simp

  ‹ add: subst_v_c_sub subst_v\<>def
  alpha-equivalent types give different answers › fun_typ_q :has_subst_v


 "atom z ♯
 (goal_cases)
  1
 then show ?case usininstance proo
 
 caseve "a a \< G
 then show ?case using eqvt_def c_of_graph_aux_def by force
 
 ?thesis usin su.simps(2)of xap(nominal_inducuct t avo: i x rule_ty_qst,on_inducct,uto)
 then obtain x1::τ_fu_typ_def sbt_v_s_def ubst_v_τef fresh_subst_v_
 obtain z' and b' and c' where "x1 = { z' : b' | c' }next by (m (no_tyes)frsh_subsst_ sust_vfu_typp_def)+
 then show ?case using 3 * by auto
 
 casei:x adt:fun_typ and :v
 then show ?case using subst_v_flip_eq_two τi \<ase x' b' c' G] GCons x F fresh by simp
 

  (eqvt) by lexicographic_ort_v_s_dsubst_v_τsubst_v_fun_typ_q_de fresh_sub )

  c_of_eq:
 shows "c_of { i::x and t::un_typ_q
 (nominal_induct "{ "subst_v t i (
 case (T_refined_type x' c')
  hence "c_of { emma subsubst_gv_flip:
 moreover have "{ by(auto simp a: subst_v_fun_typ_def subst_v_s_def subst_v_\<_  c and ::b and \<::
 fix p::perm an x1::x and v::v and t1::fun_typ_q
 by (metis subst_cv_id)
  assumes "atto xa< (Gamma>)" and "atom xa \harp> \Gamma" an "atom x <> 
 

  obtain_fresh_z_c_of:
 fixes t::"'b::fs"
 obtains z where "atom z ♯ t ∧(nominal_induct t1 avoidi: v x1 rule:fun_typstrong_induct,auto)
  -
 obtain z and c where "atom z ♯
 moreover hence "c = c_of τng c_of.simps using c_of_eq by mets
 ultimately show ?thesis
 using that by auto
 

  c_of_fresh:
 fixes x::x
  "atom x ♯
 shows "atom x ♯dz:
  -
 obtain z' and c' where z:"t = {t | c' \<>  (x,z)" using obtain_fresh_z_c_of by metis
 hence *:"c_of t z = c'[z'::=V_var z]_apply(nominalc avoi: z x v rule:f.strong_induct,auto)
 have applyau simp add: subst_v_fun_typ_dsubst_ subst_v_τf )
 hence "atom x ♯ subst flipbv_xcancel subs.eqvt subst_v_simple_commute v.perm_sim)+
 moreover have "atom x ♯
 ultimately show ?thesis assms fresh_subs[of "atom x" c' z' "V_var z"] su y meteis
 

  c_of_switch:
 fixes z::x
 assumes "tom z \sharp t"
java.lang.NullPointerException

 obtain z' and c' where emma subsdv_fsteq:
java.lang.NullPointerException
 moreover have " atom z ∉ rule: usig ubs Cns_eeqvt flipp_fresh_resh ug G_consfip by smp
 ultimately have **:"atom z ♯

 have "(c_of t z)[z::=V_var x] ∉
 also have "... = c'[z'::=V_var _f.simps z * by i
 finally show ?thesis using c_of.simps[of z' x "b_of t" c'] fresh_Pair z by metis
 

  type_eq_subst_eq1:
 fixes v::v and c1::c
 sumes "<lbrace z2 : b2 | c2 \<)"
 1::=v]_v = c2[z2::=v]_v" and "b1=b" d " c1 1 \leftrightarrow> z2) ∙= ((xa, b c[z:=V_var xa]\<^ubc
  show ?cas poof(ase"(x,'c)=(1b,c1"
java.lang.NullPointerException
 show "b1=b2" using τ
 have "z1 = z2 ∧ c1 = c2 ∨non‹
 using τc z2c] ssms blw v ==>
java.lang.NullPointerException
 

  type_eq_subst_eq2:
 fixes v::v and c1::c
 assumes "{ = ({ : b | c2 \rbrace)"
 shows "c1[z1::=v]_c\< subst_tv_graph_aux_def atom_o\Gamma'" using reshGCos
  -
 z1:v]\subc\^>v= c2[z2::=v\^b>c\^s>v" using type_eq_ubt ms by y bblast
 show "b1=b2" using τ.eq_iff hence "(x', b','x:v]<^>cv) \<in c_\<Gamma(Γ_{strong_exhaust})
 show "[[atom z1]]lst. c1 = [[atom z2]]lst. c2"
 using τ.eq_iff assms by auto
 

  type_eq_subst_eq3:
 fixes v::v and c1::c
 assumes "{ z1 : b1 | c1 } = ({ z2 : b2 | c2 })" and "atom z1 ♯ c2"
 shows "c1 = c2[z2::=V_var z1] fresh_star_def f fresh_at_bae)
 using type_eq_subst_eq1 assms subst_v_c_def
 by (metis subst_cv_var_flip)+

  type_eq_flip:
 assumes "atom x ♯
 shows "emmfre:
java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 by (metis (no_types, lifting) flip_fresh_fresh)java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

  c_of_true:
 "c_of {: "atomcb \<> v" and a8: za \<> 
 (nominal_induct "{ z' : B_bool | TRUE }
 case rinedtypp 1xa)
 hence "{by auto
 then show ?case using subst_cv.simps c_of.simps T_refined_type
 type_eq_subst_eq3
 by (metis type_eq_subst_eq)
 

  type_eq_subst:
 "atom x ♯
 shows "(((x', b', c') #\^Γ Γ)[::=v]_v @ G) = ((x', b', c'[x::=v]_v) #_'[x::=v]_v) @ G))"
 using τ.eq_iff Abs1_eq_iff assms
 using subst_cv_var_flip type_eq_flip by auto

  type_e_subst_fresh:
 fixes x::x and z::x
 assumes "atom z ♯ (x,v)" and "atom x ♯ e"
 shows "{ z : b | CE_val (V_var z) == e }[x::=v]_\τ_v = { z : b | CE_val (V_var z) == e }"
 using using assms subst_tv.simps subst_cv.simps forget_subst_cev by simp

  type_v_subst_fresh:
 fixes x::x and z::x
 assumes "atom z ♯ (x,v)" and "atom x ♯ v'"
 shows "{ a9a8a7 a6 a5a4 a3 a2 a1
 using assms subst_tv.simps subst_cv.simps by simp

  subst_tbase_eq:
java.lang.NullPointerException
  -
java.lang.NullPointerException
 by (metis prod.inject subst_tv.cases)
 hence "b_of { z:b|c} = b_of { z:b|c}[x::=v]_\τ_v" using subst_tv.simps by simp

 

  subst_tv_if:
 assumes "atom z1 ♯ (x,v)" and "atom z' ♯ (x,v)"
 shows "{ z1 : b | CE_val (v'[x::=v]_vv) == CE_val (V_lit l) IMP (c'[x::=v]_cv)[z'::=[z1]^v]_moreover have "cz::=V_var cb]_:=va]_sub>c\<^>vusing subst_cv_commute_full[of z va xa "V_var cb" ] assms fresh_def supp by fastforce
 { z1 : b | CE_val v' == CE_val (V_lit l) IMP c'[z'::=[z1]^v]_cv }[x::=v]_\τ_v"
 using subst_cv_commute_full[of z' v x "V_var z1" c'] subst_tv.simps subst_vv.simps(1) subst_ev.simps subst_cv.simps assms
 by simp

  subst_tv_tid:
 assumes "atom za ♯ (x,v)"
 shows "{ za : B_id tid | TRUE } = { za : B_id tid | TRUE }[x::=v]_\τ_v"
 using assms subst_tv.simps subst_cv.simps by presburger


  b_of_subst:
 "b_of (τ[x::=v]_\τ_v) = b_of τ"
  -
 obtain z b c where *:"τ = { moreover have "ca[za::=V_var cb]_[xa::=va]\<^>cc\^sub>v"
 thus ?thesis using subst_tv.simps * by auto
 

  subst_tv_flip:
 assumes "τ'[x::=v]_\τ_v = τ" and "atom x ♯ (v,τ)" and "atom x' ♯ (v,τ)"
 shows "((x' ↔ x) ∙ τ using subst_cv_commute_full[of za va xa "V_var cb" " ] assms fresh_def v.suppby fastf
  -
 have "(x' ↔ x) ∙ v = v ∧ (x' ↔ x) ∙
 thus ?thesis using subst_tv.eqvt[of "(x' ↔ x)" τ' x v ] assms by auto
 

  subst_cv_true:
 "{ z : B_id tid | TRUE } = { z : B_id tid | TRUE }[x::=v]_\τ_v"
  -
 obtain za::x where "atom za ♯ (x,v)" using obtain_fresh by auto
 hence "{ z : B_id tid | TRUE } = { lexicographic_orde
 moreover have "{ za : B_id tid | TRUE } = { za : B_id tid | TRUE }[x::=v]_\τ_v"
 using subst_cv.simps subst_tv.simps by (simp add: ‹atom za ♯
 ultimately show ?thesis by argo
 

 upp:
 assumes "({ z : b | c }) = ({ z1 : b1 | c1 })"
  "supp c - { atom z } = supp c1 - { atom z1 }"
  -
 have "supp c - { atom z } ∪ supp b = supp c1 - { atom z1 } ∪ supp b1" using τ.supp assms
 by (metis list.set(1) list.simps(15) sup_bot.right_neutral supp_b_empty)
 moreover have "supp b = supp b1 here
java.lang.NullPointerException
 ultimately show ?thesis
 by (metis τ.eq_iff τ.supp assms b.supp(1) list.set(1) list.set(2) sup_bot.right_neutral)
 

  fresh_t_eq:
 fixes x::x
 assumes "({ z : b | c }) = ({ zz : b | cc })" and "atom x ♯ c" and "x ≠
 shows "atom x ♯ cc"
  -
 have "supp c - { atom z } ∪ atom zz } ∪.suppassms
 by (metis list.set(1) list.simps(15) sup_bot.right_neutral supp_b_empty)
 moreover have "atom x ∉ supp c" using assms fresh_def by blast
 ultimately have "atom x ∉ supp cc - { atom zz } ∪ supp b" by force
 hence "atom x ∉ supp cc" using assms by simp
 thus ?thesis using fresh_def by auto
 

  ‹Mutable Variable Context› (nominal_induct A avoiding: i x rul: \<tau.

  subst_dv :: "Δ ==> x ==> v ==> Δ" where
 "subst_dv DNil x v = DNil"
  "subst_dv ((u,t) #_\Δ Δ) x v = ((u,t[x::=v]_\τ_v) # show ?c byauto
 apply (simp add: eqvt_def subst_dv_graph_aux_def,auto )
 using delete_aux.elims by (metis Δ.exhaust surj_pair)
  (eqvt) by lexicographic_order

 
 subst_dv_abbrev :: "Δ ==> x ==> v ==>
 where
 "Δ[x::=v]_\<Deltam A \Longrightarrow subst_tv Aa x = A"

  dmap :: "(u*τ ==> u*τ) ==> Δ ==> Δ" where
 dmap f DNil = DNil"
  "dmap f ((u,t)#_\ΔΔ) = (f (u,t) #_\Δ (dmap f Δ ))"
  add: eqvt_def ddm,auto ))
 using delete_aux.elims by (metis Δ.exhaust surj_pair)
  (eqvt) by lexicographic_order

  subst_dv_iff:
 "Δ[x::=v]_\Δ
 by(induct Δ, auto)

  size_subst_dv [simp]: "size ( subst_dv G i x) ≤simp]: a (V_var ) = A
 by (induct G,auto)

  forget_subst_dv [simp]: "atom a ♯ G ==> subst_dv G a x = G"
 apply (induct G ,auto)
 using uy (nominal_induct A avoidin: a rule: \<tau.s: fresh_at_base) 
 apply (simp add: fresh_DCons)+
 done

  subst_dv_member:
 assumes "(u,τ) ∈ setD Δ"
java.lang.NullPointerException
 using assms by(induct Δ rule: Δ_induct,auto)

  fresh_subst_dv:
 fixes x::x
 assumes "atom xa ♯ Δ" and "atom xa ♯j \ ♯ \\sharp>A ∧∨a> (j 🚫
 shows "atom xa ♯Δ[x::=v]_\Δ_v"
 using assms proof(induct Δ rule:Δ_induct)
 case DNil
 then show ?case by auto
 
 case (DCons u t Δ)
 then show ?case using subst_dv.simps subst_v_τ_def fresh_DCons fresh_Pair by simp
 

  fresh_subst_dv_if:
 fixes j::atom and i::x and x::v and t::Δ
 assumes "j ♯ t ∧ j ♯ x"
 shows "(j ♯ subst_dv t i x)"
 using assms proof(induct t rule: Δ_induct)
 case DNil
 then show ?case using subst_gv.simps fresh_GNil by auto
 
 case (DCons u' t' D')
 then show ?case unfolding subst_dv.simps using fresh_DCons fresh_subst_tv_if fresh_Pair by metis
 

  ‹ A avoiding: i x rule:: τ

  ‹ Using ideas from proofs at top of AFP/Launchbury/Substitution.thy.
 Subproofs borrowed from there; hence the apply style proofs. ›

  (default "case_sum (λx. Inl undefined) (case_sum (λx. Inl undefined) (λx. Inr undefined))")
 subst_sv :: "s ==> x ==> v ==> s"
 and subst_branchv :: "branch_s ==> x ==>
 and subst_branchlv :: "branch_list ==> x ==> v ==> branch_list" where
  ( (AS_val v') ) x v = (AS_val (subst_vv v' x v )"
  "atom y ♯ (x,v) ==> subst_sv (AS_let y e s) x v = (AS_let y (e[x::=v]_e"atom y ♯τx::= t]🚫_\^s>v_v"
  "atom y ♯ (x,v) ==> subst_sv (AS_let2 y t s1 s2) x v = (AS_let2 y (t[x::=v]_\τ_v) (subst_sv s1 x v ) (subst_sv s2 x v ))"
  " subst_sv (AS_match v' cs) x v = AS_match (v'[x::=v]_vv) (subst_branchlv cs x v )"
  "subst_sv (AS_assign y v') x v = AS_assign y (subst_vv v' x v )"
  "subst_sv ( (AS_if v' s1 s2) ) x v = (AS_if (subst_vv v' x v ) (subst_sv s1 x v ) (subst_sv s2 x v ) )"
  "atom u ♯ (x,v) ==> subst_sv (AS_var u τ v' s) x v = AS_var u (subst_tv τ x v ) (subst_vv v' x v ) (subst_sv s x v ) "
  "subst_sv (AS_while s1 s2) x v = AS_while (subst_sv s1 x v ) (subst_sv s2 x v )"
  "subst_sv (AS_seq s1 s2) x v = AS_seq (subst_sv s1 x v ) (subst_sv s2 x v )"
  "subst_sv (AS_assert c s) x v = AS_assert (subst_cv c x v) (subst_sv s x v)"
  "atom x1 ♯ (x,v) ==> subst_branchv (AS_branch dc x1 s1 ) x v = AS_branch dc x1 (subst_sv s1 x v )"

  "subst_branchlv (AS_final cs) x v = AS_final (subst_branchv cs x v )"
  "subst_branchlv (AS_cons cs css) x v = AS_cons (subst_branchv cs x v ) (subst_branchlv css x v )"
 apply (auto,simp add: eqvt_def subst_sv_subst_branchv_subst_branchlv_graph_aux_def )
 (goal_cases)

 eqvt_at_proj: "∧(s, s, xa, va)) 🚫
 eqvt_at (λa. projl (subst_sv_subst_branchv_subst_branchlv_sumC (Inl a))) (s, xa, va)"
 apply(simp add: eqvt_at_def)
 apply(rule)
 apply(subst Projl_permute)
 apply(thin_tac _)+
 apply (simp add: subst_sv_subst_branchv_subst_branchlv_sumC_def)
 apply (simp add: THE_default_def)
 apply (case_tac "Ex1 (subst_sv_subst_branchv_subst_branchlv_graph (Inl (s,xa,va)))")
 apply simp
 apply(auto)[1]
 apply (erule_tac x="x" in allE)
 apply simp
 apply(cases rule: subst_sv_subst_branchv_subst_branchlv_graph.cases)
 apply(assumption)
 apply(rule_tac x="Sum_Type.projl x" in exI,clarify,rule the1_equality,blast,simp (no_asm) only: sum.sel)+
 apply blast +

 apply(simp)+
 done

 {
 case (1 P x')
 then show ?case proof(cases x')
 case (Inl a) thus P
 proof(cases a)
 case (fields aa bb cc)
 thus P using Inl 1 s_branch_s_branch_list.strong_exhaust fresh_star_insert by metis
 qed
 next
 case (Inr b) thus P
 proof(cases b)
 case (Inl a) thus P proof(cases a)
 case (fields aa bb cc)
 then show ?thesis using Inr Inl 1 s_branch_s_branch_list.strong_exhaust fresh_star_insert by metis
 qed
 next
 case Inr2: (Inr b) thus P proof(cases b)
 case (fields aa bb cc)
  show ?thesis using Inr In1 s_branch_s_branch_list.strong_exhaust fresh_star_insert by metis
 qed
 qed
 qed
 next
 case (2 y s ya xa va sa c)
 thus ?case using eqvt_triple eqvt_at_proj by blast
 next
 case (3 y s2 ya xa va s1a s2a c)
 thus ?case using eqvt_triple eqvt_at_proj by blast
 next
 case (4 u xa va s ua sa c)
 moreover have "atom u ♯ "atom xa \notin> supp c - atom z }" using \tau>.supp[of z b c]fresh_def supp_b_em assms
 using fresh_Pair u_fresh_xv by auto
 ultimately show ?case using eqvt_triple[of u xa va ua s sa] subst_sv_def eqvt_at_proj by metis
 next
 case (5 x1 s1 x1a xa va s1a c)
 thus ?case using eqvt_triple eqvt_at_proj by blast
 }
 
  (eqvt) by lexicographic_order

 
 subst_sv_abbrev :: "s ==> x ==> v ==> s" (‹ xaf: "atom xa \<> 
 where
 "s[x::=v]_{sleftrightarrow}> xa) ∙>= 🚫

 
 subst_branchv_abbrev :: "branch_s ==> x ==> v ==> branch_s" (‹_[_::=_]_sv› [1000,50,50] 1000)
 where
 "s[x::=v]_sv ≡ subst_branchv s x v"

  size_subst_sv [simp]: "size (subst_sv A i x ) = size A" and "size (subst_branchv B i x ) = size B" and "size (subst_branchlv C i x ) = size C"
 by(nominal_induct A and B and C avoiding: i x rule: s_branch_s_branch_list.strong_induct,auto)

 forget_subst_sv [simp]: shows "atom a \A\Longrightarrow su A a x = A and atom a \sharp> B \Longrightarrow subst_branchv a = B" and "atom a ♯
 by (nominal_induct A and B and C avoiding: a x rule: s_branch_s_branch_list.strong_induct,auto simp: fresh_at_base)

  subst_sv_id [simp]: "subst_sv A a (V_var a) = A" and "subst_branchv B a (V_var a) = B" and "subst_branchlv C a (V_var a) = C"
 (nominal_induct A and B and C avoiding: a rule: s_branch_s_branch_list.strong_induct)
 case (AS_let x option e s)
 then show ?case
 by (metis (no_types, lifting) fresh_Pair not_None_eq subst_ev_id subst_sv.simps(2) subst_sv.simps(3) subst_tv_id v.fresh(2))
 
 case (AS_match v branch_s)
 then show ?case using fresh_Pair not_None_eq subst_ev_id subst_sv.simps subst_sv.simps subst_tv_id v.fresh subst_vv_id
 by metis
 (auto)+

  fresh_subst_sv_if_rl:
 shows
 "(atom x ♯ s ∧ j ♯ s) ∨ (j ♯ v ∧ (j ♯ s ∨ j = atom x)) ==> j ♯ (subst_sv s x v )" and
 "(atom x ♯ cs ∧ j ♯ cs) ∨ (j ♯ v ∧ (j ♯ cs ∨ j = atom x)) ==> j ♯ (subst_branchv cs x v)" and
 "(atom x ♯ css ∧ j ♯ css) ∨ (j ♯ v ∧ (j ♯ css ∨ j = atom x)) ==> j ♯ (subst_branchlv css x v )"
 apply(nominal_induct s and cs and css avoiding: v x rule: s_branch_s_branch_list.strong_induct)
 using pure_fresh by force+

  fresh_subst_sv_if_lr:
 shows "j ♯ (subst_sv s x v) ==> (atom x ♯ s finally show ?thesis using subst_tv.simps zbc
 "j ♯ (subst_branchv cs x v) ==> (atom x ♯
 "j ♯ (subst_branchlv css x v ) ==> (atom x ♯ css ∧ j ♯
 (nominal_induct s and cs and css avoiding: v x rule: s_branch_s_branch_list.strong_induct)
 case (AS_branch list x s )
 then show ?case using s_branch_s_branch_list.fresh fresh_Pair list.distinct(1) list.set_cases pure_fresh set_ConsD subst_branchv.simps by meti
 
 case (AS_let y e s')
 thus ?case proof(cases "atom x ♯ (AS_let y e s')")
 case True
 hence "subst_sv (AS_let y e s') x v = (AS_let y e s')" using forget_subst_sv by simp
 hence "j ♯ (AS_let y e s')" using AS_let by argo
 then show ?thesis using True by blast
 next
 case False
java.lang.NullPointerException
java.lang.NullPointerException
 by (simp add: fresh_None)
 then show ?thesis using AS_let fresh_None fresh_subst_ev_if list.discI list.set_cases s_branch_s_branch_list.fresh set_ConsD
 by metis
 qed
 
 case (AS_let2 y τ s1 s2)
 
 case True
 hence "subst_sv (AS_let2 y τ s1 s2) x v = (AS_let2 y τ s1 s2)" using forget_subst_sv by simp
 hence "j ♯ (AS_let2 y τ s1 s2)" using AS_let2 by argo
 then show ?thesis using True by blast
 next
 case False
 have "subst_sv (AS_let2 y τ s1 s2) x v = AS_let2 y (τ[x::=v]_\τ_v) (s1[x::=v]_sv) show "(j ♯sh t ∧t)∨ (j ♯"
 then show ?thesis using AS_let2
 fresh_subst_tv_if list.discI list.set_cases s_branch_s_branch_list.fresh(4) set_ConsD by auto
 qed
 (auto)+

  fresh_subst_sv_if[simp]:
 fixes x::x and v::v
 shows "j ♯ (subst_sv s x v) ⟷ (atom x ♯ s ∧ j ♯ s) ∨ (j ♯ v ∧ (j ♯ s ∨ j = atom x))" and
java.lang.StringIndexOutOfBoundsException: Index 149 out of bounds for length 0
 using fresh_subst_sv_if_lr fresh_subst_sv_if_rl by metis+

  subst_sv_commute [simp]:
 fixes A::s a case(T_refiz b c)
 shows "atom j ♯ A ==> (subst_sv (subst_sv A i t) j u ) = subst_sv A i (subst_vv t j u )" and
 atom j \ <sharpB= subst_bran su t j u )" and
 "atom j ♯ C ==> (subst_branchlv (subst_branchlv C i t) j u ) = subst_branchlv C i (subst_vv t j u ) "
 apply(nominal_induct A and B and C avoiding: i j t u rule: s_branch_s_branch_list.strong_induct)
 by(auto simp: fresh_at_base)

  c_eq_perm:
 assumes "( (atom z) ⇌ (atom z') ) ∙ c = c'" and "atom z' ♯ c"
 shows "{ z : b | c } = { z' : b | c' }"
 using τ.eq_iff Abs1_eq_iff(3)
 by (metis Nominal2_Base.swap_commute assms(1) assms(2) flip_def swap_fresh_fresh)

  subst_sv_flip:
 fixes s::s and sa::s and v'::v
 assumes "atom c ♯ (s, sa)" and "atom c ♯ (v',x, xa, s, sa)" "atom x ♯ v'" and "atom xa ♯ v'" and "(x ↔ c) ∙ s = (xa ↔ c) ∙ sa"
  "s[x::=v']<^>s
  -
 have "atom x ♯ (s[x::=v']_sv)" and xafr: "atom xa ♯ (sa[xa::=v']_sv)"
 and "atom c ♯ ( s[x::=v']_sv, sa[xa::=v']_sv)" using assms using fresh_subst_sv_if assms by( blast+ ,force)

 hence "s[x::=v']_sv = (x ↔ c) ∙ (s[x::=v']_sunfolding τ fresh_subst_v_if
 also have " ... = ((x ↔ c) ∙ s)[ ((x ↔ c) ∙ x) ::= ((x ↔ c) ∙ v') ]_sv" using subst_sv_subst_branchv_subst_branchlv.eqvt by blast
 also have "... = ((xa ↔ c) ∙ sa)[ ((x ↔ c) ∙ x) ::= ((x ↔ c) ∙ v') ]_sv" using assms by presburger
 also have "... = ((xa ↔ c) ∙
 by (metis flip_at_simps(1) flip_fresh_fresh fresh_PairD(1))
 also have "... = (xa ↔ c) ∙ (sa[xa::=v']_sv)" using subst_sv_subst_branchv_subst_branchlv.eqvt by presburger
java.lang.NullPointerException
 finally show ?thesis by simp
 

  if_type_eq:
 fixes Γ::Γ and v::v and z1::x
java.lang.NullPointerException
 and "atom z1 ♯ (za,ca)" and "atom z1' ♯ (za,ca)"
java.lang.NullPointerException
  -
 have "atom z1' ♯ (CE_val v == CE_val (V_lit ll) IMP ca[za::=[z1]^v]_cv )" using assms fresh_prod4 by blast
 moreover hence "(CE_val v == CE_val (V_lit ll) IMP ca[za::=[z1']^v]_cv) = (z1' ↔ z1) ∙ (CE_val v == CE_val (V_lit ll) IMP ca[za::=[z1]^v]_cv )"
 proof -
 have "(z1' ↔ z1) ∙ (CE_val v == CE_val (V_lit ll) IMP ca[za::=[z1]^v]_cv ) = ( (z1' ↔ z1) ∙ (CE_val v == CE_val (V_lit ll)) IMP ((z1' ↔ z1) ∙ ca[za::=[z1]^v]_cv ))"
 by auto
 also have "... = ((CE_val v == CE_val (V_lit ll)) IMP ((z1' ↔ z1) ∙ ca[za::=[z1]^v]_cv ))"
 using ‹atom z1 ♯ v› assms
 by (metis (mono_tags) ‹atom z1' ♯ (CE_val v == CE_val (V_lit ll) IMP ca[za::=[z1]^v]_cv )› c.fresh(6) c.fresh(7) ce
 also have "... = ((CE_val v == CE_val (V_lit ll)) IMP (ca[za::=[z1']^x r:τ
 using assms by fastforce
 finally show ?thesis by auto
 qed
 ultimately show ?thesis
 using τ.eq_iff Abs1_eq_iff(3)[of z1' "CE_val v == CE_val (V_lit ll) IMP ca[za::=[z1']^v]_cv"
 z1 "CE_val v == CE_val (V_lit ll) IMP ca[za::=[z1]^v] forsubst_t.simps subst_v_τ
 

  subst_sv_var_flip:
 fixes x::x and s::s and z::x
 shows "atom x ♯ s ==> ((x ↔ z) ∙
 "atom x ♯ cs \<Longrightarrowfix>
 "atom x ♯ css ==> ((x ↔ z) ∙ css) = subst_branchlv css z [x] (V_ a) tm"
 apply(nominal_induct s and cs and css avoiding: z x rule: s_branch_s_branch_list.strong_induct)
 using [[simproc del: alpha_lst]]
              apply (auto  ) (* This unpacks subst, perm *)
  using  subst_tv_var_flip  flip_fresh_fresh v.fresh s_branch_s_branch_list.fresh 
    \tau  subst_ev_var_flip   
     defer 1 (* Sometimes defering hard goals to the end makes it easier to finish *)
  using x_fresh_u   apply blast (* Next two involve u and flipping with x *)
    defer 1
  using x_fresh_u   apply blast
   defer 1
  using x_fresh_u Abs1_eq_iff'(3) flip_fresh_fresh 
   apply (simp add: subst_v_c_def)
  using x_fresh_u Abs1_eq_iff'(3) flip_fresh_fresh  
  bysimpadd)

instantiationhas_subst_v
begin

definition 
  "subst_v = subst_sv"

instance proof
  fix j::atom and i::x and  x::v and t::s
  show  "(j ♯ subst_v t i x) = ((atom i ♯ t ∧ j ♯ t) ∨ (j ♯ avoiding: a x ruav: a x r:\<tau.
    using fresh_subst_sv_if subst_v_s_def by auto

  fix a::x and tm::s and x::v
  om a ♯tm"
    using forget_subst_sv subst_v_s_def by simp

  fix a::x and tm::s
  show "subst_v tm a (V_var a) = tm" using subst_sv_id  subst_v_s_def by simp

fixperm:  v:  :s
  show "p ∙ subst_v t1 x1 v = subst_v (p ∙ t1) (p ∙ x1) (p ∙ v)" 
    usingsubst_v_s_def 

  fix x::x and c::s and z::x
  show "atom x ♯ c ==> ((x ↔ z) ∙apply(nominal_induct c avo z x :τ
    using subst_sv_var_flip subst_v_s_def by simp

z::x
  show "atom x ♯ c ==> c[z::=[x]java.lang.NullPointerException
    using subst_sv_var_flip subst_v_s_def byfixx:x andc::\tau  z:x
qed
end

section ‹Type Definition›

nominal_function subst_ft_v :: "fun_typ ==> x ==> v ==> fun_typ" where
  "atom z ♯ (x,v) ==> subst_ft_v ( AF_fun_typ z b c t (s::s)) x v = AF_fun_typ z b c[x::=v]_cv t[x::=v]_\< apply(nominal_ind c avoidin xv z rule:<>.s)
     apply(simp add: eqvt_def subst_ft_v_graph_aux_def )
    apply(simp aapply(simp add:fun_typ.strong_exhaust )
   apply(auto)
    apply(rule_tac y=a and c="(aa,b)" in fun_typ.strong_exhaust)
    apply (auto simp: eqvt_at_def fresh_star_def fresh_Pair fresh_at_base)

proof(goal_cases)
  case (1 z xa va c t s za ca ta sa cb)
  hence "c[z::=[ cb ]^v]_cv = ca[za::=[ cb ]java.lang.NullPointerException
    by (metis flip_commute subst_cv_var_flip)
  hencejava.lang.NullPointerException
  then show ?case using subst_cv_commute atom_eq_iff fresh_atom fresh_atom_at_base subst_cv_commute_full v.fresh
    using 1 subst_cv_var_flip flip_commute by metis
next
  case (2 z xa va c t s za ca ta sa cb)
  hence "t[z::=[ cb ]^v]_\<tau>_v = ta[za::=[ cb ]^v]_\<tau>_v" by metis
  hence "t[z::=[ cb ]^v]_\<tau>_v[xa::=va]_\<tau>_v = ta[za::=[ cb ]^v]_\<tau>_v[xa::=va]_\<tau>_v" by auto
  then show ?case using subst_tv_commute_full 2
    by (metis atom_eq_iff fresh_atom fresh_atom_at_base v.fresh(2))
qed

nominal_termination (eqvt) by lexicographic_order

nominal_function subst_ftq_v :: "fun_typ_q ==> x ==> v ==> fun_typ_q" where
  "atom bv ♯ (x,v) ==> subst_ftq_v (AF_fun_typ_some bv ft) x v = (AF_fun_typ_someassumesvand\sharp  noteqz"
| "subst_ftq_v (AF_fun_typ_none  ft) x v = (AF_fun_typ_none (subst_ft_v ft x v))"
       apply(simp add: eqvt_def subst_ftq_v_graph_aux_def )
      shows "c[z::]<sub\tau^>)x:v\^><><v  cx:v_tau<sub 
     apply(auto) 
   apply(rule_tac y=a and c="(aa,b)" in fun_typ_q.strong_exhaust)
    apply (auto simp: eqvt_at_def fresh_star_def fresh_Pair fresh_at_base)
proof(goal_cases)
  case (1 bv ft bva fta xa va c)
  then show ?case using subst_ft_v.simps  by (simp add: flip_fresh_fresh)
qed
nominal_termination (eqvt) by lexicographic_order

lemma size_subst_ft[simp]:  "size (subst_ft_v A x v) = size A" 
  by(nominal_induct A  avoiding: x v rule: fun_typ.strong_inductassmsproof cavoiding: x v z w rule: τ.strong_induct)

lemma forget_subst_ft [simp]: shows  "atom x ♯ A ==>case (T_refined_type x1a x2a x3a)
  by (nominal_induct A avoiding: a x rule: fun_typ.strong_induct,auto simp: fresh_at_base)

lemma subst_ft_id [simp]: "subst_ft_v A a (V_var a)  = A"
  by(nominal_induct A avoiding: a rule: fun_typ.strong_induct,auto)

instantiation fun_typ :: has_subst_v
begin

definition
  "subst_v:

instance proof

  fix j::atom and i::x and  x::v and t::fun_typ
  show(\sharptix =((atom <>t\and  <sharp <>( <>x \and>( <>t\or    ))"
    apply(nominal_induct t avoiding: i x rule:fun_typ.strong_induct)
    apply(simp only: subst_v_fun_typ_def subst_ft_v.simps )
    using fun_typ.fresh fresh_subst_v_if apply simp
    by auto

  fix a::x and tm::fun_typ and x::v
  show "atom a ♯ tm ==> subst_v tm a x  = tm"
  proof(nominal_induct tm avoiding: a x rule:fun_typ.strong_induct)
    case (AF_fun_typ x1a x2a x3a x4a x5a)
    then show ?case unfolding subst_ft_v.simps subst_v_fun_typ_def fun_typ.fresh using forget_subst_v subst_ft_v.simps subst_v_c_def forget_subst_sv subst_v_τ_def by fastforce
  qed

  fix a::x and tm::fun_typ
  show "subst_v tm a (V_var a) = tm"
  proof(nominal_induct tm avoiding: a x rule:fun_typ.strong_induct)
    case (AF_fun_typ x1a x2a x3a x4a x5a)
    then show ?caunfolding subst_ft_.simps sub fun_typ.f us forget_su.simps substv_c_ef fo subst_v\def by fas
  qed

  fix p::perm and x1::x and v::v and t1::fun_typ
  show "p ∙ subst_v t1 x1 v  = subst_v  
  proof(nominal_induct t1 avoiding: x1 v rule:fun_typ.strong_induct)
    case(AF_fun_typx2a x4a)
    then show ?case unfolding subst_ft_v.simps subst_v_fun_typ_def fun_typ.fresh  using forget_subst_v subst_ft_v.simps subst_v_c_def forget_subst_sv subst_v_\meanalphaequivalent answers>
  qed

  fix x::x and c::fun_typ and z::x
  show"  <> c ==>>( \leftrightarrow)\bullet )=cz:[x]\^sup\^>"
    apply(nominal_induct c avoiding: x z rule:fun_typ.strong_induct)
    by (auto simp add: subst_v_c_def subst_v_s_def subst_v_τ_def subst_v_fun_typ_def)

  fix x::x and c::fun_typ and z::x
  show "atom x ♯ c ==> c[z::=[x]^v]_v[x::=v]_v = c[z::=v]_v"
    apply(nominal_induct c avoiding: z x v rule:fun_typ.strong_induct)
    apply auto
    by auto sa: subst_v subs sub\tau_def ubst_v_fun_typ_def )
qed
end

instantiation fun_typ_q :: has_subst_v
begin

definition
  "subst_v = subst_ftq_v"

instance proof
  fix j::atom and i::x and x::v and t::fun_typ_q
  show "(j ♯ subst_v t i x) = ((atom i ♯
    apply(nominal_induct t avoiding: i x rule:fun_typ_q.strong_induct,auto)
                   apply(auto    (  x)
    by    x1:τ::x where*:"x = (x1,x2)" 

  fix i::x and t::fun_typ_q and x::v

    apply(nominal_induct t avoiding: i x rule:fun_typ_q.strong_induct,auto)
    by(auto simp add: subst_v_fun_typ_def subst_v_s_def subst_v_τ_def subst_v_fun_typ_q_def fresh_subst_v_if )    

  fix i::x and t::fun_typ_q
  show "subst_v t i (V_var i) = t" using subst_cv_id  subst_v_fun_typ_def  
    apply(nominal_induct t avoiding: i x rule:fun_typ_q.strong_induct,auto)
    (  add subst_v_s_defsubst_v_<>defsubst_v_fun_typ_q_def )

  fix p::perm and x1::x and v::v and t1::fun_typ_q
  show "p ∙ subst_v t1 x1 v next
    apply(nominal_induct t1 avoiding: v x1 rule:fun_typ_q.strong_induct,auto)
    by(auto simp add: subst_v_fun_typ_def subst_v_s_def subst_v_τ_def subst_v_fun_typ_q_def fresh_subst_v_if )

  fix x::x and c::fun_typ_q and z::x
  show "atom x ♯ c ==> ((x ↔ z) ∙
    apply(nominal_induct c avoiding: x z rule:fun_typ_q.strong_induct,auto)
    by(auto simp add: subst_v_fun_typ_def subst_v_s_def subst_v_τ_def subst_v_fun_typ_q_def

  fix x::x and c::fun_typ_q and z::x
  show  "tom x \sharp c \<> 
    apply(nominal_induct c avoiding: z x v rule:fun_typ_q.strong_induct,auto)
     apply(auto simp add: subst_v_fun_typ_def subst_v_s_def subst_v_τ_def subst_v_fun_typ_q_def fresh_subst_v_if )
    by (metis subst_v_fun_typ_def flip_bv_x_cancel subst_ft_v.eqvt subst_v_simple_commute v.perm_simps )+
qed

end

section ‹Variable Context›

lemma subst_dv_fst_eq:
  "fst ` setD (Δ[x::=v]<sub>\</sub><Delta><sub>v</sub>) = fst ` setD Δ"
  by(induct Δ rule: Δ_induct,simp,force)

lemma subst_gv_member_iff:
  fixes x'::x and x::x and v::v and c'::c
  assumes "x, <>toSet " xx <> to\Gamma"
  shows "(x',b',c'[x::=v]_cv) ∈ toSet Γ[x::=v]_\<Gamma>_v"
proof -
  have "x' ≠ x" using assms fresh_dom_free2 by metis
  then show ?thesis  using assms proof(induct Γ rule: Γ_induct)
    case GNil
    then show ?case by auto
  next
    case (GCons x1 b1 c1 Γ')
    show ?case proof(cases "(x',b',c') = (x1,b1,c1)")
       
      hence "((x1, b1, c1) #_\<Gamma> Γ')[x::=v]_\<Gamma>_v = ((x1, b1, c1[x::=v]_cv) #_\<Gamma> (Γ'[x::=v]_\<Gamma>\< moreover T_refined Abs1_eq_iff flip_subst_v su
      then show ?thesis using True by auto
    next
      case False
      have "x1≠x" using fresh_def fresh_GCons fresh_Pair supp_at_base GCons fresh_dom_free2 by auto
      hence "(x', b', c') ∈ toSet Γ'" using GCons False toSet.simps by auto
       hav "x<> <>"using fresh_GCo G .si toSet.sim by simp
      ultimately have "(x', b', c'[x::=v]_cv) ∈ toSet Γ'[x::=v]_\<Gamma>java.lang.NullPointerException
      hence:
      then show ?thesis using subst_gv.simps ‹x1≠x› by auto
    qed
  qed
qed

lemma fresh_subst_gv_if:
  fixes j::atom and i::x and  x::v and t::Γ
  assumes "j ♯ t ∧ j ♯ -
  shows "(j ♯ subst_gv   z and c where "atom z ♯t \and τ: b_of τ}
  using assms proof(induct t rule: Γ_induct)
  case GNil
  then show ?case using subst_gv.simps fresh_GNil by auto
next
  case (GCons x' b' c' Γ')
  then show ?case unfolding subst_gv.simps using fresh_GCons fresh_subst_cv_if by auto
qed

section ‹Lookup›

lemma set_GConsD: "y ∈ toSet (x #_\<using byauto
  by auto

lemmajava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  assumesx\noteq
  shows "(((x', b', c') #_\<Gamma> Γ')[x::=v]_\<Gamma>_v @ G)
  using subst_gv.simps append_g.simps assms by auto

end