diff -r 758904445fb2 -r d1293d30c657 Nominal/Abs.thy
--- a/Nominal/Abs.thy	Fri Mar 26 17:22:02 2010 +0100
+++ b/Nominal/Abs.thy	Fri Mar 26 17:22:17 2010 +0100
@@ -51,145 +51,187 @@
   by (case_tac [!] bs, case_tac [!] cs) 
      (auto simp add: le_fun_def le_bool_def alphas)
 
-lemma alpha_gen_refl:
-  assumes a: "R x x"
-  shows "(bs, x) \<approx>gen 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_gen_sym:
-  assumes a: "R (p \<bullet> x) y \<Longrightarrow> R (- p \<bullet> y) x"
-  shows "(bs, x) \<approx>gen R f p (cs, y) \<Longrightarrow> (cs, y) \<approx>gen 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)"
-  using a
-  unfolding alphas
-  unfolding fresh_star_def
-  by (auto simp add:  fresh_minus_perm)
-
-lemma alpha_gen_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>gen R f p (cs, y); (cs, y) \<approx>gen R f q (ds, z)\<rbrakk> \<Longrightarrow> (bs, x) \<approx>gen 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
-  unfolding fresh_star_def
-  by (simp_all add: fresh_plus_perm)
-
-lemma alpha_gen_eqvt:
-  assumes a: "R (q \<bullet> x) y \<Longrightarrow> R (p \<bullet> (q \<bullet> x)) (p \<bullet> y)"
-  and     b: "p \<bullet> (f x) = f (p \<bullet> x)"
-  and     c: "p \<bullet> (f y) = f (p \<bullet> y)"
-  shows "(bs, x) \<approx>gen R f q (cs, y) \<Longrightarrow> (p \<bullet> bs, p \<bullet> x) \<approx>gen R 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 R 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 R f (p \<bullet> q) (p \<bullet> es, p \<bullet> y)" 
-  unfolding alphas
-  unfolding set_eqvt[symmetric]
-  unfolding b[symmetric] c[symmetric]
-  unfolding Diff_eqvt[symmetric]
-  unfolding permute_eqvt[symmetric]
-  using a
-  by (auto simp add: fresh_star_permute_iff)
-
 fun
   alpha_abs 
 where
   "alpha_abs (bs, x) (cs, y) \<longleftrightarrow> (\<exists>p. (bs, x) \<approx>gen (op=) supp p (cs, y))"
 
+fun
+  alpha_abs_lst
+where
+  "alpha_abs_lst (bs, x) (cs, y) \<longleftrightarrow> (\<exists>p. (bs, x) \<approx>lst (op=) supp p (cs, y))"
+
+fun
+  alpha_abs_res
+where
+  "alpha_abs_res (bs, x) (cs, y) \<longleftrightarrow> (\<exists>p. (bs, x) \<approx>res (op=) supp p (cs, y))"
+
 notation
-  alpha_abs ("_ \<approx>abs _")
+  alpha_abs ("_ \<approx>abs _") and
+  alpha_abs_lst ("_ \<approx>abs'_lst _") and
+  alpha_abs_res ("_ \<approx>abs'_res _")
+
+lemmas alphas_abs = alpha_abs.simps alpha_abs_res.simps alpha_abs_lst.simps
+
+lemma alphas_abs_refl:
+  shows "(bs, x) \<approx>abs (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 (cs, y) \<Longrightarrow> (cs, y) \<approx>abs (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 alpha_abs_swap:
+lemma alphas_abs_trans:
+  shows "\<lbrakk>(bs, x) \<approx>abs (cs, y); (cs, y) \<approx>abs (ds, z)\<rbrakk> \<Longrightarrow> (bs, x) \<approx>abs (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 (cs, y) \<Longrightarrow> (p \<bullet> bs, p \<bullet> x) \<approx>abs (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 add: fresh_star_permute_iff permute_eqvt[symmetric])
+
+lemma alphas_abs_swap1:
   assumes a1: "a \<notin> (supp x) - bs"
   and     a2: "b \<notin> (supp x) - bs"
   shows "(bs, x) \<approx>abs ((a \<rightleftharpoons> b) \<bullet> bs, (a \<rightleftharpoons> b) \<bullet> x)"
+  and   "(bs, x) \<approx>abs_res ((a \<rightleftharpoons> b) \<bullet> bs, (a \<rightleftharpoons> b) \<bullet> x)"
   using a1 a2
-  unfolding Diff_iff
-  unfolding alpha_abs.simps
+  unfolding alphas_abs
   unfolding alphas
