(*  Title:      HOL/Quotient_Examples/FSet.thy

    Author:     Cezary Kaliszyk, TU Munich

    Author:     Christian Urban, TU Munich

A reasoning infrastructure for the type of finite sets.

*)

theory FSet

imports Quotient_List Quotient_Product

begin

text {* Definiton of List relation and the quotient type *}

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

quotient_type

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

  by (rule list_eq_equivp)

text {* Raw definitions *}

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

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

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

primrec

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

where

  "delete_raw [] x = []"

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

primrec

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

where

  "fminus_raw l [] = l"

| "fminus_raw l (h # t) = fminus_raw (delete_raw l h) t"

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 # xs) =

     (if (rsp_fold f) then

       if memb a xs then ffold_raw f z xs

       else f a (ffold_raw f z xs)

     else z)"

text {* Composition Quotient *}

lemma list_all2_refl1:

  shows "(list_all2 op \<approx>) r r"

  by (rule list_all2_refl) (metis equivp_def fset_equivp)

lemma compose_list_refl:

  shows "(list_all2 op \<approx> OOO op \<approx>) r r"

proof

  have *: "r \<approx> r" by (rule equivp_reflp[OF fset_equivp])

  show "list_all2 op \<approx> r r" by (rule list_all2_refl1)

  with * show "(op \<approx> OO list_all2 op \<approx>) r r" ..

qed

lemma Quotient_fset_list:

  shows "Quotient (list_all2 op \<approx>) (map abs_fset) (map rep_fset)"

  by (fact list_quotient[OF Quotient_fset])

lemma set_in_eq: "(\<forall>e. ((e \<in> xs) \<longleftrightarrow> (e \<in> ys))) \<equiv> xs = ys"

  by (rule eq_reflection) auto

lemma map_rel_cong: "b \<approx> ba \<Longrightarrow> map f b \<approx> map f ba"

  unfolding list_eq.simps

  by (simp only: set_map set_in_eq)

text {* Peter *}

ML {* Quotient_Info.quotient_rules_get @{context} *}

lemma 

  assumes "Quotient R1 abs1 rep1"

  and     "Quotient R2 abs2 rep2"

  shows   "Quotient (R1 OOO R2) (abs1 o ab2) (rep1 o rep2)"

using assms

sorry

lemma 

  assumes "Quotient R1 abs1 rep1"

  and     "Quotient R2 abs2 rep2"

  shows   "Quotient (R3) (abs1 o ab2) (rep1 o rep2)"

using assms

sorry

lemma quotient_compose_list[quot_thm]:

  shows  "Quotient ((list_all2 op \<approx>) OOO (op \<approx>))

    (abs_fset \<circ> (map abs_fset)) ((map rep_fset) \<circ> rep_fset)"

  unfolding Quotient_def comp_def

