theory Abs

imports "Nominal2_Atoms" "Nominal2_Eqvt" "Nominal2_Supp" "../Quotient" "../Quotient_Product"

begin

fun

  alpha_gen 

where

  alpha_gen[simp del]:

notation

  alpha_gen ("_ \<approx>gen _ _ _ _" [100, 100, 100, 100, 100] 100)

lemma [mono]: "R1 \<le> R2 \<Longrightarrow> alpha_gen x R1 \<le> alpha_gen x R2"

  by (cases x) (auto simp add: le_fun_def le_bool_def alpha_gen.simps)

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)"

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

lemma alpha_gen_compose_sym:

  fixes pi

  assumes b: "(aa, t) \<approx>gen (\<lambda>x1 x2. R x1 x2 \<and> R x2 x1) f pi (ab, s)"

  and a: "\<And>pi t s. (R t s \<Longrightarrow> R (pi \<bullet> t) (pi \<bullet> s))"

  shows "(ab, s) \<approx>gen R f (- pi) (aa, t)"

  using b apply -

  apply(simp add: alpha_gen.simps)

  apply(erule conjE)+

  apply(rule conjI)

  apply(simp add: fresh_star_def fresh_minus_perm)

  apply(subgoal_tac "R (- pi \<bullet> s) ((- pi) \<bullet> (pi \<bullet> t))")

  apply simp

  apply(rule a)

  apply assumption

  done

lemma alpha_gen_compose_trans:

  fixes pi pia

  assumes b: "(aa, t) \<approx>gen (\<lambda>x1 x2. R x1 x2 \<and> (\<forall>x. R x2 x \<longrightarrow> R x1 x)) f pi (ab, ta)"

  and c: "(ab, ta) \<approx>gen R f pia (ac, sa)"

  and a: "\<And>pi t s. (R t s \<Longrightarrow> R (pi \<bullet> t) (pi \<bullet> s))"

  shows "(aa, t) \<approx>gen R f (pia + pi) (ac, sa)"

  using b c apply -

  apply(simp add: alpha_gen.simps)

  apply(erule conjE)+

  apply(simp add: fresh_star_plus)

  apply(drule_tac x="- pia \<bullet> sa" in spec)

  apply(drule mp)

  apply(drule_tac pi="- pia" in a)

  apply(simp)

  apply(drule_tac pi="pia" in a)

  apply(simp)

  done

lemma alpha_gen_compose_eqvt:

  fixes  pia

  assumes b: "(g d, t) \<approx>gen (\<lambda>x1 x2. R x1 x2 \<and> R (pi \<bullet> x1) (pi \<bullet> x2)) f pia (g e, s)"

  and     c: "\<And>y. pi \<bullet> (g y) = g (pi \<bullet> y)"

  and     a: "\<And>x. pi \<bullet> (f x) = f (pi \<bullet> x)"

  shows  "(g (pi \<bullet> d), pi \<bullet> t) \<approx>gen R f (pi \<bullet> pia) (g (pi \<bullet> e), pi \<bullet> s)"

  using b

  apply -

  apply(simp add: alpha_gen.simps)

  apply(erule conjE)+

  apply(rule conjI)

  apply(rule_tac ?p1="- pi" in permute_eq_iff[THEN iffD1])

  apply(simp add: a[symmetric] atom_eqvt Diff_eqvt insert_eqvt set_eqvt empty_eqvt c[symmetric])

  apply(rule conjI)

  apply(rule_tac ?p1="- pi" in fresh_star_permute_iff[THEN iffD1])

  apply(simp add: a[symmetric] atom_eqvt Diff_eqvt insert_eqvt set_eqvt empty_eqvt c[symmetric])

  apply(subst permute_eqvt[symmetric])

  apply(simp)

fun

  alpha_abs 

where

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

notation

  alpha_abs ("_ \<approx>abs _")

lemma alpha_abs_swap:

  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)"

  apply(simp)

  apply(rule_tac x="(a \<rightleftharpoons> b)" in exI)

  apply(simp add: alpha_gen)

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

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

  apply(subgoal_tac "supp (a \<rightleftharpoons> b) \<subseteq> {a, b}")

  using a1 a2

  apply(simp add: fresh_star_def fresh_def)

  apply(blast)

  apply(simp add: supp_swap)

  done