-  unfolding supp_eqvt[symmetric] Diff_eqvt[symmetric]
+  unfolding supp_eqvt[symmetric] Diff_eqvt[symmetric] 
   unfolding fresh_star_def fresh_def
   unfolding swap_set_not_in[OF a1 a2] 
-  by (rule_tac x="(a \<rightleftharpoons> b)" in exI)
+  by (rule_tac [!] x="(a \<rightleftharpoons> b)" in exI)
+     (auto simp add: supp_perm swap_atom)
+
+lemma alphas_abs_swap2:
+  assumes a1: "a \<notin> (supp x) - (set bs)"
+  and     a2: "b \<notin> (supp x) - (set bs)"
+  shows "(bs, x) \<approx>abs_lst ((a \<rightleftharpoons> b) \<bullet> bs, (a \<rightleftharpoons> b) \<bullet> x)"
+  using a1 a2
+  unfolding alphas_abs
+  unfolding alphas
+  unfolding supp_eqvt[symmetric] Diff_eqvt[symmetric] set_eqvt[symmetric]
+  unfolding fresh_star_def fresh_def
+  unfolding swap_set_not_in[OF a1 a2] 
+  by (rule_tac [!] x="(a \<rightleftharpoons> b)" in exI)
      (auto simp add: supp_perm swap_atom)
 
 fun
-  supp_abs_fun
+  aux_set 
+where
+  "aux_set (bs, x) = (supp x) - bs"
+
+fun
+  aux_list
 where
-  "supp_abs_fun (bs, x) = (supp x) - bs"
+  "aux_list (cs, x) = (supp x) - (set cs)"
 
+lemma aux_abs_lemma:
+  assumes a: "(bs, x) \<approx>abs (cs, y)" 
+  shows "aux_set (bs, x) = aux_set (cs, y)"
+  using a
+  by (induct rule: alpha_abs.induct)
+     (simp add: alphas_abs alphas)
 
-lemma supp_abs_fun_lemma:
-  assumes a: "x \<approx>abs y" 
-  shows "supp_abs_fun x = supp_abs_fun y"
+lemma aux_abs_res_lemma:
+  assumes a: "(bs, x) \<approx>abs_res (cs, y)" 
+  shows "aux_set (bs, x) = aux_set (cs, y)"
   using a
-  apply(induct rule: alpha_abs.induct)
-  apply(simp add: alpha_gen)
-  done
-  
+  by (induct rule: alpha_abs_res.induct)
+     (simp add: alphas_abs alphas)
+ 
+lemma aux_abs_list_lemma:
+  assumes a: "(bs, x) \<approx>abs_lst (cs, y)" 
+  shows "aux_list (bs, x) = aux_list (cs, y)"
+  using a
+  by (induct rule: alpha_abs_lst.induct)
+     (simp add: alphas_abs alphas)
 
-quotient_type 'a abs_gen = "(atom set \<times> 'a::pt)" / "alpha_abs"
-  apply(rule equivpI)
+quotient_type 
+    'a abs_gen = "(atom set \<times> 'a::pt)" / "alpha_abs"
+and 'b abs_res = "(atom set \<times> 'b::pt)" / "alpha_abs_res"
+and 'c abs_lst = "(atom list \<times> 'c::pt)" / "alpha_abs_lst"
+  apply(rule_tac [!] equivpI)
   unfolding reflp_def symp_def transp_def
-  apply(simp_all)
-  (* refl *)
-  apply(clarify)
-  apply(rule_tac x="0" in exI)
-  apply(rule alpha_gen_refl)
-  apply(simp)
-  (* symm *)
-  apply(clarify)
-  apply(rule_tac x="- p" in exI)
-  apply(rule alpha_gen_sym)
-  apply(clarsimp)
-  apply(assumption)
-  (* trans *)
-  apply(clarify)
-  apply(rule_tac x="pa + p" in exI)
-  apply(rule alpha_gen_trans)
-  apply(auto)
-  done
+  by (auto intro: alphas_abs_sym alphas_abs_refl alphas_abs_trans simp only:)
 
 quotient_definition
   "Abs::atom set \<Rightarrow> ('a::pt) \<Rightarrow> 'a abs_gen"
 is
   "Pair::atom set \<Rightarrow> ('a::pt) \<Rightarrow> (atom set \<times> 'a)"
 
+quotient_definition
+  "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::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) Pair Pair"
-  apply(clarsimp)
-  apply(rule exI)
-  apply(rule alpha_gen_refl)
-  apply(simp)
-  done
+  shows "(op= ===> op= ===> alpha_abs) 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 simp only:)
 
 lemma [quot_respect]:
