(*  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)

section {* Empty fset, Finsert and Membership *}

quotient_definition

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 not_memb_nil:

  shows "\<not> memb x []"

  by (simp add: memb_def)

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_cons_iff:

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

  by (induct xs) (auto 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 {* Unions *}

quotient_definition

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

where

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

is

  "op @"

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

lemma memb_commute_ffold_raw:

  "rsp_fold f \<Longrightarrow> memb h b \<Longrightarrow> ffold_raw f z b = f h (ffold_raw f z (delete_raw b h))"

  apply (induct b)

  apply (simp add: not_memb_nil)

  apply (simp add: ffold_raw.simps)

  apply (rule conjI)

  apply (rule_tac [!] impI)

  apply (rule_tac [!] conjI)

  apply (rule_tac [!] impI)

  apply (simp_all add: memb_delete_raw)

  apply (simp add: memb_cons_iff)

  apply (simp add: not_memb_delete_raw_ident)

  apply (simp add: memb_cons_iff rsp_fold_def)

  done

lemma ffold_raw_rsp_pre:

  "\<forall>e. memb e a = memb e b \<Longrightarrow> ffold_raw f z a = ffold_raw f z b"

  apply (induct a arbitrary: b)

  apply (simp add: hd_in_set memb_absorb memb_def none_memb_nil)

  apply (simp add: ffold_raw.simps)

  apply (rule conjI)

  apply (rule_tac [!] impI)

  apply (rule_tac [!] conjI)

  apply (rule_tac [!] impI)

  apply (subgoal_tac "\<forall>e. memb e a2 = memb e b")

  apply (simp)

  apply (simp add: memb_cons_iff memb_def)

  apply auto

  apply (drule_tac x="e" in spec)

  apply blast

  apply (case_tac b)

  apply simp_all

  apply (subgoal_tac "ffold_raw f z b = f a1 (ffold_raw f z (delete_raw b a1))")

  apply (simp only:)

  apply (rule_tac f="f a1" in arg_cong)

  apply (subgoal_tac "\<forall>e. memb e a2 = memb e (delete_raw b a1)")

  apply simp

  apply (simp add: memb_delete_raw)

  apply (auto simp add: memb_cons_iff)[1]

  apply (erule memb_commute_ffold_raw)

  apply (drule_tac x="a1" in spec)

  apply (simp add: memb_cons_iff)

  apply (simp add: memb_cons_iff)

  apply (case_tac b)

  apply simp_all

  done

lemma [quot_respect]:

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

  by (simp add: memb_def[symmetric] ffold_raw_rsp_pre)

primrec

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

where

  "finter_raw [] l = []"

| "finter_raw (h # t) l =

     (if memb h l then h # (finter_raw t l) else finter_raw t l)"

lemma finter_raw_empty:

  "finter_raw l [] = []"

  by (induct l) (simp_all add: not_memb_nil)

lemma memb_finter_raw:

  "memb x (finter_raw xs ys) \<longleftrightarrow> memb x xs \<and> memb x ys"

  apply (induct xs)

  apply (simp add: not_memb_nil)

  apply (simp add: finter_raw.simps)

  apply (simp add: memb_cons_iff)

  apply auto

  done

lemma [quot_respect]:

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

  by (simp add: memb_def[symmetric] memb_finter_raw)

section {* Constants on the Quotient Type *} 

quotient_definition

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

  is "delete_raw"

quotient_definition

  "fset_to_set :: 'a fset \<Rightarrow> 'a set" 

  is "set"

quotient_definition

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

  is "ffold_raw"

quotient_definition

  finter (infix "|\<inter>|" 50)

where

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

is "finter_raw"

lemma funion_sym_pre:

  "xs @ ys \<approx> ys @ xs"