theory Nominal2_Abs

imports "Nominal2_Base" 

        "~~/src/HOL/Quotient" 

        "~~/src/HOL/Library/Quotient_List"

        "~~/src/HOL/Library/Quotient_Product" 

begin

section {* Abstractions *}

fun

  alpha_set 

where

  alpha_set[simp del]:

  "alpha_set (bs, x) R f p (cs, y) \<longleftrightarrow> 

     f x - bs = f y - cs \<and> 

     (f x - bs) \<sharp>* p \<and> 

     R (p \<bullet> x) y \<and>

     p \<bullet> bs = cs"

fun

  alpha_res

where

  alpha_res[simp del]:

  "alpha_res (bs, x) R f p (cs, y) \<longleftrightarrow> 

     f x - bs = f y - cs \<and> 

     (f x - bs) \<sharp>* p \<and> 

     R (p \<bullet> x) y"

fun

  alpha_lst

where

  alpha_lst[simp del]:

  "alpha_lst (bs, x) R f p (cs, y) \<longleftrightarrow> 

     f x - set bs = f y - set cs \<and> 

     (f x - set bs) \<sharp>* p \<and> 

     R (p \<bullet> x) y \<and>

     p \<bullet> bs = cs"

lemmas alphas = alpha_set.simps alpha_res.simps alpha_lst.simps

notation

  alpha_set ("_ \<approx>set _ _ _ _" [100, 100, 100, 100, 100] 100) and

  alpha_res ("_ \<approx>res _ _ _ _" [100, 100, 100, 100, 100] 100) and

  alpha_lst ("_ \<approx>lst _ _ _ _" [100, 100, 100, 100, 100] 100) 

section {* Mono *}

lemma [mono]: 

  shows "R1 \<le> R2 \<Longrightarrow> alpha_set bs R1 \<le> alpha_set bs R2"

  and   "R1 \<le> R2 \<Longrightarrow> alpha_res bs R1 \<le> alpha_res bs R2"

  and   "R1 \<le> R2 \<Longrightarrow> alpha_lst cs R1 \<le> alpha_lst cs R2"

  by (case_tac [!] bs, case_tac [!] cs) 

     (auto simp add: le_fun_def le_bool_def alphas)

section {* Equivariance *}

lemma alpha_eqvt[eqvt]:

  shows "(bs, x) \<approx>set R f q (cs, y) \<Longrightarrow> (p \<bullet> bs, p \<bullet> x) \<approx>set (p \<bullet> R) (p \<bullet> f) (p \<bullet> q) (p \<bullet> cs, p \<bullet> y)"

  and   "(bs, x) \<approx>res R f q (cs, y) \<Longrightarrow> (p \<bullet> bs, p \<bullet> x) \<approx>res (p \<bullet> R) (p \<bullet> f) (p \<bullet> q) (p \<bullet> cs, p \<bullet> y)"

  and   "(ds, x) \<approx>lst R f q (es, y) \<Longrightarrow> (p \<bullet> ds, p \<bullet> x) \<approx>lst (p \<bullet> R) (p \<bullet> f) (p \<bullet> q) (p \<bullet> es, p \<bullet> y)" 

  unfolding alphas

  unfolding permute_eqvt[symmetric]

  unfolding set_eqvt[symmetric]

  unfolding permute_fun_app_eq[symmetric]

  unfolding Diff_eqvt[symmetric]

  unfolding eq_eqvt[symmetric]

  unfolding fresh_star_eqvt[symmetric]

  by (auto simp only: permute_bool_def)

section {* Equivalence *}

lemma alpha_refl:

  assumes a: "R x x"

  shows "(bs, x) \<approx>set R f 0 (bs, x)"

  and   "(bs, x) \<approx>res R f 0 (bs, x)"

  and   "(cs, x) \<approx>lst R f 0 (cs, x)"

  using a 

  unfolding alphas

  unfolding fresh_star_def

  by (simp_all add: fresh_zero_perm)