-  shows "((op =) ===> alpha_abs ===> alpha_abs) permute permute"
-  apply(clarsimp)
-  apply(rule exI)
-  apply(rule alpha_gen_eqvt)
-  apply(simp_all add: supp_eqvt)
-  done
+  shows "(op= ===> alpha_abs ===> alpha_abs) permute permute"
+  and   "(op= ===> alpha_abs_res ===> alpha_abs_res) permute permute"
+  and   "(op= ===> alpha_abs_lst ===> alpha_abs_lst) permute permute"
+  unfolding fun_rel_def
+  by (auto intro: alphas_abs_eqvt simp only: Pair_eqvt)
 
 lemma [quot_respect]:
-  shows "(alpha_abs ===> (op =)) supp_abs_fun supp_abs_fun"
-  apply(simp add: supp_abs_fun_lemma)
-  done
+  shows "(alpha_abs ===> op=) aux_set aux_set"
+  and   "(alpha_abs_res ===> op=) aux_set aux_set"
+  and   "(alpha_abs_lst ===> op=) aux_list aux_list"
+  unfolding fun_rel_def
+  apply(rule_tac [!] allI)
+  apply(rule_tac [!] allI)
+  apply(case_tac [!] x, case_tac [!] y)
+  apply(rule_tac [!] impI)
+  by (simp_all only: aux_abs_lemma aux_abs_res_lemma aux_abs_list_lemma)
 
-lemma abs_induct:
-  "\<lbrakk>\<And>as (x::'a::pt). P (Abs as x)\<rbrakk> \<Longrightarrow> P t"
+lemma abs_inducts:
+  shows "(\<And>as (x::'a::pt). P1 (Abs as x)) \<Longrightarrow> P1 x1"
+  and   "(\<And>as (x::'a::pt). P2 (Abs_res as x)) \<Longrightarrow> P2 x2"
+  and   "(\<And>as (x::'a::pt). P3 (Abs_lst as x)) \<Longrightarrow> P3 x3"
   apply(lifting prod.induct[where 'a="atom set" and 'b="'a"])
+  apply(lifting prod.induct[where 'a="atom set" and 'b="'a"])
+  apply(lifting prod.induct[where 'a="atom list" and 'b="'a"])
   done
 
-(* TEST case *)
-lemmas abs_induct2 = prod.induct[where 'a="atom set" and 'b="'a::pt", quot_lifted]
-thm abs_induct abs_induct2
-
 instantiation abs_gen :: (pt) pt
 begin
 
@@ -198,351 +240,206 @@
 is
   "permute:: perm \<Rightarrow> (atom set \<times> 'a::pt) \<Rightarrow> (atom set \<times> 'a::pt)"
 
-(* ??? has to be 'a \<dots> 'b does not work *)
-lemma permute_ABS [simp]:
+lemma permute_Abs[simp]:
   fixes x::"'a::pt"  
   shows "(p \<bullet> (Abs as x)) = Abs (p \<bullet> as) (p \<bullet> x)"
-  thm permute_prod.simps
-  by (lifting permute_prod.simps(1)[where 'a="atom set" and 'b="'a"])
+  by (lifting permute_prod.simps[where 'a="atom set" and 'b="'a"])
 
 instance
   apply(default)
-  apply(induct_tac [!] x rule: abs_induct)
+  apply(induct_tac [!] x rule: abs_inducts(1))
+  apply(simp_all)
+  done
+
+end
+
+instantiation abs_res :: (pt) pt
+begin
+
+quotient_definition
+  "permute_abs_res::perm \<Rightarrow> ('a::pt abs_res) \<Rightarrow> 'a abs_res"
+is
+  "permute:: perm \<Rightarrow> (atom set \<times> 'a::pt) \<Rightarrow> (atom set \<times> 'a::pt)"
+
+lemma permute_Abs_res[simp]:
+  fixes x::"'a::pt"  
+  shows "(p \<bullet> (Abs_res as x)) = Abs_res (p \<bullet> as) (p \<bullet> x)"
+  by (lifting permute_prod.simps[where 'a="atom set" and 'b="'a"])
+
+instance
+  apply(default)
+  apply(induct_tac [!] x rule: abs_inducts(2))
+  apply(simp_all)
+  done
+
+end
+
+instantiation abs_lst :: (pt) pt
+begin
+
+quotient_definition
+  "permute_abs_lst::perm \<Rightarrow> ('a::pt abs_lst) \<Rightarrow> 'a abs_lst"
+is
+  "permute:: perm \<Rightarrow> (atom list \<times> 'a::pt) \<Rightarrow> (atom list \<times> 'a::pt)"
+
+lemma permute_Abs_lst[simp]:
+  fixes x::"'a::pt"  
+  shows "(p \<bullet> (Abs_lst as x)) = Abs_lst (p \<bullet> as) (p \<bullet> x)"
+  by (lifting permute_prod.simps[where 'a="atom list" and 'b="'a"])
+
+instance
+  apply(default)
+  apply(induct_tac [!] x rule: abs_inducts(3))
   apply(simp_all)
   done
 
 end
 
