(*  Title:      Quotient.thy

    Author:     Cezary Kaliszyk 

    Author:     Christian Urban

    provides a reasoning infrastructure for the type of finite sets

*)

theory FSet

imports Quotient Quotient_List List

begin

fun

  list_eq :: "'a list \<Rightarrow> 'a list \<Rightarrow> bool" (infix "\<approx>" 50)

where

  "list_eq xs ys = (\<forall>x. x \<in> set xs \<longleftrightarrow> x \<in> set ys)"

lemma list_eq_equivp:

  shows "equivp list_eq"

  unfolding equivp_reflp_symp_transp 

  unfolding reflp_def symp_def transp_def

  by auto

definition

  memb :: "'a \<Rightarrow> 'a list \<Rightarrow> bool"

where

  "memb x xs \<equiv> x \<in> set xs"

definition

  sub_list :: "'a list \<Rightarrow> 'a list \<Rightarrow> bool"

where

  "sub_list xs ys \<equiv> (\<forall>x. x \<in> set xs \<longrightarrow> x \<in> set ys)"

quotient_type

  'a fset = "'a list" / "list_eq"

by (rule list_eq_equivp)

lemma sub_list_rsp1: "\<lbrakk>xs \<approx> ys\<rbrakk> \<Longrightarrow> sub_list xs zs = sub_list ys zs"

  by (simp add: sub_list_def)

lemma sub_list_rsp2: "\<lbrakk>xs \<approx> ys\<rbrakk> \<Longrightarrow> sub_list zs xs = sub_list zs ys"

  by (simp add: sub_list_def)

lemma [quot_respect]:

  shows "(op \<approx> ===> op \<approx> ===> op =) sub_list sub_list"

  by (auto simp only: fun_rel_def sub_list_rsp1 sub_list_rsp2)

lemma [quot_respect]:

  shows "(op \<approx> ===> op \<approx> ===> op \<approx>) op @ op @"

  by auto

lemma sub_list_not_eq:

  "(sub_list x y \<and> \<not> list_eq x y) = (sub_list x y \<and> \<not> sub_list y x)"

  by (auto simp add: sub_list_def)

lemma sub_list_refl:

  "sub_list x x"

  by (simp add: sub_list_def)

lemma sub_list_trans:

  "sub_list x y \<Longrightarrow> sub_list y z \<Longrightarrow> sub_list x z"

  by (simp add: sub_list_def)

lemma sub_list_empty:

  "sub_list [] x"

  by (simp add: sub_list_def)

begin

quotient_definition

  "bot :: 'a fset" is "[] :: 'a list"

abbreviation

  fempty  ("{||}")

where

  "{||} \<equiv> bot :: 'a fset"

quotient_definition

  "less_eq_fset \<Colon> ('a fset \<Rightarrow> 'a fset \<Rightarrow> bool)"

is

  "sub_list \<Colon> ('a list \<Rightarrow> 'a list \<Rightarrow> bool)"

abbreviation

  f_subset_eq :: "'a fset \<Rightarrow> 'a fset \<Rightarrow> bool" (infix "|\<subseteq>|" 50)

where

  "xs |\<subseteq>| ys \<equiv> xs \<le> ys"

definition

  less_fset:

  "(xs :: 'a fset) < ys \<equiv> xs \<le> ys \<and> xs \<noteq> ys"

abbreviation

  f_subset :: "'a fset \<Rightarrow> 'a fset \<Rightarrow> bool" (infix "|\<subset>|" 50)

where

  "xs |\<subset>| ys \<equiv> xs < ys"

quotient_definition

  "sup  \<Colon> ('a fset \<Rightarrow> 'a fset \<Rightarrow> 'a fset)"

is

  "(op @) \<Colon> ('a list \<Rightarrow> 'a list \<Rightarrow> 'a list)"

abbreviation

  funion  (infixl "|\<union>|" 65)

where

  "xs |\<union>| ys \<equiv> sup (xs :: 'a fset) ys"

instance

proof

  show "x |\<subseteq>| x |\<union>| y" by (lifting sub_list_append_left)

  show "y |\<subseteq>| x |\<union>| y" by (lifting sub_list_append_right)

next

  fix x y :: "'a fset"

  assume a: "x |\<subseteq>| y"

  assume b: "y |\<subseteq>| x"

  show "x = y" using a b by (lifting sub_list_list_eq)

next

  fix x y z :: "'a fset"

  assume a: "y |\<subseteq>| x"

  assume b: "z |\<subseteq>| x"

  show "y |\<union>| z |\<subseteq>| x" using a b by (lifting sub_list_append)

qed

end

section {* Empty fset, Finsert and Membership *}

quotient_definition

  "finsert :: 'a \<Rightarrow> 'a fset \<Rightarrow> 'a fset"

is "op #"

syntax

  "@Finset"     :: "args => 'a fset"  ("{|(_)|}")

translations

  "{|x, xs|}" == "CONST finsert x {|xs|}"

  "{|x|}"     == "CONST finsert x {||}"