lemma alpha_sym:

  assumes a: "R (p \<bullet> x) y \<Longrightarrow> R (- p \<bullet> y) x"

  shows "(bs, x) \<approx>set R f p (cs, y) \<Longrightarrow> (cs, y) \<approx>set R f (- p) (bs, x)"

  and   "(bs, x) \<approx>res R f p (cs, y) \<Longrightarrow> (cs, y) \<approx>res R f (- p) (bs, x)"

  and   "(ds, x) \<approx>lst R f p (es, y) \<Longrightarrow> (es, y) \<approx>lst R f (- p) (ds, x)"

  unfolding alphas fresh_star_def

  using a

  by (auto simp add: fresh_minus_perm)

lemma alpha_trans:

  assumes a: "\<lbrakk>R (p \<bullet> x) y; R (q \<bullet> y) z\<rbrakk> \<Longrightarrow> R ((q + p) \<bullet> x) z"

  shows "\<lbrakk>(bs, x) \<approx>set R f p (cs, y); (cs, y) \<approx>set R f q (ds, z)\<rbrakk> \<Longrightarrow> (bs, x) \<approx>set R f (q + p) (ds, z)"

  and   "\<lbrakk>(bs, x) \<approx>res R f p (cs, y); (cs, y) \<approx>res R f q (ds, z)\<rbrakk> \<Longrightarrow> (bs, x) \<approx>res R f (q + p) (ds, z)"

  and   "\<lbrakk>(es, x) \<approx>lst R f p (gs, y); (gs, y) \<approx>lst R f q (hs, z)\<rbrakk> \<Longrightarrow> (es, x) \<approx>lst R f (q + p) (hs, z)"

  using a

  unfolding alphas fresh_star_def

  by (simp_all add: fresh_plus_perm)

lemma alpha_sym_eqvt:

  assumes a: "R (p \<bullet> x) y \<Longrightarrow> R y (p \<bullet> x)" 

  and     b: "p \<bullet> R = R"

  shows "(bs, x) \<approx>set R f p (cs, y) \<Longrightarrow> (cs, y) \<approx>set R f (- p) (bs, x)" 

  and   "(bs, x) \<approx>res R f p (cs, y) \<Longrightarrow> (cs, y) \<approx>res R f (- p) (bs, x)" 

  and   "(ds, x) \<approx>lst R f p (es, y) \<Longrightarrow> (es, y) \<approx>lst R f (- p) (ds, x)"

apply(auto intro!: alpha_sym)

apply(drule_tac [!] a)

apply(rule_tac [!] p="p" in permute_boolE)

apply(simp_all add: b permute_self)

done

lemma alpha_set_trans_eqvt:

  assumes b: "(cs, y) \<approx>set R f q (ds, z)"

  and     a: "(bs, x) \<approx>set R f p (cs, y)" 

  and     d: "q \<bullet> R = R"

  and     c: "\<lbrakk>R (p \<bullet> x) y; R y (- q \<bullet> z)\<rbrakk> \<Longrightarrow> R (p \<bullet> x) (- q \<bullet> z)"

  shows "(bs, x) \<approx>set R f (q + p) (ds, z)"

apply(rule alpha_trans(1)[OF _ a b])

apply(drule c)

apply(rule_tac p="q" in permute_boolE)

apply(simp add: d permute_self)

apply(rotate_tac -1)

apply(drule_tac p="q" in permute_boolI)

apply(simp add: d permute_self permute_eqvt[symmetric])

done

lemma alpha_res_trans_eqvt:

  assumes  b: "(cs, y) \<approx>res R f q (ds, z)"

  and     a: "(bs, x) \<approx>res R f p (cs, y)" 

  and     d: "q \<bullet> R = R"

  and     c: "\<lbrakk>R (p \<bullet> x) y; R y (- q \<bullet> z)\<rbrakk> \<Longrightarrow> R (p \<bullet> x) (- q \<bullet> z)"

  shows "(bs, x) \<approx>res R f (q + p) (ds, z)"

apply(rule alpha_trans(2)[OF _ a b])

apply(drule c)

apply(rule_tac p="q" in permute_boolE)

apply(simp add: d permute_self)