lemma alpha_gen_swap_fun:

  assumes f_eqvt: "\<And>pi. (pi \<bullet> (f x)) = f (pi \<bullet> x)"

  assumes a1: "a \<notin> (f x) - bs"

  and     a2: "b \<notin> (f x) - bs"

  shows "\<exists>pi. (bs, x) \<approx>gen (op=) f pi ((a \<rightleftharpoons> b) \<bullet> bs, (a \<rightleftharpoons> b) \<bullet> x)"

  apply(rule_tac x="(a \<rightleftharpoons> b)" in exI)

  apply(simp add: alpha_gen)

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

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

  apply(subgoal_tac "supp (a \<rightleftharpoons> b) \<subseteq> {a, b}")

  using a1 a2

  apply(simp add: fresh_star_def fresh_def)

  apply(blast)

  apply(simp add: supp_swap)

  done

fun

  supp_abs_fun

where

  "supp_abs_fun (bs, x) = (supp x) - bs"

lemma supp_abs_fun_lemma:

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

  shows "supp_abs_fun x = supp_abs_fun y"

  using a

  apply(induct rule: alpha_abs.induct)

  apply(simp add: alpha_gen)

  done

quotient_type 'a abs = "(atom set \<times> 'a::pt)" / "alpha_abs"

  apply(rule equivpI)

  unfolding reflp_def symp_def transp_def

  apply(simp_all)

  (* refl *)

  apply(clarify)

  apply(rule exI)

  apply(rule alpha_gen_refl)

  apply(simp)

  (* symm *)

  apply(clarify)

  apply(rule exI)

  apply(rule alpha_gen_sym)

  apply(assumption)

  apply(clarsimp)

  (* trans *)

  apply(clarify)

  apply(rule exI)

  apply(rule alpha_gen_trans)

  apply(assumption)

  apply(assumption)

  apply(simp)

  done

quotient_definition

  "Abs::atom set \<Rightarrow> ('a::pt) \<Rightarrow> 'a abs"

is

  "Pair::atom set \<Rightarrow> ('a::pt) \<Rightarrow> (atom set \<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

lemma [quot_respect]:

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

  apply(clarsimp)

  apply(rule exI)

  apply(rule alpha_gen_eqvt)

  apply(assumption)

  apply(simp_all add: supp_eqvt)

  done

lemma [quot_respect]:

  shows "(alpha_abs ===> (op =)) supp_abs_fun supp_abs_fun"

  apply(simp add: supp_abs_fun_lemma)

  done

lemma abs_induct:

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

  apply(lifting prod.induct[where 'a="atom set" 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 :: (pt) pt

begin

quotient_definition

  "permute_abs::perm \<Rightarrow> ('a::pt abs) \<Rightarrow> 'a abs"

is

  "permute:: perm \<Rightarrow> (atom set \<times> 'a::pt) \<Rightarrow> (atom set \<times> 'a::pt)"

lemma permute_ABS [simp]:

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

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

  by (lifting permute_prod.simps(1)[where 'a="atom set" and 'b="'a"])

instance

  apply(default)

  apply(induct_tac [!] x rule: abs_induct)

  apply(simp_all)

  done

end

quotient_definition

  "supp_Abs_fun :: ('a::pt) abs \<Rightarrow> atom \<Rightarrow> bool"

is

  "supp_abs_fun"

lemma supp_Abs_fun_simp:

  shows "supp_Abs_fun (Abs bs x) = (supp x) - bs"

  by (lifting supp_abs_fun.simps(1))

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)

  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)

  done

lemma Abs_swap:

  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)

  done

lemma supp_Abs_subset1:

  fixes x::"'a::fs"

  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 finite_supp)

  done

lemma supp_Abs_subset2:

  fixes x::"'a::fs"

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

  apply(rule supp_is_subset)

  apply(rule Abs_supports)

  apply(simp add: finite_supp)

  done

lemma supp_Abs:

  fixes x::"'a::fs"

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

  apply(rule_tac subset_antisym)

  apply(rule supp_Abs_subset2)

  apply(rule supp_Abs_subset1)

  done

