src/HOL/Sum_Type.thy
author haftmann
Sun May 06 21:49:23 2007 +0200 (2007-05-06)
changeset 22838 466599ecf610
parent 22622 25693088396b
child 25534 d0b74fdd6067
permissions -rw-r--r--
tuned
     1 (*  Title:      HOL/Sum_Type.thy
     2     ID:         $Id$
     3     Author:     Lawrence C Paulson, Cambridge University Computer Laboratory
     4     Copyright   1992  University of Cambridge
     5 *)
     6 
     7 header{*The Disjoint Sum of Two Types*}
     8 
     9 theory Sum_Type
    10 imports Typedef Fun
    11 begin
    12 
    13 text{*The representations of the two injections*}
    14 
    15 constdefs
    16   Inl_Rep :: "['a, 'a, 'b, bool] => bool"
    17   "Inl_Rep == (%a. %x y p. x=a & p)"
    18 
    19   Inr_Rep :: "['b, 'a, 'b, bool] => bool"
    20   "Inr_Rep == (%b. %x y p. y=b & ~p)"
    21 
    22 
    23 global
    24 
    25 typedef (Sum)
    26   ('a, 'b) "+"          (infixr "+" 10)
    27     = "{f. (? a. f = Inl_Rep(a::'a)) | (? b. f = Inr_Rep(b::'b))}"
    28   by auto
    29 
    30 local
    31 
    32 
    33 text{*abstract constants and syntax*}
    34 
    35 constdefs
    36   Inl :: "'a => 'a + 'b"
    37    "Inl == (%a. Abs_Sum(Inl_Rep(a)))"
    38 
    39   Inr :: "'b => 'a + 'b"
    40    "Inr == (%b. Abs_Sum(Inr_Rep(b)))"
    41 
    42   Plus :: "['a set, 'b set] => ('a + 'b) set"        (infixr "<+>" 65)
    43    "A <+> B == (Inl`A) Un (Inr`B)"
    44     --{*disjoint sum for sets; the operator + is overloaded with wrong type!*}
    45 
    46   Part :: "['a set, 'b => 'a] => 'a set"
    47    "Part A h == A Int {x. ? z. x = h(z)}"
    48     --{*for selecting out the components of a mutually recursive definition*}
    49 
    50 
    51 
    52 (** Inl_Rep and Inr_Rep: Representations of the constructors **)
    53 
    54 (*This counts as a non-emptiness result for admitting 'a+'b as a type*)
    55 lemma Inl_RepI: "Inl_Rep(a) : Sum"
    56 by (auto simp add: Sum_def)
    57 
    58 lemma Inr_RepI: "Inr_Rep(b) : Sum"
    59 by (auto simp add: Sum_def)
    60 
    61 lemma inj_on_Abs_Sum: "inj_on Abs_Sum Sum"
    62 apply (rule inj_on_inverseI)
    63 apply (erule Abs_Sum_inverse)
    64 done
    65 
    66 subsection{*Freeness Properties for @{term Inl} and  @{term Inr}*}
    67 
    68 text{*Distinctness*}
    69 
    70 lemma Inl_Rep_not_Inr_Rep: "Inl_Rep(a) ~= Inr_Rep(b)"
    71 by (auto simp add: Inl_Rep_def Inr_Rep_def expand_fun_eq)
    72 
    73 lemma Inl_not_Inr [iff]: "Inl(a) ~= Inr(b)"
    74 apply (simp add: Inl_def Inr_def)
    75 apply (rule inj_on_Abs_Sum [THEN inj_on_contraD])
    76 apply (rule Inl_Rep_not_Inr_Rep)
    77 apply (rule Inl_RepI)
    78 apply (rule Inr_RepI)
    79 done
    80 
    81 lemmas Inr_not_Inl = Inl_not_Inr [THEN not_sym, standard]
    82 declare Inr_not_Inl [iff]
    83 
    84 lemmas Inl_neq_Inr = Inl_not_Inr [THEN notE, standard]
    85 lemmas Inr_neq_Inl = sym [THEN Inl_neq_Inr, standard]
    86 
    87 
    88 text{*Injectiveness*}
    89 
    90 lemma Inl_Rep_inject: "Inl_Rep(a) = Inl_Rep(c) ==> a=c"
    91 by (auto simp add: Inl_Rep_def expand_fun_eq)
    92 
    93 lemma Inr_Rep_inject: "Inr_Rep(b) = Inr_Rep(d) ==> b=d"
    94 by (auto simp add: Inr_Rep_def expand_fun_eq)
    95 
    96 lemma inj_Inl: "inj(Inl)"
    97 apply (simp add: Inl_def)
    98 apply (rule inj_onI)
    99 apply (erule inj_on_Abs_Sum [THEN inj_onD, THEN Inl_Rep_inject])
   100 apply (rule Inl_RepI)
   101 apply (rule Inl_RepI)
   102 done
   103 lemmas Inl_inject = inj_Inl [THEN injD, standard]
   104 
   105 lemma inj_Inr: "inj(Inr)"
   106 apply (simp add: Inr_def)
   107 apply (rule inj_onI)
   108 apply (erule inj_on_Abs_Sum [THEN inj_onD, THEN Inr_Rep_inject])
   109 apply (rule Inr_RepI)
   110 apply (rule Inr_RepI)
   111 done
   112 
   113 lemmas Inr_inject = inj_Inr [THEN injD, standard]
   114 
   115 lemma Inl_eq [iff]: "(Inl(x)=Inl(y)) = (x=y)"
   116 by (blast dest!: Inl_inject)
   117 
   118 lemma Inr_eq [iff]: "(Inr(x)=Inr(y)) = (x=y)"
   119 by (blast dest!: Inr_inject)
   120 
   121 
   122 subsection {* Projections *}
   123 
   124 definition 
   125   "sum_case f g x =
   126   (if (\<exists>!y. x = Inl y) 
   127   then f (THE y. x = Inl y) 
   128   else g (THE y. x = Inr y))"
   129 definition "Projl x = sum_case id arbitrary x"
   130 definition "Projr x = sum_case arbitrary id x"
   131 
   132 lemma sum_cases[simp]: 
   133   "sum_case f g (Inl x) = f x"
   134   "sum_case f g (Inr y) = g y"
   135   unfolding sum_case_def
   136   by auto
   137 
   138 lemma Projl_Inl[simp]: "Projl (Inl x) = x"
   139   unfolding Projl_def by simp
   140 
   141 lemma Projr_Inr[simp]: "Projr (Inr x) = x"
   142   unfolding Projr_def by simp
   143 
   144 
   145 subsection{*The Disjoint Sum of Sets*}
   146 
   147 (** Introduction rules for the injections **)
   148 
   149 lemma InlI [intro!]: "a : A ==> Inl(a) : A <+> B"
   150 by (simp add: Plus_def)
   151 
   152 lemma InrI [intro!]: "b : B ==> Inr(b) : A <+> B"
   153 by (simp add: Plus_def)
   154 
   155 (** Elimination rules **)
   156 
   157 lemma PlusE [elim!]: 
   158     "[| u: A <+> B;   
   159         !!x. [| x:A;  u=Inl(x) |] ==> P;  
   160         !!y. [| y:B;  u=Inr(y) |] ==> P  
   161      |] ==> P"
   162 by (auto simp add: Plus_def)
   163 
   164 
   165 
   166 text{*Exhaustion rule for sums, a degenerate form of induction*}
   167 lemma sumE: 
   168     "[| !!x::'a. s = Inl(x) ==> P;  !!y::'b. s = Inr(y) ==> P  
   169      |] ==> P"
   170 apply (rule Abs_Sum_cases [of s]) 
   171 apply (auto simp add: Sum_def Inl_def Inr_def)
   172 done
   173 
   174 lemma sum_induct: "[| !!x. P (Inl x); !!x. P (Inr x) |] ==> P x"
   175 by (rule sumE [of x], auto)
   176 
   177 
   178 lemma UNIV_Plus_UNIV [simp]: "UNIV <+> UNIV = UNIV"
   179 apply (rule set_ext)
   180 apply(rename_tac s)
   181 apply(rule_tac s=s in sumE)
   182 apply auto
   183 done
   184 
   185 
   186 subsection{*The @{term Part} Primitive*}
   187 
   188 lemma Part_eqI [intro]: "[| a : A;  a=h(b) |] ==> a : Part A h"
   189 by (auto simp add: Part_def)
   190 
   191 lemmas PartI = Part_eqI [OF _ refl, standard]
   192 
   193 lemma PartE [elim!]: "[| a : Part A h;  !!z. [| a : A;  a=h(z) |] ==> P |] ==> P"
   194 by (auto simp add: Part_def)
   195 
   196 
   197 lemma Part_subset: "Part A h <= A"
   198 by (auto simp add: Part_def)
   199 
   200 lemma Part_mono: "A<=B ==> Part A h <= Part B h"
   201 by blast
   202 
   203 lemmas basic_monos = basic_monos Part_mono
   204 
   205 lemma PartD1: "a : Part A h ==> a : A"
   206 by (simp add: Part_def)
   207 
   208 lemma Part_id: "Part A (%x. x) = A"
   209 by blast
   210 
   211 lemma Part_Int: "Part (A Int B) h = (Part A h) Int (Part B h)"
   212 by blast
   213 
   214 lemma Part_Collect: "Part (A Int {x. P x}) h = (Part A h) Int {x. P x}"
   215 by blast
   216 
   217 
   218 subsection {* Code generator setup *}
   219 
   220 instance "+" :: (eq, eq) eq ..
   221 
   222 lemma [code func]:
   223   "(Inl x \<Colon> 'a\<Colon>eq + 'b\<Colon>eq) = Inl y \<longleftrightarrow> x = y"
   224   unfolding Inl_eq ..
   225 
   226 lemma [code func]:
   227   "(Inr x \<Colon> 'a\<Colon>eq + 'b\<Colon>eq) = Inr y \<longleftrightarrow> x = y"
   228   unfolding Inr_eq ..
   229 
   230 lemma [code func]:
   231   "Inl (x\<Colon>'a\<Colon>eq) = Inr (y\<Colon>'b\<Colon>eq) \<longleftrightarrow> False"
   232   using Inl_not_Inr by auto
   233 
   234 lemma [code func]:
   235   "Inr (x\<Colon>'b\<Colon>eq) = Inl (y\<Colon>'a\<Colon>eq) \<longleftrightarrow> False"
   236   using Inr_not_Inl by auto
   237 
   238 ML
   239 {*
   240 val Inl_RepI = thm "Inl_RepI";
   241 val Inr_RepI = thm "Inr_RepI";
   242 val inj_on_Abs_Sum = thm "inj_on_Abs_Sum";
   243 val Inl_Rep_not_Inr_Rep = thm "Inl_Rep_not_Inr_Rep";
   244 val Inl_not_Inr = thm "Inl_not_Inr";
   245 val Inr_not_Inl = thm "Inr_not_Inl";
   246 val Inl_neq_Inr = thm "Inl_neq_Inr";
   247 val Inr_neq_Inl = thm "Inr_neq_Inl";
   248 val Inl_Rep_inject = thm "Inl_Rep_inject";
   249 val Inr_Rep_inject = thm "Inr_Rep_inject";
   250 val inj_Inl = thm "inj_Inl";
   251 val Inl_inject = thm "Inl_inject";
   252 val inj_Inr = thm "inj_Inr";
   253 val Inr_inject = thm "Inr_inject";
   254 val Inl_eq = thm "Inl_eq";
   255 val Inr_eq = thm "Inr_eq";
   256 val InlI = thm "InlI";
   257 val InrI = thm "InrI";
   258 val PlusE = thm "PlusE";
   259 val sumE = thm "sumE";
   260 val sum_induct = thm "sum_induct";
   261 val Part_eqI = thm "Part_eqI";
   262 val PartI = thm "PartI";
   263 val PartE = thm "PartE";
   264 val Part_subset = thm "Part_subset";
   265 val Part_mono = thm "Part_mono";
   266 val PartD1 = thm "PartD1";
   267 val Part_id = thm "Part_id";
   268 val Part_Int = thm "Part_Int";
   269 val Part_Collect = thm "Part_Collect";
   270 
   271 val basic_monos = thms "basic_monos";
   272 *}
   273 
   274 end