apply(rotate_tac -1)

apply(drule_tac p="q" in permute_boolI)

apply(simp add: d permute_self permute_eqvt[symmetric])

done

lemma alpha_lst_trans_eqvt:

  assumes b: "(cs, y) \<approx>lst R f q (ds, z)"

  and     a: "(bs, x) \<approx>lst R f p (cs, y)" 

  and     d: "q \<bullet> R = R"

  and     c: "\<lbrakk>R (p \<bullet> x) y; R y (- q \<bullet> z)\<rbrakk> \<Longrightarrow> R (p \<bullet> x) (- q \<bullet> z)"

  shows "(bs, x) \<approx>lst R f (q + p) (ds, z)"

apply(rule alpha_trans(3)[OF _ a b])

apply(drule c)

apply(rule_tac p="q" in permute_boolE)

apply(simp add: d permute_self)

apply(rotate_tac -1)

apply(drule_tac p="q" in permute_boolI)

apply(simp add: d permute_self permute_eqvt[symmetric])

done

lemmas alpha_trans_eqvt = alpha_set_trans_eqvt alpha_res_trans_eqvt alpha_lst_trans_eqvt

section {* General Abstractions *}

fun

  alpha_abs_set 

where

  [simp del]:

  "alpha_abs_set (bs, x) (cs, y) \<longleftrightarrow> (\<exists>p. (bs, x) \<approx>set (op=) supp p (cs, y))"

fun

  alpha_abs_lst

where

  [simp del]:

  "alpha_abs_lst (bs, x) (cs, y) \<longleftrightarrow> (\<exists>p. (bs, x) \<approx>lst (op=) supp p (cs, y))"

fun

  alpha_abs_res

where

  [simp del]:

  "alpha_abs_res (bs, x) (cs, y) \<longleftrightarrow> (\<exists>p. (bs, x) \<approx>res (op=) supp p (cs, y))"

notation

  alpha_abs_set (infix "\<approx>abs'_set" 50) and

  alpha_abs_lst (infix "\<approx>abs'_lst" 50) and

  alpha_abs_res (infix "\<approx>abs'_res" 50)

lemmas alphas_abs = alpha_abs_set.simps alpha_abs_res.simps alpha_abs_lst.simps

lemma alphas_abs_refl:

  shows "(bs, x) \<approx>abs_set (bs, x)"

  and   "(bs, x) \<approx>abs_res (bs, x)"

  and   "(cs, x) \<approx>abs_lst (cs, x)" 

  unfolding alphas_abs

  unfolding alphas

  unfolding fresh_star_def

  by (rule_tac [!] x="0" in exI)

     (simp_all add: fresh_zero_perm)

lemma alphas_abs_sym:

  shows "(bs, x) \<approx>abs_set (cs, y) \<Longrightarrow> (cs, y) \<approx>abs_set (bs, x)"

  and   "(bs, x) \<approx>abs_res (cs, y) \<Longrightarrow> (cs, y) \<approx>abs_res (bs, x)"

  and   "(ds, x) \<approx>abs_lst (es, y) \<Longrightarrow> (es, y) \<approx>abs_lst (ds, x)"

  unfolding alphas_abs

  unfolding alphas

  unfolding fresh_star_def

  by (erule_tac [!] exE, rule_tac [!] x="-p" in exI)

     (auto simp add: fresh_minus_perm)

lemma alphas_abs_trans:

  shows "\<lbrakk>(bs, x) \<approx>abs_set (cs, y); (cs, y) \<approx>abs_set (ds, z)\<rbrakk> \<Longrightarrow> (bs, x) \<approx>abs_set (ds, z)"

  and   "\<lbrakk>(bs, x) \<approx>abs_res (cs, y); (cs, y) \<approx>abs_res (ds, z)\<rbrakk> \<Longrightarrow> (bs, x) \<approx>abs_res (ds, z)"

  and   "\<lbrakk>(es, x) \<approx>abs_lst (gs, y); (gs, y) \<approx>abs_lst (hs, z)\<rbrakk> \<Longrightarrow> (es, x) \<approx>abs_lst (hs, z)"

  unfolding alphas_abs

  unfolding alphas

  unfolding fresh_star_def

  apply(erule_tac [!] exE, erule_tac [!] exE)

  apply(rule_tac [!] x="pa + p" in exI)

  by (simp_all add: fresh_plus_perm)