quotient_definition

  fin ("_ |\<in>| _" [50, 51] 50)

where

  "fin :: 'a \<Rightarrow> 'a fset \<Rightarrow> bool" is "memb"

abbreviation

  fnotin :: "'a \<Rightarrow> 'a fset \<Rightarrow> bool" ("_ |\<notin>| _" [50, 51] 50)

where

  "x |\<notin>| S \<equiv> \<not> (x |\<in>| S)"

lemma memb_rsp[quot_respect]:

  shows "(op = ===> op \<approx> ===> op =) memb memb"

by (auto simp add: memb_def)

lemma nil_rsp[quot_respect]:

  shows "[] \<approx> []"

by simp

lemma cons_rsp[quot_respect]:

  shows "(op = ===> op \<approx> ===> op \<approx>) op # op #"

by simp

section {* Augmenting an fset -- @{const finsert} *}

lemma nil_not_cons:

  shows "\<not> ([] \<approx> x # xs)"

  and   "\<not> (x # xs \<approx> [])"

  by auto

lemma no_memb_nil:

  "(\<forall>x. \<not> memb x xs) = (xs = [])"

  by (simp add: memb_def)

lemma none_memb_nil:

  "(\<forall>x. \<not> memb x xs) = (xs \<approx> [])"

  by (simp add: memb_def)

lemma memb_consI1:

  shows "memb x (x # xs)"

  by (simp add: memb_def)

lemma memb_consI2:

  shows "memb x xs \<Longrightarrow> memb x (y # xs)"

  by (simp add: memb_def)

lemma memb_absorb:

  shows "memb x xs \<Longrightarrow> x # xs \<approx> xs"

  by (induct xs) (auto simp add: memb_def id_simps)

section {* Singletons *}

lemma singleton_list_eq:

  shows "[x] \<approx> [y] \<longleftrightarrow> x = y"

  by (simp add: id_simps) auto

section {* sub_list *}

lemma sub_list_cons:

  "sub_list (x # xs) ys = (memb x ys \<and> sub_list xs ys)"

  by (auto simp add: memb_def sub_list_def)

section {* Cardinality of finite sets *}

fun

  fcard_raw :: "'a list \<Rightarrow> nat"

where

  fcard_raw_nil:  "fcard_raw [] = 0"

| fcard_raw_cons: "fcard_raw (x # xs) = (if memb x xs then fcard_raw xs else Suc (fcard_raw xs))"

quotient_definition

  "fcard :: 'a fset \<Rightarrow> nat" 

is

  "fcard_raw"

lemma fcard_raw_0:

  shows "fcard_raw xs = 0 \<longleftrightarrow> xs \<approx> []"

  by (induct xs) (auto simp add: memb_def)

lemma fcard_raw_gt_0:

  assumes a: "x \<in> set xs"

  shows "0 < fcard_raw xs"

  using a by (induct xs) (auto simp add: memb_def)

lemma fcard_raw_not_memb:

  shows "\<not> memb x xs \<longleftrightarrow> fcard_raw (x # xs) = Suc (fcard_raw xs)"

  by auto

lemma fcard_raw_suc:

  assumes a: "fcard_raw xs = Suc n"

  shows "\<exists>x ys. \<not> (memb x ys) \<and> xs \<approx> (x # ys) \<and> fcard_raw ys = n"

  using a

  by (induct xs) (auto simp add: memb_def split: if_splits)

lemma singleton_fcard_1: 

  shows "set xs = {x} \<Longrightarrow> fcard_raw xs = 1"

  by (induct xs) (auto simp add: memb_def subset_insert)

lemma fcard_raw_1:

  shows "fcard_raw xs = 1 \<longleftrightarrow> (\<exists>x. xs \<approx> [x])"

  apply (auto dest!: fcard_raw_suc)

  apply (simp add: fcard_raw_0)

  apply (rule_tac x="x" in exI)

  apply simp

  apply (subgoal_tac "set xs = {x}")

  apply (drule singleton_fcard_1)

  apply auto

  done

lemma fcard_raw_delete_one:

  shows "fcard_raw ([x \<leftarrow> xs. x \<noteq> y]) = (if memb y xs then fcard_raw xs - 1 else fcard_raw xs)"

  by (induct xs) (auto dest: fcard_raw_gt_0 simp add: memb_def)

lemma fcard_raw_suc_memb:

  assumes a: "fcard_raw A = Suc n"

  shows "\<exists>a. memb a A"

  using a

  apply (induct A)

  apply simp

  apply (rule_tac x="a" in exI)

  apply (simp add: memb_def)

  done

lemma memb_card_not_0:

  assumes a: "memb a A"

  shows "\<not>(fcard_raw A = 0)"

proof -

  have "\<not>(\<forall>x. \<not> memb x A)" using a by auto

  then have "\<not>A \<approx> []" using none_memb_nil[of A] by simp

  then show ?thesis using fcard_raw_0[of A] by simp

qed

