src/HOL/HOLCF/Cpodef.thy
 author wenzelm Sun Nov 02 17:16:01 2014 +0100 (2014-11-02) changeset 58880 0baae4311a9f parent 48891 c0eafbd55de3 child 62175 8ffc4d0e652d permissions -rw-r--r--
     1 (*  Title:      HOL/HOLCF/Cpodef.thy

     2     Author:     Brian Huffman

     3 *)

     4

     5 section {* Subtypes of pcpos *}

     6

     7 theory Cpodef

     8 imports Adm

     9 keywords "pcpodef" "cpodef" :: thy_goal

    10 begin

    11

    12 subsection {* Proving a subtype is a partial order *}

    13

    14 text {*

    15   A subtype of a partial order is itself a partial order,

    16   if the ordering is defined in the standard way.

    17 *}

    18

    19 setup {* Sign.add_const_constraint (@{const_name Porder.below}, NONE) *}

    20

    21 theorem typedef_po:

    22   fixes Abs :: "'a::po \<Rightarrow> 'b::type"

    23   assumes type: "type_definition Rep Abs A"

    24     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

    25   shows "OFCLASS('b, po_class)"

    26  apply (intro_classes, unfold below)

    27    apply (rule below_refl)

    28   apply (erule (1) below_trans)

    29  apply (rule type_definition.Rep_inject [OF type, THEN iffD1])

    30  apply (erule (1) below_antisym)

    31 done

    32

    33 setup {* Sign.add_const_constraint (@{const_name Porder.below},

    34   SOME @{typ "'a::below \<Rightarrow> 'a::below \<Rightarrow> bool"}) *}

    35

    36 subsection {* Proving a subtype is finite *}

    37

    38 lemma typedef_finite_UNIV:

    39   fixes Abs :: "'a::type \<Rightarrow> 'b::type"

    40   assumes type: "type_definition Rep Abs A"

    41   shows "finite A \<Longrightarrow> finite (UNIV :: 'b set)"

    42 proof -

    43   assume "finite A"

    44   hence "finite (Abs  A)" by (rule finite_imageI)

    45   thus "finite (UNIV :: 'b set)"

    46     by (simp only: type_definition.Abs_image [OF type])

    47 qed

    48

    49 subsection {* Proving a subtype is chain-finite *}

    50

    51 lemma ch2ch_Rep:

    52   assumes below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

    53   shows "chain S \<Longrightarrow> chain (\<lambda>i. Rep (S i))"

    54 unfolding chain_def below .

    55

    56 theorem typedef_chfin:

    57   fixes Abs :: "'a::chfin \<Rightarrow> 'b::po"

    58   assumes type: "type_definition Rep Abs A"

    59     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

    60   shows "OFCLASS('b, chfin_class)"

    61  apply intro_classes

    62  apply (drule ch2ch_Rep [OF below])

    63  apply (drule chfin)

    64  apply (unfold max_in_chain_def)

    65  apply (simp add: type_definition.Rep_inject [OF type])

    66 done

    67

    68 subsection {* Proving a subtype is complete *}

    69

    70 text {*

    71   A subtype of a cpo is itself a cpo if the ordering is

    72   defined in the standard way, and the defining subset

    73   is closed with respect to limits of chains.  A set is

    74   closed if and only if membership in the set is an

    75   admissible predicate.

    76 *}

    77

    78 lemma typedef_is_lubI:

    79   assumes below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

    80   shows "range (\<lambda>i. Rep (S i)) <<| Rep x \<Longrightarrow> range S <<| x"

    81 unfolding is_lub_def is_ub_def below by simp

    82

    83 lemma Abs_inverse_lub_Rep:

    84   fixes Abs :: "'a::cpo \<Rightarrow> 'b::po"

    85   assumes type: "type_definition Rep Abs A"

    86     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

    87     and adm:  "adm (\<lambda>x. x \<in> A)"

    88   shows "chain S \<Longrightarrow> Rep (Abs (\<Squnion>i. Rep (S i))) = (\<Squnion>i. Rep (S i))"

    89  apply (rule type_definition.Abs_inverse [OF type])

    90  apply (erule admD [OF adm ch2ch_Rep [OF below]])

    91  apply (rule type_definition.Rep [OF type])

    92 done

    93

    94 theorem typedef_is_lub:

    95   fixes Abs :: "'a::cpo \<Rightarrow> 'b::po"

    96   assumes type: "type_definition Rep Abs A"

    97     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

    98     and adm: "adm (\<lambda>x. x \<in> A)"

    99   shows "chain S \<Longrightarrow> range S <<| Abs (\<Squnion>i. Rep (S i))"

   100 proof -

   101   assume S: "chain S"

   102   hence "chain (\<lambda>i. Rep (S i))" by (rule ch2ch_Rep [OF below])

   103   hence "range (\<lambda>i. Rep (S i)) <<| (\<Squnion>i. Rep (S i))" by (rule cpo_lubI)

   104   hence "range (\<lambda>i. Rep (S i)) <<| Rep (Abs (\<Squnion>i. Rep (S i)))"

   105     by (simp only: Abs_inverse_lub_Rep [OF type below adm S])

   106   thus "range S <<| Abs (\<Squnion>i. Rep (S i))"

   107     by (rule typedef_is_lubI [OF below])

   108 qed

   109

   110 lemmas typedef_lub = typedef_is_lub [THEN lub_eqI]

   111

   112 theorem typedef_cpo:

   113   fixes Abs :: "'a::cpo \<Rightarrow> 'b::po"

   114   assumes type: "type_definition Rep Abs A"

   115     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

   116     and adm: "adm (\<lambda>x. x \<in> A)"

   117   shows "OFCLASS('b, cpo_class)"

   118 proof

   119   fix S::"nat \<Rightarrow> 'b" assume "chain S"

   120   hence "range S <<| Abs (\<Squnion>i. Rep (S i))"

   121     by (rule typedef_is_lub [OF type below adm])

   122   thus "\<exists>x. range S <<| x" ..

   123 qed

   124

   125 subsubsection {* Continuity of \emph{Rep} and \emph{Abs} *}

   126

   127 text {* For any sub-cpo, the @{term Rep} function is continuous. *}

   128

   129 theorem typedef_cont_Rep:

   130   fixes Abs :: "'a::cpo \<Rightarrow> 'b::cpo"

   131   assumes type: "type_definition Rep Abs A"

   132     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

   133     and adm: "adm (\<lambda>x. x \<in> A)"

   134   shows "cont (\<lambda>x. f x) \<Longrightarrow> cont (\<lambda>x. Rep (f x))"

   135  apply (erule cont_apply [OF _ _ cont_const])

   136  apply (rule contI)

   137  apply (simp only: typedef_lub [OF type below adm])

   138  apply (simp only: Abs_inverse_lub_Rep [OF type below adm])

   139  apply (rule cpo_lubI)

   140  apply (erule ch2ch_Rep [OF below])

   141 done

   142

   143 text {*

   144   For a sub-cpo, we can make the @{term Abs} function continuous

   145   only if we restrict its domain to the defining subset by

   146   composing it with another continuous function.

   147 *}

   148

   149 theorem typedef_cont_Abs:

   150   fixes Abs :: "'a::cpo \<Rightarrow> 'b::cpo"

   151   fixes f :: "'c::cpo \<Rightarrow> 'a::cpo"

   152   assumes type: "type_definition Rep Abs A"

   153     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

   154     and adm: "adm (\<lambda>x. x \<in> A)" (* not used *)

   155     and f_in_A: "\<And>x. f x \<in> A"

   156   shows "cont f \<Longrightarrow> cont (\<lambda>x. Abs (f x))"

   157 unfolding cont_def is_lub_def is_ub_def ball_simps below

   158 by (simp add: type_definition.Abs_inverse [OF type f_in_A])

   159

   160 subsection {* Proving subtype elements are compact *}

   161

   162 theorem typedef_compact:

   163   fixes Abs :: "'a::cpo \<Rightarrow> 'b::cpo"

   164   assumes type: "type_definition Rep Abs A"

   165     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

   166     and adm: "adm (\<lambda>x. x \<in> A)"

   167   shows "compact (Rep k) \<Longrightarrow> compact k"

   168 proof (unfold compact_def)

   169   have cont_Rep: "cont Rep"

   170     by (rule typedef_cont_Rep [OF type below adm cont_id])

   171   assume "adm (\<lambda>x. Rep k \<notsqsubseteq> x)"

   172   with cont_Rep have "adm (\<lambda>x. Rep k \<notsqsubseteq> Rep x)" by (rule adm_subst)

   173   thus "adm (\<lambda>x. k \<notsqsubseteq> x)" by (unfold below)

   174 qed

   175

   176 subsection {* Proving a subtype is pointed *}

   177

   178 text {*

   179   A subtype of a cpo has a least element if and only if

   180   the defining subset has a least element.

   181 *}

   182

   183 theorem typedef_pcpo_generic:

   184   fixes Abs :: "'a::cpo \<Rightarrow> 'b::cpo"

   185   assumes type: "type_definition Rep Abs A"

   186     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

   187     and z_in_A: "z \<in> A"

   188     and z_least: "\<And>x. x \<in> A \<Longrightarrow> z \<sqsubseteq> x"

   189   shows "OFCLASS('b, pcpo_class)"

   190  apply (intro_classes)

   191  apply (rule_tac x="Abs z" in exI, rule allI)

   192  apply (unfold below)

   193  apply (subst type_definition.Abs_inverse [OF type z_in_A])

   194  apply (rule z_least [OF type_definition.Rep [OF type]])

   195 done

   196

   197 text {*

   198   As a special case, a subtype of a pcpo has a least element

   199   if the defining subset contains @{term \<bottom>}.

   200 *}

   201

   202 theorem typedef_pcpo:

   203   fixes Abs :: "'a::pcpo \<Rightarrow> 'b::cpo"

   204   assumes type: "type_definition Rep Abs A"

   205     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

   206     and bottom_in_A: "\<bottom> \<in> A"

   207   shows "OFCLASS('b, pcpo_class)"

   208 by (rule typedef_pcpo_generic [OF type below bottom_in_A], rule minimal)

   209

   210 subsubsection {* Strictness of \emph{Rep} and \emph{Abs} *}

   211

   212 text {*

   213   For a sub-pcpo where @{term \<bottom>} is a member of the defining

   214   subset, @{term Rep} and @{term Abs} are both strict.

   215 *}

   216

   217 theorem typedef_Abs_strict:

   218   assumes type: "type_definition Rep Abs A"

   219     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

   220     and bottom_in_A: "\<bottom> \<in> A"

   221   shows "Abs \<bottom> = \<bottom>"

   222  apply (rule bottomI, unfold below)

   223  apply (simp add: type_definition.Abs_inverse [OF type bottom_in_A])

   224 done

   225

   226 theorem typedef_Rep_strict:

   227   assumes type: "type_definition Rep Abs A"

   228     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

   229     and bottom_in_A: "\<bottom> \<in> A"

   230   shows "Rep \<bottom> = \<bottom>"

   231  apply (rule typedef_Abs_strict [OF type below bottom_in_A, THEN subst])

   232  apply (rule type_definition.Abs_inverse [OF type bottom_in_A])

   233 done

   234

   235 theorem typedef_Abs_bottom_iff:

   236   assumes type: "type_definition Rep Abs A"

   237     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

   238     and bottom_in_A: "\<bottom> \<in> A"

   239   shows "x \<in> A \<Longrightarrow> (Abs x = \<bottom>) = (x = \<bottom>)"

   240  apply (rule typedef_Abs_strict [OF type below bottom_in_A, THEN subst])

   241  apply (simp add: type_definition.Abs_inject [OF type] bottom_in_A)

   242 done

   243

   244 theorem typedef_Rep_bottom_iff:

   245   assumes type: "type_definition Rep Abs A"

   246     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

   247     and bottom_in_A: "\<bottom> \<in> A"

   248   shows "(Rep x = \<bottom>) = (x = \<bottom>)"

   249  apply (rule typedef_Rep_strict [OF type below bottom_in_A, THEN subst])

   250  apply (simp add: type_definition.Rep_inject [OF type])

   251 done

   252

   253 subsection {* Proving a subtype is flat *}

   254

   255 theorem typedef_flat:

   256   fixes Abs :: "'a::flat \<Rightarrow> 'b::pcpo"

   257   assumes type: "type_definition Rep Abs A"

   258     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

   259     and bottom_in_A: "\<bottom> \<in> A"

   260   shows "OFCLASS('b, flat_class)"

   261  apply (intro_classes)

   262  apply (unfold below)

   263  apply (simp add: type_definition.Rep_inject [OF type, symmetric])

   264  apply (simp add: typedef_Rep_strict [OF type below bottom_in_A])

   265  apply (simp add: ax_flat)

   266 done

   267

   268 subsection {* HOLCF type definition package *}

   269

   270 ML_file "Tools/cpodef.ML"

   271

   272 end
`