lemma alphas_abs_eqvt:

  shows "(bs, x) \<approx>abs_set (cs, y) \<Longrightarrow> (p \<bullet> bs, p \<bullet> x) \<approx>abs_set (p \<bullet> cs, p \<bullet> y)"

  and   "(bs, x) \<approx>abs_res (cs, y) \<Longrightarrow> (p \<bullet> bs, p \<bullet> x) \<approx>abs_res (p \<bullet> cs, p \<bullet> y)"

  and   "(ds, x) \<approx>abs_lst (es, y) \<Longrightarrow> (p \<bullet> ds, p \<bullet> x) \<approx>abs_lst (p \<bullet> es, p \<bullet> y)"

  unfolding alphas_abs

  unfolding alphas

  unfolding set_eqvt[symmetric]

  unfolding supp_eqvt[symmetric]

  unfolding Diff_eqvt[symmetric]

  apply(erule_tac [!] exE)

  apply(rule_tac [!] x="p \<bullet> pa" in exI)

  by (auto simp only: fresh_star_permute_iff permute_eqvt[symmetric])

section {* Strengthening the equivalence *}

lemma disjoint_right_eq:

  assumes a: "A \<union> B1 = A \<union> B2"

  and     b: "A \<inter> B1 = {}" "A \<inter> B2 = {}"

  shows "B1 = B2"

using a b

by (metis Int_Un_distrib2 Int_absorb2 Int_commute Un_upper2)

lemma supp_property_res:

  assumes a: "(as, x) \<approx>res (op =) supp p (as', x')"

  shows "p \<bullet> (supp x \<inter> as) = supp x' \<inter> as'"

proof -

  from a have "(supp x - as) \<sharp>* p" by  (auto simp only: alphas)

  then have *: "p \<bullet> (supp x - as) = (supp x - as)" 

    by (simp add: atom_set_perm_eq)

  have "(supp x' - as') \<union> (supp x' \<inter> as') = supp x'" by auto

  also have "\<dots> = supp (p \<bullet> x)" using a by (simp add: alphas)

  also have "\<dots> = p \<bullet> (supp x)" by (simp add: supp_eqvt)

  also have "\<dots> = p \<bullet> ((supp x - as) \<union> (supp x \<inter> as))" by auto

  also have "\<dots> = (p \<bullet> (supp x - as)) \<union> (p \<bullet> (supp x \<inter> as))" by (simp add: union_eqvt)

  also have "\<dots> = (supp x - as) \<union> (p \<bullet> (supp x \<inter> as))" using * by simp

  also have "\<dots> = (supp x' - as') \<union> (p \<bullet> (supp x \<inter> as))" using a by (simp add: alphas)

  finally have "(supp x' - as') \<union> (supp x' \<inter> as') = (supp x' - as') \<union> (p \<bullet> (supp x \<inter> as))" .

  moreover 

  have "(supp x' - as') \<inter> (supp x' \<inter> as') = {}" by auto

  moreover 

  have "(supp x - as) \<inter> (supp x \<inter> as) = {}" by auto

  then have "p \<bullet> ((supp x - as) \<inter> (supp x \<inter> as) = {})" by (simp add: permute_bool_def)

  then have "(p \<bullet> (supp x - as)) \<inter> (p \<bullet> (supp x \<inter> as)) = {}" by (perm_simp) (simp)

  then have "(supp x - as) \<inter> (p \<bullet> (supp x \<inter> as)) = {}" using * by simp

  then have "(supp x' - as') \<inter> (p \<bullet> (supp x \<inter> as)) = {}" using a by (simp add: alphas)

  ultimately show "p \<bullet> (supp x \<inter> as) = supp x' \<inter> as'"

    by (auto dest: disjoint_right_eq)