proof (intro conjI allI)

  fix a r s

  show "abs_fset (map abs_fset (map rep_fset (rep_fset a))) = a"

    by (simp add: abs_o_rep[OF Quotient_fset] Quotient_abs_rep[OF Quotient_fset] map_id)

  have b: "list_all2 op \<approx> (map rep_fset (rep_fset a)) (map rep_fset (rep_fset a))"

    by (rule list_all2_refl1)

  have c: "(op \<approx> OO list_all2 op \<approx>) (map rep_fset (rep_fset a)) (map rep_fset (rep_fset a))"

    by (rule, rule equivp_reflp[OF fset_equivp]) (rule b)

  show "(list_all2 op \<approx> OOO op \<approx>) (map rep_fset (rep_fset a)) (map rep_fset (rep_fset a))"

    by (rule, rule list_all2_refl1) (rule c)

  show "(list_all2 op \<approx> OOO op \<approx>) r s = ((list_all2 op \<approx> OOO op \<approx>) r r \<and>

        (list_all2 op \<approx> OOO op \<approx>) s s \<and> abs_fset (map abs_fset r) = abs_fset (map abs_fset s))"

  proof (intro iffI conjI)

    show "(list_all2 op \<approx> OOO op \<approx>) r r" by (rule compose_list_refl)

    show "(list_all2 op \<approx> OOO op \<approx>) s s" by (rule compose_list_refl)

  next

    assume a: "(list_all2 op \<approx> OOO op \<approx>) r s"

    then have b: "map abs_fset r \<approx> map abs_fset s"

    proof (elim pred_compE)

      fix b ba

      assume c: "list_all2 op \<approx> r b"

      assume d: "b \<approx> ba"

      assume e: "list_all2 op \<approx> ba s"

      have f: "map abs_fset r = map abs_fset b"

        using Quotient_rel[OF Quotient_fset_list] c by blast

      have "map abs_fset ba = map abs_fset s"

        using Quotient_rel[OF Quotient_fset_list] e by blast

      then have g: "map abs_fset s = map abs_fset ba" by simp

      then show "map abs_fset r \<approx> map abs_fset s" using d f map_rel_cong by simp

    qed

    then show "abs_fset (map abs_fset r) = abs_fset (map abs_fset s)"

      using Quotient_rel[OF Quotient_fset] by blast

  next

    assume a: "(list_all2 op \<approx> OOO op \<approx>) r r \<and> (list_all2 op \<approx> OOO op \<approx>) s s

      \<and> abs_fset (map abs_fset r) = abs_fset (map abs_fset s)"

    then have s: "(list_all2 op \<approx> OOO op \<approx>) s s" by simp

    have d: "map abs_fset r \<approx> map abs_fset s"

      by (subst Quotient_rel[OF Quotient_fset]) (simp add: a)

    have b: "map rep_fset (map abs_fset r) \<approx> map rep_fset (map abs_fset s)"

      by (rule map_rel_cong[OF d])

    have y: "list_all2 op \<approx> (map rep_fset (map abs_fset s)) s"

      by (fact rep_abs_rsp_left[OF Quotient_fset_list, OF list_all2_refl1[of s]])

    have c: "(op \<approx> OO list_all2 op \<approx>) (map rep_fset (map abs_fset r)) s"

      by (rule pred_compI) (rule b, rule y)

    have z: "list_all2 op \<approx> r (map rep_fset (map abs_fset r))"

      by (fact rep_abs_rsp[OF Quotient_fset_list, OF list_all2_refl1[of r]])

    then show "(list_all2 op \<approx> OOO op \<approx>) r s"

      using a c pred_compI by simp

  qed

qed

text {* Respectfullness *}

lemma append_rsp[quot_respect]:

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

  apply(simp del: list_eq.simps)

  by auto 

lemma append_rsp_unfolded:

  "\<lbrakk>x \<approx> y; v \<approx> w\<rbrakk> \<Longrightarrow> x @ v \<approx> y @ w"

  by auto

lemma [quot_respect]:

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

  by (auto simp add: sub_list_def)

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

lemma map_rsp[quot_respect]:

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

  by auto

lemma set_rsp[quot_respect]:

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

  by auto

lemma list_equiv_rsp[quot_respect]:

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

  by auto

lemma not_memb_nil:

  shows "\<not> memb x []"

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

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

  by (induct xs) (auto simp add: not_memb_nil memb_cons_iff)

lemma [quot_respect]:

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

  by (simp add: memb_def[symmetric] memb_finter_raw)

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 [quot_respect]:

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

  by (simp add: memb_def[symmetric] memb_delete_raw)

lemma fminus_raw_memb: "memb x (fminus_raw xs ys) = (memb x xs \<and> \<not> memb x ys)"

  by (induct ys arbitrary: xs)

     (simp_all add: not_memb_nil memb_delete_raw memb_cons_iff)

