152 

   153 text {* raw section *}

   154 

   155 lemma map_rsp_aux:

   156   assumes a: "a \<approx> b"

   157   shows "map f a \<approx> map f b"

   158   using a

   159 apply(induct a arbitrary: b)

   160 apply(auto)

   161 apply(metis rev_image_eqI)

   162 done

   163 

   164 lemma map_rsp[quot_respect]:

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

   166 by (auto simp add: map_rsp_aux)

   167 

   168 

   169 text {* lifted section *}

   270 lemma no_mem_nil: 

   271   "(\<forall>a. a \<notin> set A) = (A = [])"

   272 by (induct A) (auto)

   273 

   274 lemma none_mem_nil: 

   275   "(\<forall>a. a \<notin> set A) = (A \<approx> [])"

   276 by simp

   277 

   278 lemma mem_cons: 

   279   "a \<in> set A \<Longrightarrow> a # A \<approx> A"

   280 by auto

   281 

   282 lemma cons_left_comm:

   283   "x # y # A \<approx> y # x # A"

   284 by (auto simp add: id_simps)

   285 

   286 lemma cons_left_idem:

   287   "x # x # A \<approx> x # A"

   288 by (auto simp add: id_simps)

   289 

   290 lemma finite_set_raw_strong_cases:

   291   "(X = []) \<or> (\<exists>a Y. ((a \<notin> set Y) \<and> (X \<approx> a # Y)))"

   292   apply (induct X)

   293   apply (simp)

   294   apply (rule disjI2)

   295   apply (erule disjE)

   296   apply (rule_tac x="a" in exI)

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

   298   apply (simp)

   299   apply (erule exE)+

   300   apply (case_tac "a = aa")

   301   apply (rule_tac x="a" in exI)

   302   apply (rule_tac x="Y" in exI)

   303   apply (simp)

   304   apply (rule_tac x="aa" in exI)

   305   apply (rule_tac x="a # Y" in exI)

   306   apply (auto)

   307   done

   308 

   309 fun

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

   311 where

   312   "delete_raw [] x = []"

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

   314 

   315 lemma mem_delete_raw:

   316   "x \<in> set (delete_raw A a) = (x \<in> set A \<and> \<not>(x = a))"

   317   by (induct A arbitrary: x a) (auto)

   318 

   319 lemma mem_delete_raw_ident:

   320   "\<not>(a \<in> set (delete_raw A a))"

   321 by (induct A) (auto)

   322 

   323 lemma not_mem_delete_raw_ident:

   324   "b \<notin> set A \<Longrightarrow> (delete_raw A b = A)"

   325 by (induct A) (auto)

   326 

   327 lemma delete_raw_RSP:

   328   "A \<approx> B \<Longrightarrow> delete_raw A a \<approx> delete_raw B a"

   329 apply(induct A arbitrary: B a)

   330 apply(auto)

   331 sorry

   332 

   333 lemma cons_delete_raw:

   334   "a # (delete_raw A a) \<approx> (if a \<in> set A then A else (a # A))"

   335 sorry

   336 

   337 lemma mem_cons_delete_raw:

   338     "a \<in> set A \<Longrightarrow> a # (delete_raw A a) \<approx> A"

   339 sorry

   340 

   341 lemma finite_set_raw_delete_raw_cases:

   342     "X = [] \<or> (\<exists>a. a mem X \<and> X \<approx> a # delete_raw X a)"

   343   by (induct X) (auto)

   344 

   345 

   346 

   347 

   348 

   349 lemma list2set_thm:

   350   shows "set [] = {}"

   351   and "set (h # t) = insert h (set t)"

   352   by (auto)

   353 

   354 lemma list2set_RSP:

   355   "A \<approx> B \<Longrightarrow> set A = set B"

   356   by auto

   357 

   358 definition

   359   rsp_fold

   360 where

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

   362 

   363 primrec

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

   365 where

   366   "fold_raw f z [] = z"

   367 | "fold_raw f z (a # A) =

   368      (if (rsp_fold f) then

   369        if a mem A then fold_raw f z A

   370        else f a (fold_raw f z A)

   371      else z)"

   372 

   373 lemma mem_lcommuting_fold_raw:

   374   "rsp_fold f \<Longrightarrow> h mem B \<Longrightarrow> fold_raw f z B = f h (fold_raw f z (delete_raw B h))"

   375 sorry

   376 

   377 lemma fold_rsp[quot_respect]:

   378   "(op = ===> op = ===> op \<approx> ===> op =) fold_raw fold_raw"

   379 apply(auto)

   380 sorry

   381 

   382 primrec

   383   inter_raw

   384 where

   385   "inter_raw [] B = []"

   386 | "inter_raw (a # A) B = (if a mem B then a # inter_raw A B else inter_raw A B)"

   387 

   388 lemma mem_inter_raw:

   389   "x mem (inter_raw A B) = x mem A \<and> x mem B"

   390 sorry

   391 

   392 lemma inter_raw_RSP:

   393   "A1 \<approx> A2 \<and> B1 \<approx> B2 \<Longrightarrow> (inter_raw A1 B1) \<approx> (inter_raw A2 B2)"

   394 sorry

   395 

   396 

   397 (* LIFTING DEFS *)

   398 

   399 

   400 section {* Constants on the Quotient Type *} 

   401 

   402 

   403 quotient_definition

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

   405   is "delete_raw"

   406 

   407 quotient_definition

   408   finter ("_ \<inter>f _" [70, 71] 70)

   409 where

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

   411   is "inter_raw"

   412 

   413 quotient_definition

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

   415   is "fold_raw"

   416 

   417 quotient_definition

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

   419   is "set"

   420 

   421 

   422 section {* Lifted Theorems *}

   423 

   424 thm list.cases (* ??? *)

   425 

   426 thm cons_left_comm

   427 lemma "finsert a (finsert b S) = finsert b (finsert a S)"

   428 by (lifting cons_left_comm)

   429 

   430 thm cons_left_idem

   431 lemma "finsert a (finsert a S) = finsert a S"

   432 by (lifting cons_left_idem)

   433 

   434 (* thm MEM:

   435   MEM x [] = F

   436   MEM x (h::t) = (x=h) \/ MEM x t *)

   437 thm none_mem_nil

   438 (*lemma "(\<forall>a. a \<notin>f A) = (A = fempty)"*)

   439 

   440 thm mem_cons

   441 thm finite_set_raw_strong_cases

   442 (*thm card_raw.simps*)

   443 (*thm not_mem_card_raw*)

   444 (*thm card_raw_suc*)

   445 

   446 lemma "fcard X = Suc n \<Longrightarrow> (\<exists>a S. a \<notin>f S & X = finsert a S)"

   447 (*by (lifting card_raw_suc)*)

   448 sorry

   449 

   450 (*thm card_raw_cons_gt_0

   451 thm mem_card_raw_gt_0

   452 thm not_nil_equiv_cons

   453 *)

   454 thm delete_raw.simps

   455 (*thm mem_delete_raw*)

   456 (*thm card_raw_delete_raw*)

   457 thm cons_delete_raw

   458 thm mem_cons_delete_raw

   459 thm finite_set_raw_delete_raw_cases

   460 thm append.simps

   461 (* MEM_APPEND: MEM e (APPEND l1 l2) = MEM e l1 \/ MEM e l2 *)

   462 thm inter_raw.simps

   463 thm mem_inter_raw

   464 thm fold_raw.simps

   465 thm list2set_thm

   466 thm list_eq_def

   467 thm list.induct

   468 lemma "\<lbrakk>P fempty; \<And>a x. P x \<Longrightarrow> P (finsert a x)\<rbrakk> \<Longrightarrow> P l"

   469 by (lifting list.induct)

   470 

   471 (* We also have map and some properties of it in FSet *)

   472 (* and the following which still lifts ok *)

   473 lemma "funion (funion x xa) xb = funion x (funion xa xb)"

   474 by (lifting append_assoc)

   475