qed

lemma alpha_abs_res_stronger1_aux:

  assumes asm: "(as, x) \<approx>res (op =) supp p' (as', x')"

  shows "\<exists>p. (as, x) \<approx>res (op =) supp p (as', x') \<and> supp p \<subseteq> (supp x \<inter> as) \<union> (supp x' \<inter> as')" 

proof -

  from asm have 0: "(supp x - as) \<sharp>* p'" by  (auto simp only: alphas)

  then have #: "p' \<bullet> (supp x - as) = (supp x - as)" 

    by (simp add: atom_set_perm_eq)

  obtain p where *: "\<forall>b \<in> supp x. p \<bullet> b = p' \<bullet> b" and **: "supp p \<subseteq> supp x \<union> p' \<bullet> supp x"

    using set_renaming_perm2 by blast

  from * have a: "p \<bullet> x = p' \<bullet> x" using supp_perm_perm_eq by auto

  from 0 have 1: "(supp x - as) \<sharp>* p" using *

    by (auto simp add: fresh_star_def fresh_perm)

  then have 2: "(supp x - as) \<inter> supp p = {}"

    by (auto simp add: fresh_star_def fresh_def)

  have b: "supp x = (supp x - as) \<union> (supp x \<inter> as)" by auto

  have "supp p \<subseteq> supp x \<union> p' \<bullet> supp x" using ** by simp

  also have "\<dots> = (supp x - as) \<union> (supp x \<inter> as) \<union> (p' \<bullet> ((supp x - as) \<union> (supp x \<inter> as)))" 

    using b by simp

  also have "\<dots> = (supp x - as) \<union> (supp x \<inter> as) \<union> ((p' \<bullet> (supp x - as)) \<union> (p' \<bullet> (supp x \<inter> as)))"

    by (simp add: union_eqvt)

  also have "\<dots> = (supp x - as) \<union> (supp x \<inter> as) \<union> (p' \<bullet> (supp x \<inter> as))" 

    using # by auto

  also have "\<dots> = (supp x - as) \<union> (supp x \<inter> as) \<union> (supp x' \<inter> as')" using asm

    by (simp add: supp_property_res)

  finally have "supp p \<subseteq> (supp x - as) \<union> (supp x \<inter> as) \<union> (supp x' \<inter> as')" .

  then 

  have "supp p \<subseteq> (supp x \<inter> as) \<union> (supp x' \<inter> as')" using 2 by auto

  moreover 

  have "(as, x) \<approx>res (op =) supp p (as', x')" using asm 1 a by (simp add: alphas)

  ultimately 

  show "\<exists>p. (as, x) \<approx>res (op =) supp p (as', x') \<and> supp p \<subseteq> (supp x \<inter> as) \<union> (supp x' \<inter> as')" by blast

qed

lemma alpha_abs_res_minimal:

  assumes asm: "(as, x) \<approx>res (op =) supp p (as', x')"

  shows "(as \<inter> supp x, x) \<approx>res (op =) supp p (as' \<inter> supp x', x')"

  using asm unfolding alpha_res by (auto simp add: Diff_Int)

lemma alpha_abs_res_abs_set:

  assumes asm: "(as, x) \<approx>res (op =) supp p (as', x')"

  shows "(as \<inter> supp x, x) \<approx>set (op =) supp p (as' \<inter> supp x', x')"

proof -

  have c: "p \<bullet> x = x'"

    using alpha_abs_res_minimal[OF asm] unfolding alpha_res by clarify

  then have a: "supp x - as \<inter> supp x = supp (p \<bullet> x) - as' \<inter> supp (p \<bullet> x)"

    using alpha_abs_res_minimal[OF asm] by (simp add: alpha_res)

  have b: "(supp x - as \<inter> supp x) \<sharp>* p"

    using alpha_abs_res_minimal[OF asm] unfolding alpha_res by clarify

  have "p \<bullet> (as \<inter> supp x) = as' \<inter> supp (p \<bullet> x)"

    by (metis Int_commute asm c supp_property_res)

  then show ?thesis using a b c unfolding alpha_set by simp

