src/HOL/Sum_Type.thy
 author wenzelm Wed Sep 17 21:27:14 2008 +0200 (2008-09-17) changeset 28263 69eaa97e7e96 parent 27104 791607529f6d child 28524 644b62cf678f permissions -rw-r--r--
moved global ML bindings to global place;
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 *)
7 header{*The Disjoint Sum of Two Types*}
9 theory Sum_Type
10 imports Typedef Fun
11 begin
13 text{*The representations of the two injections*}
15 constdefs
16   Inl_Rep :: "['a, 'a, 'b, bool] => bool"
17   "Inl_Rep == (%a. %x y p. x=a & p)"
19   Inr_Rep :: "['b, 'a, 'b, bool] => bool"
20   "Inr_Rep == (%b. %x y p. y=b & ~p)"
23 global
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
30 local
33 text{*abstract constants and syntax*}
35 constdefs
36   Inl :: "'a => 'a + 'b"
37    "Inl == (%a. Abs_Sum(Inl_Rep(a)))"
39   Inr :: "'b => 'a + 'b"
40    "Inr == (%b. Abs_Sum(Inr_Rep(b)))"
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!*}
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*}
52 (** Inl_Rep and Inr_Rep: Representations of the constructors **)
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)
58 lemma Inr_RepI: "Inr_Rep(b) : Sum"
59 by (auto simp add: Sum_def)
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
66 subsection{*Freeness Properties for @{term Inl} and  @{term Inr}*}
68 text{*Distinctness*}
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)
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
81 lemmas Inr_not_Inl = Inl_not_Inr [THEN not_sym, standard]
82 declare Inr_not_Inl [iff]
84 lemmas Inl_neq_Inr = Inl_not_Inr [THEN notE, standard]
85 lemmas Inr_neq_Inl = sym [THEN Inl_neq_Inr, standard]
88 text{*Injectiveness*}
90 lemma Inl_Rep_inject: "Inl_Rep(a) = Inl_Rep(c) ==> a=c"
91 by (auto simp add: Inl_Rep_def expand_fun_eq)
93 lemma Inr_Rep_inject: "Inr_Rep(b) = Inr_Rep(d) ==> b=d"
94 by (auto simp add: Inr_Rep_def expand_fun_eq)
96 lemma inj_Inl: "inj(Inl)"
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]
105 lemma inj_Inr: "inj(Inr)"
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
113 lemmas Inr_inject = inj_Inr [THEN injD, standard]
115 lemma Inl_eq [iff]: "(Inl(x)=Inl(y)) = (x=y)"
116 by (blast dest!: Inl_inject)
118 lemma Inr_eq [iff]: "(Inr(x)=Inr(y)) = (x=y)"
119 by (blast dest!: Inr_inject)
122 subsection {* Projections *}
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"
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
138 lemma Projl_Inl[simp]: "Projl (Inl x) = x"
139   unfolding Projl_def by simp
141 lemma Projr_Inr[simp]: "Projr (Inr x) = x"
142   unfolding Projr_def by simp
145 subsection{*The Disjoint Sum of Sets*}
147 (** Introduction rules for the injections **)
149 lemma InlI [intro!]: "a : A ==> Inl(a) : A <+> B"
152 lemma InrI [intro!]: "b : B ==> Inr(b) : A <+> B"
155 (** Elimination rules **)
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)
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
175 lemma UNIV_Plus_UNIV [simp]: "UNIV <+> UNIV = UNIV"
176 apply (rule set_ext)
177 apply(rename_tac s)
178 apply(rule_tac s=s in sumE)
179 apply auto
180 done
183 subsection{*The @{term Part} Primitive*}
185 lemma Part_eqI [intro]: "[| a : A;  a=h(b) |] ==> a : Part A h"
186 by (auto simp add: Part_def)
188 lemmas PartI = Part_eqI [OF _ refl, standard]
190 lemma PartE [elim!]: "[| a : Part A h;  !!z. [| a : A;  a=h(z) |] ==> P |] ==> P"
191 by (auto simp add: Part_def)
194 lemma Part_subset: "Part A h <= A"
195 by (auto simp add: Part_def)
197 lemma Part_mono: "A<=B ==> Part A h <= Part B h"
198 by blast
200 lemmas basic_monos = basic_monos Part_mono
202 lemma PartD1: "a : Part A h ==> a : A"
205 lemma Part_id: "Part A (%x. x) = A"
206 by blast
208 lemma Part_Int: "Part (A Int B) h = (Part A h) Int (Part B h)"
209 by blast
211 lemma Part_Collect: "Part (A Int {x. P x}) h = (Part A h) Int {x. P x}"
212 by blast
215 ML
216 {*
217 val Inl_RepI = thm "Inl_RepI";
218 val Inr_RepI = thm "Inr_RepI";
219 val inj_on_Abs_Sum = thm "inj_on_Abs_Sum";
220 val Inl_Rep_not_Inr_Rep = thm "Inl_Rep_not_Inr_Rep";
221 val Inl_not_Inr = thm "Inl_not_Inr";
222 val Inr_not_Inl = thm "Inr_not_Inl";
223 val Inl_neq_Inr = thm "Inl_neq_Inr";
224 val Inr_neq_Inl = thm "Inr_neq_Inl";
225 val Inl_Rep_inject = thm "Inl_Rep_inject";
226 val Inr_Rep_inject = thm "Inr_Rep_inject";
227 val inj_Inl = thm "inj_Inl";
228 val Inl_inject = thm "Inl_inject";
229 val inj_Inr = thm "inj_Inr";
230 val Inr_inject = thm "Inr_inject";
231 val Inl_eq = thm "Inl_eq";
232 val Inr_eq = thm "Inr_eq";
233 val InlI = thm "InlI";
234 val InrI = thm "InrI";
235 val PlusE = thm "PlusE";
236 val sumE = thm "sumE";
237 val Part_eqI = thm "Part_eqI";
238 val PartI = thm "PartI";
239 val PartE = thm "PartE";
240 val Part_subset = thm "Part_subset";
241 val Part_mono = thm "Part_mono";
242 val PartD1 = thm "PartD1";
243 val Part_id = thm "Part_id";
244 val Part_Int = thm "Part_Int";
245 val Part_Collect = thm "Part_Collect";
247 val basic_monos = thms "basic_monos";
248 *}
250 end