lemma [quot_respect]:

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

  by (simp add: memb_def[symmetric] fminus_raw_memb)

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_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_rsp_aux:

  assumes a: "xs \<approx> ys"

  shows "fcard_raw xs = fcard_raw ys"

  using a

  proof (induct xs arbitrary: ys)

    case Nil

    show ?case using Nil.prems by simp

  next

    case (Cons a xs)

    have a: "a # xs \<approx> ys" by fact

    have b: "\<And>ys. xs \<approx> ys \<Longrightarrow> fcard_raw xs = fcard_raw ys" by fact

    show ?case proof (cases "a \<in> set xs")

      assume c: "a \<in> set xs"

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

      proof (intro allI iffI)

        fix x

        assume "x \<in> set xs"

        then show "x \<in> set ys" using a by auto

      next

        fix x

        assume d: "x \<in> set ys"

        have e: "(x \<in> set (a # xs)) = (x \<in> set ys)" using a by simp

        show "x \<in> set xs" using c d e unfolding list_eq.simps by simp blast

      qed

      then show ?thesis using b c by (simp add: memb_def)

    next

      assume c: "a \<notin> set xs"

      have d: "xs \<approx> [x\<leftarrow>ys . x \<noteq> a] \<Longrightarrow> fcard_raw xs = fcard_raw [x\<leftarrow>ys . x \<noteq> a]" using b by simp

      have "Suc (fcard_raw xs) = fcard_raw ys"

      proof (cases "a \<in> set ys")

        assume e: "a \<in> set ys"

        have f: "\<forall>x. (x \<in> set xs) = (x \<in> set ys \<and> x \<noteq> a)" using a c

          by (auto simp add: fcard_raw_delete_one)

        have "fcard_raw ys = Suc (fcard_raw ys - 1)" by (rule Suc_pred'[OF fcard_raw_gt_0]) (rule e)

        then show ?thesis using d e f by (simp_all add: fcard_raw_delete_one memb_def)

      next

        case False then show ?thesis using a c d by auto

      qed

      then show ?thesis using a c d by (simp add: memb_def)

  qed

qed

lemma fcard_raw_rsp[quot_respect]:

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

  by (simp add: fcard_raw_rsp_aux)

lemma memb_absorb:

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

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

lemma none_memb_nil:

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

  by (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 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_all add: not_memb_nil)

  apply (auto)

  apply (simp_all add: memb_delete_raw not_memb_delete_raw_ident rsp_fold_def  memb_cons_iff)

  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: memb_absorb memb_def none_memb_nil)

  apply (simp)

  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)[1]

  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)

lemma concat_rsp_pre:

  assumes a: "list_all2 op \<approx> x x'"

  and     b: "x' \<approx> y'"

  and     c: "list_all2 op \<approx> y' y"

  and     d: "\<exists>x\<in>set x. xa \<in> set x"

  shows "\<exists>x\<in>set y. xa \<in> set x"

proof -

  obtain xb where e: "xb \<in> set x" and f: "xa \<in> set xb" using d by auto

  have "\<exists>y. y \<in> set x' \<and> xb \<approx> y" by (rule list_all2_find_element[OF e a])

  then obtain ya where h: "ya \<in> set x'" and i: "xb \<approx> ya" by auto

  have "ya \<in> set y'" using b h by simp

  then have "\<exists>yb. yb \<in> set y \<and> ya \<approx> yb" using c by (rule list_all2_find_element)

  then show ?thesis using f i by auto

qed

lemma concat_rsp[quot_respect]:

  shows "(list_all2 op \<approx> OOO op \<approx> ===> op \<approx>) concat concat"