lemma fcard_raw_rsp_aux:

  assumes a: "xs \<approx> ys"

  shows "fcard_raw xs = fcard_raw ys"

  using a

  apply(induct xs arbitrary: ys)

  apply(auto simp add: memb_def)

  apply(subgoal_tac "\<forall>x. (x \<in> set xs) = (x \<in> set ys)")

  apply simp

  apply auto

  apply (drule_tac x="x" in spec)

  apply blast

  apply(drule_tac x="[x \<leftarrow> ys. x \<noteq> a]" in meta_spec)

  apply(simp add: fcard_raw_delete_one memb_def)

  apply (case_tac "a \<in> set ys")

  apply (simp only: if_True)

  apply (subgoal_tac "\<forall>x. (x \<in> set xs) = (x \<in> set ys \<and> x \<noteq> a)")

  apply (drule Suc_pred'[OF fcard_raw_gt_0])

  apply auto

  done

lemma fcard_raw_rsp[quot_respect]:

  shows "(op \<approx> ===> op =) fcard_raw fcard_raw"

  by (simp add: fcard_raw_rsp_aux)

section {* fmap and fset comprehension *}

quotient_definition

  "fmap :: ('a \<Rightarrow> 'b) \<Rightarrow> 'a fset \<Rightarrow> 'b fset"

is

 "map"

lemma map_append:

  "map f (xs @ ys) \<approx> (map f xs) @ (map f ys)"

  by simp

lemma memb_append:

  "memb x (xs @ ys) \<longleftrightarrow> memb x xs \<or> memb x ys"

  by (induct xs) (simp_all add: not_memb_nil memb_cons_iff)

text {* raw section *}

lemma map_rsp[quot_respect]:

  shows "(op = ===> op \<approx> ===> op \<approx>) map map"

  by auto

lemma cons_left_comm:

  "x # y # xs \<approx> y # x # xs"

  by auto

lemma cons_left_idem:

  "x # x # xs \<approx> x # xs"

  by auto

lemma fset_raw_strong_cases:

  "(xs = []) \<or> (\<exists>x ys. ((\<not> memb x ys) \<and> (xs \<approx> x # ys)))"

  apply (induct xs)

  apply (simp)

  apply (rule disjI2)

  apply (erule disjE)

  apply (rule_tac x="a" in exI)

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

  apply (simp add: memb_def)

  apply (erule exE)+

  apply (case_tac "x = a")

  apply (rule_tac x="a" in exI)

  apply (rule_tac x="ys" in exI)

  apply (simp)

  apply (rule_tac x="x" in exI)

  apply (rule_tac x="a # ys" in exI)

  apply (auto simp add: memb_def)

  done

section {* deletion *}

fun

  delete_raw :: "'a list \<Rightarrow> 'a \<Rightarrow> 'a list"

where

  "delete_raw [] x = []"

| "delete_raw (a # A) x = (if (a = x) then delete_raw A x else a # (delete_raw A x))"

lemma memb_delete_raw:

  "memb x (delete_raw xs y) = (memb x xs \<and> x \<noteq> y)"

  by (induct xs arbitrary: x y) (auto simp add: memb_def)

lemma delete_raw_rsp:

  "xs \<approx> ys \<Longrightarrow> delete_raw xs x \<approx> delete_raw ys x"

  by (simp add: memb_def[symmetric] memb_delete_raw)

lemma [quot_respect]:

  "(op \<approx> ===> op = ===> op \<approx>) delete_raw delete_raw"

  by (simp add: memb_def[symmetric] memb_delete_raw)

lemma memb_delete_raw_ident:

  shows "\<not> memb x (delete_raw xs x)"

  by (induct xs) (auto simp add: memb_def)

lemma not_memb_delete_raw_ident:

  shows "\<not> memb x xs \<Longrightarrow> delete_raw xs x = xs"

  by (induct xs) (auto simp add: memb_def)

lemma fset_raw_delete_raw_cases:

  "xs = [] \<or> (\<exists>x. memb x xs \<and> xs \<approx> x # delete_raw xs x)"

  by (induct xs) (auto simp add: memb_def)

lemma fdelete_raw_filter:

  "delete_raw xs y = [x \<leftarrow> xs. x \<noteq> y]"

  by (induct xs) simp_all

lemma fcard_raw_delete:

  "fcard_raw (delete_raw xs y) = (if memb y xs then fcard_raw xs - 1 else fcard_raw xs)"

  by (simp add: fdelete_raw_filter fcard_raw_delete_one)

lemma set_rsp[quot_respect]:

  "(op \<approx> ===> op =) set set"

  by auto

definition

  rsp_fold

where

  "rsp_fold f = (\<forall>u v w. (f u (f v w) = f v (f u w)))"

primrec

  ffold_raw :: "('a \<Rightarrow> 'b \<Rightarrow> 'b) \<Rightarrow> 'b \<Rightarrow> 'a list \<Rightarrow> 'b"

where

  "ffold_raw f z [] = z"

| "ffold_raw f z (a # A) =

     (if (rsp_fold f) then

       if memb a A then ffold_raw f z A

       else f a (ffold_raw f z A)

     else z)"