qed

lemma alpha_abs_set_abs_res:

  assumes asm: "(as \<inter> supp x, x) \<approx>set (op =) supp p (as' \<inter> supp x', x')"

  shows "(as, x) \<approx>res (op =) supp p (as', x')"

  using asm unfolding alphas by (auto simp add: Diff_Int)

lemma alpha_abs_res_stronger1:

  assumes asm: "(as, x) \<approx>res (op =) supp p' (as', x')"

  shows "\<exists>p. (as, x) \<approx>res (op =) supp p (as', x') \<and> supp p \<subseteq> as \<union> as'"

using alpha_abs_res_stronger1_aux[OF asm] by auto

lemma alpha_abs_set_stronger1:

  assumes asm: "(as, x) \<approx>set (op =) supp p' (as', x')"

  shows "\<exists>p. (as, x) \<approx>set (op =) supp p (as', x') \<and> supp p \<subseteq> as \<union> as'"

proof -

  from asm have 0: "(supp x - as) \<sharp>* p'" by  (auto simp only: alphas)

  then have #: "p' \<bullet> (supp x - as) = (supp x - as)" 

    by (simp add: atom_set_perm_eq)

  obtain p where *: "\<forall>b \<in> (supp x \<union> as). p \<bullet> b = p' \<bullet> b" 

    and **: "supp p \<subseteq> (supp x \<union> as) \<union> p' \<bullet> (supp x \<union> as)"

    using set_renaming_perm2 by blast

  from * have "\<forall>b \<in> supp x. p \<bullet> b = p' \<bullet> b" by blast

  then have a: "p \<bullet> x = p' \<bullet> x" using supp_perm_perm_eq by auto

  from * have "\<forall>b \<in> as. p \<bullet> b = p' \<bullet> b" by blast

  then have zb: "p \<bullet> as = p' \<bullet> as" 

    apply(auto simp add: permute_set_def)

    apply(rule_tac x="xa" in exI)

    apply(simp)

    done

  have zc: "p' \<bullet> as = as'" using asm by (simp add: alphas)

  from 0 have 1: "(supp x - as) \<sharp>* p" using *

    by (auto simp add: fresh_star_def fresh_perm)

  then have 2: "(supp x - as) \<inter> supp p = {}"

    by (auto simp add: fresh_star_def fresh_def)

  have b: "supp x = (supp x - as) \<union> (supp x \<inter> as)" by auto

  have "supp p \<subseteq> supp x \<union> as \<union> p' \<bullet> supp x \<union> p' \<bullet> as" using ** using union_eqvt by blast

  also have "\<dots> = (supp x - as) \<union> (supp x \<inter> as) \<union> as \<union> (p' \<bullet> ((supp x - as) \<union> (supp x \<inter> as))) \<union> p' \<bullet> as" 

    using b by simp

  also have "\<dots> = (supp x - as) \<union> (supp x \<inter> as) \<union> as \<union> 

    ((p' \<bullet> (supp x - as)) \<union> (p' \<bullet> (supp x \<inter> as))) \<union> p' \<bullet> as" by (simp add: union_eqvt)

  also have "\<dots> = (supp x - as) \<union> (supp x \<inter> as) \<union> as \<union> (p' \<bullet> (supp x \<inter> as)) \<union> p' \<bullet> as"

    using # by auto

  also have "\<dots> = (supp x - as) \<union> (supp x \<inter> as) \<union> as \<union> p' \<bullet> ((supp x \<inter> as) \<union> as)" using union_eqvt

    by auto

  also have "\<dots> = (supp x - as) \<union> (supp x \<inter> as) \<union> as \<union> p' \<bullet> as" 

    by (metis Int_commute Un_commute sup_inf_absorb)

  also have "\<dots> = (supp x - as) \<union> as \<union> p' \<bullet> as" by blast

  finally have "supp p \<subseteq> (supp x - as) \<union> as \<union> p' \<bullet> as" .

  then have "supp p \<subseteq> as \<union> p' \<bullet> as" using 2 by blast

  moreover 

  have "(as, x) \<approx>set (op =) supp p (as', x')" using asm 1 a zb by (simp add: alphas)

  ultimately 

  show "\<exists>p. (as, x) \<approx>set (op =) supp p (as', x') \<and> supp p \<subseteq> as \<union> as'" using zc by blast