proof (rule fun_relI, elim pred_compE)

  fix a b ba bb

  assume a: "list_all2 op \<approx> a ba"

  assume b: "ba \<approx> bb"

  assume c: "list_all2 op \<approx> bb b"

  have "\<forall>x. (\<exists>xa\<in>set a. x \<in> set xa) = (\<exists>xa\<in>set b. x \<in> set xa)" proof

    fix x

    show "(\<exists>xa\<in>set a. x \<in> set xa) = (\<exists>xa\<in>set b. x \<in> set xa)" proof

      assume d: "\<exists>xa\<in>set a. x \<in> set xa"

      show "\<exists>xa\<in>set b. x \<in> set xa" by (rule concat_rsp_pre[OF a b c d])

    next

      assume e: "\<exists>xa\<in>set b. x \<in> set xa"

      have a': "list_all2 op \<approx> ba a" by (rule list_all2_symp[OF list_eq_equivp, OF a])

      have b': "bb \<approx> ba" by (rule equivp_symp[OF list_eq_equivp, OF b])

      have c': "list_all2 op \<approx> b bb" by (rule list_all2_symp[OF list_eq_equivp, OF c])

      show "\<exists>xa\<in>set a. x \<in> set xa" by (rule concat_rsp_pre[OF c' b' a' e])

    qed

  qed

  then show "concat a \<approx> concat b" by simp

qed

lemma concat_rsp_unfolded:

  "\<lbrakk>list_all2 op \<approx> a ba; ba \<approx> bb; list_all2 op \<approx> bb b\<rbrakk> \<Longrightarrow> concat a \<approx> concat b"

proof -

  fix a b ba bb

  assume a: "list_all2 op \<approx> a ba"

  assume b: "ba \<approx> bb"

  assume c: "list_all2 op \<approx> bb b"

  have "\<forall>x. (\<exists>xa\<in>set a. x \<in> set xa) = (\<exists>xa\<in>set b. x \<in> set xa)" proof

    fix x

    show "(\<exists>xa\<in>set a. x \<in> set xa) = (\<exists>xa\<in>set b. x \<in> set xa)" proof

      assume d: "\<exists>xa\<in>set a. x \<in> set xa"

      show "\<exists>xa\<in>set b. x \<in> set xa" by (rule concat_rsp_pre[OF a b c d])

    next

      assume e: "\<exists>xa\<in>set b. x \<in> set xa"

      have a': "list_all2 op \<approx> ba a" by (rule list_all2_symp[OF list_eq_equivp, OF a])

      have b': "bb \<approx> ba" by (rule equivp_symp[OF list_eq_equivp, OF b])

      have c': "list_all2 op \<approx> b bb" by (rule list_all2_symp[OF list_eq_equivp, OF c])

      show "\<exists>xa\<in>set a. x \<in> set xa" by (rule concat_rsp_pre[OF c' b' a' e])

    qed

  qed

  then show "concat a \<approx> concat b" by simp

qed

lemma [quot_respect]:

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

  by auto

text {* Distributive lattice with bot *}

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)

lemma sub_list_append_left:

  "sub_list x (x @ y)"

  by (simp add: sub_list_def)

lemma sub_list_append_right:

  "sub_list y (x @ y)"

  by (simp add: sub_list_def)

lemma sub_list_inter_left:

  shows "sub_list (finter_raw x y) x"

  by (simp add: sub_list_def memb_def[symmetric] memb_finter_raw)

lemma sub_list_inter_right:

  shows "sub_list (finter_raw x y) y"

  by (simp add: sub_list_def memb_def[symmetric] memb_finter_raw)

lemma sub_list_list_eq:

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

  unfolding sub_list_def list_eq.simps by blast

lemma sub_list_append:

  "sub_list y x \<Longrightarrow> sub_list z x \<Longrightarrow> sub_list (y @ z) x"

  unfolding sub_list_def by auto

lemma sub_list_inter:

  "sub_list x y \<Longrightarrow> sub_list x z \<Longrightarrow> sub_list x (finter_raw y z)"

  by (simp add: sub_list_def memb_def[symmetric] memb_finter_raw)

lemma append_inter_distrib:

  "x @ (finter_raw y z) \<approx> finter_raw (x @ y) (x @ z)"

  apply (induct x)

  apply (simp_all add: memb_def)

  apply (simp add: memb_def[symmetric] memb_finter_raw)

  apply (auto simp add: memb_def)

  done

instantiation fset :: (type) "{bounded_lattice_bot,distrib_lattice,minus}"

begin

quotient_definition

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

abbreviation

  fempty  ("{||}")