datatype 'a rabst = 

  RAbst "atom set" "'a::pt"

fun map_fun 

where "map_fun f (RAbst bs x) = RAbst bs (f x)"

fun map_rel

where "map_rel R (RAbst bs x) (RAbst cs y) = R x y"

declare [[map "rabst" = (map_fun, map_rel)]]

instantiation rabst :: (pt) pt

  permute_rabst

  "p \<bullet> (RAbst bs x) = RAbst (p \<bullet> bs) (p \<bullet> x)"

end

 alpha_gen 

 alpha_gen[simp del]:

   "(alpha_gen (bs, x) R f pi (cs, y)) \<longleftrightarrow> (f x - bs = f y - cs) \<and> ((f x - bs) \<sharp>* pi) \<and> (R (pi \<bullet> x) y)"

notation

  alpha_gen ("_ \<approx>gen _ _ _ _")

lemma alpha_gen_refl:

  assumes a: "R x x"

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

  using a by (simp add: alpha_gen fresh_star_def fresh_zero_perm)

lemma alpha_gen_sym:

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

  and     b: "R (p \<bullet> x) y \<Longrightarrow> R (- p \<bullet> y) x"

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

  using a b by (simp add: alpha_gen fresh_star_def fresh_def supp_minus_perm)

lemma alpha_gen_trans:

  assumes a: "(bs, x) \<approx>gen R f p1 (cs, y)"

  and     b: "(cs, y) \<approx>gen R f p2 (ds, z)"

  and     c: "\<lbrakk>R (p1 \<bullet> x) y; R (p2 \<bullet> y) z\<rbrakk> \<Longrightarrow> R ((p2 + p1) \<bullet> x) z"

  shows "(bs, x) \<approx>gen R f (p2 + p1) (ds, z)"

  using a b c using supp_plus_perm

  apply(simp add: alpha_gen fresh_star_def fresh_def)

  apply(blast)

  done

lemma alpha_gen_eqvt:

  assumes a: "(bs, x) \<approx>gen R f q (cs, y)"

  and     b: "R (q \<bullet> x) y \<Longrightarrow> R (p \<bullet> (q \<bullet> x)) (p \<bullet> y)"

  and     c: "p \<bullet> (f x) = f (p \<bullet> x)"

  and     d: "p \<bullet> (f y) = f (p \<bullet> y)"

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

  using a b

  apply(simp add: alpha_gen c[symmetric] d[symmetric] Diff_eqvt[symmetric])

  apply(simp add: permute_eqvt[symmetric])

  apply(simp add: fresh_star_permute_iff)

  apply(clarsimp)

  done

fun

  alpha_rabst :: "('a::pt) rabst \<Rightarrow> 'a rabst \<Rightarrow> bool" ("_ \<approx>raw _") 

where

  "(RAbst bs x) \<approx>raw (RAbst cs y) = (\<exists>p. (bs, x) \<approx>gen (op=) supp p (cs, y))" 

  shows "abst \<approx>raw abst"

apply(induct abst)

apply(rule exI)

apply(rule alpha_gen_refl)

apply(simp)

  assumes a: "abst1 \<approx>raw abst2"

  shows "abst2 \<approx>raw abst1"

apply(induct rule: alpha_rabst.induct)

apply(erule exE)

apply(rule exI)

apply(rule alpha_gen_sym)

apply(assumption)

apply(clarsimp)

  assumes a1: "abst1 \<approx>raw abst2"

  and     a2: "abst2 \<approx>raw abst3"

  shows "abst1 \<approx>raw abst3"

apply(induct rule: alpha_rabst.induct)

apply(induct rule: alpha_rabst.induct)

apply(erule exE)+

apply(rule exI)

apply(rule alpha_gen_trans)

apply(assumption)

apply(assumption)

  assumes a: "abst1 \<approx>raw abst2"

  shows "(p \<bullet> abst1) \<approx>raw(p \<bullet> abst2)"

apply(induct abst1 abst2 rule: alpha_rabst.induct)

apply(erule exE)

apply(rule exI)

apply(rule alpha_gen_eqvt)

apply(assumption)

apply(simp)

apply(simp add: supp_eqvt)

apply(simp add: supp_eqvt)

  shows "(RAbst bs x) \<approx>raw (RAbst ((a \<rightleftharpoons> b) \<bullet> bs) ((a \<rightleftharpoons> b) \<bullet> x))"

apply(simp)

apply(simp add: alpha_gen)

apply(simp add: supp_eqvt[symmetric] Diff_eqvt[symmetric])

apply(simp add: swap_set_fresh[OF a1 a2])

apply(simp add: fresh_star_def fresh_def)

  "s_test (RAbst bs x) = (supp x) - bs"

  assumes a: "x \<approx>raw y" 

apply(induct rule: alpha_rabst.induct)

apply(simp add: alpha_gen)

quotient_type 'a abst = "('a::pt) rabst" / "alpha_rabst::('a::pt) rabst \<Rightarrow> 'a rabst \<Rightarrow> bool"

   "Abst::atom set \<Rightarrow> ('a::pt) \<Rightarrow> 'a abst"

   "RAbst"

  shows "((op =) ===> (op =) ===> alpha_rabst) RAbst RAbst"

apply(simp del: alpha_rabst.simps add: alpha_reflp)

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

  shows "(alpha_rabst ===> (op =)) s_test s_test"

lemma abst_induct:

  "\<lbrakk>\<And>as (x::'a::pt). P (Abst as x)\<rbrakk> \<Longrightarrow> P t"

apply(lifting rabst.induct)

instantiation abst :: (pt) pt

  "permute_abst::perm \<Rightarrow> ('a::pt abst) \<Rightarrow> 'a abst"

  "permute::perm \<Rightarrow> ('a::pt rabst) \<Rightarrow> 'a rabst"

  fixes x::"'a::pt"  (* ??? has to be 'a \<dots> 'b does not work *)

  shows "(p \<bullet> (Abst as x)) = Abst (p \<bullet> as) (p \<bullet> x)"

apply(lifting permute_rabst.simps(1))

  apply(induct_tac [!] x rule: abst_induct)

  shows "(Abst bs x) = (Abst ((a \<rightleftharpoons> b) \<bullet> bs) ((a \<rightleftharpoons> b) \<bullet> x))"

lemma Abst_supports:

  shows "((supp x) - as) supports (Abst as x)"

  "s_test_lifted :: ('a::pt) abst \<Rightarrow> atom \<Rightarrow> bool"

  "s_test::('a::pt) rabst \<Rightarrow> atom \<Rightarrow> bool"

  shows "s_test_lifted (Abst bs x) = (supp x) - bs"

apply(induct ab rule: abst_induct)

  shows "(a \<sharp> Abst bs x) \<Longrightarrow> (a \<sharp> s_test_lifted (Abst bs x))"

  shows "((supp x) - as) \<subseteq> (supp (Abst as x))"

lemma supp_Abst:

  shows "supp (Abst as x) = (supp x) - as"

apply(rule Abst_supports)

instance abst :: (fs) fs

apply(induct_tac x rule: abst_induct)

apply(simp add: supp_Abst)

  shows "a \<sharp> Abst bs x = (a \<in> bs \<or> (a \<notin> bs \<and> a \<sharp> x))"

apply(simp add: supp_Abst)

thm alpha_rabst.simps(1)

  shows "(Abst bs x) = (Abst cs y) \<longleftrightarrow> (\<exists>p. (bs, x) \<approx>gen (op =) supp p (cs, y))"

apply(lifting alpha_rabst.simps(1))