qed

lemma alpha_abs_lst_stronger1:

  assumes asm: "(as, x) \<approx>lst (op =) supp p' (as', x')"

  shows "\<exists>p. (as, x) \<approx>lst (op =) supp p (as', x') \<and> supp p \<subseteq> set as \<union> set as'"

proof -

  from asm have 0: "(supp x - set as) \<sharp>* p'" by  (auto simp only: alphas)

  then have #: "p' \<bullet> (supp x - set as) = (supp x - set as)" 

    by (simp add: atom_set_perm_eq)

  obtain p where *: "\<forall>b \<in> (supp x \<union> set as). p \<bullet> b = p' \<bullet> b" 

    and **: "supp p \<subseteq> (supp x \<union> set as) \<union> p' \<bullet> (supp x \<union> set as)"

    using set_renaming_perm2 by blast

  from * have "\<forall>b \<in> supp x. p \<bullet> b = p' \<bullet> b" by blast

  then have a: "p \<bullet> x = p' \<bullet> x" using supp_perm_perm_eq by auto

  from * have "\<forall>b \<in> set as. p \<bullet> b = p' \<bullet> b" by blast

  then have zb: "p \<bullet> as = p' \<bullet> as" by (induct as) (auto)

  have zc: "p' \<bullet> set as = set as'" using asm by (simp add: alphas set_eqvt)

  from 0 have 1: "(supp x - set as) \<sharp>* p" using *

    by (auto simp add: fresh_star_def fresh_perm)

  then have 2: "(supp x - set as) \<inter> supp p = {}"

    by (auto simp add: fresh_star_def fresh_def)

  have b: "supp x = (supp x - set as) \<union> (supp x \<inter> set as)" by auto

  have "supp p \<subseteq> supp x \<union> set as \<union> p' \<bullet> supp x \<union> p' \<bullet> set as" using ** using union_eqvt by blast

  also have "\<dots> = (supp x - set as) \<union> (supp x \<inter> set as) \<union> set as \<union> 

    (p' \<bullet> ((supp x - set as) \<union> (supp x \<inter> set as))) \<union> p' \<bullet> set as" using b by simp

  also have "\<dots> = (supp x - set as) \<union> (supp x \<inter> set as) \<union> set as \<union> 

    ((p' \<bullet> (supp x - set as)) \<union> (p' \<bullet> (supp x \<inter> set as))) \<union> p' \<bullet> set as" by (simp add: union_eqvt)

  also have "\<dots> = (supp x - set as) \<union> (supp x \<inter> set as) \<union> set as \<union> 

    (p' \<bullet> (supp x \<inter> set as)) \<union> p' \<bullet> set as" using # by auto

  also have "\<dots> = (supp x - set as) \<union> (supp x \<inter> set as) \<union> set as \<union> p' \<bullet> ((supp x \<inter> set as) \<union> set as)" 

    using union_eqvt by auto

  also have "\<dots> = (supp x - set as) \<union> (supp x \<inter> set as) \<union> set as \<union> p' \<bullet> set as" 

    by (metis Int_commute Un_commute sup_inf_absorb)

  also have "\<dots> = (supp x - set as) \<union> set as \<union> p' \<bullet> set as" by blast

  finally have "supp p \<subseteq> (supp x - set as) \<union> set as \<union> p' \<bullet> set as" .

  then have "supp p \<subseteq> set as \<union> p' \<bullet> set as" using 2 by blast

  moreover 

  have "(as, x) \<approx>lst (op =) supp p (as', x')" using asm 1 a zb by (simp add: alphas)

  ultimately 

  show "\<exists>p. (as, x) \<approx>lst (op =) supp p (as', x') \<and> supp p \<subseteq> set as \<union> set as'" using zc by blast 

qed

lemma alphas_abs_stronger:

  shows "(as, x) \<approx>abs_set (as', x') \<longleftrightarrow> (\<exists>p. (as, x) \<approx>set (op =) supp p (as', x') \<and> supp p \<subseteq> as \<union> as')"

  and   "(as, x) \<approx>abs_res (as', x') \<longleftrightarrow> (\<exists>p. (as, x) \<approx>res (op =) supp p (as', x') \<and> supp p \<subseteq> as \<union> as')"

  and   "(bs, x) \<approx>abs_lst (bs', x') \<longleftrightarrow> 

   (\<exists>p. (bs, x) \<approx>lst (op =) supp p (bs', x') \<and> supp p \<subseteq> set bs \<union> set bs')"

apply(rule iffI)

apply(auto simp add: alphas_abs alpha_abs_set_stronger1)[1]

apply(auto simp add: alphas_abs)[1]

apply(rule iffI)

apply(auto simp add: alphas_abs alpha_abs_res_stronger1)[1]

apply(auto simp add: alphas_abs)[1]

apply(rule iffI)

apply(auto simp add: alphas_abs alpha_abs_lst_stronger1)[1]

apply(auto simp add: alphas_abs)[1]

done

lemma alpha_res_alpha_set:

  "(bs, x) \<approx>res op = supp p (cs, y) \<longleftrightarrow> (bs \<inter> supp x, x) \<approx>set op = supp p (cs \<inter> supp y, y)"

  using alpha_abs_set_abs_res alpha_abs_res_abs_set by blast

section {* Quotient types *}

quotient_type

    'a abs_set = "(atom set \<times> 'a::pt)" / "alpha_abs_set"

  apply(rule equivpI)

  unfolding reflp_def refl_on_def symp_def sym_def transp_def trans_def

  by (auto intro: alphas_abs_sym alphas_abs_refl alphas_abs_trans simp only:)

quotient_type

    'b abs_res = "(atom set \<times> 'b::pt)" / "alpha_abs_res"

  apply(rule equivpI)

  unfolding reflp_def refl_on_def symp_def sym_def transp_def trans_def

  by (auto intro: alphas_abs_sym alphas_abs_refl alphas_abs_trans simp only:)

quotient_type

   'c abs_lst = "(atom list \<times> 'c::pt)" / "alpha_abs_lst"

  apply(rule_tac [!] equivpI)

  unfolding reflp_def refl_on_def symp_def sym_def transp_def trans_def

  by (auto intro: alphas_abs_sym alphas_abs_refl alphas_abs_trans simp only:)