instance abs :: (fs) fs

  apply(default)

  apply(induct_tac x rule: abs_induct)

  apply(simp add: supp_Abs)

  apply(simp add: 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)

  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 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_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)

done

lemma perm_zero:

  assumes a: "\<forall>x::atom. p \<bullet> x = x"

  shows "p = 0"

using a

by (simp add: expand_perm_eq)

fun

  add_perm 

where

  "add_perm [] = 0"

| "add_perm ((a, b) # xs) = (a \<rightleftharpoons> b) + add_perm xs"

fun

  elem_perm

where

  "elem_perm [] = {}"

| "elem_perm ((a, b) # xs) = {a, b} \<union> elem_perm xs"

lemma add_perm_apend:

  shows "add_perm (xs @ ys) = add_perm xs + add_perm ys"

apply(induct xs arbitrary: ys)

apply(auto simp add: add_assoc)

done

lemma perm_list_exists:

  fixes p::perm

  shows "\<exists>xs. p = add_perm xs \<and> supp xs \<subseteq> supp p"

apply(induct p taking: "\<lambda>p::perm. card (supp p)" rule: measure_induct)

apply(rename_tac p)

apply(case_tac "supp p = {}")

apply(simp)

apply(simp add: supp_perm)

apply(drule perm_zero)

apply(simp)

apply(rule_tac x="[]" in exI)

apply(simp add: supp_Nil)

apply(subgoal_tac "\<exists>x. x \<in> supp p")

defer

apply(auto)[1]

apply(erule exE)

apply(drule_tac x="p + (((- p) \<bullet> x) \<rightleftharpoons> x)" in spec)

apply(drule mp)

defer

apply(erule exE)

apply(rule_tac x="xs @ [((- p) \<bullet> x, x)]" in exI)

apply(simp add: add_perm_apend)

apply(erule conjE)

apply(drule sym)

apply(simp)

apply(simp add: expand_perm_eq)

apply(simp add: supp_append)

apply(simp add: supp_perm supp_Cons supp_Nil supp_Pair supp_atom)

apply(rule conjI)

prefer 2

apply(auto)[1]

apply (metis left_minus minus_unique permute_atom_def_raw permute_minus_cancel(2))

defer

apply(rule psubset_card_mono)

apply(simp add: finite_supp)

apply(rule psubsetI)

defer

apply(subgoal_tac "x \<notin> supp (p + (- p \<bullet> x \<rightleftharpoons> x))")

apply(blast)

apply(simp add: supp_perm)

defer

apply(auto simp add: supp_perm)[1]

apply(case_tac "x = xa")

apply(simp)

apply(case_tac "((- p) \<bullet> x) = xa")

apply(simp)

apply(case_tac "sort_of xa = sort_of x")

apply(simp)

apply(auto)[1]

apply(simp)

apply(simp)

apply(subgoal_tac "{a. p \<bullet> (- p \<bullet> x \<rightleftharpoons> x) \<bullet> a \<noteq> a} \<subseteq> {a. p \<bullet> a \<noteq> a}")

apply(blast)

apply(auto simp add: supp_perm)[1]

apply(case_tac "x = xa")

apply(simp)

apply(case_tac "((- p) \<bullet> x) = xa")

apply(simp)

apply(case_tac "sort_of xa = sort_of x")

apply(simp)

apply(auto)[1]

apply(simp)

apply(simp)

done

lemma tt0:

  fixes p::perm

  shows "(supp x) \<sharp>* p \<Longrightarrow> \<forall>a \<in> supp p. a \<sharp> x"

apply(auto simp add: fresh_star_def supp_perm fresh_def)

done

lemma uu0:

  shows "(\<forall>a \<in> elem_perm xs. a \<sharp> x) \<Longrightarrow> (add_perm xs \<bullet> x) = x"

apply(induct xs rule: add_perm.induct)

apply(simp)

apply(simp add: swap_fresh_fresh)

done

lemma yy0:

  fixes xs::"(atom \<times> atom) list"

  shows "supp xs = elem_perm xs"

apply(induct xs rule: elem_perm.induct)

apply(auto simp add: supp_Nil supp_Cons supp_Pair supp_atom)

done

lemma tt1: