diff --git a/thys/Goedel_HFSet_Semanticless/Coding.thy b/thys/Goedel_HFSet_Semanticless/Coding.thy
--- a/thys/Goedel_HFSet_Semanticless/Coding.thy
+++ b/thys/Goedel_HFSet_Semanticless/Coding.thy
@@ -1,681 +1,681 @@
 chapter\<open>De Bruijn Syntax, Quotations, Codes, V-Codes\<close>
 
 theory Coding
 imports SyntaxN
 begin
 
 declare fresh_Nil [iff]
 
 section \<open>de Bruijn Indices (locally-nameless version)\<close>
 
 nominal_datatype dbtm = DBZero | DBVar name | DBInd nat | DBEats dbtm dbtm
 
 nominal_datatype dbfm =
     DBMem dbtm dbtm
   | DBEq dbtm dbtm
   | DBDisj dbfm dbfm
   | DBNeg dbfm
   | DBEx dbfm
 
 declare dbtm.supp [simp]
 declare dbfm.supp [simp]
 
 fun lookup :: "name list \<Rightarrow> nat \<Rightarrow> name \<Rightarrow> dbtm"
   where
     "lookup [] n x = DBVar x"
   | "lookup (y # ys) n x = (if x = y then DBInd n else (lookup ys (Suc n) x))"
 
 lemma fresh_imp_notin_env: "atom name \<sharp> e \<Longrightarrow> name \<notin> set e"
   by (metis List.finite_set fresh_finite_set_at_base fresh_set)
 
 lemma lookup_notin: "x \<notin> set e \<Longrightarrow> lookup e n x = DBVar x"
   by (induct e arbitrary: n) auto
 
 lemma lookup_in:
   "x \<in> set e \<Longrightarrow> \<exists>k. lookup e n x = DBInd k \<and> n \<le> k \<and> k < n + length e"
 apply (induct e arbitrary: n)
 apply (auto intro: Suc_leD)
 apply (metis Suc_leD add_Suc_right add_Suc_shift)
 done
 
 lemma lookup_fresh: "x \<sharp> lookup e n y \<longleftrightarrow> y \<in> set e \<or> x \<noteq> atom y"
   by (induct arbitrary: n rule: lookup.induct) (auto simp: pure_fresh fresh_at_base)
 
 lemma lookup_eqvt[eqvt]: "(p \<bullet> lookup xs n x) = lookup (p \<bullet> xs) (p \<bullet> n) (p \<bullet> x)"
   by (induct xs arbitrary: n) (simp_all add: permute_pure)
 
 lemma lookup_inject [iff]: "(lookup e n x = lookup e n y) \<longleftrightarrow> x = y"
 apply (induct e n x arbitrary: y rule: lookup.induct, force, simp)
 by (metis Suc_n_not_le_n dbtm.distinct(7) dbtm.eq_iff(3) lookup_in lookup_notin)
 
 nominal_function trans_tm :: "name list \<Rightarrow> tm \<Rightarrow> dbtm"
   where
    "trans_tm e Zero = DBZero"
  | "trans_tm e (Var k) = lookup e 0 k"
  | "trans_tm e (Eats t u) = DBEats (trans_tm e t) (trans_tm e u)"
 by (auto simp: eqvt_def trans_tm_graph_aux_def) (metis tm.strong_exhaust)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma fresh_trans_tm_iff [simp]: "i \<sharp> trans_tm e t \<longleftrightarrow> i \<sharp> t \<or> i \<in> atom ` set e"
   by (induct t rule: tm.induct, auto simp: lookup_fresh fresh_at_base)
 
 lemma trans_tm_forget: "atom i \<sharp> t \<Longrightarrow> trans_tm [i] t = trans_tm [] t"
   by (induct t rule: tm.induct, auto simp: fresh_Pair)
 
 nominal_function (invariant "\<lambda>(xs, _) y. atom ` set xs \<sharp>* y")
   trans_fm :: "name list \<Rightarrow> fm \<Rightarrow> dbfm"
   where
    "trans_fm e (Mem t u) = DBMem (trans_tm e t) (trans_tm e u)"
  | "trans_fm e (Eq t u)  = DBEq (trans_tm e t) (trans_tm e u)"
  | "trans_fm e (Disj A B) = DBDisj (trans_fm e A) (trans_fm e B)"
  | "trans_fm e (Neg A)   = DBNeg (trans_fm e A)"
  | "atom k \<sharp> e \<Longrightarrow> trans_fm e (Ex k A) = DBEx (trans_fm (k#e) A)"
 apply(simp add: eqvt_def trans_fm_graph_aux_def)
 apply(erule trans_fm_graph.induct)
 using [[simproc del: alpha_lst]]
 apply(auto simp: fresh_star_def)
 apply(rule_tac y=b and c=a in fm.strong_exhaust)
 apply(auto simp: fresh_star_def)
 apply(erule_tac c=ea in Abs_lst1_fcb2')
 apply (simp_all add: eqvt_at_def)
 apply (simp_all add: fresh_star_Pair perm_supp_eq)
 apply (simp add: fresh_star_def)
 done
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma fresh_trans_fm [simp]: "i \<sharp> trans_fm e A \<longleftrightarrow> i \<sharp> A \<or> i \<in> atom ` set e"
   by (nominal_induct A avoiding: e rule: fm.strong_induct, auto simp: fresh_at_base)
 
 abbreviation DBConj :: "dbfm \<Rightarrow> dbfm \<Rightarrow> dbfm"
   where "DBConj t u \<equiv> DBNeg (DBDisj (DBNeg t) (DBNeg u))"
 
 lemma trans_fm_Conj [simp]: "trans_fm e (Conj A B) = DBConj (trans_fm e A) (trans_fm e B)"
   by (simp add: Conj_def)
 
 lemma trans_tm_inject [iff]: "(trans_tm e t = trans_tm e u) \<longleftrightarrow> t = u"
 proof (induct t arbitrary: e u rule: tm.induct)
   case Zero show ?case
     apply (cases u rule: tm.exhaust, auto)
     apply (metis dbtm.distinct(1) dbtm.distinct(3) lookup_in lookup_notin)
     done
 next
   case (Var i) show ?case
     apply (cases u rule: tm.exhaust, auto)
     apply (metis dbtm.distinct(1) dbtm.distinct(3) lookup_in lookup_notin)
     apply (metis dbtm.distinct(10) dbtm.distinct(11) lookup_in lookup_notin)
     done
 next
   case (Eats tm1 tm2) thus ?case
     apply (cases u rule: tm.exhaust, auto)
     apply (metis dbtm.distinct(12) dbtm.distinct(9) lookup_in lookup_notin)
     done
 qed
 
 lemma trans_fm_inject [iff]: "(trans_fm e A = trans_fm e B) \<longleftrightarrow> A = B"
 proof (nominal_induct A avoiding: e B rule: fm.strong_induct)
   case (Mem tm1 tm2) thus ?case
     by (rule fm.strong_exhaust [where y=B and c=e]) (auto simp: fresh_star_def)
 next
   case (Eq tm1 tm2) thus ?case
     by (rule fm.strong_exhaust [where y=B and c=e]) (auto simp: fresh_star_def)
 next
   case (Disj fm1 fm2) show ?case
     by (rule fm.strong_exhaust [where y=B and c=e]) (auto simp: Disj fresh_star_def)
 next
   case (Neg fm) show ?case
     by (rule fm.strong_exhaust [where y=B and c=e]) (auto simp: Neg fresh_star_def)
 next
   case (Ex name fm)
   thus ?case  using [[simproc del: alpha_lst]]
   proof (cases rule: fm.strong_exhaust [where y=B and c="(e, name)"], simp_all add: fresh_star_def)
     fix name'::name and fm'::fm
     assume name': "atom name' \<sharp> (e, name)"
     assume "atom name \<sharp> fm' \<or> name = name'"
     thus "(trans_fm (name # e) fm = trans_fm (name' # e) fm') = ([[atom name]]lst. fm = [[atom name']]lst. fm')"
          (is "?lhs = ?rhs")
     proof (rule disjE)
       assume "name = name'"
       thus "?lhs = ?rhs"
         by (metis fresh_Pair fresh_at_base(2) name')
     next
       assume name: "atom name \<sharp> fm'"
       have eq1: "(name \<leftrightarrow> name') \<bullet> trans_fm (name' # e) fm' = trans_fm (name' # e) fm'"
         by (simp add: flip_fresh_fresh name)
       have eq2: "(name \<leftrightarrow> name') \<bullet> ([[atom name']]lst. fm') = [[atom name']]lst. fm'"
         by (rule flip_fresh_fresh) (auto simp: Abs_fresh_iff name)
       show "?lhs = ?rhs" using name' eq1 eq2 Ex(1) Ex(3) [of "name#e" "(name \<leftrightarrow> name') \<bullet> fm'"]
         by (simp add: flip_fresh_fresh) (metis Abs1_eq(3))
     qed
   qed
 qed
 
 lemma trans_fm_perm:
   assumes c: "atom c \<sharp> (i,j,A,B)"
   and     t: "trans_fm [i] A = trans_fm [j] B"
   shows "(i \<leftrightarrow> c) \<bullet> A = (j \<leftrightarrow> c) \<bullet> B"
 proof -
   have c_fresh1: "atom c \<sharp> trans_fm [i] A"
     using c by (auto simp: supp_Pair)
   moreover
   have i_fresh: "atom i \<sharp> trans_fm [i] A"
     by auto
   moreover
   have c_fresh2: "atom c \<sharp> trans_fm [j] B"
     using c by (auto simp: supp_Pair)
   moreover
   have j_fresh: "atom j \<sharp> trans_fm [j] B"
     by auto
   ultimately have "((i \<leftrightarrow> c) \<bullet> (trans_fm [i] A)) = ((j \<leftrightarrow> c) \<bullet> trans_fm [j] B)"
     by (simp only: flip_fresh_fresh t)
   then have "trans_fm [c] ((i \<leftrightarrow> c) \<bullet> A) = trans_fm [c] ((j \<leftrightarrow> c) \<bullet> B)"
     by simp
   then show "(i \<leftrightarrow> c) \<bullet> A = (j \<leftrightarrow> c) \<bullet> B" by simp
 qed
 
 section\<open>Characterising the Well-Formed de Bruijn Formulas\<close>
 
 subsection\<open>Well-Formed Terms\<close>
 
 inductive wf_dbtm :: "dbtm \<Rightarrow> bool"
   where
     Zero:  "wf_dbtm DBZero"
   | Var:   "wf_dbtm (DBVar name)"
   | Eats:  "wf_dbtm t1 \<Longrightarrow> wf_dbtm t2 \<Longrightarrow> wf_dbtm (DBEats t1 t2)"
 
 equivariance wf_dbtm
 
 inductive_cases Zero_wf_dbtm [elim!]: "wf_dbtm DBZero"
 inductive_cases Var_wf_dbtm [elim!]:  "wf_dbtm (DBVar name)"
 inductive_cases Ind_wf_dbtm [elim!]:  "wf_dbtm (DBInd i)"
 inductive_cases Eats_wf_dbtm [elim!]: "wf_dbtm (DBEats t1 t2)"
 
 declare wf_dbtm.intros [intro]
 
 lemma wf_dbtm_imp_is_tm:
   assumes "wf_dbtm x"
   shows "\<exists>t::tm. x = trans_tm [] t"
 using assms
 proof (induct rule: wf_dbtm.induct)
   case Zero thus ?case
     by (metis trans_tm.simps(1))
 next
   case (Var i) thus ?case
     by (metis lookup.simps(1) trans_tm.simps(2))
 next
   case (Eats dt1 dt2) thus ?case
     by (metis trans_tm.simps(3))
 qed
 
 lemma wf_dbtm_trans_tm: "wf_dbtm (trans_tm [] t)"
   by (induct t rule: tm.induct) auto
 
 theorem wf_dbtm_iff_is_tm: "wf_dbtm x \<longleftrightarrow> (\<exists>t::tm. x = trans_tm [] t)"
   by (metis wf_dbtm_imp_is_tm wf_dbtm_trans_tm)
 
 nominal_function abst_dbtm :: "name \<Rightarrow> nat \<Rightarrow> dbtm \<Rightarrow> dbtm"
   where
    "abst_dbtm name i DBZero = DBZero"
  | "abst_dbtm name i (DBVar name') = (if name = name' then DBInd i else DBVar name')"
  | "abst_dbtm name i (DBInd j) = DBInd j"
  | "abst_dbtm name i (DBEats t1 t2) = DBEats (abst_dbtm name i t1) (abst_dbtm name i t2)"
 apply (simp add: eqvt_def abst_dbtm_graph_aux_def, auto)
 apply (metis dbtm.exhaust)
 done
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 nominal_function subst_dbtm :: "dbtm \<Rightarrow> name \<Rightarrow> dbtm \<Rightarrow> dbtm"
   where
    "subst_dbtm u i DBZero = DBZero"
  | "subst_dbtm u i (DBVar name) = (if i = name then u else DBVar name)"
  | "subst_dbtm u i (DBInd j) = DBInd j"
  | "subst_dbtm u i (DBEats t1 t2) = DBEats (subst_dbtm u i t1) (subst_dbtm u i t2)"
 by (auto simp: eqvt_def subst_dbtm_graph_aux_def) (metis dbtm.exhaust)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma fresh_iff_non_subst_dbtm: "subst_dbtm DBZero i t = t \<longleftrightarrow> atom i \<sharp> t"
   by (induct t rule: dbtm.induct) (auto simp: pure_fresh fresh_at_base(2))
 
 lemma lookup_append: "lookup (e @ [i]) n j = abst_dbtm i (length e + n) (lookup e n j)"
   by (induct e arbitrary: n) (auto simp: fresh_Cons)
 
 lemma trans_tm_abs: "trans_tm (e@[name]) t = abst_dbtm name (length e) (trans_tm e t)"
   by (induct t rule: tm.induct) (auto simp: lookup_notin lookup_append)
 
 subsection\<open>Well-Formed Formulas\<close>
 
 nominal_function abst_dbfm :: "name \<Rightarrow> nat \<Rightarrow> dbfm \<Rightarrow> dbfm"
   where
    "abst_dbfm name i (DBMem t1 t2) = DBMem (abst_dbtm name i t1) (abst_dbtm name i t2)"
  | "abst_dbfm name i (DBEq t1 t2) =  DBEq (abst_dbtm name i t1) (abst_dbtm name i t2)"
  | "abst_dbfm name i (DBDisj A1 A2) = DBDisj (abst_dbfm name i A1) (abst_dbfm name i A2)"
  | "abst_dbfm name i (DBNeg A) = DBNeg (abst_dbfm name i A)"
  | "abst_dbfm name i (DBEx A) = DBEx (abst_dbfm name (i+1) A)"
 apply (simp add: eqvt_def abst_dbfm_graph_aux_def, auto)
 apply (metis dbfm.exhaust)
 done
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 nominal_function subst_dbfm :: "dbtm \<Rightarrow> name \<Rightarrow> dbfm \<Rightarrow> dbfm"
   where
    "subst_dbfm u i (DBMem t1 t2) = DBMem (subst_dbtm u i t1) (subst_dbtm u i t2)"
  | "subst_dbfm u i (DBEq t1 t2) =  DBEq (subst_dbtm u i t1) (subst_dbtm u i t2)"
  | "subst_dbfm u i (DBDisj A1 A2) = DBDisj (subst_dbfm u i A1) (subst_dbfm u i A2)"
  | "subst_dbfm u i (DBNeg A) = DBNeg (subst_dbfm u i A)"
  | "subst_dbfm u i (DBEx A) = DBEx (subst_dbfm u i A)"
 by (auto simp: eqvt_def subst_dbfm_graph_aux_def) (metis dbfm.exhaust)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma fresh_iff_non_subst_dbfm: "subst_dbfm DBZero i t = t \<longleftrightarrow> atom i \<sharp> t"
   by (induct t rule: dbfm.induct) (auto simp: fresh_iff_non_subst_dbtm)
 
 
 section\<open>Well formed terms and formulas (de Bruijn representation)\<close>
 
 inductive wf_dbfm :: "dbfm \<Rightarrow> bool"
   where
     Mem:   "wf_dbtm t1 \<Longrightarrow> wf_dbtm t2 \<Longrightarrow> wf_dbfm (DBMem t1 t2)"
   | Eq:    "wf_dbtm t1 \<Longrightarrow> wf_dbtm t2 \<Longrightarrow> wf_dbfm (DBEq t1 t2)"
   | Disj:  "wf_dbfm A1 \<Longrightarrow> wf_dbfm A2 \<Longrightarrow> wf_dbfm (DBDisj A1 A2)"
   | Neg:   "wf_dbfm A \<Longrightarrow> wf_dbfm (DBNeg A)"
   | Ex:    "wf_dbfm A \<Longrightarrow> wf_dbfm (DBEx (abst_dbfm name 0 A))"
 
 equivariance wf_dbfm
 
 lemma atom_fresh_abst_dbtm [simp]: "atom i \<sharp> abst_dbtm i n t"
   by (induct t rule: dbtm.induct) (auto simp: pure_fresh)
 
 lemma atom_fresh_abst_dbfm [simp]: "atom i \<sharp> abst_dbfm i n A"
   by (nominal_induct A arbitrary: n rule: dbfm.strong_induct) auto
 
 text\<open>Setting up strong induction: "avoiding" for name. Necessary to allow some proofs to go through\<close>
 nominal_inductive wf_dbfm
   avoids Ex: name
   by (auto simp: fresh_star_def)
 
 inductive_cases Mem_wf_dbfm [elim!]:  "wf_dbfm (DBMem t1 t2)"
 inductive_cases Eq_wf_dbfm [elim!]:   "wf_dbfm (DBEq t1 t2)"
 inductive_cases Disj_wf_dbfm [elim!]: "wf_dbfm (DBDisj A1 A2)"
 inductive_cases Neg_wf_dbfm [elim!]:  "wf_dbfm (DBNeg A)"
 inductive_cases Ex_wf_dbfm [elim!]:   "wf_dbfm (DBEx z)"
 
 declare wf_dbfm.intros [intro]
 
 lemma trans_fm_abs: "trans_fm (e@[name]) A = abst_dbfm name (length e) (trans_fm e A)"
   apply (nominal_induct A avoiding: name e rule: fm.strong_induct)
   apply (auto simp: trans_tm_abs fresh_Cons fresh_append)
   apply (metis One_nat_def Suc_eq_plus1 append_Cons list.size(4))
   done
 
 lemma abst_trans_fm: "abst_dbfm name 0 (trans_fm [] A) = trans_fm [name] A"
   by (metis append_Nil list.size(3) trans_fm_abs)
 
 lemma abst_trans_fm2: "i \<noteq> j \<Longrightarrow> abst_dbfm i (Suc 0) (trans_fm [j] A) = trans_fm [j,i] A"
   using trans_fm_abs [where e="[j]" and name=i]
   by auto
 
 lemma wf_dbfm_imp_is_fm:
   assumes "wf_dbfm x" shows "\<exists>A::fm. x = trans_fm [] A"
 using assms
 proof (induct rule: wf_dbfm.induct)
   case (Mem t1 t2) thus ?case
     by (metis trans_fm.simps(1) wf_dbtm_imp_is_tm)
 next
   case (Eq t1 t2) thus ?case
     by (metis trans_fm.simps(2) wf_dbtm_imp_is_tm)
 next
   case (Disj fm1 fm2) thus ?case
     by (metis trans_fm.simps(3))
 next
   case (Neg fm) thus ?case
     by (metis trans_fm.simps(4))
 next
   case (Ex fm name) thus ?case
     apply auto
     apply (rule_tac x="Ex name A" in exI)
     apply (auto simp: abst_trans_fm)
     done
 qed
 
 lemma wf_dbfm_trans_fm: "wf_dbfm (trans_fm [] A)"
   apply (nominal_induct A rule: fm.strong_induct)
   apply (auto simp: wf_dbtm_trans_tm abst_trans_fm)
   apply (metis abst_trans_fm wf_dbfm.Ex)
   done
 
 lemma wf_dbfm_iff_is_fm: "wf_dbfm x \<longleftrightarrow> (\<exists>A::fm. x = trans_fm [] A)"
   by (metis wf_dbfm_imp_is_fm wf_dbfm_trans_fm)
 
 lemma dbtm_abst_ignore [simp]:
   "abst_dbtm name i (abst_dbtm name j t) = abst_dbtm name j t"
   by (induct t rule: dbtm.induct) auto
 
 lemma abst_dbtm_fresh_ignore [simp]: "atom name \<sharp> u \<Longrightarrow> abst_dbtm name j u = u"
   by (induct u rule: dbtm.induct) auto
 
 lemma dbtm_subst_ignore [simp]:
   "subst_dbtm u name (abst_dbtm name j t) = abst_dbtm name j t"
   by (induct t rule: dbtm.induct) auto
 
 lemma dbtm_abst_swap_subst:
   "name \<noteq> name' \<Longrightarrow> atom name' \<sharp> u \<Longrightarrow>
    subst_dbtm u name (abst_dbtm name' j t) = abst_dbtm name' j (subst_dbtm u name t)"
   by (induct t rule: dbtm.induct) auto
 
 lemma dbfm_abst_swap_subst:
   "name \<noteq> name' \<Longrightarrow> atom name' \<sharp> u \<Longrightarrow>
    subst_dbfm u name (abst_dbfm name' j A) = abst_dbfm name' j (subst_dbfm u name A)"
   by (induct A arbitrary: j rule: dbfm.induct) (auto simp: dbtm_abst_swap_subst)
 
 lemma subst_trans_commute [simp]:
   "atom i \<sharp> e \<Longrightarrow> subst_dbtm (trans_tm e u) i (trans_tm e t) = trans_tm e (subst i u t)"
   apply (induct t rule: tm.induct)
   apply (auto simp: lookup_notin fresh_imp_notin_env)
   apply (metis abst_dbtm_fresh_ignore dbtm_subst_ignore lookup_fresh lookup_notin subst_dbtm.simps(2))
   done
 
 lemma subst_fm_trans_commute [simp]:
   "subst_dbfm (trans_tm [] u) name (trans_fm [] A) = trans_fm [] (A (name::= u))"
   apply (nominal_induct A avoiding: name u rule: fm.strong_induct)
   apply (auto simp: lookup_notin abst_trans_fm [symmetric])
   apply (metis dbfm_abst_swap_subst fresh_at_base(2) fresh_trans_tm_iff)
   done
 
 lemma subst_fm_trans_commute_eq:
   "du = trans_tm [] u \<Longrightarrow> subst_dbfm du i (trans_fm [] A) = trans_fm [] (A(i::=u))"
   by (metis subst_fm_trans_commute)
 
 
 section\<open>Quotations\<close>
 
 fun HTuple :: "nat \<Rightarrow> tm"  where
    "HTuple 0 = HPair Zero Zero"
  | "HTuple (Suc k) = HPair Zero (HTuple k)"
 
 lemma fresh_HTuple [simp]: "x \<sharp> HTuple n"
   by (induct n) auto
 
 lemma HTuple_eqvt[eqvt]: "(p \<bullet> HTuple n) = HTuple (p \<bullet> n)"
   by (induct n, auto simp: HPair_eqvt permute_pure)
 
 subsection \<open>Quotations of de Bruijn terms\<close>
 
 definition nat_of_name :: "name \<Rightarrow> nat"
   where "nat_of_name x = nat_of (atom x)"
 
 lemma nat_of_name_inject [simp]: "nat_of_name n1 = nat_of_name n2 \<longleftrightarrow> n1 = n2"
   by (metis nat_of_name_def atom_components_eq_iff atom_eq_iff sort_of_atom_eq)
 
 definition name_of_nat :: "nat \<Rightarrow> name"
   where "name_of_nat n \<equiv> Abs_name (Atom (Sort ''SyntaxN.name'' []) n)"
 
 lemma nat_of_name_Abs_eq [simp]: "nat_of_name (Abs_name (Atom (Sort ''SyntaxN.name'' []) n)) = n"
   by (auto simp: nat_of_name_def atom_name_def Abs_name_inverse)
 
 lemma nat_of_name_name_eq [simp]: "nat_of_name (name_of_nat n) = n"
   by (simp add: name_of_nat_def)
 
 lemma name_of_nat_nat_of_name [simp]: "name_of_nat (nat_of_name i) = i"
   by (metis nat_of_name_inject nat_of_name_name_eq)
 
 lemma HPair_neq_ORD_OF [simp]: "HPair x y \<noteq> ORD_OF i"
   by (metis HPair_def ORD_OF.elims SUCC_def tm.distinct(3) tm.eq_iff(3))
 
 text\<open>Infinite support, so we cannot use nominal primrec.\<close>
 function quot_dbtm :: "dbtm \<Rightarrow> tm"
   where
    "quot_dbtm DBZero = Zero"
  | "quot_dbtm (DBVar name) = ORD_OF (Suc (nat_of_name name))"
  | "quot_dbtm (DBInd k) = HPair (HTuple 6) (ORD_OF k)"
  | "quot_dbtm (DBEats t u) = HPair (HTuple 1) (HPair (quot_dbtm t) (quot_dbtm u))"
 by (rule dbtm.exhaust) auto
 
 termination
   by lexicographic_order
 
 subsection \<open>Quotations of de Bruijn formulas\<close>
 
 text\<open>Infinite support, so we cannot use nominal primrec.\<close>
 function quot_dbfm :: "dbfm \<Rightarrow> tm"
   where
    "quot_dbfm (DBMem t u) = HPair (HTuple 0) (HPair (quot_dbtm t) (quot_dbtm u))"
  | "quot_dbfm (DBEq t u) = HPair (HTuple 2) (HPair (quot_dbtm t) (quot_dbtm u))"
  | "quot_dbfm (DBDisj A B) = HPair (HTuple 3) (HPair (quot_dbfm A) (quot_dbfm B))"
  | "quot_dbfm (DBNeg A) = HPair (HTuple 4) (quot_dbfm A)"
  | "quot_dbfm (DBEx A) = HPair (HTuple 5) (quot_dbfm A)"
 by (rule_tac y=x in dbfm.exhaust, auto)
 
 termination
   by lexicographic_order
 
 lemma HTuple_minus_1: "n > 0 \<Longrightarrow> HTuple n = HPair Zero (HTuple (n - 1))"
   by (metis Suc_diff_1 HTuple.simps(2))
 
 lemmas HTS = HTuple_minus_1 HTuple.simps \<comment> \<open>for freeness reasoning on codes\<close>
 
 class quot =
-  fixes quot :: "'a \<Rightarrow> tm"  ("\<lceil>_\<rceil>")
+  fixes quot :: "'a \<Rightarrow> tm"  ("\<guillemotleft>_\<guillemotright>")
 
 instantiation tm :: quot
 begin
   definition quot_tm :: "tm \<Rightarrow> tm"
     where "quot_tm t = quot_dbtm (trans_tm [] t)"
 
   instance ..
 end
 
 lemma quot_dbtm_fresh [simp]: "s \<sharp> (quot_dbtm t)"
   by (induct t rule: dbtm.induct) auto
 
-lemma quot_tm_fresh [simp]: fixes t::tm shows "s \<sharp> \<lceil>t\<rceil>"
+lemma quot_tm_fresh [simp]: fixes t::tm shows "s \<sharp> \<guillemotleft>t\<guillemotright>"
   by (simp add: quot_tm_def)
 
-lemma quot_Zero [simp]: "\<lceil>Zero\<rceil> = Zero"
+lemma quot_Zero [simp]: "\<guillemotleft>Zero\<guillemotright> = Zero"
   by (simp add: quot_tm_def)
 
-lemma quot_Var: "\<lceil>Var x\<rceil> = SUCC (ORD_OF (nat_of_name x))"
+lemma quot_Var: "\<guillemotleft>Var x\<guillemotright> = SUCC (ORD_OF (nat_of_name x))"
   by (simp add: quot_tm_def)
 
-lemma quot_Eats: "\<lceil>Eats x y\<rceil> = HPair (HTuple 1) (HPair \<lceil>x\<rceil> \<lceil>y\<rceil>)"
+lemma quot_Eats: "\<guillemotleft>Eats x y\<guillemotright> = HPair (HTuple 1) (HPair \<guillemotleft>x\<guillemotright> \<guillemotleft>y\<guillemotright>)"
   by (simp add: quot_tm_def)
 
 
 instantiation fm :: quot
 begin
   definition quot_fm :: "fm \<Rightarrow> tm"
     where "quot_fm A = quot_dbfm (trans_fm [] A)"
 
   instance ..
 end
 
 lemma quot_dbfm_fresh [simp]: "s \<sharp> (quot_dbfm A)"
   by (induct A rule: dbfm.induct) auto
 
-lemma quot_fm_fresh [simp]: fixes A::fm shows "s \<sharp> \<lceil>A\<rceil>"
+lemma quot_fm_fresh [simp]: fixes A::fm shows "s \<sharp> \<guillemotleft>A\<guillemotright>"
   by (simp add: quot_fm_def)
 
-lemma quot_fm_permute [simp]: fixes A:: fm shows "p \<bullet> \<lceil>A\<rceil> = \<lceil>A\<rceil>"
+lemma quot_fm_permute [simp]: fixes A:: fm shows "p \<bullet> \<guillemotleft>A\<guillemotright> = \<guillemotleft>A\<guillemotright>"
   by (metis fresh_star_def perm_supp_eq quot_fm_fresh)
 
-lemma quot_Mem: "\<lceil>x IN y\<rceil> = HPair (HTuple 0) (HPair (\<lceil>x\<rceil>) (\<lceil>y\<rceil>))"
+lemma quot_Mem: "\<guillemotleft>x IN y\<guillemotright> = HPair (HTuple 0) (HPair (\<guillemotleft>x\<guillemotright>) (\<guillemotleft>y\<guillemotright>))"
   by (simp add: quot_fm_def quot_tm_def)
 
-lemma quot_Eq: "\<lceil>x EQ y\<rceil> = HPair (HTuple 2) (HPair (\<lceil>x\<rceil>) (\<lceil>y\<rceil>))"
+lemma quot_Eq: "\<guillemotleft>x EQ y\<guillemotright> = HPair (HTuple 2) (HPair (\<guillemotleft>x\<guillemotright>) (\<guillemotleft>y\<guillemotright>))"
   by (simp add: quot_fm_def quot_tm_def)
 
-lemma quot_Disj: "\<lceil>A OR B\<rceil> = HPair (HTuple 3) (HPair (\<lceil>A\<rceil>) (\<lceil>B\<rceil>))"
+lemma quot_Disj: "\<guillemotleft>A OR B\<guillemotright> = HPair (HTuple 3) (HPair (\<guillemotleft>A\<guillemotright>) (\<guillemotleft>B\<guillemotright>))"
   by (simp add: quot_fm_def)
 
-lemma quot_Neg: "\<lceil>Neg A\<rceil> = HPair (HTuple 4) (\<lceil>A\<rceil>)"
+lemma quot_Neg: "\<guillemotleft>Neg A\<guillemotright> = HPair (HTuple 4) (\<guillemotleft>A\<guillemotright>)"
   by (simp add: quot_fm_def)
 
-lemma quot_Ex: "\<lceil>Ex i A\<rceil> = HPair (HTuple 5) (quot_dbfm (trans_fm [i] A))"
+lemma quot_Ex: "\<guillemotleft>Ex i A\<guillemotright> = HPair (HTuple 5) (quot_dbfm (trans_fm [i] A))"
   by (simp add: quot_fm_def)
 
 lemmas quot_simps = quot_Var quot_Eats quot_Eq quot_Mem quot_Disj quot_Neg quot_Ex
 
 section\<open>Definitions Involving Coding\<close>
 
 abbreviation Q_Eats :: "tm \<Rightarrow> tm \<Rightarrow> tm"
   where "Q_Eats t u \<equiv> HPair (HTuple (Suc 0)) (HPair t u)"
 
 abbreviation Q_Succ :: "tm \<Rightarrow> tm"
   where "Q_Succ t \<equiv> Q_Eats t t"
 
-lemma quot_Succ: "\<lceil>SUCC x\<rceil> = Q_Succ \<lceil>x\<rceil>"
+lemma quot_Succ: "\<guillemotleft>SUCC x\<guillemotright> = Q_Succ \<guillemotleft>x\<guillemotright>"
   by (auto simp: SUCC_def quot_Eats)
 
 abbreviation Q_HPair :: "tm \<Rightarrow> tm \<Rightarrow> tm"
   where "Q_HPair t u \<equiv>
            Q_Eats (Q_Eats Zero (Q_Eats (Q_Eats Zero u) t))
                   (Q_Eats (Q_Eats Zero t) t)"
 
 abbreviation Q_Mem :: "tm \<Rightarrow> tm \<Rightarrow> tm"
   where "Q_Mem t u \<equiv> HPair (HTuple 0) (HPair t u)"
 
 abbreviation Q_Eq :: "tm \<Rightarrow> tm \<Rightarrow> tm"
   where "Q_Eq t u \<equiv> HPair (HTuple 2) (HPair t u)"
 
 abbreviation Q_Disj :: "tm \<Rightarrow> tm \<Rightarrow> tm"
   where "Q_Disj t u \<equiv> HPair (HTuple 3) (HPair t u)"
 
 abbreviation Q_Neg :: "tm \<Rightarrow> tm"
   where "Q_Neg t \<equiv> HPair (HTuple 4) t"
 
 abbreviation Q_Conj :: "tm \<Rightarrow> tm \<Rightarrow> tm"
   where "Q_Conj t u \<equiv> Q_Neg (Q_Disj (Q_Neg t) (Q_Neg u))"
 
 abbreviation Q_Imp :: "tm \<Rightarrow> tm \<Rightarrow> tm"
   where "Q_Imp t u \<equiv> Q_Disj (Q_Neg t) u"
 
 abbreviation Q_Ex :: "tm \<Rightarrow> tm"
   where "Q_Ex t \<equiv> HPair (HTuple 5) t"
 
 abbreviation Q_All :: "tm \<Rightarrow> tm"
   where "Q_All t \<equiv> Q_Neg (Q_Ex (Q_Neg t))"
 
-lemma quot_subst_eq: "\<lceil>A(i::=t)\<rceil> = quot_dbfm (subst_dbfm (trans_tm [] t) i (trans_fm [] A))"
+lemma quot_subst_eq: "\<guillemotleft>A(i::=t)\<guillemotright> = quot_dbfm (subst_dbfm (trans_tm [] t) i (trans_fm [] A))"
   by (metis quot_fm_def subst_fm_trans_commute)
 
 lemma Q_Succ_cong: "H \<turnstile> x EQ x' \<Longrightarrow> H \<turnstile> Q_Succ x EQ Q_Succ x'"
   by (metis HPair_cong Refl)
 
 subsection\<open>The set \<open>\<Gamma>\<close> of Definition 1.1, constant terms used for coding\<close>
 
 inductive coding_tm :: "tm \<Rightarrow> bool"
   where
     Ord:    "\<exists>i. x = ORD_OF i \<Longrightarrow> coding_tm x"
   | HPair:  "coding_tm x \<Longrightarrow> coding_tm y \<Longrightarrow> coding_tm (HPair x y)"
 
 declare coding_tm.intros [intro]
 
 lemma coding_tm_Zero [intro]: "coding_tm Zero"
   by (metis ORD_OF.simps(1) Ord)
 
 lemma coding_tm_HTuple [intro]: "coding_tm (HTuple k)"
   by (induct k, auto)
 
 inductive_simps coding_tm_HPair [simp]: "coding_tm (HPair x y)"
 
 lemma quot_dbtm_coding [simp]: "coding_tm (quot_dbtm t)"
   apply (induct t rule: dbtm.induct, auto)
   apply (metis ORD_OF.simps(2) Ord)
   done
 
 lemma quot_dbfm_coding [simp]: "coding_tm (quot_dbfm fm)"
   by (induct fm rule: dbfm.induct, auto)
 
-lemma quot_fm_coding: fixes A::fm shows "coding_tm \<lceil>A\<rceil>"
+lemma quot_fm_coding: fixes A::fm shows "coding_tm \<guillemotleft>A\<guillemotright>"
   by (metis quot_dbfm_coding quot_fm_def)
 
 
 section \<open>V-Coding for terms and formulas, for the Second Theorem\<close>
 
 text\<open>Infinite support, so we cannot use nominal primrec.\<close>
 function vquot_dbtm :: "name set \<Rightarrow> dbtm \<Rightarrow> tm"
   where
    "vquot_dbtm V DBZero = Zero"
  | "vquot_dbtm V (DBVar name) = (if name \<in> V then Var name
                                  else ORD_OF (Suc (nat_of_name name)))"
  | "vquot_dbtm V (DBInd k) = HPair (HTuple 6) (ORD_OF k)"
  | "vquot_dbtm V (DBEats t u) = HPair (HTuple 1) (HPair (vquot_dbtm V t) (vquot_dbtm V u))"
 by (auto, rule_tac y=b in dbtm.exhaust, auto)
 
 termination
   by lexicographic_order
 
 lemma fresh_vquot_dbtm [simp]: "i \<sharp> vquot_dbtm V tm \<longleftrightarrow> i \<sharp> tm \<or> i \<notin> atom ` V"
   by (induct tm rule: dbtm.induct) (auto simp: fresh_at_base pure_fresh)
 
 text\<open>Infinite support, so we cannot use nominal primrec.\<close>
 function vquot_dbfm :: "name set \<Rightarrow> dbfm \<Rightarrow> tm"
   where
    "vquot_dbfm V (DBMem t u) = HPair (HTuple 0) (HPair (vquot_dbtm V t) (vquot_dbtm V u))"
  | "vquot_dbfm V (DBEq t u) = HPair (HTuple 2) (HPair (vquot_dbtm V t) (vquot_dbtm V u))"
  | "vquot_dbfm V (DBDisj A B) = HPair (HTuple 3) (HPair (vquot_dbfm V A) (vquot_dbfm V B))"
  | "vquot_dbfm V (DBNeg A) = HPair (HTuple 4) (vquot_dbfm V A)"
  | "vquot_dbfm V (DBEx A) = HPair (HTuple 5) (vquot_dbfm V A)"
 by (auto, rule_tac y=b in dbfm.exhaust, auto)
 
 termination
   by lexicographic_order
 
 lemma fresh_vquot_dbfm [simp]: "i \<sharp> vquot_dbfm V fm \<longleftrightarrow> i \<sharp> fm \<or> i \<notin> atom ` V"
   by (induct fm rule: dbfm.induct) (auto simp: HPair_def HTuple_minus_1)
 
 class vquot =
   fixes vquot :: "'a \<Rightarrow> name set \<Rightarrow> tm"  ("\<lfloor>_\<rfloor>_"  [0,1000]1000)
 
 instantiation tm :: vquot
 begin
   definition vquot_tm :: "tm \<Rightarrow> name set \<Rightarrow> tm"
     where "vquot_tm t V = vquot_dbtm V (trans_tm [] t)"
   instance ..
 end
 
 lemma vquot_dbtm_empty [simp]: "vquot_dbtm {} t = quot_dbtm t"
   by (induct t rule: dbtm.induct) auto
 
-lemma vquot_tm_empty [simp]: fixes t::tm shows "\<lfloor>t\<rfloor>{} = \<lceil>t\<rceil>"
+lemma vquot_tm_empty [simp]: fixes t::tm shows "\<lfloor>t\<rfloor>{} = \<guillemotleft>t\<guillemotright>"
   by (simp add: vquot_tm_def quot_tm_def)
 
 lemma vquot_dbtm_eq: "atom ` V \<inter> supp t = atom ` W \<inter> supp t \<Longrightarrow> vquot_dbtm V t = vquot_dbtm W t"
   by (induct t rule: dbtm.induct) (auto simp: image_iff, blast+)
 
 instantiation fm :: vquot
 begin
   definition vquot_fm :: "fm \<Rightarrow> name set \<Rightarrow> tm"
     where "vquot_fm A V = vquot_dbfm V (trans_fm [] A)"
   instance ..
 end
 
 lemma vquot_fm_fresh [simp]: fixes A::fm shows "i \<sharp> \<lfloor>A\<rfloor>V \<longleftrightarrow> i \<sharp> A \<or> i \<notin> atom ` V"
   by (simp add: vquot_fm_def)
 
 lemma vquot_dbfm_empty [simp]: "vquot_dbfm {} A = quot_dbfm A"
   by (induct A rule: dbfm.induct) auto
 
-lemma vquot_fm_empty [simp]: fixes A::fm shows "\<lfloor>A\<rfloor>{} = \<lceil>A\<rceil>"
+lemma vquot_fm_empty [simp]: fixes A::fm shows "\<lfloor>A\<rfloor>{} = \<guillemotleft>A\<guillemotright>"
   by (simp add: vquot_fm_def quot_fm_def)
 
 lemma vquot_dbfm_eq: "atom ` V \<inter> supp A = atom ` W \<inter> supp A \<Longrightarrow> vquot_dbfm V A = vquot_dbfm W A"
   by (induct A rule: dbfm.induct) (auto simp: intro!: vquot_dbtm_eq, blast+)
 
 lemma vquot_fm_insert:
   fixes A::fm shows "atom i \<notin> supp A \<Longrightarrow> \<lfloor>A\<rfloor>(insert i V) = \<lfloor>A\<rfloor>V"
   by (auto simp: vquot_fm_def supp_conv_fresh intro: vquot_dbfm_eq)
 
 declare HTuple.simps [simp del]
 
 end
diff --git a/thys/Goedel_HFSet_Semanticless/Goedel_I.thy b/thys/Goedel_HFSet_Semanticless/Goedel_I.thy
--- a/thys/Goedel_HFSet_Semanticless/Goedel_I.thy
+++ b/thys/Goedel_HFSet_Semanticless/Goedel_I.thy
@@ -1,790 +1,790 @@
 chapter \<open>Section 6 Material and Gödel's First Incompleteness Theorem\<close>
 
 theory Goedel_I
 imports Pf_Predicates Functions II_Prelims
 begin
 
 section\<open>The Function W and Lemma 6.1\<close>
 
 subsection\<open>Predicate form, defined on sequences\<close>
 
 nominal_function SeqWRP :: "tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> fm"
   where "\<lbrakk>atom l \<sharp> (s,k,sl); atom sl \<sharp> (s)\<rbrakk> \<Longrightarrow>
     SeqWRP s k y = LstSeqP s k y AND
           HPair Zero Zero IN s AND
           All2 l k (Ex sl (HPair (Var l) (Var sl) IN s AND
                            HPair (SUCC (Var l)) (Q_Succ (Var sl)) IN s))"
   by (auto simp: eqvt_def SeqWRP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma
   shows SeqWRP_fresh_iff [simp]: "a \<sharp> SeqWRP s k y \<longleftrightarrow> a \<sharp> s \<and> a \<sharp> k \<and> a \<sharp> y" (is ?thesis1)
     and SeqWRP_sf [iff]:         "Sigma_fm (SeqWRP s k y)"  (is ?thsf)
     and SeqWRP_imp_OrdP:         "{SeqWRP s k t} \<turnstile> OrdP k" (is ?thOrd)
     and SeqWRP_LstSeqP:          "{SeqWRP s k t} \<turnstile> LstSeqP s k t" (is ?thlstseq)
 proof -
   obtain l::name and sl::name where "atom l \<sharp> (s,k,sl)" "atom sl \<sharp> (s)"
     by (metis obtain_fresh)
   thus ?thesis1 ?thsf ?thOrd ?thlstseq
       by (auto intro: LstSeqP_OrdP[THEN cut1])
 qed
 
 lemma SeqWRP_subst [simp]:
       "(SeqWRP s k y)(i::=t) = SeqWRP (subst i t s) (subst i t k) (subst i t y)"
 proof -
   obtain l::name and sl::name
     where "atom l \<sharp> (s,k,sl,t,i)" "atom sl \<sharp> (s,k,t,i)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: SeqWRP.simps [where l=l and sl=sl])
 qed
 
 lemma SeqWRP_cong:
   assumes "H \<turnstile> s EQ s'" and  "H \<turnstile> k EQ k'" and  "H \<turnstile> y EQ y'"
   shows "H \<turnstile> SeqWRP s k y IFF SeqWRP s' k' y'"
   by (rule P3_cong [OF _ assms], auto)
 
 declare SeqWRP.simps [simp del]
 
 subsection\<open>Predicate form of W\<close>
 
 nominal_function WRP :: "tm \<Rightarrow> tm \<Rightarrow> fm"
   where "\<lbrakk>atom s \<sharp> (x,y)\<rbrakk> \<Longrightarrow>
     WRP x y = Ex s (SeqWRP (Var s) x y)"
   by (auto simp: eqvt_def WRP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma
   shows WRP_fresh_iff [simp]: "a \<sharp> WRP x y \<longleftrightarrow> a \<sharp> x \<and> a \<sharp> y" (is ?thesis1)
     and sigma_fm_WRP [simp]:  "Sigma_fm (WRP x y)"  (is ?thsf)
 proof -
   obtain s::name where "atom s \<sharp> (x,y)"
     by (metis obtain_fresh)
   thus ?thesis1 ?thsf
     by auto
 qed
 
 lemma WRP_subst [simp]: "(WRP x y)(i::=t) = WRP (subst i t x) (subst i t y)"
 proof -
   obtain s::name where "atom s \<sharp> (x,y,t,i)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: WRP.simps [of s])
 qed
 
 lemma WRP_cong: "H \<turnstile> t EQ t' \<Longrightarrow> H \<turnstile> u EQ u' \<Longrightarrow> H \<turnstile> WRP t u IFF WRP t' u'"
   by (rule P2_cong) auto
 
 declare WRP.simps [simp del]
 
 lemma ground_WRP [simp]: "ground_fm (WRP x y) \<longleftrightarrow> ground x \<and> ground y"
   by (auto simp: ground_aux_def ground_fm_aux_def supp_conv_fresh)
 
 lemma SeqWRP_Zero: "{} \<turnstile> SyntaxN.Ex s (SeqWRP (Var s) Zero Zero)"
 proof -
   obtain l sl :: name where "atom l \<sharp> (s, sl)" "atom sl \<sharp> s" by (metis obtain_fresh)
   then show ?thesis
     apply (subst SeqWRP.simps[of l _ _ sl]; simp)
     apply (rule Ex_I[where x="(Eats Zero (HPair Zero Zero))"], simp)
     apply (auto intro!: Mem_Eats_I2)
     done
 qed
 
 lemma WRP_Zero: "{} \<turnstile> WRP Zero Zero"
   by (subst WRP.simps[of undefined]) (auto simp: SeqWRP_Zero)
 
 lemma SeqWRP_HPair_Zero_Zero: "{SeqWRP s k y} \<turnstile> HPair Zero Zero IN s"
 proof -
   let ?vs = "(s,k,y)"
   obtain l::name and sl::name
     where "atom l \<sharp> (?vs,sl)" "atom sl \<sharp> (?vs)" by (metis obtain_fresh)
   then show ?thesis
     by (subst SeqWRP.simps[of l _ _ sl]) auto
 qed
 
 lemma SeqWRP_Succ:
   assumes "atom s \<sharp> (s1,k1,y)"
   shows "{SeqWRP s1 k1 y} \<turnstile> SyntaxN.Ex s (SeqWRP (Var s) (SUCC k1) (Q_Succ y))"
 proof -
   let ?vs = "(s,s1,k1,y)"
   obtain l::name and sl::name and l1::name and sl1::name
     where atoms:
       "atom l \<sharp> (?vs,sl1,l1,sl)"
       "atom sl \<sharp> (?vs,sl1,l1)"
       "atom l1 \<sharp> (?vs,sl1)"
       "atom sl1 \<sharp> (?vs)"
     by (metis obtain_fresh)
   let ?hyp = "{RestrictedP s1 (SUCC k1) (Var s), OrdP k1, SeqWRP s1 k1 y}"
   show ?thesis
     using assms atoms
     apply (auto simp: SeqWRP.simps [of l "Var s" _ sl])
     apply (rule cut_same [where A="OrdP k1"])
     apply (rule SeqWRP_imp_OrdP)
     apply (rule cut_same [OF exists_RestrictedP [of s s1 "SUCC k1"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
       apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC k1)  (Q_Succ y))"])
       apply (simp_all (no_asm_simp))
     apply (rule Conj_I)
     apply (blast intro: RestrictedP_LstSeqP_Eats[THEN cut2] SeqWRP_LstSeqP[THEN cut1])
     apply (rule Conj_I)
      apply (rule Mem_Eats_I1)
      apply (blast intro: RestrictedP_Mem[THEN cut3] SeqWRP_HPair_Zero_Zero[THEN cut1] Zero_In_SUCC[THEN cut1])
   proof (rule All2_SUCC_I, simp_all)
     show "?hyp \<turnstile>  SyntaxN.Ex sl
      (HPair k1 (Var sl) IN Eats (Var s) (HPair (SUCC k1) (Q_Succ y)) AND
       HPair (SUCC k1) (Q_Succ (Var sl)) IN
       Eats (Var s) (HPair (SUCC k1) (Q_Succ y)))"
       \<comment> \<open>verifying the final values\<close>
       apply (rule Ex_I [where x="y"])
       using assms atoms apply simp
       apply (rule Conj_I[rotated])
        apply (rule Mem_Eats_I2, rule Refl)
      apply (rule Mem_Eats_I1)
       apply (rule RestrictedP_Mem[THEN cut3])
         apply (rule AssumeH)
        apply (simp add: LstSeqP_imp_Mem SeqWRP_LstSeqP thin1)
       apply (rule Mem_SUCC_Refl)
       done
   next
     show "?hyp \<turnstile> All2 l k1
      (SyntaxN.Ex sl
        (HPair (Var l) (Var sl) IN
         Eats (Var s) (HPair (SUCC k1) (Q_Succ y)) AND
         HPair (SUCC (Var l)) (Q_Succ (Var sl)) IN
         Eats (Var s) (HPair (SUCC k1) (Q_Succ y))))"
       \<comment> \<open>verifying the sequence buildup\<close>
       apply (rule All_I Imp_I)+
       using assms atoms apply simp_all
         \<comment> \<open>... the sequence buildup via s1\<close>
     apply (simp add: SeqWRP.simps [of l s1 _ sl])
       apply (rule AssumeH Ex_EH Conj_EH)+
       apply (rule All2_E [THEN rotate2], auto del: Disj_EH)
       apply (rule Ex_I [where x="Var sl"], simp)
       apply (rule Conj_I)
        apply (blast intro: Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] Mem_SUCC_I1)
       apply (blast intro: Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] OrdP_IN_SUCC)
       done
   qed
 qed (*>*)
 
 lemma WRP_Succ: "{OrdP i, WRP i y} \<turnstile> WRP (SUCC i) (Q_Succ y)"
 proof -
   obtain s t :: name where "atom s \<sharp> (i, y)" "atom t \<sharp> (s,i, y)" by (metis obtain_fresh)
   then show ?thesis
     by (subst WRP.simps[of s], simp, subst WRP.simps[of t], simp) (force intro: SeqWRP_Succ[THEN cut1])
 qed
 
-lemma WRP: "{} \<turnstile> WRP (ORD_OF i) \<lceil>ORD_OF i\<rceil>"
+lemma WRP: "{} \<turnstile> WRP (ORD_OF i) \<guillemotleft>ORD_OF i\<guillemotright>"
   by (induct i)
     (auto simp: WRP_Zero quot_Succ intro!: WRP_Succ[THEN cut2])
 
-lemma prove_WRP:  "{} \<turnstile> WRP \<lceil>Var x\<rceil> \<lceil>\<lceil>Var x\<rceil>\<rceil>"
+lemma prove_WRP:  "{} \<turnstile> WRP \<guillemotleft>Var x\<guillemotright> \<guillemotleft>\<guillemotleft>Var x\<guillemotright>\<guillemotright>"
   unfolding quot_Var quot_Succ
   by (rule WRP_Succ[THEN cut2]) (auto simp: WRP)
 
 subsection\<open>Proving that these relations are functions\<close>
 
 lemma SeqWRP_Zero_E:
   assumes "insert (y EQ Zero) H \<turnstile> A"  "H \<turnstile> k EQ Zero"
   shows "insert (SeqWRP s k y) H \<turnstile> A"
 proof -
   obtain l::name and sl::name
     where "atom l \<sharp> (s,k,sl)" "atom sl \<sharp> (s)"
     by (metis obtain_fresh)
   thus ?thesis
     apply (auto simp: SeqWRP.simps [where s=s and l=l and sl=sl])
     apply (rule cut_same [where A = "LstSeqP s Zero y"])
     apply (blast intro: thin1 assms  LstSeqP_cong [OF Refl _ Refl, THEN Iff_MP_same])
     apply (rule cut_same [where A = "y EQ Zero"])
     apply (blast intro: LstSeqP_EQ)
     apply (metis rotate2 assms(1) thin1)
     done
 qed
 
 lemma SeqWRP_SUCC_lemma:
   assumes y': "atom y' \<sharp> (s,k,y)"
   shows "{SeqWRP s (SUCC k) y} \<turnstile> Ex y' (SeqWRP s k (Var y') AND y EQ Q_Succ (Var y'))"
 proof -
   obtain l::name and sl::name
     where atoms: "atom l \<sharp> (s,k,y,y',sl)" "atom sl \<sharp> (s,k,y,y')"
     by (metis obtain_fresh)
   thus ?thesis using y'
     apply (auto simp: SeqWRP.simps [where s=s and l=l and sl=sl])
     apply (rule All2_SUCC_E' [where t=k, THEN rotate2], auto)
     apply (rule Ex_I [where x = "Var sl"], auto)
     apply (blast intro: LstSeqP_SUCC) \<comment> \<open>showing @{term"SeqWRP s k (Var sl)"}\<close>
     apply (blast intro: ContraProve LstSeqP_EQ)
     done
 qed
 
 lemma SeqWRP_SUCC_E:
   assumes y': "atom y' \<sharp> (s,k,y)" and k': "H \<turnstile> k' EQ (SUCC k)"
   shows "insert (SeqWRP s k' y) H  \<turnstile> Ex y' (SeqWRP s k (Var y') AND y EQ Q_Succ (Var y'))"
   using SeqWRP_cong [OF Refl k' Refl] cut1 [OF SeqWRP_SUCC_lemma [of y' s k y]]
   by (metis Assume Iff_MP_left Iff_sym y')
 
 lemma SeqWRP_unique: "{OrdP x, SeqWRP s x y, SeqWRP s' x y'} \<turnstile> y' EQ y"
 proof -
   obtain i::name and j::name and j'::name and k::name and sl::name and sl'::name and l::name and pi::name
     where  i: "atom i \<sharp> (s,s',y,y')" and j: "atom j \<sharp> (s,s',i,x,y,y')" and j': "atom j' \<sharp> (s,s',i,j,x,y,y')"
       and atoms: "atom k \<sharp> (s,s',i,j,j')" "atom sl \<sharp> (s,s',i,j,j',k)" "atom sl' \<sharp> (s,s',i,j,j',k,sl)"
                  "atom pi \<sharp> (s,s',i,j,j',k,sl,sl')"
     by (metis obtain_fresh)
   have "{OrdP (Var i)} \<turnstile> All j (All j' (SeqWRP s (Var i) (Var j) IMP (SeqWRP s' (Var i) (Var j') IMP Var j' EQ Var j)))"
     apply (rule OrdIndH [where j=k])
     using i j j' atoms apply auto
     apply (rule rotate4)
     apply (rule OrdP_cases_E [where k=pi], simp_all)
     \<comment> \<open>Zero case\<close>
     apply (rule SeqWRP_Zero_E [THEN rotate3])
     prefer 2 apply blast
     apply (rule SeqWRP_Zero_E [THEN rotate4])
     prefer 2 apply blast
     apply (blast intro: ContraProve [THEN rotate4] Sym Trans)
     \<comment> \<open>SUCC case\<close>
     apply (rule Ex_I [where x = "Var pi"], auto)
     apply (metis ContraProve EQ_imp_SUBS2 Mem_SUCC_I2 Refl Subset_D)
     apply (rule cut_same)
     apply (rule SeqWRP_SUCC_E [of sl' s' "Var pi", THEN rotate4], auto)
     apply (rule cut_same)
     apply (rule SeqWRP_SUCC_E [of sl s "Var pi", THEN rotate7], auto)
     apply (rule All_E [where x = "Var sl", THEN rotate5], simp)
     apply (rule All_E [where x = "Var sl'"], simp)
     apply (rule Imp_E, blast)+
     apply (rule cut_same [OF Q_Succ_cong [OF Assume]])
     apply (blast intro: Trans [OF Hyp Sym] HPair_cong)
     done
   hence "{OrdP (Var i)} \<turnstile> (All j' (SeqWRP s (Var i) (Var j) IMP (SeqWRP s' (Var i) (Var j') IMP Var j' EQ Var j)))(j::=y)"
     by (metis All_D)
   hence "{OrdP (Var i)} \<turnstile> (SeqWRP s (Var i) y IMP (SeqWRP s' (Var i) (Var j') IMP Var j' EQ y))(j'::=y')"
     using j j'
     by simp (drule All_D [where x=y'], simp)
   hence "{} \<turnstile> OrdP (Var i) IMP (SeqWRP s (Var i) y IMP (SeqWRP s' (Var i) y' IMP y' EQ y))"
     using j j'
     by simp (metis Imp_I)
   hence "{} \<turnstile> (OrdP (Var i) IMP (SeqWRP s (Var i) y IMP (SeqWRP s' (Var i) y' IMP y' EQ y)))(i::=x)"
     by (metis Subst emptyE)
   thus ?thesis using i
     by simp (metis anti_deduction insert_commute)
 qed
 
 theorem WRP_unique: "{OrdP x, WRP x y, WRP x y'} \<turnstile> y' EQ y"
 proof -
   obtain s::name and s'::name
     where "atom s \<sharp> (x,y,y')"  "atom s' \<sharp> (x,y,y',s)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: SeqWRP_unique [THEN rotate3] WRP.simps [of s _ y]  WRP.simps [of s' _ y'])
 qed
 
 section\<open>The Function HF and Lemma 6.2\<close>
 
 subsection \<open>Defining the syntax: quantified body\<close>
 
 nominal_function SeqHRP :: "tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> fm"
   where "\<lbrakk>atom l \<sharp> (s,k,sl,sl',m,n,sm,sm',sn,sn');
           atom sl \<sharp> (s,sl',m,n,sm,sm',sn,sn');
           atom sl' \<sharp> (s,m,n,sm,sm',sn,sn');
           atom m \<sharp> (s,n,sm,sm',sn,sn');
           atom n \<sharp> (s,sm,sm',sn,sn');
           atom sm \<sharp> (s,sm',sn,sn');
           atom sm' \<sharp> (s,sn,sn');
           atom sn \<sharp> (s,sn');
           atom sn' \<sharp> (s)\<rbrakk> \<Longrightarrow>
     SeqHRP x x' s k =
       LstSeqP s k (HPair x x') AND
       All2 l (SUCC k) (Ex sl (Ex sl' (HPair (Var l) (HPair (Var sl) (Var sl')) IN s AND
                 ((OrdP (Var sl) AND WRP (Var sl) (Var sl')) OR
                  Ex m (Ex n (Ex sm (Ex sm' (Ex sn (Ex sn' (Var m IN Var l AND Var n IN Var l AND
                        HPair (Var m) (HPair (Var sm) (Var sm')) IN s AND
                        HPair (Var n) (HPair (Var sn) (Var sn')) IN s AND
                        Var sl EQ HPair (Var sm) (Var sn) AND
                        Var sl' EQ Q_HPair (Var sm') (Var sn')))))))))))"
 by (auto simp: eqvt_def SeqHRP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma
  shows SeqHRP_fresh_iff [simp]:
       "a \<sharp> SeqHRP x x' s k \<longleftrightarrow> a \<sharp> x \<and> a \<sharp> x' \<and> a \<sharp> s \<and> a \<sharp> k"  (is ?thesis1)
   and SeqHRP_sf [iff]:  "Sigma_fm (SeqHRP x x' s k)"  (is ?thsf)
   and SeqHRP_imp_OrdP: "{ SeqHRP x y s k } \<turnstile> OrdP k"  (is ?thord)
   and SeqHRP_imp_LstSeqP: "{ SeqHRP x y s k } \<turnstile> LstSeqP s k (HPair x y)"  (is ?thlstseq)
 proof -
   obtain l::name and sl::name and sl'::name and m::name and n::name and
          sm::name and sm'::name and sn::name and sn'::name
     where atoms:
          "atom l \<sharp> (s,k,sl,sl',m,n,sm,sm',sn,sn')"
          "atom sl \<sharp> (s,sl',m,n,sm,sm',sn,sn')" "atom sl' \<sharp> (s,m,n,sm,sm',sn,sn')"
          "atom m \<sharp> (s,n,sm,sm',sn,sn')" "atom n \<sharp> (s,sm,sm',sn,sn')"
          "atom sm \<sharp> (s,sm',sn,sn')" "atom sm' \<sharp> (s,sn,sn')"
          "atom sn \<sharp> (s,sn')" "atom sn' \<sharp> (s)"
     by (metis obtain_fresh)
   thus ?thesis1 ?thsf ?thord ?thlstseq
     by (auto intro: LstSeqP_OrdP)
 qed
 
 lemma SeqHRP_subst [simp]:
       "(SeqHRP x x' s k)(i::=t) = SeqHRP (subst i t x) (subst i t x') (subst i t s) (subst i t k)"
 proof -
   obtain l::name and sl::name and sl'::name and m::name and n::name and
          sm::name and sm'::name and sn::name and sn'::name
     where "atom l \<sharp> (s,k,t,i,sl,sl',m,n,sm,sm',sn,sn')"
           "atom sl \<sharp> (s,t,i,sl',m,n,sm,sm',sn,sn')"
           "atom sl' \<sharp> (s,t,i,m,n,sm,sm',sn,sn')"
           "atom m \<sharp> (s,t,i,n,sm,sm',sn,sn')" "atom n \<sharp> (s,t,i,sm,sm',sn,sn')"
           "atom sm \<sharp> (s,t,i,sm',sn,sn')" "atom sm' \<sharp> (s,t,i,sn,sn')"
           "atom sn \<sharp> (s,t,i,sn')" "atom sn' \<sharp> (s,t,i)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: SeqHRP.simps [of l _ _ sl sl' m n sm sm' sn sn'])
 qed
 
 lemma SeqHRP_cong:
   assumes "H \<turnstile> x EQ x'" and "H \<turnstile> y EQ y'" "H \<turnstile> s EQ s'" and  "H \<turnstile> k EQ k'"
   shows "H \<turnstile> SeqHRP x y s k IFF SeqHRP x' y' s' k'"
   by (rule P4_cong [OF _ assms], auto)
 
 subsection \<open>Defining the syntax: main predicate\<close>
 
 nominal_function HRP :: "tm \<Rightarrow> tm \<Rightarrow> fm"
   where "\<lbrakk>atom s \<sharp> (x,x',k); atom k \<sharp> (x,x')\<rbrakk> \<Longrightarrow>
          HRP x x' = Ex s (Ex k (SeqHRP x x' (Var s) (Var k)))"
   by (auto simp: eqvt_def HRP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma
  shows HRP_fresh_iff [simp]: "a \<sharp> HRP x x' \<longleftrightarrow> a \<sharp> x \<and> a \<sharp> x'"  (is ?thesis1)
    and HRP_sf [iff]:         "Sigma_fm (HRP x x')"  (is ?thsf)
 proof -
   obtain s::name and k::name  where "atom s \<sharp> (x,x',k)"  "atom k \<sharp> (x,x')"
     by (metis obtain_fresh)
   thus ?thesis1 ?thsf
     by auto
 qed
 
 lemma HRP_subst [simp]: "(HRP x x')(i::=t) = HRP (subst i t x) (subst i t x')"
 proof -
   obtain s::name and k::name where "atom s \<sharp> (x,x',t,i,k)"  "atom k \<sharp> (x,x',t,i)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: HRP.simps [of s _ _ k])
 qed
 
 subsection\<open>Proving that these relations are functions\<close>
 
 lemma SeqHRP_lemma:
   assumes "atom m \<sharp> (x,x',s,k,n,sm,sm',sn,sn')" "atom n \<sharp> (x,x',s,k,sm,sm',sn,sn')"
           "atom sm \<sharp> (x,x',s,k,sm',sn,sn')" "atom sm' \<sharp> (x,x',s,k,sn,sn')"
           "atom sn \<sharp> (x,x',s,k,sn')" "atom sn' \<sharp> (x,x',s,k)"
     shows "{ SeqHRP x x' s k }
          \<turnstile> (OrdP x AND WRP x x') OR
              Ex m (Ex n (Ex sm (Ex sm' (Ex sn (Ex sn' (Var m IN k AND Var n IN k AND
                        SeqHRP (Var sm) (Var sm') s (Var m) AND
                        SeqHRP (Var sn) (Var sn') s (Var n) AND
                        x EQ HPair (Var sm) (Var sn) AND
                        x' EQ Q_HPair (Var sm') (Var sn')))))))"
 proof -
   obtain l::name and sl::name and sl'::name
     where atoms:
           "atom l \<sharp> (x,x',s,k,sl,sl',m,n,sm,sm',sn,sn')"
           "atom sl \<sharp> (x,x',s,k,sl',m,n,sm,sm',sn,sn')"
           "atom sl' \<sharp> (x,x',s,k,m,n,sm,sm',sn,sn')"
     by (metis obtain_fresh)
   thus ?thesis using atoms assms
     apply (simp add: SeqHRP.simps [of l s k sl sl' m n sm sm' sn sn'])
     apply (rule Conj_E)
     apply (rule All2_SUCC_E' [where t=k, THEN rotate2], simp_all)
     apply (rule rotate2)
     apply (rule Ex_E Conj_E)+
     apply (rule cut_same [where A = "HPair x x' EQ HPair (Var sl) (Var sl')"])
     apply (metis Assume LstSeqP_EQ rotate4, simp_all, clarify)
     apply (rule Disj_E [THEN rotate4])
     apply (rule Disj_I1)
     apply (metis Assume AssumeH(3) Sym thin1  Iff_MP_same [OF Conj_cong [OF OrdP_cong WRP_cong] Assume])
     \<comment> \<open>auto could be used but is VERY SLOW\<close>
     apply (rule Disj_I2)
     apply (rule Ex_E Conj_EH)+
     apply simp_all
     apply (rule Ex_I [where x = "Var m"], simp)
     apply (rule Ex_I [where x = "Var n"], simp)
     apply (rule Ex_I [where x = "Var sm"], simp)
     apply (rule Ex_I [where x = "Var sm'"], simp)
     apply (rule Ex_I [where x = "Var sn"], simp)
     apply (rule Ex_I [where x = "Var sn'"], simp)
     apply (simp add: SeqHRP.simps [of l _ _ sl sl' m n sm sm' sn sn'])
     apply (rule Conj_I, blast)+
     \<comment> \<open>first SeqHRP subgoal\<close>
     apply (rule Conj_I)+
     apply (blast intro: LstSeqP_Mem)
     apply (rule All2_Subset [OF Hyp], blast)
     apply (blast intro!: SUCC_Subset_Ord LstSeqP_OrdP, blast, simp)
     \<comment> \<open>next SeqHRP subgoal\<close>
     apply (rule Conj_I)+
     apply (blast intro: LstSeqP_Mem)
     apply (rule All2_Subset [OF Hyp], blast)
     apply (auto intro!: SUCC_Subset_Ord LstSeqP_OrdP)
     \<comment> \<open>finally, the equality pair\<close>
     apply (blast intro: Trans)+
     done
 qed
 
 lemma SeqHRP_unique: "{SeqHRP x y s u, SeqHRP x y' s' u'} \<turnstile> y' EQ y"
 proof -
   obtain i::name and j::name and j'::name and k::name and k'::name and l::name
      and m::name and n::name and sm::name and sn::name and sm'::name and sn'::name
      and m2::name and n2::name and sm2::name and sn2::name and sm2'::name and sn2'::name
     where atoms:  "atom i \<sharp> (s,s',y,y')"   "atom j \<sharp> (s,s',i,x,y,y')"  "atom j' \<sharp> (s,s',i,j,x,y,y')"
                   "atom k \<sharp> (s,s',x,y,y',u',i,j,j')" "atom k' \<sharp> (s,s',x,y,y',k,i,j,j')" "atom l \<sharp> (s,s',i,j,j',k,k')"
                   "atom m \<sharp> (s,s',i,j,j',k,k',l)"   "atom n \<sharp> (s,s',i,j,j',k,k',l,m)"
                   "atom sm \<sharp> (s,s',i,j,j',k,k',l,m,n)"  "atom sn \<sharp> (s,s',i,j,j',k,k',l,m,n,sm)"
                   "atom sm' \<sharp> (s,s',i,j,j',k,k',l,m,n,sm,sn)"   "atom sn' \<sharp> (s,s',i,j,j',k,k',l,m,n,sm,sn,sm')"
                   "atom m2 \<sharp> (s,s',i,j,j',k,k',l,m,n,sm,sn,sm',sn')"   "atom n2 \<sharp> (s,s',i,j,j',k,k',l,m,n,sm,sn,sm',sn',m2)"
                   "atom sm2 \<sharp> (s,s',i,j,j',k,k',l,m,n,sm,sn,sm',sn',m2,n2)"  "atom sn2 \<sharp> (s,s',i,j,j',k,k',l,m,n,sm,sn,sm',sn',m2,n2,sm2)"
                   "atom sm2' \<sharp> (s,s',i,j,j',k,k',l,m,n,sm,sn,sm',sn',m2,n2,sm2,sn2)"   "atom sn2' \<sharp> (s,s',i,j,j',k,k',l,m,n,sm,sn,sm',sn',m2,n2,sm2,sn2,sm2')"
     by (metis obtain_fresh)
   have "{OrdP (Var k)}
        \<turnstile> All i (All j (All j' (All k' (SeqHRP (Var i) (Var j) s (Var k) IMP (SeqHRP (Var i) (Var j') s' (Var k') IMP Var j' EQ Var j)))))"
     apply (rule OrdIndH [where j=l])
     using atoms apply auto
     apply (rule Swap)
     apply (rule cut_same)
     apply (rule cut1 [OF SeqHRP_lemma [of m "Var i" "Var j" s "Var k" n sm sm' sn sn']], simp_all, blast)
     apply (rule cut_same)
     apply (rule cut1 [OF SeqHRP_lemma [of m2 "Var i" "Var j'" s' "Var k'" n2 sm2 sm2' sn2 sn2']], simp_all, blast)
     apply (rule Disj_EH Conj_EH)+
     \<comment> \<open>case 1, both are ordinals\<close>
     apply (blast intro: cut3 [OF WRP_unique])
     \<comment> \<open>case 2, @{term "OrdP (Var i)"} but also a pair\<close>
     apply (rule Conj_EH Ex_EH)+
     apply simp_all
     apply (rule cut_same [where A = "OrdP (HPair (Var sm) (Var sn))"])
     apply (blast intro: OrdP_cong [OF Hyp, THEN Iff_MP_same], blast)
     \<comment> \<open>towards second two cases\<close>
     apply (rule Ex_E Disj_EH Conj_EH)+
     \<comment> \<open>case 3, @{term "OrdP (Var i)"} but also a pair\<close>
     apply (rule cut_same [where A = "OrdP (HPair (Var sm2) (Var sn2))"])
     apply (blast intro: OrdP_cong [OF Hyp, THEN Iff_MP_same], blast)
     \<comment> \<open>case 4, two pairs\<close>
     apply (rule Ex_E Disj_EH Conj_EH)+
     apply (rule All_E' [OF Hyp, where x="Var m"], blast)
     apply (rule All_E' [OF Hyp, where x="Var n"], blast, simp_all)
     apply (rule Disj_EH, blast intro: thin1 ContraProve)+
     apply (rule All_E [where x="Var sm"], simp)
     apply (rule All_E [where x="Var sm'"], simp)
     apply (rule All_E [where x="Var sm2'"], simp)
     apply (rule All_E [where x="Var m2"], simp)
     apply (rule All_E [where x="Var sn", THEN rotate2], simp)
     apply (rule All_E [where x="Var sn'"], simp)
     apply (rule All_E [where x="Var sn2'"], simp)
     apply (rule All_E [where x="Var n2"], simp)
     apply (rule cut_same [where A = "HPair (Var sm) (Var sn) EQ HPair (Var sm2) (Var sn2)"])
     apply (blast intro: Sym Trans)
     apply (rule cut_same [where A = "SeqHRP (Var sn) (Var sn2') s' (Var n2)"])
     apply (blast intro: SeqHRP_cong [OF Hyp Refl Refl, THEN Iff_MP2_same])
     apply (rule cut_same [where A = "SeqHRP (Var sm) (Var sm2') s' (Var m2)"])
     apply (blast intro: SeqHRP_cong [OF Hyp Refl Refl, THEN Iff_MP2_same])
     apply (rule Disj_EH, blast intro: thin1 ContraProve)+
     apply (blast intro: Trans [OF Hyp Sym] intro!: HPair_cong)
     done
   hence "{OrdP (Var k)}
          \<turnstile> All j (All j' (All k' (SeqHRP x (Var j) s (Var k)
                IMP (SeqHRP x (Var j') s' (Var k') IMP Var j' EQ Var j))))"
     apply (rule All_D [where x = x, THEN cut_same])
     using atoms by auto
   hence "{OrdP (Var k)}
          \<turnstile> All j' (All k' (SeqHRP x y s (Var k) IMP (SeqHRP x (Var j') s' (Var k') IMP Var j' EQ y)))"
     apply (rule All_D [where x = y, THEN cut_same])
     using atoms by auto
   hence "{OrdP (Var k)}
           \<turnstile> All k' (SeqHRP x y s (Var k) IMP (SeqHRP x y' s' (Var k') IMP y' EQ y))"
     apply (rule All_D [where x = y', THEN cut_same])
     using atoms by auto
   hence "{OrdP (Var k)} \<turnstile> SeqHRP x y s (Var k) IMP (SeqHRP x y' s' u' IMP y' EQ y)"
     apply (rule All_D [where x = u', THEN cut_same])
     using atoms by auto
   hence "{SeqHRP x y s (Var k)} \<turnstile> SeqHRP x y s (Var k) IMP (SeqHRP x y' s' u' IMP y' EQ y)"
     by (metis SeqHRP_imp_OrdP cut1)
   hence "{} \<turnstile> ((SeqHRP x y s (Var k) IMP (SeqHRP x y' s' u' IMP y' EQ y)))(k::=u)"
     by (metis Subst emptyE Assume MP_same Imp_I)
   hence "{} \<turnstile> SeqHRP x y s u IMP (SeqHRP x y' s' u' IMP y' EQ y)"
     using atoms by simp
   thus ?thesis
     by (metis anti_deduction insert_commute)
 qed
 
 theorem HRP_unique: "{HRP x y, HRP x y'} \<turnstile> y' EQ y"
 proof -
   obtain s::name and s'::name and k::name and k'::name
     where "atom s \<sharp> (x,y,y')" "atom s' \<sharp> (x,y,y',s)"
           "atom k \<sharp> (x,y,y',s,s')" "atom k' \<sharp> (x,y,y',s,s',k)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: SeqHRP_unique HRP.simps [of s x y k]  HRP.simps [of s' x y' k'])
 qed
 
-lemma HRP_ORD_OF: "{} \<turnstile> HRP (ORD_OF i) \<lceil>ORD_OF i\<rceil>"
+lemma HRP_ORD_OF: "{} \<turnstile> HRP (ORD_OF i) \<guillemotleft>ORD_OF i\<guillemotright>"
 proof -
   let ?vs = "(i)"
   obtain s k l::name and sl::name and sl'::name and m::name and n::name and
     sm::name and sm'::name and sn::name and sn'::name
     where atoms:
       "atom s \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn',l,k)"
       "atom k \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn',l)"
       "atom l \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn')"
       "atom sl \<sharp> (?vs,sl',m,n,sm,sm',sn,sn')" "atom sl' \<sharp> (?vs,m,n,sm,sm',sn,sn')"
       "atom m \<sharp> (?vs,n,sm,sm',sn,sn')" "atom n \<sharp> (?vs,sm,sm',sn,sn')"
       "atom sm \<sharp> (?vs,sm',sn,sn')" "atom sm' \<sharp> (?vs,sn,sn')"
       "atom sn \<sharp> (?vs,sn')" "atom sn' \<sharp> ?vs"
     by (metis obtain_fresh)
   then show ?thesis
   apply (subst HRP.simps[of s _ _ k]; simp)
     apply (subst SeqHRP.simps[of l _ _ sl sl' m n sm sm' sn sn']; simp?)
-    apply (rule Ex_I[where x="Eats Zero (HPair Zero (HPair (ORD_OF i) \<lceil>ORD_OF i\<rceil>))"]; simp)
+    apply (rule Ex_I[where x="Eats Zero (HPair Zero (HPair (ORD_OF i) \<guillemotleft>ORD_OF i\<guillemotright>))"]; simp)
     apply (rule Ex_I[where x="Zero"]; simp)
     apply (rule Conj_I[OF LstSeqP_single])
     apply (rule All2_SUCC_I, simp)
      apply auto [2]
     apply (rule Ex_I[where x="ORD_OF i"], simp)
-    apply (rule Ex_I[where x="\<lceil>ORD_OF i\<rceil>"], simp)
+    apply (rule Ex_I[where x="\<guillemotleft>ORD_OF i\<guillemotright>"], simp)
     apply (auto intro!: Disj_I1 WRP Mem_Eats_I2)
     done
 qed
 
 lemma SeqHRP_HPair:
   assumes "atom s \<sharp> (k,s1,s2,k1,k2,x,y,x',y')" "atom k \<sharp> (s1,s2,k1,k2,x,y,x',y')"
   shows "{SeqHRP x x' s1 k1,
             SeqHRP y y' s2 k2}
            \<turnstile> Ex s (Ex k (SeqHRP (HPair x y) (Q_HPair x' y') (Var s) (Var k)))" (*<*)
 proof -
   let ?vs = "(s1,s2,s,k1,k2,k,x,y,x',y')"
   obtain km::name and kn::name and j::name and k'::name
     and l::name and sl::name and sl'::name and m::name and n::name
     and sm::name and sm'::name and sn::name and sn'::name
     where atoms2: "atom km \<sharp> (kn,j,k',l,s1,s2,s,k1,k2,k,x,y,x',y',sl,sl',m,n,sm,sm',sn,sn')"
       "atom kn \<sharp> (j,k',l,s1,s2,s,k1,k2,k,x,y,x',y',sl,sl',m,n,sm,sm',sn,sn')"
       "atom j \<sharp> (k',l,s1,s2,s,k1,k2,k,x,y,x',y',sl,sl',m,n,sm,sm',sn,sn')"
       and atoms: "atom k' \<sharp> (l,s1,s2,s,k1,k2,k,x,y,x',y',sl,sl',m,n,sm,sm',sn,sn')"
       "atom l \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',sl,sl',m,n,sm,sm',sn,sn')"
       "atom sl \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',sl',m,n,sm,sm',sn,sn')"
       "atom sl' \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',m,n,sm,sm',sn,sn')"
       "atom m \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',n,sm,sm',sn,sn')"
       "atom n \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',sm,sm',sn,sn')"
       "atom sm \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',sm',sn,sn')"
       "atom sm' \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',sn,sn')"
       "atom sn \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',sn')"
       "atom sn' \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y')"
     by (metis obtain_fresh)
   let ?hyp = "{HaddP k1 k2 (Var k'), OrdP k1, OrdP k2, SeqAppendP s1 (SUCC k1) s2 (SUCC k2) (Var s),
                SeqHRP x x' s1 k1, SeqHRP y y' s2 k2}"
   show ?thesis
     using assms atoms
     apply (auto simp: SeqHRP.simps [of l "Var s" _ sl sl' m n sm sm' sn sn'])
     apply (rule cut_same [where A="OrdP k1 AND OrdP k2"])
      apply (metis Conj_I SeqHRP_imp_OrdP thin1 thin2)
     apply (rule cut_same [OF exists_SeqAppendP [of s s1 "SUCC k1" s2 "SUCC k2"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
       apply (rule cut_same [OF exists_HaddP [where j=k' and x=k1 and y=k2]])
         apply (rule AssumeH Ex_EH Conj_EH | simp)+
         apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC(SUCC(Var k'))) (HPair(HPair x y)(Q_HPair x' y')))"])
         apply (simp_all (no_asm_simp))
     apply (rule Ex_I [where x="SUCC (SUCC (Var k'))"], simp)
     apply (rule Conj_I)
      apply (blast intro: LstSeqP_SeqAppendP_Eats SeqHRP_imp_LstSeqP [THEN cut1])
   proof (rule All2_SUCC_I, simp_all)
     show "?hyp \<turnstile>     SyntaxN.Ex sl
      (SyntaxN.Ex sl'
        (HPair (SUCC (SUCC (Var k'))) (HPair (Var sl) (Var sl')) IN
         Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (HPair x y) (Q_HPair x' y'))) AND
         (OrdP (Var sl) AND WRP (Var sl) (Var sl') OR
          SyntaxN.Ex m
           (SyntaxN.Ex n
             (SyntaxN.Ex sm
               (SyntaxN.Ex sm'
                 (SyntaxN.Ex sn
                   (SyntaxN.Ex sn'
                     (Var m IN SUCC (SUCC (Var k')) AND
                      Var n IN SUCC (SUCC (Var k')) AND
                      HPair (Var m) (HPair (Var sm) (Var sm')) IN
                      Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (HPair x y) (Q_HPair x' y'))) AND
                      HPair (Var n) (HPair (Var sn) (Var sn')) IN
                      Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (HPair x y) (Q_HPair x' y'))) AND
                      Var sl EQ HPair (Var sm) (Var sn) AND Var sl' EQ Q_HPair (Var sm') (Var sn'))))))))))"
       \<comment> \<open>verifying the final values\<close>
       apply (rule Ex_I [where x="HPair x y"])
       using assms atoms apply simp
       apply (rule Ex_I [where x="Q_HPair x' y'"], simp)
       apply (rule Conj_I, metis Mem_Eats_I2 Refl)
       apply (rule Disj_I2)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x="SUCC (Var k')"], simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule_tac x=x' in Ex_I, simp)
       apply (rule Ex_I [where x=y], simp)
       apply (rule_tac x=y' in Ex_I, simp)
       apply (rule Conj_I)
        apply (blast intro: HaddP_Mem_I LstSeqP_OrdP Mem_SUCC_I1)
       apply (rule Conj_I [OF Mem_SUCC_Refl])
       apply (blast intro: Disj_I1 Mem_Eats_I1 Mem_SUCC_Refl SeqHRP_imp_LstSeqP [THEN cut1]
           LstSeqP_imp_Mem SeqAppendP_Mem1 [THEN cut3] SeqAppendP_Mem2 [THEN cut4] HaddP_SUCC1 [THEN cut1])
       done
   next
     show "?hyp \<turnstile>  All2 l (SUCC (SUCC (Var k')))
      (SyntaxN.Ex sl
        (SyntaxN.Ex sl'
          (HPair (Var l) (HPair (Var sl) (Var sl')) IN
           Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (HPair x y) (Q_HPair x' y'))) AND
           (OrdP (Var sl) AND WRP (Var sl) (Var sl') OR
            SyntaxN.Ex m
             (SyntaxN.Ex n
               (SyntaxN.Ex sm
                 (SyntaxN.Ex sm'
                   (SyntaxN.Ex sn
                     (SyntaxN.Ex sn'
                       (Var m IN Var l AND
                        Var n IN Var l AND
                        HPair (Var m) (HPair (Var sm) (Var sm')) IN
                        Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (HPair x y) (Q_HPair x' y'))) AND
                        HPair (Var n) (HPair (Var sn) (Var sn')) IN
                        Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (HPair x y) (Q_HPair x' y'))) AND
                        Var sl EQ HPair (Var sm) (Var sn) AND Var sl' EQ Q_HPair (Var sm') (Var sn')))))))))))"
       \<comment> \<open>verifying the sequence buildup\<close>
       apply (rule cut_same [where A="HaddP (SUCC k1) (SUCC k2) (SUCC (SUCC (Var k')))"])
        apply (blast intro: HaddP_SUCC1 [THEN cut1] HaddP_SUCC2 [THEN cut1])
       apply (rule All_I Imp_I)+
        apply (rule HaddP_Mem_cases [where i=j])
       using assms atoms atoms2 apply simp_all
           apply (rule AssumeH)
          apply (blast intro: OrdP_SUCC_I LstSeqP_OrdP)
         \<comment> \<open>... the sequence buildup via s1\<close>
         apply (simp add: SeqHRP.simps [of l s1 _ sl sl' m n sm sm' sn sn'])
         apply (rule AssumeH Ex_EH Conj_EH)+
         apply (rule All2_E [THEN rotate2])
           apply (simp | rule AssumeH Ex_EH Conj_EH)+
             apply (rule Ex_I [where x="Var sl"], simp)
             apply (rule Ex_I [where x="Var sl'"], simp)
             apply (rule Conj_I [OF Mem_Eats_I1])
              apply (metis SeqAppendP_Mem1 rotate3 thin2 thin4)
             apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
                         apply (rule Ex_I [where x="Var m"], simp)
                         apply (rule Ex_I [where x="Var n"], simp)
                         apply (rule Ex_I [where x="Var sm"], simp)
                         apply (rule Ex_I [where x="Var sm'"], simp)
                         apply (rule Ex_I [where x="Var sn"], simp)
                         apply (rule Ex_I [where x="Var sn'"], simp_all (no_asm_simp))
        apply (rule Conj_I, rule AssumeH)+
        apply (rule Conj_I)
         apply (blast intro: OrdP_Trans [OF OrdP_SUCC_I] Mem_Eats_I1 [OF SeqAppendP_Mem1 [THEN cut3]] Hyp)
        apply (blast intro: Disj_I1 Disj_I2 OrdP_Trans [OF OrdP_SUCC_I] Mem_Eats_I1 [OF SeqAppendP_Mem1 [THEN cut3]] Hyp)
         \<comment> \<open>... the sequence buildup via s2\<close>
       apply (simp add: SeqHRP.simps [of l s2 _ sl sl' m n sm sm' sn sn'])
       apply (rule AssumeH Ex_EH Conj_EH)+
       apply (rule All2_E [THEN rotate2])
         apply (simp | rule AssumeH Ex_EH Conj_EH)+
           apply (rule Ex_I [where x="Var sl"], simp)
           apply (rule Ex_I [where x="Var sl'"], simp)
           apply (rule cut_same [where A="OrdP (Var j)"])
            apply (metis HaddP_imp_OrdP rotate2 thin2)
           apply (rule Conj_I)
            apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] del: Disj_EH)
           apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
                       apply (rule cut_same [OF exists_HaddP [where j=km and x="SUCC k1" and y="Var m"]])
                         apply (blast intro: Ord_IN_Ord, simp)
                       apply (rule cut_same [OF exists_HaddP [where j=kn and x="SUCC k1" and y="Var n"]])
                         apply (metis AssumeH(6) Ord_IN_Ord0 rotate8, simp)
                       apply (rule AssumeH Ex_EH Conj_EH | simp)+
                           apply (rule Ex_I [where x="Var km"], simp)
                           apply (rule Ex_I [where x="Var kn"], simp)
                           apply (rule Ex_I [where x="Var sm"], simp)
                           apply (rule Ex_I [where x="Var sm'"], simp)
                           apply (rule Ex_I [where x="Var sn"], simp)
                           apply (rule Ex_I [where x="Var sn'"], simp_all (no_asm_simp))
       apply (rule Conj_I [OF _ Conj_I])
         apply (blast intro!: HaddP_Mem_cancel_left [THEN Iff_MP2_same] OrdP_SUCC_I intro: LstSeqP_OrdP Hyp)+
       apply (blast del: Disj_EH  intro: OrdP_Trans Hyp
           intro!: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] HaddP_imp_OrdP [THEN cut1])
       done
   qed
 qed (*>*)
 
 lemma HRP_HPair: "{HRP x x', HRP y y'} \<turnstile> HRP (HPair x y) (Q_HPair x' y')"
 proof -
   obtain k1::name and s1::name and k2::name and s2::name and k::name and s::name
     where "atom s1 \<sharp> (x,y,x',y')"        "atom k1 \<sharp> (x,y,x',y',s1)"
       "atom s2 \<sharp> (x,y,x',y',k1,s1)"  "atom k2 \<sharp> (x,y,x',y',s2,k1,s1)"
       "atom s  \<sharp> (x,y,x',y',k2,s2,k1,s1)" "atom k  \<sharp> (x,y,x',y',s,k2,s2,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (force simp: HRP.simps [of s "HPair x y" _ k]
         HRP.simps [of s1 x _ k1]
         HRP.simps [of s2 y _ k2]
         intro: SeqHRP_HPair [THEN cut2])
 qed
 
-lemma HRP_HPair_quot: "{HRP x \<lceil>x\<rceil>, HRP y \<lceil>y\<rceil>} \<turnstile> HRP (HPair x y) \<lceil>HPair x y\<rceil>"
-  using HRP_HPair[of x "\<lceil>x\<rceil>" y "\<lceil>y\<rceil>"]
+lemma HRP_HPair_quot: "{HRP x \<guillemotleft>x\<guillemotright>, HRP y \<guillemotleft>y\<guillemotright>} \<turnstile> HRP (HPair x y) \<guillemotleft>HPair x y\<guillemotright>"
+  using HRP_HPair[of x "\<guillemotleft>x\<guillemotright>" y "\<guillemotleft>y\<guillemotright>"]
   unfolding HPair_def quot_simps by auto
 
-lemma prove_HRP_coding_tm: fixes t::tm shows "coding_tm t \<Longrightarrow> {} \<turnstile> HRP t \<lceil>t\<rceil>"
+lemma prove_HRP_coding_tm: fixes t::tm shows "coding_tm t \<Longrightarrow> {} \<turnstile> HRP t \<guillemotleft>t\<guillemotright>"
   by (induct t rule: coding_tm.induct)
     (auto simp: quot_simps HRP_ORD_OF HRP_HPair_quot[THEN cut2])
 
 lemmas prove_HRP = prove_HRP_coding_tm[OF quot_fm_coding]
 
 section\<open>The Function K and Lemma 6.3\<close>
 
 nominal_function KRP :: "tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> fm"
   where "atom y \<sharp> (v,x,x') \<Longrightarrow>
          KRP v x x' = Ex y (HRP x (Var y) AND SubstFormP v (Var y) x x')"
   by (auto simp: eqvt_def KRP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma KRP_fresh_iff [simp]: "a \<sharp> KRP v x x' \<longleftrightarrow> a \<sharp> v \<and> a \<sharp> x \<and> a \<sharp> x'"
 proof -
   obtain y::name where "atom y \<sharp> (v,x,x')"
     by (metis obtain_fresh)
   thus ?thesis
     by auto
 qed
 
 lemma KRP_subst [simp]: "(KRP v x x')(i::=t) = KRP (subst i t v) (subst i t x) (subst i t x')"
 proof -
   obtain y::name where "atom y \<sharp> (v,x,x',t,i)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: KRP.simps [of y])
 qed
 
 declare KRP.simps [simp del]
 
-lemma prove_SubstFormP: "{} \<turnstile> SubstFormP \<lceil>Var i\<rceil> \<lceil>\<lceil>A\<rceil>\<rceil> \<lceil>A\<rceil> \<lceil>A(i::=\<lceil>A\<rceil>)\<rceil>"
+lemma prove_SubstFormP: "{} \<turnstile> SubstFormP \<guillemotleft>Var i\<guillemotright> \<guillemotleft>\<guillemotleft>A\<guillemotright>\<guillemotright> \<guillemotleft>A\<guillemotright> \<guillemotleft>A(i::=\<guillemotleft>A\<guillemotright>)\<guillemotright>"
   using SubstFormP by blast
 
-lemma prove_KRP: "{} \<turnstile> KRP \<lceil>Var i\<rceil> \<lceil>A\<rceil> \<lceil>A(i::=\<lceil>A\<rceil>)\<rceil>"
+lemma prove_KRP: "{} \<turnstile> KRP \<guillemotleft>Var i\<guillemotright> \<guillemotleft>A\<guillemotright> \<guillemotleft>A(i::=\<guillemotleft>A\<guillemotright>)\<guillemotright>"
   by (auto simp: KRP.simps [of y]
-           intro!: Ex_I [where x="\<lceil>\<lceil>A\<rceil>\<rceil>"] prove_HRP prove_SubstFormP)
+           intro!: Ex_I [where x="\<guillemotleft>\<guillemotleft>A\<guillemotright>\<guillemotright>"] prove_HRP prove_SubstFormP)
 
 lemma KRP_unique: "{KRP v x y, KRP v x y'} \<turnstile> y' EQ y"
 proof -
   obtain u::name and u'::name where "atom u \<sharp> (v,x,y,y')" "atom u' \<sharp> (v,x,y,y',u)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: KRP.simps [of u v x y] KRP.simps [of u' v x y']
              intro: SubstFormP_cong [THEN Iff_MP2_same]
                     SubstFormP_unique [THEN cut2] HRP_unique [THEN cut2])
 qed
 
-lemma KRP_subst_fm: "{KRP \<lceil>Var i\<rceil> \<lceil>\<beta>\<rceil> (Var j)} \<turnstile> Var j EQ \<lceil>\<beta>(i::=\<lceil>\<beta>\<rceil>)\<rceil>"
+lemma KRP_subst_fm: "{KRP \<guillemotleft>Var i\<guillemotright> \<guillemotleft>\<beta>\<guillemotright> (Var j)} \<turnstile> Var j EQ \<guillemotleft>\<beta>(i::=\<guillemotleft>\<beta>\<guillemotright>)\<guillemotright>"
   by (metis KRP_unique cut0 prove_KRP)
 
 end
 
diff --git a/thys/Goedel_HFSet_Semanticless/II_Prelims.thy b/thys/Goedel_HFSet_Semanticless/II_Prelims.thy
--- a/thys/Goedel_HFSet_Semanticless/II_Prelims.thy
+++ b/thys/Goedel_HFSet_Semanticless/II_Prelims.thy
@@ -1,4582 +1,4582 @@
 chapter\<open>Syntactic Preliminaries for the Second Incompleteness Theorem\<close>
 
 theory II_Prelims
 imports Pf_Predicates
 begin
 
 declare IndP.simps [simp del]
 
 lemma OrdP_ORD_OF [intro]: "H \<turnstile> OrdP (ORD_OF n)"
 proof -
   have "{} \<turnstile> OrdP (ORD_OF n)"
     by (induct n) (auto simp: OrdP_SUCC_I)
   thus ?thesis
     by (rule thin0)
 qed
 
-lemma VarP_Var [intro]: "H \<turnstile> VarP \<lceil>Var i\<rceil>"
+lemma VarP_Var [intro]: "H \<turnstile> VarP \<guillemotleft>Var i\<guillemotright>"
   unfolding VarP_def
   by (auto simp: quot_Var OrdP_ORD_OF intro!: OrdP_SUCC_I cut1[OF Zero_In_SUCC])
 
 lemma VarP_neq_IndP: "{t EQ v, VarP v, IndP t} \<turnstile> Fls"
 proof -
   obtain m::name where "atom m \<sharp> (t,v)"
     by (metis obtain_fresh)
   thus ?thesis
     apply (auto simp: VarP_def IndP.simps [of m])
     apply (rule cut_same [of _ "OrdP (Q_Ind (Var m))"])
     apply (blast intro: Sym Trans OrdP_cong [THEN Iff_MP_same])
     by (metis OrdP_HPairE)
 qed
 
 lemma Mem_HFun_Sigma_OrdP: "{HPair t u IN f, HFun_Sigma f} \<turnstile> OrdP t"
 proof -
   obtain x::name and y::name and z::name and x'::name and y'::name and z'::name
     where "atom z \<sharp> (f,t,u,z',x,y,x',y')"  "atom z' \<sharp> (f,t,u,x,y,x',y')"
        "atom x \<sharp> (f,t,u,y,x',y')"  "atom y \<sharp> (f,t,u,x',y')"
        "atom x' \<sharp> (f,t,u,y')"  "atom y' \<sharp> (f,t,u)"
     by (metis obtain_fresh)
   thus ?thesis
   apply (simp add: HFun_Sigma.simps [of z f z' x y x' y'])
   apply (rule All2_E [where x="HPair t u", THEN rotate2], auto)
   apply (rule All2_E [where x="HPair t u"], auto intro: OrdP_cong [THEN Iff_MP2_same])
   done
 qed
 
 section \<open>NotInDom\<close>
 
 nominal_function NotInDom :: "tm \<Rightarrow> tm \<Rightarrow> fm"
   where "atom z \<sharp> (t, r) \<Longrightarrow> NotInDom t r = All z (Neg (HPair t (Var z) IN r))"
 by (auto simp: eqvt_def NotInDom_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma NotInDom_fresh_iff [simp]: "a \<sharp> NotInDom t r \<longleftrightarrow> a \<sharp> (t, r)"
 proof -
   obtain j::name where "atom j \<sharp> (t,r)"
     by (rule obtain_fresh)
   thus ?thesis
     by auto
 qed
 
 lemma subst_fm_NotInDom [simp]: "(NotInDom t r)(i::=x) = NotInDom (subst i x t) (subst i x r)"
 proof -
   obtain j::name where "atom j \<sharp> (i,x,t,r)"
     by (rule obtain_fresh)
   thus ?thesis
     by (auto simp: NotInDom.simps [of j])
 qed
 
 lemma NotInDom_cong: "H \<turnstile> t EQ t' \<Longrightarrow> H \<turnstile> r EQ r' \<Longrightarrow> H \<turnstile> NotInDom t r IFF NotInDom t' r'"
   by (rule P2_cong) auto
 
 lemma NotInDom_Zero: "H \<turnstile> NotInDom t Zero"
 proof -
   obtain z::name where "atom z \<sharp> t"
     by (metis obtain_fresh)
   hence "{} \<turnstile> NotInDom t Zero"
     by (auto simp: fresh_Pair)
   thus ?thesis
     by (rule thin0)
 qed
 
 lemma NotInDom_Fls: "{HPair d d' IN r, NotInDom d r} \<turnstile> A"
 proof -
   obtain z::name where "atom z \<sharp> (d,r)"
     by (metis obtain_fresh)
   hence "{HPair d d' IN r, NotInDom d r} \<turnstile> Fls"
     by (auto intro!: Ex_I [where x=d'])
   thus ?thesis
     by (metis ExFalso)
 qed
 
 lemma NotInDom_Contra: "H \<turnstile> NotInDom d r \<Longrightarrow> H \<turnstile> HPair x y IN r \<Longrightarrow> insert (x EQ d) H \<turnstile> A"
 by (rule NotInDom_Fls [THEN cut2, THEN ExFalso])
    (auto intro: thin1 NotInDom_cong [OF Assume Refl, THEN Iff_MP2_same])
 
 
 section \<open>Restriction of a Sequence to a Domain\<close>
 
 nominal_function RestrictedP :: "tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> fm"
   where "\<lbrakk>atom x \<sharp> (y,f,k,g); atom y \<sharp> (f,k,g)\<rbrakk> \<Longrightarrow>
     RestrictedP f k g =
       g SUBS f AND
       All x (All y (HPair (Var x) (Var y) IN g IFF
                     (Var x) IN k AND HPair (Var x) (Var y) IN f))"
 by (auto simp: eqvt_def RestrictedP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma RestrictedP_fresh_iff [simp]: "a \<sharp> RestrictedP f k g \<longleftrightarrow> a \<sharp> f \<and> a \<sharp> k \<and> a \<sharp> g"
 proof -
   obtain x::name and y::name where "atom x \<sharp> (y,f,k,g)" "atom y \<sharp> (f,k,g)"
     by (metis obtain_fresh)
   thus ?thesis
     by auto
 qed
 
 lemma subst_fm_RestrictedP [simp]:
   "(RestrictedP f k g)(i::=u) = RestrictedP (subst i u f) (subst i u k) (subst i u g)"
 proof -
   obtain x::name and y::name  where "atom x \<sharp> (y,f,k,g,i,u)" "atom y \<sharp> (f,k,g,i,u)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: RestrictedP.simps [of x y])
 qed
 
 lemma RestrictedP_cong:
   "\<lbrakk>H \<turnstile> f EQ f'; H \<turnstile> k EQ A'; H \<turnstile> g EQ g'\<rbrakk>
    \<Longrightarrow> H \<turnstile> RestrictedP f k g IFF RestrictedP f' A' g'"
   by (rule P3_cong) auto
 
 lemma RestrictedP_Zero: "H \<turnstile> RestrictedP Zero k Zero"
 proof -
   obtain x::name and y::name  where "atom x \<sharp> (y,k)" "atom y \<sharp> (k)"
     by (metis obtain_fresh)
   hence "{} \<turnstile> RestrictedP Zero k Zero"
     by (auto simp: RestrictedP.simps [of x y])
   thus ?thesis
     by (rule thin0)
 qed
 
 lemma RestrictedP_Mem: "{ RestrictedP s k s', HPair a b IN s, a IN k } \<turnstile> HPair a b IN s'"
 proof -
   obtain x::name and y::name where "atom x \<sharp> (y,s,k,s',a,b)" "atom y \<sharp> (s,k,s',a,b)"
     by (metis obtain_fresh)
   thus ?thesis
     apply (auto simp: RestrictedP.simps [of x y])
     apply (rule All_E [where x=a, THEN rotate2], auto)
     apply (rule All_E [where x=b], auto intro: Iff_E2)
     done
 qed
 
 lemma RestrictedP_imp_Subset: "{RestrictedP s k s'} \<turnstile> s' SUBS s"
 proof -
   obtain x::name and y::name where "atom x \<sharp> (y,s,k,s')" "atom y \<sharp> (s,k,s')"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: RestrictedP.simps [of x y])
 qed
 
 lemma RestrictedP_Mem2:
   "{ RestrictedP s k s', HPair a b IN s' } \<turnstile> HPair a b IN s AND a IN k"
 proof -
   obtain x::name and y::name where "atom x \<sharp> (y,s,k,s',a,b)" "atom y \<sharp> (s,k,s',a,b)"
     by (metis obtain_fresh)
   thus ?thesis
     apply (auto simp: RestrictedP.simps [of x y] intro: Subset_D)
     apply (rule All_E [where x=a, THEN rotate2], auto)
     apply (rule All_E [where x=b], auto intro: Iff_E1)
     done
 qed
 
 lemma RestrictedP_Mem_D: "H \<turnstile> RestrictedP s k t \<Longrightarrow> H \<turnstile> a IN t \<Longrightarrow> insert (a IN s) H \<turnstile> A \<Longrightarrow> H \<turnstile> A"
   by (metis RestrictedP_imp_Subset Subset_E cut1)
 
 lemma RestrictedP_Eats:
   "{ RestrictedP s k s', a IN k } \<turnstile> RestrictedP (Eats s (HPair a b)) k (Eats s' (HPair a b))" (*<*)
 proof -
   obtain x::name and y::name
   where "atom x \<sharp> (y,s,k,s',a,b)" "atom y \<sharp> (s,k,s',a,b)"
     by (metis obtain_fresh)
   thus ?thesis
     apply (auto simp: RestrictedP.simps [of x y])
       apply (metis Assume Subset_Eats_I Subset_trans)
      apply (metis Mem_Eats_I2 Refl)
     apply (rule Swap, auto)
          apply (rule All_E [where x="Var x", THEN rotate2], auto)
          apply (rule All_E [where x="Var y"], simp)
          apply (metis Assume Conj_E Iff_E1)
         apply (blast intro: Subset_D)
        apply (blast intro: Mem_cong [THEN Iff_MP2_same])
       apply (metis Assume AssumeH(2) HPair_cong Mem_Eats_I2)
      apply (rule All_E [where x="Var x", THEN rotate3], auto)
      apply (rule All_E [where x="Var y"], simp)
      apply (metis Assume AssumeH(2) Conj_I Iff_E2 Mem_Eats_I1)
     apply (blast intro: Mem_Eats_I2 HPair_cong)
    done
 qed (*>*)
 
 lemma exists_RestrictedP:
   assumes s: "atom s \<sharp> (f,k)"
   shows  "H \<turnstile> Ex s (RestrictedP f k (Var s))" (*<*)
 proof -
   obtain j::name and x::name and y::name and z::name
     where atoms: "atom j \<sharp> (k,z,s)"  "atom x \<sharp> (j,k,z,s)"  "atom y \<sharp> (x,j,k,z,s)"  "atom z \<sharp> (s,k)"
     by (metis obtain_fresh)
   have "{} \<turnstile> Ex s (RestrictedP (Var z) k (Var s))"
     apply (rule Ind [of j z]) using atoms s
     apply simp_all
     apply (rule Ex_I [where x=Zero], simp add: RestrictedP_Zero)
     apply (rule All_I)+
     apply (auto del: Ex_EH)
     apply (rule thin1)
     apply (rule Ex_E)
     proof (rule Cases [where A="Ex x (Ex y ((Var x) IN k AND Var j EQ HPair (Var x) (Var y)))"], auto)
       show "{Var x IN k, Var j EQ HPair (Var x) (Var y), RestrictedP (Var z) k (Var s)}
             \<turnstile> Ex s (RestrictedP (Eats (Var z) (Var j)) k (Var s))"
         apply (rule Ex_I [where x="Eats (Var s) (HPair (Var x) (Var y))"])
         using atoms s apply auto
         apply (rule RestrictedP_cong [OF _ Refl Refl, THEN Iff_MP2_same])
         apply (blast intro: Eats_cong [OF Refl])
         apply (rule Var_Eq_subst_Iff [THEN rotate2, THEN Iff_MP_same])
         apply (auto intro: RestrictedP_Eats [THEN cut2])
         done
     next
       obtain u::name and v::name
       where uv: "atom u \<sharp> (x,y,z,s,j,k)" "atom v \<sharp> (u,x,y,z,s,j,k)"
         by (metis obtain_fresh)
       show "{Neg (Ex x (Ex y (Var x IN k AND Var j EQ HPair (Var x) (Var y)))),
              RestrictedP (Var z) k (Var s)} \<turnstile>
              Ex s (RestrictedP (Eats (Var z) (Var j)) k (Var s))"
         apply (rule Ex_I [where x="Var s"])
         using uv atoms
         apply (auto simp: RestrictedP.simps [of u v])
          apply (metis Assume Subset_Eats_I Subset_trans)
         apply (rule Swap, auto)
            apply (rule All_E [THEN rotate4, of _ _ "Var u"], auto)
            apply (rule All_E [where x="Var v"], simp)
            apply (metis Assume Conj_E Iff_E1)
           apply (rule Mem_Eats_I1)
           apply (metis Assume AssumeH(3) Subset_D)
          apply (rule All_E [where x="Var u", THEN rotate5], auto)
          apply (rule All_E [where x="Var v"], simp)
          apply (metis Assume AssumeH(2) Conj_I Iff_E2)
         apply (rule ContraProve [THEN rotate3])
        apply (rule Ex_I [where x="Var u"], simp)
        apply (rule Ex_I [where x="Var v"], auto intro: Sym)
        done
     qed
   hence "{} \<turnstile> (Ex s (RestrictedP (Var z) k (Var s)))(z::=f)"
     by (rule Subst) simp
   thus ?thesis using atoms s
     by simp (rule thin0)
 qed (*>*)
 
 lemma cut_RestrictedP:
   assumes s: "atom s \<sharp> (f,k,A)" and "\<forall>C \<in> H. atom s \<sharp> C"
   shows  "insert (RestrictedP f k (Var s)) H \<turnstile> A \<Longrightarrow> H \<turnstile> A"
   apply (rule cut_same [OF exists_RestrictedP [of s]])
   using assms apply auto
   done
 
 lemma RestrictedP_NotInDom: "{ RestrictedP s k s', Neg (j IN k) } \<turnstile> NotInDom j s'"
 proof -
   obtain x::name and y::name and z::name
   where "atom x \<sharp> (y,s,j,k,s')" "atom y \<sharp> (s,j,k,s')" "atom z \<sharp> (s,j,k,s')"
     by (metis obtain_fresh)
   thus ?thesis
     apply (auto simp: RestrictedP.simps [of x y] NotInDom.simps [of z])
     apply (rule All_E [where x=j, THEN rotate3], auto)
     apply (rule All_E, auto intro: Conj_E1 Iff_E1)
     done
 qed
 
 declare RestrictedP.simps [simp del]
 
 section \<open>Applications to LstSeqP\<close>
 
 lemma HFun_Sigma_Eats:
   assumes "H \<turnstile> HFun_Sigma r" "H \<turnstile> NotInDom d r" "H \<turnstile> OrdP d"
     shows "H \<turnstile> HFun_Sigma (Eats r (HPair d d'))" (*<*)
 proof -
   obtain x::name and y::name and z::name and x'::name and y'::name and z'::name and z''::name
     where "atom z'' \<sharp> (r,d,d',z,z',x,y,x',y')"
       and "atom z \<sharp> (r,d,d',z',x,y,x',y')" and "atom z' \<sharp> (r,d,d',x,y,x',y')"
       and "atom x \<sharp> (r,d,d',y,x',y')" and "atom y \<sharp> (r,d,d',x',y')"
       and "atom x' \<sharp> (r,d,d',y')" and "atom y' \<sharp> (r,d,d')"
     by (metis obtain_fresh)
   hence "{ HFun_Sigma r, NotInDom d r, OrdP d } \<turnstile> HFun_Sigma (Eats r (HPair d d'))"
     apply (auto simp: HFun_Sigma.simps [of z _ z' x y x' y'])
       \<comment> \<open>case 1\<close>
        apply (rule Ex_I [where x = "Var z"], simp)
        apply (rule Neg_Imp_I, blast)
       apply (rule All_E [where x = "Var z'"], auto)
       \<comment> \<open>case 2\<close>
       apply (rule Ex_I [where x = "Var z"], simp)
       apply (rule Neg_Imp_I, blast)
       apply (rule All_E [where x = "Var z"], simp)
       apply (rule Imp_E, auto del: Disj_EH)
       apply (rule thin1)
       apply (rule thin1)
       apply (rule Ex_I [where x = "Var x"], simp)
       apply (rule Ex_I [where x = "Var y"], simp)
       apply (rule Ex_I [where x = d], simp)
       apply (rule Ex_I [where x = d'], auto)
       apply (blast intro: Disj_I1 OrdNotEqP_I NotInDom_Contra Mem_cong [THEN Iff_MP_same])
     \<comment> \<open>case 3\<close>
     apply (rule Ex_I [where x = "Var z'"])
     apply (subst subst_fm_Ex_with_renaming [where i'=z''] | subst subst_fm.simps)+
     apply (auto simp add: flip_fresh_fresh)
     apply (rule Ex_I [where x = "Var z'", THEN Swap], simp)
     apply (rule Neg_I)
     apply (rule Imp_E, auto del: Disj_EH)
     apply (rule thin1)
     apply (rule thin1)
     apply (rule Ex_I [where x = d], simp)
     apply (rule Ex_I [where x = d'], simp)
     apply (rule Ex_I [where x = "Var x"], simp)
     apply (rule Ex_I [where x = "Var y"], auto)
     apply (blast intro: Disj_I1 Sym_L OrdNotEqP_I NotInDom_Contra Mem_cong [THEN Iff_MP_same])
     \<comment> \<open>case 4\<close>
     apply (rule rotate2 [OF Swap])
     apply (rule Ex_I [where x = d], auto)
     apply (rule Ex_I [where x = d'], auto)
     apply (rule Ex_I [where x = d], auto)
     apply (rule Ex_I [where x = d'], auto intro: Disj_I2)
     done
   thus ?thesis using assms
     by (rule cut3)
 qed (*>*)
 
 lemma HFun_Sigma_single [iff]: "H \<turnstile> OrdP d \<Longrightarrow> H \<turnstile> HFun_Sigma (Eats Zero (HPair d d'))"
   by (metis HFun_Sigma_Eats HFun_Sigma_Zero NotInDom_Zero)
 
 lemma LstSeqP_single [iff]: "H \<turnstile> LstSeqP (Eats Zero (HPair Zero x)) Zero x"
   by (auto simp: LstSeqP.simps intro!: OrdP_SUCC_I HDomain_Incl_Eats_I Mem_Eats_I2)
 
 lemma NotInDom_LstSeqP_Eats:
   "{ NotInDom (SUCC k) s, LstSeqP s k y } \<turnstile> LstSeqP (Eats s (HPair (SUCC k) z)) (SUCC k) z"
 by (auto simp: LstSeqP.simps intro: HDomain_Incl_Eats_I Mem_Eats_I2 OrdP_SUCC_I HFun_Sigma_Eats)
 
 lemma RestrictedP_HDomain_Incl: "{HDomain_Incl s k, RestrictedP s k s'} \<turnstile> HDomain_Incl s' k"
 proof -
   obtain u::name and v::name and x::name and y::name and z::name
     where "atom u \<sharp> (v,s,k,s')" "atom v \<sharp> (s,k,s')"
           "atom x \<sharp> (s,k,s',u,v,y,z)" "atom y \<sharp> (s,k,s',u,v,z)" "atom z \<sharp> (s,k,s',u,v)"
     by (metis obtain_fresh)
   thus ?thesis
     apply (auto simp: HDomain_Incl.simps [of x _ _ y z])
     apply (rule Ex_I [where x="Var x"], auto)
     apply (rule Ex_I [where x="Var y"], auto)
     apply (rule Ex_I [where x="Var z"], simp)
     apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same, THEN rotate2])
     apply (auto simp: RestrictedP.simps [of u v])
     apply (rule All_E [where x="Var x", THEN rotate2], auto)
     apply (rule All_E [where x="Var y"])
     apply (auto intro: Iff_E ContraProve Mem_cong [THEN Iff_MP_same])
     done
 qed
 
 lemma RestrictedP_HFun_Sigma: "{HFun_Sigma s, RestrictedP s k s'} \<turnstile> HFun_Sigma s'"
   by (metis Assume RestrictedP_imp_Subset Subset_HFun_Sigma rcut2)
 
 lemma RestrictedP_LstSeqP:
   "{ RestrictedP s (SUCC k) s', LstSeqP s k y } \<turnstile> LstSeqP s' k y"
   by (auto simp: LstSeqP.simps
            intro: Mem_Neg_refl cut2 [OF RestrictedP_HDomain_Incl]
                                cut2 [OF RestrictedP_HFun_Sigma] cut3 [OF RestrictedP_Mem])
 
 lemma RestrictedP_LstSeqP_Eats:
   "{ RestrictedP s (SUCC k) s', LstSeqP s k y }
    \<turnstile> LstSeqP (Eats s' (HPair (SUCC k) z)) (SUCC k) z"
 by (blast intro: Mem_Neg_refl cut2 [OF NotInDom_LstSeqP_Eats]
                               cut2 [OF RestrictedP_NotInDom] cut2 [OF RestrictedP_LstSeqP])
 
 
 section\<open>Ordinal Addition\<close>
 
 subsection\<open>Predicate form, defined on sequences\<close>
 
 nominal_function SeqHaddP :: "tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> fm"
   where "\<lbrakk>atom l \<sharp> (sl,s,k,j); atom sl \<sharp> (s,j)\<rbrakk> \<Longrightarrow>
     SeqHaddP s j k y = LstSeqP s k y AND
           HPair Zero j IN s AND
           All2 l k (Ex sl (HPair (Var l) (Var sl) IN s AND
                            HPair (SUCC (Var l)) (SUCC (Var sl)) IN s))"
 by (auto simp: eqvt_def SeqHaddP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma SeqHaddP_fresh_iff [simp]: "a \<sharp> SeqHaddP s j k y \<longleftrightarrow> a \<sharp> s \<and> a \<sharp> j \<and> a \<sharp> k \<and> a \<sharp> y"
 proof -
   obtain l::name and sl::name where "atom l \<sharp> (sl,s,k,j)" "atom sl \<sharp> (s,j)"
     by (metis obtain_fresh)
   thus ?thesis
     by force
 qed
 
 lemma SeqHaddP_subst [simp]:
   "(SeqHaddP s j k y)(i::=t) = SeqHaddP (subst i t s) (subst i t j) (subst i t k) (subst i t y)"
 proof -
   obtain l::name and sl::name where "atom l \<sharp> (s,k,j,sl,t,i)" "atom sl \<sharp> (s,k,j,t,i)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: SeqHaddP.simps [where l=l and sl=sl])
 qed
 
 declare SeqHaddP.simps [simp del]
 
 nominal_function HaddP :: "tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> fm"
   where "\<lbrakk>atom s \<sharp> (x,y,z)\<rbrakk> \<Longrightarrow>
     HaddP x y z = Ex s (SeqHaddP (Var s) x y z)"
 by (auto simp: eqvt_def HaddP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma HaddP_fresh_iff [simp]: "a \<sharp> HaddP x y z \<longleftrightarrow> a \<sharp> x \<and> a \<sharp> y \<and> a \<sharp> z"
 proof -
   obtain s::name where "atom s \<sharp> (x,y,z)"
     by (metis obtain_fresh)
   thus ?thesis
     by force
 qed
 
 lemma HaddP_subst [simp]: "(HaddP x y z)(i::=t) = HaddP (subst i t x) (subst i t y) (subst i t z)"
 proof -
   obtain s::name where "atom s \<sharp> (x,y,z,t,i)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: HaddP.simps [of s])
 qed
 
 lemma HaddP_cong: "\<lbrakk>H \<turnstile> t EQ t'; H \<turnstile> u EQ u'; H \<turnstile> v EQ v'\<rbrakk> \<Longrightarrow> H \<turnstile> HaddP t u v IFF HaddP t' u' v'"
   by (rule P3_cong) auto
 
 declare HaddP.simps [simp del]
 
 lemma HaddP_Zero2: "H \<turnstile> HaddP x Zero x"
 proof -
   obtain s::name and l::name and sl::name where "atom l \<sharp> (sl,s,x)" "atom sl \<sharp> (s,x)" "atom s \<sharp> x"
     by (metis obtain_fresh)
   hence "{} \<turnstile> HaddP x Zero x"
     by (auto simp: HaddP.simps [of s] SeqHaddP.simps [of l sl]
           intro!: Mem_Eats_I2 Ex_I [where x="Eats Zero (HPair Zero x)"])
   thus ?thesis
     by (rule thin0)
 qed
 
 lemma HaddP_imp_OrdP: "{HaddP x y z} \<turnstile> OrdP y"
 proof -
   obtain s::name and l::name and sl::name
     where "atom l \<sharp> (sl,s,x,y,z)" "atom sl \<sharp> (s,x,y,z)" "atom s \<sharp> (x,y,z)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: HaddP.simps [of s] SeqHaddP.simps [of l sl] LstSeqP.simps)
 qed
 
 lemma HaddP_SUCC2: "{HaddP x y z} \<turnstile> HaddP x (SUCC y) (SUCC z)" (*<*)
 proof -
   obtain s::name and s'::name and l::name and sl::name
     where "atom s' \<sharp> (l,sl,s,x,y,z)" "atom l \<sharp> (sl,s,x,y,z)" "atom sl \<sharp> (s,x,y,z)" "atom s \<sharp> (x,y,z)"
     by (metis obtain_fresh)
   hence "{HaddP x y z, OrdP y} \<turnstile> HaddP x (SUCC y) (SUCC z)"
     apply (auto simp: HaddP.simps [of s] SeqHaddP.simps [of l sl])
     apply (rule cut_RestrictedP [of s' "Var s" "SUCC y"], auto)
     apply (rule Ex_I [where x="Eats (Var s') (HPair (SUCC y) (SUCC z))"])
        apply (auto intro!: Mem_SUCC_EH)
        apply (metis rotate2 RestrictedP_LstSeqP_Eats rotate3 thin1)
       apply (blast intro: Mem_Eats_I1 cut3 [OF RestrictedP_Mem] cut1 [OF Zero_In_SUCC])
      apply (rule Ex_I [where x="Var l"], auto)
      apply (rule Ex_I [where x="Var sl"], auto)
      apply (blast intro: Mem_Eats_I1 cut3 [OF RestrictedP_Mem] Mem_SUCC_I1)
     apply (blast intro: Mem_Eats_I1 cut3 [OF RestrictedP_Mem] OrdP_IN_SUCC)
    apply (rule ContraProve [THEN rotate2])
    apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same], simp add: LstSeqP.simps)
    apply (rule Ex_I [where x=z])
    apply (force intro: Mem_Eats_I1 Mem_Eats_I2 cut3 [OF RestrictedP_Mem] Mem_SUCC_I2)
    done
  thus ?thesis
    by (metis Assume HaddP_imp_OrdP cut2)
 qed (*>*)
 
 subsection\<open>Proving that these relations are functions\<close>
 
 lemma SeqHaddP_Zero_E: "{SeqHaddP s w Zero z} \<turnstile> w EQ z"
 proof -
   obtain l::name and sl::name where "atom l \<sharp> (s,w,z,sl)" "atom sl \<sharp> (s,w)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: SeqHaddP.simps [of l sl] LstSeqP.simps intro: HFun_Sigma_E)
 qed
 
 lemma SeqHaddP_SUCC_lemma:
   assumes y': "atom y' \<sharp> (s,j,k,y)"
   shows "{SeqHaddP s j (SUCC k) y} \<turnstile> Ex y' (SeqHaddP s j k (Var y') AND y EQ SUCC (Var y'))"
 proof -
   obtain l::name and sl::name  where "atom l \<sharp> (s,j,k,y,y',sl)" "atom sl \<sharp> (s,j,k,y,y')"
     by (metis obtain_fresh)
   thus ?thesis using y'
     apply (auto simp: SeqHaddP.simps [where s=s and l=l and sl=sl])
     apply (rule All2_SUCC_E' [where t=k, THEN rotate2], auto)
     apply (auto intro!: Ex_I [where x="Var sl"])
     apply (blast intro: LstSeqP_SUCC) \<comment> \<open>showing @{term"SeqHaddP s j k (Var sl)"}\<close>
     apply (blast intro: LstSeqP_EQ)
     done
 qed
 
 lemma SeqHaddP_SUCC:
   assumes "H \<turnstile> SeqHaddP s j (SUCC k) y"  "atom y' \<sharp> (s,j,k,y)"
   shows "H \<turnstile> Ex y' (SeqHaddP s j k (Var y') AND y EQ SUCC (Var y'))"
   by (metis SeqHaddP_SUCC_lemma [THEN cut1] assms)
 
 lemma SeqHaddP_unique: "{OrdP x, SeqHaddP s w x y, SeqHaddP s' w x y'} \<turnstile> y' EQ y" (*<*)
 proof -
   obtain i::name and j::name and j'::name and k::name and sl::name and sl'::name
      and l::name and ji::name and ji'::name
    where ij: "atom i \<sharp> (s,s',w,y,y')" "atom j \<sharp> (s,s',w,i,x,y,y')" "atom j' \<sharp> (s,s',w,i,j,x,y,y')"
      and atoms: "atom k \<sharp> (s,s',w,i,j,j')" "atom sl \<sharp> (s,s',w,i,j,j',k)" "atom sl' \<sharp> (s,s',w,i,j,j',k,sl)"
                 "atom ji \<sharp> (s,s',w,i,j,j',k,sl,sl')"  "atom ji' \<sharp> (s,s',w,i,j,j',k,sl,sl',ji)"
     by (metis obtain_fresh)
   have "{OrdP (Var i)}
         \<turnstile> All j (All j' (SeqHaddP s w (Var i) (Var j) IMP (SeqHaddP s' w (Var i) (Var j') IMP Var j' EQ Var j)))"
     apply (rule OrdInd2H)
     using ij atoms apply auto
     apply (metis SeqHaddP_Zero_E [THEN cut1] Assume AssumeH(2) Sym Trans)
     \<comment> \<open>SUCC case\<close>
     apply (rule cut_same [OF SeqHaddP_SUCC [where y' = ji and s=s]], auto)
     apply (rule cut_same [OF SeqHaddP_SUCC [where y' = ji' and s=s']], auto)
     apply (rule Ex_I [where x = "Var ji"], auto)
     apply (rule All_E [where x = "Var ji'"], auto)
     apply (blast intro: Trans [OF Hyp] Sym intro!: SUCC_cong)
     done
   hence "{OrdP (Var i)}
          \<turnstile> (All j' (SeqHaddP s w (Var i) (Var j) IMP (SeqHaddP s' w (Var i) (Var j') IMP Var j' EQ Var j)))(j::=y)"
     by (metis All_D)
   hence "{OrdP (Var i)}
          \<turnstile> All j' (SeqHaddP s w (Var i) y IMP (SeqHaddP s' w (Var i) (Var j') IMP Var j' EQ y))"
     using ij by simp
   hence "{OrdP (Var i)}
          \<turnstile> (SeqHaddP s w (Var i) y IMP (SeqHaddP s' w (Var i) (Var j') IMP Var j' EQ y))(j'::=y')"
     by (metis All_D)
   hence "{OrdP (Var i)} \<turnstile> SeqHaddP s w (Var i) y IMP (SeqHaddP s' w (Var i) y' IMP y' EQ y)"
     using ij by simp
   hence "{} \<turnstile> (OrdP (Var i) IMP SeqHaddP s w (Var i) y IMP (SeqHaddP s' w (Var i) y' IMP y' EQ y))(i::=x)"
     by (metis Imp_I Subst emptyE)
   thus ?thesis
     using ij by simp (metis DisjAssoc2 Disj_commute anti_deduction)
 qed (*>*)
 
 lemma HaddP_unique: "{HaddP w x y, HaddP w x y'} \<turnstile> y' EQ y"
 proof -
   obtain s::name and s'::name  where "atom s \<sharp> (w,x,y,y')" "atom s' \<sharp> (w,x,y,y',s)"
     by (metis obtain_fresh)
   hence "{OrdP x, HaddP w x y, HaddP w x y'} \<turnstile> y' EQ y"
     by (auto simp: HaddP.simps [of s _ _ y]  HaddP.simps [of s' _ _ y']
              intro: SeqHaddP_unique [THEN cut3])
   thus ?thesis
     by (metis HaddP_imp_OrdP cut_same thin1)
 qed
 
 lemma HaddP_Zero1: assumes "H \<turnstile> OrdP x" shows "H \<turnstile> HaddP Zero x x"
 proof -
   fix k::name
   have "{ OrdP (Var k) } \<turnstile> HaddP Zero (Var k) (Var k)"
     by (rule OrdInd2H [where i=k]) (auto intro: HaddP_Zero2 HaddP_SUCC2 [THEN cut1])
   hence "{} \<turnstile> OrdP (Var k) IMP HaddP Zero (Var k) (Var k)"
     by (metis Imp_I)
   hence "{} \<turnstile> (OrdP (Var k) IMP HaddP Zero (Var k) (Var k))(k::=x)"
     by (rule Subst) auto
   hence "{} \<turnstile> OrdP x IMP HaddP Zero x x"
     by simp
   thus ?thesis using assms
     by (metis MP_same thin0)
 qed
 
 lemma HaddP_Zero_D1: "insert (HaddP Zero x y) H \<turnstile> x EQ y"
   by (metis Assume HaddP_imp_OrdP HaddP_Zero1 HaddP_unique [THEN cut2] rcut1)
 
 lemma HaddP_Zero_D2: "insert (HaddP x Zero y) H \<turnstile> x EQ y"
   by (metis Assume HaddP_Zero2 HaddP_unique [THEN cut2])
 
 lemma HaddP_SUCC_Ex2:
   assumes "H \<turnstile> HaddP x (SUCC y) z" "atom z' \<sharp> (x,y,z)"
     shows "H \<turnstile> Ex z' (HaddP x y (Var z') AND z EQ SUCC (Var z'))"
 proof -
   obtain s::name and s'::name  where "atom s \<sharp> (x,y,z,z')" "atom s' \<sharp> (x,y,z,z',s)"
     by (metis obtain_fresh)
   hence "{ HaddP x (SUCC y) z } \<turnstile> Ex z' (HaddP x y (Var z') AND z EQ SUCC (Var z'))"
     using assms
     apply (auto simp: HaddP.simps [of s _ _ ]  HaddP.simps [of s' _ _ ])
     apply (rule cut_same [OF SeqHaddP_SUCC_lemma [of z']], auto)
     apply (rule Ex_I, auto)+
     done
   thus ?thesis
     by (metis assms(1) cut1)
 qed
 
 lemma HaddP_SUCC1: "{ HaddP x y z } \<turnstile> HaddP (SUCC x) y (SUCC z)" (*<*)
 proof -
   obtain i::name and j::name and z'::name
    where atoms: "atom i \<sharp> (x,y,z)"  "atom j \<sharp> (i,x,y,z)"  "atom z' \<sharp> (x,i,j)"
     by (metis obtain_fresh)
   have "{OrdP (Var i)} \<turnstile> All j (HaddP x (Var i) (Var j) IMP HaddP (SUCC x) (Var i) (SUCC (Var j)))"
        (is "_ \<turnstile> ?scheme")
     proof (rule OrdInd2H)
       show "{} \<turnstile> ?scheme(i::=Zero)"
         using atoms apply auto
         apply (rule cut_same [OF HaddP_Zero_D2])
         apply (rule Var_Eq_subst_Iff [THEN Sym_L, THEN Iff_MP_same], auto intro: HaddP_Zero2)
         done
     next
       show "{} \<turnstile> All i (OrdP (Var i) IMP ?scheme IMP ?scheme(i::=SUCC (Var i)))"
         using atoms
         apply auto
         apply (rule cut_same [OF HaddP_SUCC_Ex2 [where z'=z']], auto)
         apply (rule Ex_I [where x="Var z'"], auto)
         apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same, THEN rotate3], simp)
         by (metis Assume HaddP_SUCC2 cut1 thin1)
     qed
   hence "{OrdP (Var i)} \<turnstile> (HaddP x (Var i) (Var j) IMP HaddP (SUCC x) (Var i) (SUCC (Var j)))(j::=z)"
     by (rule All_D)
   hence "{OrdP (Var i)} \<turnstile> HaddP x (Var i) z IMP HaddP (SUCC x) (Var i) (SUCC z)"
     using atoms by auto
   hence "{} \<turnstile> HaddP x (Var i) z IMP HaddP (SUCC x) (Var i) (SUCC z)"
     by (metis HaddP_imp_OrdP Imp_cut)
   hence "{} \<turnstile> (HaddP x (Var i) z IMP HaddP (SUCC x) (Var i) (SUCC z))(i::=y)"
     using atoms by (force intro!: Subst)
   thus ?thesis
     using atoms by simp (metis anti_deduction)
 qed (*>*)
 
 lemma HaddP_commute: "{HaddP x y z, OrdP x} \<turnstile> HaddP y x z" (*<*)
 proof -
   obtain i::name and j::name and z'::name
    where atoms: "atom i \<sharp> (x,y,z)"  "atom j \<sharp> (i,x,y,z)"  "atom z' \<sharp> (x,i,j)"
     by (metis obtain_fresh)
   have "{OrdP (Var i), OrdP x} \<turnstile> All j (HaddP x (Var i) (Var j) IMP HaddP (Var i) x (Var j))"
        (is "_ \<turnstile> ?scheme")
     proof (rule OrdInd2H)
       show "{OrdP x} \<turnstile> ?scheme(i::=Zero)"
         using atoms apply auto
         apply (rule cut_same [OF HaddP_Zero_D2])
         apply (rule Var_Eq_subst_Iff [THEN Sym_L, THEN Iff_MP_same], auto intro: HaddP_Zero1)
         done
     next
       show "{OrdP x} \<turnstile> All i (OrdP (Var i) IMP ?scheme IMP ?scheme(i::=SUCC (Var i)))"
         using atoms
         apply auto
         apply (rule cut_same [OF HaddP_SUCC_Ex2 [where z'=z']], auto)
         apply (rule Ex_I [where x="Var z'"], auto)
         apply (rule rotate3)
         apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same], simp)
         by (metis Assume HaddP_SUCC1 cut1 thin1)
     qed
   hence "{OrdP (Var i), OrdP x} \<turnstile> (HaddP x (Var i) (Var j) IMP HaddP (Var i) x (Var j))(j::=z)"
     by (rule All_D)
   hence "{OrdP (Var i), OrdP x} \<turnstile> HaddP x (Var i) z IMP HaddP (Var i) x z"
     using atoms by auto
   hence "{OrdP x} \<turnstile> HaddP x (Var i) z IMP HaddP (Var i) x z"
     by (metis HaddP_imp_OrdP Imp_cut)
   hence "{OrdP x} \<turnstile> (HaddP x (Var i) z IMP HaddP (Var i) x z)(i::=y)"
     using atoms by (force intro!: Subst)
   thus ?thesis
     using atoms by simp (metis anti_deduction)
 qed (*>*)
 
 lemma HaddP_SUCC_Ex1:
   assumes "atom i \<sharp> (x,y,z)"
     shows "insert (HaddP (SUCC x) y z) (insert (OrdP x) H)
            \<turnstile> Ex i (HaddP x y (Var i) AND z EQ SUCC (Var i))"
 proof -
   have "{ HaddP (SUCC x) y z, OrdP x } \<turnstile> Ex i (HaddP x y (Var i) AND z EQ SUCC (Var i))"
     apply (rule cut_same [OF HaddP_commute [THEN cut2]])
     apply (blast intro: OrdP_SUCC_I)+
     apply (rule cut_same [OF HaddP_SUCC_Ex2 [where z'=i]], blast)
     using assms apply auto
     apply (auto intro!: Ex_I [where x="Var i"])
     by (metis AssumeH(2) HaddP_commute [THEN cut2] HaddP_imp_OrdP rotate2 thin1)
   thus ?thesis
     by (metis Assume AssumeH(2) cut2)
 qed
 
 lemma HaddP_inv2: "{HaddP x y z, HaddP x y' z, OrdP x} \<turnstile> y' EQ y" (*<*)
 proof -
   obtain i::name and j::name and u::name and u'::name
    where atoms: "atom i \<sharp> (x,y,y',z)"  "atom j \<sharp> (i,x,y,y',z)"
                 "atom u \<sharp> (x,y,y',i,j)" "atom u' \<sharp> (x,y,y',u,i,j)"
     by (metis obtain_fresh)
   have "{OrdP (Var i)} \<turnstile> All j (HaddP (Var i) y (Var j) IMP HaddP (Var i) y' (Var j) IMP y' EQ y)"
        (is "_ \<turnstile> ?scheme")
     proof (rule OrdInd2H)
       show "{} \<turnstile> ?scheme(i::=Zero)"
         using atoms
         by auto (metis HaddP_Zero_D1 Sym Trans thin1)
     next
       show "{} \<turnstile> All i (OrdP (Var i) IMP ?scheme IMP ?scheme(i::=SUCC (Var i)))"
         using atoms
         apply auto
         apply (rule cut_same [OF HaddP_SUCC_Ex1 [where y=y and i=u, THEN cut2]], auto)
         apply (rule Ex_I [where x="Var u"], auto)
         apply (rule cut_same [OF HaddP_SUCC_Ex1 [where y=y' and i=u', THEN cut2]], auto)
         apply (rule cut_same [where A="SUCC (Var u) EQ SUCC (Var u')"])
         apply (auto intro: Sym Trans)
         apply (rule rotate4 [OF ContraProve])
         apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same], force)
         done
     qed
   hence "{OrdP (Var i)} \<turnstile> (HaddP (Var i) y (Var j) IMP HaddP (Var i) y' (Var j) IMP y' EQ y)(j::=z)"
     by (rule All_D)
   hence "{OrdP (Var i)} \<turnstile> HaddP (Var i) y z IMP HaddP (Var i) y' z IMP y' EQ y"
     using atoms by auto
   hence "{} \<turnstile> OrdP (Var i) IMP HaddP (Var i) y z IMP HaddP (Var i) y' z IMP y' EQ y"
     by (metis Imp_I)
   hence "{} \<turnstile> (OrdP (Var i) IMP HaddP (Var i) y z IMP HaddP (Var i) y' z IMP y' EQ y)(i::=x)"
     using atoms by (force intro!: Subst)
   thus ?thesis
     using atoms by simp (metis DisjAssoc2 Disj_commute anti_deduction)
 qed (*>*)
 
 lemma Mem_imp_subtract: (*<*)
   assumes "H \<turnstile> x IN y" "H \<turnstile> OrdP y" and k: "atom (k::name) \<sharp> (x,y)"
     shows  "H \<turnstile> Ex k (HaddP x (Var k) y AND Zero IN (Var k))"
 proof -
   obtain i::name
    where atoms: "atom i \<sharp> (x,y,k)"
     by (metis obtain_fresh)
   have "{OrdP (Var i)} \<turnstile> x IN Var i IMP Ex k (HaddP x (Var k) (Var i) AND Zero IN (Var k))"
        (is "_ \<turnstile> ?scheme")
     proof (rule OrdInd2H)
       show "{} \<turnstile> ?scheme(i::=Zero)"
         by auto
     next
       show "{} \<turnstile> All i (OrdP (Var i) IMP ?scheme IMP ?scheme(i::=SUCC (Var i)))"
         using atoms k
         apply (auto intro!: Mem_SUCC_EH)
         apply (rule Ex_I [where x="SUCC (Var k)"], auto)
         apply (metis AssumeH(4) HaddP_SUCC2 cut1 insert_commute)
         apply (blast intro: Mem_SUCC_I1)
         apply (rule Ex_I [where x="SUCC Zero"], auto)
         apply (rule thin1)
         apply (rule Var_Eq_subst_Iff [THEN Sym_L, THEN Iff_MP_same], simp)
         apply (metis HaddP_SUCC2 HaddP_Zero2 cut1)
         apply (rule Ex_I [where x="SUCC (Var k)"], auto intro: Mem_SUCC_I1)
         apply (metis AssumeH(4) HaddP_SUCC2 cut1 insert_commute)
         done
     qed
   hence "{} \<turnstile> OrdP (Var i) IMP x IN Var i IMP Ex k (HaddP x (Var k) (Var i) AND Zero IN (Var k))"
     by (metis Imp_I)
   hence "{} \<turnstile> (OrdP (Var i) IMP x IN Var i IMP Ex k (HaddP x (Var k) (Var i) AND Zero IN (Var k)))(i::=y)"
     by (force intro!: Subst)
   thus ?thesis using assms atoms
     by simp (metis (no_types) anti_deduction cut2)
 qed (*>*)
 
 lemma HaddP_OrdP:
   assumes "H \<turnstile> HaddP x y z" "H \<turnstile> OrdP x"  shows "H \<turnstile> OrdP z"  (*<*)
 proof -
   obtain i::name and j::name and k::name
    where atoms: "atom i \<sharp> (x,y,z)"  "atom j \<sharp> (i,x,y,z)"  "atom k \<sharp> (i,j,x,y,z)"
     by (metis obtain_fresh)
   have "{OrdP (Var i), OrdP x} \<turnstile> All j (HaddP x (Var i) (Var j) IMP OrdP (Var j))"
        (is "_ \<turnstile> ?scheme")
     proof (rule OrdInd2H)
       show "{OrdP x} \<turnstile> ?scheme(i::=Zero)"
         using atoms
         by (auto intro: HaddP_Zero_D2 OrdP_cong [THEN Iff_MP_same])
     next
       show "{OrdP x} \<turnstile> All i (OrdP (Var i) IMP ?scheme IMP ?scheme(i::=SUCC (Var i)))"
         using atoms
         apply auto
         apply (rule cut_same [OF HaddP_SUCC_Ex2 [where z'=k]], auto)
         apply (rule Ex_I [where x="Var k"], auto)
         apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same, THEN rotate3], auto intro: OrdP_SUCC_I)
         done
     qed
   hence "{OrdP (Var i), OrdP x} \<turnstile> (HaddP x (Var i) (Var j) IMP OrdP (Var j))(j::=z)"
     by (rule All_D)
   hence "{OrdP (Var i), OrdP x} \<turnstile> (HaddP x (Var i) z IMP OrdP z)"
     using atoms by simp
   hence "{OrdP x} \<turnstile> HaddP x (Var i) z IMP OrdP z"
     by (metis HaddP_imp_OrdP Imp_cut)
   hence "{OrdP x} \<turnstile> (HaddP x (Var i) z IMP OrdP z)(i::=y)"
     using atoms by (force intro!: Subst)
   thus ?thesis using assms atoms
     by simp (metis anti_deduction cut2)
 qed (*>*)
 
 lemma HaddP_Mem_cancel_left:
   assumes "H \<turnstile> HaddP x y' z'" "H \<turnstile> HaddP x y z" "H \<turnstile> OrdP x"
     shows "H \<turnstile> z' IN z IFF y' IN y" (*<*)
 proof -
   obtain i::name and j::name and j'::name and k::name and k'::name
    where atoms: "atom i \<sharp> (x,y,y',z,z')" "atom j \<sharp> (i,x,y,y',z,z')" "atom j' \<sharp> (i,j,x,y,y',z,z')"
                  "atom k \<sharp> (i,j,j',x,y,y',z,z')" "atom k' \<sharp> (i,j,j',k,x,y,y',z,z')"
     by (metis obtain_fresh)
   have "{OrdP (Var i)}
         \<turnstile> All j (All j' (HaddP (Var i) y' (Var j') IMP (HaddP (Var i) y (Var j) IMP
                          ((Var j') IN (Var j) IFF y' IN y))))"
        (is "_ \<turnstile> ?scheme")
     proof (rule OrdInd2H)
       show "{} \<turnstile> ?scheme(i::=Zero)"
         using atoms apply simp
         apply (rule All_I Imp_I Ex_EH)+
         apply (rule cut_same [where A="Var j EQ y"])
         apply (metis HaddP_Zero_D1 Sym)
         apply (rule cut_same [where A="Var j' EQ y'"])
         apply (metis HaddP_Zero_D1 Sym thin1)
         apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same], simp)
         apply (rule thin1)
         apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same], auto)
         done
     next
       show "{} \<turnstile> All i (OrdP (Var i) IMP ?scheme IMP ?scheme(i::=SUCC (Var i)))"
         using atoms apply simp
         apply (rule All_I Imp_I Ex_EH)+
         apply (rule cut_same [OF HaddP_SUCC_Ex1 [of k "Var i" y "Var j", THEN cut2]], simp_all)
         apply (rule AssumeH Conj_EH Ex_EH)+
         apply (rule cut_same [OF HaddP_SUCC_Ex1 [of k' "Var i" y' "Var j'", THEN cut2]], simp_all)
         apply (rule AssumeH Conj_EH Ex_EH)+
         apply (rule rotate7)
         apply (rule All_E [where x = "Var k"], simp)
         apply (rule All_E [where x = "Var k'"], simp_all)
         apply (rule Imp_E AssumeH)+
         apply (rule Iff_trans)
         prefer 2
         apply (rule AssumeH)
         apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same, THEN rotate3], simp)
         apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same, THEN rotate5], simp)
         apply (blast intro!: HaddP_OrdP OrdP_IN_SUCC_Iff)
         done
     qed
   hence "{OrdP (Var i)}
          \<turnstile> (All j' (HaddP (Var i) y' (Var j') IMP (HaddP (Var i) y (Var j) IMP ((Var j') IN (Var j) IFF y' IN y))))(j::=z)"
     by (metis All_D)
   hence "{OrdP (Var i)}
          \<turnstile> (All j' (HaddP (Var i) y' (Var j') IMP (HaddP (Var i) y z IMP ((Var j') IN z IFF y' IN y))))"
     using atoms by simp
   hence "{OrdP (Var i)}
          \<turnstile> (HaddP (Var i) y' (Var j') IMP (HaddP (Var i) y z IMP ((Var j') IN z IFF y' IN y)))(j'::=z')"
     by (metis All_D)
   hence "{OrdP (Var i)} \<turnstile> HaddP (Var i) y' z' IMP (HaddP (Var i) y z IMP (z' IN z IFF y' IN y))"
     using atoms by simp
   hence "{} \<turnstile> (OrdP (Var i) IMP HaddP (Var i) y' z' IMP (HaddP (Var i) y z IMP (z' IN z IFF y' IN y)))(i::=x)"
     by (metis Imp_I Subst emptyE)
   thus ?thesis
     using atoms by simp (metis assms MP_null MP_same)
 qed (*>*)
 
 lemma HaddP_Mem_cancel_right_Mem:
   assumes "H \<turnstile> HaddP x' y z'" "H \<turnstile> HaddP x y z" "H \<turnstile> x' IN x" "H \<turnstile> OrdP x"
     shows "H \<turnstile> z' IN z"
 proof -
   have "H \<turnstile> OrdP x'"
     by (metis Ord_IN_Ord assms(3) assms(4))
   hence "H \<turnstile> HaddP y x' z'" "H \<turnstile> HaddP y x z"
     by (blast intro: assms HaddP_commute [THEN cut2])+
   thus ?thesis
     by (blast intro: assms HaddP_imp_OrdP [THEN cut1] HaddP_Mem_cancel_left [THEN Iff_MP2_same])
 qed
 
 lemma HaddP_Mem_cases:
   assumes "H \<turnstile> HaddP k1 k2 k" "H \<turnstile> OrdP k1"
           "insert (x IN k1) H \<turnstile> A"
           "insert (Var i IN k2) (insert (HaddP k1 (Var i) x) H) \<turnstile> A"
       and i: "atom (i::name) \<sharp> (k1,k2,k,x,A)" and "\<forall>C \<in> H. atom i \<sharp> C"
     shows "insert (x IN k) H \<turnstile> A" (*<*)
 proof -
   obtain j::name where j: "atom j \<sharp> (k1,k2,k,x)"
     by (metis obtain_fresh)
   have seq: "{HaddP k1 k2 k, x IN k, OrdP k1} \<turnstile> x IN k1 OR (Ex i (HaddP k1 (Var i) x AND Var i IN k2))"
     apply (rule cut_same [OF HaddP_OrdP])
     apply (rule AssumeH)+
     apply (rule cut_same [OF Ord_IN_Ord])
     apply (rule AssumeH)+
     apply (rule OrdP_linear [of _ x k1], (rule AssumeH)+)
     proof -
       show "{x IN k1, OrdP x, OrdP k, HaddP k1 k2 k, x IN k, OrdP k1} \<turnstile> x IN k1 OR Ex i (HaddP k1 (Var i) x AND Var i IN k2)"
         by (blast intro: Disj_I1)
     next
       show "{x EQ k1, OrdP x, OrdP k, HaddP k1 k2 k, x IN k, OrdP k1} \<turnstile> x IN k1 OR Ex i (HaddP k1 (Var i) x AND Var i IN k2)"
         apply (rule cut_same [OF Zero_In_OrdP [of k2, THEN cut1]])
         apply (metis AssumeH(4) HaddP_imp_OrdP cut1)
         apply auto
         apply (rule cut_same [where A="HaddP x Zero k"])
         apply (blast intro: HaddP_cong [THEN Iff_MP_same] Sym)
         apply (rule cut_same [where A="x EQ k"])
         apply (metis HaddP_Zero_D2)
         apply (blast intro: Mem_non_refl Mem_cong [THEN Iff_MP_same])
         apply (rule Disj_I2)
         apply (rule Ex_I [where x=Zero])
         using i apply auto
         apply (rule HaddP_cong [THEN Iff_MP_same])
         apply (rule AssumeH Refl HaddP_Zero2)+
         done
     next
       show "{k1 IN x, OrdP x, OrdP k, HaddP k1 k2 k, x IN k, OrdP k1} \<turnstile> x IN k1 OR Ex i (HaddP k1 (Var i) x AND Var i IN k2)"
         apply (rule Disj_I2)
         apply (rule cut_same [OF Mem_imp_subtract [of _ k1 x j]])
         apply (rule AssumeH)+
         using i j apply auto
         apply (rule Ex_I [where x="Var j"], auto intro: HaddP_Mem_cancel_left [THEN Iff_MP_same])
         done
     qed
   show ?thesis using assms
     by (force intro: cut_same [OF seq [THEN cut3]] thin1 simp: insert_commute)
 qed (*>*)
 
 lemma HaddP_Mem_contra:
   assumes "H \<turnstile> HaddP x y z" "H \<turnstile> z IN x" "H \<turnstile> OrdP x"
     shows "H \<turnstile> A"
 proof -
   obtain i::name and j::name and k::name
    where atoms: "atom i \<sharp> (x,y,z)" "atom j \<sharp> (i,x,y,z)" "atom k \<sharp> (i,j,x,y,z)"
     by (metis obtain_fresh)
   have "{OrdP (Var i)}  \<turnstile> All j (HaddP (Var i) y (Var j) IMP Neg ((Var j) IN (Var i)))"
        (is "_ \<turnstile> ?scheme")
     proof (rule OrdInd2H)
       show "{} \<turnstile> ?scheme(i::=Zero)"
         using atoms by auto
     next
       show "{} \<turnstile> All i (OrdP (Var i) IMP ?scheme IMP ?scheme(i::=SUCC (Var i)))"
         using  atoms apply auto
         apply (rule cut_same [OF HaddP_SUCC_Ex1 [of k "Var i" y "Var j", THEN cut2]], auto)
         apply (rule Ex_I [where x="Var k"], auto)
         apply (blast intro: OrdP_IN_SUCC_D Mem_cong [OF _ Refl, THEN Iff_MP_same])
         done
     qed
   hence "{OrdP (Var i)} \<turnstile> (HaddP (Var i) y (Var j) IMP Neg ((Var j) IN (Var i)))(j::=z)"
     by (metis All_D)
   hence "{} \<turnstile> OrdP (Var i) IMP HaddP (Var i) y z IMP Neg (z IN (Var i))"
     using atoms by simp (metis Imp_I)
   hence "{} \<turnstile> (OrdP (Var i) IMP HaddP (Var i) y z IMP Neg (z IN (Var i)))(i::=x)"
     by (metis Subst emptyE)
   thus ?thesis
     using atoms by simp (metis MP_same MP_null Neg_D assms)
 qed (*>*)
 
 lemma exists_HaddP:
   assumes "H \<turnstile> OrdP y" "atom j \<sharp> (x,y)"
     shows "H \<turnstile> Ex j (HaddP x y (Var j))"
 proof -
   obtain i::name
    where atoms: "atom i \<sharp> (j,x,y)"
     by (metis obtain_fresh)
   have "{OrdP (Var i)} \<turnstile> Ex j (HaddP x (Var i) (Var j))"
        (is "_ \<turnstile> ?scheme")
     proof (rule OrdInd2H)
       show "{} \<turnstile> ?scheme(i::=Zero)"
         using atoms assms
         by (force intro!: Ex_I [where x=x] HaddP_Zero2)
     next
       show "{} \<turnstile> All i (OrdP (Var i) IMP ?scheme IMP ?scheme(i::=SUCC (Var i)))"
         using atoms assms
         apply auto
         apply (auto intro!: Ex_I [where x="SUCC (Var j)"] HaddP_SUCC2)
         apply (metis HaddP_SUCC2 insert_commute thin1)
         done
     qed
   hence "{} \<turnstile> OrdP (Var i) IMP Ex j (HaddP x (Var i) (Var j))"
     by (metis Imp_I)
   hence "{} \<turnstile> (OrdP (Var i) IMP Ex j (HaddP x (Var i) (Var j)))(i::=y)"
     using atoms by (force intro!: Subst)
   thus ?thesis
     using atoms assms by simp (metis MP_null assms(1))
 qed
 
 lemma HaddP_Mem_I:
   assumes "H \<turnstile> HaddP x y z" "H \<turnstile> OrdP x" shows "H \<turnstile> x IN SUCC z"
 proof -
   have "{HaddP x y z, OrdP x} \<turnstile> x IN SUCC z"
     apply (rule OrdP_linear [of _ x "SUCC z"])
     apply (auto intro: OrdP_SUCC_I HaddP_OrdP)
     apply (rule HaddP_Mem_contra, blast)
     apply (metis Assume Mem_SUCC_I2 OrdP_IN_SUCC_D Sym_L thin1 thin2, blast)
     apply (blast intro: HaddP_Mem_contra Mem_SUCC_Refl OrdP_Trans)
     done
   thus ?thesis
     by (rule cut2) (auto intro: assms)
 qed
 
 
 section \<open>A Shifted Sequence\<close>
 
 nominal_function ShiftP :: "tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> fm"
   where "\<lbrakk>atom x \<sharp> (x',y,z,f,del,k); atom x' \<sharp> (y,z,f,del,k); atom y \<sharp> (z,f,del,k); atom z \<sharp> (f,del,g,k)\<rbrakk> \<Longrightarrow>
     ShiftP f k del g =
       All z (Var z IN g IFF
       (Ex x (Ex x' (Ex y ((Var z) EQ HPair (Var x') (Var y) AND
                           HaddP del (Var x) (Var x') AND
                           HPair (Var x) (Var y) IN f AND Var x IN k)))))"
 by (auto simp: eqvt_def ShiftP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma ShiftP_fresh_iff [simp]: "a \<sharp> ShiftP f k del g \<longleftrightarrow> a \<sharp> f \<and> a \<sharp> k \<and> a \<sharp> del \<and> a \<sharp> g"
 proof -
   obtain x::name and x'::name and y::name and z::name
     where "atom x \<sharp> (x',y,z,f,del,k)" "atom x' \<sharp> (y,z,f,del,k)"
           "atom y \<sharp> (z,f,del,k)" "atom z \<sharp> (f,del,g,k)"
     by (metis obtain_fresh)
   thus ?thesis
     by auto
 qed
 
 lemma subst_fm_ShiftP [simp]:
   "(ShiftP f k del g)(i::=u) = ShiftP (subst i u f) (subst i u k) (subst i u del) (subst i u g)"
 proof -
   obtain x::name and x'::name and y::name and z::name
   where "atom x \<sharp> (x',y,z,f,del,k,i,u)" "atom x' \<sharp> (y,z,f,del,k,i,u)"
         "atom y \<sharp> (z,f,del,k,i,u)" "atom z \<sharp> (f,del,g,k,i,u)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: ShiftP.simps [of x x' y z])
 qed
 
 lemma ShiftP_Zero: "{} \<turnstile> ShiftP Zero k d Zero"
 proof -
   obtain x::name and x'::name and y::name and z::name
   where "atom x \<sharp> (x',y,z,k,d)" "atom x' \<sharp> (y,z,k,d)" "atom y \<sharp> (z,k,d)" "atom z \<sharp> (k,d)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: ShiftP.simps [of x x' y z])
 qed
 
 lemma ShiftP_Mem1:
   "{ShiftP f k del g, HPair a b IN f, HaddP del a a', a IN k} \<turnstile> HPair a' b IN g"
 proof -
   obtain x::name and x'::name and y::name and z::name
     where "atom x \<sharp> (x',y,z,f,del,k,a,a',b)" "atom x' \<sharp> (y,z,f,del,k,a,a',b)"
           "atom y \<sharp> (z,f,del,k,a,a',b)" "atom z \<sharp> (f,del,g,k,a,a',b)"
     by (metis obtain_fresh)
   thus ?thesis
     apply (auto simp: ShiftP.simps [of x x' y z])
     apply (rule All_E [where x="HPair a' b"], auto intro!: Iff_E2)
     apply (rule Ex_I [where x=a], simp)
     apply (rule Ex_I [where x="a'"], simp)
     apply (rule Ex_I [where x=b], auto intro: Mem_Eats_I1)
     done
 qed
 
 lemma ShiftP_Mem2:
   assumes "atom u \<sharp> (f,k,del,a,b)"
   shows  "{ShiftP f k del g, HPair a b IN g} \<turnstile> Ex u ((Var u) IN k AND HaddP del (Var u) a AND HPair (Var u) b IN f)"
 proof -
   obtain x::name and x'::name and y::name and z::name
   where atoms: "atom x \<sharp> (x',y,z,f,del,g,k,a,u,b)" "atom x' \<sharp> (y,z,f,del,g,k,a,u,b)"
                "atom y \<sharp> (z,f,del,g,k,a,u,b)" "atom z \<sharp> (f,del,g,k,a,u,b)"
     by (metis obtain_fresh)
   thus ?thesis using assms
     apply (auto simp: ShiftP.simps [of x x' y z])
     apply (rule All_E [where x="HPair a b"])
     apply (auto intro!: Iff_E1 [OF Assume])
     apply (rule Ex_I [where x="Var x"])
     apply (auto intro: Mem_cong [OF HPair_cong Refl, THEN Iff_MP2_same])
     apply (blast intro: HaddP_cong [OF Refl Refl, THEN Iff_MP2_same])
     done
 qed
 
 lemma ShiftP_Mem_D:
   assumes "H \<turnstile> ShiftP f k del g" "H \<turnstile> a IN g"
           "atom x \<sharp> (x',y,a,f,del,k)" "atom x' \<sharp> (y,a,f,del,k)" "atom y \<sharp> (a,f,del,k)"
   shows  "H \<turnstile> (Ex x (Ex x' (Ex y (a EQ HPair (Var x') (Var y) AND
                                   HaddP del (Var x) (Var x') AND
                                   HPair (Var x) (Var y) IN f AND Var x IN k))))"
          (is "_ \<turnstile> ?concl")
 proof -
   obtain z::name where "atom z \<sharp> (x,x',y,f,del,g,k,a)"
     by (metis obtain_fresh)
   hence "{ShiftP f k del g, a IN g} \<turnstile> ?concl" using assms
     by (auto simp: ShiftP.simps [of x x' y z]) (rule All_E [where x=a], auto intro: Iff_E1)
   thus ?thesis
     by (rule cut2) (rule assms)+
 qed
 
 lemma ShiftP_Eats_Eats:
   "{ShiftP f k del g, HaddP del a a', a IN k}
    \<turnstile> ShiftP (Eats f (HPair a b)) k del (Eats g (HPair a' b))" (*<*)
 proof -
   obtain x::name and x'::name and y::name and z::name
     where "atom x \<sharp> (x',y,z,f,del,g,k,a,a',b)" "atom x' \<sharp> (y,z,f,del,g,k,a,a',b)"
           "atom y \<sharp> (z,f,del,g,k,a,a',b)" "atom z \<sharp> (f,del,g,k,a,a',b)"
     by (metis obtain_fresh)
   thus ?thesis
     apply (auto simp: ShiftP.simps [of x x' y z] intro!: Iff_I [THEN Swap])
     apply (rule All_E [where x="Var z", THEN rotate2], simp)
     apply (rule Iff_E)
     apply auto [1]
     apply (rule Ex_I [where x="Var x"], simp)
     apply (rule Ex_I [where x="Var x'"], simp)
     apply (rule Ex_I [where x="Var y"], simp)
     apply (blast intro: Mem_Eats_I1, blast)
     apply (rule Ex_I [where x=a], simp)
     apply (rule Ex_I [where x="a'"], simp)
     apply (rule Ex_I [where x=b], simp)
     apply (metis Assume AssumeH(3) AssumeH(4) Conj_I Mem_Eats_I2 Refl)
     apply (rule All_E [where x="Var z", THEN rotate5], auto)
     apply (rule Mem_Eats_I1)
     apply (rule Iff_MP2_same [OF Hyp], blast)
     apply (rule Ex_I [where x="Var x"], simp)
     apply (rule Ex_I [where x="Var x'"], simp)
     apply (rule Ex_I [where x="Var y"], auto)
     apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same, THEN rotate5], simp)
     apply (blast intro: Mem_Eats_I2 HaddP_cong [THEN Iff_MP_same] HaddP_unique [THEN cut2] HPair_cong)
     done
 qed (*>*)
 
 lemma ShiftP_Eats_Neg:
   assumes "atom u \<sharp> (u',v,f,k,del,g,c)" "atom u' \<sharp> (v,f,k,del,g,c)" "atom v \<sharp> (f,k,del,g,c)"
   shows
   "{ShiftP f k del g,
     Neg (Ex u (Ex u' (Ex v (c EQ HPair (Var u) (Var v) AND Var u IN k AND HaddP del (Var u) (Var u')))))}
    \<turnstile> ShiftP (Eats f c) k del g"  (*<*)
 proof -
   obtain x::name and x'::name and y::name and z::name
   where atoms: "atom x \<sharp> (x',y,z,u,u',v,f,k,del,g,c)" "atom x' \<sharp> (y,z,u,u',v,f,k,del,g,c)"
                "atom y \<sharp> (z,u,u',v,f,k,del,g,c)" "atom z \<sharp> (u,u',v,f,k,del,g,c)"
     by (metis obtain_fresh)
   thus ?thesis using assms
     apply (auto simp: ShiftP.simps [of x x' y z] intro!: Iff_I [THEN Swap])
     apply (rule All_E [where x="Var z", THEN rotate3])
     apply (auto intro!: Iff_E1 [OF Assume])
     apply (rule Ex_I [where x="Var x"], simp)
     apply (rule Ex_I [where x="Var x'"], simp)
     apply (rule Ex_I [where x="Var y"], simp)
     apply (blast intro: Mem_Eats_I1)
     apply (rule All_E [where x="Var z", THEN rotate6], simp)
     apply (rule Iff_E2)
     apply (rule Ex_I [where x="Var x"], simp)
     apply (rule Ex_I [where x="Var x'"], simp)
     apply (rule Ex_I [where x="Var y"])
     apply (auto intro: Mem_Eats_I1)
     apply (rule Swap [THEN rotate5])
     apply (rule Ex_I [where x="Var x"], simp)
     apply (rule Ex_I [where x="Var x'"], simp)
     apply (rule Ex_I [where x="Var y"], simp)
     apply (blast intro: Sym Mem_Eats_I1)
     done
 qed (*>*)
 
 lemma exists_ShiftP:
   assumes t: "atom t \<sharp> (s,k,del)"
   shows "H \<turnstile> Ex t (ShiftP s k del (Var t))" (*<*)
 proof -
   obtain i::name and j::name
     where i: "atom (i::name) \<sharp> (s,t,k,del)" and j: "atom (j::name) \<sharp> (i,s,t,k,del)"
     by (metis obtain_fresh)
   have "{} \<turnstile> Ex t (ShiftP (Var i) k del (Var t))" (is "{} \<turnstile> ?scheme")
   proof (rule Ind [of j])
     show "atom j \<sharp> (i, ?scheme)" using j
       by simp
   next
     show "{} \<turnstile> ?scheme(i::=Zero)" using i t
       by (auto intro!: Ex_I [where x=Zero] simp: ShiftP_Zero)
   next
     obtain x::name and x'::name and y::name
     where atoms: "atom x \<sharp> (x',y,s,k,del,t,i,j)" "atom x' \<sharp> (y,s,k,del,t,i,j)"
                  "atom y \<sharp> (s,k,del,t,i,j)"
       by (metis obtain_fresh)
     let ?caseA = "Ex x (Ex x' (Ex y ((Var j) EQ HPair (Var x) (Var y) AND Var x IN k AND
                                      HaddP del (Var x) (Var x'))))"
     show "{} \<turnstile> All i (All j (?scheme IMP ?scheme(i::=Var j) IMP ?scheme(i::=Eats (Var i) (Var j))))"
       using i j atoms
       apply (auto del: Ex_EH)
       apply (rule Ex_E)
       apply (auto del: Ex_EH)
       apply (rule Ex_E)
       apply (auto del: Ex_EH)
       apply (rule thin1, auto)
       proof (rule Cases [where A="?caseA"])
         show "{?caseA, ShiftP (Var i) k del (Var t)}
               \<turnstile> Ex t (ShiftP (Eats (Var i) (Var j)) k del (Var t))"
           using i j t atoms
           apply (auto simp del: ShiftP.simps)
           apply (rule Ex_I [where x="Eats (Var t) (HPair (Var x') (Var y))"], auto)
           apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same, THEN rotate3])
           apply (auto intro: ShiftP_Eats_Eats [THEN cut3])
           done
       next
         show "{Neg ?caseA, ShiftP (Var i) k del (Var t)}
               \<turnstile> Ex t (ShiftP (Eats (Var i) (Var j)) k del (Var t))"
           using atoms
           by (auto intro!: Ex_I [where x="Var t"] ShiftP_Eats_Neg [of x x' y, THEN cut2]
                    simp: ShiftP_Zero)
       qed
   qed
   hence "{} \<turnstile> (Ex t (ShiftP (Var i) k del (Var t)))(i::=s)"
     by (blast intro: Subst)
   thus ?thesis using i t
     by (auto intro: thin0)
 qed (*>*)
 
 
 section \<open>Union of Two Sets\<close>
 
 nominal_function UnionP :: "tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> fm"
   where "atom i \<sharp> (x,y,z) \<Longrightarrow> UnionP x y z = All i (Var i IN z IFF (Var i IN x OR Var i IN y))"
 by (auto simp: eqvt_def UnionP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma UnionP_fresh_iff [simp]: "a \<sharp> UnionP x y z \<longleftrightarrow> a \<sharp> x \<and> a \<sharp> y \<and> a \<sharp> z"
 proof -
   obtain i::name where "atom i \<sharp> (x,y,z)"
     by (metis obtain_fresh)
   thus ?thesis
     by auto
 qed
 
 lemma subst_fm_UnionP [simp]:
   "(UnionP x y z)(i::=u) = UnionP (subst i u x) (subst i u y) (subst i u z)"
 proof -
   obtain j::name where "atom j \<sharp> (x,y,z,i,u)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: UnionP.simps [of j])
 qed
 
 lemma Union_Zero1: "H \<turnstile> UnionP Zero x x"
 proof -
   obtain i::name where "atom i \<sharp> x"
     by (metis obtain_fresh)
   hence "{} \<turnstile> UnionP Zero x x"
     by (auto simp: UnionP.simps [of i] intro: Disj_I2)
   thus ?thesis
     by (metis thin0)
 qed
 
 lemma Union_Eats: "{UnionP x y z} \<turnstile> UnionP (Eats x a) y (Eats z a)"
 proof -
   obtain i::name where "atom i \<sharp> (x,y,z,a)"
     by (metis obtain_fresh)
   thus ?thesis
     apply (auto simp: UnionP.simps [of i])
     apply (rule Ex_I [where x="Var i"])
     apply (auto intro: Iff_E1 [THEN rotate2] Iff_E2 [THEN rotate2] Mem_Eats_I1 Mem_Eats_I2 Disj_I1 Disj_I2)
     done
 qed
 
 lemma exists_Union_lemma:
   assumes z: "atom z \<sharp> (i,y)" and i: "atom i \<sharp> y"
   shows "{} \<turnstile> Ex z (UnionP (Var i) y (Var z))"
 proof -
   obtain j::name where j: "atom j \<sharp> (y,z,i)"
     by (metis obtain_fresh)
   show "{} \<turnstile> Ex z (UnionP (Var i) y (Var z))"
     apply (rule Ind [of j i]) using j z i
     apply simp_all
     apply (rule Ex_I [where x=y], simp add: Union_Zero1)
     apply (auto del: Ex_EH)
     apply (rule Ex_E)
     apply (rule NegNeg_E)
     apply (rule Ex_E)
     apply (auto del: Ex_EH)
     apply (rule thin1, force intro: Ex_I [where x="Eats (Var z) (Var j)"] Union_Eats)
     done
 qed
 
 lemma exists_UnionP:
   assumes z: "atom z \<sharp> (x,y)"  shows "H \<turnstile> Ex z (UnionP x y (Var z))"
 proof -
   obtain i::name  where i: "atom i \<sharp> (y,z)"
     by (metis obtain_fresh)
   hence "{} \<turnstile> Ex z (UnionP (Var i) y (Var z))"
     by (metis exists_Union_lemma fresh_Pair fresh_at_base(2) z)
   hence "{} \<turnstile> (Ex z (UnionP (Var i) y (Var z)))(i::=x)"
     by (metis Subst empty_iff)
   thus ?thesis using i z
     by (simp add: thin0)
 qed
 
 lemma UnionP_Mem1: "{ UnionP x y z, a IN x } \<turnstile> a IN z"
 proof -
   obtain i::name where "atom i \<sharp> (x,y,z,a)"
     by (metis obtain_fresh)
   thus ?thesis
     by (force simp: UnionP.simps [of i] intro: All_E [where x=a] Disj_I1 Iff_E2)
 qed
 
 lemma UnionP_Mem2: "{ UnionP x y z, a IN y } \<turnstile> a IN z"
 proof -
   obtain i::name where "atom i \<sharp> (x,y,z,a)"
     by (metis obtain_fresh)
   thus ?thesis
     by (force simp: UnionP.simps [of i] intro: All_E [where x=a] Disj_I2 Iff_E2)
 qed
 
 lemma UnionP_Mem: "{ UnionP x y z, a IN z } \<turnstile> a IN x OR a IN y"
 proof -
   obtain i::name where "atom i \<sharp> (x,y,z,a)"
     by (metis obtain_fresh)
   thus ?thesis
     by (force simp: UnionP.simps [of i] intro: All_E [where x=a] Iff_E1)
 qed
 
 lemma UnionP_Mem_E:
   assumes "H \<turnstile> UnionP x y z"
       and "insert (a IN x) H \<turnstile> A"
       and "insert (a IN y) H \<turnstile> A"
     shows "insert (a IN z) H \<turnstile> A"
   using assms
   by (blast intro: rotate2 cut_same [OF UnionP_Mem [THEN cut2]] thin1)
 
 
 section \<open>Append on Sequences\<close>
 
 nominal_function SeqAppendP :: "tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> fm"
   where "\<lbrakk>atom g1 \<sharp> (g2,f1,k1,f2,k2,g); atom g2 \<sharp> (f1,k1,f2,k2,g)\<rbrakk> \<Longrightarrow>
     SeqAppendP f1 k1 f2 k2 g =
       (Ex g1 (Ex g2 (RestrictedP f1 k1 (Var g1) AND
                      ShiftP f2 k2 k1 (Var g2) AND
                      UnionP (Var g1) (Var g2) g)))"
 by (auto simp: eqvt_def SeqAppendP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma SeqAppendP_fresh_iff [simp]:
   "a \<sharp> SeqAppendP f1 k1 f2 k2 g \<longleftrightarrow> a \<sharp> f1 \<and> a \<sharp> k1 \<and> a \<sharp> f2 \<and> a \<sharp> k2 \<and> a \<sharp> g"
 proof -
   obtain g1::name and g2::name
     where "atom g1 \<sharp> (g2,f1,k1,f2,k2,g)" "atom g2 \<sharp> (f1,k1,f2,k2,g)"
     by (metis obtain_fresh)
   thus ?thesis
     by auto
 qed
 
 lemma subst_fm_SeqAppendP [simp]:
   "(SeqAppendP f1 k1 f2 k2 g)(i::=u) =
    SeqAppendP (subst i u f1) (subst i u k1) (subst i u f2) (subst i u k2) (subst i u g)"
 proof -
   obtain g1::name and g2::name
   where "atom g1 \<sharp> (g2,f1,k1,f2,k2,g,i,u)" "atom g2 \<sharp> (f1,k1,f2,k2,g,i,u)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: SeqAppendP.simps [of g1 g2])
 qed
 
 lemma exists_SeqAppendP:
   assumes "atom g \<sharp> (f1,k1,f2,k2)"
   shows "H \<turnstile> Ex g (SeqAppendP f1 k1 f2 k2 (Var g))"
 proof -
   obtain g1::name and g2::name
   where atoms: "atom g1 \<sharp> (g2,f1,k1,f2,k2,g)" "atom g2 \<sharp> (f1,k1,f2,k2,g)"
     by (metis obtain_fresh)
   hence "{} \<turnstile> Ex g (SeqAppendP f1 k1 f2 k2 (Var g))"
     using assms
     apply (auto simp: SeqAppendP.simps [of g1 g2])
     apply (rule cut_same [OF exists_RestrictedP [of g1 f1 k1]], auto)
     apply (rule cut_same [OF exists_ShiftP [of g2 f2 k2 k1]], auto)
     apply (rule cut_same [OF exists_UnionP [of g "Var g1" "Var g2"]], auto)
     apply (rule Ex_I [where x="Var g"], simp)
     apply (rule Ex_I [where x="Var g1"], simp)
     apply (rule Ex_I [where x="Var g2"], auto)
     done
   thus ?thesis using assms
     by (metis thin0)
 qed
 
 lemma SeqAppendP_Mem1: "{SeqAppendP f1 k1 f2 k2 g, HPair x y IN f1, x IN k1} \<turnstile> HPair x y IN g"
 proof -
   obtain g1::name and g2::name
     where "atom g1 \<sharp> (g2,f1,k1,f2,k2,g,x,y)" "atom g2 \<sharp> (f1,k1,f2,k2,g,x,y)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: SeqAppendP.simps [of g1 g2] intro: UnionP_Mem1 [THEN cut2] RestrictedP_Mem [THEN cut3])
 qed
 
 lemma SeqAppendP_Mem2: "{SeqAppendP f1 k1 f2 k2 g, HaddP k1 x x', x IN k2, HPair x y IN f2} \<turnstile> HPair x' y IN g"
 proof -
   obtain g1::name and g2::name
     where "atom g1 \<sharp> (g2,f1,k1,f2,k2,g,x,x',y)" "atom g2 \<sharp> (f1,k1,f2,k2,g,x,x',y)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: SeqAppendP.simps [of g1 g2] intro: UnionP_Mem2 [THEN cut2] ShiftP_Mem1 [THEN cut4])
 qed
 
 lemma SeqAppendP_Mem_E:
   assumes "H \<turnstile> SeqAppendP f1 k1 f2 k2 g"
       and "insert (HPair x y IN f1) (insert (x IN k1) H) \<turnstile> A"
       and "insert (HPair (Var u) y IN f2) (insert (HaddP k1 (Var u) x) (insert (Var u IN k2) H)) \<turnstile> A"
       and u: "atom u \<sharp> (f1,k1,f2,k2,x,y,g,A)" "\<forall>C \<in> H. atom u \<sharp> C"
   shows "insert (HPair x y IN g) H \<turnstile> A" (*<*)
 proof -
   obtain g1::name and g2::name
   where atoms: "atom g1 \<sharp> (g2,f1,k1,f2,k2,g,x,y,u)" "atom g2 \<sharp> (f1,k1,f2,k2,g,x,y,u)"
     by (metis obtain_fresh)
   hence "{SeqAppendP f1 k1 f2 k2 g, HPair x y IN g}
          \<turnstile> (HPair x y IN f1 AND x IN k1) OR Ex u ((Var u) IN k2 AND HaddP k1 (Var u) x AND HPair (Var u) y IN f2)"
     using u
     apply (auto simp: SeqAppendP.simps [of g1 g2])
     apply (rule UnionP_Mem_E [THEN rotate4])
     apply (rule AssumeH)+
     apply (blast intro: Disj_I1 cut_same [OF RestrictedP_Mem2 [THEN cut2]])
     apply (rule Disj_I2)
     apply (rule cut_same [OF ShiftP_Mem2 [where u=u, THEN cut2]])
     defer 1
     apply force+
     done
   thus ?thesis
     apply (rule cut_same [OF _ [THEN cut2]])
     using assms
     apply (auto intro: thin1 rotate2 thin3 thin4)
     done
 qed (*>*)
 
 section \<open>LstSeqP and SeqAppendP\<close>
 
 lemma HDomain_Incl_SeqAppendP:  \<comment> \<open>The And eliminates the need to prove @{text cut5}\<close>
   "{SeqAppendP f1 k1 f2 k2 g, HDomain_Incl f1 k1 AND HDomain_Incl f2 k2,
     HaddP k1 k2 k, OrdP k1} \<turnstile> HDomain_Incl g k" (*<*)
 proof -
   obtain x::name and y::name and z::name and i::name
     where "atom x \<sharp> (f1,k1,f2,k2,g,k,y,z,i)"  "atom y \<sharp> (f1,k1,f2,k2,g,k,z,i)"
           "atom z \<sharp> (f1,k1,f2,k2,g,k,i)"  "atom i \<sharp> (f1,k1,f2,k2,g,k)"
     by (metis obtain_fresh)
   thus ?thesis
     apply (auto simp: HDomain_Incl.simps [of x _ _ y z])
     apply (rule HaddP_Mem_cases [where i=i, THEN rotate2], auto)
     \<comment> \<open>case 1\<close>
     apply (rule All_E' [where x = "Var x"], blast, auto)
     apply (rule ContraProve [THEN rotate4])
     apply (rule Ex_I [where x = "Var y"], auto)
     apply (rule Ex_I [where x = "Var z"], auto)
     apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same, THEN rotate2], simp)
     apply (rule SeqAppendP_Mem1 [THEN cut3], auto)
     apply (rule Mem_cong [OF Assume Refl, THEN Iff_MP_same], auto)
     \<comment> \<open>case 2\<close>
     apply (rule Ex_I [where x = "Var i"], auto)
     apply (rule ContraProve [THEN rotate5])
     apply (rule Ex_I [where x = "Var y"], simp)
     apply (rule Ex_I [where x = "HPair (Var x) (Var y)"], auto)
     apply (blast intro: SeqAppendP_Mem2 [THEN cut4] Mem_cong [OF _ Refl, THEN Iff_MP_same])
     done
 qed (*>*)
 
 declare SeqAppendP.simps [simp del]
 
 lemma HFun_Sigma_SeqAppendP:
   "{SeqAppendP f1 k1 f2 k2 g, HFun_Sigma f1, HFun_Sigma f2, OrdP k1} \<turnstile> HFun_Sigma g" (*<*)
 proof -
   obtain x::name and y::name and z::name
      and x'::name and y'::name and z'::name and g1::name and g2::name
      and v::name and v'::name and w::name
     where atoms:
        "atom v \<sharp> (v',w,g1,g2,z,z',x,y,x',y',f1,k1,f2,k2,g)" "atom v' \<sharp> (w,g1,g2,z,z',x,y,x',y',f1,k1,f2,k2,g)"
        "atom w \<sharp> (g1,g2,z,z',x,y,x',y',f1,k1,f2,k2,g)"
        "atom g1 \<sharp> (g2,z,z',x,y,x',y',f1,k1,f2,k2,g)" "atom g2 \<sharp> (z,z',x,y,x',y',f1,k1,f2,k2,g)"
        "atom z \<sharp> (z',x,y,x',y',f1,k1,f2,k2,g)" "atom z' \<sharp> (x,y,x',y',f1,k1,f2,k2,g)"
        "atom x \<sharp> (y,x',y',f1,k1,f2,k2,g)" "atom y \<sharp> (x',y',f1,k1,f2,k2,g)"
        "atom x' \<sharp> (y',f1,k1,f2,k2,g)" "atom y' \<sharp> (f1,k1,f2,k2,g)"
     by (metis obtain_fresh)
   thus ?thesis
     apply (simp add: HFun_Sigma.simps [of z g z' x y x' y'] SeqAppendP.simps [of g1 g2])
     apply (rule Ex_EH Conj_EH All_I Imp_I)+
     apply (rule cut_same [OF UnionP_Mem [where a = "Var z", THEN cut2]])
     apply (rule AssumeH)+
     apply (rule Disj_E)
     apply (rule cut_same [OF UnionP_Mem [where a = "Var z'", THEN cut2]])
     apply (rule AssumeH)+
     apply (rule thin1 [where A="UnionP (Var g1) (Var g2) g", THEN rotate6])
     apply (rule Disj_E)
     \<comment> \<open>case 1/1\<close>
     apply (rule thin1 [where A="ShiftP f2 k2 k1 (Var g2)", THEN rotate5])
     apply (rule RestrictedP_Mem_D [where a = "Var z"])
     apply (rule AssumeH)+
     apply (rule RestrictedP_Mem_D [where a = "Var z'"])
     apply (rule AssumeH)+
     apply (simp add: HFun_Sigma.simps [of z f1 z' x y x' y'])
     apply (rule All2_E [where x = "Var z", THEN rotate8], simp_all, blast)
     apply (rule All2_E [where x = "Var z'"], simp_all, blast)
     apply (rule Ex_EH Conj_EH)+
     apply simp_all
     apply (rule Ex_I [where x="Var x"], simp)
     apply (rule Ex_I [where x="Var y"], simp)
     apply (rule Ex_I [where x="Var x'"], simp)
     apply (rule Ex_I [where x="Var y'"], simp)
     apply (rule Conj_I, blast)+
     apply blast
     \<comment> \<open>case 1/2\<close>
     apply (rule RestrictedP_Mem_D [where a = "Var z"])
     apply (rule AssumeH)+
     apply (rule thin1 [where A="Var z IN g", THEN rotate5])
     apply (rule thin1 [where A="Var z' IN g", THEN rotate4])
     apply (rule cut_same [OF HFun_Sigma_Mem_imp_HPair [of _ f1 "Var z" x y]], simp_all)
     apply (rule AssumeH)+
     apply (rule cut_same [OF ShiftP_Mem_D [where x=v and x'=v' and y=w]])
     apply (rule AssumeH Ex_EH Conj_EH)+
     apply auto [3]
     apply (rule AssumeH Ex_EH Conj_EH)+
     apply simp_all
     apply (rule Ex_I [where x="Var x"], simp)
     apply (rule Ex_I [where x="Var y"], simp)
     apply (rule Ex_I [where x="Var v'"], simp)
     apply (rule Ex_I [where x="Var w"], simp)
     apply auto [1]
     apply (blast intro: Mem_HFun_Sigma_OrdP [THEN cut2] Mem_cong [OF _ Refl, THEN Iff_MP_same])
     apply (blast intro: Hyp HaddP_OrdP)
     apply (rule cut_same [OF RestrictedP_Mem2 [THEN cut2]])
     apply (rule AssumeH)+
     apply (blast intro: Mem_cong [OF _ Refl, THEN Iff_MP_same])
     apply (blast intro: Hyp Mem_cong [OF _ Refl, THEN Iff_MP_same] HaddP_Mem_contra)
     \<comment> \<open>END of case 1/2\<close>
     apply (rule cut_same [OF UnionP_Mem [where a = "Var z'", THEN cut2]])
     apply (rule AssumeH)+
     apply (rule thin1 [where A="UnionP (Var g1) (Var g2) g", THEN rotate6])
     apply (rule Disj_E)
     \<comment> \<open>case 2/1\<close>
     apply (rule RestrictedP_Mem_D [where a = "Var z'"])
     apply (rule AssumeH)+
     apply (rule thin1 [where A="Var z IN g", THEN rotate5])
     apply (rule thin1 [where A="Var z' IN g", THEN rotate4])
     apply (rule cut_same [OF HFun_Sigma_Mem_imp_HPair [of _ f1 "Var z'" x y]], simp_all)
     apply (rule AssumeH)+
     apply (rule cut_same [OF ShiftP_Mem_D [where x=v and x'=v' and y=w]])
     apply (rule AssumeH Ex_EH Conj_EH)+
     apply auto [3]
     apply (rule AssumeH Ex_EH Conj_EH)+
     apply simp_all
     apply (rule Ex_I [where x="Var v'"], simp)
     apply (rule Ex_I [where x="Var w"], simp)
     apply (rule Ex_I [where x="Var x"], simp)
     apply (rule Ex_I [where x="Var y"], simp)
     apply auto [1]
     apply (blast intro: Hyp HaddP_OrdP)
     apply (blast intro: Mem_HFun_Sigma_OrdP [THEN cut2] Mem_cong [OF _ Refl, THEN Iff_MP_same])
     apply (rule cut_same [OF RestrictedP_Mem2 [THEN cut2]])
     apply (rule AssumeH)+
     apply (blast intro: Mem_cong [OF _ Refl, THEN Iff_MP_same])
     apply (blast intro: Mem_cong [OF _ Refl, THEN Iff_MP2_same] HaddP_Mem_contra Hyp)
     \<comment> \<open>case 2/2\<close>
     apply (rule cut_same [OF ShiftP_Mem_D [where x=x and x'=x' and y=y and a = "Var z"]])
     apply (rule AssumeH Ex_EH Conj_EH)+
     apply simp_all
     apply (rule cut_same [OF ShiftP_Mem_D [where x=v and x'=v' and y=w and a = "Var z'"]])
     apply (rule AssumeH Ex_EH Conj_EH)+
     apply simp_all
     apply (rule thin1 [where A="ShiftP f2 k2 k1 (Var g2)", THEN rotate7])
     apply (rule thin1 [where A="RestrictedP f1 k1 (Var g1)", THEN rotate7])
     apply (rule AssumeH Ex_EH Conj_EH)+
     apply simp_all
     apply (rule Ex_I [where x="Var x'"], simp)
     apply (rule Ex_I [where x="Var y"], simp)
     apply (rule Ex_I [where x="Var v'"], simp)
     apply (rule Ex_I [where x="Var w"], auto intro: Hyp HaddP_OrdP)
     apply (rule cut_same [where A="Var x EQ Var v"])
     apply (blast intro: HaddP_inv2 [THEN cut3] HaddP_cong [OF Refl Refl, THEN Iff_MP_same] Hyp)
     apply (rule HFun_Sigma_E [where r=f2])
     apply (auto intro: Hyp Var_Eq_subst_Iff [THEN Iff_MP_same])
     done
 qed (*>*)
 
 lemma LstSeqP_SeqAppendP:
   assumes "H \<turnstile> SeqAppendP f1 (SUCC k1) f2 (SUCC k2) g"
           "H \<turnstile> LstSeqP f1 k1 y1" "H \<turnstile> LstSeqP f2 k2 y2" "H \<turnstile> HaddP k1 k2 k"
   shows "H \<turnstile> LstSeqP g (SUCC k) y2"
 proof -
   have "{SeqAppendP f1 (SUCC k1) f2 (SUCC k2) g, LstSeqP f1 k1 y1, LstSeqP f2 k2 y2, HaddP k1 k2 k}
    \<turnstile> LstSeqP g (SUCC k) y2"
     apply (auto simp: LstSeqP.simps intro: HaddP_OrdP OrdP_SUCC_I)
     apply (rule HDomain_Incl_SeqAppendP [THEN cut4])
     apply (rule AssumeH Conj_I)+
     apply (blast intro: HaddP_SUCC1 [THEN cut1] HaddP_SUCC2 [THEN cut1])
     apply (blast intro: HaddP_OrdP OrdP_SUCC_I)
     apply (rule HFun_Sigma_SeqAppendP [THEN cut4])
     apply (auto intro: HaddP_OrdP OrdP_SUCC_I)
     apply (blast intro: Mem_SUCC_Refl HaddP_SUCC1 [THEN cut1] HaddP_SUCC2 [THEN cut1]
                         SeqAppendP_Mem2 [THEN cut4])
     done
   thus ?thesis using assms
     by (rule cut4)
 qed
 
 lemma SeqAppendP_NotInDom: "{SeqAppendP f1 k1 f2 k2 g, HaddP k1 k2 k, OrdP k1} \<turnstile> NotInDom k g"
 proof -
   obtain x::name and z::name
     where "atom x \<sharp> (z,f1,k1,f2,k2,g,k)"  "atom z \<sharp> (f1,k1,f2,k2,g,k)"
     by (metis obtain_fresh)
   thus ?thesis
     apply (auto simp: NotInDom.simps [of z])
     apply (rule SeqAppendP_Mem_E [where u=x])
     apply (rule AssumeH)+
     apply (blast intro: HaddP_Mem_contra, simp_all)
     apply (rule cut_same [where A="(Var x) EQ k2"])
     apply (blast intro: HaddP_inv2 [THEN cut3])
     apply (blast intro: Mem_non_refl [where x=k2] Mem_cong [OF _ Refl, THEN Iff_MP_same])
     done
 qed
 
 lemma LstSeqP_SeqAppendP_Eats:
   assumes "H \<turnstile> SeqAppendP f1 (SUCC k1) f2 (SUCC k2) g"
           "H \<turnstile> LstSeqP f1 k1 y1" "H \<turnstile> LstSeqP f2 k2 y2" "H \<turnstile> HaddP k1 k2 k"
   shows "H \<turnstile> LstSeqP (Eats g (HPair (SUCC (SUCC k)) z)) (SUCC (SUCC k)) z"
 proof -
   have "{SeqAppendP f1 (SUCC k1) f2 (SUCC k2) g, LstSeqP f1 k1 y1, LstSeqP f2 k2 y2, HaddP k1 k2 k}
         \<turnstile> LstSeqP (Eats g (HPair (SUCC (SUCC k)) z)) (SUCC (SUCC k)) z"
     apply (rule cut2 [OF NotInDom_LstSeqP_Eats])
     apply (rule SeqAppendP_NotInDom [THEN cut3])
     apply (rule AssumeH)
     apply (metis HaddP_SUCC1 HaddP_SUCC2 cut1 thin1)
     apply (metis Assume LstSeqP_OrdP OrdP_SUCC_I insert_commute)
     apply (blast intro: LstSeqP_SeqAppendP)
     done
   thus ?thesis using assms
     by (rule cut4)
 qed
 
 section \<open>Substitution and Abstraction on Terms\<close>
 
 subsection \<open>Atomic cases\<close>
 
 lemma SeqStTermP_Var_same:
   assumes "atom s \<sharp> (k,v,i)" "atom k \<sharp> (v,i)"
     shows "{VarP v} \<turnstile> Ex s (Ex k (SeqStTermP v i v i (Var s) (Var k)))"
 proof -
   obtain l::name and sl::name and sl'::name and m::name and sm::name and sm'::name
      and n::name and sn::name and sn'::name
     where "atom l \<sharp> (v,i,s,k,sl,sl',m,n,sm,sm',sn,sn')"
           "atom sl \<sharp> (v,i,s,k,sl',m,n,sm,sm',sn,sn')"
           "atom sl' \<sharp> (v,i,s,k,m,n,sm,sm',sn,sn')"
           "atom m \<sharp> (v,i,s,k,n,sm,sm',sn,sn')" "atom n \<sharp> (v,i,s,k,sm,sm',sn,sn')"
           "atom sm \<sharp> (v,i,s,k,sm',sn,sn')" "atom sm' \<sharp> (v,i,s,k,sn,sn')"
           "atom sn \<sharp> (v,i,s,k,sn')" "atom sn' \<sharp> (v,i,s,k)"
     by (metis obtain_fresh)
   thus ?thesis using assms
     apply (simp add: SeqStTermP.simps [of l _ _ v i sl sl' m n sm sm' sn sn'])
     apply (rule Ex_I [where x = "Eats Zero (HPair Zero (HPair v i))"], simp)
     apply (rule Ex_I [where x = Zero], auto intro!: Mem_SUCC_EH)
     apply (rule Ex_I [where x = v], simp)
     apply (rule Ex_I [where x = i], auto intro: Disj_I1 Mem_Eats_I2 HPair_cong)
     done
 qed
 
 lemma SeqStTermP_Var_diff:
   assumes "atom s \<sharp> (k,v,w,i)" "atom k \<sharp> (v,w,i)"
     shows "{VarP v, VarP w, Neg (v EQ w) } \<turnstile> Ex s (Ex k (SeqStTermP v i w w (Var s) (Var k)))"
 proof -
   obtain l::name and sl::name and sl'::name and m::name and sm::name and sm'::name
      and n::name and sn::name and sn'::name
     where "atom l \<sharp> (v,w,i,s,k,sl,sl',m,n,sm,sm',sn,sn')"
           "atom sl \<sharp> (v,w,i,s,k,sl',m,n,sm,sm',sn,sn')"
           "atom sl' \<sharp> (v,w,i,s,k,m,n,sm,sm',sn,sn')"
           "atom m \<sharp> (v,w,i,s,k,n,sm,sm',sn,sn')" "atom n \<sharp> (v,w,i,s,k,sm,sm',sn,sn')"
           "atom sm \<sharp> (v,w,i,s,k,sm',sn,sn')" "atom sm' \<sharp> (v,w,i,s,k,sn,sn')"
           "atom sn \<sharp> (v,w,i,s,k,sn')" "atom sn' \<sharp> (v,w,i,s,k)"
     by (metis obtain_fresh)
   thus ?thesis using assms
     apply (simp add: SeqStTermP.simps [of l _ _ v i sl sl' m n sm sm' sn sn'])
     apply (rule Ex_I [where x = "Eats Zero (HPair Zero (HPair w w))"], simp)
     apply (rule Ex_I [where x = Zero], auto intro!: Mem_SUCC_EH)
     apply (rule rotate2 [OF Swap])
     apply (rule Ex_I [where x = w], simp)
     apply (rule Ex_I [where x = w], auto simp: VarP_def)
     apply (blast intro: HPair_cong Mem_Eats_I2)
     apply (blast intro: Sym OrdNotEqP_I Disj_I1 Disj_I2)
     done
 qed
 
 lemma SeqStTermP_Zero:
   assumes "atom s \<sharp> (k,v,i)" "atom k \<sharp> (v,i)"
     shows "{VarP v} \<turnstile> Ex s (Ex k (SeqStTermP v i Zero Zero (Var s) (Var k)))" (*<*)
 proof -
   obtain l::name and sl::name and sl'::name and m::name and sm::name and sm'::name
      and n::name and sn::name and sn'::name
     where "atom l \<sharp> (v,i,s,k,sl,sl',m,n,sm,sm',sn,sn')"
           "atom sl \<sharp> (v,i,s,k,sl',m,n,sm,sm',sn,sn')"
           "atom sl' \<sharp> (v,i,s,k,m,n,sm,sm',sn,sn')"
           "atom m \<sharp> (v,i,s,k,n,sm,sm',sn,sn')" "atom n \<sharp> (v,i,s,k,sm,sm',sn,sn')"
           "atom sm \<sharp> (v,i,s,k,sm',sn,sn')" "atom sm' \<sharp> (v,i,s,k,sn,sn')"
           "atom sn \<sharp> (v,i,s,k,sn')" "atom sn' \<sharp> (v,i,s,k)"
     by (metis obtain_fresh)
   thus ?thesis using assms
     apply (simp add: SeqStTermP.simps [of l _ _ v i sl sl' m n sm sm' sn sn'])
     apply (rule Ex_I [where x = "Eats Zero (HPair Zero (HPair Zero Zero))"], simp)
     apply (rule Ex_I [where x = Zero], auto intro!: Mem_SUCC_EH)
     apply (rule Ex_I [where x = Zero], simp)
     apply (rule Ex_I [where x = Zero], simp)
     apply (rule Conj_I)
     apply (force intro: Var_Eq_subst_Iff [THEN Iff_MP_same] Mem_Eats_I2)
     apply (force simp: VarP_def OrdNotEqP.simps intro: Disj_I1 Disj_I2)
     done
 qed (*>*)
 
-corollary SubstTermP_Zero: "{TermP t} \<turnstile> SubstTermP \<lceil>Var v\<rceil> t Zero Zero"
+corollary SubstTermP_Zero: "{TermP t} \<turnstile> SubstTermP \<guillemotleft>Var v\<guillemotright> t Zero Zero"
 proof -
   obtain s::name and k::name where "atom s \<sharp> (v,t,k)"  "atom k \<sharp> (v,t)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: SubstTermP.simps [of s _ _ _ _ k] intro: SeqStTermP_Zero [THEN cut1])
 qed
 
 corollary SubstTermP_Var_same: "{VarP v, TermP t} \<turnstile> SubstTermP v t v t"
 proof -
   obtain s::name and k::name where "atom s \<sharp> (v,t,k)" "atom k \<sharp> (v,t)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: SubstTermP.simps [of s _ _ _ _ k] intro: SeqStTermP_Var_same [THEN cut1])
 qed
 
 corollary SubstTermP_Var_diff: "{VarP v, VarP w, Neg (v EQ w), TermP t} \<turnstile> SubstTermP v t w w"
 proof -
   obtain s::name and k::name where "atom s \<sharp> (v,w,t,k)" "atom k \<sharp> (v,w,t)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: SubstTermP.simps [of s _ _ _ _ k] intro: SeqStTermP_Var_diff [THEN cut3])
 qed
 
 lemma SeqStTermP_Ind:
   assumes "atom s \<sharp> (k,v,t,i)" "atom k \<sharp> (v,t,i)"
     shows "{VarP v, IndP t} \<turnstile> Ex s (Ex k (SeqStTermP v i t t (Var s) (Var k)))"
 proof -
   obtain l::name and sl::name and sl'::name and m::name and sm::name and sm'::name
      and n::name and sn::name and sn'::name
     where "atom l \<sharp> (v,t,i,s,k,sl,sl',m,n,sm,sm',sn,sn')"
           "atom sl \<sharp> (v,t,i,s,k,sl',m,n,sm,sm',sn,sn')"
           "atom sl' \<sharp> (v,t,i,s,k,m,n,sm,sm',sn,sn')"
           "atom m \<sharp> (v,t,i,s,k,n,sm,sm',sn,sn')" "atom n \<sharp> (v,t,i,s,k,sm,sm',sn,sn')"
           "atom sm \<sharp> (v,t,i,s,k,sm',sn,sn')" "atom sm' \<sharp> (v,t,i,s,k,sn,sn')"
           "atom sn \<sharp> (v,t,i,s,k,sn')" "atom sn' \<sharp> (v,t,i,s,k)"
     by (metis obtain_fresh)
   thus ?thesis using assms
     apply (simp add: SeqStTermP.simps [of l _ _ v i sl sl' m n sm sm' sn sn'])
     apply (rule Ex_I [where x = "Eats Zero (HPair Zero (HPair t t))"], simp)
     apply (rule Ex_I [where x = Zero], auto intro!: Mem_SUCC_EH)
     apply (rule Ex_I [where x = t], simp)
     apply (rule Ex_I [where x = t], auto intro: HPair_cong Mem_Eats_I2)
     apply (blast intro: Disj_I1 Disj_I2 VarP_neq_IndP)
     done
 qed
 
 corollary SubstTermP_Ind: "{VarP v, IndP w, TermP t} \<turnstile> SubstTermP v t w w"
 proof -
   obtain s::name and k::name where "atom s \<sharp> (v,w,t,k)" "atom k \<sharp> (v,w,t)"
     by (metis obtain_fresh)
   thus ?thesis
     by (force simp: SubstTermP.simps [of s _ _ _ _ k]
               intro: SeqStTermP_Ind [THEN cut2])
 qed
 
 subsection \<open>Non-atomic cases\<close>
 
 lemma SeqStTermP_Eats:
   assumes sk: "atom s \<sharp> (k,s1,s2,k1,k2,t1,t2,u1,u2,v,i)"
               "atom k \<sharp> (t1,t2,u1,u2,v,i)"
     shows "{SeqStTermP v i t1 u1 s1 k1, SeqStTermP v i t2 u2 s2 k2}
            \<turnstile> Ex s (Ex k (SeqStTermP v i (Q_Eats t1 t2) (Q_Eats u1 u2) (Var s) (Var k)))" (*<*)
 proof -
   obtain km::name and kn::name and j::name and k'::name and l::name and sl::name and sl'::name
      and m::name and n::name and sm::name and sm'::name and sn::name and sn'::name
     where atoms2: "atom km \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,v,i,kn,j,k',l,sl,sl',m,n,sm,sm',sn,sn')"
          "atom kn \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,v,i,j,k',l,sl,sl',m,n,sm,sm',sn,sn')"
          "atom j  \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,v,i,k',l,sl,sl',m,n,sm,sm',sn,sn')"
       and atoms: "atom k' \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,v,i,l,sl,sl',m,n,sm,sm',sn,sn')"
          "atom l  \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,v,i,sl,sl',m,n,sm,sm',sn,sn')"
          "atom sl \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,v,i,sl',m,n,sm,sm',sn,sn')"
          "atom sl'\<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,v,i,m,n,sm,sm',sn,sn')"
          "atom m  \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,v,i,n,sm,sm',sn,sn')"
          "atom n  \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,v,i,sm,sm',sn,sn')"
          "atom sm \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,v,i,sm',sn,sn')"
          "atom sm'\<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,v,i,sn,sn')"
          "atom sn \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,v,i,sn')"
          "atom sn'\<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,v,i)"
     by (metis obtain_fresh)
   let ?hyp = "{HaddP k1 k2 (Var k'), OrdP k1, OrdP k2, SeqAppendP s1 (SUCC k1) s2 (SUCC k2) (Var s), SeqStTermP v i t1 u1 s1 k1, SeqStTermP v i t2 u2 s2 k2}"
   show ?thesis
      using sk atoms
      apply (auto simp: SeqStTermP.simps [of l "Var s" _ _ _ sl sl' m n sm sm' sn sn'])
      apply (rule cut_same [where A="OrdP k1 AND OrdP k2"])
      apply (metis Conj_I SeqStTermP_imp_OrdP thin1 thin2)
      apply (rule cut_same [OF exists_SeqAppendP [of s s1 "SUCC k1" s2 "SUCC k2"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule cut_same [OF exists_HaddP [where j=k' and x=k1 and y=k2]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Q_Eats t1 t2) (Q_Eats u1 u2)))"])
      apply (simp_all (no_asm_simp))
      apply (rule Ex_I [where x="SUCC (SUCC (Var k'))"], simp)
      apply (rule Conj_I [OF _ Conj_I])
      apply (metis SeqStTermP_imp_VarP thin1)
      apply (blast intro: LstSeqP_SeqAppendP_Eats SeqStTermP_imp_LstSeqP [THEN cut1])
      proof (rule All2_SUCC_I, simp_all)
        show "?hyp \<turnstile> Ex sl (Ex sl'
               (HPair (SUCC (SUCC (Var k'))) (HPair (Var sl) (Var sl')) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Q_Eats t1 t2) (Q_Eats u1 u2))) AND
                ((Var sl EQ v AND Var sl' EQ i OR (IndP (Var sl) OR Var sl NEQ v) AND Var sl' EQ Var sl) OR
                 Ex m (Ex n (Ex sm (Ex sm' (Ex sn (Ex sn'
                  (Var m IN SUCC (SUCC (Var k')) AND
                   Var n IN SUCC (SUCC (Var k')) AND
                   HPair (Var m) (HPair (Var sm) (Var sm')) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Q_Eats t1 t2) (Q_Eats u1 u2))) AND
                   HPair (Var n) (HPair (Var sn) (Var sn')) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Q_Eats t1 t2) (Q_Eats u1 u2))) AND
                   Var sl EQ Q_Eats (Var sm) (Var sn) AND Var sl' EQ Q_Eats (Var sm') (Var sn'))))))))))"
        \<comment> \<open>verifying the final values\<close>
        apply (rule Ex_I [where x="Q_Eats t1 t2"])
        using sk atoms apply simp
        apply (rule Ex_I [where x="Q_Eats u1 u2"], simp)
        apply (rule Conj_I, metis Mem_Eats_I2 Refl)
        apply (rule Disj_I2)
        apply (rule Ex_I [where x=k1], simp)
        apply (rule Ex_I [where x="SUCC (Var k')"], simp)
        apply (rule Ex_I [where x=t1], simp)
        apply (rule Ex_I [where x=u1], simp)
        apply (rule Ex_I [where x=t2], simp)
        apply (rule Ex_I [where x=u2], simp)
        apply (rule Conj_I)
        apply (blast intro: HaddP_Mem_I LstSeqP_OrdP Mem_SUCC_I1)
        apply (rule Conj_I [OF Mem_SUCC_Refl Conj_I])
        apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem1 [THEN cut3] Mem_SUCC_Refl SeqStTermP_imp_LstSeqP [THEN cut1]
                            LstSeqP_imp_Mem)
        apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] Mem_SUCC_Refl SeqStTermP_imp_LstSeqP [THEN cut1]
                            HaddP_SUCC1 [THEN cut1] LstSeqP_imp_Mem)
        done
      next
        show "?hyp \<turnstile> All2 l (SUCC (SUCC (Var k')))
                 (Ex sl (Ex sl'
                   (HPair (Var l) (HPair (Var sl) (Var sl')) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Q_Eats t1 t2) (Q_Eats u1 u2))) AND
                    ((Var sl EQ v AND Var sl' EQ i OR (IndP (Var sl) OR Var sl NEQ v) AND Var sl' EQ Var sl) OR
                     Ex m (Ex n (Ex sm (Ex sm' (Ex sn (Ex sn'
                        (Var m IN Var l AND
                         Var n IN Var l AND
                         HPair (Var m) (HPair (Var sm) (Var sm')) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Q_Eats t1 t2) (Q_Eats u1 u2))) AND
                         HPair (Var n) (HPair (Var sn) (Var sn')) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Q_Eats t1 t2) (Q_Eats u1 u2))) AND
                         Var sl EQ Q_Eats (Var sm) (Var sn) AND Var sl' EQ Q_Eats (Var sm') (Var sn')))))))))))"
      \<comment> \<open>verifying the sequence buildup\<close>
      apply (rule cut_same [where A="HaddP (SUCC k1) (SUCC k2) (SUCC (SUCC (Var k')))"])
      apply (blast intro: HaddP_SUCC1 [THEN cut1] HaddP_SUCC2 [THEN cut1])
      apply (rule All_I Imp_I)+
      apply (rule HaddP_Mem_cases [where i=j])
      using sk atoms atoms2 apply simp_all
      apply (rule AssumeH)
      apply (blast intro: OrdP_SUCC_I LstSeqP_OrdP)
      \<comment> \<open>... the sequence buildup via s1\<close>
      apply (simp add: SeqStTermP.simps [of l s1 _ _ _ sl sl' m n sm sm' sn sn'])
      apply (rule AssumeH Ex_EH Conj_EH)+
      apply (rule All2_E [THEN rotate2])
      apply (simp | rule AssumeH Ex_EH Conj_EH)+
      apply (rule Ex_I [where x="Var sl"], simp)
      apply (rule Ex_I [where x="Var sl'"], simp)
      apply (rule Conj_I)
      apply (metis Mem_Eats_I1 SeqAppendP_Mem1 rotate3 thin2 thin4)
      apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
      apply (rule Ex_I [where x="Var m"], simp)
      apply (rule Ex_I [where x="Var n"], simp)
      apply (rule Ex_I [where x="Var sm"], simp)
      apply (rule Ex_I [where x="Var sm'"], simp)
      apply (rule Ex_I [where x="Var sn"], simp)
      apply (rule Ex_I [where x="Var sn'"], simp_all)
      apply (rule Conj_I, rule AssumeH)+
      apply (blast del: Disj_EH intro: OrdP_Trans [OF OrdP_SUCC_I] Mem_Eats_I1 [OF SeqAppendP_Mem1 [THEN cut3]] Hyp)
      \<comment> \<open>... the sequence buildup via s2\<close>
      apply (simp add: SeqStTermP.simps [of l s2 _ _ _ sl sl' m n sm sm' sn sn'])
      apply (rule AssumeH Ex_EH Conj_EH)+
      apply (rule All2_E [THEN rotate2])
      apply (simp | rule AssumeH Ex_EH Conj_EH)+
      apply (rule Ex_I [where x="Var sl"], simp)
      apply (rule Ex_I [where x="Var sl'"], simp)
      apply (rule cut_same [where A="OrdP (Var j)"])
      apply (metis HaddP_imp_OrdP rotate2 thin2)
      apply (rule Conj_I)
      apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] del: Disj_EH)
      apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
      apply simp_all
      apply (rule cut_same [OF exists_HaddP [where j=km and x="SUCC k1" and y="Var m"]])
      apply (blast intro!: Ord_IN_Ord, simp)
      apply (rule cut_same [OF exists_HaddP [where j=kn and x="SUCC k1" and y="Var n"]])
      apply (blast intro!: Ord_IN_Ord, simp)
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule Ex_I [where x="Var km"], simp)
      apply (rule Ex_I [where x="Var kn"], simp)
      apply (rule Ex_I [where x="Var sm"], simp)
      apply (rule Ex_I [where x="Var sm'"], simp)
      apply (rule Ex_I [where x="Var sn"], simp)
      apply (rule Ex_I [where x="Var sn'"], simp_all)
      apply (rule Conj_I [OF _ Conj_I])
      apply (blast intro!: HaddP_Mem_cancel_left [THEN Iff_MP2_same] OrdP_SUCC_I intro: LstSeqP_OrdP Hyp)+
      apply (blast intro: OrdP_Trans Hyp Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] HaddP_imp_OrdP [THEN cut1])
      done
    qed
 qed (*>*)
 
 theorem SubstTermP_Eats:
    "{SubstTermP v i t1 u1, SubstTermP v i t2 u2} \<turnstile> SubstTermP v i (Q_Eats t1 t2) (Q_Eats u1 u2)"
 proof -
   obtain k1::name and s1::name and k2::name and s2::name and k::name and s::name
     where "atom s1 \<sharp> (v,i,t1,u1,t2,u2)" "atom k1 \<sharp> (v,i,t1,u1,t2,u2,s1)"
           "atom s2 \<sharp> (v,i,t1,u1,t2,u2,k1,s1)" "atom k2 \<sharp> (v,i,t1,u1,t2,u2,s2,k1,s1)"
           "atom s  \<sharp> (v,i,t1,u1,t2,u2,k2,s2,k1,s1)"
           "atom k  \<sharp> (v,i,t1,u1,t2,u2,s,k2,s2,k1,s1)"
     by (metis obtain_fresh)
    thus ?thesis
      by (auto intro!: SeqStTermP_Eats [THEN cut2]
               simp: SubstTermP.simps [of s _ _ _ "(Q_Eats u1 u2)" k]
                     SubstTermP.simps [of s1 v i t1 u1 k1]
                     SubstTermP.simps [of s2 v i t2 u2 k2])
 qed
 
 subsection \<open>Substitution over a constant\<close>
 
 lemma SeqConstP_lemma:
   assumes "atom m \<sharp> (s,k,c,n,sm,sn)"  "atom n \<sharp> (s,k,c,sm,sn)"
           "atom sm \<sharp> (s,k,c,sn)"      "atom sn \<sharp> (s,k,c)"
     shows "{ SeqConstP s k c }
            \<turnstile> c EQ Zero OR
              Ex m (Ex n (Ex sm (Ex sn (Var m IN k AND Var n IN k AND
                    SeqConstP s (Var m) (Var sm) AND
                    SeqConstP s (Var n) (Var sn) AND
                    c EQ Q_Eats (Var sm) (Var sn)))))"  (*<*)
 proof -
   obtain l::name and sl::name where "atom l \<sharp> (s,k,c,sl,m,n,sm,sn)" "atom sl \<sharp> (s,k,c,m,n,sm,sn)"
     by (metis obtain_fresh)
   thus ?thesis using assms
     apply (simp add: SeqCTermP.simps [of l s k sl m n sm sn])
     apply (rule Conj_EH)+
     apply (rule All2_SUCC_E [THEN rotate2], auto del: Disj_EH)
     apply (rule cut_same [where A = "c EQ (Var sl)"])
     apply (metis Assume AssumeH(4) LstSeqP_EQ)
     apply (rule Disj_EH)
     apply (blast intro: Disj_I1 Sym Trans)
     \<comment> \<open>now the quantified case\<close>
     apply (auto intro!: Disj_I2)
     apply (rule Ex_I [where x = "Var m"], simp)
     apply (rule Ex_I [where x = "Var n"], simp)
     apply (rule Ex_I [where x = "Var sm"], simp)
     apply (rule Ex_I [where x = "Var sn"], simp)
     apply (simp_all add: SeqCTermP.simps [of l s _ sl m n sm sn])
     apply ((rule Conj_I)+, blast intro: LstSeqP_Mem)+
     \<comment> \<open>first SeqCTermP subgoal\<close>
     apply (rule All2_Subset [OF Hyp], blast)
     apply (blast intro!: SUCC_Subset_Ord LstSeqP_OrdP, blast, simp)
     \<comment> \<open>next SeqCTermP subgoal\<close>
     apply ((rule Conj_I)+, blast intro: LstSeqP_Mem)+
     apply (rule All2_Subset [OF Hyp], blast)
     apply (blast intro!: SUCC_Subset_Ord LstSeqP_OrdP, blast, simp)
     \<comment> \<open>finally, the equality pair\<close>
     apply (blast intro: Trans)
     done
 qed (*>*)
 
-lemma SeqConstP_imp_SubstTermP: "{SeqConstP s kk c, TermP t} \<turnstile> SubstTermP \<lceil>Var w\<rceil> t c c" (*<*)
+lemma SeqConstP_imp_SubstTermP: "{SeqConstP s kk c, TermP t} \<turnstile> SubstTermP \<guillemotleft>Var w\<guillemotright> t c c" (*<*)
 proof -
   obtain j::name and k::name and l::name and sl::name and m::name and n::name and sm::name and sn::name
     where atoms: "atom j \<sharp> (s,kk,c,t,k,l,sl,m,n,sm,sn)"  "atom k \<sharp> (s,kk,c,t,l,sl,m,n,sm,sn)"
                  "atom l \<sharp> (s,kk,c,t,sl,m,n,sm,sn)"   "atom sl \<sharp> (s,kk,c,t,m,n,sm,sn)"
                  "atom m \<sharp> (s,kk,c,t,n,sm,sn)"  "atom n \<sharp> (s,kk,c,t,sm,sn)"
                  "atom sm \<sharp> (s,kk,c,t,sn)"      "atom sn \<sharp> (s,kk,c,t)"
     by (metis obtain_fresh)
-  have "{ OrdP (Var k), TermP t } \<turnstile> All j (SeqConstP s (Var k) (Var j) IMP SubstTermP \<lceil>Var w\<rceil> t (Var j) (Var j))"
+  have "{ OrdP (Var k), TermP t } \<turnstile> All j (SeqConstP s (Var k) (Var j) IMP SubstTermP \<guillemotleft>Var w\<guillemotright> t (Var j) (Var j))"
         (is "_ \<turnstile> ?scheme")
     proof (rule OrdIndH [where j=l])
       show "atom l \<sharp> (k, ?scheme)" using atoms
         by simp
     next
       show "{TermP t} \<turnstile> All k (OrdP (Var k) IMP (All2 l (Var k) (?scheme(k::= Var l)) IMP ?scheme))"
         using atoms apply auto
         apply (rule Swap)
         apply (rule cut_same)
         apply (rule cut1 [OF SeqConstP_lemma [of m s "Var k" "Var j" n sm sn]], auto)
         \<comment> \<open>case 1, @{term Zero}\<close>
         apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same])
         apply (auto intro: SubstTermP_Zero [THEN cut1])
         \<comment> \<open>case 2, @{term Q_Eats}\<close>
         apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same, THEN rotate2], simp)
         apply (rule SubstTermP_Eats [THEN cut2])
         \<comment> \<open>First argument\<close>
         apply (rule All2_E' [OF Hyp, where x="Var m"], blast+, simp_all)
         apply (force intro: All_E [where x="Var sm"])
         \<comment> \<open>Second argument\<close>
         apply (rule All2_E' [OF Hyp, where x="Var n"], blast+, simp_all)
         apply (rule All_E [where x="Var sn"], auto)
         done
     qed
-  hence "{OrdP (Var k), TermP t} \<turnstile> (SeqConstP s (Var k) (Var j) IMP SubstTermP \<lceil>Var w\<rceil> t (Var j) (Var j))(j::=c)"
+  hence "{OrdP (Var k), TermP t} \<turnstile> (SeqConstP s (Var k) (Var j) IMP SubstTermP \<guillemotleft>Var w\<guillemotright> t (Var j) (Var j))(j::=c)"
     by (metis All_D)
-  hence "{TermP t} \<turnstile> (SeqConstP s (Var k) c IMP SubstTermP \<lceil>Var w\<rceil> t c c)"
+  hence "{TermP t} \<turnstile> (SeqConstP s (Var k) c IMP SubstTermP \<guillemotleft>Var w\<guillemotright> t c c)"
     using atoms by simp (metis Imp_cut SeqCTermP_imp_OrdP)
-  hence "{TermP t} \<turnstile> (SeqConstP s (Var k) c IMP SubstTermP \<lceil>Var w\<rceil> t c c)(k::=kk)"
+  hence "{TermP t} \<turnstile> (SeqConstP s (Var k) c IMP SubstTermP \<guillemotleft>Var w\<guillemotright> t c c)(k::=kk)"
     using atoms by (force intro!: Subst)
   thus ?thesis
     using atoms by (simp add: anti_deduction)
 qed (*>*)
 
-theorem SubstTermP_Const: "{ConstP c, TermP t} \<turnstile> SubstTermP \<lceil>Var w\<rceil> t c c"
+theorem SubstTermP_Const: "{ConstP c, TermP t} \<turnstile> SubstTermP \<guillemotleft>Var w\<guillemotright> t c c"
 proof -
   obtain s::name and k::name where "atom s \<sharp> (c,t,w,k)" "atom k \<sharp> (c,t,w)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: CTermP.simps [of k s c] SeqConstP_imp_SubstTermP)
 qed
 
 
 section \<open>Substitution on Formulas\<close>
 
 subsection \<open>Membership\<close>
 
 lemma SubstAtomicP_Mem:
   "{SubstTermP v i x x', SubstTermP v i y y'} \<turnstile> SubstAtomicP v i (Q_Mem x y) (Q_Mem x' y')"
 proof -
   obtain t::name and u::name and t'::name and u'::name
     where "atom t \<sharp> (v,i,x,x',y,y',t',u,u')" "atom t' \<sharp> (v,i,x,x',y,y',u,u')"
       "atom u \<sharp> (v,i,x,x',y,y',u')" "atom u' \<sharp> (v,i,x,x',y,y')"
     by (metis obtain_fresh)
   thus ?thesis
     apply (simp add: SubstAtomicP.simps [of t _ _ _ _ t' u u'])
     apply (rule Ex_I [where x = x], simp)
     apply (rule Ex_I [where x = y], simp)
     apply (rule Ex_I [where x = x'], simp)
     apply (rule Ex_I [where x = y'], auto intro: Disj_I2)
     done
 qed
 
 lemma SeqSubstFormP_Mem:
   assumes "atom s \<sharp> (k,x,y,x',y',v,i)" "atom k \<sharp> (x,y,x',y',v,i)"
   shows "{SubstTermP v i x x', SubstTermP v i y y'}
            \<turnstile> Ex s (Ex k (SeqSubstFormP v i (Q_Mem x y) (Q_Mem x' y') (Var s) (Var k)))"
 proof -
   let ?vs = "(s,k,x,y,x',y',v,i)"
   obtain l::name and sl::name and sl'::name and m::name and n::name and sm::name and sm'::name and sn::name and sn'::name
     where "atom l \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn')"
       "atom sl \<sharp> (?vs,sl',m,n,sm,sm',sn,sn')" "atom sl' \<sharp> (?vs,m,n,sm,sm',sn,sn')"
       "atom m \<sharp> (?vs,n,sm,sm',sn,sn')" "atom n \<sharp> (?vs,sm,sm',sn,sn')"
       "atom sm \<sharp> (?vs,sm',sn,sn')" "atom sm' \<sharp> (?vs,sn,sn')"
       "atom sn \<sharp> (?vs,sn')" "atom sn' \<sharp> ?vs"
     by (metis obtain_fresh)
   thus ?thesis
     using assms
     apply (auto simp: SeqSubstFormP.simps [of l "Var s" _ _ _ sl sl' m n sm sm' sn sn'])
     apply (rule Ex_I [where x = "Eats Zero (HPair Zero (HPair (Q_Mem x y) (Q_Mem x' y')))"], simp)
     apply (rule Ex_I [where x = Zero], auto intro!: Mem_SUCC_EH)
     apply (rule Ex_I [where x = "Q_Mem x y"], simp)
     apply (rule Ex_I [where x = "Q_Mem x' y'"], auto intro: Mem_Eats_I2 HPair_cong)
     apply (blast intro: SubstAtomicP_Mem [THEN cut2] Disj_I1)
     done
 qed
 
 lemma SubstFormP_Mem:
   "{SubstTermP v i x x', SubstTermP v i y y'} \<turnstile> SubstFormP v i (Q_Mem x y) (Q_Mem x' y')"
 proof -
   obtain k1::name and s1::name and k2::name and s2::name and k::name and s::name
     where "atom s1 \<sharp> (v,i,x,y,x',y')" "atom k1 \<sharp> (v,i,x,y,x',y',s1)"
       "atom s2 \<sharp> (v,i,x,y,x',y',k1,s1)" "atom k2 \<sharp> (v,i,x,y,x',y',s2,k1,s1)"
       "atom s  \<sharp> (v,i,x,y,x',y',k2,s2,k1,s1)" "atom k  \<sharp> (v,i,x,y,x',y',s,k2,s2,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: SubstFormP.simps [of s v i "(Q_Mem x y)" _ k]
         SubstFormP.simps [of s1 v i x x' k1]
         SubstFormP.simps [of s2 v i y y' k2]
         intro: SubstTermP_imp_TermP SubstTermP_imp_VarP SeqSubstFormP_Mem thin1)
 qed
 
 subsection \<open>Equality\<close>
 
 lemma SubstAtomicP_Eq:
   "{SubstTermP v i x x', SubstTermP v i y y'} \<turnstile> SubstAtomicP v i (Q_Eq x y) (Q_Eq x' y')"
 proof -
   obtain t::name and u::name and t'::name  and u'::name
     where "atom t \<sharp> (v,i,x,x',y,y',t',u,u')" "atom t' \<sharp> (v,i,x,x',y,y',u,u')"
       "atom u \<sharp> (v,i,x,x',y,y',u')" "atom u' \<sharp> (v,i,x,x',y,y')"
     by (metis obtain_fresh)
   thus ?thesis
     apply (simp add: SubstAtomicP.simps [of t _ _ _ _ t' u u'])
     apply (rule Ex_I [where x = x], simp)
     apply (rule Ex_I [where x = y], simp)
     apply (rule Ex_I [where x = x'], simp)
     apply (rule Ex_I [where x = y'], auto intro: Disj_I1)
     done
 qed
 
 lemma SeqSubstFormP_Eq:
   assumes sk: "atom s \<sharp> (k,x,y,x',y',v,i)" "atom k \<sharp> (x,y,x',y',v,i)"
   shows "{SubstTermP v i x x', SubstTermP v i y y'}
            \<turnstile> Ex s (Ex k (SeqSubstFormP v i (Q_Eq x y) (Q_Eq x' y') (Var s) (Var k)))"
 proof -
   let ?vs = "(s,k,x,y,x',y',v,i)"
   obtain l::name and sl::name and sl'::name and m::name and n::name and sm::name and sm'::name and sn::name and sn'::name
     where "atom l \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn')"
       "atom sl \<sharp> (?vs,sl',m,n,sm,sm',sn,sn')" "atom sl' \<sharp> (?vs,m,n,sm,sm',sn,sn')"
       "atom m \<sharp> (?vs,n,sm,sm',sn,sn')" "atom n \<sharp> (?vs,sm,sm',sn,sn')"
       "atom sm \<sharp> (?vs,sm',sn,sn')" "atom sm' \<sharp> (?vs,sn,sn')"
       "atom sn \<sharp> (?vs,sn')" "atom sn' \<sharp> ?vs"
     by (metis obtain_fresh)
   thus ?thesis
     using sk
     apply (auto simp: SeqSubstFormP.simps [of l "Var s" _ _ _ sl sl' m n sm sm' sn sn'])
     apply (rule Ex_I [where x = "Eats Zero (HPair Zero (HPair (Q_Eq x y) (Q_Eq x' y')))"], simp)
     apply (rule Ex_I [where x = Zero], auto intro!: Mem_SUCC_EH)
     apply (rule Ex_I [where x = "Q_Eq x y"], simp)
     apply (rule Ex_I [where x = "Q_Eq x' y'"], auto)
      apply (metis Mem_Eats_I2 Assume HPair_cong Refl)
     apply (blast intro: SubstAtomicP_Eq [THEN cut2] Disj_I1)
     done
 qed
 
 lemma SubstFormP_Eq:
   "{SubstTermP v i x x', SubstTermP v i y y'} \<turnstile> SubstFormP v i (Q_Eq x y) (Q_Eq x' y')"
 proof -
   obtain k1::name and s1::name and k2::name and s2::name and k::name and s::name
     where "atom s1 \<sharp> (v,i,x,y,x',y')" "atom k1 \<sharp> (v,i,x,y,x',y',s1)"
       "atom s2 \<sharp> (v,i,x,y,x',y',k1,s1)" "atom k2 \<sharp> (v,i,x,y,x',y',s2,k1,s1)"
       "atom s  \<sharp> (v,i,x,y,x',y',k2,s2,k1,s1)" "atom k  \<sharp> (v,i,x,y,x',y',s,k2,s2,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: SubstFormP.simps [of s v i "(Q_Eq x y)" _ k]
         SubstFormP.simps [of s1 v i x x' k1]
         SubstFormP.simps [of s2 v i y y' k2]
         intro: SeqSubstFormP_Eq SubstTermP_imp_TermP SubstTermP_imp_VarP thin1)
 qed
 
 subsection \<open>Negation\<close>
 
 lemma SeqSubstFormP_Neg:
   assumes "atom s \<sharp> (k,s1,k1,x,x',v,i)" "atom k \<sharp> (s1,k1,x,x',v,i)"
   shows "{SeqSubstFormP v i x x' s1 k1, TermP i, VarP v}
            \<turnstile> Ex s (Ex k (SeqSubstFormP v i (Q_Neg x) (Q_Neg x') (Var s) (Var k)))" (*<*)
 proof -
   let ?vs = "(s1,k1,s,k,x,x',v,i)"
   obtain l::name and sl::name and sl'::name and m::name and n::name and
     sm::name and sm'::name and sn::name and sn'::name
     where atoms:
       "atom l \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn')"
       "atom sl \<sharp> (?vs,sl',m,n,sm,sm',sn,sn')" "atom sl' \<sharp> (?vs,m,n,sm,sm',sn,sn')"
       "atom m \<sharp> (?vs,n,sm,sm',sn,sn')" "atom n \<sharp> (?vs,sm,sm',sn,sn')"
       "atom sm \<sharp> (?vs,sm',sn,sn')" "atom sm' \<sharp> (?vs,sn,sn')"
       "atom sn \<sharp> (?vs,sn')" "atom sn' \<sharp> ?vs"
     by (metis obtain_fresh)
   let ?hyp = "{RestrictedP s1 (SUCC k1) (Var s), OrdP k1, SeqSubstFormP v i x x' s1 k1, TermP i, VarP v}"
   show ?thesis
     using assms atoms
     apply (auto simp: SeqSubstFormP.simps [of l "Var s" _ _ _ sl sl' m n sm sm' sn sn'])
     apply (rule cut_same [where A="OrdP k1"])
      apply (metis SeqSubstFormP_imp_OrdP thin2)
     apply (rule cut_same [OF exists_RestrictedP [of s s1 "SUCC k1"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
       apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC k1) (HPair (Q_Neg x) (Q_Neg x')))"])
       apply (simp_all (no_asm_simp))
     apply (rule Ex_I [where x="(SUCC k1)"])
     apply (simp add: flip_fresh_fresh)
     apply (rule Conj_I)
      apply (blast intro: RestrictedP_LstSeqP_Eats [THEN cut2] SeqSubstFormP_imp_LstSeqP [THEN cut1])
   proof (rule All2_SUCC_I, simp_all)
     show "?hyp \<turnstile> Ex sl (Ex sl'
               (HPair (SUCC k1) (HPair (Var sl) (Var sl')) IN Eats (Var s) (HPair (SUCC k1) (HPair (Q_Neg x) (Q_Neg x'))) AND
                (SubstAtomicP v i (Var sl) (Var sl') OR
                 Ex m (Ex n
                    (Ex sm (Ex sm'
                        (Ex sn (Ex sn'
                        (Var m IN SUCC k1 AND
                         Var n IN SUCC k1 AND
                         HPair (Var m) (HPair (Var sm) (Var sm')) IN Eats (Var s) (HPair (SUCC k1) (HPair (Q_Neg x) (Q_Neg x'))) AND
                         HPair (Var n) (HPair (Var sn) (Var sn')) IN Eats (Var s) (HPair (SUCC k1) (HPair (Q_Neg x) (Q_Neg x'))) AND
                         (Var sl EQ Q_Disj (Var sm) (Var sn) AND Var sl' EQ Q_Disj (Var sm') (Var sn') OR
                           Var sl EQ Q_Neg (Var sm) AND Var sl' EQ Q_Neg (Var sm') OR Var sl EQ Q_Ex (Var sm) AND Var sl' EQ Q_Ex (Var sm')))))))))))"
       \<comment> \<open>verifying the final values\<close>
       apply (rule Ex_I [where x="Q_Neg x"])
       using assms atoms apply simp
       apply (rule Ex_I [where x="Q_Neg x'"], simp)
       apply (rule Conj_I, metis Mem_Eats_I2 Refl)
       apply (rule Disj_I2)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule_tac x=x' in Ex_I, simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule_tac x=x' in Ex_I, simp)
       apply (rule Conj_I [OF Mem_SUCC_Refl])+
       apply (blast intro: Disj_I1 Disj_I2 Mem_Eats_I1 RestrictedP_Mem [THEN cut3] Mem_SUCC_Refl
           SeqSubstFormP_imp_LstSeqP [THEN cut1] LstSeqP_imp_Mem)
       done
   next
     show "?hyp \<turnstile> All2 l (SUCC k1)
                 (Ex sl (Ex sl'
                     (HPair (Var l) (HPair (Var sl) (Var sl')) IN Eats (Var s) (HPair (SUCC k1) (HPair (Q_Neg x) (Q_Neg x'))) AND
                      (SubstAtomicP v i (Var sl) (Var sl') OR
                       Ex m (Ex n
                          (Ex sm (Ex sm'
                              (Ex sn (Ex sn'
                                  (Var m IN Var l AND
                                   Var n IN Var l AND
                                   HPair (Var m) (HPair (Var sm) (Var sm')) IN Eats (Var s) (HPair (SUCC k1) (HPair (Q_Neg x) (Q_Neg x'))) AND
                                   HPair (Var n) (HPair (Var sn) (Var sn')) IN Eats (Var s) (HPair (SUCC k1) (HPair (Q_Neg x) (Q_Neg x'))) AND
                                   (Var sl EQ Q_Disj (Var sm) (Var sn) AND Var sl' EQ Q_Disj (Var sm') (Var sn') OR
                             Var sl EQ Q_Neg (Var sm) AND Var sl' EQ Q_Neg (Var sm') OR Var sl EQ Q_Ex (Var sm) AND Var sl' EQ Q_Ex (Var sm'))))))))))))"
       \<comment> \<open>verifying the sequence buildup\<close>
       apply (rule All_I Imp_I)+
       using assms atoms apply simp_all
         \<comment> \<open>... the sequence buildup via s1\<close>
       apply (simp add: SeqSubstFormP.simps [of l s1 _ _ _ sl sl' m n sm sm' sn sn'])
       apply (rule AssumeH Ex_EH Conj_EH)+
       apply (rule All2_E [THEN rotate2], auto del: Disj_EH)
       apply (rule Ex_I [where x="Var sl"], simp)
       apply (rule Ex_I [where x="Var sl'"], simp)
       apply (rule Conj_I)
        apply (blast intro: Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] del: Disj_EH)
       apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
                   apply (rule Ex_I [where x="Var m"], simp)
                   apply (rule Ex_I [where x="Var n"], simp)
                   apply (rule Ex_I [where x="Var sm"], simp)
                   apply (rule Ex_I [where x="Var sm'"], simp)
                   apply (rule Ex_I [where x="Var sn"], simp)
                   apply (rule Ex_I [where x="Var sn'"], auto del: Disj_EH)
        apply (blast intro: Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] OrdP_Trans [OF OrdP_SUCC_I])+
       done
   qed
 qed (*>*)
 
 theorem SubstFormP_Neg: "{SubstFormP v i x x'} \<turnstile> SubstFormP v i (Q_Neg x) (Q_Neg x')"
 proof -
   obtain k1::name and s1::name and k::name and s::name
     where "atom s1 \<sharp> (v,i,x,x')"        "atom k1 \<sharp> (v,i,x,x',s1)"
       "atom s  \<sharp> (v,i,x,x',k1,s1)"  "atom k  \<sharp> (v,i,x,x',s,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (force simp: SubstFormP.simps [of s v i "Q_Neg x" _ k] SubstFormP.simps [of s1 v i x x' k1]
         intro: SeqSubstFormP_Neg [THEN cut3])
 qed
 
 subsection \<open>Disjunction\<close>
 
 lemma SeqSubstFormP_Disj:
   assumes "atom s \<sharp> (k,s1,s2,k1,k2,x,y,x',y',v,i)" "atom k \<sharp> (s1,s2,k1,k2,x,y,x',y',v,i)"
   shows "{SeqSubstFormP v i x x' s1 k1,
             SeqSubstFormP v i y y' s2 k2, TermP i, VarP v}
            \<turnstile> Ex s (Ex k (SeqSubstFormP v i (Q_Disj x y) (Q_Disj x' y') (Var s) (Var k)))" (*<*)
 proof -
   let ?vs = "(s1,s2,s,k1,k2,k,x,y,x',y',v,i)"
   obtain km::name and kn::name and j::name and k'::name
     and l::name and sl::name and sl'::name and m::name and n::name
     and sm::name and sm'::name and sn::name and sn'::name
     where atoms2: "atom km \<sharp> (kn,j,k',l,s1,s2,s,k1,k2,k,x,y,x',y',v,i,sl,sl',m,n,sm,sm',sn,sn')"
       "atom kn \<sharp> (j,k',l,s1,s2,s,k1,k2,k,x,y,x',y',v,i,sl,sl',m,n,sm,sm',sn,sn')"
       "atom j \<sharp> (k',l,s1,s2,s,k1,k2,k,x,y,x',y',v,i,sl,sl',m,n,sm,sm',sn,sn')"
       and atoms: "atom k' \<sharp> (l,s1,s2,s,k1,k2,k,x,y,x',y',v,i,sl,sl',m,n,sm,sm',sn,sn')"
       "atom l \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,sl,sl',m,n,sm,sm',sn,sn')"
       "atom sl \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,sl',m,n,sm,sm',sn,sn')"
       "atom sl' \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,m,n,sm,sm',sn,sn')"
       "atom m \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,n,sm,sm',sn,sn')"
       "atom n \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,sm,sm',sn,sn')"
       "atom sm \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,sm',sn,sn')"
       "atom sm' \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,sn,sn')"
       "atom sn \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,sn')"
       "atom sn' \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i)"
     by (metis obtain_fresh)
   let ?hyp = "{HaddP k1 k2 (Var k'), OrdP k1, OrdP k2, SeqAppendP s1 (SUCC k1) s2 (SUCC k2) (Var s),
                SeqSubstFormP v i x x' s1 k1, SeqSubstFormP v i y y' s2 k2, TermP i, VarP v}"
   show ?thesis
     using assms atoms
     apply (auto simp: SeqSubstFormP.simps [of l "Var s" _ _ _ sl sl' m n sm sm' sn sn'])
     apply (rule cut_same [where A="OrdP k1 AND OrdP k2"])
      apply (metis Conj_I SeqSubstFormP_imp_OrdP thin1 thin2)
     apply (rule cut_same [OF exists_SeqAppendP [of s s1 "SUCC k1" s2 "SUCC k2"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
       apply (rule cut_same [OF exists_HaddP [where j=k' and x=k1 and y=k2]])
         apply (rule AssumeH Ex_EH Conj_EH | simp)+
         apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC(SUCC(Var k'))) (HPair(Q_Disj x y)(Q_Disj x' y')))"])
         apply (simp_all (no_asm_simp))
     apply (rule Ex_I [where x="SUCC (SUCC (Var k'))"], simp)
     apply (rule Conj_I)
      apply (blast intro: LstSeqP_SeqAppendP_Eats SeqSubstFormP_imp_LstSeqP [THEN cut1])
   proof (rule All2_SUCC_I, simp_all)
     show "?hyp \<turnstile> Ex sl (Ex sl'
                  (HPair (SUCC (SUCC (Var k'))) (HPair (Var sl) (Var sl')) IN
                   Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Q_Disj x y) (Q_Disj x' y'))) AND
                   (SubstAtomicP v i (Var sl) (Var sl') OR
                    Ex m (Ex n (Ex sm (Ex sm' (Ex sn (Ex sn'
                       (Var m IN SUCC (SUCC (Var k')) AND
                        Var n IN SUCC (SUCC (Var k')) AND
                        HPair (Var m) (HPair (Var sm) (Var sm')) IN
                        Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Q_Disj x y) (Q_Disj x' y'))) AND
                        HPair (Var n) (HPair (Var sn) (Var sn')) IN
                        Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Q_Disj x y) (Q_Disj x' y'))) AND
                        (Var sl EQ Q_Disj (Var sm) (Var sn) AND Var sl' EQ Q_Disj (Var sm') (Var sn') OR
                           Var sl EQ Q_Neg (Var sm) AND Var sl' EQ Q_Neg (Var sm') OR Var sl EQ Q_Ex (Var sm) AND Var sl' EQ Q_Ex (Var sm')))))))))))"
       \<comment> \<open>verifying the final values\<close>
       apply (rule Ex_I [where x="Q_Disj x y"])
       using assms atoms apply simp
       apply (rule Ex_I [where x="Q_Disj x' y'"], simp)
       apply (rule Conj_I, metis Mem_Eats_I2 Refl)
       apply (rule Disj_I2)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x="SUCC (Var k')"], simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule_tac x=x' in Ex_I, simp)
       apply (rule Ex_I [where x=y], simp)
       apply (rule_tac x=y' in Ex_I, simp)
       apply (rule Conj_I)
        apply (blast intro: HaddP_Mem_I LstSeqP_OrdP Mem_SUCC_I1)
       apply (rule Conj_I [OF Mem_SUCC_Refl])
       apply (blast intro: Disj_I1 Mem_Eats_I1 Mem_SUCC_Refl SeqSubstFormP_imp_LstSeqP [THEN cut1]
           LstSeqP_imp_Mem SeqAppendP_Mem1 [THEN cut3] SeqAppendP_Mem2 [THEN cut4] HaddP_SUCC1 [THEN cut1])
       done
   next
     show "?hyp \<turnstile>  All2 l (SUCC (SUCC (Var k')))
      (Ex sl
        (Ex sl'
          (HPair (Var l) (HPair (Var sl) (Var sl')) IN
           Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Q_Disj x y) (Q_Disj x' y'))) AND
           (SubstAtomicP v i (Var sl) (Var sl') OR
            Ex m (Ex n
               (Ex sm (Ex sm'
                   (Ex sn (Ex sn'
                       (Var m IN Var l AND
                        Var n IN Var l AND
                        HPair (Var m) (HPair (Var sm) (Var sm')) IN
                        Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Q_Disj x y) (Q_Disj x' y'))) AND
                        HPair (Var n) (HPair (Var sn) (Var sn')) IN
                        Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Q_Disj x y) (Q_Disj x' y'))) AND
                        (Var sl EQ Q_Disj (Var sm) (Var sn) AND Var sl' EQ Q_Disj (Var sm') (Var sn') OR
                             Var sl EQ Q_Neg (Var sm) AND Var sl' EQ Q_Neg (Var sm') OR Var sl EQ Q_Ex (Var sm) AND Var sl' EQ Q_Ex (Var sm'))))))))))))"
       \<comment> \<open>verifying the sequence buildup\<close>
       apply (rule cut_same [where A="HaddP (SUCC k1) (SUCC k2) (SUCC (SUCC (Var k')))"])
        apply (blast intro: HaddP_SUCC1 [THEN cut1] HaddP_SUCC2 [THEN cut1])
       apply (rule All_I Imp_I)+
        apply (rule HaddP_Mem_cases [where i=j])
       using assms atoms atoms2 apply simp_all
           apply (rule AssumeH)
          apply (blast intro: OrdP_SUCC_I LstSeqP_OrdP)
         \<comment> \<open>... the sequence buildup via s1\<close>
         apply (simp add: SeqSubstFormP.simps [of l s1 _ _ _ sl sl' m n sm sm' sn sn'])
         apply (rule AssumeH Ex_EH Conj_EH)+
         apply (rule All2_E [THEN rotate2])
           apply (simp | rule AssumeH Ex_EH Conj_EH)+
             apply (rule Ex_I [where x="Var sl"], simp)
             apply (rule Ex_I [where x="Var sl'"], simp)
             apply (rule Conj_I [OF Mem_Eats_I1])
              apply (metis SeqAppendP_Mem1 rotate3 thin2 thin4)
             apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
                         apply (rule Ex_I [where x="Var m"], simp)
                         apply (rule Ex_I [where x="Var n"], simp)
                         apply (rule Ex_I [where x="Var sm"], simp)
                         apply (rule Ex_I [where x="Var sm'"], simp)
                         apply (rule Ex_I [where x="Var sn"], simp)
                         apply (rule Ex_I [where x="Var sn'"], simp_all (no_asm_simp))
        apply (rule Conj_I, rule AssumeH)+
        apply (rule Conj_I)
         apply (blast intro: OrdP_Trans [OF OrdP_SUCC_I] Mem_Eats_I1 [OF SeqAppendP_Mem1 [THEN cut3]] Hyp)
        apply (blast intro: Disj_I1 Disj_I2 OrdP_Trans [OF OrdP_SUCC_I] Mem_Eats_I1 [OF SeqAppendP_Mem1 [THEN cut3]] Hyp)
         \<comment> \<open>... the sequence buildup via s2\<close>
       apply (simp add: SeqSubstFormP.simps [of l s2 _ _ _ sl sl' m n sm sm' sn sn'])
       apply (rule AssumeH Ex_EH Conj_EH)+
       apply (rule All2_E [THEN rotate2])
         apply (simp | rule AssumeH Ex_EH Conj_EH)+
           apply (rule Ex_I [where x="Var sl"], simp)
           apply (rule Ex_I [where x="Var sl'"], simp)
           apply (rule cut_same [where A="OrdP (Var j)"])
            apply (metis HaddP_imp_OrdP rotate2 thin2)
           apply (rule Conj_I)
            apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] del: Disj_EH)
           apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
                       apply (rule cut_same [OF exists_HaddP [where j=km and x="SUCC k1" and y="Var m"]])
                         apply (blast intro: Ord_IN_Ord, simp)
                       apply (rule cut_same [OF exists_HaddP [where j=kn and x="SUCC k1" and y="Var n"]])
                         apply (metis AssumeH(6) Ord_IN_Ord0 rotate8, simp)
                       apply (rule AssumeH Ex_EH Conj_EH | simp)+
                           apply (rule Ex_I [where x="Var km"], simp)
                           apply (rule Ex_I [where x="Var kn"], simp)
                           apply (rule Ex_I [where x="Var sm"], simp)
                           apply (rule Ex_I [where x="Var sm'"], simp)
                           apply (rule Ex_I [where x="Var sn"], simp)
                           apply (rule Ex_I [where x="Var sn'"], simp_all (no_asm_simp))
       apply (rule Conj_I [OF _ Conj_I])
         apply (blast intro!: HaddP_Mem_cancel_left [THEN Iff_MP2_same] OrdP_SUCC_I intro: LstSeqP_OrdP Hyp)+
       apply (blast del: Disj_EH  intro: OrdP_Trans Hyp
           intro!: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] HaddP_imp_OrdP [THEN cut1])
       done
   qed
 qed (*>*)
 
 theorem SubstFormP_Disj:
   "{SubstFormP v i x x', SubstFormP v i y y'} \<turnstile> SubstFormP v i (Q_Disj x y) (Q_Disj x' y')"
 proof -
   obtain k1::name and s1::name and k2::name and s2::name and k::name and s::name
     where "atom s1 \<sharp> (v,i,x,y,x',y')"        "atom k1 \<sharp> (v,i,x,y,x',y',s1)"
       "atom s2 \<sharp> (v,i,x,y,x',y',k1,s1)"  "atom k2 \<sharp> (v,i,x,y,x',y',s2,k1,s1)"
       "atom s  \<sharp> (v,i,x,y,x',y',k2,s2,k1,s1)" "atom k  \<sharp> (v,i,x,y,x',y',s,k2,s2,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (force simp: SubstFormP.simps [of s v i "Q_Disj x y" _ k]
         SubstFormP.simps [of s1 v i x x' k1]
         SubstFormP.simps [of s2 v i y y' k2]
         intro: SeqSubstFormP_Disj [THEN cut4])
 qed
 
 subsection \<open>Existential\<close>
 
 lemma SeqSubstFormP_Ex:
   assumes "atom s \<sharp> (k,s1,k1,x,x',v,i)" "atom k \<sharp> (s1,k1,x,x',v,i)"
   shows "{SeqSubstFormP v i x x' s1 k1, TermP i, VarP v}
            \<turnstile> Ex s (Ex k (SeqSubstFormP v i (Q_Ex x) (Q_Ex x') (Var s) (Var k)))" (*<*)
 proof -
   obtain l::name and sl::name and sl'::name and m::name and n::name
     and sm::name and sm'::name and sn::name and sn'::name
     where atoms:
       "atom l \<sharp> (s1,k1,s,k,x,x',v,i,sl,sl',m,n,sm,sm',sn,sn')"
       "atom sl \<sharp> (s1,k1,s,k,x,x',v,i,sl',m,n,sm,sm',sn,sn')"
       "atom sl' \<sharp> (s1,k1,s,k,x,x',v,i,m,n,sm,sm',sn,sn')"
       "atom m \<sharp> (s1,k1,s,k,x,x',v,i,n,sm,sm',sn,sn')"
       "atom n \<sharp> (s1,k1,s,k,x,x',v,i,sm,sm',sn,sn')"
       "atom sm \<sharp> (s1,k1,s,k,x,x',v,i,sm',sn,sn')"
       "atom sm' \<sharp> (s1,k1,s,k,x,x',v,i,sn,sn')"
       "atom sn \<sharp> (s1,k1,s,k,x,x',v,i,sn')"
       "atom sn' \<sharp> (s1,k1,s,k,x,x',v,i)"
     by (metis obtain_fresh)
   let ?hyp = "{RestrictedP s1 (SUCC k1) (Var s), OrdP k1, SeqSubstFormP v i x x' s1 k1, TermP i, VarP v}"
   show ?thesis
     using assms atoms
     apply (auto simp: SeqSubstFormP.simps [of l "Var s" _ _ _ sl sl' m n sm sm' sn sn'])
     apply (rule cut_same [where A="OrdP k1"])
      apply (metis SeqSubstFormP_imp_OrdP thin2)
     apply (rule cut_same [OF exists_RestrictedP [of s s1 "SUCC k1"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
       apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC k1) (HPair (Q_Ex x) (Q_Ex x')))"], simp)
       apply (rule Ex_I [where x="(SUCC k1)"], simp)
       apply (rule Conj_I)
        apply (blast intro: RestrictedP_LstSeqP_Eats [THEN cut2] SeqSubstFormP_imp_LstSeqP [THEN cut1])
   proof (rule All2_SUCC_I, simp_all)
     show "?hyp \<turnstile> Ex sl (Ex sl'
           (HPair (SUCC k1) (HPair (Var sl) (Var sl')) IN Eats (Var s) (HPair (SUCC k1) (HPair (Q_Ex x) (Q_Ex x'))) AND
            (SubstAtomicP v i (Var sl) (Var sl') OR
             Ex m (Ex n
                (Ex sm (Ex sm'
                    (Ex sn (Ex sn'
                        (Var m IN SUCC k1 AND
                         Var n IN SUCC k1 AND
                         HPair (Var m) (HPair (Var sm) (Var sm')) IN Eats (Var s) (HPair (SUCC k1) (HPair (Q_Ex x) (Q_Ex x'))) AND
                         HPair (Var n) (HPair (Var sn) (Var sn')) IN Eats (Var s) (HPair (SUCC k1) (HPair (Q_Ex x) (Q_Ex x'))) AND
                         (Var sl EQ Q_Disj (Var sm) (Var sn) AND Var sl' EQ Q_Disj (Var sm') (Var sn') OR
                           Var sl EQ Q_Neg (Var sm) AND Var sl' EQ Q_Neg (Var sm') OR Var sl EQ Q_Ex (Var sm) AND Var sl' EQ Q_Ex (Var sm')))))))))))"
       \<comment> \<open>verifying the final values\<close>
       apply (rule Ex_I [where x="Q_Ex x"])
       using assms atoms apply simp
       apply (rule Ex_I [where x="Q_Ex x'"], simp)
       apply (rule Conj_I, metis Mem_Eats_I2 Refl)
       apply (rule Disj_I2)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule_tac x=x' in Ex_I, simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule_tac x=x' in Ex_I, simp)
       apply (rule Conj_I [OF Mem_SUCC_Refl])+
       apply (blast intro: Disj_I2 Mem_Eats_I1 RestrictedP_Mem [THEN cut3] Mem_SUCC_Refl
           SeqSubstFormP_imp_LstSeqP [THEN cut1] LstSeqP_imp_Mem)
       done
   next
     show "?hyp
              \<turnstile> All2 l (SUCC k1)
                 (Ex sl (Ex sl'
                     (HPair (Var l) (HPair (Var sl) (Var sl')) IN Eats (Var s) (HPair (SUCC k1) (HPair (Q_Ex x) (Q_Ex x'))) AND
                      (SubstAtomicP v i (Var sl) (Var sl') OR
                       Ex m (Ex n
                          (Ex sm (Ex sm'
                              (Ex sn (Ex sn'
                                  (Var m IN Var l AND
                                   Var n IN Var l AND
                                   HPair (Var m) (HPair (Var sm) (Var sm')) IN Eats (Var s) (HPair (SUCC k1) (HPair (Q_Ex x) (Q_Ex x'))) AND
                                   HPair (Var n) (HPair (Var sn) (Var sn')) IN Eats (Var s) (HPair (SUCC k1) (HPair (Q_Ex x) (Q_Ex x'))) AND
                                   (Var sl EQ Q_Disj (Var sm) (Var sn) AND Var sl' EQ Q_Disj (Var sm') (Var sn') OR
                             Var sl EQ Q_Neg (Var sm) AND Var sl' EQ Q_Neg (Var sm') OR Var sl EQ Q_Ex (Var sm) AND Var sl' EQ Q_Ex (Var sm'))))))))))))"
       \<comment> \<open>verifying the sequence buildup\<close>
       using assms atoms
         \<comment> \<open>... the sequence buildup via s1\<close>
       apply (auto simp add: SeqSubstFormP.simps [of l s1 _ _ _ sl sl' m n sm sm' sn sn'])
       apply (rule Swap)
       apply (rule All2_E, auto del: Disj_EH)
       apply (rule Ex_I [where x="Var sl"], simp)
       apply (rule Ex_I [where x="Var sl'"], simp)
       apply (rule Conj_I)
        apply (blast intro: Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] del: Disj_EH)
       apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
                   apply (rule Ex_I [where x="Var m"], simp)
                   apply (rule Ex_I [where x="Var n"], simp)
                   apply (rule Ex_I [where x="Var sm"], simp)
                   apply (rule Ex_I [where x="Var sm'"], simp)
                   apply (rule Ex_I [where x="Var sn"], simp)
                   apply (rule Ex_I [where x="Var sn'"])
                   apply (auto intro: Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] OrdP_Trans [OF OrdP_SUCC_I] del: Disj_EH)
       done
   qed
 qed (*>*)
 
 theorem SubstFormP_Ex: "{SubstFormP v i x x'} \<turnstile> SubstFormP v i (Q_Ex x) (Q_Ex x')"
 proof -
   obtain k1::name and s1::name and k::name and s::name
     where "atom s1 \<sharp> (v,i,x,x')"        "atom k1 \<sharp> (v,i,x,x',s1)"
       "atom s  \<sharp> (v,i,x,x',k1,s1)"  "atom k  \<sharp> (v,i,x,x',s,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (force simp: SubstFormP.simps [of s v i "Q_Ex x" _ k] SubstFormP.simps [of s1 v i x x' k1]
         intro: SeqSubstFormP_Ex [THEN cut3])
 qed
 
 
 section \<open>Constant Terms\<close>
 
 lemma ConstP_Zero: "{} \<turnstile> ConstP Zero"
 proof -
   obtain s::name and k::name and l::name and sl::name and m::name and n::name and sm::name and sn::name
     where atoms:
       "atom s \<sharp> (k,l,sl,m,n,sm,sn)"
       "atom k \<sharp> (l,sl,m,n,sm,sn)"
       "atom l \<sharp> (sl,m,n,sm,sn)"
       "atom sl \<sharp> (m,n,sm,sn)"
       "atom m \<sharp> (n,sm,sn)"
       "atom n \<sharp> (sm,sn)"
       "atom sm \<sharp> sn"
     by (metis obtain_fresh)
   then show ?thesis
     apply (subst CTermP.simps[of k s]; auto?)
     apply (rule Ex_I[of _ _ _ "Eats Zero (HPair Zero Zero)"]; auto?)
     apply (rule Ex_I[of _ _ _ "Zero"]; auto?)
     apply (subst SeqCTermP.simps[of l _ _ sl m n sm sn]; auto?)
     apply (rule Ex_I[of _ _ _ "Zero"]; auto?)
      apply (rule Mem_SUCC_E[OF Mem_Zero_E])
      apply (rule Mem_Eats_I2)
      apply (rule HPair_cong[OF Assume Refl])
     apply (rule Disj_I1[OF Refl])
     done
 qed
 
 lemma SeqConstP_Eats:
   assumes "atom s \<sharp> (k,s1,s2,k1,k2,t1,t2)" "atom k \<sharp> (s1,s2,k1,k2,t1,t2)"
     shows "{SeqConstP s1 k1 t1, SeqConstP s2 k2 t2}
            \<turnstile> Ex s (Ex k (SeqConstP (Var s) (Var k) (Q_Eats t1 t2)))" (*<*)
 proof -
   obtain km::name and kn::name and j::name and k'::name
      and l::name and sl::name and m::name and n::name and sm::name and sn::name
     where atoms:
          "atom km \<sharp> (kn,j,k',l,s1,s2,s,k1,k2,k,t1,t2,sl,m,n,sm,sn)"
          "atom kn \<sharp> (j,k',l,s1,s2,s,k1,k2,k,t1,t2,sl,m,n,sm,sn)"
          "atom j \<sharp> (k',l,s1,s2,s,k1,k2,k,t1,t2,sl,m,n,sm,sn)"
          "atom k' \<sharp> (l,s1,s2,s,k1,k2,k,t1,t2,sl,m,n,sm,sn)"
          "atom l \<sharp> (s1,s2,s,k1,k2,k,t1,t2,sl,m,n,sm,sn)"
          "atom sl \<sharp> (s1,s2,s,k1,k2,k,t1,t2,m,n,sm,sn)"
          "atom m \<sharp> (s1,s2,s,k1,k2,k,t1,t2,n,sm,sn)"
          "atom n \<sharp> (s1,s2,s,k1,k2,k,t1,t2,sm,sn)"
          "atom sm \<sharp> (s1,s2,s,k1,k2,k,t1,t2,sn)"
          "atom sn \<sharp> (s1,s2,s,k1,k2,k,t1,t2)"
     by (metis obtain_fresh)
   let ?hyp = "{HaddP k1 k2 (Var k'), OrdP k1, OrdP k2, SeqAppendP s1 (SUCC k1) s2 (SUCC k2) (Var s),
               SeqConstP s1 k1 t1, SeqConstP s2 k2 t2}"
   show ?thesis
      using assms atoms
      apply (auto simp: SeqCTermP.simps [of l "Var s" _ sl m n sm sn])
      apply (rule cut_same [where A="OrdP k1 AND OrdP k2"])
      apply (metis Conj_I SeqCTermP_imp_OrdP thin1 thin2)
      apply (rule cut_same [OF exists_SeqAppendP [of s s1 "SUCC k1" s2 "SUCC k2"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule cut_same [OF exists_HaddP [where j=k' and x=k1 and y=k2]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (Q_Eats t1 t2))"], simp)
      apply (rule Ex_I [where x="SUCC (SUCC (Var k'))"], simp)
      apply (rule Conj_I)
      apply (blast intro: LstSeqP_SeqAppendP_Eats SeqCTermP_imp_LstSeqP [THEN cut1])
      proof (rule All2_SUCC_I, simp_all)
        show "?hyp \<turnstile> Ex sl (HPair (SUCC (SUCC (Var k'))) (Var sl) IN Eats (Var s)
                           (HPair (SUCC (SUCC (Var k'))) (Q_Eats t1 t2))   AND
                 (Var sl EQ Zero OR Fls OR
                  Ex m (Ex n(Ex sm (Ex sn
                       (Var m IN SUCC (SUCC (Var k')) AND
                        Var n IN SUCC (SUCC (Var k')) AND
                        HPair (Var m) (Var sm) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (Q_Eats t1 t2)) AND
                        HPair (Var n) (Var sn) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (Q_Eats t1 t2)) AND
                        Var sl EQ Q_Eats (Var sm) (Var sn)))))))"
        \<comment> \<open>verifying the final values\<close>
        apply (rule Ex_I [where x="Q_Eats t1 t2"])
        using assms atoms apply simp
        apply (rule Conj_I, metis Mem_Eats_I2 Refl)
        apply (rule Disj_I2)+
        apply (rule Ex_I [where x=k1], simp)
        apply (rule Ex_I [where x="SUCC (Var k')"], simp)
        apply (rule Ex_I [where x=t1], simp)
        apply (rule Ex_I [where x=t2], simp)
        apply (rule Conj_I)
        apply (blast intro: HaddP_Mem_I LstSeqP_OrdP Mem_SUCC_I1)
        apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem1 [THEN cut3] SeqAppendP_Mem2 [THEN cut4]
                  Mem_SUCC_Refl SeqCTermP_imp_LstSeqP [THEN cut1] LstSeqP_imp_Mem HaddP_SUCC1 [THEN cut1])
        done
      next
        show "?hyp \<turnstile> All2 l (SUCC (SUCC (Var k')))
                  (Ex sl
                    (HPair (Var l) (Var sl) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (Q_Eats t1 t2)) AND
                     (Var sl EQ Zero OR Fls OR
                      Ex m (Ex n (Ex sm (Ex sn
                           (Var m IN Var l AND
                            Var n IN Var l AND
                            HPair (Var m) (Var sm) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (Q_Eats t1 t2)) AND
                            HPair (Var n) (Var sn) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (Q_Eats t1 t2)) AND
                            Var sl EQ Q_Eats (Var sm) (Var sn))))))))"
      \<comment> \<open>verifying the sequence buildup\<close>
      apply (rule cut_same [where A="HaddP (SUCC k1) (SUCC k2) (SUCC (SUCC (Var k')))"])
      apply (blast intro: HaddP_SUCC1 [THEN cut1] HaddP_SUCC2 [THEN cut1])
      apply (rule All_I Imp_I)+
      apply (rule HaddP_Mem_cases [where i=j])
      using assms atoms apply simp_all
      apply (rule AssumeH)
      apply (blast intro: OrdP_SUCC_I LstSeqP_OrdP)
      \<comment> \<open>... the sequence buildup via s1\<close>
      apply (simp add: SeqCTermP.simps [of l s1 _ sl m n sm sn])
      apply (rule AssumeH Ex_EH Conj_EH)+
      apply (rule All2_E [THEN rotate2], auto del: Disj_EH)
      apply (rule Ex_I [where x="Var sl"], simp)
      apply (rule Conj_I)
      apply (rule Mem_Eats_I1)
      apply (metis SeqAppendP_Mem1 rotate3 thin2 thin4)
      apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
      apply simp_all
      apply (rule Ex_I [where x="Var m"], simp)
      apply (rule Ex_I [where x="Var n"], simp)
      apply (rule Ex_I [where x="Var sm"], simp)
      apply (rule Ex_I [where x="Var sn"], simp)
      apply (rule Conj_I, rule AssumeH)+
      apply (blast del: Disj_EH intro: OrdP_Trans [OF OrdP_SUCC_I] Mem_Eats_I1 [OF SeqAppendP_Mem1 [THEN cut3]] Hyp)
      \<comment> \<open>... the sequence buildup via s2\<close>
      apply (simp add: SeqCTermP.simps [of l s2 _ sl m n sm sn])
      apply (rule AssumeH Ex_EH Conj_EH)+
      apply (rule All2_E [THEN rotate2], auto del: Disj_EH)
      apply (rule Ex_I [where x="Var sl"], simp)
      apply (rule cut_same [where A="OrdP (Var j)"])
      apply (metis HaddP_imp_OrdP rotate2 thin2)
      apply (rule Conj_I)
      apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] del: Disj_EH)
      apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
      apply (rule cut_same [OF exists_HaddP [where j=km and x="SUCC k1" and y="Var m"]])
      apply (blast intro: Ord_IN_Ord, simp)
      apply (rule cut_same [OF exists_HaddP [where j=kn and x="SUCC k1" and y="Var n"]])
      apply (metis AssumeH(6) Ord_IN_Ord0 rotate8, simp)
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule Ex_I [where x="Var km"], simp)
      apply (rule Ex_I [where x="Var kn"], simp)
      apply (rule Ex_I [where x="Var sm"], simp)
      apply (rule Ex_I [where x="Var sn"], simp_all)
      apply (rule Conj_I [OF _ Conj_I])
      apply (blast intro!: HaddP_Mem_cancel_left [THEN Iff_MP2_same] OrdP_SUCC_I intro: LstSeqP_OrdP Hyp)+
      apply (blast del: Disj_EH  intro: OrdP_Trans Hyp
                   intro!: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] HaddP_imp_OrdP [THEN cut1])
      done
    qed
  qed (*>*)
 
 theorem ConstP_Eats: "{ConstP t1, ConstP t2} \<turnstile> ConstP (Q_Eats t1 t2)"
 proof -
   obtain k1::name and s1::name and k2::name and s2::name and k::name and s::name
     where "atom s1 \<sharp> (t1,t2)" "atom k1 \<sharp> (t1,t2,s1)"
       "atom s2 \<sharp> (t1,t2,k1,s1)" "atom k2 \<sharp> (t1,t2,s2,k1,s1)"
       "atom s  \<sharp> (t1,t2,k2,s2,k1,s1)" "atom k  \<sharp> (t1,t2,s,k2,s2,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: CTermP.simps [of k s "(Q_Eats t1 t2)"]
         CTermP.simps [of k1 s1 t1]  CTermP.simps [of k2 s2 t2]
         intro!:  SeqConstP_Eats [THEN cut2])
 qed
 
 lemma TermP_Zero: "{} \<turnstile> TermP Zero"
 proof -
   obtain s::name and k::name and l::name and sl::name and m::name and n::name and sm::name and sn::name
     where atoms:
       "atom s \<sharp> (k,l,sl,m,n,sm,sn)"
       "atom k \<sharp> (l,sl,m,n,sm,sn)"
       "atom l \<sharp> (sl,m,n,sm,sn)"
       "atom sl \<sharp> (m,n,sm,sn)"
       "atom m \<sharp> (n,sm,sn)"
       "atom n \<sharp> (sm,sn)"
       "atom sm \<sharp> sn"
     by (metis obtain_fresh)
   then show ?thesis
     apply (subst CTermP.simps[of k s]; auto?)
     apply (rule Ex_I[of _ _ _ "Eats Zero (HPair Zero Zero)"]; auto?)
     apply (rule Ex_I[of _ _ _ "Zero"]; auto?)
     apply (subst SeqCTermP.simps[of l _ _ sl m n sm sn]; auto?)
     apply (rule Ex_I[of _ _ _ "Zero"]; auto?)
      apply (rule Mem_SUCC_E[OF Mem_Zero_E])
      apply (rule Mem_Eats_I2)
      apply (rule HPair_cong[OF Assume Refl])
     apply (rule Disj_I1[OF Refl])
     done
 qed
 
-lemma TermP_Var: "{} \<turnstile> TermP \<lceil>Var x\<rceil>"
+lemma TermP_Var: "{} \<turnstile> TermP \<guillemotleft>Var x\<guillemotright>"
 proof -
   obtain s::name and k::name and l::name and sl::name and m::name and n::name and sm::name and sn::name
     where atoms:
       "atom s \<sharp> (k,l,sl,m,n,sm,sn,x)"
       "atom k \<sharp> (l,sl,m,n,sm,sn,x)"
       "atom l \<sharp> (sl,m,n,sm,sn,x)"
       "atom sl \<sharp> (m,n,sm,sn,x)"
       "atom m \<sharp> (n,sm,sn,x)"
       "atom n \<sharp> (sm,sn,x)"
       "atom sm \<sharp> (sn,x)"
       "atom sn \<sharp> x"
     by (metis obtain_fresh)
   then show ?thesis
     apply (subst CTermP.simps[of k s]; auto?)
-    apply (rule Ex_I[of _ _ _ "Eats Zero (HPair Zero \<lceil>Var x\<rceil>)"]; auto?)
+    apply (rule Ex_I[of _ _ _ "Eats Zero (HPair Zero \<guillemotleft>Var x\<guillemotright>)"]; auto?)
     apply (rule Ex_I[of _ _ _ "Zero"]; auto?)
     apply (subst SeqCTermP.simps[of l _ _ sl m n sm sn]; auto?)
-    apply (rule Ex_I[of _ _ _ "\<lceil>Var x\<rceil>"]; auto?)
+    apply (rule Ex_I[of _ _ _ "\<guillemotleft>Var x\<guillemotright>"]; auto?)
      apply (rule Mem_SUCC_E[OF Mem_Zero_E])
      apply (rule Mem_Eats_I2)
      apply (rule HPair_cong[OF Assume Refl])
     apply (rule Disj_I2[OF Disj_I1])
     apply (auto simp: VarP_Var)
     done
 qed
 
 lemma SeqTermP_Eats:
   assumes "atom s \<sharp> (k,s1,s2,k1,k2,t1,t2)" "atom k \<sharp> (s1,s2,k1,k2,t1,t2)"
     shows "{SeqTermP s1 k1 t1, SeqTermP s2 k2 t2}
            \<turnstile> Ex s (Ex k (SeqTermP (Var s) (Var k) (Q_Eats t1 t2)))" (*<*)
 proof -
   obtain km::name and kn::name and j::name and k'::name
      and l::name and sl::name and m::name and n::name and sm::name and sn::name
     where atoms:
          "atom km \<sharp> (kn,j,k',l,s1,s2,s,k1,k2,k,t1,t2,sl,m,n,sm,sn)"
          "atom kn \<sharp> (j,k',l,s1,s2,s,k1,k2,k,t1,t2,sl,m,n,sm,sn)"
          "atom j \<sharp> (k',l,s1,s2,s,k1,k2,k,t1,t2,sl,m,n,sm,sn)"
          "atom k' \<sharp> (l,s1,s2,s,k1,k2,k,t1,t2,sl,m,n,sm,sn)"
          "atom l \<sharp> (s1,s2,s,k1,k2,k,t1,t2,sl,m,n,sm,sn)"
          "atom sl \<sharp> (s1,s2,s,k1,k2,k,t1,t2,m,n,sm,sn)"
          "atom m \<sharp> (s1,s2,s,k1,k2,k,t1,t2,n,sm,sn)"
          "atom n \<sharp> (s1,s2,s,k1,k2,k,t1,t2,sm,sn)"
          "atom sm \<sharp> (s1,s2,s,k1,k2,k,t1,t2,sn)"
          "atom sn \<sharp> (s1,s2,s,k1,k2,k,t1,t2)"
     by (metis obtain_fresh)
   let ?hyp = "{HaddP k1 k2 (Var k'), OrdP k1, OrdP k2, SeqAppendP s1 (SUCC k1) s2 (SUCC k2) (Var s),
               SeqTermP s1 k1 t1, SeqTermP s2 k2 t2}"
   show ?thesis
      using assms atoms
      apply (auto simp: SeqCTermP.simps [of l "Var s" _ sl m n sm sn])
      apply (rule cut_same [where A="OrdP k1 AND OrdP k2"])
      apply (metis Conj_I SeqCTermP_imp_OrdP thin1 thin2)
      apply (rule cut_same [OF exists_SeqAppendP [of s s1 "SUCC k1" s2 "SUCC k2"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule cut_same [OF exists_HaddP [where j=k' and x=k1 and y=k2]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (Q_Eats t1 t2))"], simp)
      apply (rule Ex_I [where x="SUCC (SUCC (Var k'))"], simp)
      apply (rule Conj_I)
      apply (blast intro: LstSeqP_SeqAppendP_Eats SeqCTermP_imp_LstSeqP [THEN cut1])
      proof (rule All2_SUCC_I, simp_all)
        show "?hyp \<turnstile> Ex sl (HPair (SUCC (SUCC (Var k'))) (Var sl) IN Eats (Var s)
                           (HPair (SUCC (SUCC (Var k'))) (Q_Eats t1 t2))   AND
                 (Var sl EQ Zero OR VarP (Var sl) OR
                  Ex m (Ex n(Ex sm (Ex sn
                       (Var m IN SUCC (SUCC (Var k')) AND
                        Var n IN SUCC (SUCC (Var k')) AND
                        HPair (Var m) (Var sm) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (Q_Eats t1 t2)) AND
                        HPair (Var n) (Var sn) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (Q_Eats t1 t2)) AND
                        Var sl EQ Q_Eats (Var sm) (Var sn)))))))"
        \<comment> \<open>verifying the final values\<close>
        apply (rule Ex_I [where x="Q_Eats t1 t2"])
        using assms atoms apply simp
        apply (rule Conj_I, metis Mem_Eats_I2 Refl)
        apply (rule Disj_I2)+
        apply (rule Ex_I [where x=k1], simp)
        apply (rule Ex_I [where x="SUCC (Var k')"], simp)
        apply (rule Ex_I [where x=t1], simp)
        apply (rule Ex_I [where x=t2], simp)
        apply (rule Conj_I)
        apply (blast intro: HaddP_Mem_I LstSeqP_OrdP Mem_SUCC_I1)
        apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem1 [THEN cut3] SeqAppendP_Mem2 [THEN cut4]
                  Mem_SUCC_Refl SeqCTermP_imp_LstSeqP [THEN cut1] LstSeqP_imp_Mem HaddP_SUCC1 [THEN cut1])
        done
      next
        show "?hyp \<turnstile> All2 l (SUCC (SUCC (Var k')))
                  (Ex sl
                    (HPair (Var l) (Var sl) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (Q_Eats t1 t2)) AND
                     (Var sl EQ Zero OR VarP (Var sl) OR
                      Ex m (Ex n (Ex sm (Ex sn
                           (Var m IN Var l AND
                            Var n IN Var l AND
                            HPair (Var m) (Var sm) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (Q_Eats t1 t2)) AND
                            HPair (Var n) (Var sn) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (Q_Eats t1 t2)) AND
                            Var sl EQ Q_Eats (Var sm) (Var sn))))))))"
      \<comment> \<open>verifying the sequence buildup\<close>
      apply (rule cut_same [where A="HaddP (SUCC k1) (SUCC k2) (SUCC (SUCC (Var k')))"])
      apply (blast intro: HaddP_SUCC1 [THEN cut1] HaddP_SUCC2 [THEN cut1])
      apply (rule All_I Imp_I)+
      apply (rule HaddP_Mem_cases [where i=j])
      using assms atoms apply simp_all
      apply (rule AssumeH)
      apply (blast intro: OrdP_SUCC_I LstSeqP_OrdP)
      \<comment> \<open>... the sequence buildup via s1\<close>
      apply (simp add: SeqCTermP.simps [of l s1 _ sl m n sm sn])
      apply (rule AssumeH Ex_EH Conj_EH)+
      apply (rule All2_E [THEN rotate2], auto del: Disj_EH)
      apply (rule Ex_I [where x="Var sl"], simp)
      apply (rule Conj_I)
      apply (rule Mem_Eats_I1)
      apply (metis SeqAppendP_Mem1 rotate3 thin2 thin4)
      apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
      apply simp_all
      apply (rule Ex_I [where x="Var m"], simp)
      apply (rule Ex_I [where x="Var n"], simp)
      apply (rule Ex_I [where x="Var sm"], simp)
      apply (rule Ex_I [where x="Var sn"], simp)
      apply (rule Conj_I, rule AssumeH)+
      apply (blast del: Disj_EH intro: OrdP_Trans [OF OrdP_SUCC_I] Mem_Eats_I1 [OF SeqAppendP_Mem1 [THEN cut3]] Hyp)
      \<comment> \<open>... the sequence buildup via s2\<close>
      apply (simp add: SeqCTermP.simps [of l s2 _ sl m n sm sn])
      apply (rule AssumeH Ex_EH Conj_EH)+
      apply (rule All2_E [THEN rotate2], auto del: Disj_EH)
      apply (rule Ex_I [where x="Var sl"], simp)
      apply (rule cut_same [where A="OrdP (Var j)"])
      apply (metis HaddP_imp_OrdP rotate2 thin2)
      apply (rule Conj_I)
      apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] del: Disj_EH)
      apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
      apply (rule cut_same [OF exists_HaddP [where j=km and x="SUCC k1" and y="Var m"]])
      apply (blast intro: Ord_IN_Ord, simp)
      apply (rule cut_same [OF exists_HaddP [where j=kn and x="SUCC k1" and y="Var n"]])
      apply (metis AssumeH(6) Ord_IN_Ord0 rotate8, simp)
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule Ex_I [where x="Var km"], simp)
      apply (rule Ex_I [where x="Var kn"], simp)
      apply (rule Ex_I [where x="Var sm"], simp)
      apply (rule Ex_I [where x="Var sn"], simp_all)
      apply (rule Conj_I [OF _ Conj_I])
      apply (blast intro!: HaddP_Mem_cancel_left [THEN Iff_MP2_same] OrdP_SUCC_I intro: LstSeqP_OrdP Hyp)+
      apply (blast del: Disj_EH  intro: OrdP_Trans Hyp
                   intro!: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] HaddP_imp_OrdP [THEN cut1])
      done
    qed
 qed (*>*)
 
 theorem TermP_Eats: "{TermP t1, TermP t2} \<turnstile> TermP (Q_Eats t1 t2)"
 proof -
   obtain k1::name and s1::name and k2::name and s2::name and k::name and s::name
     where "atom s1 \<sharp> (t1,t2)" "atom k1 \<sharp> (t1,t2,s1)"
       "atom s2 \<sharp> (t1,t2,k1,s1)" "atom k2 \<sharp> (t1,t2,s2,k1,s1)"
       "atom s  \<sharp> (t1,t2,k2,s2,k1,s1)" "atom k  \<sharp> (t1,t2,s,k2,s2,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: CTermP.simps [of k s "(Q_Eats t1 t2)"]
         CTermP.simps [of k1 s1 t1]  CTermP.simps [of k2 s2 t2]
         intro!:  SeqTermP_Eats [THEN cut2])
 qed
 
 
 section \<open>Proofs\<close>
 
 lemma PrfP_inference:
   assumes "atom s \<sharp> (k,s1,s2,k1,k2,\<alpha>1,\<alpha>2,\<beta>)" "atom k \<sharp> (s1,s2,k1,k2,\<alpha>1,\<alpha>2,\<beta>)"
     shows "{PrfP s1 k1 \<alpha>1, PrfP s2 k2 \<alpha>2, ModPonP \<alpha>1 \<alpha>2 \<beta> OR ExistsP \<alpha>1 \<beta> OR SubstP \<alpha>1 \<beta>}
            \<turnstile> Ex k (Ex s (PrfP (Var s) (Var k) \<beta>))" (*<*)
 proof -
   obtain km::name and kn::name and j::name and k'::name
      and l::name and sl::name and m::name and n::name and sm::name and sn::name
     where atoms:
          "atom km \<sharp> (kn,j,k',l,s1,s2,s,k1,k2,k,\<alpha>1,\<alpha>2,\<beta>,sl,m,n,sm,sn)"
          "atom kn \<sharp> (j,k',l,s1,s2,s,k1,k2,k,\<alpha>1,\<alpha>2,\<beta>,sl,m,n,sm,sn)"
          "atom j \<sharp> (k',l,s1,s2,s,k1,k2,k,\<alpha>1,\<alpha>2,\<beta>,sl,m,n,sm,sn)"
          "atom k' \<sharp> (l,s1,s2,s,k1,k2,k,\<alpha>1,\<alpha>2,\<beta>,sl,m,n,sm,sn)"
          "atom l \<sharp> (s1,s2,s,k1,k2,k,\<alpha>1,\<alpha>2,\<beta>,sl,m,n,sm,sn)"
          "atom sl \<sharp> (s1,s2,s,k1,k2,k,\<alpha>1,\<alpha>2,\<beta>,m,n,sm,sn)"
          "atom m \<sharp> (s1,s2,s,k1,k2,k,\<alpha>1,\<alpha>2,\<beta>,n,sm,sn)"
          "atom n \<sharp> (s1,s2,s,k1,k2,k,\<alpha>1,\<alpha>2,\<beta>,sm,sn)"
          "atom sm \<sharp> (s1,s2,s,k1,k2,k,\<alpha>1,\<alpha>2,\<beta>,sn)"
          "atom sn \<sharp> (s1,s2,s,k1,k2,k,\<alpha>1,\<alpha>2,\<beta>)"
     by (metis obtain_fresh)
   let ?hyp = "{HaddP k1 k2 (Var k'), OrdP k1, OrdP k2, SeqAppendP s1 (SUCC k1) s2 (SUCC k2) (Var s),
               PrfP s1 k1 \<alpha>1, PrfP s2 k2 \<alpha>2, ModPonP \<alpha>1 \<alpha>2 \<beta> OR ExistsP \<alpha>1 \<beta> OR SubstP \<alpha>1 \<beta>}"
   show ?thesis
      using assms atoms
      apply (simp add: PrfP.simps [of l "Var s" sl m n sm sn])
      apply (rule cut_same [where A="OrdP k1 AND OrdP k2"])
      apply (metis Conj_I PrfP_imp_OrdP thin1 thin2)
      apply (rule cut_same [OF exists_SeqAppendP [of s s1 "SUCC k1" s2 "SUCC k2"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule cut_same [OF exists_HaddP [where j=k' and x=k1 and y=k2]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule Ex_I [where x="SUCC (SUCC (Var k'))"], simp)
      apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC (SUCC (Var k'))) \<beta>)"], simp)
      apply (rule Conj_I)
      apply (blast intro: LstSeqP_SeqAppendP_Eats PrfP_imp_LstSeqP [THEN cut1])
      proof (rule All2_SUCC_I, simp_all)
        show "?hyp \<turnstile> Ex sn
                  (HPair (SUCC (SUCC (Var k'))) (Var sn) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) \<beta>) AND
                   (AxiomP (Var sn) OR
                    Ex m (Ex l (Ex sm (Ex sl
                       (Var m IN SUCC (SUCC (Var k')) AND
                        Var l IN SUCC (SUCC (Var k')) AND
                        HPair (Var m) (Var sm) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) \<beta>) AND
                        HPair (Var l) (Var sl) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) \<beta>) AND
                        (ModPonP (Var sm) (Var sl) (Var sn) OR ExistsP (Var sm) (Var sn) OR SubstP (Var sm) (Var sn))))))))"
        \<comment> \<open>verifying the final values\<close>
        apply (rule Ex_I [where x="\<beta>"])
        using assms atoms apply simp
        apply (rule Conj_I, metis Mem_Eats_I2 Refl)
        apply (rule Disj_I2)
        apply (rule Ex_I [where x=k1], simp)
        apply (rule Ex_I [where x="SUCC (Var k')"], simp)
        apply (rule_tac x=\<alpha>1 in Ex_I, simp)
        apply (rule_tac x=\<alpha>2 in Ex_I, simp)
        apply (rule Conj_I)
        apply (blast intro: HaddP_Mem_I LstSeqP_OrdP Mem_SUCC_I1)
        apply (rule Conj_I [OF Mem_SUCC_Refl Conj_I])
        apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem1 [THEN cut3] Mem_SUCC_Refl PrfP_imp_LstSeqP [THEN cut1] LstSeqP_imp_Mem)
        apply (blast del: Disj_EH  intro: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] Mem_SUCC_Refl
                      PrfP_imp_LstSeqP [THEN cut1] HaddP_SUCC1 [THEN cut1] LstSeqP_imp_Mem)
        done
      next
        show "?hyp \<turnstile> All2 n (SUCC (SUCC (Var k')))
                (Ex sn
                  (HPair (Var n) (Var sn) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) \<beta>) AND
                   (AxiomP (Var sn) OR
                    Ex m (Ex l (Ex sm (Ex sl
                       (Var m IN Var n AND
                        Var l IN Var n AND
                        HPair (Var m) (Var sm) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) \<beta>) AND
                        HPair (Var l) (Var sl) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) \<beta>) AND
                        (ModPonP (Var sm) (Var sl) (Var sn) OR ExistsP (Var sm) (Var sn) OR SubstP (Var sm) (Var sn)))))))))"
      \<comment> \<open>verifying the sequence buildup\<close>
      apply (rule cut_same [where A="HaddP (SUCC k1) (SUCC k2) (SUCC (SUCC (Var k')))"])
      apply (blast intro: HaddP_SUCC1 [THEN cut1] HaddP_SUCC2 [THEN cut1])
      apply (rule All_I Imp_I)+
      apply (rule HaddP_Mem_cases [where i=j])
      using assms atoms apply simp_all
      apply (rule AssumeH)
      apply (blast intro: OrdP_SUCC_I LstSeqP_OrdP)
      \<comment> \<open>... the sequence buildup via s1\<close>
      apply (simp add: PrfP.simps [of l s1 sl m n sm sn])
      apply (rule AssumeH Ex_EH Conj_EH)+
      apply (rule All2_E [THEN rotate2])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule Ex_I [where x="Var sn"], simp)
      apply (rule Conj_I)
      apply (rule Mem_Eats_I1)
      apply (metis SeqAppendP_Mem1 rotate3 thin2 thin4)
      apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
      apply (rule Ex_I [where x="Var m"], simp)
      apply (rule Ex_I [where x="Var l"], simp)
      apply (rule Ex_I [where x="Var sm"], simp)
      apply (rule Ex_I [where x="Var sl"], simp_all)
      apply (rule Conj_I, rule AssumeH)+
      apply (blast del: Disj_EH intro: OrdP_Trans [OF OrdP_SUCC_I] Mem_Eats_I1 [OF SeqAppendP_Mem1 [THEN cut3]] Hyp)
      \<comment> \<open>... the sequence buildup via s2\<close>
      apply (simp add: PrfP.simps [of l s2 sl m n sm sn])
      apply (rule AssumeH Ex_EH Conj_EH)+
      apply (rule All2_E [THEN rotate2])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule Ex_I [where x="Var sn"], simp)
      apply (rule cut_same [where A="OrdP (Var j)"])
      apply (metis HaddP_imp_OrdP rotate2 thin2)
      apply (rule Conj_I)
      apply (blast intro!: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] del: Disj_EH)
      apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
      apply (rule cut_same [OF exists_HaddP [where j=km and x="SUCC k1" and y="Var m"]])
      apply (blast intro: Ord_IN_Ord, simp)
      apply (rule cut_same [OF exists_HaddP [where j=kn and x="SUCC k1" and y="Var l"]])
      apply (blast intro!: Ord_IN_Ord)
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule Ex_I [where x="Var km"], simp)
      apply (rule Ex_I [where x="Var kn"], simp)
      apply (rule Ex_I [where x="Var sm"], simp)
      apply (rule Ex_I [where x="Var sl"], simp_all)
      apply (rule Conj_I [OF _ Conj_I])
      apply (blast intro!: HaddP_Mem_cancel_left [THEN Iff_MP2_same] OrdP_SUCC_I intro: LstSeqP_OrdP Hyp)+
      apply (blast del: Disj_EH  intro: OrdP_Trans Hyp
                   intro!: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] HaddP_imp_OrdP [THEN cut1])
      done
    qed
 qed (*>*)
 
 corollary PfP_inference: "{PfP \<alpha>1, PfP \<alpha>2, ModPonP \<alpha>1 \<alpha>2 \<beta> OR ExistsP \<alpha>1 \<beta> OR SubstP \<alpha>1 \<beta>} \<turnstile> PfP \<beta>"
 proof -
   obtain k1::name and s1::name and k2::name and s2::name and k::name and s::name
     where "atom s1 \<sharp> (\<alpha>1,\<alpha>2,\<beta>)" "atom k1 \<sharp> (\<alpha>1,\<alpha>2,\<beta>,s1)"
           "atom s2 \<sharp> (\<alpha>1,\<alpha>2,\<beta>,k1,s1)""atom k2 \<sharp> (\<alpha>1,\<alpha>2,\<beta>,s2,k1,s1)"
           "atom s  \<sharp> (\<alpha>1,\<alpha>2,\<beta>,k2,s2,k1,s1)"
           "atom k  \<sharp> (\<alpha>1,\<alpha>2,\<beta>,s,k2,s2,k1,s1)"
     by (metis obtain_fresh)
    thus ?thesis
      apply (simp add: PfP.simps [of k s \<beta>] PfP.simps [of k1 s1 \<alpha>1]  PfP.simps [of k2 s2 \<alpha>2])
      apply (auto intro!: PrfP_inference [of s k "Var s1" "Var s2", THEN cut3] del: Disj_EH)
      done
 qed
 
 theorem PfP_implies_SubstForm_PfP:
    assumes "H \<turnstile> PfP y" "H \<turnstile> SubstFormP x t y z"
      shows "H \<turnstile> PfP z"
 proof -
   obtain u::name and v::name
     where atoms: "atom u \<sharp> (t,x,y,z,v)"   "atom v \<sharp> (t,x,y,z)"
     by (metis obtain_fresh)
   show ?thesis
     apply (rule PfP_inference [of y, THEN cut3])
     apply (rule assms)+
     using atoms
     apply (auto simp: SubstP.simps [of u _ _ v] intro!: Disj_I2)
     apply (rule Ex_I [where x=x], simp)
     apply (rule Ex_I [where x=t], simp add: assms)
     done
 qed
 
 theorem PfP_implies_ModPon_PfP: "\<lbrakk>H \<turnstile> PfP (Q_Imp x y); H \<turnstile> PfP x\<rbrakk> \<Longrightarrow> H \<turnstile> PfP y"
   by (force intro: PfP_inference [of x, THEN cut3] Disj_I1  simp add: ModPonP_def)
 
-corollary PfP_implies_ModPon_PfP_quot: "\<lbrakk>H \<turnstile> PfP \<lceil>\<alpha> IMP \<beta>\<rceil>; H \<turnstile> PfP \<lceil>\<alpha>\<rceil>\<rbrakk> \<Longrightarrow> H \<turnstile> PfP \<lceil>\<beta>\<rceil>"
+corollary PfP_implies_ModPon_PfP_quot: "\<lbrakk>H \<turnstile> PfP \<guillemotleft>\<alpha> IMP \<beta>\<guillemotright>; H \<turnstile> PfP \<guillemotleft>\<alpha>\<guillemotright>\<rbrakk> \<Longrightarrow> H \<turnstile> PfP \<guillemotleft>\<beta>\<guillemotright>"
   by (auto simp: quot_fm_def intro: PfP_implies_ModPon_PfP)
 
 
 lemma TermP_quot:
   fixes \<alpha> :: tm
-  shows "{} \<turnstile> TermP \<lceil>\<alpha>\<rceil>"
+  shows "{} \<turnstile> TermP \<guillemotleft>\<alpha>\<guillemotright>"
   by (induct \<alpha> rule: tm.induct)
     (auto simp: quot_Eats intro: TermP_Zero TermP_Var TermP_Eats[THEN cut2])
 
 lemma TermP_quot_dbtm:
   fixes \<alpha> :: tm
   assumes "wf_dbtm u"
   shows "{} \<turnstile> TermP (quot_dbtm u)"
   using assms
   by (induct u rule: dbtm.induct)
     (auto simp: quot_Eats intro: TermP_Zero
     TermP_Var[unfolded quot_tm_def, simplified] TermP_Eats[THEN cut2])
 
 section \<open>Formulas\<close>
 
 section \<open>Abstraction on Formulas\<close>
 
 subsection \<open>Membership\<close>
 
 lemma AbstAtomicP_Mem:
   "{AbstTermP v i x x', AbstTermP v i y y'} \<turnstile> AbstAtomicP v i (Q_Mem x y) (Q_Mem x' y')"
 proof -
   obtain t::name and u::name and t'::name and u'::name
     where "atom t \<sharp> (v,i,x,x',y,y',t',u,u')" "atom t' \<sharp> (v,i,x,x',y,y',u,u')"
       "atom u \<sharp> (v,i,x,x',y,y',u')" "atom u' \<sharp> (v,i,x,x',y,y')"
     by (metis obtain_fresh)
   thus ?thesis
     apply (simp add: AbstAtomicP.simps [of t _ _ _ _ t' u u'])
     apply (rule Ex_I [where x = x], simp)
     apply (rule Ex_I [where x = y], simp)
     apply (rule Ex_I [where x = x'], simp)
     apply (rule Ex_I [where x = y'], auto intro: Disj_I2)
     done
 qed
 
 lemma SeqAbstFormP_Mem:
   assumes "atom s \<sharp> (k,x,y,x',y',v,i)" "atom k \<sharp> (x,y,x',y',v,i)"
   shows "{AbstTermP v i x x', AbstTermP v i y y'}
            \<turnstile> Ex s (Ex k (SeqAbstFormP v i (Q_Mem x y) (Q_Mem x' y') (Var s) (Var k)))"
 proof -
   let ?vs = "(s,k,x,y,x',y',v,i)"
   obtain l::name and sl::name and sl'::name and m::name and n::name and sm::name and sm'::name and sn::name and sn'::name
     and sli smi sni :: name
     where
       "atom sni \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn',l,sli,smi)"
       "atom smi \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn',l,sli)"
       "atom sli \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn',l)"
       "atom l \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn')"
       "atom sl \<sharp> (?vs,sl',m,n,sm,sm',sn,sn')" "atom sl' \<sharp> (?vs,m,n,sm,sm',sn,sn')"
       "atom m \<sharp> (?vs,n,sm,sm',sn,sn')" "atom n \<sharp> (?vs,sm,sm',sn,sn')"
       "atom sm \<sharp> (?vs,sm',sn,sn')" "atom sm' \<sharp> (?vs,sn,sn')"
       "atom sn \<sharp> (?vs,sn')" "atom sn' \<sharp> ?vs"
     by (metis obtain_fresh)
   thus ?thesis
     using assms
     apply (auto simp: SeqAbstFormP.simps [of l "Var s" _ _ sli sl sl' m n smi sm sm' sni sn sn'])
     apply (rule Ex_I [where x = "Eats Zero (HPair Zero (HPair i (HPair (Q_Mem x y) (Q_Mem x' y'))))"], simp)
     apply (rule Ex_I [where x = Zero], auto intro!: Mem_SUCC_EH)
     apply (rule Ex_I [where x = "i"], simp)
     apply (rule Ex_I [where x = "Q_Mem x y"], simp)
     apply (rule Ex_I [where x = "Q_Mem x' y'"], auto intro: Mem_Eats_I2 HPair_cong)
     apply (blast intro: AbstAtomicP_Mem [THEN cut2] Disj_I1)
     done
 qed
 
 lemma AbstFormP_Mem:
   "{AbstTermP v i x x', AbstTermP v i y y'} \<turnstile> AbstFormP v i (Q_Mem x y) (Q_Mem x' y')"
 proof -
   obtain k1::name and s1::name and k2::name and s2::name and k::name and s::name
     where "atom s1 \<sharp> (v,i,x,y,x',y')" "atom k1 \<sharp> (v,i,x,y,x',y',s1)"
       "atom s2 \<sharp> (v,i,x,y,x',y',k1,s1)" "atom k2 \<sharp> (v,i,x,y,x',y',s2,k1,s1)"
       "atom s  \<sharp> (v,i,x,y,x',y',k2,s2,k1,s1)" "atom k  \<sharp> (v,i,x,y,x',y',s,k2,s2,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: AbstFormP.simps [of s v i "(Q_Mem x y)" _ k]
         AbstFormP.simps [of s1 v i x x' k1]
         AbstFormP.simps [of s2 v i y y' k2]
         intro: AbstTermP_imp_VarP AbstTermP_imp_OrdP SeqAbstFormP_Mem thin1)
 qed
 
 subsection \<open>Equality\<close>
 
 lemma AbstAtomicP_Eq:
   "{AbstTermP v i x x', AbstTermP v i y y'} \<turnstile> AbstAtomicP v i (Q_Eq x y) (Q_Eq x' y')"
 proof -
   obtain t::name and u::name and t'::name  and u'::name
     where "atom t \<sharp> (v,i,x,x',y,y',t',u,u')" "atom t' \<sharp> (v,i,x,x',y,y',u,u')"
       "atom u \<sharp> (v,i,x,x',y,y',u')" "atom u' \<sharp> (v,i,x,x',y,y')"
     by (metis obtain_fresh)
   thus ?thesis
     apply (simp add: AbstAtomicP.simps [of t _ _ _ _ t' u u'])
     apply (rule Ex_I [where x = x], simp)
     apply (rule Ex_I [where x = y], simp)
     apply (rule Ex_I [where x = x'], simp)
     apply (rule Ex_I [where x = y'], auto intro: Disj_I1)
     done
 qed
 
 lemma SeqAbstFormP_Eq:
   assumes sk: "atom s \<sharp> (k,x,y,x',y',v,i)" "atom k \<sharp> (x,y,x',y',v,i)"
   shows "{AbstTermP v i x x', AbstTermP v i y y'}
            \<turnstile> Ex s (Ex k (SeqAbstFormP v i (Q_Eq x y) (Q_Eq x' y') (Var s) (Var k)))"
 proof -
   let ?vs = "(s,k,x,y,x',y',v,i)"
   obtain l::name and sl::name and sl'::name and m::name and n::name and sm::name and sm'::name and sn::name and sn'::name
     and sli smi sni :: name
     where
       "atom sni \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn',l,sli,smi)"
       "atom smi \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn',l,sli)"
       "atom sli \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn',l)"
       "atom l \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn')"
       "atom sl \<sharp> (?vs,sl',m,n,sm,sm',sn,sn')" "atom sl' \<sharp> (?vs,m,n,sm,sm',sn,sn')"
       "atom m \<sharp> (?vs,n,sm,sm',sn,sn')" "atom n \<sharp> (?vs,sm,sm',sn,sn')"
       "atom sm \<sharp> (?vs,sm',sn,sn')" "atom sm' \<sharp> (?vs,sn,sn')"
       "atom sn \<sharp> (?vs,sn')" "atom sn' \<sharp> ?vs"
     by (metis obtain_fresh)
   thus ?thesis
     using sk
     apply (auto simp: SeqAbstFormP.simps [of l "Var s" _ _ sli sl sl' m n smi sm sm' sni sn sn'])
     apply (rule Ex_I [where x = "Eats Zero (HPair Zero (HPair i (HPair (Q_Eq x y) (Q_Eq x' y'))))"], simp)
     apply (rule Ex_I [where x = Zero], auto intro!: Mem_SUCC_EH)
     apply (rule Ex_I [where x = "i"], simp)
     apply (rule Ex_I [where x = "Q_Eq x y"], simp)
     apply (rule Ex_I [where x = "Q_Eq x' y'"], auto)
      apply (metis Mem_Eats_I2 Assume HPair_cong Refl)
     apply (blast intro: AbstAtomicP_Eq [THEN cut2] Disj_I1)
     done
 qed
 
 lemma AbstFormP_Eq:
   "{AbstTermP v i x x', AbstTermP v i y y'} \<turnstile> AbstFormP v i (Q_Eq x y) (Q_Eq x' y')"
 proof -
   obtain k1::name and s1::name and k2::name and s2::name and k::name and s::name
     where "atom s1 \<sharp> (v,i,x,y,x',y')" "atom k1 \<sharp> (v,i,x,y,x',y',s1)"
       "atom s2 \<sharp> (v,i,x,y,x',y',k1,s1)" "atom k2 \<sharp> (v,i,x,y,x',y',s2,k1,s1)"
       "atom s  \<sharp> (v,i,x,y,x',y',k2,s2,k1,s1)" "atom k  \<sharp> (v,i,x,y,x',y',s,k2,s2,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: AbstFormP.simps [of s v i "(Q_Eq x y)" _ k]
         AbstFormP.simps [of s1 v i x x' k1]
         AbstFormP.simps [of s2 v i y y' k2]
         intro: SeqAbstFormP_Eq AbstTermP_imp_OrdP AbstTermP_imp_VarP thin1)
 qed
 
 subsection \<open>Negation\<close>
 
 lemma SeqAbstFormP_Neg:
   assumes "atom s \<sharp> (k,s1,k1,x,x',v,i)" "atom k \<sharp> (s1,k1,x,x',v,i)"
   shows "{SeqAbstFormP v i x x' s1 k1, OrdP i, VarP v}
            \<turnstile> Ex s (Ex k (SeqAbstFormP v i (Q_Neg x) (Q_Neg x') (Var s) (Var k)))" (*<*)
 proof -
   let ?vs = "(s1,k1,s,k,x,x',v,i)"
   obtain l::name and sl::name and sl'::name and m::name and n::name and
     sm::name and sm'::name and sn::name and sn'::name
     and sli smi sni :: name
     where atoms:
       "atom sni \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn',l,sli,smi)"
       "atom smi \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn',l,sli)"
       "atom sli \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn',l)"
       "atom l \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn')"
       "atom sl \<sharp> (?vs,sl',m,n,sm,sm',sn,sn')" "atom sl' \<sharp> (?vs,m,n,sm,sm',sn,sn')"
       "atom m \<sharp> (?vs,n,sm,sm',sn,sn')" "atom n \<sharp> (?vs,sm,sm',sn,sn')"
       "atom sm \<sharp> (?vs,sm',sn,sn')" "atom sm' \<sharp> (?vs,sn,sn')"
       "atom sn \<sharp> (?vs,sn')" "atom sn' \<sharp> ?vs"
     by (metis obtain_fresh)
   let ?hyp = "{RestrictedP s1 (SUCC k1) (Var s), OrdP k1, SeqAbstFormP v i x x' s1 k1, OrdP i, VarP v}"
   show ?thesis
     using assms atoms
     apply (auto simp: SeqAbstFormP.simps [of l "Var s" _ _ sli sl sl' m n smi sm sm' sni sn sn'])
     apply (rule cut_same [where A="OrdP k1"])
      apply (metis SeqAbstFormP_imp_OrdP thin2)
     apply (rule cut_same [OF exists_RestrictedP [of s s1 "SUCC k1"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
       apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC k1) (HPair i (HPair (Q_Neg x) (Q_Neg x'))))"])
       apply (simp_all (no_asm_simp))
     apply (rule Ex_I [where x="(SUCC k1)"])
     apply (simp add: flip_fresh_fresh)
     apply (rule Conj_I)
      apply (blast intro: RestrictedP_LstSeqP_Eats [THEN cut2] SeqAbstFormP_imp_LstSeqP [THEN cut1])
   proof (rule All2_SUCC_I, simp_all)
     show "?hyp \<turnstile> SyntaxN.Ex sli (SyntaxN.Ex sl (SyntaxN.Ex sl'
             (HPair (SUCC k1) (HPair (Var sli) (HPair (Var sl) (Var sl'))) IN
               Eats (Var s) (HPair (SUCC k1) (HPair i (HPair (Q_Neg x) (Q_Neg x')))) AND
             (AbstAtomicP v (Var sli) (Var sl) (Var sl') OR
               OrdP (Var sli) AND
               SyntaxN.Ex m (SyntaxN.Ex n
               (SyntaxN.Ex smi (SyntaxN.Ex sm (SyntaxN.Ex sm'
               (SyntaxN.Ex sni (SyntaxN.Ex sn (SyntaxN.Ex sn'
               (Var m IN SUCC k1 AND Var n IN SUCC k1 AND
               HPair (Var m) (HPair (Var smi) (HPair (Var sm) (Var sm'))) IN
                 Eats (Var s) (HPair (SUCC k1) (HPair i (HPair (Q_Neg x) (Q_Neg x')))) AND
               HPair (Var n) (HPair (Var sni) (HPair (Var sn) (Var sn'))) IN
                 Eats (Var s) (HPair (SUCC k1) (HPair i (HPair (Q_Neg x) (Q_Neg x')))) AND
               (Var sli EQ Var smi AND Var sli EQ Var sni AND
               Var sl EQ Q_Disj (Var sm) (Var sn) AND  Var sl' EQ Q_Disj (Var sm') (Var sn') OR
               Var sli EQ Var smi AND Var sl EQ Q_Neg (Var sm) AND Var sl' EQ Q_Neg (Var sm') OR
               SUCC (Var sli) EQ Var smi AND Var sl EQ Q_Ex (Var sm) AND Var sl' EQ Q_Ex (Var sm'))))))))))))))"
       \<comment> \<open>verifying the final values\<close>
       apply (rule Ex_I [where x="i"])
       using assms atoms apply simp
       apply (rule Ex_I [where x="Q_Neg x"], simp)
       apply (rule Ex_I [where x="Q_Neg x'"], simp)
       apply (rule Conj_I, metis Mem_Eats_I2 Refl)
       apply (rule Disj_I2)
       apply (rule Conj_I, blast)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x=i], simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule_tac x=x' in Ex_I, simp)
       apply (rule Ex_I [where x=i], simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule_tac x=x' in Ex_I, simp)
       apply (rule Conj_I [OF Mem_SUCC_Refl])+
       apply (blast intro: Disj_I1 Disj_I2 Mem_Eats_I1 RestrictedP_Mem [THEN cut3] Mem_SUCC_Refl
           SeqAbstFormP_imp_LstSeqP [THEN cut1] LstSeqP_imp_Mem)
       done
   next
     show "?hyp \<turnstile> All2 l (SUCC k1) (SyntaxN.Ex sli (SyntaxN.Ex sl (SyntaxN.Ex sl'
       (HPair (Var l) (HPair (Var sli) (HPair (Var sl) (Var sl'))) IN
         Eats (Var s) (HPair (SUCC k1) (HPair i (HPair (Q_Neg x) (Q_Neg x')))) AND
       (AbstAtomicP v (Var sli) (Var sl) (Var sl') OR
         OrdP (Var sli) AND
         SyntaxN.Ex m (SyntaxN.Ex n
         (SyntaxN.Ex smi (SyntaxN.Ex sm (SyntaxN.Ex sm'
         (SyntaxN.Ex sni (SyntaxN.Ex sn (SyntaxN.Ex sn'
         (Var m IN Var l AND Var n IN Var l AND
         HPair (Var m) (HPair (Var smi) (HPair (Var sm) (Var sm'))) IN
           Eats (Var s) (HPair (SUCC k1) (HPair i (HPair (Q_Neg x) (Q_Neg x')))) AND
         HPair (Var n) (HPair (Var sni) (HPair (Var sn) (Var sn'))) IN
           Eats (Var s) (HPair (SUCC k1) (HPair i (HPair (Q_Neg x) (Q_Neg x')))) AND
         (Var sli EQ Var smi AND Var sli EQ Var sni AND
         Var sl EQ Q_Disj (Var sm) (Var sn) AND Var sl' EQ Q_Disj (Var sm') (Var sn') OR
         Var sli EQ Var smi AND Var sl EQ Q_Neg (Var sm) AND Var sl' EQ Q_Neg (Var sm') OR
         SUCC (Var sli) EQ Var smi AND Var sl EQ Q_Ex (Var sm) AND Var sl' EQ Q_Ex (Var sm')))))))))))))))"
       \<comment> \<open>verifying the sequence buildup\<close>
       apply (rule All_I Imp_I)+
       using assms atoms apply simp_all
         \<comment> \<open>... the sequence buildup via s1\<close>
        apply (simp add: SeqAbstFormP.simps [of l s1 _ _ sli sl sl' m n smi sm sm' sni sn sn'])
       apply (rule AssumeH Ex_EH Conj_EH)+
       apply (rule All2_E [THEN rotate2], auto del: Disj_EH)
       apply (rule Ex_I [where x="Var sli"], simp)
       apply (rule Ex_I [where x="Var sl"], simp)
       apply (rule Ex_I [where x="Var sl'"], simp)
       apply (rule Conj_I)
        apply (blast intro: Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] del: Disj_EH)
       apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH Conj_I)+
                   apply (rule Ex_I [where x="Var m"], simp)
                   apply (rule Ex_I [where x="Var n"], simp)
                   apply (rule Ex_I [where x="Var smi"], simp)
                   apply (rule Ex_I [where x="Var sm"], simp)
                   apply (rule Ex_I [where x="Var sm'"], simp)
                   apply (rule Ex_I [where x="Var sni"], simp)
                   apply (rule Ex_I [where x="Var sn"], simp)
                   apply (rule Ex_I [where x="Var sn'"], auto del: Disj_EH)
        apply (rule Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] AssumeH OrdP_Trans [OF OrdP_SUCC_I])+
       done
   qed
 qed (*>*)
 
 theorem AbstFormP_Neg: "{AbstFormP v i x x'} \<turnstile> AbstFormP v i (Q_Neg x) (Q_Neg x')"
 proof -
   obtain k1::name and s1::name and k::name and s::name
     where "atom s1 \<sharp> (v,i,x,x')"        "atom k1 \<sharp> (v,i,x,x',s1)"
       "atom s  \<sharp> (v,i,x,x',k1,s1)"  "atom k  \<sharp> (v,i,x,x',s,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (force simp: AbstFormP.simps [of s v i "Q_Neg x" _ k] AbstFormP.simps [of s1 v i x x' k1]
         intro: SeqAbstFormP_Neg [THEN cut3])
 qed
 
 subsection \<open>Disjunction\<close>
 
 lemma SeqAbstFormP_Disj:
   assumes "atom s \<sharp> (k,s1,s2,k1,k2,x,y,x',y',v,i)" "atom k \<sharp> (s1,s2,k1,k2,x,y,x',y',v,i)"
   shows "{SeqAbstFormP v i x x' s1 k1,
             SeqAbstFormP v i y y' s2 k2, OrdP i, VarP v}
            \<turnstile> Ex s (Ex k (SeqAbstFormP v i (Q_Disj x y) (Q_Disj x' y') (Var s) (Var k)))" (*<*)
 proof -
   let ?vs = "(s1,s2,s,k1,k2,k,x,y,x',y',v,i)"
   obtain km::name and kn::name and j::name and k'::name
     and l::name and sl::name and sl'::name and m::name and n::name
     and sm::name and sm'::name and sn::name and sn'::name and sli sni smi :: name
     where atoms2: "atom km \<sharp> (kn,j,k',sni,smi,sli,l,s1,s2,s,k1,k2,k,x,y,x',y',v,i,sl,sl',m,n,sm,sm',sn,sn')"
       "atom kn \<sharp> (j,k',sni,smi,sli,l,s1,s2,s,k1,k2,k,x,y,x',y',v,i,sl,sl',m,n,sm,sm',sn,sn')"
       "atom j \<sharp> (k',sni,smi,sli,l,s1,s2,s,k1,k2,k,x,y,x',y',v,i,sl,sl',m,n,sm,sm',sn,sn')"
       and atoms: "atom k' \<sharp> (sni,smi,sli,l,s1,s2,s,k1,k2,k,x,y,x',y',v,i,sl,sl',m,n,sm,sm',sn,sn')"
       "atom sni \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn',l,sli,smi)"
       "atom smi \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn',l,sli)"
       "atom sli \<sharp> (?vs,sl,sl',m,n,sm,sm',sn,sn',l)"
       "atom l \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,sl,sl',m,n,sm,sm',sn,sn')"
       "atom sl \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,sl',m,n,sm,sm',sn,sn')"
       "atom sl' \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,m,n,sm,sm',sn,sn')"
       "atom m \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,n,sm,sm',sn,sn')"
       "atom n \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,sm,sm',sn,sn')"
       "atom sm \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,sm',sn,sn')"
       "atom sm' \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,sn,sn')"
       "atom sn \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i,sn')"
       "atom sn' \<sharp> (s1,s2,s,k1,k2,k,x,y,x',y',v,i)"
     by (metis obtain_fresh)
   let ?hyp = "{HaddP k1 k2 (Var k'), OrdP k1, OrdP k2, SeqAppendP s1 (SUCC k1) s2 (SUCC k2) (Var s),
                SeqAbstFormP v i x x' s1 k1, SeqAbstFormP v i y y' s2 k2, OrdP i, VarP v}"
   show ?thesis
     using assms atoms
     apply (auto simp: SeqAbstFormP.simps [of l "Var s" _ _ sli sl sl' m n smi sm sm' sni sn sn'])
     apply (rule cut_same [where A="OrdP k1 AND OrdP k2"])
      apply (metis Conj_I SeqAbstFormP_imp_OrdP thin1 thin2)
     apply (rule cut_same [OF exists_SeqAppendP [of s s1 "SUCC k1" s2 "SUCC k2"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
       apply (rule cut_same [OF exists_HaddP [where j=k' and x=k1 and y=k2]])
         apply (rule AssumeH Ex_EH Conj_EH | simp)+
         apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC(SUCC(Var k'))) (HPair i (HPair(Q_Disj x y)(Q_Disj x' y'))))"])
         apply (simp_all (no_asm_simp))
     apply (rule Ex_I [where x="SUCC (SUCC (Var k'))"], simp)
     apply (rule Conj_I)
      apply (blast intro: LstSeqP_SeqAppendP_Eats SeqAbstFormP_imp_LstSeqP [THEN cut1])
   proof (rule All2_SUCC_I, simp_all)
     show "?hyp \<turnstile> SyntaxN.Ex sli (SyntaxN.Ex sl (SyntaxN.Ex sl'
          (HPair (SUCC (SUCC (Var k'))) (HPair (Var sli) (HPair (Var sl) (Var sl'))) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair i (HPair (Q_Disj x y) (Q_Disj x' y')))) AND
           (AbstAtomicP v (Var sli) (Var sl) (Var sl') OR
            OrdP (Var sli) AND
            SyntaxN.Ex m
             (SyntaxN.Ex n
               (SyntaxN.Ex smi
                 (SyntaxN.Ex sm
                   (SyntaxN.Ex sm'
                     (SyntaxN.Ex sni
                       (SyntaxN.Ex sn
                         (SyntaxN.Ex sn'
                           (Var m IN SUCC (SUCC (Var k')) AND
                            Var n IN SUCC (SUCC (Var k')) AND
                            HPair (Var m) (HPair (Var smi) (HPair (Var sm) (Var sm'))) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair i (HPair (Q_Disj x y) (Q_Disj x' y')))) AND
                            HPair (Var n) (HPair (Var sni) (HPair (Var sn) (Var sn'))) IN Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair i (HPair (Q_Disj x y) (Q_Disj x' y')))) AND
                            (Var sli EQ Var smi AND Var sli EQ Var sni AND Var sl EQ Q_Disj (Var sm) (Var sn) AND Var sl' EQ Q_Disj (Var sm') (Var sn') OR
                             Var sli EQ Var smi AND Var sl EQ Q_Neg (Var sm) AND Var sl' EQ Q_Neg (Var sm') OR
                             SUCC (Var sli) EQ Var smi AND Var sl EQ Q_Ex (Var sm) AND Var sl' EQ Q_Ex (Var sm'))))))))))))))"
       \<comment> \<open>verifying the final values\<close>
       apply (rule Ex_I [where x="i"])
       using assms atoms apply simp
       apply (rule Ex_I [where x="Q_Disj x y"], simp)
       apply (rule Ex_I [where x="Q_Disj x' y'"], simp)
       apply (rule Conj_I, metis Mem_Eats_I2 Refl)
       apply (rule Disj_I2)
       apply (rule Conj_I, blast)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x="SUCC (Var k')"], simp)
       apply (rule Ex_I [where x=i], simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule_tac x=x' in Ex_I, simp)
       apply (rule Ex_I [where x=i], simp)
       apply (rule Ex_I [where x=y], simp)
       apply (rule_tac x=y' in Ex_I, simp)
       apply (rule Conj_I)
        apply (blast intro: HaddP_Mem_I LstSeqP_OrdP Mem_SUCC_I1)
       apply (rule Conj_I [OF Mem_SUCC_Refl])
       apply (blast intro: Disj_I1 Mem_Eats_I1 Mem_SUCC_Refl SeqAbstFormP_imp_LstSeqP [THEN cut1]
           LstSeqP_imp_Mem SeqAppendP_Mem1 [THEN cut3] SeqAppendP_Mem2 [THEN cut4] HaddP_SUCC1 [THEN cut1])
       done
   next
     show "?hyp \<turnstile> All2 l (SUCC (SUCC (Var k')))
      (SyntaxN.Ex sli
        (SyntaxN.Ex sl
          (SyntaxN.Ex sl'
            (HPair (Var l) (HPair (Var sli) (HPair (Var sl) (Var sl'))) IN
             Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair i (HPair (Q_Disj x y) (Q_Disj x' y')))) AND
             (AbstAtomicP v (Var sli) (Var sl) (Var sl') OR
              OrdP (Var sli) AND
              SyntaxN.Ex m
               (SyntaxN.Ex n
                 (SyntaxN.Ex smi
                   (SyntaxN.Ex sm
                     (SyntaxN.Ex sm'
                       (SyntaxN.Ex sni
                         (SyntaxN.Ex sn
                           (SyntaxN.Ex sn'
                             (Var m IN Var l AND
                              Var n IN Var l AND
                              HPair (Var m) (HPair (Var smi) (HPair (Var sm) (Var sm'))) IN
                              Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair i (HPair (Q_Disj x y) (Q_Disj x' y')))) AND
                              HPair (Var n) (HPair (Var sni) (HPair (Var sn) (Var sn'))) IN
                              Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair i (HPair (Q_Disj x y) (Q_Disj x' y')))) AND
                              (Var sli EQ Var smi AND Var sli EQ Var sni AND Var sl EQ Q_Disj (Var sm) (Var sn) AND Var sl' EQ Q_Disj (Var sm') (Var sn') OR
                               Var sli EQ Var smi AND Var sl EQ Q_Neg (Var sm) AND Var sl' EQ Q_Neg (Var sm') OR
                               SUCC (Var sli) EQ Var smi AND Var sl EQ Q_Ex (Var sm) AND Var sl' EQ Q_Ex (Var sm')))))))))))))))"
       \<comment> \<open>verifying the sequence buildup\<close>
       apply (rule cut_same [where A="HaddP (SUCC k1) (SUCC k2) (SUCC (SUCC (Var k')))"])
        apply (blast intro: HaddP_SUCC1 [THEN cut1] HaddP_SUCC2 [THEN cut1])
       apply (rule All_I Imp_I)+
        apply (rule HaddP_Mem_cases [where i=j])
       using assms atoms atoms2 apply simp_all
           apply (rule AssumeH)
          apply (blast intro: OrdP_SUCC_I LstSeqP_OrdP)
         \<comment> \<open>... the sequence buildup via s1\<close>
        apply (simp add: SeqAbstFormP.simps [of l s1 _ _ sli sl sl' m n smi sm sm' sni sn sn'])
         apply (rule AssumeH Ex_EH Conj_EH)+
         apply (rule All2_E [THEN rotate2])
           apply (simp | rule AssumeH Ex_EH Conj_EH)+
             apply (rule Ex_I [where x="Var sli"], simp)
             apply (rule Ex_I [where x="Var sl"], simp)
             apply (rule Ex_I [where x="Var sl'"], simp)
             apply (rule Conj_I [OF Mem_Eats_I1])
              apply (metis SeqAppendP_Mem1 rotate3 thin2 thin4)
             apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
                           apply (rule Conj_I)
                           apply (blast intro: Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] del: Disj_EH)
                         apply (rule Ex_I [where x="Var m"], simp)
                         apply (rule Ex_I [where x="Var n"], simp)
                         apply (rule Ex_I [where x="Var smi"], simp)
                         apply (rule Ex_I [where x="Var sm"], simp)
                         apply (rule Ex_I [where x="Var sm'"], simp)
                         apply (rule Ex_I [where x="Var sni"], simp)
                         apply (rule Ex_I [where x="Var sn"], simp)
                         apply (rule Ex_I [where x="Var sn'"], simp_all (no_asm_simp))
        apply (rule Conj_I, rule AssumeH)+
        apply (rule Conj_I)
         apply (blast intro: OrdP_Trans [OF OrdP_SUCC_I] Mem_Eats_I1 [OF SeqAppendP_Mem1 [THEN cut3]] Hyp)
        apply (blast intro: Disj_I1 Disj_I2 OrdP_Trans [OF OrdP_SUCC_I] Mem_Eats_I1 [OF SeqAppendP_Mem1 [THEN cut3]] Hyp)
         \<comment> \<open>... the sequence buildup via s2\<close>
        apply (simp add: SeqAbstFormP.simps [of l s2 _ _ sli sl sl' m n smi sm sm' sni sn sn'])
       apply (rule AssumeH Ex_EH Conj_EH)+
       apply (rule All2_E [THEN rotate2])
         apply (simp | rule AssumeH Ex_EH Conj_EH)+
           apply (rule Ex_I [where x="Var sli"], simp)
           apply (rule Ex_I [where x="Var sl"], simp)
           apply (rule Ex_I [where x="Var sl'"], simp)
           apply (rule cut_same [where A="OrdP (Var j)"])
            apply (metis HaddP_imp_OrdP rotate2 thin2)
           apply (rule Conj_I)
            apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] del: Disj_EH)
           apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
                       apply (rule cut_same [OF exists_HaddP [where j=km and x="SUCC k1" and y="Var m"]])
                         apply (blast intro: Ord_IN_Ord, simp)
                       apply (rule cut_same [OF exists_HaddP [where j=kn and x="SUCC k1" and y="Var n"]])
                         apply (metis AssumeH(6) Ord_IN_Ord0 rotate8, simp)
                       apply (rule AssumeH Ex_EH Conj_EH | simp)+
                           apply (rule Conj_I)
                           apply (blast intro: Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] del: Disj_EH)
                           apply (rule Ex_I [where x="Var km"], simp)
                           apply (rule Ex_I [where x="Var kn"], simp)
                           apply (rule Ex_I [where x="Var smi"], simp)
                           apply (rule Ex_I [where x="Var sm"], simp)
                           apply (rule Ex_I [where x="Var sm'"], simp)
                           apply (rule Ex_I [where x="Var sni"], simp)
                           apply (rule Ex_I [where x="Var sn"], simp)
                           apply (rule Ex_I [where x="Var sn'"], simp_all (no_asm_simp))
       apply (rule Conj_I [OF _ Conj_I])
         apply (blast intro!: HaddP_Mem_cancel_left [THEN Iff_MP2_same] OrdP_SUCC_I intro: LstSeqP_OrdP Hyp)+
       apply (blast del: Disj_EH  intro: OrdP_Trans Hyp
           intro!: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] HaddP_imp_OrdP [THEN cut1])
       done
   qed
 qed (*>*)
 
 theorem AbstFormP_Disj:
   "{AbstFormP v i x x', AbstFormP v i y y'} \<turnstile> AbstFormP v i (Q_Disj x y) (Q_Disj x' y')"
 proof -
   obtain k1::name and s1::name and k2::name and s2::name and k::name and s::name
     where "atom s1 \<sharp> (v,i,x,y,x',y')"        "atom k1 \<sharp> (v,i,x,y,x',y',s1)"
       "atom s2 \<sharp> (v,i,x,y,x',y',k1,s1)"  "atom k2 \<sharp> (v,i,x,y,x',y',s2,k1,s1)"
       "atom s  \<sharp> (v,i,x,y,x',y',k2,s2,k1,s1)" "atom k  \<sharp> (v,i,x,y,x',y',s,k2,s2,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (force simp: AbstFormP.simps [of s v i "Q_Disj x y" _ k]
         AbstFormP.simps [of s1 v i x x' k1]
         AbstFormP.simps [of s2 v i y y' k2]
         intro: SeqAbstFormP_Disj [THEN cut4])
 qed
 
 subsection \<open>Existential\<close>
 
 lemma SeqAbstFormP_Ex:
   assumes "atom s \<sharp> (k,s1,k1,x,x',v,i)" "atom k \<sharp> (s1,k1,x,x',v,i)"
   shows "{SeqAbstFormP v (SUCC i) x x' s1 k1, OrdP i, VarP v}
            \<turnstile> Ex s (Ex k (SeqAbstFormP v i (Q_Ex x) (Q_Ex x') (Var s) (Var k)))" (*<*)
 proof -
   obtain l::name and sl::name and sl'::name and m::name and n::name
     and sm::name and sm'::name and sn::name and sn'::name
     and sli smi sni :: name
     where atoms:
       "atom sni \<sharp> (s1,k1,s,k,x,x',v,i,sl,sl',m,n,sm,sm',sn,sn',l,sli,smi)"
       "atom smi \<sharp> (s1,k1,s,k,x,x',v,i,sl,sl',m,n,sm,sm',sn,sn',l,sli)"
       "atom sli \<sharp> (s1,k1,s,k,x,x',v,i,sl,sl',m,n,sm,sm',sn,sn',l)"
       "atom l \<sharp> (s1,k1,s,k,x,x',v,i,sl,sl',m,n,sm,sm',sn,sn')"
       "atom sl \<sharp> (s1,k1,s,k,x,x',v,i,sl',m,n,sm,sm',sn,sn')"
       "atom sl' \<sharp> (s1,k1,s,k,x,x',v,i,m,n,sm,sm',sn,sn')"
       "atom m \<sharp> (s1,k1,s,k,x,x',v,i,n,sm,sm',sn,sn')"
       "atom n \<sharp> (s1,k1,s,k,x,x',v,i,sm,sm',sn,sn')"
       "atom sm \<sharp> (s1,k1,s,k,x,x',v,i,sm',sn,sn')"
       "atom sm' \<sharp> (s1,k1,s,k,x,x',v,i,sn,sn')"
       "atom sn \<sharp> (s1,k1,s,k,x,x',v,i,sn')"
       "atom sn' \<sharp> (s1,k1,s,k,x,x',v,i)"
     by (metis obtain_fresh)
   let ?hyp = "{RestrictedP s1 (SUCC k1) (Var s), OrdP k1, SeqAbstFormP v (SUCC i) x x' s1 k1, OrdP i, VarP v}"
   show ?thesis
     using assms atoms
     apply (auto simp: SeqAbstFormP.simps [of l "Var s" _ _ sli sl sl' m n smi sm sm' sni sn sn'])
     apply (rule cut_same [where A="OrdP k1"])
      apply (metis SeqAbstFormP_imp_OrdP thin2)
     apply (rule cut_same [OF exists_RestrictedP [of s s1 "SUCC k1"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
       apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC k1) (HPair i (HPair (Q_Ex x) (Q_Ex x'))))"], simp)
       apply (rule Ex_I [where x="(SUCC k1)"], simp)
       apply (rule Conj_I)
        apply (blast intro: RestrictedP_LstSeqP_Eats [THEN cut2] SeqAbstFormP_imp_LstSeqP [THEN cut1])
   proof (rule All2_SUCC_I, simp_all)
     show "?hyp \<turnstile> SyntaxN.Ex sli
      (SyntaxN.Ex sl
        (SyntaxN.Ex sl'
          (HPair (SUCC k1) (HPair (Var sli) (HPair (Var sl) (Var sl'))) IN Eats (Var s) (HPair (SUCC k1) (HPair i (HPair (Q_Ex x) (Q_Ex x')))) AND
           (AbstAtomicP v (Var sli) (Var sl) (Var sl') OR
            OrdP (Var sli) AND
            SyntaxN.Ex m
             (SyntaxN.Ex n
               (SyntaxN.Ex smi
                 (SyntaxN.Ex sm
                   (SyntaxN.Ex sm'
                     (SyntaxN.Ex sni
                       (SyntaxN.Ex sn
                         (SyntaxN.Ex sn'
                           (Var m IN SUCC k1 AND
                            Var n IN SUCC k1 AND
                            HPair (Var m) (HPair (Var smi) (HPair (Var sm) (Var sm'))) IN
                            Eats (Var s) (HPair (SUCC k1) (HPair i (HPair (Q_Ex x) (Q_Ex x')))) AND
                            HPair (Var n) (HPair (Var sni) (HPair (Var sn) (Var sn'))) IN
                            Eats (Var s) (HPair (SUCC k1) (HPair i (HPair (Q_Ex x) (Q_Ex x')))) AND
                            (Var sli EQ Var smi AND
                             Var sli EQ Var sni AND Var sl EQ Q_Disj (Var sm) (Var sn) AND Var sl' EQ Q_Disj (Var sm') (Var sn') OR
                             Var sli EQ Var smi AND Var sl EQ Q_Neg (Var sm) AND Var sl' EQ Q_Neg (Var sm') OR
                             SUCC (Var sli) EQ Var smi AND Var sl EQ Q_Ex (Var sm) AND Var sl' EQ Q_Ex (Var sm'))))))))))))))"
       \<comment> \<open>verifying the final values\<close>
       apply (rule Ex_I [where x="i"])
       using assms atoms apply simp
       apply (rule Ex_I [where x="Q_Ex x"], simp)
       apply (rule Ex_I [where x="Q_Ex x'"], simp)
       apply (rule Conj_I, metis Mem_Eats_I2 Refl)
       apply (rule Disj_I2)
       apply (rule Conj_I, blast)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x="SUCC i"], simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule_tac x=x' in Ex_I, simp)
       apply (rule Ex_I [where x="SUCC i"], simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule_tac x=x' in Ex_I, simp)
       apply (rule Conj_I [OF Mem_SUCC_Refl])+
       apply (blast intro: Disj_I2 Mem_Eats_I1 RestrictedP_Mem [THEN cut3] Mem_SUCC_Refl
           SeqAbstFormP_imp_LstSeqP [THEN cut1] LstSeqP_imp_Mem)
       done
   next
     show "?hyp
              \<turnstile> All2 l (SUCC k1)
      (SyntaxN.Ex sli
        (SyntaxN.Ex sl
          (SyntaxN.Ex sl'
            (HPair (Var l) (HPair (Var sli) (HPair (Var sl) (Var sl'))) IN Eats (Var s) (HPair (SUCC k1) (HPair i (HPair (Q_Ex x) (Q_Ex x')))) AND
             (AbstAtomicP v (Var sli) (Var sl) (Var sl') OR
              OrdP (Var sli) AND
              SyntaxN.Ex m
               (SyntaxN.Ex n
                 (SyntaxN.Ex smi
                   (SyntaxN.Ex sm
                     (SyntaxN.Ex sm'
                       (SyntaxN.Ex sni
                         (SyntaxN.Ex sn
                           (SyntaxN.Ex sn'
                             (Var m IN Var l AND
                              Var n IN Var l AND
                              HPair (Var m) (HPair (Var smi) (HPair (Var sm) (Var sm'))) IN
                              Eats (Var s) (HPair (SUCC k1) (HPair i (HPair (Q_Ex x) (Q_Ex x')))) AND
                              HPair (Var n) (HPair (Var sni) (HPair (Var sn) (Var sn'))) IN
                              Eats (Var s) (HPair (SUCC k1) (HPair i (HPair (Q_Ex x) (Q_Ex x')))) AND
                              (Var sli EQ Var smi AND Var sli EQ Var sni AND Var sl EQ Q_Disj (Var sm) (Var sn) AND Var sl' EQ Q_Disj (Var sm') (Var sn') OR
                               Var sli EQ Var smi AND Var sl EQ Q_Neg (Var sm) AND Var sl' EQ Q_Neg (Var sm') OR
                               SUCC (Var sli) EQ Var smi AND Var sl EQ Q_Ex (Var sm) AND Var sl' EQ Q_Ex (Var sm')))))))))))))))"
       \<comment> \<open>verifying the sequence buildup\<close>
       using assms atoms
         \<comment> \<open>... the sequence buildup via s1\<close>
       apply (auto simp add: SeqAbstFormP.simps [of l s1 _ _ sli sl sl' m n smi sm sm' sni sn sn'])
       apply (rule Swap)
       apply (rule All2_E, auto del: Disj_EH)
       apply (rule Ex_I [where x="Var sli"], simp)
       apply (rule Ex_I [where x="Var sl"], simp)
       apply (rule Ex_I [where x="Var sl'"], simp)
       apply (rule Conj_I)
        apply (blast intro: Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] del: Disj_EH)
       apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
           apply (rule Conj_I)
            apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] del: Disj_EH)
                   apply (rule Ex_I [where x="Var m"], simp)
                   apply (rule Ex_I [where x="Var n"], simp)
                   apply (rule Ex_I [where x="Var smi"], simp)
                   apply (rule Ex_I [where x="Var sm"], simp)
                   apply (rule Ex_I [where x="Var sm'"], simp)
                   apply (rule Ex_I [where x="Var sni"], simp)
                   apply (rule Ex_I [where x="Var sn"], simp)
                   apply (rule Ex_I [where x="Var sn'"])
                   apply (auto intro: Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] OrdP_Trans [OF OrdP_SUCC_I] del: Disj_EH)
       done
   qed
 qed (*>*)
 
 theorem AbstFormP_Ex: "{AbstFormP v (SUCC i) x x'} \<turnstile> AbstFormP v i (Q_Ex x) (Q_Ex x')"
 proof -
   obtain k1::name and s1::name and k::name and s::name
     where "atom s1 \<sharp> (v,i,x,x')"        "atom k1 \<sharp> (v,i,x,x',s1)"
       "atom s  \<sharp> (v,i,x,x',k1,s1)"  "atom k  \<sharp> (v,i,x,x',s,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: AbstFormP.simps [of s v i "Q_Ex x" _ k] AbstFormP.simps [of s1 v "SUCC i" x x' k1]
         intro!: SeqAbstFormP_Ex [THEN cut3] Ord_IN_Ord[OF Mem_SUCC_I2[OF Refl], of _ i])
 qed
 
-corollary AbstTermP_Zero: "{OrdP t} \<turnstile> AbstTermP \<lceil>Var v\<rceil> t Zero Zero"
+corollary AbstTermP_Zero: "{OrdP t} \<turnstile> AbstTermP \<guillemotleft>Var v\<guillemotright> t Zero Zero"
 proof -
   obtain s::name and k::name where "atom s \<sharp> (v,t,k)"  "atom k \<sharp> (v,t)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: AbstTermP.simps [of s _ _ _ _ k] intro: SeqStTermP_Zero [THEN cut1])
 qed
 
 corollary AbstTermP_Var_same: "{VarP v, OrdP t} \<turnstile> AbstTermP v t v (Q_Ind t)"
 proof -
   obtain s::name and k::name where "atom s \<sharp> (v,t,k)" "atom k \<sharp> (v,t)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: AbstTermP.simps [of s _ _ _ _ k] intro: SeqStTermP_Var_same [THEN cut1])
 qed
 
 corollary AbstTermP_Var_diff: "{VarP v, VarP w, Neg (v EQ w), OrdP t} \<turnstile> AbstTermP v t w w"
 proof -
   obtain s::name and k::name where "atom s \<sharp> (v,w,t,k)" "atom k \<sharp> (v,w,t)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: AbstTermP.simps [of s _ _ _ _ k] intro: SeqStTermP_Var_diff [THEN cut3])
 qed
 
 theorem AbstTermP_Eats:
    "{AbstTermP v i t1 u1, AbstTermP v i t2 u2} \<turnstile> AbstTermP v i (Q_Eats t1 t2) (Q_Eats u1 u2)"
 proof -
   obtain k1::name and s1::name and k2::name and s2::name and k::name and s::name
     where "atom s1 \<sharp> (v,i,t1,u1,t2,u2)" "atom k1 \<sharp> (v,i,t1,u1,t2,u2,s1)"
           "atom s2 \<sharp> (v,i,t1,u1,t2,u2,k1,s1)" "atom k2 \<sharp> (v,i,t1,u1,t2,u2,s2,k1,s1)"
           "atom s  \<sharp> (v,i,t1,u1,t2,u2,k2,s2,k1,s1)"
           "atom k  \<sharp> (v,i,t1,u1,t2,u2,s,k2,s2,k1,s1)"
     by (metis obtain_fresh)
    thus ?thesis
      by (auto intro!: SeqStTermP_Eats [THEN cut2]
               simp: AbstTermP.simps [of s _ _ _ "(Q_Eats u1 u2)" k]
                     AbstTermP.simps [of s1 v i t1 u1 k1]
                     AbstTermP.simps [of s2 v i t2 u2 k2])
  qed
 
 corollary AbstTermP_Ind: "{VarP v, IndP w, OrdP t} \<turnstile> AbstTermP v t w w"
 proof -
   obtain s::name and k::name where "atom s \<sharp> (v,w,t,k)" "atom k \<sharp> (v,w,t)"
     by (metis obtain_fresh)
   thus ?thesis
     by (force simp: AbstTermP.simps [of s _ _ _ _ k]
               intro: SeqStTermP_Ind [THEN cut2])
 qed
 
 lemma ORD_OF_EQ_diff: "x \<noteq> y \<Longrightarrow> {ORD_OF x EQ ORD_OF y} \<turnstile> Fls"
 proof (induct x arbitrary: y)
   case (Suc x)
   then show ?case using SUCC_inject_E
     by (cases y) (auto simp: gr0_conv_Suc Eats_EQ_Zero_E SUCC_def)
 qed (auto simp: gr0_conv_Suc SUCC_def)
 
-lemma quot_Var_EQ_diff: "i \<noteq> x \<Longrightarrow> {\<lceil>Var i\<rceil> EQ \<lceil>Var x\<rceil>} \<turnstile> Fls"
+lemma quot_Var_EQ_diff: "i \<noteq> x \<Longrightarrow> {\<guillemotleft>Var i\<guillemotright> EQ \<guillemotleft>Var x\<guillemotright>} \<turnstile> Fls"
   by (auto simp: quot_Var ORD_OF_EQ_diff)
 
-lemma AbstTermP_dbtm: "{} \<turnstile> AbstTermP \<lceil>Var i\<rceil> (ORD_OF n) (quot_dbtm u) (quot_dbtm (abst_dbtm i n u))"
+lemma AbstTermP_dbtm: "{} \<turnstile> AbstTermP \<guillemotleft>Var i\<guillemotright> (ORD_OF n) (quot_dbtm u) (quot_dbtm (abst_dbtm i n u))"
 proof (induct u rule: dbtm.induct)
   case (DBVar x)
   then show ?case
     by (auto simp: quot_Var[symmetric] quot_Var_EQ_diff
       intro!: AbstTermP_Var_same[THEN cut2] AbstTermP_Var_diff[THEN cut4] TermP_Zero)
 qed (auto intro!: AbstTermP_Zero[THEN cut1] AbstTermP_Eats[THEN cut2] AbstTermP_Ind[THEN cut3] IndP_Q_Ind)
 
-lemma AbstFormP_dbfm: "{} \<turnstile> AbstFormP \<lceil>Var i\<rceil> (ORD_OF n) (quot_dbfm db) (quot_dbfm (abst_dbfm i n db))"
+lemma AbstFormP_dbfm: "{} \<turnstile> AbstFormP \<guillemotleft>Var i\<guillemotright> (ORD_OF n) (quot_dbfm db) (quot_dbfm (abst_dbfm i n db))"
   by (induction db arbitrary: n rule: dbfm.induct)
     (auto intro!: AbstTermP_dbtm AbstFormP_Mem[THEN cut2] AbstFormP_Eq[THEN cut2]
         AbstFormP_Disj[THEN cut2] AbstFormP_Neg[THEN cut1] AbstFormP_Ex[THEN cut1]
         dest: meta_spec[of _ "Suc _"])
 
 lemmas AbstFormP = AbstFormP_dbfm[where db="trans_fm [] A" and n = 0 for A,
     simplified, folded quot_fm_def, unfolded abst_trans_fm]
 
 lemma SubstTermP_trivial_dbtm:
-  "atom i \<sharp> u \<Longrightarrow> {} \<turnstile> SubstTermP \<lceil>Var i\<rceil> Zero (quot_dbtm u) (quot_dbtm u)"
+  "atom i \<sharp> u \<Longrightarrow> {} \<turnstile> SubstTermP \<guillemotleft>Var i\<guillemotright> Zero (quot_dbtm u) (quot_dbtm u)"
 proof (induct u rule: dbtm.induct)
   case (DBVar x)
   then show ?case
     by (auto simp: quot_Var[symmetric] quot_Var_EQ_diff
       intro!: SubstTermP_Var_same[THEN cut2] SubstTermP_Var_diff[THEN cut4] TermP_Zero)
 qed (auto intro!: SubstTermP_Zero[THEN cut1] SubstTermP_Eats[THEN cut2] SubstTermP_Ind[THEN cut3]
   TermP_Zero IndP_Q_Ind)
 
 lemma SubstTermP_dbtm: "wf_dbtm t \<Longrightarrow>
-   {} \<turnstile> SubstTermP \<lceil>Var i\<rceil> (quot_dbtm t) (quot_dbtm u) (quot_dbtm (subst_dbtm t i u))"
+   {} \<turnstile> SubstTermP \<guillemotleft>Var i\<guillemotright> (quot_dbtm t) (quot_dbtm u) (quot_dbtm (subst_dbtm t i u))"
 proof (induct u rule: dbtm.induct)
   case (DBVar x)
   then show ?case
     apply (auto simp: quot_Var[symmetric]
       intro!: SubstTermP_Var_same[THEN cut2] SubstTermP_Var_diff[THEN cut4] TermP_quot_dbtm)
     apply (auto simp: quot_Var ORD_OF_EQ_diff)
     done
 qed (auto intro!: SubstTermP_Zero[THEN cut1] SubstTermP_Ind[THEN cut3] SubstTermP_Eats[THEN cut2]
    TermP_quot_dbtm IndP_Q_Ind)
 
 
 
 lemma SubstFormP_trivial_dbfm:
   fixes X :: fm
   assumes "atom i \<sharp> db"
-  shows "{} \<turnstile> SubstFormP \<lceil>Var i\<rceil> Zero (quot_dbfm db) (quot_dbfm db)"
+  shows "{} \<turnstile> SubstFormP \<guillemotleft>Var i\<guillemotright> Zero (quot_dbfm db) (quot_dbfm db)"
   using assms
   by (induct db rule: dbfm.induct)
     (auto intro!: SubstFormP_Ex[THEN cut1] SubstFormP_Neg[THEN cut1] SubstFormP_Disj[THEN cut2]
           SubstFormP_Eq[THEN cut2] SubstFormP_Mem[THEN cut2] SubstTermP_trivial_dbtm)+
 
 lemma SubstFormP_dbfm:
   assumes "wf_dbtm t"
-  shows "{} \<turnstile> SubstFormP \<lceil>Var i\<rceil> (quot_dbtm t) (quot_dbfm db) (quot_dbfm (subst_dbfm t i db))"
+  shows "{} \<turnstile> SubstFormP \<guillemotleft>Var i\<guillemotright> (quot_dbtm t) (quot_dbfm db) (quot_dbfm (subst_dbfm t i db))"
   by (induct db rule: dbfm.induct)
     (auto intro!: SubstTermP_dbtm assms SubstFormP_Ex[THEN cut1] SubstFormP_Neg[THEN cut1]
            SubstFormP_Disj[THEN cut2] SubstFormP_Eq[THEN cut2] SubstFormP_Mem[THEN cut2])+
 
 lemmas SubstFormP_trivial = SubstFormP_trivial_dbfm[where db="trans_fm [] A" for A,
     simplified, folded quot_tm_def quot_fm_def quot_subst_eq]
 lemmas SubstFormP = SubstFormP_dbfm[OF wf_dbtm_trans_tm, where db="trans_fm [] A" for A,
     simplified, folded quot_tm_def quot_fm_def quot_subst_eq]
 lemmas SubstFormP_Zero = SubstFormP_dbfm[OF wf_dbtm.Zero, where db="trans_fm [] A" for A,
     simplified, folded  trans_tm.simps[of "[]"], folded quot_tm_def quot_fm_def quot_subst_eq]
 
 lemma AtomicP_Mem:
   "{TermP x, TermP y} \<turnstile> AtomicP (Q_Mem x y)"
 proof -
   obtain t::name and u::name
     where "atom t \<sharp> (x, y)" "atom u \<sharp> (t, x, y)"
     by (metis obtain_fresh)
   thus ?thesis
     apply (simp add: AtomicP.simps [of t u])
     apply (rule Ex_I [where x = x], simp)
     apply (rule Ex_I [where x = y], simp)
     apply (auto intro: Disj_I2)
     done
 qed
 
 lemma AtomicP_Eq:
   "{TermP x, TermP y} \<turnstile> AtomicP (Q_Eq x y)"
 proof -
   obtain t::name and u::name
     where "atom t \<sharp> (x, y)" "atom u \<sharp> (t, x, y)"
     by (metis obtain_fresh)
   thus ?thesis
     apply (simp add: AtomicP.simps [of t u])
     apply (rule Ex_I [where x = x], simp)
     apply (rule Ex_I [where x = y], simp)
     apply (auto intro: Disj_I1)
     done
 qed
 
 lemma SeqFormP_Mem:
   assumes "atom s \<sharp> (k,x,y)" "atom k \<sharp> (x,y)"
   shows "{TermP x, TermP y} \<turnstile> Ex k (Ex s (SeqFormP (Var s) (Var k) (Q_Mem x y)))"
 proof -
   let ?vs = "(x,y,s,k)"
   obtain l::name and sl::name and m::name and n::name and sm::name and sn::name
     where
       "atom l \<sharp> (?vs,sl,m,n,sm,sn)"
       "atom sl \<sharp> (?vs,m,n,sm,sn)"
       "atom m \<sharp> (?vs,n,sm,sn)" "atom n \<sharp> (?vs,sm,sn)"
       "atom sm \<sharp> (?vs,sn)"
       "atom sn \<sharp> (?vs)"
     by (metis obtain_fresh)
   with assms show ?thesis
     apply (auto simp: SeqFormP.simps[of l "Var s" _ _ sl m n sm sn])
     apply (rule Ex_I [where x = Zero], simp)
     apply (rule Ex_I [where x = "Eats Zero (HPair Zero (Q_Mem x y))"], auto intro!: Mem_SUCC_EH)
     apply (rule Ex_I [where x = "Q_Mem x y"], auto intro!: Mem_Eats_I2 HPair_cong Disj_I1 AtomicP_Mem[THEN cut2])
     done
 qed
 
 lemma SeqFormP_Eq:
   assumes "atom s \<sharp> (k,x,y)" "atom k \<sharp> (x,y)"
   shows "{TermP x, TermP y} \<turnstile> Ex k (Ex s (SeqFormP (Var s) (Var k) (Q_Eq x y)))"
 proof -
   let ?vs = "(x,y,s,k)"
   obtain l::name and sl::name and m::name and n::name and sm::name and sn::name
     where
       "atom l \<sharp> (?vs,sl,m,n,sm,sn)"
       "atom sl \<sharp> (?vs,m,n,sm,sn)"
       "atom m \<sharp> (?vs,n,sm,sn)" "atom n \<sharp> (?vs,sm,sn)"
       "atom sm \<sharp> (?vs,sn)"
       "atom sn \<sharp> (?vs)"
     by (metis obtain_fresh)
   with assms show ?thesis
     apply (auto simp: SeqFormP.simps[of l "Var s" _ _ sl m n sm sn])
     apply (rule Ex_I [where x = Zero], simp)
     apply (rule Ex_I [where x = "Eats Zero (HPair Zero (Q_Eq x y))"], auto intro!: Mem_SUCC_EH)
     apply (rule Ex_I [where x = "Q_Eq x y"], auto intro!: Mem_Eats_I2 HPair_cong Disj_I1 AtomicP_Eq[THEN cut2])
     done
 qed
 
 lemma FormP_Mem:
   "{TermP x, TermP y} \<turnstile> FormP (Q_Mem x y)"
 proof -
   obtain s::name and k::name
     where "atom s \<sharp> (x, y)" "atom k \<sharp> (s, x, y)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp add: FormP.simps [of k s] intro!: SeqFormP_Mem)
 qed
 
 lemma FormP_Eq:
   "{TermP x, TermP y} \<turnstile> FormP (Q_Eq x y)"
 proof -
   obtain s::name and k::name
     where "atom s \<sharp> (x, y)" "atom k \<sharp> (s, x, y)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp add: FormP.simps [of k s] intro!: SeqFormP_Eq)
 qed
 
 subsection \<open>MakeForm\<close>
 
 lemma MakeFormP_Neg: "{} \<turnstile> MakeFormP (Q_Neg x) x y"
 proof -
   obtain a::name and b::name
     where "atom a \<sharp> (x, y)" "atom b \<sharp> (a, x, y)" by (metis obtain_fresh)
   then show ?thesis
     by (auto simp: MakeFormP.simps[of a _ _ _ b] intro: Disj_I2[OF Disj_I1])
 qed
 
 lemma MakeFormP_Disj: "{} \<turnstile> MakeFormP (Q_Disj x y) x y"
 proof -
   obtain a::name and b::name
     where "atom a \<sharp> (x, y)" "atom b \<sharp> (a, x, y)" by (metis obtain_fresh)
   then show ?thesis
     by (auto simp: MakeFormP.simps[of a _ _ _ b] intro: Disj_I1)
 qed
 
 lemma MakeFormP_Ex: "{AbstFormP v Zero t x} \<turnstile> MakeFormP (Q_Ex x) t y"
 proof -
   obtain a::name and b::name
     where "atom a \<sharp> (v, x, t, y)" "atom b \<sharp> (a, v, x, t, y)" by (metis obtain_fresh)
   then show ?thesis
     by (subst MakeFormP.simps[of a _ _ _ b])
       (force intro!: Disj_I2[OF Disj_I2] intro: Ex_I[of _ _ _ v] Ex_I[of _ _ _ x])+
 qed
 
 subsection \<open>Negation\<close>
 
 lemma SeqFormP_Neg:
   assumes "atom s \<sharp> (k,s1,k1,x)" "atom k \<sharp> (s1,k1,x)"
   shows "{SeqFormP s1 k1 x} \<turnstile> Ex k (Ex s (SeqFormP (Var s) (Var k) (Q_Neg x)))" (*<*)
 proof -
   let ?vs = "(s1,k1,s,k,x)"
   obtain l::name and sl::name and m::name and n::name and
     sm::name and sn::name
     where atoms:
       "atom l \<sharp> (?vs,sl,m,n,sm,sn)"
       "atom sl \<sharp> (?vs,m,n,sm,sn)"
       "atom m \<sharp> (?vs,n,sm,sn)" "atom n \<sharp> (?vs,sm,sn)"
       "atom sm \<sharp> (?vs,sn)"
       "atom sn \<sharp> (?vs)"
     by (metis obtain_fresh)
   let ?hyp = "{RestrictedP s1 (SUCC k1) (Var s), OrdP k1, SeqFormP s1 k1 x}"
   show ?thesis
     using assms atoms
     apply (auto simp: SeqFormP.simps [of l "Var s" _ _ sl m n sm sn])
     apply (rule cut_same [where A="OrdP k1"])
     apply (rule SeqFormP_imp_OrdP)
     apply (rule cut_same [OF exists_RestrictedP [of s s1 "SUCC k1"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
     apply (rule Ex_I [where x="(SUCC k1)"])
       apply (simp_all (no_asm_simp))
       apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC k1)  (Q_Neg x))"])
       apply (simp_all (no_asm_simp))
     apply (rule Conj_I)
      apply (blast intro: RestrictedP_LstSeqP_Eats [THEN cut2] SeqFormP_imp_LstSeqP [THEN cut1])
   proof (rule All2_SUCC_I, simp_all)
     show "?hyp \<turnstile> SyntaxN.Ex sn
      (HPair (SUCC k1) (Var sn) IN
       Eats (Var s) (HPair (SUCC k1) (Q_Neg x)) AND
       (AtomicP (Var sn) OR
        SyntaxN.Ex m
         (SyntaxN.Ex l
           (SyntaxN.Ex sm
             (SyntaxN.Ex sl
               (Var m IN SUCC k1 AND
                Var l IN SUCC k1 AND
                HPair (Var m) (Var sm) IN
                Eats (Var s) (HPair (SUCC k1) (Q_Neg x)) AND
                HPair (Var l) (Var sl) IN
                Eats (Var s) (HPair (SUCC k1) (Q_Neg x)) AND
                MakeFormP (Var sn) (Var sm) (Var sl)))))))"
       \<comment> \<open>verifying the final values\<close>
       apply (rule Ex_I [where x="Q_Neg x"])
       using assms atoms apply simp
       apply (rule Conj_I, metis Mem_Eats_I2 Refl)
       apply (rule Disj_I2)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule Conj_I [OF Mem_SUCC_Refl])+
       apply (blast intro: Disj_I1 Disj_I2 Mem_Eats_I1 RestrictedP_Mem [THEN cut3] Mem_SUCC_Refl
           SeqFormP_imp_LstSeqP [THEN cut1] LstSeqP_imp_Mem MakeFormP_Neg[THEN thin0])
       done
   next
     show "?hyp \<turnstile> All2 n (SUCC k1)
      (SyntaxN.Ex sn
        (HPair (Var n) (Var sn) IN
         Eats (Var s) (HPair (SUCC k1) (Q_Neg x)) AND
         (AtomicP (Var sn) OR
          SyntaxN.Ex m
           (SyntaxN.Ex l
             (SyntaxN.Ex sm
               (SyntaxN.Ex sl
                 (Var m IN Var n AND
                  Var l IN Var n AND
                  HPair (Var m) (Var sm) IN
                  Eats (Var s) (HPair (SUCC k1) (Q_Neg x)) AND
                  HPair (Var l) (Var sl) IN
                  Eats (Var s) (HPair (SUCC k1) (Q_Neg x)) AND
                  MakeFormP (Var sn) (Var sm) (Var sl))))))))"
       \<comment> \<open>verifying the sequence buildup\<close>
       apply (rule All_I Imp_I)+
       using assms atoms apply simp_all
         \<comment> \<open>... the sequence buildup via s1\<close>
     apply (simp add: SeqFormP.simps [of l s1 _ _ sl m n sm sn])
       apply (rule AssumeH Ex_EH Conj_EH)+
       apply (rule All2_E [THEN rotate2], auto del: Disj_EH)
       apply (rule Ex_I [where x="Var sn"], simp)
       apply (rule Conj_I)
        apply (blast intro: Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] del: Disj_EH)
       apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH Conj_I)+
               apply (rule Ex_I [where x="Var m"], simp)
               apply (rule Ex_I [where x="Var l"], simp)
               apply (rule Ex_I [where x="Var sm"], simp)
               apply (rule Ex_I [where x="Var sl"], simp)
               apply auto
        apply (rule Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] AssumeH OrdP_Trans [OF OrdP_SUCC_I])+
       done
   qed
 qed (*>*)
 
 theorem FormP_Neg: "{FormP x} \<turnstile> FormP (Q_Neg x)"
 proof -
   obtain k1::name and s1::name and k::name and s::name
     where "atom s1 \<sharp> x"        "atom k1 \<sharp> (x,s1)"
       "atom s \<sharp> (x,k1,s1)"  "atom k  \<sharp> (x,s,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (force simp: FormP.simps [of k s "Q_Neg x"] FormP.simps [of k1 s1 x]
         intro: SeqFormP_Neg [THEN cut1])
 qed
 
 subsection \<open>Disjunction\<close>
 
 lemma SeqFormP_Disj:
   assumes "atom s \<sharp> (k,s1,s2,k1,k2,x,y)" "atom k \<sharp> (s1,s2,k1,k2,x,y)"
   shows "{SeqFormP s1 k1 x, SeqFormP s2 k2 y}
            \<turnstile> Ex k (Ex s (SeqFormP (Var s) (Var k) (Q_Disj x y)))" (*<*)
 proof -
   let ?vs = "(s1,s2,s,k1,k2,k,x,y)"
   obtain km::name and kn::name and j::name and k'::name
     and l::name and sl::name and m::name and n::name
     and sm::name and sn::name
     where atoms2: "atom km \<sharp> (kn,j,k',l,s1,s2,s,k1,k2,k,x,y,sl,m,n,sm,sn)"
       "atom kn \<sharp> (j,k',l,s1,s2,s,k1,k2,k,x,y,sl,m,n,sm,sn)"
       "atom j \<sharp> (k',l,s1,s2,s,k1,k2,k,x,y,sl,m,n,sm,sn)"
       and atoms: "atom k' \<sharp> (l,s1,s2,s,k1,k2,k,x,y,sl,m,n,sm,sn)"
       "atom l \<sharp> (s1,s2,s,k1,k2,k,x,y,sl,m,n,sm,sn)"
       "atom sl \<sharp> (s1,s2,s,k1,k2,k,x,y,m,n,sm,sn)"
       "atom m \<sharp> (s1,s2,s,k1,k2,k,x,y,n,sm,sn)"
       "atom n \<sharp> (s1,s2,s,k1,k2,k,x,y,sm,sn)"
       "atom sm \<sharp> (s1,s2,s,k1,k2,k,x,y,sn)"
       "atom sn \<sharp> (s1,s2,s,k1,k2,k,x,y)"
     by (metis obtain_fresh)
   let ?hyp = "{HaddP k1 k2 (Var k'), OrdP k1, OrdP k2, SeqAppendP s1 (SUCC k1) s2 (SUCC k2) (Var s),
                SeqFormP s1 k1 x, SeqFormP s2 k2 y}"
   show ?thesis
     using assms atoms
     apply (auto simp: SeqFormP.simps [of l "Var s" _ _ sl m n sm sn])
     apply (rule cut_same [where A="OrdP k1 AND OrdP k2"])
      apply (metis Conj_I SeqFormP_imp_OrdP thin1 thin2)
     apply (rule cut_same [OF exists_SeqAppendP [of s s1 "SUCC k1" s2 "SUCC k2"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
       apply (rule cut_same [OF exists_HaddP [where j=k' and x=k1 and y=k2]])
         apply (rule AssumeH Ex_EH Conj_EH | simp)+
         apply (rule Ex_I [where x="SUCC (SUCC (Var k'))"])
         apply (simp_all (no_asm_simp) add: )
     apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC(SUCC(Var k'))) (Q_Disj x y))"], simp)
     apply (rule Conj_I)
      apply (blast intro: LstSeqP_SeqAppendP_Eats SeqFormP_imp_LstSeqP [THEN cut1])
   proof (rule All2_SUCC_I, simp_all)
     show "?hyp \<turnstile> SyntaxN.Ex sn
      (HPair (SUCC (SUCC (Var k'))) (Var sn) IN
       Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (Q_Disj x y)) AND
       (AtomicP (Var sn) OR
        SyntaxN.Ex m
         (SyntaxN.Ex l
           (SyntaxN.Ex sm
             (SyntaxN.Ex sl
               (Var m IN SUCC (SUCC (Var k')) AND
                Var l IN SUCC (SUCC (Var k')) AND
                HPair (Var m) (Var sm) IN
                Eats (Var s)
                 (HPair (SUCC (SUCC (Var k'))) (Q_Disj x y)) AND
                HPair (Var l) (Var sl) IN
                Eats (Var s)
                 (HPair (SUCC (SUCC (Var k'))) (Q_Disj x y)) AND
                MakeFormP (Var sn) (Var sm) (Var sl)))))))"
       \<comment> \<open>verifying the final values\<close>
       apply (rule Ex_I [where x="Q_Disj x y"])
       using assms atoms apply simp
       apply (rule Conj_I, metis Mem_Eats_I2 Refl)
       apply (rule Disj_I2)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x="SUCC (Var k')"], simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule Ex_I [where x=y], simp)
       apply (rule Conj_I)
        apply (blast intro: HaddP_Mem_I LstSeqP_OrdP Mem_SUCC_I1)
       apply (rule Conj_I [OF Mem_SUCC_Refl])
       apply (blast intro: Disj_I1 Mem_Eats_I1 Mem_SUCC_Refl SeqFormP_imp_LstSeqP [THEN cut1]
           LstSeqP_imp_Mem SeqAppendP_Mem1 [THEN cut3] SeqAppendP_Mem2 [THEN cut4] HaddP_SUCC1 [THEN cut1]
           MakeFormP_Disj[THEN thin0])
       done
   next
     show "?hyp \<turnstile> All2 n (SUCC (SUCC (Var k')))
      (SyntaxN.Ex sn
        (HPair (Var n) (Var sn) IN
         Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (Q_Disj x y)) AND
         (AtomicP (Var sn) OR
          SyntaxN.Ex m
           (SyntaxN.Ex l
             (SyntaxN.Ex sm
               (SyntaxN.Ex sl
                 (Var m IN Var n AND
                  Var l IN Var n AND
                  HPair (Var m) (Var sm) IN
                  Eats (Var s)
                   (HPair (SUCC (SUCC (Var k'))) (Q_Disj x y)) AND
                  HPair (Var l) (Var sl) IN
                  Eats (Var s)
                   (HPair (SUCC (SUCC (Var k'))) (Q_Disj x y)) AND
                  MakeFormP (Var sn) (Var sm) (Var sl))))))))"
       \<comment> \<open>verifying the sequence buildup\<close>
       apply (rule cut_same [where A="HaddP (SUCC k1) (SUCC k2) (SUCC (SUCC (Var k')))"])
        apply (blast intro: HaddP_SUCC1 [THEN cut1] HaddP_SUCC2 [THEN cut1])
       apply (rule All_I Imp_I)+
        apply (rule HaddP_Mem_cases [where i=j])
       using assms atoms atoms2 apply simp_all
           apply (rule AssumeH)
          apply (blast intro: OrdP_SUCC_I LstSeqP_OrdP)
         \<comment> \<open>... the sequence buildup via s1\<close>
         apply (simp add: SeqFormP.simps [of l s1 _ _ sl m n sm sn])
         apply (rule AssumeH Ex_EH Conj_EH)+
         apply (rule All2_E [THEN rotate2])
           apply (simp | rule AssumeH Ex_EH Conj_EH)+
             apply (rule Ex_I [where x="Var sn"], simp)
             apply (rule Conj_I [OF Mem_Eats_I1])
              apply (metis SeqAppendP_Mem1 rotate3 thin2 thin4)
             apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
                         apply (rule Ex_I [where x="Var m"], simp)
                         apply (rule Ex_I [where x="Var l"], simp)
                         apply (rule Ex_I [where x="Var sm"], simp)
                         apply (rule Ex_I [where x="Var sl"], simp_all (no_asm_simp))
        apply (rule Conj_I, rule AssumeH)+
        apply (rule Conj_I)
         apply (blast intro: OrdP_Trans [OF OrdP_SUCC_I] Mem_Eats_I1 [OF SeqAppendP_Mem1 [THEN cut3]] Hyp)
        apply (blast intro: Disj_I1 Disj_I2 OrdP_Trans [OF OrdP_SUCC_I] Mem_Eats_I1 [OF SeqAppendP_Mem1 [THEN cut3]] Hyp)
         \<comment> \<open>... the sequence buildup via s2\<close>
       apply (simp add: SeqFormP.simps [of l s2 _ _ sl m n sm sn])
       apply (rule AssumeH Ex_EH Conj_EH)+
       apply (rule All2_E [THEN rotate2])
         apply (simp | rule AssumeH Ex_EH Conj_EH)+
           apply (rule Ex_I [where x="Var sn"], simp)
           apply (rule cut_same [where A="OrdP (Var j)"])
            apply (metis HaddP_imp_OrdP rotate2 thin2)
           apply (rule Conj_I)
            apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] del: Disj_EH)
           apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
                       apply (rule cut_same [OF exists_HaddP [where j=km and x="SUCC k1" and y="Var m"]])
                         apply (blast intro: Ord_IN_Ord, simp)
                 apply (rule cut_same [OF exists_HaddP [where j=kn and x="SUCC k1" and y="Var l"]])
                         apply (metis AssumeH(6) Ord_IN_Ord0 rotate8, simp)
                       apply (rule AssumeH Ex_EH Conj_EH | simp)+
                           apply (rule Ex_I [where x="Var km"], simp)
                           apply (rule Ex_I [where x="Var kn"], simp)
                           apply (rule Ex_I [where x="Var sm"], simp)
                           apply (rule Ex_I [where x="Var sl"], simp_all (no_asm_simp))
       apply (rule Conj_I [OF _ Conj_I])
         apply (blast intro!: HaddP_Mem_cancel_left [THEN Iff_MP2_same] OrdP_SUCC_I intro: LstSeqP_OrdP Hyp)+
       apply (blast del: Disj_EH  intro: OrdP_Trans Hyp
           intro!: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] HaddP_imp_OrdP [THEN cut1])
       done
   qed
 qed (*>*)
 
 theorem FormP_Disj:
   "{FormP x, FormP y} \<turnstile> FormP (Q_Disj x y)"
 proof -
   obtain k1::name and s1::name and k2::name and s2::name and k::name and s::name
     where "atom s1 \<sharp> (x,y)"        "atom k1 \<sharp> (x,y,s1)"
       "atom s2 \<sharp> (x,y,k1,s1)"  "atom k2 \<sharp> (x,y,s2,k1,s1)"
       "atom s  \<sharp> (x,y,k2,s2,k1,s1)" "atom k  \<sharp> (x,y,s,k2,s2,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (force simp: FormP.simps [of k s "Q_Disj x y"]
         FormP.simps [of k1 s1 x]
         FormP.simps [of k2 s2 y]
         intro: SeqFormP_Disj [THEN cut2])
 qed
 
 subsection \<open>Existential\<close>
 
 lemma SeqFormP_Ex:
   assumes "atom s \<sharp> (k,s1,k1,x,y,v)" "atom k \<sharp> (s1,k1,x,y,v)"
   shows "{SeqFormP s1 k1 x,AbstFormP v Zero x y, VarP v} \<turnstile> Ex k (Ex s (SeqFormP (Var s) (Var k) (Q_Ex y)))"
 proof -
   let ?vs = "(s1,s,k1,k,x,y,v)"
   obtain km::name and kn::name and j::name and k'::name
     and l::name and sl::name and m::name and n::name
     and sm::name and sn::name
     where atoms2: "atom km \<sharp> (kn,j,k',l,s1,s,k1,k,x,y,v,sl,m,n,sm,sn)"
       "atom kn \<sharp> (j,k',l,s1,s,k1,k,x,y,v,sl,m,n,sm,sn)"
       "atom j \<sharp> (k',l,s1,s,k1,k,x,y,v,sl,m,n,sm,sn)"
       and atoms: "atom k' \<sharp> (l,s1,s,k1,k,x,y,v,sl,m,n,sm,sn)"
       "atom l \<sharp> (s1,s,k1,k,x,y,v,sl,m,n,sm,sn)"
       "atom sl \<sharp> (s1,s,k1,k,x,y,v,m,n,sm,sn)"
       "atom m \<sharp> (s1,s,k1,k,x,y,v,n,sm,sn)"
       "atom n \<sharp> (s1,s,k1,k,x,y,v,sm,sn)"
       "atom sm \<sharp> (s1,s,k1,k,x,y,v,sn)"
       "atom sn \<sharp> (s1,s,k1,k,x,y,v)"
     by (metis obtain_fresh)
   let ?hyp = "{RestrictedP s1 (SUCC k1) (Var s), OrdP k1, SeqFormP s1 k1 x,AbstFormP v Zero x y, VarP v}"
   show ?thesis
     using assms atoms
     apply (auto simp: SeqFormP.simps [of l "Var s" _ _ sl m n sm sn])
     apply (rule cut_same [where A="OrdP k1"])
      apply (metis SeqFormP_imp_OrdP thin2)
     apply (rule cut_same [OF exists_RestrictedP [of s s1 "SUCC k1"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
       apply (rule Ex_I [where x="(SUCC k1)"], simp)
       apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC k1) (Q_Ex y))"], simp)
       apply (rule Conj_I)
        apply (blast intro: RestrictedP_LstSeqP_Eats [THEN cut2] SeqFormP_imp_LstSeqP [THEN cut1])
   proof (rule All2_SUCC_I, simp_all)
     show "?hyp \<turnstile>  SyntaxN.Ex sn
      (HPair (SUCC k1) (Var sn) IN
       Eats (Var s) (HPair (SUCC k1) (Q_Ex y)) AND
       (AtomicP (Var sn) OR
        SyntaxN.Ex m
         (SyntaxN.Ex l
           (SyntaxN.Ex sm
             (SyntaxN.Ex sl
               (Var m IN SUCC k1 AND
                Var l IN SUCC k1 AND
                HPair (Var m) (Var sm) IN
                Eats (Var s) (HPair (SUCC k1) (Q_Ex y)) AND
                HPair (Var l) (Var sl) IN
                Eats (Var s) (HPair (SUCC k1) (Q_Ex y)) AND
                MakeFormP (Var sn) (Var sm) (Var sl)))))))"
       \<comment> \<open>verifying the final values\<close>
       apply (rule Ex_I [where x="Q_Ex y"])
       using assms atoms apply simp
       apply (rule Conj_I, metis Mem_Eats_I2 Refl)
       apply (rule Disj_I2)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x=k1], simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule Ex_I [where x=x], simp)
       apply (rule Conj_I [OF Mem_SUCC_Refl])+
       apply safe
       apply (blast intro: Disj_I2 Mem_Eats_I1 RestrictedP_Mem [THEN cut3] Mem_SUCC_Refl
           SeqFormP_imp_LstSeqP [THEN cut1] LstSeqP_imp_Mem)
       apply (blast intro: Disj_I2 Mem_Eats_I1 RestrictedP_Mem [THEN cut3] Mem_SUCC_Refl
           SeqFormP_imp_LstSeqP [THEN cut1] LstSeqP_imp_Mem)
       apply (rule MakeFormP_Ex[THEN cut1, of _ v])
       apply blast
       done
   next
     show "?hyp \<turnstile> All2 n (SUCC k1)
      (SyntaxN.Ex sn
        (HPair (Var n) (Var sn) IN
         Eats (Var s) (HPair (SUCC k1) (Q_Ex y)) AND
         (AtomicP (Var sn) OR
          SyntaxN.Ex m
           (SyntaxN.Ex l
             (SyntaxN.Ex sm
               (SyntaxN.Ex sl
                 (Var m IN Var n AND
                  Var l IN Var n AND
                  HPair (Var m) (Var sm) IN
                  Eats (Var s) (HPair (SUCC k1) (Q_Ex y)) AND
                  HPair (Var l) (Var sl) IN
                  Eats (Var s) (HPair (SUCC k1) (Q_Ex y)) AND
                  MakeFormP (Var sn) (Var sm) (Var sl))))))))"
       apply (rule All_I Imp_I)+
       using assms atoms apply simp_all
         \<comment> \<open>... the sequence buildup via s1\<close>
       apply (simp add: SeqFormP.simps [of l s1 _ _ sl m n sm sn])
       apply (rule AssumeH Ex_EH Conj_EH)+
       apply (rule All2_E [THEN rotate2], auto del: Disj_EH)
       apply (rule Ex_I [where x="Var sn"], simp)
       apply (rule Conj_I)
        apply (blast intro: Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] del: Disj_EH)
       apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH Conj_I)+
               apply (rule Ex_I [where x="Var m"], simp)
               apply (rule Ex_I [where x="Var l"], simp)
               apply (rule Ex_I [where x="Var sm"], simp)
               apply (rule Ex_I [where x="Var sl"], simp)
               apply auto
        apply (rule Mem_Eats_I1 [OF RestrictedP_Mem [THEN cut3]] AssumeH OrdP_Trans [OF OrdP_SUCC_I])+
       done
   qed
 qed (*>*)
 
-theorem FormP_Ex: "{FormP t, AbstFormP \<lceil>Var i\<rceil> Zero t x} \<turnstile> FormP (Q_Ex x)"
+theorem FormP_Ex: "{FormP t, AbstFormP \<guillemotleft>Var i\<guillemotright> Zero t x} \<turnstile> FormP (Q_Ex x)"
 proof -
   obtain k1::name and s1::name and k::name and s::name
     where "atom s1 \<sharp> (i,t,x)" "atom k1 \<sharp> (i,t,x,s1)" "atom s  \<sharp> (i,t,x,k1,s1)"  "atom k \<sharp> (i,t,x,s,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: FormP.simps [of k s "Q_Ex x"] FormP.simps [of k1 s1 t]
       intro!: SeqFormP_Ex [THEN cut3])
 qed
 
 lemma FormP_quot_dbfm:
   fixes A :: dbfm
   shows "wf_dbfm A \<Longrightarrow> {} \<turnstile> FormP (quot_dbfm A)"
   by (induct A rule: wf_dbfm.induct)
     (auto simp: intro!: FormP_Mem[THEN cut2] FormP_Eq[THEN cut2] Ex_I
       FormP_Neg[THEN cut1] FormP_Disj[THEN cut2] FormP_Ex[THEN cut2]
       TermP_quot_dbtm AbstFormP_dbfm[where n=0, simplified])
 
 lemma FormP_quot:
   fixes A :: fm
-  shows "{} \<turnstile> FormP \<lceil>A\<rceil>"
+  shows "{} \<turnstile> FormP \<guillemotleft>A\<guillemotright>"
   unfolding quot_fm_def
   by (rule FormP_quot_dbfm, rule wf_dbfm_trans_fm)
 
 
 lemma PfP_I:
   assumes "{} \<turnstile> PrfP S K A"
   shows "{} \<turnstile> PfP A"
 proof -
   obtain s::name and k::name where "atom s \<sharp> (k,A,S,K)" "atom k \<sharp> (A,S,K)" by (metis obtain_fresh)
   with assms show ?thesis
     apply (subst PfP.simps[of s k]; simp)
     apply (rule Ex_I[of _ _ _ K], auto, rule Ex_I[of _ _ _ S], auto)
     done
 qed
 
-lemmas PfP_Single_I = PfP_I[of "Eats Zero (HPair Zero \<lceil>A\<rceil>)" Zero for A]
-
-lemma PfP_extra: "{} \<turnstile> PfP \<lceil>extra_axiom\<rceil>"
+lemmas PfP_Single_I = PfP_I[of "Eats Zero (HPair Zero \<guillemotleft>A\<guillemotright>)" Zero for A]
+
+lemma PfP_extra: "{} \<turnstile> PfP \<guillemotleft>extra_axiom\<guillemotright>"
 proof -
   obtain l::name and sl::name and m::name and n::name and sm::name and sn::name
     where atoms:
       "atom l \<sharp> (sl,m,n,sm,sn)"
       "atom sl \<sharp> (m,n,sm,sn)"
       "atom m \<sharp> (n,sm,sn)"
       "atom n \<sharp> (sm,sn)"
       "atom sm \<sharp> sn"
     by (metis obtain_fresh)
   with Extra show ?thesis
     apply (intro PfP_Single_I[of extra_axiom])
     apply (subst PrfP.simps[of l _ sl m n sm sn]; auto?)
-    apply (rule Ex_I[of _ _ _ "\<lceil>extra_axiom\<rceil>"]; auto?)
+    apply (rule Ex_I[of _ _ _ "\<guillemotleft>extra_axiom\<guillemotright>"]; auto?)
      apply (rule Mem_SUCC_E[OF Mem_Zero_E])
      apply (rule Mem_Eats_I2)
      apply (rule HPair_cong[OF Assume Refl])
     apply (auto simp: AxiomP_def intro!: Disj_I1)
     done
 qed
 
 lemma SentP_I:
   assumes "A \<in> boolean_axioms"
-  shows "{} \<turnstile> SentP \<lceil>A\<rceil>"
+  shows "{} \<turnstile> SentP \<guillemotleft>A\<guillemotright>"
 proof -
   obtain x y z :: name where "atom z \<sharp> (x,y)" "atom y \<sharp> x" by (metis obtain_fresh)
   with assms show ?thesis
     apply (subst SentP.simps[of x y z]; simp)
     subgoal
     proof (erule boolean_axioms.cases, goal_cases Ident DisjI1 DisjCont DisjAssoc DisjConj)
       case (Ident A)
       then show ?thesis
-        by (intro Ex_I[of _ _ _ "\<lceil>A\<rceil>"]; simp)+
+        by (intro Ex_I[of _ _ _ "\<guillemotleft>A\<guillemotright>"]; simp)+
           (auto simp: FormP_quot[THEN thin0] quot_simps intro!: Disj_I1)
     next
       case (DisjI1 A B)
       then show ?thesis
-        by (intro Ex_I[of _ _ _ "\<lceil>A\<rceil>"]; simp, (intro Ex_I[of _ _ _ "\<lceil>B\<rceil>"]; simp)?)+
+        by (intro Ex_I[of _ _ _ "\<guillemotleft>A\<guillemotright>"]; simp, (intro Ex_I[of _ _ _ "\<guillemotleft>B\<guillemotright>"]; simp)?)+
           (auto simp: FormP_quot[THEN thin0] quot_simps intro!: Disj_I2[OF Disj_I1])
     next
       case (DisjCont A)
       then show ?thesis
-        by (intro Ex_I[of _ _ _ "\<lceil>A\<rceil>"]; simp)+
+        by (intro Ex_I[of _ _ _ "\<guillemotleft>A\<guillemotright>"]; simp)+
           (auto simp: FormP_quot[THEN thin0] quot_simps intro!: Disj_I2[OF Disj_I2[OF Disj_I1]])
     next
       case (DisjAssoc A B C)
       then show ?thesis
-        by (intro Ex_I[of _ _ _ "\<lceil>A\<rceil>"]; simp, intro Ex_I[of _ _ _ "\<lceil>B\<rceil>"]; simp, intro Ex_I[of _ _ _ "\<lceil>C\<rceil>"]; simp)+
+        by (intro Ex_I[of _ _ _ "\<guillemotleft>A\<guillemotright>"]; simp, intro Ex_I[of _ _ _ "\<guillemotleft>B\<guillemotright>"]; simp, intro Ex_I[of _ _ _ "\<guillemotleft>C\<guillemotright>"]; simp)+
           (auto simp: FormP_quot[THEN thin0] quot_simps intro!: Disj_I2[OF Disj_I2[OF Disj_I2[OF Disj_I1]]])
     next
       case (DisjConj A B C)
       then show ?thesis
-        by (intro Ex_I[of _ _ _ "\<lceil>A\<rceil>"]; simp, intro Ex_I[of _ _ _ "\<lceil>B\<rceil>"]; simp, intro Ex_I[of _ _ _ "\<lceil>C\<rceil>"]; simp)+
+        by (intro Ex_I[of _ _ _ "\<guillemotleft>A\<guillemotright>"]; simp, intro Ex_I[of _ _ _ "\<guillemotleft>B\<guillemotright>"]; simp, intro Ex_I[of _ _ _ "\<guillemotleft>C\<guillemotright>"]; simp)+
           (auto simp: FormP_quot[THEN thin0] quot_simps intro!: Disj_I2[OF Disj_I2[OF Disj_I2[OF Disj_I2]]])
     qed
     done
 qed
 
 lemma SentP_subst [simp]: "(SentP A)(j::=w) = SentP (subst j w A)"
 proof -
   obtain x y z ::name where "atom x \<sharp> (y,z,j,w,A)" "atom y \<sharp> (z,j,w,A)"  "atom z \<sharp> (j,w,A)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: SentP.simps [of x y z])
 qed
 
 theorem proved_imp_proved_PfP:
   assumes "{} \<turnstile> \<alpha>"
-  shows "{} \<turnstile> PfP \<lceil>\<alpha>\<rceil>"
+  shows "{} \<turnstile> PfP \<guillemotleft>\<alpha>\<guillemotright>"
   using assms
 proof (induct "{} :: fm set" \<alpha> rule: hfthm.induct)
   case (Hyp A)
   then show ?case
     by auto
 next
   case Extra
   then show ?case by (simp add: PfP_extra)
 next
   case (Bool A)
   obtain l::name and sl::name and m::name and n::name and
          sm::name and sn::name and x::name and y::name and z::name
          where atoms:
           "atom l \<sharp> (x,y,z,sl,m,n,sm,sn)"
          "atom sl \<sharp> (x,y,z,m,n,sm,sn)"
           "atom m \<sharp> (x,y,z,n,sm,sn)"
           "atom n \<sharp> (x,y,z,sm,sn)"
          "atom sm \<sharp> (x,y,z,sn)"
          "atom sn \<sharp> (x,y,z)"
           "atom z \<sharp> (x,y)"
           "atom y \<sharp> x"
     by (metis obtain_fresh)
   with Bool show ?case
     apply (intro PfP_Single_I[of A])
     apply (subst PrfP.simps[of l _ sl m n sm sn]; auto?)
-    apply (rule Ex_I[of _ _ _ "\<lceil>A\<rceil>"]; auto?)
+    apply (rule Ex_I[of _ _ _ "\<guillemotleft>A\<guillemotright>"]; auto?)
      apply (rule Mem_SUCC_E[OF Mem_Zero_E])
      apply (rule Mem_Eats_I2)
      apply (rule HPair_cong[OF Assume Refl])
     apply (rule Disj_I1)
     apply (unfold AxiomP_def; simp)
     apply (rule Disj_I2[OF Disj_I1])
     apply (auto elim!: SentP_I[THEN thin0])
     done
 next
   case (Eq A)
   obtain l::name and sl::name and m::name and n::name and sm::name and sn::name and x::name and y::name and z::name
          where atoms:
           "atom l \<sharp> (x,y,z,sl,m,n,sm,sn)"
          "atom sl \<sharp> (x,y,z,m,n,sm,sn)"
           "atom m \<sharp> (x,y,z,n,sm,sn)"
           "atom n \<sharp> (x,y,z,sm,sn)"
          "atom sm \<sharp> (x,y,z,sn)"
          "atom sn \<sharp> (x,y,z)"
           "atom z \<sharp> (x,y)"
           "atom y \<sharp> x"
     by (metis obtain_fresh)
   with Eq show ?case
     apply (intro PfP_Single_I[of A])
     apply (subst PrfP.simps[of l _ sl m n sm sn]; auto?)
-    apply (rule Ex_I[of _ _ _ "\<lceil>A\<rceil>"]; auto?)
+    apply (rule Ex_I[of _ _ _ "\<guillemotleft>A\<guillemotright>"]; auto?)
      apply (rule Mem_SUCC_E[OF Mem_Zero_E])
      apply (rule Mem_Eats_I2)
      apply (rule HPair_cong[OF Assume Refl])
     apply (rule Disj_I1)
     apply (unfold AxiomP_def; simp)
     apply (rule Disj_I2[OF Disj_I2[OF Disj_I1]])
     apply (auto simp: equality_axioms_def
       intro: Disj_I1 Disj_I2[OF Disj_I1] Disj_I2[OF Disj_I2[OF Disj_I1]] Disj_I2[OF Disj_I2[OF Disj_I2]])
     done
 next
   case (Spec A)
   obtain l::name and sl::name and m::name and n::name and
          sm::name and sn::name and x::name and y::name and z::name
          where atoms:
           "atom l \<sharp> (x,y,z,sl,m,n,sm,sn)"
          "atom sl \<sharp> (x,y,z,m,n,sm,sn)"
           "atom m \<sharp> (x,y,z,n,sm,sn)"
           "atom n \<sharp> (x,y,z,sm,sn)"
          "atom sm \<sharp> (x,y,z,sn)"
          "atom sn \<sharp> (x,y,z)"
           "atom z \<sharp> (x,y)"
           "atom y \<sharp> x"
     by (metis obtain_fresh)
   let ?vs = "(x,y,z,l,sl,m,n,sm,sn)"
   from Spec atoms show ?case
     apply (intro PfP_Single_I[of A])
     apply (subst PrfP.simps[of l _ sl m n sm sn]; auto?)
-    apply (rule Ex_I[of _ _ _ "\<lceil>A\<rceil>"]; auto?)
+    apply (rule Ex_I[of _ _ _ "\<guillemotleft>A\<guillemotright>"]; auto?)
      apply (rule Mem_SUCC_E[OF Mem_Zero_E])
      apply (rule Mem_Eats_I2)
      apply (rule HPair_cong[OF Assume Refl])
     apply (rule Disj_I1)
     apply (unfold AxiomP_def; simp)
     apply (rule Disj_I2[OF Disj_I2[OF Disj_I2[OF Disj_I2[OF Disj_I1]]]])
     subgoal premises prems
     using prems proof (cases A rule: special_axioms.cases)
     case (I X i t)
     let ?vs' = "(?vs, X, i, t)"
       obtain AA XX ii tt res :: name
         where atoms:
           "atom AA \<sharp> (?vs', res, tt, ii, XX)"
           "atom XX \<sharp> (?vs', res, tt, ii)"
           "atom ii \<sharp> (?vs', res, tt)"
           "atom tt \<sharp> (?vs', res)"
           "atom res \<sharp> ?vs'"
         by (metis obtain_fresh)
       with I show ?thesis
         apply (subst Special_axP.simps[of ii _ res tt AA XX]; simp?)
-        apply (rule Ex_I[of _ _ _ "\<lceil>Var i\<rceil>"]; auto?)
-        apply (rule Ex_I[of _ _ _ "\<lceil>X\<rceil>"]; auto?)
+        apply (rule Ex_I[of _ _ _ "\<guillemotleft>Var i\<guillemotright>"]; auto?)
+        apply (rule Ex_I[of _ _ _ "\<guillemotleft>X\<guillemotright>"]; auto?)
         apply (rule Ex_I[of _ _ _ "quot_dbfm (trans_fm [i] X)"]; auto?)
-        apply (rule Ex_I[of _ _ _ "\<lceil>t\<rceil>"]; auto?)
-        apply (rule Ex_I[of _ _ _ "\<lceil>X(i::=t)\<rceil>"]; auto?)
+        apply (rule Ex_I[of _ _ _ "\<guillemotleft>t\<guillemotright>"]; auto?)
+        apply (rule Ex_I[of _ _ _ "\<guillemotleft>X(i::=t)\<guillemotright>"]; auto?)
             apply (auto simp: TermP_quot[THEN thin0] FormP_quot[THEN thin0]
                SubstFormP[THEN thin0] AbstFormP[THEN thin0]
                quot_Ex quot_Disj quot_Neg vquot_fm_def)
         done
     qed
     done
 next
   case (HF A)
   obtain l::name and sl::name and m::name and n::name and
          sm::name and sn::name and x::name and y::name and z::name
          where atoms:
           "atom l \<sharp> (x,y,z,sl,m,n,sm,sn)"
          "atom sl \<sharp> (x,y,z,m,n,sm,sn)"
           "atom m \<sharp> (x,y,z,n,sm,sn)"
           "atom n \<sharp> (x,y,z,sm,sn)"
          "atom sm \<sharp> (x,y,z,sn)"
          "atom sn \<sharp> (x,y,z)"
           "atom z \<sharp> (x,y)"
           "atom y \<sharp> x"
     by (metis obtain_fresh)
   with HF show ?case
     apply (intro PfP_Single_I[of A])
     apply (subst PrfP.simps[of l _ sl m n sm sn]; auto?)
-    apply (rule Ex_I[of _ _ _ "\<lceil>A\<rceil>"]; auto?)
+    apply (rule Ex_I[of _ _ _ "\<guillemotleft>A\<guillemotright>"]; auto?)
      apply (rule Mem_SUCC_E[OF Mem_Zero_E])
      apply (rule Mem_Eats_I2)
      apply (rule HPair_cong[OF Assume Refl])
     apply (rule Disj_I1)
     apply (unfold AxiomP_def; simp)
     apply (rule Disj_I2[OF Disj_I2[OF Disj_I2[OF Disj_I1]]])
     apply (auto simp: HF_axioms_def intro: Disj_I1 Disj_I2)
     done
 next
   case (Ind A)
   obtain l::name and sl::name and m::name and n::name and
          sm::name and sn::name and x::name and y::name and z::name
          where atoms:
           "atom l \<sharp> (x,y,z,sl,m,n,sm,sn)"
          "atom sl \<sharp> (x,y,z,m,n,sm,sn)"
           "atom m \<sharp> (x,y,z,n,sm,sn)"
           "atom n \<sharp> (x,y,z,sm,sn)"
          "atom sm \<sharp> (x,y,z,sn)"
          "atom sn \<sharp> (x,y,z)"
           "atom z \<sharp> (x,y)"
           "atom y \<sharp> x"
     by (metis obtain_fresh)
   let ?vs = "(x,y,z,l,sl,m,n,sm,sn)"
   from Ind atoms show ?case
     apply (intro PfP_Single_I[of A])
     apply (subst PrfP.simps[of l _ sl m n sm sn]; auto?)
-    apply (rule Ex_I[of _ _ _ "\<lceil>A\<rceil>"]; auto?)
+    apply (rule Ex_I[of _ _ _ "\<guillemotleft>A\<guillemotright>"]; auto?)
      apply (rule Mem_SUCC_E[OF Mem_Zero_E])
      apply (rule Mem_Eats_I2)
      apply (rule HPair_cong[OF Assume Refl])
     apply (rule Disj_I1)
     apply (unfold AxiomP_def; simp)
     apply (rule Disj_I2[OF Disj_I2[OF Disj_I2[OF  Disj_I2[OF Disj_I2]]]])
     subgoal premises prems
     using prems proof (cases A rule: induction_axioms.cases)
       case (ind j i X)
       let ?vs' = "(?vs, X, i, j)"
       obtain ax allvw allw xevw xw x0 xa w v :: name
         where atoms:
           "atom ax \<sharp> (?vs', v, w, xa, x0, xw, xevw, allw, allvw)"
           "atom allvw \<sharp> (?vs', v, w, xa, x0, xw, xevw, allw)"
           "atom allw \<sharp> (?vs', v, w, xa, x0, xw, xevw)"
           "atom xevw \<sharp> (?vs', v, w, xa, x0, xw)"
           "atom xw \<sharp> (?vs', v, w, xa, x0)"
           "atom x0 \<sharp> (?vs', v, w, xa)"
           "atom xa \<sharp> (?vs', v, w)"
           "atom w \<sharp> (?vs', v)"
           "atom v \<sharp> (?vs')"
         by (metis obtain_fresh)
       with ind(2) show ?thesis
         unfolding ind(1)
         apply (subst Induction_axP.simps[of ax _ allvw allw xevw xw x0 xa w v])
                  apply simp_all
-        apply (rule Ex_I[of _ _ _ "\<lceil>Var i\<rceil>"]; auto?)
-        apply (rule Ex_I[of _ _ _ "\<lceil>Var j\<rceil>"]; auto?)
-        apply (rule Ex_I[of _ _ _ "\<lceil>X\<rceil>"]; auto?)
-        apply (rule Ex_I[of _ _ _ "\<lceil>X(i::=Zero)\<rceil>"]; auto?)
-        apply (rule Ex_I[of _ _ _ "\<lceil>X(i::=Var j)\<rceil>"]; auto?)
-        apply (rule Ex_I[of _ _ _ "\<lceil>X(i::=Eats (Var i) (Var j))\<rceil>"]; auto?)
+        apply (rule Ex_I[of _ _ _ "\<guillemotleft>Var i\<guillemotright>"]; auto?)
+        apply (rule Ex_I[of _ _ _ "\<guillemotleft>Var j\<guillemotright>"]; auto?)
+        apply (rule Ex_I[of _ _ _ "\<guillemotleft>X\<guillemotright>"]; auto?)
+        apply (rule Ex_I[of _ _ _ "\<guillemotleft>X(i::=Zero)\<guillemotright>"]; auto?)
+        apply (rule Ex_I[of _ _ _ "\<guillemotleft>X(i::=Var j)\<guillemotright>"]; auto?)
+        apply (rule Ex_I[of _ _ _ "\<guillemotleft>X(i::=Eats (Var i) (Var j))\<guillemotright>"]; auto?)
         apply (rule Ex_I[of _ _ _ "quot_dbfm (trans_fm [j] (X IMP (X(i::= Var j) IMP X(i::= Eats(Var i)(Var j)))))"]; auto?)
         apply (rule Ex_I[of _ _ _ "Q_All (quot_dbfm (trans_fm [j,i] (X IMP (X(i::= Var j) IMP X(i::= Eats(Var i)(Var j))))))"]; auto?)
         apply (rule Ex_I[of _ _ _ "quot_dbfm (trans_fm [i] X)"]; auto?)
         subgoal
           apply (rule thin0)
           apply (rule OrdNotEqP_I)
             apply (auto simp: quot_Var ORD_OF_EQ_diff intro!: OrdP_SUCC_I0[THEN cut1])
           done
         subgoal
           by (auto simp: VarNonOccFormP.simps FormP_quot[THEN thin0] SubstFormP_trivial[THEN thin0])
         subgoal
           by (rule SubstFormP_Zero[THEN thin0])
         subgoal
           by (rule SubstFormP[THEN thin0])
         subgoal
           unfolding quot_Eats[symmetric] One_nat_def[symmetric]
           by (rule SubstFormP[THEN thin0])
         subgoal
           unfolding quot_simps[symmetric] quot_dbfm.simps[symmetric] trans_fm.simps[symmetric]
           by (rule AbstFormP[THEN thin0])
         subgoal
           by (auto simp only: quot_simps[symmetric] quot_dbfm.simps[symmetric] trans_fm.simps[symmetric]
             fresh_Cons fresh_Nil fresh_Pair trans_fm.simps(5)[symmetric, of j "[]"]
             quot_fm_def[symmetric] intro!: AbstFormP[THEN thin0])
         subgoal
           unfolding quot_simps[symmetric] quot_dbfm.simps[symmetric] trans_fm.simps[symmetric]
           by (rule AbstFormP[THEN thin0])
         subgoal
           by (auto simp: quot_simps trans_fm.simps(5)[of j "[i]"]
             fresh_Cons fresh_Pair)
         done
     qed
     done
 next
   case (MP H A B H')
   then show ?case
     by (auto elim!: PfP_implies_ModPon_PfP_quot)
 next
   case (Exists A B i)
   obtain a x y z::name
     where atoms:
       "atom a \<sharp> (i,x,y,z)"
       "atom z \<sharp> (i,x,y)"
       "atom y \<sharp> (i,x)"
       "atom x \<sharp> i"
     by (metis obtain_fresh)
   with Exists show ?case
     apply (auto elim!: PfP_inference [THEN cut3] intro!: PfP_extra Disj_I2[OF Disj_I1])
     apply (subst ExistsP.simps[of x _ _ a y z]; (auto simp: VarNonOccFormP.simps)?)
-    apply (rule Ex_I[of _ _ _ "\<lceil>A\<rceil>"]; auto?)
+    apply (rule Ex_I[of _ _ _ "\<guillemotleft>A\<guillemotright>"]; auto?)
     apply (rule Ex_I[of _ _ _ "quot_dbfm (trans_fm [i] A)"]; auto?)
-    apply (rule Ex_I[of _ _ _ "\<lceil>B\<rceil>"]; auto?)
-    apply (rule Ex_I[of _ _ _ "\<lceil>Var i\<rceil>"]; auto?)
+    apply (rule Ex_I[of _ _ _ "\<guillemotleft>B\<guillemotright>"]; auto?)
+    apply (rule Ex_I[of _ _ _ "\<guillemotleft>Var i\<guillemotright>"]; auto?)
          apply (auto simp: FormP_quot quot_Disj quot_Neg quot_Ex SubstFormP_trivial AbstFormP)
     done
 qed
 
 end
 
diff --git a/thys/Goedel_HFSet_Semanticless/Pf_Predicates.thy b/thys/Goedel_HFSet_Semanticless/Pf_Predicates.thy
--- a/thys/Goedel_HFSet_Semanticless/Pf_Predicates.thy
+++ b/thys/Goedel_HFSet_Semanticless/Pf_Predicates.thy
@@ -1,331 +1,331 @@
 chapter\<open>Formalizing Provability\<close>
 
 theory Pf_Predicates
 imports Coding_Predicates
 begin
 
 section \<open>Section 4 Predicates (Leading up to Pf)\<close>
 
 subsection \<open>The predicate \<open>SentP\<close>, for the Sentiential (Boolean) Axioms\<close>
 
 nominal_function SentP :: "tm \<Rightarrow> fm"
   where "\<lbrakk>atom y \<sharp> (z,w,x); atom z \<sharp> (w,x); atom w \<sharp> x\<rbrakk> \<Longrightarrow>
     SentP x = Ex y (Ex z (Ex w (FormP (Var y) AND FormP (Var z) AND FormP (Var w) AND
                ( (x EQ Q_Imp (Var y) (Var y)) OR
                  (x EQ Q_Imp (Var y) (Q_Disj (Var y) (Var z)) OR
                  (x EQ Q_Imp (Q_Disj (Var y) (Var y)) (Var y)) OR
                  (x EQ Q_Imp (Q_Disj (Var y) (Q_Disj (Var z) (Var w)))
                              (Q_Disj (Q_Disj (Var y) (Var z)) (Var w))) OR
                  (x EQ Q_Imp (Q_Disj (Var y) (Var z))
                              (Q_Imp (Q_Disj (Q_Neg (Var y)) (Var w)) (Q_Disj (Var z) (Var w)))))))))"
   by (auto simp: eqvt_def SentP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma
  shows SentP_fresh_iff [simp]: "a \<sharp> SentP x \<longleftrightarrow> a \<sharp> x"                  (is ?thesis1)
    and SentP_sf [iff]:         "Sigma_fm (SentP x)"                     (is ?thsf)
 proof -
   obtain y::name and z::name and w::name  where "atom y \<sharp> (z,w,x)" "atom z \<sharp> (w,x)" "atom w \<sharp> x"
     by (metis obtain_fresh)
   thus ?thesis1 ?thsf
     by auto
 qed
 
 subsection \<open>The predicate \<open>Equality_axP\<close>, for the Equality Axioms\<close>
 
 function Equality_axP :: "tm \<Rightarrow> fm"
   where "Equality_axP x =
-    x EQ \<lceil>refl_ax\<rceil> OR x EQ \<lceil>eq_cong_ax\<rceil> OR x EQ \<lceil>mem_cong_ax\<rceil> OR x EQ \<lceil>eats_cong_ax\<rceil>"
+    x EQ \<guillemotleft>refl_ax\<guillemotright> OR x EQ \<guillemotleft>eq_cong_ax\<guillemotright> OR x EQ \<guillemotleft>mem_cong_ax\<guillemotright> OR x EQ \<guillemotleft>eats_cong_ax\<guillemotright>"
 by auto
 
 termination
   by lexicographic_order
 
 subsection \<open>The predicate \<open>HF_axP\<close>, for the HF Axioms\<close>
 
 function HF_axP :: "tm \<Rightarrow> fm"
-  where "HF_axP x = x EQ \<lceil>HF1\<rceil> OR x EQ \<lceil>HF2\<rceil>"
+  where "HF_axP x = x EQ \<guillemotleft>HF1\<guillemotright> OR x EQ \<guillemotleft>HF2\<guillemotright>"
 by auto
 
 termination
   by lexicographic_order
 
 lemma HF_axP_sf [iff]: "Sigma_fm (HF_axP t)"
   by auto
 
 
 subsection \<open>The specialisation axioms\<close>
 
 subsubsection \<open>Defining the syntax\<close>
 
 nominal_function Special_axP :: "tm \<Rightarrow> fm" where
   "\<lbrakk>atom v \<sharp> (p,sx,y,ax,x); atom x \<sharp> (p,sx,y,ax);
     atom ax \<sharp> (p,sx,y); atom y \<sharp> (p,sx); atom sx \<sharp> p\<rbrakk> \<Longrightarrow>
   Special_axP p = Ex v (Ex x (Ex ax (Ex y (Ex sx
                    (FormP (Var x) AND VarP (Var v) AND TermP (Var y) AND
                     AbstFormP (Var v) Zero (Var x) (Var ax) AND
                     SubstFormP (Var v) (Var y) (Var x) (Var sx) AND
                     p EQ Q_Imp (Var sx) (Q_Ex (Var ax)))))))"
   by (auto simp: eqvt_def Special_axP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma
  shows Special_axP_fresh_iff [simp]: "a \<sharp> Special_axP p \<longleftrightarrow> a \<sharp> p" (is ?thesis1)
    and Special_axP_sf [iff]:       "Sigma_fm (Special_axP p)" (is ?thesis3)
 proof -
   obtain v::name and x::name and ax::name and y::name and sx::name
     where "atom v \<sharp> (p,sx,y,ax,x)" "atom x \<sharp> (p,sx,y,ax)"
           "atom ax \<sharp> (p,sx,y)" "atom y \<sharp> (p,sx)" "atom sx \<sharp> p"
     by (metis obtain_fresh)
   thus ?thesis1 ?thesis3
     by auto
 qed
 
 subsection \<open>The induction axioms\<close>
 
 subsubsection \<open>Defining the syntax\<close>
 
 nominal_function Induction_axP :: "tm \<Rightarrow> fm" where
   "\<lbrakk>atom ax \<sharp> (p,v,w,x,x0,xw,xevw,allw,allvw);
     atom allvw \<sharp> (p,v,w,x,x0,xw,xevw,allw); atom allw \<sharp> (p,v,w,x,x0,xw,xevw);
     atom xevw \<sharp> (p,v,w,x,x0,xw); atom xw \<sharp> (p,v,w,x,x0);
     atom x0 \<sharp> (p,v,w,x); atom x \<sharp> (p,v,w);
     atom w \<sharp> (p,v); atom v \<sharp> p\<rbrakk> \<Longrightarrow>
   Induction_axP p = Ex v (Ex w (Ex x (Ex x0 (Ex xw (Ex xevw (Ex allw (Ex allvw (Ex ax
                ((Var v NEQ Var w) AND VarNonOccFormP (Var w) (Var x) AND
                 SubstFormP (Var v) Zero (Var x) (Var x0) AND
                 SubstFormP (Var v) (Var w) (Var x) (Var xw) AND
                 SubstFormP (Var v) (Q_Eats (Var v) (Var w)) (Var x) (Var xevw) AND
                 AbstFormP (Var w) Zero (Q_Imp (Var x) (Q_Imp (Var xw) (Var xevw))) (Var allw) AND
                 AbstFormP (Var v) Zero (Q_All (Var allw)) (Var allvw) AND
                 AbstFormP (Var v) Zero (Var x) (Var ax) AND
                 p EQ Q_Imp (Var x0) (Q_Imp (Q_All (Var allvw)) (Q_All (Var ax))))))))))))"
   by (auto simp: eqvt_def Induction_axP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma
  shows Induction_axP_fresh_iff [simp]: "a \<sharp> Induction_axP p \<longleftrightarrow> a \<sharp> p" (is ?thesis1)
    and Induction_axP_sf [iff]: "Sigma_fm (Induction_axP p)" (is ?thesis3)
 proof -
   obtain v::name and w::name and x::name and x0::name and xw::name and xevw::name
                  and allw::name and allvw::name and ax::name
     where atoms: "atom ax \<sharp> (p,v,w,x,x0,xw,xevw,allw,allvw)"
                  "atom allvw \<sharp> (p,v,w,x,x0,xw,xevw,allw)" "atom allw \<sharp> (p,v,w,x,x0,xw,xevw)"
                  "atom xevw \<sharp> (p,v,w,x,x0,xw)" "atom xw \<sharp> (p,v,w,x,x0)" "atom x0 \<sharp> (p,v,w,x)"
                  "atom x \<sharp> (p,v,w)" "atom w \<sharp> (p,v)" "atom v \<sharp> p"
     by (metis obtain_fresh)
   thus ?thesis1 ?thesis3
     by auto
 qed
 
 subsection \<open>The predicate \<open>AxiomP\<close>, for any Axioms\<close>
 
 definition AxiomP :: "tm \<Rightarrow> fm"
-  where "AxiomP x \<equiv> x EQ \<lceil>extra_axiom\<rceil> OR SentP x OR Equality_axP x OR
+  where "AxiomP x \<equiv> x EQ \<guillemotleft>extra_axiom\<guillemotright> OR SentP x OR Equality_axP x OR
                     HF_axP x OR Special_axP x OR Induction_axP x"
 
 lemma AxiomP_I:
-  "{} \<turnstile> AxiomP \<lceil>extra_axiom\<rceil>"
+  "{} \<turnstile> AxiomP \<guillemotleft>extra_axiom\<guillemotright>"
   "{} \<turnstile> SentP x \<Longrightarrow> {} \<turnstile> AxiomP x"
   "{} \<turnstile> Equality_axP x \<Longrightarrow> {} \<turnstile> AxiomP x"
   "{} \<turnstile> HF_axP x \<Longrightarrow> {} \<turnstile> AxiomP x"
   "{} \<turnstile> Special_axP x \<Longrightarrow> {} \<turnstile> AxiomP x"
   "{} \<turnstile> Induction_axP x \<Longrightarrow> {} \<turnstile> AxiomP x"
   unfolding AxiomP_def
   by (rule Disj_I1, rule Refl,
       rule Disj_I2, rule Disj_I1, assumption,
       rule Disj_I2, rule Disj_I2, rule Disj_I1, assumption,
       rule Disj_I2, rule Disj_I2, rule Disj_I2, rule Disj_I1, assumption,
       rule Disj_I2, rule Disj_I2, rule Disj_I2, rule Disj_I2, rule Disj_I1, assumption,
       rule Disj_I2, rule Disj_I2, rule Disj_I2, rule Disj_I2, rule Disj_I2, assumption)
 
 lemma AxiomP_eqvt [eqvt]: "(p \<bullet> AxiomP x) = AxiomP (p \<bullet> x)"
   by (simp add: AxiomP_def)
 
 lemma AxiomP_fresh_iff [simp]: "a \<sharp> AxiomP x \<longleftrightarrow> a \<sharp> x"
   by (auto simp: AxiomP_def)
 
 lemma AxiomP_sf [iff]: "Sigma_fm (AxiomP t)"
   by (auto simp: AxiomP_def)
 
 
 subsection \<open>The predicate \<open>ModPonP\<close>, for the inference rule Modus Ponens\<close>
 
 definition ModPonP :: "tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> fm"
   where "ModPonP x y z = (y EQ Q_Imp x z)"
 
 lemma ModPonP_eqvt [eqvt]: "(p \<bullet> ModPonP x y z) = ModPonP (p \<bullet> x) (p \<bullet> y) (p \<bullet> z)"
   by (simp add: ModPonP_def)
 
 lemma ModPonP_fresh_iff [simp]: "a \<sharp> ModPonP x y z \<longleftrightarrow> a \<sharp> x \<and> a \<sharp> y \<and> a \<sharp> z"
   by (auto simp: ModPonP_def)
 
 lemma ModPonP_sf [iff]: "Sigma_fm (ModPonP t u v)"
   by (auto simp: ModPonP_def)
 
 lemma ModPonP_subst [simp]:
   "(ModPonP t u v)(i::=w) = ModPonP (subst i w t) (subst i w u) (subst i w v)"
   by (auto simp: ModPonP_def)
 
 
 subsection \<open>The predicate \<open>ExistsP\<close>, for the existential rule\<close>
 subsubsection \<open>Definition\<close>
 
 (*  "\<turnstile> A IMP B \<Longrightarrow> atom i \<sharp> B \<Longrightarrow>  \<turnstile> (Ex i A) IMP B" *)
 nominal_function ExistsP :: "tm \<Rightarrow> tm \<Rightarrow> fm" where
   "\<lbrakk>atom x \<sharp> (p,q,v,y,x'); atom x' \<sharp> (p,q,v,y);
     atom y \<sharp> (p,q,v); atom v \<sharp> (p,q)\<rbrakk> \<Longrightarrow>
   ExistsP p q = Ex x (Ex x' (Ex y (Ex v (FormP (Var x) AND
                     VarNonOccFormP (Var v) (Var y) AND
                     AbstFormP (Var v) Zero (Var x) (Var x') AND
                     p EQ Q_Imp (Var x) (Var y) AND
                     q EQ Q_Imp (Q_Ex (Var x')) (Var y)))))"
   by (auto simp: eqvt_def ExistsP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma
  shows ExistsP_fresh_iff [simp]: "a \<sharp> ExistsP p q \<longleftrightarrow> a \<sharp> p \<and> a \<sharp> q"    (is ?thesis1)
    and ExistsP_sf [iff]:       "Sigma_fm (ExistsP p q)"   (is ?thesis3)
 proof -
   obtain x::name and x'::name and y::name and v::name
     where "atom x \<sharp> (p,q,v,y,x')"  "atom x' \<sharp> (p,q,v,y)" "atom y \<sharp> (p,q,v)"  "atom v \<sharp> (p,q)"
     by (metis obtain_fresh)
   thus ?thesis1 ?thesis3
     by auto
 qed
 
 lemma ExistsP_subst [simp]: "(ExistsP p q)(j::=w) = ExistsP (subst j w p) (subst j w q)"
 proof -
   obtain x::name and x'::name and y::name and v::name
     where "atom x \<sharp> (j,w,p,q,v,y,x')"   "atom x' \<sharp> (j,w,p,q,v,y)"
           "atom y \<sharp> (j,w,p,q,v)"   "atom v \<sharp> (j,w,p,q)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: ExistsP.simps [of x _ _ x' y v])
 qed
 
 subsection \<open>The predicate \<open>SubstP\<close>, for the substitution rule\<close>
 
 text\<open>Although the substitution rule is derivable in the calculus, the derivation is
 too complicated to reproduce within the proof function. It is much easier to
 provide it as an immediate inference step, justifying its soundness in terms
 of other inference rules.\<close>
 
 subsubsection \<open>Definition\<close>
 
 nominal_function SubstP :: "tm \<Rightarrow> tm \<Rightarrow> fm" where
   "\<lbrakk>atom u \<sharp> (p,q,v); atom v \<sharp> (p,q)\<rbrakk> \<Longrightarrow>
    SubstP p q = Ex v (Ex u (SubstFormP (Var v) (Var u) p q))"
   by (auto simp: eqvt_def SubstP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma
  shows SubstP_fresh_iff [simp]: "a \<sharp> SubstP p q \<longleftrightarrow> a \<sharp> p \<and> a \<sharp> q"        (is ?thesis1)
    and SubstP_sf [iff]: "Sigma_fm (SubstP p q)"                           (is ?thesis3)
 proof -
   obtain u::name and v::name  where "atom u \<sharp> (p,q,v)" "atom v \<sharp> (p,q)"
     by (metis obtain_fresh)
   thus ?thesis1 ?thesis3
     by auto
 qed
 
 lemma SubstP_subst [simp]: "(SubstP p q)(j::=w) = SubstP (subst j w p) (subst j w q)"
 proof -
   obtain u::name and v::name  where "atom u \<sharp> (j,w,p,q,v)"  "atom v \<sharp> (j,w,p,q)"
     by (metis obtain_fresh)
   thus ?thesis
     by (simp add: SubstP.simps [of u _ _ v])
 qed
 
 
 subsection \<open>The predicate \<open>PrfP\<close>\<close>
 
 (*Prf(s,k,t) \<equiv> LstSeq(s,k,t) \<and> (\<forall>n\<in>k)[Sent (s n) \<or> (\<exists>m,l\<in>n)[ModPon (s m) (s l) (s n)]]*)
 nominal_function PrfP :: "tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> fm"
   where "\<lbrakk>atom l \<sharp> (s,sl,m,n,sm,sn); atom sl \<sharp> (s,m,n,sm,sn);
           atom m \<sharp> (s,n,sm,sn); atom n \<sharp> (s,k,sm,sn);
           atom sm \<sharp> (s,sn); atom sn \<sharp> (s)\<rbrakk> \<Longrightarrow>
     PrfP s k t =
       LstSeqP s k t AND
       All2 n (SUCC k) (Ex sn (HPair (Var n) (Var sn) IN s AND (AxiomP (Var sn) OR
                 Ex m (Ex l (Ex sm (Ex sl (Var m IN Var n AND Var l IN Var n AND
                        HPair (Var m) (Var sm) IN s AND HPair (Var l) (Var sl) IN s AND
                        (ModPonP (Var sm) (Var sl) (Var sn) OR
                         ExistsP (Var sm) (Var sn) OR
                         SubstP (Var sm) (Var sn)))))))))"
   by (auto simp: eqvt_def PrfP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma
   shows PrfP_fresh_iff [simp]: "a \<sharp> PrfP s k t \<longleftrightarrow> a \<sharp> s \<and> a \<sharp> k \<and> a \<sharp> t"      (is ?thesis1)
   and PrfP_imp_OrdP [simp]:    "{PrfP s k t} \<turnstile> OrdP k"         (is ?thord)
   and PrfP_imp_LstSeqP [simp]: "{PrfP s k t} \<turnstile> LstSeqP s k t"  (is ?thlstseq)
   and PrfP_sf [iff]:           "Sigma_fm (PrfP s k t)"         (is ?thsf)
 proof -
   obtain l::name and sl::name and m::name and n::name and sm::name and sn::name
     where atoms: "atom l \<sharp> (s,sl,m,n,sm,sn)"   "atom sl \<sharp> (s,m,n,sm,sn)"
         "atom m \<sharp> (s,n,sm,sn)"   "atom n \<sharp> (s,k,sm,sn)"
         "atom sm \<sharp> (s,sn)"   "atom sn \<sharp> (s)"
     by (metis obtain_fresh)
   thus ?thesis1 ?thord ?thlstseq ?thsf
     by (auto intro: LstSeqP_OrdP)
 qed
 
 lemma PrfP_subst [simp]:
      "(PrfP t u v)(j::=w) = PrfP (subst j w t) (subst j w u) (subst j w v)"
 proof -
   obtain l::name and sl::name and m::name and n::name and sm::name and sn::name
     where "atom l \<sharp> (t,u,v,j,w,sl,m,n,sm,sn)"   "atom sl \<sharp> (t,u,v,j,w,m,n,sm,sn)"
           "atom m \<sharp> (t,u,v,j,w,n,sm,sn)"   "atom n \<sharp> (t,u,v,j,w,sm,sn)"
           "atom sm \<sharp> (t,u,v,j,w,sn)"   "atom sn \<sharp> (t,u,v,j,w)"
     by (metis obtain_fresh)
   thus ?thesis
     by (simp add: PrfP.simps [of l _ sl m n sm sn])
 qed
 
 
 subsection \<open>The predicate \<open>PfP\<close>\<close>
 
 nominal_function PfP :: "tm \<Rightarrow> fm"
   where "\<lbrakk>atom k \<sharp> (s,y); atom s \<sharp> y\<rbrakk> \<Longrightarrow>
     PfP y = Ex k (Ex s (PrfP (Var s) (Var k) y))"
   by (auto simp: eqvt_def PfP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma
  shows PfP_fresh_iff [simp]: "a \<sharp> PfP y \<longleftrightarrow> a \<sharp> y"           (is ?thesis1)
    and PfP_sf [iff]: "Sigma_fm (PfP y)"                      (is ?thsf)
 proof -
   obtain k::name and s::name where "atom k \<sharp> (s,y)" "atom s \<sharp> y"
     by (metis obtain_fresh)
   thus ?thesis1 ?thsf
     by auto
 qed
 
 lemma PfP_subst [simp]: "(PfP t)(j::=w) = PfP (subst j w t)"
 proof -
   obtain k::name and s::name where "atom k \<sharp> (s,t,j,w)" "atom s \<sharp> (t,j,w)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: PfP.simps [of k s])
 qed
 
 lemma ground_PfP [simp]: "ground_fm (PfP y) = ground y"
   by (simp add: ground_aux_def ground_fm_aux_def supp_conv_fresh)
 
 end
 
diff --git a/thys/Goedel_HFSet_Semanticless/Pseudo_Coding.thy b/thys/Goedel_HFSet_Semanticless/Pseudo_Coding.thy
--- a/thys/Goedel_HFSet_Semanticless/Pseudo_Coding.thy
+++ b/thys/Goedel_HFSet_Semanticless/Pseudo_Coding.thy
@@ -1,328 +1,328 @@
 chapter\<open>Pseudo-Coding: Section 7 Material\<close>
 
 theory Pseudo_Coding
 imports II_Prelims
 begin
 
 section\<open>General Lemmas\<close>
 
 lemma Collect_disj_Un: "{f i |i. P i \<or> Q i} = {f i |i. P i} \<union> {f i |i. Q i}"
 by auto
 
 abbreviation Q_Subset :: "tm \<Rightarrow> tm \<Rightarrow> tm"
   where "Q_Subset t u \<equiv> (Q_All (Q_Imp (Q_Mem (Q_Ind Zero) t) (Q_Mem (Q_Ind Zero) u)))"
 
-lemma NEQ_quot_tm: "i\<noteq>j \<Longrightarrow> {} \<turnstile> \<lceil>Var i\<rceil> NEQ \<lceil>Var j\<rceil>"
+lemma NEQ_quot_tm: "i\<noteq>j \<Longrightarrow> {} \<turnstile> \<guillemotleft>Var i\<guillemotright> NEQ \<guillemotleft>Var j\<guillemotright>"
   using VarP_Var[of "{}" i] VarP_Var[of "{}" j]
   by (intro OrdNotEqP_I) (auto simp: VarP_def quot_Var ORD_OF_EQ_diff dest!: Conj_E1)
 
-lemma EQ_quot_tm_Fls: "i\<noteq>j \<Longrightarrow> insert (\<lceil>Var i\<rceil> EQ \<lceil>Var j\<rceil>) H \<turnstile> Fls"
+lemma EQ_quot_tm_Fls: "i\<noteq>j \<Longrightarrow> insert (\<guillemotleft>Var i\<guillemotright> EQ \<guillemotleft>Var j\<guillemotright>) H \<turnstile> Fls"
   by (metis (full_types) NEQ_quot_tm Assume OrdNotEqP_E cut2 thin0)
 
 lemma perm_commute: "a \<sharp> p \<Longrightarrow> a' \<sharp> p \<Longrightarrow> (a \<rightleftharpoons> a') + p = p + (a \<rightleftharpoons> a')"
   by (rule plus_perm_eq) (simp add: supp_swap fresh_def)
 
 lemma perm_self_inverseI: "\<lbrakk>-p = q; a \<sharp> p; a' \<sharp> p\<rbrakk> \<Longrightarrow> - ((a \<rightleftharpoons> a') + p) = (a \<rightleftharpoons> a') + q"
   by (simp_all add: perm_commute fresh_plus_perm minus_add)
 
 lemma fresh_image:
   fixes f :: "'a \<Rightarrow> 'b::fs"  shows "finite A \<Longrightarrow> i \<sharp> f ` A \<longleftrightarrow> (\<forall>x\<in>A. i \<sharp> f x)"
   by (induct rule: finite_induct) (auto simp: fresh_finite_insert)
 
 lemma atom_in_atom_image [simp]: "atom j \<in> atom ` V \<longleftrightarrow> j \<in> V"
   by auto
 
 lemma fresh_star_empty [simp]: "{} \<sharp>* bs"
   by (simp add: fresh_star_def)
 
 declare fresh_star_insert [simp]
 
 lemma fresh_star_finite_insert:
   fixes S :: "('a::fs) set"  shows "finite S \<Longrightarrow> a \<sharp>* insert x S \<longleftrightarrow> a \<sharp>* x \<and> a \<sharp>* S"
   by (auto simp: fresh_star_def fresh_finite_insert)
 
 lemma fresh_finite_Diff_single [simp]:
   fixes V :: "name set"   shows "finite V \<Longrightarrow> a \<sharp> (V - {j}) \<longleftrightarrow> (a \<sharp> j \<longrightarrow> a \<sharp> V)"
 apply (auto simp: fresh_finite_insert)
 apply (metis finite_Diff fresh_finite_insert insert_Diff_single)
 apply (metis Diff_iff finite_Diff fresh_atom fresh_atom_at_base fresh_finite_set_at_base insertI1)
 apply (metis Diff_idemp Diff_insert_absorb finite_Diff fresh_finite_insert insert_Diff_single insert_absorb)
 done
 
 lemma fresh_image_atom [simp]: "finite A \<Longrightarrow> i \<sharp> atom ` A \<longleftrightarrow> i \<sharp> A"
   by (induct rule: finite_induct) (auto simp: fresh_finite_insert)
 
 lemma atom_fresh_star_atom_set_conv: "\<lbrakk>atom i \<sharp> bs; finite bs\<rbrakk> \<Longrightarrow> bs \<sharp>* i"
 by (metis fresh_finite_atom_set fresh_ineq_at_base fresh_star_def)
 
 lemma notin_V:
   assumes p: "atom i \<sharp> p" and V: "finite V" "atom ` (p \<bullet> V) \<sharp>* V"
   shows "i \<notin> V" "i \<notin> p \<bullet> V"
   using V
   apply (auto simp: fresh_def fresh_star_def supp_finite_set_at_base)
   apply (metis p mem_permute_iff fresh_at_base_permI)+
   done
 
 section\<open>Simultaneous Substitution\<close>
 
 definition ssubst :: "tm \<Rightarrow> name set \<Rightarrow> (name \<Rightarrow> tm) \<Rightarrow> tm"
   where "ssubst t V F = Finite_Set.fold (\<lambda>i. subst i (F i)) t V"
 
 definition make_F :: "name set \<Rightarrow> perm \<Rightarrow> name \<Rightarrow> tm"
   where "make_F Vs p \<equiv> \<lambda>i. if i \<in> Vs then Var (p \<bullet> i) else Var i"
 
 lemma ssubst_empty [simp]: "ssubst t {} F = t"
   by (simp add: ssubst_def)
 
 text\<open>Renaming a finite set of variables. Based on the theorem \<open>at_set_avoiding\<close>\<close>
 locale quote_perm =
   fixes p :: perm and Vs :: "name set" and F :: "name \<Rightarrow> tm"
   assumes p: "atom ` (p \<bullet> Vs) \<sharp>* Vs"
       and pinv: "-p = p"
       and Vs:  "finite Vs"
   defines "F \<equiv> make_F Vs p"
 begin
 
 lemma F_unfold: "F i = (if i \<in> Vs then Var (p \<bullet> i) else Var i)"
   by (simp add: F_def make_F_def)
 
 lemma finite_V [simp]: "V \<subseteq> Vs \<Longrightarrow> finite V"
   by (metis Vs finite_subset)
 
 lemma perm_exits_Vs: "i \<in> Vs \<Longrightarrow> (p \<bullet> i) \<notin> Vs"
   by (metis Vs fresh_finite_set_at_base imageI fresh_star_def mem_permute_iff p)
 
 lemma atom_fresh_perm: "\<lbrakk>x \<in> Vs; y \<in> Vs\<rbrakk> \<Longrightarrow> atom x \<sharp> p \<bullet> y"
   by (metis imageI Vs p fresh_finite_set_at_base fresh_star_def mem_permute_iff fresh_at_base(2))
 
 lemma fresh_pj: "\<lbrakk>a \<sharp> p; j \<in> Vs\<rbrakk> \<Longrightarrow> a \<sharp> p \<bullet> j"
   by (metis atom_fresh_perm fresh_at_base(2) fresh_perm fresh_permute_left pinv)
 
 lemma fresh_Vs: "a \<sharp> p \<Longrightarrow> a \<sharp> Vs"
   by (metis Vs fresh_def fresh_perm fresh_permute_iff fresh_star_def p permute_finite supp_finite_set_at_base)
 
 lemma fresh_pVs: "a \<sharp> p \<Longrightarrow> a \<sharp> p \<bullet> Vs"
   by (metis fresh_Vs fresh_perm fresh_permute_left pinv)
 
 lemma assumes "V \<subseteq> Vs" "a \<sharp> p"
       shows fresh_pV [simp]: "a \<sharp> p \<bullet> V" and fresh_V [simp]: "a \<sharp> V"
   using fresh_pVs fresh_Vs assms
   apply (auto simp: fresh_def)
   apply (metis (full_types) Vs finite_V permute_finite set_mp subset_Un_eq supp_of_finite_union union_eqvt)
   by (metis Vs finite_V set_mp subset_Un_eq supp_of_finite_union)
 
 lemma qp_insert:
   fixes i::name and i'::name
   assumes "atom i \<sharp> p" "atom i' \<sharp> (i,p)"
     shows  "quote_perm ((atom i \<rightleftharpoons> atom i') + p) (insert i Vs)"
 using p pinv Vs assms
   by (auto simp: quote_perm_def fresh_at_base_permI atom_fresh_star_atom_set_conv swap_fresh_fresh
                  fresh_star_finite_insert fresh_finite_insert perm_self_inverseI)
 
 lemma subst_F_left_commute: "subst x (F x) (subst y (F y) t) = subst y (F y) (subst x (F x) t)"
   by (metis subst_tm_commute2 F_unfold subst_tm_id F_unfold atom_fresh_perm tm.fresh(2))
 
 lemma
   assumes "finite V" "i \<notin> V"
   shows ssubst_insert:  "ssubst t (insert i V) F = subst i (F i) (ssubst t V F)"  (is ?thesis1)
     and ssubst_insert2: "ssubst t (insert i V) F = ssubst (subst i (F i) t) V F"  (is ?thesis2)
 proof -
   interpret comp_fun_commute "(\<lambda>i. subst i (F i))"
   proof qed (simp add: subst_F_left_commute fun_eq_iff)
   show ?thesis1 using assms Vs
     by (simp add: ssubst_def)
   show ?thesis2 using assms Vs
     by (simp add: ssubst_def fold_insert2 del: fold_insert)
 qed
 
 lemma ssubst_insert_if:
   "finite V \<Longrightarrow>
      ssubst t (insert i V) F = (if i \<in> V then ssubst t V F
                                          else subst i (F i) (ssubst t V F))"
   by (simp add: ssubst_insert insert_absorb)
 
 lemma ssubst_single [simp]: "ssubst t {i} F = subst i (F i) t"
   by (simp add: ssubst_insert)
 
 lemma ssubst_Var_if [simp]:
   assumes "finite V"
     shows "ssubst (Var i) V F = (if i \<in> V then F i else Var i)"
 using assms
   apply (induction V, auto)
   apply (metis ssubst_insert subst.simps(2))
   apply (metis ssubst_insert2 subst.simps(2))+
   done
 
 lemma ssubst_Zero [simp]: "finite V \<Longrightarrow> ssubst Zero V F = Zero"
   by (induct V rule: finite_induct) (auto simp: ssubst_insert)
 
 lemma ssubst_Eats [simp]: "finite V \<Longrightarrow> ssubst (Eats t u) V F = Eats (ssubst t V F) (ssubst u V F)"
   by (induct V rule: finite_induct) (auto simp: ssubst_insert)
 
 lemma ssubst_SUCC [simp]: "finite V \<Longrightarrow> ssubst (SUCC t) V F = SUCC (ssubst t V F)"
   by (metis SUCC_def ssubst_Eats)
 
 lemma ssubst_ORD_OF [simp]: "finite V \<Longrightarrow> ssubst (ORD_OF n) V F = ORD_OF n"
   by (induction n) auto
 
 lemma ssubst_HPair [simp]:
   "finite V \<Longrightarrow> ssubst (HPair t u) V F = HPair (ssubst t V F) (ssubst u V F)"
   by (simp add: HPair_def)
 
 lemma ssubst_HTuple [simp]: "finite V \<Longrightarrow> ssubst (HTuple n) V F = (HTuple n)"
   by (induction n) (auto simp: HTuple.simps)
 
 lemma ssubst_Subset:
   assumes "finite V" shows "ssubst \<lfloor>t SUBS u\<rfloor>V V F = Q_Subset (ssubst \<lfloor>t\<rfloor>V V F) (ssubst \<lfloor>u\<rfloor>V V F)"
 proof -
   obtain i::name where "atom i \<sharp> (t,u)"
     by (rule obtain_fresh)
   thus ?thesis using assms
     by (auto simp: Subset.simps [of i] vquot_fm_def vquot_tm_def trans_tm_forget)
 qed
 
 lemma fresh_ssubst:
   assumes "finite V" "a \<sharp> p \<bullet> V" "a \<sharp> t"
     shows "a \<sharp> ssubst t V F"
 using assms
   by (induct V)
      (auto simp: ssubst_insert_if fresh_finite_insert F_unfold intro: fresh_ineq_at_base)
 
 lemma fresh_ssubst':
   assumes "finite V" "atom i \<sharp> t" "atom (p \<bullet> i) \<sharp> t"
     shows "atom i \<sharp> ssubst t V F"
 using assms
   by (induct t rule: tm.induct) (auto simp: F_unfold fresh_permute_left pinv)
 
 lemma ssubst_vquot_Ex:
   "\<lbrakk>finite V; atom i \<sharp> p \<bullet> V\<rbrakk>
    \<Longrightarrow> ssubst \<lfloor>Ex i A\<rfloor>(insert i V) (insert i V) F = ssubst \<lfloor>Ex i A\<rfloor>V V F"
    by (simp add: ssubst_insert_if insert_absorb vquot_fm_insert fresh_ssubst)
 
 lemma ground_ssubst_eq: "\<lbrakk>finite V; supp t = {}\<rbrakk> \<Longrightarrow> ssubst t V F = t"
   by (induct V rule: finite_induct) (auto simp: ssubst_insert fresh_def)
 
 lemma ssubst_quot_tm [simp]:
-  fixes t::tm shows "finite V \<Longrightarrow> ssubst \<lceil>t\<rceil> V F = \<lceil>t\<rceil>"
+  fixes t::tm shows "finite V \<Longrightarrow> ssubst \<guillemotleft>t\<guillemotright> V F = \<guillemotleft>t\<guillemotright>"
   by (simp add: ground_ssubst_eq supp_conv_fresh)
 
 lemma ssubst_quot_fm [simp]:
-  fixes A::fm shows "finite V \<Longrightarrow> ssubst \<lceil>A\<rceil> V F = \<lceil>A\<rceil>"
+  fixes A::fm shows "finite V \<Longrightarrow> ssubst \<guillemotleft>A\<guillemotright> V F = \<guillemotleft>A\<guillemotright>"
   by (simp add: ground_ssubst_eq supp_conv_fresh)
 
 lemma atom_in_p_Vs: "\<lbrakk>i \<in> p \<bullet> V; V \<subseteq> Vs\<rbrakk> \<Longrightarrow> i \<in> p \<bullet> Vs"
   by (metis (full_types) True_eqvt set_mp subset_eqvt)
 
 
 section\<open>The Main Theorems of Section 7\<close>
 
 lemma SubstTermP_vquot_dbtm:
   assumes w: "w \<in> Vs - V" and V: "V \<subseteq> Vs" "V' = p \<bullet> V"
       and s: "supp dbtm \<subseteq> atom ` Vs"
   shows
   "insert (ConstP (F w)) {ConstP (F i) | i. i \<in> V}
-   \<turnstile> SubstTermP \<lceil>Var w\<rceil> (F w)
+   \<turnstile> SubstTermP \<guillemotleft>Var w\<guillemotright> (F w)
                 (ssubst (vquot_dbtm V dbtm) V F)
                 (subst w (F w) (ssubst (vquot_dbtm (insert w V) dbtm) V F))"
 using s
 proof (induct dbtm rule: dbtm.induct)
   case DBZero thus ?case using V w
     by (auto intro: SubstTermP_Zero [THEN cut1] ConstP_imp_TermP [THEN cut1])
 next
   case (DBInd n) thus ?case using V
     apply auto
     apply (rule thin [of "{ConstP (F w)}"])
     apply (rule SubstTermP_Ind [THEN cut3])
     apply (auto simp: IndP_Q_Ind OrdP_ORD_OF ConstP_imp_TermP)
     done
 next
   case (DBVar i) show ?case
   proof (cases "i \<in> V'")
     case True hence "i \<notin> Vs" using assms
       by (metis p Vs atom_in_atom_image atom_in_p_Vs fresh_finite_set_at_base fresh_star_def)
     thus ?thesis using DBVar True V
       by auto
   next
     case False thus ?thesis using DBVar V w
       apply (auto simp: quot_Var [symmetric])
         apply (blast intro: thin [of "{ConstP (F w)}"] ConstP_imp_TermP
                             SubstTermP_Var_same [THEN cut2])
        apply (subst forget_subst_tm, metis F_unfold atom_fresh_perm tm.fresh(2))
        apply (blast intro: Hyp thin [of "{ConstP (F w)}"] ConstP_imp_TermP
                            SubstTermP_Const [THEN cut2])
        apply (blast intro: Hyp thin [of "{ConstP (F w)}"] ConstP_imp_TermP EQ_quot_tm_Fls
                            SubstTermP_Var_diff [THEN cut4])
       done
   qed
 next
   case (DBEats tm1 tm2) thus ?case using V
     by (auto simp: SubstTermP_Eats [THEN cut2])
 qed
 
 lemma SubstFormP_vquot_dbfm:
   assumes w: "w \<in> Vs - V" and V: "V \<subseteq> Vs" "V' = p \<bullet> V"
       and s: "supp dbfm \<subseteq> atom ` Vs"
   shows
   "insert (ConstP (F w)) {ConstP (F i) | i. i \<in> V}
-   \<turnstile> SubstFormP \<lceil>Var w\<rceil> (F w)
+   \<turnstile> SubstFormP \<guillemotleft>Var w\<guillemotright> (F w)
                 (ssubst (vquot_dbfm V dbfm) V F)
                 (subst w (F w) (ssubst (vquot_dbfm (insert w V) dbfm) V F))"
 using w s
 proof (induct dbfm rule: dbfm.induct)
   case (DBMem t u) thus ?case using V
     by (auto intro: SubstTermP_vquot_dbtm SubstFormP_Mem [THEN cut2])
 next
   case (DBEq t u) thus ?case using V
     by (auto intro: SubstTermP_vquot_dbtm SubstFormP_Eq [THEN cut2])
 next
   case (DBDisj A B) thus ?case using V
     by (auto intro: SubstFormP_Disj [THEN cut2])
 next
   case (DBNeg A) thus ?case using V
     by (auto intro: SubstFormP_Neg [THEN cut1])
 next
   case (DBEx A) thus ?case using V
     by (auto intro: SubstFormP_Ex [THEN cut1])
 qed
 
 text\<open>Lemmas 7.5 and 7.6\<close>
 lemma ssubst_SubstFormP:
   fixes A::fm
   assumes w: "w \<in> Vs - V" and V: "V \<subseteq> Vs" "V' = p \<bullet> V"
       and s: "supp A \<subseteq> atom ` Vs"
   shows
   "insert (ConstP (F w)) {ConstP (F i) | i. i \<in> V}
-   \<turnstile> SubstFormP \<lceil>Var w\<rceil> (F w)
+   \<turnstile> SubstFormP \<guillemotleft>Var w\<guillemotright> (F w)
                 (ssubst \<lfloor>A\<rfloor>V V F)
                 (ssubst \<lfloor>A\<rfloor>(insert w V) (insert w V) F)"
 proof -
   have "w \<notin> V" using assms
     by auto
   thus ?thesis using assms
     by (simp add: vquot_fm_def supp_conv_fresh ssubst_insert_if SubstFormP_vquot_dbfm)
 qed
 
 text\<open>Theorem 7.3\<close>
 theorem PfP_implies_PfP_ssubst:
   fixes \<beta>::fm
-  assumes \<beta>: "{} \<turnstile> PfP \<lceil>\<beta>\<rceil>"
+  assumes \<beta>: "{} \<turnstile> PfP \<guillemotleft>\<beta>\<guillemotright>"
       and V: "V \<subseteq> Vs"
       and s: "supp \<beta> \<subseteq> atom ` Vs"
     shows    "{ConstP (F i) | i. i \<in> V} \<turnstile> PfP (ssubst \<lfloor>\<beta>\<rfloor>V V F)"
 proof -
   show ?thesis using finite_V [OF V] V
   proof induction
     case empty thus ?case
       by (auto simp: \<beta>)
   next
     case (insert i V)
     thus ?case using assms
       by (auto simp: Collect_disj_Un fresh_finite_set_at_base
                intro: PfP_implies_SubstForm_PfP thin1 ssubst_SubstFormP)
   qed
 qed
 
 end
 
 end
 
diff --git a/thys/Goedel_HFSet_Semanticless/Quote.thy b/thys/Goedel_HFSet_Semanticless/Quote.thy
--- a/thys/Goedel_HFSet_Semanticless/Quote.thy
+++ b/thys/Goedel_HFSet_Semanticless/Quote.thy
@@ -1,1437 +1,1437 @@
 chapter\<open>Quotations of the Free Variables\<close>
 
 theory Quote
 imports Pseudo_Coding
 begin
 
 section \<open>Sequence version of the ``Special p-Function, F*''\<close>
 
 text\<open>The definition below describes a relation, not a function.
       This material relates to Section 8, but omits the ordering of the universe.\<close>
 
 subsection \<open>Defining the syntax: quantified body\<close>
 
 nominal_function SeqQuoteP :: "tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> tm \<Rightarrow> fm"
   where "\<lbrakk>atom l \<sharp> (s,k,sl,sl',m,n,sm,sm',sn,sn');
           atom sl \<sharp> (s,sl',m,n,sm,sm',sn,sn'); atom sl' \<sharp> (s,m,n,sm,sm',sn,sn');
           atom m \<sharp> (s,n,sm,sm',sn,sn');  atom n \<sharp> (s,sm,sm',sn,sn');
           atom sm \<sharp> (s,sm',sn,sn');  atom sm' \<sharp> (s,sn,sn');
           atom sn \<sharp> (s,sn');  atom sn' \<sharp> s\<rbrakk> \<Longrightarrow>
     SeqQuoteP t u s k =
       LstSeqP s k (HPair t u) AND
       All2 l (SUCC k) (Ex sl (Ex sl' (HPair (Var l) (HPair (Var sl) (Var sl')) IN s AND
                 ((Var sl EQ Zero AND Var sl' EQ Zero) OR
                 Ex m (Ex n (Ex sm (Ex sm' (Ex sn (Ex sn' (Var m IN Var l AND Var n IN Var l AND
                        HPair (Var m) (HPair (Var sm) (Var sm')) IN s AND
                        HPair (Var n) (HPair (Var sn) (Var sn')) IN s AND
                        Var sl EQ Eats (Var sm) (Var sn) AND
                        Var sl' EQ Q_Eats (Var sm') (Var sn')))))))))))"
 by (auto simp: eqvt_def SeqQuoteP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 lemma
   shows SeqQuoteP_fresh_iff [simp]:
       "a \<sharp> SeqQuoteP t u s k \<longleftrightarrow> a \<sharp> t \<and> a \<sharp> u \<and> a \<sharp> s \<and> a \<sharp> k"  (is ?thesis1)
   and SeqQuoteP_sf [iff]:
       "Sigma_fm (SeqQuoteP t u s k)"    (is ?thsf)
   and SeqQuoteP_imp_OrdP:
       "{ SeqQuoteP t u s k } \<turnstile> OrdP k"  (is ?thord)
   and SeqQuoteP_imp_LstSeqP:
       "{ SeqQuoteP t u s k } \<turnstile> LstSeqP s k (HPair t u)"  (is ?thlstseq)
 proof -
   obtain l::name and sl::name and sl'::name and m::name and n::name and
          sm::name and sm'::name and sn::name and sn'::name
     where atoms:
          "atom l \<sharp> (s,k,sl,sl',m,n,sm,sm',sn,sn')"
          "atom sl \<sharp> (s,sl',m,n,sm,sm',sn,sn')"  "atom sl' \<sharp> (s,m,n,sm,sm',sn,sn')"
          "atom m \<sharp> (s,n,sm,sm',sn,sn')"  "atom n \<sharp> (s,sm,sm',sn,sn')"
          "atom sm \<sharp> (s,sm',sn,sn')"  "atom sm' \<sharp> (s,sn,sn')"
          "atom sn \<sharp> (s,sn')"  "atom sn' \<sharp> s"
     by (metis obtain_fresh)
   thus ?thesis1 ?thsf ?thord ?thlstseq
     by auto (auto simp: LstSeqP.simps)
 qed
 
 lemma SeqQuoteP_subst [simp]:
       "(SeqQuoteP t u s k)(j::=w) =
        SeqQuoteP (subst j w t) (subst j w u) (subst j w s) (subst j w k)"
 proof -
   obtain l::name and sl::name and sl'::name and m::name and n::name and
          sm::name and sm'::name and sn::name and sn'::name
     where "atom l \<sharp> (s,k,w,j,sl,sl',m,n,sm,sm',sn,sn')"
           "atom sl \<sharp> (s,w,j,sl',m,n,sm,sm',sn,sn')"  "atom sl' \<sharp> (s,w,j,m,n,sm,sm',sn,sn')"
           "atom m \<sharp> (s,w,j,n,sm,sm',sn,sn')"  "atom n \<sharp> (s,w,j,sm,sm',sn,sn')"
           "atom sm \<sharp> (s,w,j,sm',sn,sn')"  "atom sm' \<sharp> (s,w,j,sn,sn')"
           "atom sn \<sharp> (s,w,j,sn')"  "atom sn' \<sharp> (s,w,j)"
     by (metis obtain_fresh)
   thus ?thesis
     by (force simp add: SeqQuoteP.simps [of l _ _ sl sl' m n sm sm' sn sn'])
 qed
 
 declare SeqQuoteP.simps [simp del]
 
 subsection \<open>Correctness properties\<close>
 
 lemma SeqQuoteP_lemma:
   fixes m::name and sm::name and sm'::name and n::name and sn::name and sn'::name
   assumes "atom m \<sharp> (t,u,s,k,n,sm,sm',sn,sn')"  "atom n \<sharp> (t,u,s,k,sm,sm',sn,sn')"
           "atom sm \<sharp> (t,u,s,k,sm',sn,sn')"  "atom sm' \<sharp> (t,u,s,k,sn,sn')"
           "atom sn \<sharp> (t,u,s,k,sn')"  "atom sn' \<sharp> (t,u,s,k)"
     shows "{ SeqQuoteP t u s k }
            \<turnstile> (t EQ Zero AND u EQ Zero) OR
              Ex m (Ex n (Ex sm (Ex sm' (Ex sn (Ex sn' (Var m IN k AND Var n IN k AND
                  SeqQuoteP (Var sm) (Var sm') s (Var m) AND
                  SeqQuoteP (Var sn) (Var sn') s (Var n) AND
                  t EQ Eats (Var sm) (Var sn) AND
                  u EQ Q_Eats (Var sm') (Var sn')))))))"
 proof -
   obtain l::name and sl::name and sl'::name
     where "atom l \<sharp> (t,u,s,k,sl,sl',m,n,sm,sm',sn,sn')"
           "atom sl \<sharp> (t,u,s,k,sl',m,n,sm,sm',sn,sn')"
           "atom sl' \<sharp> (t,u,s,k,m,n,sm,sm',sn,sn')"
     by (metis obtain_fresh)
   thus ?thesis using assms
     apply (simp add: SeqQuoteP.simps [of l s k sl sl' m n sm sm' sn sn'])
     apply (rule Conj_EH Ex_EH All2_SUCC_E [THEN rotate2] | simp)+
     apply (rule cut_same [where A = "HPair t u EQ HPair (Var sl) (Var sl')"])
     apply (metis Assume AssumeH(4) LstSeqP_EQ)
     apply clarify
     apply (rule Disj_EH)
     apply (rule Disj_I1)
     apply (rule anti_deduction)
     apply (rule Var_Eq_subst_Iff [THEN Sym_L, THEN Iff_MP_same])
     apply (rule rotate2)
     apply (rule Var_Eq_subst_Iff [THEN Sym_L, THEN Iff_MP_same], force)
     \<comment> \<open>now the quantified case\<close>
     apply (rule Ex_EH Conj_EH)+
     apply simp_all
     apply (rule Disj_I2)
     apply (rule Ex_I [where x = "Var m"], simp)
     apply (rule Ex_I [where x = "Var n"], simp)
     apply (rule Ex_I [where x = "Var sm"], simp)
     apply (rule Ex_I [where x = "Var sm'"], simp)
     apply (rule Ex_I [where x = "Var sn"], simp)
     apply (rule Ex_I [where x = "Var sn'"], simp)
     apply (simp_all add: SeqQuoteP.simps [of l s _ sl sl' m n sm sm' sn sn'])
     apply ((rule Conj_I)+, blast intro: LstSeqP_Mem)+
     \<comment> \<open>first SeqQuoteP subgoal\<close>
     apply (rule All2_Subset [OF Hyp])
     apply (blast intro!: SUCC_Subset_Ord LstSeqP_OrdP)+
     apply simp
     \<comment> \<open>next SeqQuoteP subgoal\<close>
     apply ((rule Conj_I)+, blast intro: LstSeqP_Mem)+
     apply (rule All2_Subset [OF Hyp], blast)
     apply (auto intro!: SUCC_Subset_Ord LstSeqP_OrdP intro: Trans)
     done
 qed
 
 section \<open>The ``special function'' itself\<close>
 
 nominal_function QuoteP :: "tm \<Rightarrow> tm \<Rightarrow> fm"
   where "\<lbrakk>atom s \<sharp> (t,u,k); atom k \<sharp> (t,u)\<rbrakk> \<Longrightarrow>
     QuoteP t u = Ex s (Ex k (SeqQuoteP t u (Var s) (Var k)))"
 by (auto simp: eqvt_def QuoteP_graph_aux_def flip_fresh_fresh) (metis obtain_fresh)
 
 nominal_termination (eqvt)
   by lexicographic_order
 
 
 lemma
   shows QuoteP_fresh_iff [simp]: "a \<sharp> QuoteP t u \<longleftrightarrow> a \<sharp> t \<and> a \<sharp> u"  (is ?thesis1)
   and QuoteP_sf [iff]: "Sigma_fm (QuoteP t u)"  (is ?thsf)
 proof -
   obtain s::name and k::name  where "atom s \<sharp> (t,u,k)"  "atom k \<sharp> (t,u)"
     by (metis obtain_fresh)
   thus ?thesis1 ?thsf
     by auto
 qed
 
 lemma QuoteP_subst [simp]:
   "(QuoteP t u)(j::=w) = QuoteP (subst j w t) (subst j w u)"
 proof -
   obtain s::name and k::name  where "atom s \<sharp> (t,u,w,j,k)"  "atom k \<sharp> (t,u,w,j)"
     by (metis obtain_fresh)
   thus ?thesis
     by (simp add: QuoteP.simps [of s _ _ k])
 qed
 
 declare QuoteP.simps [simp del]
 
 subsection \<open>Correctness properties\<close>
 
 lemma QuoteP_Zero: "{} \<turnstile> QuoteP Zero Zero"
 proof -
  obtain l :: "name"
     and sl :: "name"
     and sl' :: "name"
     and m :: "name"
     and n :: "name"
     and sm :: "name"
     and sm' :: "name"
     and sn :: "name"
     and sn' :: "name"
     and s :: "name"
     and k :: "name"
   where "atom l \<sharp> (s, k, sl, sl', m, n, sm, sm', sn, sn')"
     and "atom sl \<sharp> (s, k, sl', m, n, sm, sm', sn, sn')"
     and "atom sl' \<sharp> (s, k, m, n, sm, sm', sn, sn')"
     and "atom m \<sharp> (s, k, n, sm, sm', sn, sn')"
     and "atom n \<sharp> (s, k, sm, sm', sn, sn')"
     and "atom sm \<sharp> (s, k, sm', sn, sn')"
     and "atom sm' \<sharp> (s, k, sn, sn')"
     and "atom sn \<sharp> (s, k, sn')"
     and "atom sn' \<sharp> (s, k)"
     and "atom k \<sharp> s"
     by (metis obtain_fresh)
   then show ?thesis
     apply (subst QuoteP.simps[of s _ _ k]; simp)
     apply (rule Ex_I[of _ _ _ "Eats Zero (HPair Zero (HPair Zero Zero))"]; simp)
     apply (rule Ex_I[of _ _ _ "Zero"]; simp)
     apply (subst SeqQuoteP.simps[of l _ _ sl sl' m n sm sm' sn sn']; simp?)
     apply (rule Conj_I)
      apply (rule LstSeqP_single)
     apply (auto intro!: Ex_I[of _ _ _ Zero])
      apply (rule Mem_SUCC_E[OF Mem_Zero_E])
      apply (rule Mem_Eats_I2)
      apply (rule HPair_cong[OF Assume Refl])
     apply (auto intro!: Disj_I1)
     done
 qed
 
 lemma SeqQuoteP_Eats:
   assumes "atom s \<sharp> (k,s1,s2,k1,k2,t1,t2,u1,u2)" "atom k \<sharp> (s1,s2,k1,k2,t1,t2,u1,u2)"
     shows "{SeqQuoteP t1 u1 s1 k1, SeqQuoteP t2 u2 s2 k2} \<turnstile>
            Ex s (Ex k (SeqQuoteP (Eats t1 t2) (Q_Eats u1 u2) (Var s) (Var k)))"
 proof -
   obtain km::name and kn::name and j::name and k'::name and l::name
      and sl::name and sl'::name and m::name and n::name and sm::name
      and sm'::name and sn::name and sn'::name
    where atoms2:
          "atom km \<sharp> (kn,j,k',l,s1,s2,s,k1,k2,k,t1,t2,u1,u2,sl,sl',m,n,sm,sm',sn,sn')"
          "atom kn \<sharp> (j,k',l,s1,s2,s,k1,k2,k,t1,t2,u1,u2,sl,sl',m,n,sm,sm',sn,sn')"
          "atom j \<sharp> (k',l,s1,s2,s,k1,k2,k,t1,t2,u1,u2,sl,sl',m,n,sm,sm',sn,sn')"
      and atoms: "atom k' \<sharp> (l,s1,s2,s,k1,k2,k,t1,t2,u1,u2,sl,sl',m,n,sm,sm',sn,sn')"
          "atom l \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,sl,sl',m,n,sm,sm',sn,sn')"
          "atom sl \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,sl',m,n,sm,sm',sn,sn')"
          "atom sl' \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,m,n,sm,sm',sn,sn')"
          "atom m \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,n,sm,sm',sn,sn')"
          "atom n \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,sm,sm',sn,sn')"
          "atom sm \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,sm',sn,sn')"
          "atom sm' \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,sn,sn')"
          "atom sn \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2,sn')"
          "atom sn' \<sharp> (s1,s2,s,k1,k2,k,t1,t2,u1,u2)"
     by (metis obtain_fresh)
   show ?thesis
      using assms atoms
      apply (auto simp: SeqQuoteP.simps [of l "Var s" _ sl sl' m n sm sm' sn sn'])
      apply (rule cut_same [where A="OrdP k1 AND OrdP k2"])
      apply (metis Conj_I SeqQuoteP_imp_OrdP thin1 thin2)
      apply (rule cut_same [OF exists_SeqAppendP [of s s1 "SUCC k1" s2 "SUCC k2"]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule cut_same [OF exists_HaddP [where j=k' and x=k1 and y=k2]])
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule Ex_I [where x="Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Eats t1 t2) (Q_Eats u1 u2)))"])
      apply (simp_all (no_asm_simp))
      apply (rule Ex_I [where x="SUCC (SUCC (Var k'))"])
      apply simp
      apply (rule Conj_I [OF LstSeqP_SeqAppendP_Eats])
      apply (blast intro: SeqQuoteP_imp_LstSeqP [THEN cut1])+
      proof (rule All2_SUCC_I, simp_all)
        show "{HaddP k1 k2 (Var k'), OrdP k1, OrdP k2, SeqAppendP s1 (SUCC k1) s2 (SUCC k2) (Var s),
               SeqQuoteP t1 u1 s1 k1, SeqQuoteP t2 u2 s2 k2}
              \<turnstile> Ex sl (Ex sl'
                  (HPair (SUCC (SUCC (Var k'))) (HPair (Var sl) (Var sl')) IN
                   Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Eats t1 t2) (Q_Eats u1 u2))) AND
                   (Var sl EQ Zero AND Var sl' EQ Zero OR
                    Ex m (Ex n (Ex sm (Ex sm' (Ex sn (Ex sn'
                     (Var m IN SUCC (SUCC (Var k')) AND
                      Var n IN SUCC (SUCC (Var k')) AND
                      HPair (Var m) (HPair (Var sm) (Var sm')) IN
                      Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Eats t1 t2) (Q_Eats u1 u2))) AND
                      HPair (Var n) (HPair (Var sn) (Var sn')) IN
                      Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Eats t1 t2) (Q_Eats u1 u2))) AND
                      Var sl EQ Eats (Var sm) (Var sn) AND Var sl' EQ Q_Eats (Var sm') (Var sn'))))))))))"
        \<comment> \<open>verifying the final values\<close>
        apply (rule Ex_I [where x="Eats t1 t2"])
        using assms atoms apply simp
        apply (rule Ex_I [where x="Q_Eats u1 u2"], simp)
        apply (rule Conj_I [OF Mem_Eats_I2 [OF Refl]])
        apply (rule Disj_I2)
        apply (rule Ex_I [where x=k1], simp)
        apply (rule Ex_I [where x="SUCC (Var k')"], simp)
        apply (rule Ex_I [where x=t1], simp)
        apply (rule Ex_I [where x=u1], simp)
        apply (rule Ex_I [where x=t2], simp)
        apply (rule Ex_I [where x=u2], simp)
        apply (rule Conj_I)
        apply (blast intro: HaddP_Mem_I Mem_SUCC_I1)
        apply (rule Conj_I [OF Mem_SUCC_Refl])
        apply (rule Conj_I)
        apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem1 [THEN cut3] Mem_SUCC_Refl
                 SeqQuoteP_imp_LstSeqP [THEN cut1] LstSeqP_imp_Mem)
        apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] Mem_SUCC_Refl
                 SeqQuoteP_imp_LstSeqP [THEN cut1] LstSeqP_imp_Mem  HaddP_SUCC1 [THEN cut1])
        done
      next
        show "{HaddP k1 k2 (Var k'), OrdP k1, OrdP k2, SeqAppendP s1 (SUCC k1) s2 (SUCC k2) (Var s),
               SeqQuoteP t1 u1 s1 k1, SeqQuoteP t2 u2 s2 k2}
              \<turnstile> All2 l (SUCC (SUCC (Var k')))
                  (Ex sl (Ex sl'
                    (HPair (Var l) (HPair (Var sl) (Var sl')) IN
                     Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Eats t1 t2) (Q_Eats u1 u2))) AND
                     (Var sl EQ Zero AND Var sl' EQ Zero OR
                      Ex m (Ex n (Ex sm (Ex sm' (Ex sn (Ex sn'
                       (Var m IN Var l AND
                        Var n IN Var l AND
                        HPair (Var m) (HPair (Var sm) (Var sm')) IN
                        Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Eats t1 t2) (Q_Eats u1 u2))) AND
                        HPair (Var n) (HPair (Var sn) (Var sn')) IN
                        Eats (Var s) (HPair (SUCC (SUCC (Var k'))) (HPair (Eats t1 t2) (Q_Eats u1 u2))) AND
                        Var sl EQ Eats (Var sm) (Var sn) AND Var sl' EQ Q_Eats (Var sm') (Var sn')))))))))))"
      \<comment> \<open>verifying the sequence buildup\<close>
      apply (rule cut_same [where A="HaddP (SUCC k1) (SUCC k2) (SUCC (SUCC (Var k')))"])
      apply (blast intro: HaddP_SUCC1 [THEN cut1] HaddP_SUCC2 [THEN cut1])
      apply (rule All_I Imp_I)+
      apply (rule HaddP_Mem_cases [where i=j])
      using assms atoms atoms2 apply simp_all
      apply (rule AssumeH)
      apply (blast intro: OrdP_SUCC_I)
      \<comment> \<open>... the sequence buildup via s1\<close>
      apply (simp add: SeqQuoteP.simps [of l s1 _ sl sl' m n sm sm' sn sn'])
      apply (rule AssumeH Ex_EH Conj_EH)+
      apply (rule All2_E [THEN rotate2])
      apply (simp | rule AssumeH Ex_EH Conj_EH)+
      apply (rule Ex_I [where x="Var sl"], simp)
      apply (rule Ex_I [where x="Var sl'"], simp)
      apply (rule Conj_I)
      apply (rule Mem_Eats_I1)
      apply (metis SeqAppendP_Mem1 rotate3 thin2 thin4)
      apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
      apply (rule Ex_I [where x="Var m"], simp)
      apply (rule Ex_I [where x="Var n"], simp)
      apply (rule Ex_I [where x="Var sm"], simp)
      apply (rule Ex_I [where x="Var sm'"], simp)
      apply (rule Ex_I [where x="Var sn"], simp)
      apply (rule Ex_I [where x="Var sn'"], simp_all)
      apply (rule Conj_I, rule AssumeH)+
      apply (blast intro: OrdP_Trans [OF OrdP_SUCC_I] Mem_Eats_I1 [OF SeqAppendP_Mem1 [THEN cut3]] Hyp)
      \<comment> \<open>... the sequence buildup via s2\<close>
      apply (simp add: SeqQuoteP.simps [of l s2 _ sl sl' m n sm sm' sn sn'])
      apply (rule AssumeH Ex_EH Conj_EH)+
      apply (rule All2_E [THEN rotate2])
      apply (simp | rule AssumeH Ex_EH Conj_EH)+
      apply (rule Ex_I [where x="Var sl"], simp)
      apply (rule Ex_I [where x="Var sl'"], simp)
      apply (rule cut_same [where A="OrdP (Var j)"])
      apply (metis HaddP_imp_OrdP rotate2 thin2)
      apply (rule Conj_I)
      apply (blast intro: Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4]  del: Disj_EH)
      apply (rule AssumeH Disj_IE1H Ex_EH Conj_EH)+
      apply (rule cut_same [OF exists_HaddP [where j=km and x="SUCC k1" and y="Var m"]])
      apply (blast intro: Ord_IN_Ord, simp)
      apply (rule cut_same [OF exists_HaddP [where j=kn and x="SUCC k1" and y="Var n"]])
      apply (metis AssumeH(6) Ord_IN_Ord0 rotate8, simp)
      apply (rule AssumeH Ex_EH Conj_EH | simp)+
      apply (rule Ex_I [where x="Var km"], simp)
      apply (rule Ex_I [where x="Var kn"], simp)
      apply (rule Ex_I [where x="Var sm"], simp)
      apply (rule Ex_I [where x="Var sm'"], simp)
      apply (rule Ex_I [where x="Var sn"], simp)
      apply (rule Ex_I [where x="Var sn'"], simp_all)
      apply (rule Conj_I [OF _ Conj_I])
      apply (blast intro: Hyp OrdP_SUCC_I HaddP_Mem_cancel_left [THEN Iff_MP2_same])
      apply (blast intro: Hyp OrdP_SUCC_I HaddP_Mem_cancel_left [THEN Iff_MP2_same])
      apply (blast intro: Hyp Mem_Eats_I1 SeqAppendP_Mem2 [THEN cut4] OrdP_Trans HaddP_imp_OrdP [THEN cut1])
      done
    qed
 qed
 
 
 lemma QuoteP_Eats: "{QuoteP t1 u1, QuoteP t2 u2} \<turnstile> QuoteP (Eats t1 t2) (Q_Eats u1 u2)"
 proof -
   obtain k1::name and s1::name and k2::name and s2::name and k::name and s::name
     where "atom s1 \<sharp> (t1,u1,t2,u2)"             "atom k1 \<sharp> (t1,u1,t2,u2,s1)"
           "atom s2 \<sharp> (t1,u1,t2,u2,k1,s1)"       "atom k2 \<sharp> (t1,u1,t2,u2,s2,k1,s1)"
           "atom s  \<sharp> (t1,u1,t2,u2,k2,s2,k1,s1)" "atom k  \<sharp> (t1,u1,t2,u2,s,k2,s2,k1,s1)"
     by (metis obtain_fresh)
   thus ?thesis
     by (auto simp: QuoteP.simps [of s _ "(Q_Eats u1 u2)" k]
                    QuoteP.simps [of s1 t1 u1 k1] QuoteP.simps [of s2 t2 u2 k2]
              intro!: SeqQuoteP_Eats [THEN cut2])
 qed
 
 lemma exists_QuoteP:
   assumes j: "atom j \<sharp> x"  shows "{} \<turnstile> Ex j (QuoteP x (Var j))"
 proof -
   obtain i::name and j'::name and k::name
     where atoms: "atom i \<sharp> (j,x)"  "atom j' \<sharp> (i,j,x)"  "atom (k::name) \<sharp> (i,j,j',x)"
     by (metis obtain_fresh)
   have "{} \<turnstile> Ex j (QuoteP (Var i) (Var j))" (is "{} \<turnstile> ?scheme")
   proof (rule Ind [of k])
     show "atom k \<sharp> (i, ?scheme)" using atoms
       by simp
   next
     show "{} \<turnstile> ?scheme(i::=Zero)" using j atoms
       by (auto intro: Ex_I [where x=Zero] simp add: QuoteP_Zero)
   next
     show "{} \<turnstile> All i (All k (?scheme IMP ?scheme(i::=Var k) IMP ?scheme(i::=Eats (Var i) (Var k))))"
       apply (rule All_I Imp_I)+
       using atoms assms
       apply simp_all
       apply (rule Ex_E)
       apply (rule Ex_E_with_renaming [where i'=j', THEN rotate2], auto)
       apply (rule Ex_I [where x= "Q_Eats (Var j') (Var j)"], auto intro: QuoteP_Eats)
       done
   qed
   hence "{} \<turnstile> (Ex j (QuoteP (Var i) (Var j))) (i::= x)"
     by (rule Subst) auto
   thus ?thesis
     using atoms j by auto
 qed
 
 lemma QuoteP_imp_ConstP: "{ QuoteP x y } \<turnstile> ConstP y"
 proof -
   obtain j::name and j'::name and l::name and s::name and k::name
      and m::name and n::name and sm::name and sn::name and sm'::name and sn'::name
     where atoms: "atom j \<sharp> (x,y,s,k,j',l,m,n,sm,sm',sn,sn')"
              "atom j' \<sharp> (x,y,s,k,l,m,n,sm,sm',sn,sn')"
              "atom l \<sharp> (s,k,m,n,sm,sm',sn,sn')"
              "atom m \<sharp> (s,k,n,sm,sm',sn,sn')" "atom n \<sharp> (s,k,sm,sm',sn,sn')"
              "atom sm \<sharp> (s,k,sm',sn,sn')" "atom sm' \<sharp> (s,k,sn,sn')"
              "atom sn \<sharp> (s,k,sn')" "atom sn' \<sharp> (s,k)" "atom s \<sharp> (k,x,y)" "atom k \<sharp> (x,y)"
     by (metis obtain_fresh)
   have "{OrdP (Var k)}
         \<turnstile> All j (All j' (SeqQuoteP (Var j) (Var j') (Var s) (Var k) IMP ConstP (Var j')))"
         (is "_ \<turnstile> ?scheme")
     proof (rule OrdIndH [where j=l])
       show "atom l \<sharp> (k, ?scheme)" using atoms
         by simp
     next
       show "{} \<turnstile> All k (OrdP (Var k) IMP (All2 l (Var k) (?scheme(k::= Var l)) IMP ?scheme))"
         apply (rule All_I Imp_I)+
         using atoms
         apply (simp_all add: fresh_at_base fresh_finite_set_at_base)
         \<comment> \<open>freshness finally proved!\<close>
         apply (rule cut_same)
         apply (rule cut1 [OF SeqQuoteP_lemma [of m "Var j" "Var j'" "Var s" "Var k" n sm sm' sn sn']], simp_all, blast)
         apply (rule Imp_I Disj_EH Conj_EH)+
         \<comment> \<open>case 1, Var j EQ Zero\<close>
         apply (rule thin1)
         apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same], simp)
         apply (metis thin0 ConstP_Zero)
         \<comment> \<open>case 2, @{term "Var j EQ Eats (Var sm) (Var sn)"}\<close>
         apply (rule Imp_I Conj_EH Ex_EH)+
         apply simp_all
         apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same, THEN rotate2], simp)
         apply (rule ConstP_Eats [THEN cut2])
         \<comment> \<open>Operand 1. IH for sm\<close>
         apply (rule All2_E [where x="Var m", THEN rotate8], auto)
         apply (rule All_E [where x="Var sm"], simp)
         apply (rule All_E [where x="Var sm'"], auto)
         \<comment> \<open>Operand 2. IH for sm\<close>
         apply (rule All2_E [where x="Var n", THEN rotate8], auto)
         apply (rule All_E [where x="Var sn"], simp)
         apply (rule All_E [where x="Var sn'"], auto)
         done
     qed
   hence "{OrdP(Var k)}
          \<turnstile> (All j' (SeqQuoteP (Var j) (Var j') (Var s) (Var k) IMP ConstP (Var j'))) (j::=x)"
     by (metis All_D)
   hence "{OrdP(Var k)} \<turnstile> All j' (SeqQuoteP x (Var j') (Var s) (Var k) IMP ConstP (Var j'))"
     using atoms by simp
   hence "{OrdP(Var k)} \<turnstile> (SeqQuoteP x (Var j') (Var s) (Var k) IMP ConstP (Var j')) (j'::=y)"
     by (metis All_D)
   hence "{OrdP(Var k)} \<turnstile> SeqQuoteP x y (Var s) (Var k) IMP ConstP y"
     using atoms by simp
   hence "{ SeqQuoteP x y (Var s) (Var k) } \<turnstile> ConstP y"
     by (metis Imp_cut SeqQuoteP_imp_OrdP anti_deduction)
   thus "{ QuoteP x y } \<turnstile> ConstP y" using atoms
     by (auto simp: QuoteP.simps [of s _ _ k])
 qed
 
 lemma SeqQuoteP_imp_QuoteP: "{SeqQuoteP t u s k} \<turnstile> QuoteP t u"
 proof -
   obtain s'::name and k'::name  where "atom s' \<sharp> (k',t,u,s,k)"  "atom k' \<sharp> (t,u,s,k)"
     by (metis obtain_fresh)
   thus ?thesis
     apply (simp add: QuoteP.simps [of s' _ _ k'])
     apply (rule Ex_I [where x = s], simp)
     apply (rule Ex_I [where x = k], auto)
     done
 qed
 
 lemmas QuoteP_I = SeqQuoteP_imp_QuoteP [THEN cut1]
 
 
 section \<open>The Operator @{term quote_all}\<close>
 
 subsection \<open>Definition and basic properties\<close>
 
 definition quote_all :: "[perm, name set] \<Rightarrow> fm set"
   where "quote_all p V = {QuoteP (Var i) (Var (p \<bullet> i)) | i. i \<in> V}"
 
 lemma quote_all_empty [simp]: "quote_all p {} = {}"
   by (simp add: quote_all_def)
 
 lemma quote_all_insert [simp]:
   "quote_all p (insert i V) = insert (QuoteP (Var i) (Var (p \<bullet> i))) (quote_all p V)"
   by (auto simp: quote_all_def)
 
 lemma finite_quote_all [simp]: "finite V \<Longrightarrow> finite (quote_all p V)"
   by (induct rule: finite_induct) auto
 
 lemma fresh_quote_all [simp]: "finite V \<Longrightarrow> i \<sharp> quote_all p V \<longleftrightarrow> i \<sharp> V \<and> i \<sharp> p\<bullet>V"
   by (induct rule: finite_induct) (auto simp: fresh_finite_insert)
 
 lemma fresh_quote_all_mem: "\<lbrakk>A \<in> quote_all p V; finite V; i \<sharp> V; i \<sharp> p \<bullet> V\<rbrakk> \<Longrightarrow> i \<sharp> A"
   by (metis Set.set_insert finite_insert finite_quote_all fresh_finite_insert fresh_quote_all)
 
 lemma quote_all_perm_eq:
   assumes "finite V" "atom i \<sharp> (p,V)" "atom i' \<sharp> (p,V)"
     shows "quote_all ((atom i \<rightleftharpoons> atom i') + p) V = quote_all p V"
 proof -
   { fix W
     assume w: "W \<subseteq> V"
     have "finite W"
       by (metis \<open>finite V\<close> finite_subset w)
     hence "quote_all ((atom i \<rightleftharpoons> atom i') + p) W = quote_all p W" using w
         apply induction  using assms
         apply (auto simp: fresh_Pair perm_commute)
         apply (metis fresh_finite_set_at_base swap_at_base_simps(3))+
         done}
   thus ?thesis
     by (metis order_refl)
 qed
 
 
 subsection \<open>Transferring theorems to the level of derivability\<close>
 
 context quote_perm
 begin
 
 lemma QuoteP_imp_ConstP_F_hyps:
   assumes "Us \<subseteq> Vs" "{ConstP (F i) | i. i \<in> Us} \<turnstile> A"  shows "quote_all p Us \<turnstile> A"
 proof -
   show ?thesis using finite_V [OF \<open>Us \<subseteq> Vs\<close>]  assms
   proof (induction arbitrary: A rule: finite_induct)
     case empty thus ?case by simp
   next
     case (insert v Us) thus ?case
       by (auto simp: Collect_disj_Un)
          (metis (lifting) anti_deduction Imp_cut [OF _ QuoteP_imp_ConstP] Disj_I2 F_unfold)
   qed
 qed
 
 text\<open>Lemma 8.3\<close>
 theorem quote_all_PfP_ssubst:
   assumes \<beta>: "{} \<turnstile> \<beta>"
       and V: "V \<subseteq> Vs"
       and s: "supp \<beta> \<subseteq> atom ` Vs"
     shows    "quote_all p V \<turnstile> PfP (ssubst \<lfloor>\<beta>\<rfloor>V V F)"
 proof -
-  have "{} \<turnstile> PfP \<lceil>\<beta>\<rceil>"
+  have "{} \<turnstile> PfP \<guillemotleft>\<beta>\<guillemotright>"
     by (metis \<beta> proved_imp_proved_PfP)
   hence "{ConstP (F i) | i. i \<in> V} \<turnstile> PfP (ssubst \<lfloor>\<beta>\<rfloor>V V F)"
     by (simp add: PfP_implies_PfP_ssubst V s)
   thus ?thesis
     by (rule QuoteP_imp_ConstP_F_hyps [OF V])
 qed
 
 text\<open>Lemma 8.4\<close>
 corollary quote_all_MonPon_PfP_ssubst:
   assumes A: "{} \<turnstile> \<alpha> IMP \<beta>"
       and V: "V \<subseteq> Vs"
       and s: "supp \<alpha> \<subseteq> atom ` Vs" "supp \<beta> \<subseteq> atom ` Vs"
     shows    "quote_all p V \<turnstile> PfP (ssubst \<lfloor>\<alpha>\<rfloor>V V F) IMP PfP (ssubst \<lfloor>\<beta>\<rfloor>V V F)"
 using quote_all_PfP_ssubst [OF A V] s
   by (auto simp: V vquot_fm_def intro: PfP_implies_ModPon_PfP thin1)
 
 text\<open>Lemma 8.4b\<close>
 corollary quote_all_MonPon2_PfP_ssubst:
   assumes A: "{} \<turnstile> \<alpha>1 IMP \<alpha>2 IMP \<beta>"
       and V: "V \<subseteq> Vs"
       and s: "supp \<alpha>1 \<subseteq> atom ` Vs" "supp \<alpha>2 \<subseteq> atom ` Vs" "supp \<beta> \<subseteq> atom ` Vs"
     shows "quote_all p V \<turnstile> PfP (ssubst \<lfloor>\<alpha>1\<rfloor>V V F) IMP PfP (ssubst \<lfloor>\<alpha>2\<rfloor>V V F) IMP PfP (ssubst \<lfloor>\<beta>\<rfloor>V V F)"
 using quote_all_PfP_ssubst [OF A V] s
   by (force simp: V vquot_fm_def intro: PfP_implies_ModPon_PfP [OF PfP_implies_ModPon_PfP] thin1)
 
 lemma quote_all_Disj_I1_PfP_ssubst:
   assumes "V \<subseteq> Vs" "supp \<alpha> \<subseteq> atom ` Vs" "supp \<beta> \<subseteq> atom ` Vs"
       and prems: "H \<turnstile> PfP (ssubst \<lfloor>\<alpha>\<rfloor>V V F)" "quote_all p V \<subseteq> H"
     shows "H \<turnstile> PfP (ssubst \<lfloor>\<alpha> OR \<beta>\<rfloor>V V F)"
 proof -
   have "{} \<turnstile> \<alpha> IMP (\<alpha> OR \<beta>)"
     by (blast intro: Disj_I1)
   hence "quote_all p V \<turnstile> PfP (ssubst \<lfloor>\<alpha>\<rfloor>V V F) IMP PfP (ssubst \<lfloor>\<alpha> OR \<beta>\<rfloor>V V F)"
     using assms by (auto simp: quote_all_MonPon_PfP_ssubst)
   thus ?thesis
     by (metis MP_same prems thin)
 qed
 
 lemma quote_all_Disj_I2_PfP_ssubst:
   assumes "V \<subseteq> Vs" "supp \<alpha> \<subseteq> atom ` Vs" "supp \<beta> \<subseteq> atom ` Vs"
       and prems: "H \<turnstile> PfP (ssubst \<lfloor>\<beta>\<rfloor>V V F)" "quote_all p V \<subseteq> H"
     shows "H \<turnstile> PfP (ssubst \<lfloor>\<alpha> OR \<beta>\<rfloor>V V F)"
 proof -
   have "{} \<turnstile> \<beta> IMP (\<alpha> OR \<beta>)"
     by (blast intro: Disj_I2)
   hence "quote_all p V \<turnstile> PfP (ssubst \<lfloor>\<beta>\<rfloor>V V F) IMP PfP (ssubst \<lfloor>\<alpha> OR \<beta>\<rfloor>V V F)"
     using assms by (auto simp: quote_all_MonPon_PfP_ssubst)
   thus ?thesis
     by (metis MP_same prems thin)
 qed
 
 lemma quote_all_Conj_I_PfP_ssubst:
   assumes "V \<subseteq> Vs" "supp \<alpha> \<subseteq> atom ` Vs" "supp \<beta> \<subseteq> atom ` Vs"
       and prems: "H \<turnstile> PfP (ssubst \<lfloor>\<alpha>\<rfloor>V V F)" "H \<turnstile> PfP (ssubst \<lfloor>\<beta>\<rfloor>V V F)" "quote_all p V \<subseteq> H"
     shows "H \<turnstile> PfP (ssubst \<lfloor>\<alpha> AND \<beta>\<rfloor>V V F)"
 proof -
   have "{} \<turnstile> \<alpha> IMP \<beta> IMP (\<alpha> AND \<beta>)"
     by blast
   hence "quote_all p V
          \<turnstile> PfP (ssubst \<lfloor>\<alpha>\<rfloor>V V F) IMP PfP (ssubst \<lfloor>\<beta>\<rfloor>V V F) IMP PfP (ssubst \<lfloor>\<alpha> AND \<beta>\<rfloor>V V F)"
     using assms by (auto simp: quote_all_MonPon2_PfP_ssubst)
   thus ?thesis
     by (metis MP_same prems thin)
 qed
 
 lemma quote_all_Contra_PfP_ssubst:
   assumes "V \<subseteq> Vs" "supp \<alpha> \<subseteq> atom ` Vs"
   shows "quote_all p V
          \<turnstile> PfP (ssubst \<lfloor>\<alpha>\<rfloor>V V F) IMP PfP (ssubst \<lfloor>Neg \<alpha>\<rfloor>V V F) IMP PfP (ssubst \<lfloor>Fls\<rfloor>V V F)"
 proof -
   have "{} \<turnstile> \<alpha> IMP Neg \<alpha> IMP Fls"
     by blast
   thus ?thesis
     using assms by (auto simp: quote_all_MonPon2_PfP_ssubst supp_conv_fresh)
 qed
 
 lemma fresh_ssubst_dbtm: "\<lbrakk>atom i \<sharp> p\<bullet>V; V \<subseteq> Vs\<rbrakk> \<Longrightarrow> atom i \<sharp> ssubst (vquot_dbtm V t) V F"
   by (induct t rule: dbtm.induct) (auto simp: F_unfold fresh_image permute_set_eq_image)
 
 lemma fresh_ssubst_dbfm: "\<lbrakk>atom i \<sharp> p\<bullet>V; V \<subseteq> Vs\<rbrakk> \<Longrightarrow> atom i \<sharp> ssubst (vquot_dbfm V A) V F"
   by (nominal_induct A rule: dbfm.strong_induct) (auto simp: fresh_ssubst_dbtm)
 
 lemma fresh_ssubst_fm:
   fixes A::fm shows "\<lbrakk>atom i \<sharp> p\<bullet>V; V \<subseteq> Vs\<rbrakk> \<Longrightarrow> atom i \<sharp> ssubst (\<lfloor>A\<rfloor>V) V F"
   by (simp add: fresh_ssubst_dbfm vquot_fm_def)
 
 end
 
 
 section \<open>Star Property. Equality and Membership: Lemmas 9.3 and 9.4\<close>
 
 lemma SeqQuoteP_Mem_imp_QMem_and_Subset:
   assumes "atom i \<sharp> (j,j',i',si,ki,sj,kj)" "atom i' \<sharp> (j,j',si,ki,sj,kj)"
           "atom j \<sharp> (j',si,ki,sj,kj)" "atom j' \<sharp> (si,ki,sj,kj)"
           "atom si \<sharp> (ki,sj,kj)" "atom sj \<sharp> (ki,kj)"
   shows "{SeqQuoteP (Var i) (Var i') (Var si) ki, SeqQuoteP (Var j) (Var j') (Var sj) kj}
          \<turnstile> (Var i IN Var j IMP PfP (Q_Mem (Var i') (Var j')))  AND
            (Var i SUBS Var j IMP PfP (Q_Subset (Var i') (Var j')))"
 proof -
   obtain k::name and l::name and li::name and lj::name
      and m::name and n::name and sm::name and sn::name and sm'::name and sn'::name
    where atoms: "atom lj \<sharp> (li,l,i,j,j',i',si,ki,sj,kj,i,i',k,m,n,sm,sm',sn,sn')"
                 "atom li \<sharp> (l,j,j',i,i',si,ki,sj,kj,i,i',k,m,n,sm,sm',sn,sn')"
                 "atom l \<sharp> (j,j',i,i',si,ki,sj,kj,i,i',k,m,n,sm,sm',sn,sn')"
                 "atom k \<sharp> (j,j',i,i',si,ki,sj,kj,m,n,sm,sm',sn,sn')"
                 "atom m \<sharp> (j,j',i,i',si,ki,sj,kj,n,sm,sm',sn,sn')"
                 "atom n \<sharp> (j,j',i,i',si,ki,sj,kj,sm,sm',sn,sn')"
                 "atom sm \<sharp> (j,j',i,i',si,ki,sj,kj,sm',sn,sn')"
                 "atom sm' \<sharp> (j,j',i,i',si,ki,sj,kj,sn,sn')"
                 "atom sn \<sharp> (j,j',i,i',si,ki,sj,kj,sn')"
                 "atom sn' \<sharp> (j,j',i,i',si,ki,sj,kj)"
     by (metis obtain_fresh)
   have "{OrdP(Var k)}
        \<turnstile> All i (All i' (All si (All li (All j (All j' (All sj (All lj
           (SeqQuoteP (Var i) (Var i') (Var si) (Var li) IMP
            SeqQuoteP (Var j) (Var j') (Var sj) (Var lj) IMP
            HaddP (Var li) (Var lj) (Var k) IMP
              ( (Var i IN Var j IMP PfP (Q_Mem (Var i') (Var j')))  AND
                (Var i SUBS Var j IMP PfP (Q_Subset (Var i') (Var j'))))))))))))"
         (is "_ \<turnstile> ?scheme")
     proof (rule OrdIndH [where j=l])
       show "atom l \<sharp> (k, ?scheme)" using atoms
         by simp
     next
       define V p where "V = {i,j,sm,sn}"
         and "p = (atom i \<rightleftharpoons> atom i') + (atom j \<rightleftharpoons> atom j') +
                  (atom sm \<rightleftharpoons> atom sm') + (atom sn \<rightleftharpoons> atom sn')"
       define F where "F \<equiv> make_F V p"
       interpret qp: quote_perm p V F
         proof unfold_locales
           show "finite V" by (simp add: V_def)
           show "atom ` (p \<bullet> V) \<sharp>* V"
             using atoms assms
             by (auto simp: p_def V_def F_def make_F_def fresh_star_def fresh_finite_insert)
           show "-p = p"  using assms atoms
             by (simp add: p_def add.assoc perm_self_inverseI fresh_swap fresh_plus_perm)
           show "F \<equiv> make_F V p"
             by (rule F_def)
         qed
       have V_mem: "i \<in> V" "j \<in> V" "sm \<in> V" "sn \<in> V"
         by (auto simp: V_def)  \<comment> \<open>Part of (2) from page 32\<close>
       have Mem1: "{} \<turnstile> (Var i IN Var sm) IMP (Var i IN Eats (Var sm) (Var sn))"
         by (blast intro: Mem_Eats_I1)
       have Q_Mem1: "quote_all p V
                      \<turnstile> PfP (Q_Mem (Var i') (Var sm')) IMP
                        PfP (Q_Mem (Var i') (Q_Eats (Var sm') (Var sn')))"
          using qp.quote_all_MonPon_PfP_ssubst [OF Mem1 subset_refl] assms atoms V_mem
          by (simp add: vquot_fm_def qp.Vs) (simp add: qp.F_unfold p_def)
       have Mem2: "{} \<turnstile> (Var i EQ Var sn) IMP (Var i IN Eats (Var sm) (Var sn))"
         by (blast intro: Mem_Eats_I2)
       have Q_Mem2: "quote_all p V
                  \<turnstile> PfP (Q_Eq (Var i') (Var sn')) IMP
                    PfP (Q_Mem (Var i') (Q_Eats (Var sm') (Var sn')))"
          using qp.quote_all_MonPon_PfP_ssubst [OF Mem2 subset_refl] assms atoms V_mem
          by (simp add: vquot_fm_def qp.Vs) (simp add: qp.F_unfold p_def)
       have Subs1: "{} \<turnstile> Zero SUBS Var j"
         by blast
       have Q_Subs1: "{QuoteP (Var j) (Var j')} \<turnstile> PfP (Q_Subset Zero (Var j'))"
          using qp.quote_all_PfP_ssubst [OF Subs1, of "{j}"] assms atoms
          by (simp add: qp.ssubst_Subset vquot_tm_def supp_conv_fresh fresh_at_base del: qp.ssubst_single)
             (simp add: qp.F_unfold p_def V_def)
       have Subs2: "{} \<turnstile> Var sm SUBS Var j IMP Var sn IN Var j IMP Eats (Var sm) (Var sn) SUBS Var j"
         by blast
       have Q_Subs2: "quote_all p V
                      \<turnstile> PfP (Q_Subset (Var sm') (Var j')) IMP
                        PfP (Q_Mem (Var sn') (Var j')) IMP
                        PfP (Q_Subset (Q_Eats (Var sm') (Var sn')) (Var j'))"
          using qp.quote_all_MonPon2_PfP_ssubst [OF Subs2 subset_refl] assms atoms V_mem
          by (simp add: qp.ssubst_Subset vquot_tm_def supp_conv_fresh subset_eq fresh_at_base)
             (simp add: vquot_fm_def qp.F_unfold p_def V_def)
       have Ext: "{} \<turnstile> Var i SUBS Var sn IMP Var sn SUBS Var i IMP Var i EQ Var sn"
         by (blast intro: Equality_I)
       have Q_Ext: "{QuoteP (Var i) (Var i'), QuoteP (Var sn) (Var sn')}
                    \<turnstile> PfP (Q_Subset (Var i') (Var sn')) IMP
                      PfP (Q_Subset (Var sn') (Var i')) IMP
                      PfP (Q_Eq (Var i') (Var sn'))"
          using qp.quote_all_MonPon2_PfP_ssubst [OF Ext, of "{i,sn}"] assms atoms
          by (simp add: qp.ssubst_Subset vquot_tm_def supp_conv_fresh subset_eq fresh_at_base
                   del: qp.ssubst_single)
             (simp add: vquot_fm_def qp.F_unfold p_def V_def)
       show "{} \<turnstile> All k (OrdP (Var k) IMP (All2 l (Var k) (?scheme(k::= Var l)) IMP ?scheme))"
         apply (rule All_I Imp_I)+
         using atoms assms
         apply simp_all
         apply (rule cut_same [where A = "QuoteP (Var i) (Var i')"])
         apply (blast intro: QuoteP_I)
         apply (rule cut_same [where A = "QuoteP (Var j) (Var j')"])
         apply (blast intro: QuoteP_I)
         apply (rule rotate6)
         apply (rule Conj_I)
         \<comment> \<open>@{term"Var i IN Var j IMP PfP (Q_Mem (Var i') (Var j'))"}\<close>
         apply (rule cut_same)
         apply (rule cut1 [OF SeqQuoteP_lemma [of m "Var j" "Var j'" "Var sj" "Var lj" n sm sm' sn sn']], simp_all, blast)
         apply (rule Imp_I Disj_EH Conj_EH)+
         \<comment> \<open>case 1, @{term "Var j EQ Zero"}\<close>
         apply (rule cut_same [where A = "Var i IN Zero"])
         apply (blast intro: Mem_cong [THEN Iff_MP_same], blast)
         \<comment> \<open>case 2, @{term "Var j EQ Eats (Var sm) (Var sn)"}\<close>
         apply (rule Imp_I Conj_EH Ex_EH)+
         apply simp_all
         apply (rule Var_Eq_subst_Iff [THEN rotate2, THEN Iff_MP_same], simp)
         apply (rule cut_same [where A = "QuoteP (Var sm) (Var sm')"])
         apply (blast intro: QuoteP_I)
         apply (rule cut_same [where A = "QuoteP (Var sn) (Var sn')"])
         apply (blast intro: QuoteP_I)
         apply (rule cut_same [where A = "Var i IN Eats (Var sm) (Var sn)"])
         apply (rule Mem_cong [OF Refl, THEN Iff_MP_same])
         apply (rule AssumeH Mem_Eats_E)+
         \<comment> \<open>Eats case 1. IH for sm\<close>
         apply (rule cut_same [where A = "OrdP (Var m)"])
         apply (blast intro: Hyp Ord_IN_Ord SeqQuoteP_imp_OrdP [THEN cut1])
         apply (rule cut_same [OF exists_HaddP [where j=l and x="Var li" and y="Var m"]])
         apply auto
         apply (rule All2_E [where x="Var l", THEN rotate13], simp_all)
         apply (blast intro: Hyp HaddP_Mem_cancel_left [THEN Iff_MP2_same] SeqQuoteP_imp_OrdP [THEN cut1])
         apply (rule All_E [where x="Var i"], simp)
         apply (rule All_E [where x="Var i'"], simp)
         apply (rule All_E [where x="Var si"], simp)
         apply (rule All_E [where x="Var li"], simp)
         apply (rule All_E [where x="Var sm"], simp)
         apply (rule All_E [where x="Var sm'"], simp)
         apply (rule All_E [where x="Var sj"], simp)
         apply (rule All_E [where x="Var m"], simp)
         apply (force intro: MP_thin [OF Q_Mem1] simp add: V_def p_def)
         \<comment> \<open>Eats case 2\<close>
         apply (rule rotate13)
         apply (rule cut_same [where A = "OrdP (Var n)"])
         apply (blast intro: Hyp Ord_IN_Ord SeqQuoteP_imp_OrdP [THEN cut1])
         apply (rule cut_same [OF exists_HaddP [where j=l and x="Var li" and y="Var n"]])
         apply auto
         apply (rule MP_same)
         apply (rule Q_Mem2 [THEN thin])
         apply (simp add: V_def p_def)
         apply (rule MP_same)
         apply (rule MP_same)
         apply (rule Q_Ext [THEN thin])
         apply (simp add: V_def p_def)
         \<comment> \<open>@{term"PfP (Q_Subset (Var i') (Var sn'))"}\<close>
         apply (rule All2_E [where x="Var l", THEN rotate14], simp_all)
         apply (blast intro: Hyp HaddP_Mem_cancel_left [THEN Iff_MP2_same] SeqQuoteP_imp_OrdP [THEN cut1])
         apply (rule All_E [where x="Var i"], simp)
         apply (rule All_E [where x="Var i'"], simp)
         apply (rule All_E [where x="Var si"], simp)
         apply (rule All_E [where x="Var li"], simp)
         apply (rule All_E [where x="Var sn"], simp)
         apply (rule All_E [where x="Var sn'"], simp)
         apply (rule All_E [where x="Var sj"], simp)
         apply (rule All_E [where x="Var n"], simp)
         apply (rule Imp_E, blast intro: Hyp)+
         apply (rule Conj_E)
         apply (rule thin1)
         apply (blast intro!: Imp_E EQ_imp_SUBS [THEN cut1])
         \<comment> \<open>@{term"PfP (Q_Subset (Var sn') (Var i'))"}\<close>
         apply (rule All2_E [where x="Var l", THEN rotate14], simp_all)
         apply (blast intro: Hyp HaddP_Mem_cancel_left [THEN Iff_MP2_same] SeqQuoteP_imp_OrdP [THEN cut1])
         apply (rule All_E [where x="Var sn"], simp)
         apply (rule All_E [where x="Var sn'"], simp)
         apply (rule All_E [where x="Var sj"], simp)
         apply (rule All_E [where x="Var n"], simp)
         apply (rule All_E [where x="Var i"], simp)
         apply (rule All_E [where x="Var i'"], simp)
         apply (rule All_E [where x="Var si"], simp)
         apply (rule All_E [where x="Var li"], simp)
         apply (rule Imp_E, blast intro: Hyp)+
         apply (rule Imp_E)
         apply (blast intro: Hyp HaddP_commute [THEN cut2] SeqQuoteP_imp_OrdP [THEN cut1])
         apply (rule Conj_E)
         apply (rule thin1)
         apply (blast intro!: Imp_E EQ_imp_SUBS2 [THEN cut1])
         \<comment> \<open>@{term"Var i SUBS Var j IMP PfP (Q_Subset (Var i') (Var j'))"}\<close>
         apply (rule cut_same)
         apply (rule cut1 [OF SeqQuoteP_lemma [of m "Var i" "Var i'" "Var si" "Var li" n sm sm' sn sn']], simp_all, blast)
         apply (rule Imp_I Disj_EH Conj_EH)+
         \<comment> \<open>case 1, Var i EQ Zero\<close>
         apply (rule cut_same [where A = "PfP (Q_Subset Zero (Var j'))"])
         apply (blast intro: Q_Subs1 [THEN cut1] SeqQuoteP_imp_QuoteP [THEN cut1])
         apply (force intro: Var_Eq_subst_Iff [THEN Iff_MP_same, THEN rotate3])
         \<comment> \<open>case 2, @{term "Var i EQ Eats (Var sm) (Var sn)"}\<close>
         apply (rule Conj_EH Ex_EH)+
         apply simp_all
         apply (rule cut_same [where A = "OrdP (Var lj)"])
         apply (blast intro: Hyp SeqQuoteP_imp_OrdP [THEN cut1])
         apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same, THEN rotate3], simp)
         apply (rule cut_same [where A = "QuoteP (Var sm) (Var sm')"])
         apply (blast intro: QuoteP_I)
         apply (rule cut_same [where A = "QuoteP (Var sn) (Var sn')"])
         apply (blast intro: QuoteP_I)
         apply (rule cut_same [where A = "Eats (Var sm) (Var sn) SUBS Var j"])
         apply (rule Subset_cong [OF _ Refl, THEN Iff_MP_same])
         apply (rule AssumeH Mem_Eats_E)+
         \<comment> \<open>Eats case split\<close>
         apply (rule Eats_Subset_E)
         apply (rule rotate15)
         apply (rule MP_same [THEN MP_same])
         apply (rule Q_Subs2 [THEN thin])
         apply (simp add: V_def p_def)
         \<comment> \<open>Eats case 1: @{term "PfP (Q_Subset (Var sm') (Var j'))"}\<close>
         apply (rule cut_same [OF exists_HaddP [where j=l and x="Var m" and y="Var lj"]])
         apply (rule AssumeH Ex_EH Conj_EH | simp)+
         \<comment> \<open>IH for sm\<close>
         apply (rule All2_E [where x="Var l", THEN rotate15], simp_all)
         apply (blast intro: Hyp HaddP_Mem_cancel_right_Mem SeqQuoteP_imp_OrdP [THEN cut1])
         apply (rule All_E [where x="Var sm"], simp)
         apply (rule All_E [where x="Var sm'"], simp)
         apply (rule All_E [where x="Var si"], simp)
         apply (rule All_E [where x="Var m"], simp)
         apply (rule All_E [where x="Var j"], simp)
         apply (rule All_E [where x="Var j'"], simp)
         apply (rule All_E [where x="Var sj"], simp)
         apply (rule All_E [where x="Var lj"], simp)
         apply (blast intro: thin1 Imp_E)
         \<comment> \<open>Eats case 2: @{term "PfP (Q_Mem (Var sn') (Var j'))"}\<close>
         apply (rule cut_same [OF exists_HaddP [where j=l and x="Var n" and y="Var lj"]])
         apply (rule AssumeH Ex_EH Conj_EH | simp)+
         \<comment> \<open>IH for sn\<close>
         apply (rule All2_E [where x="Var l", THEN rotate15], simp_all)
         apply (blast intro: Hyp HaddP_Mem_cancel_right_Mem SeqQuoteP_imp_OrdP [THEN cut1])
         apply (rule All_E [where x="Var sn"], simp)
         apply (rule All_E [where x="Var sn'"], simp)
         apply (rule All_E [where x="Var si"], simp)
         apply (rule All_E [where x="Var n"], simp)
         apply (rule All_E [where x="Var j"], simp)
         apply (rule All_E [where x="Var j'"], simp)
         apply (rule All_E [where x="Var sj"], simp)
         apply (rule All_E [where x="Var lj"], simp)
         apply (blast intro: Hyp Imp_E)
         done
     qed
   hence p1: "{OrdP(Var k)}
              \<turnstile> (All i' (All si (All li
                   (All j (All j' (All sj (All lj
                         (SeqQuoteP (Var i) (Var i') (Var si) (Var li) IMP
                          SeqQuoteP (Var j) (Var j') (Var sj) (Var lj) IMP
                          HaddP (Var li) (Var lj) (Var k) IMP
                          (Var i IN Var j IMP PfP (Q_Mem (Var i') (Var j'))) AND
                          (Var i SUBS Var j IMP PfP (Q_Subset (Var i') (Var j'))))))))))) (i::= Var i)"
         by (metis All_D)
   have p2: "{OrdP(Var k)}
             \<turnstile> (All si (All li
                 (All j (All j' (All sj (All lj
                       (SeqQuoteP (Var i) (Var i') (Var si) (Var li) IMP
                        SeqQuoteP (Var j) (Var j') (Var sj) (Var lj) IMP
                        HaddP (Var li) (Var lj) (Var k) IMP
                        (Var i IN Var j IMP PfP (Q_Mem (Var i') (Var j'))) AND
                        (Var i SUBS Var j IMP PfP (Q_Subset (Var i') (Var j'))))))))))(i'::= Var i')"
     apply (rule All_D)
     using atoms p1 by simp
   have p3: "{OrdP(Var k)}
             \<turnstile> (All li
               (All j (All j' (All sj (All lj
                     (SeqQuoteP (Var i) (Var i') (Var si) (Var li) IMP
                      SeqQuoteP (Var j) (Var j') (Var sj) (Var lj) IMP
                      HaddP (Var li) (Var lj) (Var k) IMP
                      (Var i IN Var j IMP PfP (Q_Mem (Var i') (Var j'))) AND
                      (Var i SUBS Var j IMP PfP (Q_Subset (Var i') (Var j'))))))))) (si::= Var si)"
     apply (rule All_D)
     using atoms p2 by simp
   have p4: "{OrdP(Var k)}
             \<turnstile> (All j (All j' (All sj (All lj
                     (SeqQuoteP (Var i) (Var i') (Var si) (Var li) IMP
                      SeqQuoteP (Var j) (Var j') (Var sj) (Var lj) IMP
                      HaddP (Var li) (Var lj) (Var k) IMP
                      (Var i IN Var j IMP PfP (Q_Mem (Var i') (Var j'))) AND
                      (Var i SUBS Var j IMP PfP (Q_Subset (Var i') (Var j')))))))) (li::= ki)"
     apply (rule All_D)
     using atoms p3 by simp
   have p5: "{OrdP(Var k)}
             \<turnstile> (All j' (All sj (All lj
                 (SeqQuoteP (Var i) (Var i') (Var si) ki IMP
                  SeqQuoteP (Var j) (Var j') (Var sj) (Var lj) IMP
                  HaddP ki (Var lj) (Var k) IMP
                  (Var i IN Var j IMP PfP (Q_Mem (Var i') (Var j'))) AND
                  (Var i SUBS Var j IMP PfP (Q_Subset (Var i') (Var j'))))))) (j::= Var j)"
     apply (rule All_D)
     using atoms assms p4 by simp
   have p6: "{OrdP(Var k)}
             \<turnstile> (All sj (All lj
                   (SeqQuoteP (Var i) (Var i') (Var si) ki IMP
                    SeqQuoteP (Var j) (Var j') (Var sj) (Var lj) IMP
                    HaddP ki (Var lj) (Var k) IMP
                    (Var i IN Var j IMP PfP (Q_Mem (Var i') (Var j'))) AND
                    (Var i SUBS Var j IMP PfP (Q_Subset (Var i') (Var j')))))) (j'::= Var j')"
     apply (rule All_D)
     using atoms p5 by simp
   have p7: "{OrdP(Var k)}
             \<turnstile> (All lj (SeqQuoteP (Var i) (Var i') (Var si) ki IMP
                        SeqQuoteP (Var j) (Var j') (Var sj) (Var lj) IMP
                        HaddP ki (Var lj) (Var k) IMP
                        (Var i IN Var j IMP PfP (Q_Mem (Var i') (Var j'))) AND
                        (Var i SUBS Var j IMP PfP (Q_Subset (Var i') (Var j'))))) (sj::= Var sj)"
     apply (rule All_D)
     using atoms p6 by simp
   have p8: "{OrdP(Var k)}
             \<turnstile> (SeqQuoteP (Var i) (Var i') (Var si) ki IMP
                SeqQuoteP (Var j) (Var j') (Var sj) (Var lj) IMP
                HaddP ki (Var lj) (Var k) IMP
                (Var i IN Var j IMP PfP (Q_Mem (Var i') (Var j'))) AND
                (Var i SUBS Var j IMP PfP (Q_Subset (Var i') (Var j')))) (lj::= kj)"
     apply (rule All_D)
     using atoms p7 by simp
   hence p9: "{OrdP(Var k)}
              \<turnstile> SeqQuoteP (Var i) (Var i') (Var si) ki IMP
                SeqQuoteP (Var j) (Var j') (Var sj) kj IMP
                HaddP ki kj (Var k) IMP
                (Var i IN Var j IMP PfP (Q_Mem (Var i') (Var j'))) AND
                (Var i SUBS Var j IMP PfP (Q_Subset (Var i') (Var j')))"
     using assms atoms by simp
   have p10:  "{ HaddP ki kj (Var k),
                SeqQuoteP (Var i) (Var i') (Var si) ki,
                SeqQuoteP (Var j) (Var j') (Var sj) kj, OrdP (Var k) }
              \<turnstile> (Var i IN Var j IMP PfP (Q_Mem (Var i') (Var j'))) AND
                (Var i SUBS Var j IMP PfP (Q_Subset (Var i') (Var j')))"
     apply (rule MP_same [THEN MP_same [THEN MP_same]])
     apply (rule p9 [THEN thin])
     apply (auto intro: MP_same)
     done
   show ?thesis
     apply (rule cut_same [OF exists_HaddP [where j=k and x=ki and y=kj]])
     apply (metis SeqQuoteP_imp_OrdP thin1)
     prefer 2
     apply (rule Ex_E)
     apply (rule p10 [THEN cut4])
     using assms atoms
     apply (auto intro: HaddP_OrdP SeqQuoteP_imp_OrdP [THEN cut1])
     done
 qed
 
 
 lemma
   assumes "atom i \<sharp> (j,j',i')" "atom i' \<sharp> (j,j')" "atom j \<sharp> (j')"
   shows QuoteP_Mem_imp_QMem:
         "{QuoteP (Var i) (Var i'), QuoteP (Var j) (Var j'), Var i IN Var j}
          \<turnstile> PfP (Q_Mem (Var i') (Var j'))"     (is ?thesis1)
     and QuoteP_Mem_imp_QSubset:
         "{QuoteP (Var i) (Var i'), QuoteP (Var j) (Var j'), Var i SUBS Var j}
          \<turnstile> PfP (Q_Subset (Var i') (Var j'))"  (is ?thesis2)
 proof -
   obtain si::name and ki::name and sj::name and kj::name
     where atoms: "atom si \<sharp> (ki,sj,kj,i,j,j',i')"  "atom ki \<sharp> (sj,kj,i,j,j',i')"
                  "atom sj \<sharp> (kj,i,j,j',i')"  "atom kj \<sharp> (i,j,j',i')"
     by (metis obtain_fresh)
   hence C:  "{QuoteP (Var i) (Var i'), QuoteP (Var j) (Var j')}
              \<turnstile> (Var i IN Var j IMP PfP (Q_Mem (Var i') (Var j')))  AND
                (Var i SUBS Var j IMP PfP (Q_Subset (Var i') (Var j')))"
     using assms
     by (auto simp: QuoteP.simps [of si "Var i" _ ki] QuoteP.simps [of sj "Var j" _ kj]
              intro!: SeqQuoteP_Mem_imp_QMem_and_Subset del: Conj_I)
   show ?thesis1
     by (best intro: Conj_E1 [OF C, THEN MP_thin])
   show ?thesis2
     by (best intro: Conj_E2 [OF C, THEN MP_thin])
 qed
 
 
 section \<open>Star Property. Universal Quantifier: Lemma 9.7\<close>
 
 lemma (in quote_perm) SeqQuoteP_Mem_imp_All2:
   assumes IH: "insert (QuoteP (Var i) (Var i')) (quote_all p Vs)
                \<turnstile> \<alpha> IMP PfP (ssubst \<lfloor>\<alpha>\<rfloor>(insert i Vs) (insert i Vs) Fi)"
       and sp: "supp \<alpha> - {atom i} \<subseteq> atom ` Vs"
       and j: "j \<in> Vs" and j': "p \<bullet> j = j'"
       and pi: "pi = (atom i \<rightleftharpoons> atom i') + p"
       and Fi: "Fi = make_F (insert i Vs) pi"
       and atoms: "atom i \<sharp> (j,j',s,k,p)" "atom i' \<sharp> (i,p,\<alpha>)"
                  "atom j \<sharp> (j',s,k,\<alpha>)" "atom j' \<sharp> (s,k,\<alpha>)"
                  "atom s \<sharp> (k,\<alpha>)" "atom k \<sharp> (\<alpha>,p)"
   shows "insert (SeqQuoteP (Var j) (Var j') (Var s) (Var k)) (quote_all p (Vs-{j}))
          \<turnstile> All2 i (Var j) \<alpha> IMP PfP (ssubst \<lfloor>All2 i (Var j) \<alpha>\<rfloor>Vs Vs F)"
 proof -
   have pj' [simp]: "p \<bullet> j' = j" using pinv j'
     by (metis permute_minus_cancel(2))
   have [simp]: "F j = Var j'" using j j'
     by (auto simp: F_unfold)
   hence i': "atom i' \<sharp> Vs" using atoms
     by (auto simp: Vs)
   have fresh_ss [simp]: "\<And>i A::fm. atom i \<sharp> p \<Longrightarrow> atom i \<sharp> ssubst (\<lfloor>A\<rfloor>Vs) Vs F"
     by (simp add: vquot_fm_def fresh_ssubst_dbfm)
   obtain l::name and m::name and n::name and sm::name and sn::name and sm'::name and sn'::name
     where atoms': "atom l \<sharp> (p,\<alpha>,i,j,j',s,k,m,n,sm,sm',sn,sn')"
        "atom m \<sharp> (p,\<alpha>,i,j,j',s,k,n,sm,sm',sn,sn')" "atom n \<sharp> (p,\<alpha>,i,j,j',s,k,sm,sm',sn,sn')"
        "atom sm \<sharp> (p,\<alpha>,i,j,j',s,k,sm',sn,sn')" "atom sm' \<sharp> (p,\<alpha>,i,j,j',s,k,sn,sn')"
        "atom sn \<sharp> (p,\<alpha>,i,j,j',s,k,sn')" "atom sn' \<sharp> (p,\<alpha>,i,j,j',s,k)"
     by (metis obtain_fresh)
   define V' p'
     where "V' = {sm,sn} \<union> Vs"
       and "p' = (atom sm \<rightleftharpoons> atom sm') + (atom sn \<rightleftharpoons> atom sn') + p"
   define F' where "F' \<equiv> make_F V' p'"
   interpret qp': quote_perm p' V' F'
     proof unfold_locales
       show "finite V'" by (simp add: V'_def)
       show "atom ` (p' \<bullet> V') \<sharp>* V'"
         using atoms atoms' p
         by (auto simp: p'_def V'_def swap_fresh_fresh fresh_at_base_permI
                 fresh_star_finite_insert fresh_finite_insert atom_fresh_star_atom_set_conv)
       show "F' \<equiv> make_F V' p'"
         by (rule F'_def)
       show "- p' = p'" using atoms atoms' pinv
         by (simp add: p'_def add.assoc perm_self_inverseI fresh_swap fresh_plus_perm)
     qed
   have All2_Zero: "{} \<turnstile> All2 i Zero \<alpha>"
     by auto
   have Q_All2_Zero:
     "quote_all p Vs \<turnstile> PfP (Q_All (Q_Imp (Q_Mem (Q_Ind Zero) Zero)
                                 (ssubst (vquot_dbfm Vs (trans_fm [i] \<alpha>)) Vs F)))"
          using quote_all_PfP_ssubst [OF All2_Zero] assms
          by (force simp add: vquot_fm_def supp_conv_fresh)
   have All2_Eats: "{} \<turnstile> All2 i (Var sm) \<alpha> IMP \<alpha>(i::=Var sn) IMP All2 i (Eats (Var sm) (Var sn)) \<alpha>"
     using atoms'  apply auto
     apply (rule Ex_I [where x = "Var i"], auto)
     apply (rule rotate2)
     apply (blast intro: ContraProve Var_Eq_imp_subst_Iff [THEN Iff_MP_same])
     done
   have [simp]: "F' sm = Var sm'" "F' sn = Var sn'" using atoms'
     by (auto simp: V'_def p'_def qp'.F_unfold swap_fresh_fresh fresh_at_base_permI)
   have smn' [simp]: "sm \<in> V'" "sn \<in> V'" "sm \<notin> Vs" "sn \<notin> Vs" using atoms'
     by (auto simp: V'_def fresh_finite_set_at_base [symmetric])
   hence Q_All2_Eats: "quote_all p' V'
                       \<turnstile> PfP (ssubst \<lfloor>All2 i (Var sm) \<alpha>\<rfloor>V' V' F') IMP
                         PfP (ssubst \<lfloor>\<alpha>(i::=Var sn)\<rfloor>V' V' F') IMP
                         PfP (ssubst \<lfloor>All2 i (Eats (Var sm) (Var sn)) \<alpha>\<rfloor>V' V' F')"
      using sp  qp'.quote_all_MonPon2_PfP_ssubst [OF All2_Eats subset_refl]
      by (simp add: supp_conv_fresh subset_eq V'_def)
         (metis Diff_iff empty_iff fresh_ineq_at_base insertE mem_Collect_eq)
   interpret qpi: quote_perm pi "insert i Vs" Fi
     unfolding pi
     apply (rule qp_insert) using atoms
     apply (auto simp: Fi pi)
     done
   have F'_eq_F: "\<And>name. name \<in> Vs \<Longrightarrow> F' name = F name"
     using atoms'
     by (auto simp: F_unfold qp'.F_unfold p'_def swap_fresh_fresh V'_def fresh_pj)
   { fix t::dbtm
     assume "supp t \<subseteq> atom ` V'" "supp t \<subseteq> atom ` Vs"
     hence "ssubst (vquot_dbtm V' t) V' F' = ssubst (vquot_dbtm Vs t) Vs F"
       by (induction t rule: dbtm.induct) (auto simp: F'_eq_F)
   } note ssubst_v_tm = this
   { fix A::dbfm
     assume "supp A \<subseteq> atom ` V'" "supp A \<subseteq> atom ` Vs"
     hence "ssubst (vquot_dbfm V' A) V' F' = ssubst (vquot_dbfm Vs A) Vs F"
       by (induction A rule: dbfm.induct) (auto simp: ssubst_v_tm F'_eq_F)
   } note ssubst_v_fm = this
   have ss_noprimes: "ssubst (vquot_dbfm V' (trans_fm [i] \<alpha>)) V' F' =
                      ssubst (vquot_dbfm Vs (trans_fm [i] \<alpha>)) Vs F"
     apply (rule ssubst_v_fm)
     using sp  apply (auto simp: V'_def supp_conv_fresh)
     done
   { fix t::dbtm
     assume "supp t - {atom i} \<subseteq> atom ` Vs"
     hence "subst i' (Var sn') (ssubst (vquot_dbtm (insert i Vs) t) (insert i Vs) Fi) =
            ssubst (vquot_dbtm V' (subst_dbtm (DBVar sn) i t)) V' F'"
       apply (induction t rule: dbtm.induct)
       using atoms atoms'
       apply (auto simp: vquot_tm_def pi V'_def qpi.F_unfold qp'.F_unfold p'_def fresh_pj swap_fresh_fresh fresh_at_base_permI)
       done
   } note perm_v_tm = this
   { fix A::dbfm
     assume "supp A - {atom i} \<subseteq> atom ` Vs"
     hence "subst i' (Var sn') (ssubst (vquot_dbfm (insert i Vs) A) (insert i Vs) Fi) =
            ssubst (vquot_dbfm V' (subst_dbfm (DBVar sn) i A)) V' F'"
       by (induct A rule: dbfm.induct) (auto simp: Un_Diff perm_v_tm)
   } note perm_v_fm = this
   have "quote_all p Vs \<turnstile> QuoteP (Var i) (Var i') IMP
                  (\<alpha> IMP PfP (ssubst \<lfloor>\<alpha>\<rfloor>(insert i Vs) (insert i Vs) Fi))"
     using IH by auto
   hence "quote_all p Vs
          \<turnstile> (QuoteP (Var i) (Var i') IMP
                  (\<alpha> IMP PfP (ssubst \<lfloor>\<alpha>\<rfloor>(insert i Vs) (insert i Vs) Fi))) (i'::=Var sn')"
     using atoms IH
     by (force intro!: Subst elim!: fresh_quote_all_mem)
   hence "quote_all p Vs
          \<turnstile> QuoteP (Var i) (Var sn') IMP
            (\<alpha> IMP PfP (subst i' (Var sn') (ssubst \<lfloor>\<alpha>\<rfloor>(insert i Vs) (insert i Vs) Fi)))"
     using atoms by simp
   moreover have "subst i' (Var sn') (ssubst \<lfloor>\<alpha>\<rfloor>(insert i Vs) (insert i Vs) Fi)
                  = ssubst \<lfloor>\<alpha>(i::=Var sn)\<rfloor>V' V' F'"
     using sp
     by (auto simp: vquot_fm_def perm_v_fm supp_conv_fresh subst_fm_trans_commute [symmetric])
   ultimately
   have "quote_all p Vs
          \<turnstile> QuoteP (Var i) (Var sn') IMP (\<alpha> IMP PfP (ssubst \<lfloor>\<alpha>(i::=Var sn)\<rfloor>V' V' F'))"
     by simp
   hence "quote_all p Vs
          \<turnstile> (QuoteP (Var i) (Var sn') IMP (\<alpha> IMP PfP (ssubst \<lfloor>\<alpha>(i::=Var sn)\<rfloor>V' V' F'))) (i::=Var sn)"
     using \<open>atom i \<sharp> _\<close>
     by (force intro!: Subst elim!: fresh_quote_all_mem)
   hence "quote_all p Vs
          \<turnstile> (QuoteP (Var sn) (Var sn') IMP
            (\<alpha>(i::=Var sn) IMP PfP (subst i (Var sn) (ssubst \<lfloor>\<alpha>(i::=Var sn)\<rfloor>V' V' F'))))"
     using atoms atoms' by simp
   moreover have "subst i (Var sn) (ssubst \<lfloor>\<alpha>(i::=Var sn)\<rfloor>V' V' F')
                  = ssubst \<lfloor>\<alpha>(i::=Var sn)\<rfloor>V' V' F'"
     using atoms atoms' i'
     by (auto simp: swap_fresh_fresh fresh_at_base_permI p'_def
              intro!: forget_subst_tm [OF qp'.fresh_ssubst'])
   ultimately
   have "quote_all p Vs
          \<turnstile> QuoteP (Var sn) (Var sn') IMP (\<alpha>(i::=Var sn) IMP PfP (ssubst \<lfloor>\<alpha>(i::=Var sn)\<rfloor>V' V' F'))"
     using atoms atoms' by simp
   hence star0: "insert (QuoteP (Var sn) (Var sn')) (quote_all p Vs)
                 \<turnstile> \<alpha>(i::=Var sn) IMP PfP (ssubst \<lfloor>\<alpha>(i::=Var sn)\<rfloor>V' V' F')"
     by (rule anti_deduction)
   have subst_i_star: "quote_all p' V' \<turnstile> \<alpha>(i::=Var sn) IMP PfP (ssubst \<lfloor>\<alpha>(i::=Var sn)\<rfloor>V' V' F')"
     apply (rule thin [OF star0])
     using atoms'
     apply (force simp: V'_def p'_def fresh_swap fresh_plus_perm fresh_at_base_permI add.assoc
                        quote_all_perm_eq)
     done
   have "insert (OrdP (Var k)) (quote_all p (Vs-{j}))
         \<turnstile> All j (All j' (SeqQuoteP (Var j) (Var j') (Var s) (Var k) IMP
                          All2 i (Var j) \<alpha> IMP PfP (ssubst \<lfloor>All2 i (Var j) \<alpha>\<rfloor>Vs Vs F)))"
         (is "_ \<turnstile> ?scheme")
     proof (rule OrdIndH [where j=l])
       show "atom l \<sharp> (k, ?scheme)" using atoms atoms' j j' fresh_pVs
         by (simp add: fresh_Pair F_unfold)
     next
       have substj: "\<And>t j. atom j \<sharp> \<alpha> \<Longrightarrow> atom (p \<bullet> j) \<sharp> \<alpha> \<Longrightarrow>
                            subst j t (ssubst (vquot_dbfm Vs (trans_fm [i] \<alpha>)) Vs F) =
                            ssubst (vquot_dbfm Vs (trans_fm [i] \<alpha>)) Vs F"
         by (auto simp: fresh_ssubst')
       { fix W
         assume W: "W \<subseteq> Vs"
         hence "finite W" by (metis Vs infinite_super)
         hence "quote_all p' W = quote_all p W" using W
         proof (induction)
           case empty thus ?case
             by simp
         next
           case (insert w W)
           hence "w \<in> Vs" "atom sm \<sharp> p \<bullet> Vs" "atom sm' \<sharp> p \<bullet> Vs" "atom sn \<sharp> p \<bullet> Vs" "atom sn' \<sharp> p \<bullet> Vs"
             using atoms' Vs by (auto simp: fresh_pVs)
           hence "atom sm \<sharp> p \<bullet> w" "atom sm' \<sharp> p \<bullet> w" "atom sn \<sharp> p \<bullet> w" "atom sn' \<sharp> p \<bullet> w"
             by (metis Vs fresh_at_base(2) fresh_finite_set_at_base fresh_permute_left)+
           thus ?case using insert
           by (simp add: p'_def swap_fresh_fresh)
         qed
       }
       hence "quote_all p' Vs = quote_all p Vs"
         by (metis subset_refl)
       also have "... = insert (QuoteP (Var j) (Var j')) (quote_all p (Vs - {j}))"
         using j j' by (auto simp: quote_all_def)
       finally have "quote_all p' V' =
                     {QuoteP (Var sn) (Var sn'), QuoteP (Var sm) (Var sm')} \<union>
                     insert (QuoteP (Var j) (Var j')) (quote_all p (Vs - {j}))"
         using atoms'
         by (auto simp: p'_def V'_def fresh_at_base_permI Collect_disj_Un)
       also have "... = {QuoteP (Var sn) (Var sn'), QuoteP (Var sm) (Var sm'), QuoteP (Var j) (Var j')}
                        \<union> quote_all p (Vs - {j})"
         by blast
       finally have quote_all'_eq:
             "quote_all p' V' =
               {QuoteP (Var sn) (Var sn'), QuoteP (Var sm) (Var sm'), QuoteP (Var j) (Var j')}
               \<union> quote_all p (Vs - {j})" .
       have pjV: "p \<bullet> j \<notin> Vs"
         by (metis j perm_exits_Vs)
       hence jpV: "atom j \<sharp> p \<bullet> Vs"
         by (simp add: fresh_permute_left pinv fresh_finite_set_at_base)
       show "quote_all p (Vs-{j}) \<turnstile> All k (OrdP (Var k) IMP (All2 l (Var k) (?scheme(k::= Var l)) IMP ?scheme))"
         apply (rule All_I Imp_I)+
         using atoms atoms' j jpV pjV
         apply (auto simp: fresh_at_base fresh_finite_set_at_base j' elim!: fresh_quote_all_mem)
         apply (rule cut_same [where A = "QuoteP (Var j) (Var j')"])
         apply (blast intro: QuoteP_I)
         apply (rule cut_same)
         apply (rule cut1 [OF SeqQuoteP_lemma [of m "Var j" "Var j'" "Var s" "Var k" n sm sm' sn sn']], simp_all, blast)
         apply (rule Imp_I Disj_EH Conj_EH)+
         \<comment> \<open>case 1, Var j EQ Zero\<close>
         apply (simp add: vquot_fm_def)
         apply (rule thin1)
         apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same], simp)
         apply (simp add: substj)
         apply (rule Q_All2_Zero [THEN thin])
         using assms
         apply (simp add: quote_all_def, blast)
         \<comment> \<open>case 2, @{term "Var j EQ Eats (Var sm) (Var sn)"}\<close>
         apply (rule Imp_I Conj_EH Ex_EH)+
         using atoms  apply (auto elim!: fresh_quote_all_mem)
         apply (rule cut_same [where A = "QuoteP (Var sm) (Var sm')"])
         apply (blast intro: QuoteP_I)
         apply (rule cut_same [where A = "QuoteP (Var sn) (Var sn')"])
         apply (blast intro: QuoteP_I)
         \<comment> \<open>Eats case. IH for sm\<close>
         apply (rule All2_E [where x="Var m", THEN rotate12], simp_all, blast)
         apply (rule All_E [where x="Var sm"], simp)
         apply (rule All_E [where x="Var sm'"], simp)
         apply (rule Imp_E, blast)
         \<comment> \<open>Setting up the subgoal\<close>
         apply (rule cut_same [where A = "PfP (ssubst \<lfloor>All2 i (Eats (Var sm) (Var sn)) \<alpha>\<rfloor>V' V' F')"])
          defer 1
          apply (rule rotate6)
          apply (simp add: vquot_fm_def)
          apply (rule Var_Eq_subst_Iff [THEN Iff_MP_same], force simp add: substj ss_noprimes j')
         apply (rule cut_same [where A = "All2 i (Eats (Var sm) (Var sn)) \<alpha>"])
          apply (rule All2_cong [OF Hyp Iff_refl, THEN Iff_MP_same], blast)
           apply (force elim!: fresh_quote_all_mem
                        simp add: fresh_at_base fresh_finite_set_at_base, blast)
         apply (rule All2_Eats_E, simp)
         apply (rule MP_same [THEN MP_same])
         apply (rule Q_All2_Eats [THEN thin])
         apply (force simp add: quote_all'_eq)
         \<comment> \<open>Proving @{term "PfP (ssubst \<lfloor>All2 i (Var sm) \<alpha>\<rfloor>V' V' F')"}\<close>
         apply (force intro!: Imp_E [THEN rotate3] simp add: vquot_fm_def substj j' ss_noprimes)
         \<comment> \<open>Proving @{term "PfP (ssubst \<lfloor>\<alpha>(i::=Var sn)\<rfloor>V' V' F')"}\<close>
         apply (rule MP_same [OF subst_i_star [THEN thin]])
         apply (force simp add: quote_all'_eq, blast)
         done
     qed
   hence p1: "insert (OrdP (Var k)) (quote_all p (Vs-{j}))
              \<turnstile> (All j' (SeqQuoteP (Var j) (Var j') (Var s) (Var k) IMP
                 All2 i (Var j) \<alpha> IMP PfP (ssubst \<lfloor>All2 i (Var j) \<alpha>\<rfloor>Vs Vs F))) (j::=Var j)"
     by (metis All_D)
   have "insert (OrdP (Var k)) (quote_all p (Vs-{j}))
         \<turnstile> (SeqQuoteP (Var j) (Var j') (Var s) (Var k) IMP
             All2 i (Var j) \<alpha> IMP PfP (ssubst \<lfloor>All2 i (Var j) \<alpha>\<rfloor>Vs Vs F)) (j'::=Var j')"
     apply (rule All_D)
     using p1 atoms by simp
   thus ?thesis
     using atoms
     by simp (metis SeqQuoteP_imp_OrdP Imp_cut anti_deduction)
 qed
 
 lemma (in quote_perm) quote_all_Mem_imp_All2:
   assumes IH: "insert (QuoteP (Var i) (Var i')) (quote_all p Vs)
                \<turnstile> \<alpha> IMP PfP (ssubst \<lfloor>\<alpha>\<rfloor>(insert i Vs) (insert i Vs) Fi)"
       and "supp (All2 i (Var j) \<alpha>) \<subseteq> atom ` Vs"
       and j: "atom j \<sharp> (i,\<alpha>)" and i: "atom i \<sharp> p" and i': "atom i' \<sharp> (i,p,\<alpha>)"
       and pi: "pi = (atom i \<rightleftharpoons> atom i') + p"
       and Fi: "Fi = make_F (insert i Vs) pi"
   shows "insert (All2 i (Var j) \<alpha>) (quote_all p Vs) \<turnstile> PfP (ssubst \<lfloor>All2 i (Var j) \<alpha>\<rfloor>Vs Vs F)"
 proof -
   have sp: "supp \<alpha> - {atom i} \<subseteq> atom ` Vs" and jV: "j \<in> Vs"
     using assms
     by (auto simp: fresh_def supp_Pair)
   obtain s::name and k::name
     where atoms: "atom s \<sharp> (k,i,j,p\<bullet>j,\<alpha>,p)" "atom k \<sharp> (i,j,p\<bullet>j,\<alpha>,p)"
     by (metis obtain_fresh)
   hence ii: "atom i \<sharp> (j, p \<bullet> j, s, k, p)" using i j
     by (simp add: fresh_Pair) (metis fresh_at_base(2) fresh_perm fresh_permute_left pinv)
   have jj: "atom j \<sharp> (p \<bullet> j, s, k, \<alpha>)" using atoms j
     by (auto simp: fresh_Pair) (metis atom_fresh_perm jV)
   have pj: "atom (p \<bullet> j) \<sharp> (s, k, \<alpha>)" using atoms ii sp jV
     by (simp add: fresh_Pair) (auto simp: fresh_def perm_exits_Vs dest!: subsetD)
   show ?thesis
     apply (rule cut_same [where A = "QuoteP (Var j) (Var (p \<bullet> j))"])
     apply (force intro: jV Hyp simp add: quote_all_def)
     using atoms
     apply (auto simp: QuoteP.simps [of s _ _ k] elim!: fresh_quote_all_mem)
     apply (rule MP_same)
     apply (rule SeqQuoteP_Mem_imp_All2 [OF IH sp jV refl pi Fi ii i' jj pj, THEN thin])
     apply (auto simp: fresh_at_base_permI quote_all_def intro!: fresh_ssubst')
     done
 qed
 
 
 section \<open>The Derivability Condition, Theorem 9.1\<close>
 
 lemma SpecI: "H \<turnstile> A IMP Ex i A"
   by (metis Imp_I Assume Ex_I subst_fm_id)
 
 lemma star:
   fixes p :: perm and F :: "name \<Rightarrow> tm"
   assumes C: "ss_fm \<alpha>"
       and p: "atom ` (p \<bullet> V) \<sharp>* V" "-p = p"
       and V: "finite V" "supp \<alpha> \<subseteq> atom ` V"
       and F: "F = make_F V p"
     shows "insert \<alpha> (quote_all p V) \<turnstile> PfP (ssubst \<lfloor>\<alpha>\<rfloor>V V F)"
 using C V p F
 proof (nominal_induct avoiding: p arbitrary: V F rule: ss_fm.strong_induct)
     case (MemI i j) show ?case
     proof (cases "i=j")
       case True thus ?thesis
         by auto
     next
       case False
       hence ij: "atom i \<sharp> j" "{i, j} \<subseteq> V" using MemI
         by auto
       interpret qp: quote_perm p V F
         by unfold_locales (auto simp: image_iff F make_F_def p MemI)
       have "insert (Var i IN Var j) (quote_all p V) \<turnstile> PfP (Q_Mem (Var (p \<bullet> i)) (Var (p \<bullet> j)))"
         apply (rule QuoteP_Mem_imp_QMem [of i j, THEN cut3])
         using ij  apply (auto simp: quote_all_def qp.atom_fresh_perm intro: Hyp)
         apply (metis atom_eqvt fresh_Pair fresh_at_base(2) fresh_permute_iff qp.atom_fresh_perm)
         done
       thus ?thesis
         apply (simp add: vquot_fm_def)
         using MemI  apply (auto simp: make_F_def)
         done
     qed
   next
     case (DisjI A B)
       interpret qp: quote_perm p V F
         by unfold_locales (auto simp: image_iff DisjI)
     show ?case
       apply auto
       apply (rule_tac [2] qp.quote_all_Disj_I2_PfP_ssubst)
       apply (rule qp.quote_all_Disj_I1_PfP_ssubst)
       using DisjI by auto
   next
     case (ConjI A B)
       interpret qp: quote_perm p V F
         by unfold_locales (auto simp: image_iff ConjI)
     show ?case
       apply (rule qp.quote_all_Conj_I_PfP_ssubst)
       using ConjI  by (auto intro: thin1 thin2)
   next
     case (ExI A i)
     interpret qp: quote_perm p V F
       by unfold_locales (auto simp: image_iff ExI)
     obtain i'::name where i': "atom i' \<sharp> (i,p,A)"
       by (metis obtain_fresh)
     define p' where "p' = (atom i \<rightleftharpoons> atom i') + p"
     define F' where "F' = make_F (insert i V) p'"
     have p'_apply [simp]: "!!v. p' \<bullet> v = (if v=i then i' else if v=i' then i else p \<bullet> v)"
       using  \<open>atom i \<sharp> p\<close>  i'
       by (auto simp: p'_def fresh_Pair fresh_at_base_permI)
          (metis atom_eq_iff fresh_at_base_permI permute_eq_iff swap_at_base_simps(3))
     have p'V: "p' \<bullet> V = p \<bullet> V"
       by (metis i' p'_def permute_plus fresh_Pair qp.fresh_pVs swap_fresh_fresh \<open>atom i \<sharp> p\<close>)
     have i: "i \<notin> V" "i \<notin> p \<bullet> V"  "atom i \<sharp> V" "atom i \<sharp> p \<bullet> V"  "atom i \<sharp> p' \<bullet> V" using ExI
       by (auto simp: p'V fresh_finite_set_at_base notin_V)
     interpret qp': quote_perm p' "insert i V" F'
       by (auto simp: qp.qp_insert i' p'_def F'_def  \<open>atom i \<sharp> p\<close>)
     { fix W t assume W: "W \<subseteq> V" "i\<notin>W" "i'\<notin>W"
       hence "finite W" by (metis \<open>finite V\<close> infinite_super)
       hence "ssubst t W F' = ssubst t W F" using W
         by induct (auto simp: qp.ssubst_insert_if qp'.ssubst_insert_if qp.F_unfold qp'.F_unfold)
     }
     hence ss_simp: "ssubst \<lfloor>Ex i A\<rfloor>(insert i V) (insert i V) F' = ssubst \<lfloor>Ex i A\<rfloor>V V F" using i
       by (metis equalityE insertCI p'_apply qp'.perm_exits_Vs qp'.ssubst_vquot_Ex qp.Vs)
     have qa_p': "quote_all p' V = quote_all p V" using i i' ExI.hyps(1)
       by (auto simp: p'_def quote_all_perm_eq)
     have ss: "(quote_all p' (insert i V))
               \<turnstile> PfP (ssubst \<lfloor>A\<rfloor>(insert i V) (insert i V) F') IMP
                 PfP (ssubst \<lfloor>Ex i A\<rfloor>(insert i V) (insert i V) F')"
       apply (rule qp'.quote_all_MonPon_PfP_ssubst [OF SpecI])
       using ExI  apply auto
       done
     hence "insert A (quote_all p' (insert i V))
            \<turnstile> PfP (ssubst \<lfloor>Ex i A\<rfloor>(insert i V) (insert i V) F')"
       apply (rule MP_thin)
       apply (rule ExI(3) [of "insert i V" p' F'])
       apply (metis \<open>finite V\<close> finite_insert)
       using \<open>supp (Ex i A) \<subseteq> _\<close> qp'.p qp'.pinv i'
       apply (auto simp: F'_def fresh_finite_insert)
       done
     hence "insert (QuoteP (Var i) (Var i')) (insert A (quote_all p V))
            \<turnstile> PfP (ssubst \<lfloor>Ex i A\<rfloor>V V F)"
       by (auto simp: insert_commute ss_simp qa_p')
     hence Exi': "insert (Ex i' (QuoteP (Var i) (Var i'))) (insert A (quote_all p V))
                  \<turnstile> PfP (ssubst \<lfloor>Ex i A\<rfloor>V V F)"
       by (auto intro!: qp.fresh_ssubst_fm) (auto simp: ExI i' fresh_quote_all_mem)
     have "insert A (quote_all p V) \<turnstile> PfP (ssubst \<lfloor>Ex i A\<rfloor>V V F)"
       using i'  by (auto intro: cut0 [OF exists_QuoteP Exi'])
     thus "insert (Ex i A) (quote_all p V) \<turnstile> PfP (ssubst \<lfloor>Ex i A\<rfloor>V V F)"
       apply (rule Ex_E, simp)
       apply (rule qp.fresh_ssubst_fm)  using i ExI
       apply (auto simp: fresh_quote_all_mem)
       done
    next
     case (All2I A j i p V F)
     interpret qp: quote_perm p V F
       by unfold_locales (auto simp: image_iff All2I)
     obtain i'::name where i': "atom i' \<sharp> (i,p,A)"
       by (metis obtain_fresh)
     define p' where "p' = (atom i \<rightleftharpoons> atom i') + p"
     define F' where "F' = make_F (insert i V) p'"
     interpret qp': quote_perm p' "insert i V" F'
       using \<open>atom i \<sharp> p\<close> i'
       by (auto simp: qp.qp_insert p'_def F'_def)
     have p'_apply [simp]: "p' \<bullet> i = i'"
       using \<open>atom i \<sharp> p\<close> by (auto simp: p'_def fresh_at_base_permI)
     have qa_p': "quote_all p' V = quote_all p V" using i' All2I
       by (auto simp: p'_def quote_all_perm_eq)
     have "insert A (quote_all p' (insert i V))
           \<turnstile> PfP (ssubst \<lfloor>A\<rfloor>(insert i V) (insert i V) F')"
       apply (rule All2I.hyps)
       using \<open>supp (All2 i _ A) \<subseteq> _\<close>   qp'.p qp'.pinv
       apply (auto simp: F'_def fresh_finite_insert)
       done
     hence "insert (QuoteP (Var i) (Var i')) (quote_all p V)
            \<turnstile> A IMP PfP (ssubst \<lfloor>A\<rfloor>(insert i V) (insert i V) (make_F (insert i V) p'))"
       by (auto simp: insert_commute qa_p' F'_def)
     thus "insert (All2 i (Var j) A) (quote_all p V) \<turnstile> PfP (ssubst \<lfloor>All2 i (Var j) A\<rfloor>V V F)"
       using All2I i' qp.quote_all_Mem_imp_All2 by (simp add: p'_def)
 qed
 
 theorem Provability:
   assumes "Sigma_fm \<alpha>" "ground_fm \<alpha>"
-    shows "{\<alpha>} \<turnstile> PfP \<lceil>\<alpha>\<rceil>"
+    shows "{\<alpha>} \<turnstile> PfP \<guillemotleft>\<alpha>\<guillemotright>"
 proof -
   obtain \<beta> where \<beta>: "ss_fm \<beta>" "ground_fm \<beta>" "{} \<turnstile> \<alpha> IFF \<beta>" using assms
     by (auto simp: Sigma_fm_def ground_fm_aux_def)
-  hence "{\<beta>} \<turnstile> PfP \<lceil>\<beta>\<rceil>" using star [of \<beta> 0 "{}"]
+  hence "{\<beta>} \<turnstile> PfP \<guillemotleft>\<beta>\<guillemotright>" using star [of \<beta> 0 "{}"]
     by (auto simp: ground_fm_aux_def fresh_star_def)
-  then have "{\<alpha>} \<turnstile> PfP \<lceil>\<beta>\<rceil>" using \<beta>
+  then have "{\<alpha>} \<turnstile> PfP \<guillemotleft>\<beta>\<guillemotright>" using \<beta>
     by (metis Iff_MP_left')
-  moreover have "{} \<turnstile> PfP \<lceil>\<beta> IMP \<alpha>\<rceil>" using \<beta>
+  moreover have "{} \<turnstile> PfP \<guillemotleft>\<beta> IMP \<alpha>\<guillemotright>" using \<beta>
     by (metis Conj_E2 Iff_def proved_imp_proved_PfP)
   ultimately show ?thesis
     by (metis PfP_implies_ModPon_PfP_quot thin0)
 qed
 
 end