+lemmas permute_abs = permute_Abs permute_Abs_res permute_Abs_lst
+
+
 quotient_definition
-  "supp_Abs_fun :: ('a::pt) abs_gen \<Rightarrow> atom \<Rightarrow> bool"
+  "supp_gen :: ('a::pt) abs_gen \<Rightarrow> atom set"
 is
-  "supp_abs_fun"
+  "aux_set"
+
+quotient_definition
+  "supp_res :: ('a::pt) abs_res \<Rightarrow> atom set"
+is
+  "aux_set"
 
-lemma supp_Abs_fun_simp:
-  shows "supp_Abs_fun (Abs bs x) = (supp x) - bs"
-  by (lifting supp_abs_fun.simps(1))
+quotient_definition
+  "supp_lst :: ('a::pt) abs_lst \<Rightarrow> atom set"
+is
+  "aux_list"
 
-lemma supp_Abs_fun_eqvt [eqvt]:
-  shows "(p \<bullet> supp_Abs_fun x) = supp_Abs_fun (p \<bullet> x)"
-  apply(induct_tac x rule: abs_induct)
-  apply(simp add: supp_Abs_fun_simp supp_eqvt Diff_eqvt)
+lemma aux_supps:
+  shows "supp_gen (Abs bs x) = (supp x) - bs"
+  and   "supp_res (Abs_res bs x) = (supp x) - bs"
+  and   "supp_lst (Abs_lst cs x) = (supp x) - (set cs)"
+  apply(lifting aux_set.simps)
+  apply(lifting aux_set.simps)
+  apply(lifting aux_list.simps)
   done
 
-lemma supp_Abs_fun_fresh:
-  shows "a \<sharp> Abs bs x \<Longrightarrow> a \<sharp> supp_Abs_fun (Abs bs x)"
-  apply(rule fresh_fun_eqvt_app)
-  apply(simp add: eqvts_raw)
-  apply(simp)
+lemma aux_supp_eqvt[eqvt]:
+  shows "(p \<bullet> supp_gen x) = supp_gen (p \<bullet> x)"
+  and   "(p \<bullet> supp_res y) = supp_res (p \<bullet> y)"
+  and   "(p \<bullet> supp_lst z) = supp_lst (p \<bullet> z)"
+  apply(induct_tac x rule: abs_inducts(1))
+  apply(simp add: aux_supps supp_eqvt Diff_eqvt)
+  apply(induct_tac y rule: abs_inducts(2))
+  apply(simp add: aux_supps supp_eqvt Diff_eqvt)
+  apply(induct_tac z rule: abs_inducts(3))
+  apply(simp add: aux_supps supp_eqvt Diff_eqvt set_eqvt)
   done
 
-lemma Abs_swap:
+lemma aux_fresh:
+  shows "a \<sharp> Abs bs x \<Longrightarrow> a \<sharp> supp_gen (Abs bs x)"
+  and   "a \<sharp> Abs_res bs x \<Longrightarrow> a \<sharp> supp_res (Abs_res bs x)"
+  and   "a \<sharp> Abs_lst cs x \<Longrightarrow> a \<sharp> supp_lst (Abs_lst cs x)"
+  apply(rule_tac [!] fresh_fun_eqvt_app)
+  apply(simp_all add: eqvts_raw)
+  done
+
+lemma abs_swap1:
   assumes a1: "a \<notin> (supp x) - bs"
   and     a2: "b \<notin> (supp x) - bs"
-  shows "(Abs bs x) = (Abs ((a \<rightleftharpoons> b) \<bullet> bs) ((a \<rightleftharpoons> b) \<bullet> x))"
-  using a1 a2 by (lifting alpha_abs_swap)
-
-lemma Abs_supports:
-  shows "((supp x) - as) supports (Abs as x)"
-  unfolding supports_def
-  apply(clarify)
-  apply(simp (no_asm))
-  apply(subst Abs_swap[symmetric])
-  apply(simp_all)
+  shows "Abs bs x = Abs ((a \<rightleftharpoons> b) \<bullet> bs) ((a \<rightleftharpoons> b) \<bullet> x)"
+  and   "Abs_res bs x = Abs_res ((a \<rightleftharpoons> b) \<bullet> bs) ((a \<rightleftharpoons> b) \<bullet> x)"
+  using a1 a2 
+  apply(lifting alphas_abs_swap1(1))
+  apply(lifting alphas_abs_swap1(2))
   done
 
