src/HOL/HOLCF/Cpodef.thy

 (*  Title:      HOL/HOLCF/Cpodef.thy
     Author:     Brian Huffman
 *)
 
-section {* Subtypes of pcpos *}
+section \<open>Subtypes of pcpos\<close>
 
 theory Cpodef
 imports Adm
 keywords "pcpodef" "cpodef" :: thy_goal
 begin
 
-subsection {* Proving a subtype is a partial order *}
-
-text {*
+subsection \<open>Proving a subtype is a partial order\<close>
+
+text \<open>
   A subtype of a partial order is itself a partial order,
   if the ordering is defined in the standard way.
-*}
-
-setup {* Sign.add_const_constraint (@{const_name Porder.below}, NONE) *}
+\<close>
+
+setup \<open>Sign.add_const_constraint (@{const_name Porder.below}, NONE)\<close>
 
 theorem typedef_po:
   fixes Abs :: "'a::po \<Rightarrow> 'b::type"
   assumes type: "type_definition Rep Abs A"
     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

   apply (erule (1) below_trans)
  apply (rule type_definition.Rep_inject [OF type, THEN iffD1])
  apply (erule (1) below_antisym)
 done
 
-setup {* Sign.add_const_constraint (@{const_name Porder.below},
-  SOME @{typ "'a::below \<Rightarrow> 'a::below \<Rightarrow> bool"}) *}
-
-subsection {* Proving a subtype is finite *}
+setup \<open>Sign.add_const_constraint (@{const_name Porder.below},
+  SOME @{typ "'a::below \<Rightarrow> 'a::below \<Rightarrow> bool"})\<close>
+
+subsection \<open>Proving a subtype is finite\<close>
 
 lemma typedef_finite_UNIV:
   fixes Abs :: "'a::type \<Rightarrow> 'b::type"
   assumes type: "type_definition Rep Abs A"
   shows "finite A \<Longrightarrow> finite (UNIV :: 'b set)"

   hence "finite (Abs ` A)" by (rule finite_imageI)
   thus "finite (UNIV :: 'b set)"
     by (simp only: type_definition.Abs_image [OF type])
 qed
 
-subsection {* Proving a subtype is chain-finite *}
+subsection \<open>Proving a subtype is chain-finite\<close>
 
 lemma ch2ch_Rep:
   assumes below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"
   shows "chain S \<Longrightarrow> chain (\<lambda>i. Rep (S i))"
 unfolding chain_def below .

  apply (drule chfin)
  apply (unfold max_in_chain_def)
  apply (simp add: type_definition.Rep_inject [OF type])
 done
 
-subsection {* Proving a subtype is complete *}
-
-text {*
+subsection \<open>Proving a subtype is complete\<close>
+
+text \<open>
   A subtype of a cpo is itself a cpo if the ordering is
   defined in the standard way, and the defining subset
   is closed with respect to limits of chains.  A set is
   closed if and only if membership in the set is an
   admissible predicate.
-*}
+\<close>
 
 lemma typedef_is_lubI:
   assumes below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"
   shows "range (\<lambda>i. Rep (S i)) <<| Rep x \<Longrightarrow> range S <<| x"
 unfolding is_lub_def is_ub_def below by simp

   hence "range S <<| Abs (\<Squnion>i. Rep (S i))"
     by (rule typedef_is_lub [OF type below adm])
   thus "\<exists>x. range S <<| x" ..
 qed
 
-subsubsection {* Continuity of \emph{Rep} and \emph{Abs} *}
-
-text {* For any sub-cpo, the @{term Rep} function is continuous. *}
+subsubsection \<open>Continuity of \emph{Rep} and \emph{Abs}\<close>
+
+text \<open>For any sub-cpo, the @{term Rep} function is continuous.\<close>
 
 theorem typedef_cont_Rep:
   fixes Abs :: "'a::cpo \<Rightarrow> 'b::cpo"
   assumes type: "type_definition Rep Abs A"
     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

  apply (simp only: Abs_inverse_lub_Rep [OF type below adm])
  apply (rule cpo_lubI)
  apply (erule ch2ch_Rep [OF below])
 done
 