quotient_definition

  Abs_set ("[_]set. _" [60, 60] 60)

where

  "Abs_set::atom set \<Rightarrow> ('a::pt) \<Rightarrow> 'a abs_set"

is

  "Pair::atom set \<Rightarrow> ('a::pt) \<Rightarrow> (atom set \<times> 'a)" .

quotient_definition

  Abs_res ("[_]res. _" [60, 60] 60)

where

  "Abs_res::atom set \<Rightarrow> ('a::pt) \<Rightarrow> 'a abs_res"

is

  "Pair::atom set \<Rightarrow> ('a::pt) \<Rightarrow> (atom set \<times> 'a)" .

quotient_definition

  Abs_lst ("[_]lst. _" [60, 60] 60)

where

  "Abs_lst::atom list \<Rightarrow> ('a::pt) \<Rightarrow> 'a abs_lst"

is

  "Pair::atom list \<Rightarrow> ('a::pt) \<Rightarrow> (atom list \<times> 'a)" .

lemma [quot_respect]:

  shows "(op= ===> op= ===> alpha_abs_set) Pair Pair"

  and   "(op= ===> op= ===> alpha_abs_res) Pair Pair"

  and   "(op= ===> op= ===> alpha_abs_lst) Pair Pair"

  unfolding fun_rel_def

  by (auto intro: alphas_abs_refl)

lemma [quot_respect]:

  shows "(op= ===> alpha_abs_set ===> alpha_abs_set) permute permute"