-lemma finite_supp_Abs_subset1:
-  assumes "finite (supp x)"
+lemma abs_swap2:
+  assumes a1: "a \<notin> (supp x) - (set bs)"
+  and     a2: "b \<notin> (supp x) - (set bs)"
+  shows "Abs_lst bs x = Abs_lst ((a \<rightleftharpoons> b) \<bullet> bs) ((a \<rightleftharpoons> b) \<bullet> x)"
+  using a1 a2 by (lifting alphas_abs_swap2)
+
+lemma abs_supports:
+  shows "((supp x) - as) supports (Abs as x)"
+  and   "((supp x) - as) supports (Abs_res as x)"
+  and   "((supp x) - (set bs)) supports (Abs_lst bs x)"
+  unfolding supports_def
+  unfolding permute_abs
+  by (simp_all add: abs_swap1[symmetric] abs_swap2[symmetric])
+
+lemma supp_abs_subset1:
+  assumes a: "finite (supp x)"
   shows "(supp x) - as \<subseteq> supp (Abs as x)"
-  apply(simp add: supp_conv_fresh)
-  apply(auto)
-  apply(drule_tac supp_Abs_fun_fresh)
-  apply(simp only: supp_Abs_fun_simp)
-  apply(simp add: fresh_def)
-  apply(simp add: supp_finite_atom_set assms)
+  and   "(supp x) - as \<subseteq> supp (Abs_res as x)"
+  and   "(supp x) - (set bs) \<subseteq> supp (Abs_lst bs x)"
+  unfolding supp_conv_fresh
+  apply(auto dest!: aux_fresh simp add: aux_supps)
+  apply(simp_all add: fresh_def supp_finite_atom_set a)
   done
 
-lemma finite_supp_Abs_subset2:
-  assumes "finite (supp x)"
+lemma supp_abs_subset2:
+  assumes a: "finite (supp x)"
   shows "supp (Abs as x) \<subseteq> (supp x) - as"
-  apply(rule supp_is_subset)
-  apply(rule Abs_supports)
-  apply(simp add: assms)
+  and   "supp (Abs_res as x) \<subseteq> (supp x) - as"
+  and   "supp (Abs_lst bs x) \<subseteq> (supp x) - (set bs)"
+  apply(rule_tac [!] supp_is_subset)
+  apply(simp_all add: abs_supports a)
   done
 
-lemma finite_supp_Abs:
-  assumes "finite (supp x)"
+lemma abs_finite_supp:
+  assumes a: "finite (supp x)"
   shows "supp (Abs as x) = (supp x) - as"
-  apply(rule_tac subset_antisym)
-  apply(rule finite_supp_Abs_subset2[OF assms])
-  apply(rule finite_supp_Abs_subset1[OF assms])
+  and   "supp (Abs_res as x) = (supp x) - as"
+  and   "supp (Abs_lst bs x) = (supp x) - (set bs)"
+  apply(rule_tac [!] subset_antisym)
+  apply(simp_all add: supp_abs_subset1[OF a] supp_abs_subset2[OF a])
   done
 
-lemma supp_Abs:
+lemma supp_abs:
   fixes x::"'a::fs"
   shows "supp (Abs as x) = (supp x) - as"
-  apply(rule finite_supp_Abs)
-  apply(simp add: finite_supp)
+  and   "supp (Abs_res as x) = (supp x) - as"
+  and   "supp (Abs_lst bs x) = (supp x) - (set bs)"
+  apply(rule_tac [!] abs_finite_supp)
+  apply(simp_all add: finite_supp)
   done
 
 instance abs_gen :: (fs) fs
   apply(default)
-  apply(induct_tac x rule: abs_induct)
-  apply(simp add: supp_Abs)
-  apply(simp add: finite_supp)
+  apply(induct_tac x rule: abs_inducts(1))
+  apply(simp add: supp_abs finite_supp)
   done
 
-lemma Abs_fresh_iff:
-  fixes x::"'a::fs"
-  shows "a \<sharp> Abs bs x \<longleftrightarrow> a \<in> bs \<or> (a \<notin> bs \<and> a \<sharp> x)"
-  apply(simp add: fresh_def)
-  apply(simp add: supp_Abs)
-  apply(auto)
+instance abs_res :: (fs) fs
+  apply(default)
+  apply(induct_tac x rule: abs_inducts(2))
+  apply(simp add: supp_abs finite_supp)
+  done
+
+instance abs_lst :: (fs) fs
+  apply(default)
+  apply(induct_tac x rule: abs_inducts(3))
+  apply(simp add: supp_abs finite_supp)
   done
 
-lemma Abs_eq_iff:
-  shows "Abs bs x = Abs cs y \<longleftrightarrow> (\<exists>p. (bs, x) \<approx>gen (op =) supp p (cs, y))"
-  by (lifting alpha_abs.simps(1))
-
-
-
-(* 
-  below is a construction site for showing that in the
-  single-binder case, the old and new alpha equivalence 
-  coincide
-*)
-
-fun
-  alpha1
-where
-  "alpha1 (a, x) (b, y) \<longleftrightarrow> (a = b \<and> x = y) \<or> (a \<noteq> b \<and> x = (a \<rightleftharpoons> b) \<bullet> y \<and> a \<sharp> y)"
-
-notation 
-  alpha1 ("_ \<approx>abs1 _")
-
-fun
-  alpha2
-where
-  "alpha2 (a, x) (b, y) \<longleftrightarrow> (\<exists>c. c \<sharp> (a,b,x,y) \<and> ((c \<rightleftharpoons> a) \<bullet> x) = ((c \<rightleftharpoons> b) \<bullet> y))"
-
-notation 
-  alpha2 ("_ \<approx>abs2 _")
+lemma abs_fresh_iff:
+  fixes x::"'a::fs"
+  shows "a \<sharp> Abs bs x \<longleftrightarrow> a \<in> bs \<or> (a \<notin> bs \<and> a \<sharp> x)"
+  and   "a \<sharp> Abs_res bs x \<longleftrightarrow> a \<in> bs \<or> (a \<notin> bs \<and> a \<sharp> x)"
+  and   "a \<sharp> Abs_lst cs x \<longleftrightarrow> a \<in> (set cs) \<or> (a \<notin> (set cs) \<and> a \<sharp> x)"
+  unfolding fresh_def
+  unfolding supp_abs
+  by auto
 
-lemma alpha_old_new:
-  assumes a: "(a, x) \<approx>abs1 (b, y)" "sort_of a = sort_of b"
-  shows "({a}, x) \<approx>abs ({b}, y)"
-using a
-apply(simp)
-apply(erule disjE)
-apply(simp)
-apply(rule exI)
-apply(rule alpha_gen_refl)
-apply(simp)
-apply(rule_tac x="(a \<rightleftharpoons> b)" in  exI)
-apply(simp add: alpha_gen)
-apply(simp add: fresh_def)
-apply(rule conjI)
-apply(rule_tac ?p1="(a \<rightleftharpoons> b)" in  permute_eq_iff[THEN iffD1])
-apply(rule trans)
-apply(simp add: Diff_eqvt supp_eqvt)
-apply(subst swap_set_not_in)
-back
-apply(simp)
-apply(simp)
-apply(simp add: permute_set_eq)
-apply(rule conjI)
-apply(rule_tac ?p1="(a \<rightleftharpoons> b)" in fresh_star_permute_iff[THEN iffD1])
-apply(simp add: permute_self)
-apply(simp add: Diff_eqvt supp_eqvt)
-apply(simp add: permute_set_eq)
-apply(subgoal_tac "supp (a \<rightleftharpoons> b) \<subseteq> {a, b}")
-apply(simp add: fresh_star_def fresh_def)
-apply(blast)
-apply(simp add: supp_swap)
-apply(simp add: eqvts)
-done
-
-
-lemma perm_induct_test:
-  fixes P :: "perm => bool"
-  assumes fin: "finite (supp p)" 
-  assumes zero: "P 0"
-  assumes swap: "\<And>a b. \<lbrakk>sort_of a = sort_of b; a \<noteq> b\<rbrakk> \<Longrightarrow> P (a \<rightleftharpoons> b)"
-  assumes plus: "\<And>p1 p2. \<lbrakk>supp p1 \<inter> supp p2 = {}; P p1; P p2\<rbrakk> \<Longrightarrow> P (p1 + p2)"
-  shows "P p"
-using fin
-apply(induct F\<equiv>"supp p" arbitrary: p rule: finite_induct)
-oops
-
-lemma ii:
-  assumes "\<forall>x \<in> A. p \<bullet> x = x"
-  shows "p \<bullet> A = A"
-using assms
-apply(auto)
-apply (metis Collect_def Collect_mem_eq Int_absorb assms eqvt_bound inf_Int_eq mem_def mem_permute_iff)
-apply (metis Collect_def Collect_mem_eq Int_absorb assms eqvt_apply eqvt_bound eqvt_lambda inf_Int_eq mem_def mem_permute_iff permute_minus_cancel(2) permute_pure)
-done
-
-
-
-lemma alpha_abs_Pair:
-  shows "(bs, (x1, x2)) \<approx>gen (\<lambda>(x1,x2) (y1,y2). x1=y1 \<and> x2=y2) (\<lambda>(x,y). supp x \<union> supp y) p (cs, (y1, y2))
-         \<longleftrightarrow> ((bs, x1) \<approx>gen (op=) supp p (cs, y1) \<and> (bs, x2) \<approx>gen (op=) supp p (cs, y2))"         
-  apply(simp add: alpha_gen)
-  apply(simp add: fresh_star_def)
-  apply(simp add: ball_Un Un_Diff)
-  apply(rule iffI)
-  apply(simp)
-  defer
-  apply(simp)
-  apply(rule conjI)
-  apply(clarify)
-  apply(simp add: supp_eqvt[symmetric] Diff_eqvt[symmetric])
-  apply(rule sym)
-  apply(rule ii)
-  apply(simp add: fresh_def supp_perm)
-  apply(clarify)
-  apply(simp add: supp_eqvt[symmetric] Diff_eqvt[symmetric])
-  apply(simp add: fresh_def supp_perm)
-  apply(rule sym)
-  apply(rule ii)
-  apply(simp)
+lemma abs_eq_iff:
+  shows "Abs bs x = Abs cs y \<longleftrightarrow> (bs, x) \<approx>abs (cs, y)"
+  and   "Abs_res bs x = Abs_res cs y \<longleftrightarrow> (bs, x) \<approx>abs_res (cs, y)"
+  and   "Abs_lst ds x = Abs_lst hs y \<longleftrightarrow> (ds, x) \<approx>abs_lst (hs, y)"
+  apply(simp_all)
+  apply(lifting alphas_abs)
   done
 
 
-lemma yy:
-  assumes "S1 - {x} = S2 - {x}" "x \<in> S1" "x \<in> S2"
-  shows "S1 = S2"
-using assms
-apply (metis insert_Diff_single insert_absorb)
-done
-
-lemma kk:
-  assumes a: "p \<bullet> x = y"
-  shows "\<forall>a \<in> supp x. (p \<bullet> a) \<in> supp y"
-using a
-apply(auto)
-apply(rule_tac p="- p" in permute_boolE)
-apply(simp add: mem_eqvt supp_eqvt)
-done
-
-lemma ww:
-  assumes "a \<notin> supp x" "b \<in> supp x" "a \<noteq> b" "sort_of a = sort_of b"
-  shows "((a \<rightleftharpoons> b) \<bullet> x) \<noteq> x"
-apply(subgoal_tac "(supp x) supports x")
-apply(simp add: supports_def)
-using assms
-apply -
-apply(drule_tac x="a" in spec)
-defer
-apply(rule supp_supports)
-apply(auto)
-apply(rotate_tac 1)
-apply(drule_tac p="(a \<rightleftharpoons> b)" in permute_boolI)
-apply(simp add: mem_eqvt supp_eqvt)
-done
-
-lemma alpha_abs_sym:
-  assumes a: "({a}, x) \<approx>abs ({b}, y)"
-  shows "({b}, y) \<approx>abs ({a}, x)"
-using a
-apply(simp)
-apply(erule exE)
-apply(rule_tac x="- p" in exI)
-apply(simp add: alpha_gen)
-apply(simp add: fresh_star_def fresh_minus_perm)
-apply (metis permute_minus_cancel(2))
-done
-
-lemma alpha_abs_trans:
-  assumes a: "({a1}, x1) \<approx>abs ({a2}, x2)"
-  assumes b: "({a2}, x2) \<approx>abs ({a3}, x3)"
-  shows "({a1}, x1) \<approx>abs ({a3}, x3)"
-using a b
-apply(simp)
-apply(erule exE)+
-apply(rule_tac x="pa + p" in exI)
-apply(simp add: alpha_gen)
-apply(simp add: fresh_star_def fresh_plus_perm)
-done
-
-lemma alpha_equal:
-  assumes a: "({a}, x) \<approx>abs ({a}, y)" 
-  shows "(a, x) \<approx>abs1 (a, y)"
-using a
-apply(simp)
-apply(erule exE)
-apply(simp add: alpha_gen)
-apply(erule conjE)+
-apply(case_tac "a \<notin> supp x")
-apply(simp)
-apply(subgoal_tac "supp x \<sharp>* p")
-apply(drule supp_perm_eq)
-apply(simp)
-apply(simp)
-apply(simp)
-apply(case_tac "a \<notin> supp y")
-apply(simp)
-apply(drule supp_perm_eq)
-apply(clarify)
-apply(simp (no_asm_use))
-apply(simp)
-apply(simp)
-apply(drule yy)
-apply(simp)
-apply(simp)
-apply(simp)
-apply(case_tac "a \<sharp> p")
-apply(subgoal_tac "supp y \<sharp>* p")
-apply(drule supp_perm_eq)
-apply(clarify)
-apply(simp (no_asm_use))
-apply(metis)
-apply(auto simp add: fresh_star_def)[1]
-apply(frule_tac kk)
-apply(drule_tac x="a" in bspec)
-apply(simp)
-apply(simp add: fresh_def)
-apply(simp add: supp_perm)
-apply(subgoal_tac "((p \<bullet> a) \<sharp> p)")
-apply(simp add: fresh_def supp_perm)
-apply(simp add: fresh_star_def)
-done
-
-lemma alpha_unequal:
-  assumes a: "({a}, x) \<approx>abs ({b}, y)" "sort_of a = sort_of b" "a \<noteq> b"
-  shows "(a, x) \<approx>abs1 (b, y)"
-using a
-apply -
-apply(subgoal_tac "a \<notin> supp x - {a}")
-apply(subgoal_tac "b \<notin> supp x - {a}")
-defer
-apply(simp add: alpha_gen)
-apply(simp)
-apply(drule_tac alpha_abs_swap)
-apply(assumption)
-apply(simp only: insert_eqvt empty_eqvt swap_atom_simps)
-apply(drule alpha_abs_sym)
-apply(rotate_tac 4)
-apply(drule_tac alpha_abs_trans)
-apply(assumption)
-apply(drule alpha_equal)
-apply(simp)
-apply(rule_tac p="(a \<rightleftharpoons> b)" in permute_boolE)
-apply(simp add: fresh_eqvt)
-apply(simp add: fresh_def)
-done
-
-lemma alpha_new_old:
-  assumes a: "({a}, x) \<approx>abs ({b}, y)" "sort_of a = sort_of b" 
-  shows "(a, x) \<approx>abs1 (b, y)"
-using a
-apply(case_tac "a=b")
-apply(simp only: alpha_equal)
-apply(drule alpha_unequal)
-apply(simp)
-apply(simp)
-apply(simp)
-done
+section {* BELOW is stuff that may or may not be needed *}
 
 (* support of concrete atom sets *)
 