-text {*
+text \<open>
   For a sub-cpo, we can make the @{term Abs} function continuous
   only if we restrict its domain to the defining subset by
   composing it with another continuous function.
-*}
+\<close>
 
 theorem typedef_cont_Abs:
   fixes Abs :: "'a::cpo \<Rightarrow> 'b::cpo"
   fixes f :: "'c::cpo \<Rightarrow> 'a::cpo"
   assumes type: "type_definition Rep Abs A"

     and f_in_A: "\<And>x. f x \<in> A"
   shows "cont f \<Longrightarrow> cont (\<lambda>x. Abs (f x))"
 unfolding cont_def is_lub_def is_ub_def ball_simps below
 by (simp add: type_definition.Abs_inverse [OF type f_in_A])
 
-subsection {* Proving subtype elements are compact *}
+subsection \<open>Proving subtype elements are compact\<close>
 
 theorem typedef_compact:
   fixes Abs :: "'a::cpo \<Rightarrow> 'b::cpo"
   assumes type: "type_definition Rep Abs A"
     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

   assume "adm (\<lambda>x. Rep k \<notsqsubseteq> x)"
   with cont_Rep have "adm (\<lambda>x. Rep k \<notsqsubseteq> Rep x)" by (rule adm_subst)
   thus "adm (\<lambda>x. k \<notsqsubseteq> x)" by (unfold below)
 qed
 
-subsection {* Proving a subtype is pointed *}
-
-text {*
+subsection \<open>Proving a subtype is pointed\<close>
+
+text \<open>
   A subtype of a cpo has a least element if and only if
   the defining subset has a least element.
-*}
+\<close>
 
 theorem typedef_pcpo_generic:
   fixes Abs :: "'a::cpo \<Rightarrow> 'b::cpo"
   assumes type: "type_definition Rep Abs A"
     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

  apply (unfold below)
  apply (subst type_definition.Abs_inverse [OF type z_in_A])
  apply (rule z_least [OF type_definition.Rep [OF type]])
 done
 
-text {*
+text \<open>
   As a special case, a subtype of a pcpo has a least element
   if the defining subset contains @{term \<bottom>}.
-*}
+\<close>
 
 theorem typedef_pcpo:
   fixes Abs :: "'a::pcpo \<Rightarrow> 'b::cpo"
   assumes type: "type_definition Rep Abs A"
     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"
     and bottom_in_A: "\<bottom> \<in> A"
   shows "OFCLASS('b, pcpo_class)"
 by (rule typedef_pcpo_generic [OF type below bottom_in_A], rule minimal)
 
-subsubsection {* Strictness of \emph{Rep} and \emph{Abs} *}
-
-text {*
+subsubsection \<open>Strictness of \emph{Rep} and \emph{Abs}\<close>
+
+text \<open>
   For a sub-pcpo where @{term \<bottom>} is a member of the defining
   subset, @{term Rep} and @{term Abs} are both strict.
-*}
+\<close>
 
 theorem typedef_Abs_strict:
   assumes type: "type_definition Rep Abs A"
     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"
     and bottom_in_A: "\<bottom> \<in> A"

   shows "(Rep x = \<bottom>) = (x = \<bottom>)"
  apply (rule typedef_Rep_strict [OF type below bottom_in_A, THEN subst])
  apply (simp add: type_definition.Rep_inject [OF type])
 done
 
-subsection {* Proving a subtype is flat *}
+subsection \<open>Proving a subtype is flat\<close>
 
 theorem typedef_flat:
   fixes Abs :: "'a::flat \<Rightarrow> 'b::pcpo"
   assumes type: "type_definition Rep Abs A"
     and below: "op \<sqsubseteq> \<equiv> \<lambda>x y. Rep x \<sqsubseteq> Rep y"

  apply (simp add: type_definition.Rep_inject [OF type, symmetric])
  apply (simp add: typedef_Rep_strict [OF type below bottom_in_A])
  apply (simp add: ax_flat)
 done
 
-subsection {* HOLCF type definition package *}
+subsection \<open>HOLCF type definition package\<close>
 
 ML_file "Tools/cpodef.ML"
 
 end