@@ -563,6 +460,12 @@
   done
 
 (* TODO: The following lemmas can be moved somewhere... *)
+
+lemma Abs_eq_iff:
+  shows "Abs bs x = Abs cs y \<longleftrightarrow> (\<exists>p. (bs, x) \<approx>gen (op =) supp p (cs, y))"
+  by (lifting alpha_abs.simps(1))
+
+
 lemma split_rsp2[quot_respect]: "((R1 ===> R2 ===> prod_rel R1 R2 ===> op =) ===>
   prod_rel R1 R2 ===> prod_rel R1 R2 ===> op =) split split"
   by auto
@@ -673,5 +576,51 @@
   apply(simp)
   done
 
+lemma alpha_gen_refl:
+  assumes a: "R x x"
+  shows "(bs, x) \<approx>gen 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_gen_sym:
+  assumes a: "R (p \<bullet> x) y \<Longrightarrow> R (- p \<bullet> y) x"
+  shows "(bs, x) \<approx>gen R f p (cs, y) \<Longrightarrow> (cs, y) \<approx>gen 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)"
+  using a
+  unfolding alphas
+  unfolding fresh_star_def
+  by (auto simp add:  fresh_minus_perm)
+
+lemma alpha_gen_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>gen R f p (cs, y); (cs, y) \<approx>gen R f q (ds, z)\<rbrakk> \<Longrightarrow> (bs, x) \<approx>gen 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
+  unfolding fresh_star_def
+  by (simp_all add: fresh_plus_perm)
+
+lemma alpha_gen_eqvt:
+  assumes a: "R (q \<bullet> x) y \<Longrightarrow> R (p \<bullet> (q \<bullet> x)) (p \<bullet> y)"
+  and     b: "p \<bullet> (f x) = f (p \<bullet> x)"
+  and     c: "p \<bullet> (f y) = f (p \<bullet> y)"
+  shows "(bs, x) \<approx>gen R f q (cs, y) \<Longrightarrow> (p \<bullet> bs, p \<bullet> x) \<approx>gen R 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 R 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 R f (p \<bullet> q) (p \<bullet> es, p \<bullet> y)" 
+  unfolding alphas
+  unfolding set_eqvt[symmetric]
+  unfolding b[symmetric] c[symmetric]
+  unfolding Diff_eqvt[symmetric]
+  unfolding permute_eqvt[symmetric]
+  using a
+  by (auto simp add: fresh_star_permute_iff)
+
+
 end