src/HOL/MicroJava/J/TypeRel.thy
author bulwahn
Fri Oct 21 11:17:14 2011 +0200 (2011-10-21)
changeset 45231 d85a2fdc586c
parent 44035 322d1657c40c
child 45970 b6d0cff57d96
permissions -rw-r--r--
replacing code_inline by code_unfold, removing obsolete code_unfold, code_inline del now that the ancient code generator is removed
     1 (*  Title:      HOL/MicroJava/J/TypeRel.thy
     2     Author:     David von Oheimb, Technische Universitaet Muenchen
     3 *)
     4 
     5 header {* \isaheader{Relations between Java Types} *}
     6 
     7 theory TypeRel imports Decl "~~/src/HOL/Library/Wfrec" begin
     8 
     9 -- "direct subclass, cf. 8.1.3"
    10 
    11 inductive_set
    12   subcls1 :: "'c prog => (cname \<times> cname) set"
    13   and subcls1' :: "'c prog => cname \<Rightarrow> cname => bool" ("_ \<turnstile> _ \<prec>C1 _" [71,71,71] 70)
    14   for G :: "'c prog"
    15 where
    16   "G \<turnstile> C \<prec>C1 D \<equiv> (C, D) \<in> subcls1 G"
    17   | subcls1I: "\<lbrakk>class G C = Some (D,rest); C \<noteq> Object\<rbrakk> \<Longrightarrow> G \<turnstile> C \<prec>C1 D"
    18 
    19 abbreviation
    20   subcls  :: "'c prog => cname \<Rightarrow> cname => bool" ("_ \<turnstile> _ \<preceq>C _"  [71,71,71] 70)
    21   where "G \<turnstile> C \<preceq>C D \<equiv> (C, D) \<in> (subcls1 G)^*"
    22 
    23 lemma subcls1D: 
    24   "G\<turnstile>C\<prec>C1D \<Longrightarrow> C \<noteq> Object \<and> (\<exists>fs ms. class G C = Some (D,fs,ms))"
    25 apply (erule subcls1.cases)
    26 apply auto
    27 done
    28 
    29 lemma subcls1_def2:
    30   "subcls1 P =
    31      (SIGMA C:{C. is_class P C}. {D. C\<noteq>Object \<and> fst (the (class P C))=D})"
    32   by (auto simp add: is_class_def dest: subcls1D intro: subcls1I)
    33 
    34 lemma finite_subcls1: "finite (subcls1 G)"
    35 apply(simp add: subcls1_def2 del: mem_Sigma_iff)
    36 apply(rule finite_SigmaI [OF finite_is_class])
    37 apply(rule_tac B = "{fst (the (class G C))}" in finite_subset)
    38 apply  auto
    39 done
    40 
    41 lemma subcls_is_class: "(C, D) \<in> (subcls1 G)^+  ==> is_class G C"
    42 apply (unfold is_class_def)
    43 apply(erule trancl_trans_induct)
    44 apply (auto dest!: subcls1D)
    45 done
    46 
    47 lemma subcls_is_class2 [rule_format (no_asm)]: 
    48   "G\<turnstile>C\<preceq>C D \<Longrightarrow> is_class G D \<longrightarrow> is_class G C"
    49 apply (unfold is_class_def)
    50 apply (erule rtrancl_induct)
    51 apply  (drule_tac [2] subcls1D)
    52 apply  auto
    53 done
    54 
    55 definition class_rec :: "'c prog \<Rightarrow> cname \<Rightarrow> 'a \<Rightarrow>
    56     (cname \<Rightarrow> fdecl list \<Rightarrow> 'c mdecl list \<Rightarrow> 'a \<Rightarrow> 'a) \<Rightarrow> 'a" where
    57   "class_rec G == wfrec ((subcls1 G)^-1)
    58     (\<lambda>r C t f. case class G C of
    59          None \<Rightarrow> undefined
    60        | Some (D,fs,ms) \<Rightarrow> 
    61            f C fs ms (if C = Object then t else r D t f))"
    62 
    63 lemma class_rec_lemma:
    64   assumes wf: "wf ((subcls1 G)^-1)"
    65     and cls: "class G C = Some (D, fs, ms)"
    66   shows "class_rec G C t f = f C fs ms (if C=Object then t else class_rec G D t f)"
    67 proof -
    68   from wf have step: "\<And>H a. wfrec ((subcls1 G)\<inverse>) H a =
    69     H (cut (wfrec ((subcls1 G)\<inverse>) H) ((subcls1 G)\<inverse>) a) a"
    70     by (rule wfrec)
    71   have cut: "\<And>f. C \<noteq> Object \<Longrightarrow> cut f ((subcls1 G)\<inverse>) C D = f D"
    72     by (rule cut_apply [where r="(subcls1 G)^-1", simplified, OF subcls1I, OF cls])
    73   from cls show ?thesis by (simp add: step cut class_rec_def)
    74 qed
    75 
    76 definition
    77   "wf_class G = wf ((subcls1 G)^-1)"
    78 
    79 
    80 
    81 text {* Code generator setup *}
    82 
    83 code_pred 
    84   (modes: i \<Rightarrow> i \<Rightarrow> o \<Rightarrow> bool, i \<Rightarrow> i \<Rightarrow> i \<Rightarrow> bool)
    85   subcls1p 
    86   .
    87 declare subcls1_def[unfolded Collect_def, code_pred_def]
    88 code_pred 
    89   (modes: i \<Rightarrow> i \<times> o \<Rightarrow> bool, i \<Rightarrow> i \<times> i \<Rightarrow> bool)
    90   [inductify]
    91   subcls1 
    92   .
    93 
    94 definition subcls' where "subcls' G = (subcls1p G)^**"
    95 code_pred
    96   (modes: i \<Rightarrow> i \<Rightarrow> i \<Rightarrow> bool, i \<Rightarrow> i \<Rightarrow> o \<Rightarrow> bool)
    97   [inductify]
    98   subcls'
    99 .
   100 lemma subcls_conv_subcls' [code_unfold]:
   101   "(subcls1 G)^* = (\<lambda>(C, D). subcls' G C D)"
   102 by(simp add: subcls'_def subcls1_def rtrancl_def)(simp add: Collect_def)
   103 
   104 lemma class_rec_code [code]:
   105   "class_rec G C t f = 
   106   (if wf_class G then 
   107     (case class G C of
   108        None \<Rightarrow> class_rec G C t f
   109      | Some (D, fs, ms) \<Rightarrow> 
   110        if C = Object then f Object fs ms t else f C fs ms (class_rec G D t f))
   111    else class_rec G C t f)"
   112 apply(cases "wf_class G")
   113  apply(unfold class_rec_def wf_class_def)
   114  apply(subst wfrec, assumption)
   115  apply(cases "class G C")
   116   apply(simp add: wfrec)
   117  apply clarsimp
   118  apply(rename_tac D fs ms)
   119  apply(rule_tac f="f C fs ms" in arg_cong)
   120  apply(clarsimp simp add: cut_def)
   121  apply(blast intro: subcls1I)
   122 apply simp
   123 done
   124 
   125 lemma wf_class_code [code]:
   126   "wf_class G \<longleftrightarrow> (\<forall>(C, rest) \<in> set G. C \<noteq> Object \<longrightarrow> \<not> G \<turnstile> fst (the (class G C)) \<preceq>C C)"
   127 proof
   128   assume "wf_class G"
   129   hence wf: "wf (((subcls1 G)^+)^-1)" unfolding wf_class_def by(rule wf_converse_trancl)
   130   hence acyc: "acyclic ((subcls1 G)^+)" by(auto dest: wf_acyclic)
   131   show "\<forall>(C, rest) \<in> set G. C \<noteq> Object \<longrightarrow> \<not> G \<turnstile> fst (the (class G C)) \<preceq>C C"
   132   proof(safe)
   133     fix C D fs ms
   134     assume "(C, D, fs, ms) \<in> set G"
   135       and "C \<noteq> Object"
   136       and subcls: "G \<turnstile> fst (the (class G C)) \<preceq>C C"
   137     from `(C, D, fs, ms) \<in> set G` obtain D' fs' ms'
   138       where "class": "class G C = Some (D', fs', ms')"
   139       unfolding class_def by(auto dest!: weak_map_of_SomeI)
   140     hence "G \<turnstile> C \<prec>C1 D'" using `C \<noteq> Object` ..
   141     hence "(C, D') \<in> (subcls1 G)^+" ..
   142     also with acyc have "C \<noteq> D'" by(auto simp add: acyclic_def)
   143     with subcls "class" have "(D', C) \<in> (subcls1 G)^+" by(auto dest: rtranclD)
   144     finally show False using acyc by(auto simp add: acyclic_def)
   145   qed
   146 next
   147   assume rhs[rule_format]: "\<forall>(C, rest) \<in> set G. C \<noteq> Object \<longrightarrow> \<not> G \<turnstile> fst (the (class G C)) \<preceq>C C"
   148   have "acyclic (subcls1 G)"
   149   proof(intro acyclicI strip notI)
   150     fix C
   151     assume "(C, C) \<in> (subcls1 G)\<^sup>+"
   152     thus False
   153     proof(cases)
   154       case base
   155       then obtain rest where "class G C = Some (C, rest)"
   156         and "C \<noteq> Object" by cases
   157       from `class G C = Some (C, rest)` have "(C, C, rest) \<in> set G"
   158         unfolding class_def by(rule map_of_SomeD)
   159       with `C \<noteq> Object` `class G C = Some (C, rest)`
   160       have "\<not> G \<turnstile> C \<preceq>C C" by(auto dest: rhs)
   161       thus False by simp
   162     next
   163       case (step D)
   164       from `G \<turnstile> D \<prec>C1 C` obtain rest where "class G D = Some (C, rest)"
   165         and "D \<noteq> Object" by cases
   166       from `class G D = Some (C, rest)` have "(D, C, rest) \<in> set G"
   167         unfolding class_def by(rule map_of_SomeD)
   168       with `D \<noteq> Object` `class G D = Some (C, rest)`
   169       have "\<not> G \<turnstile> C \<preceq>C D" by(auto dest: rhs)
   170       moreover from `(C, D) \<in> (subcls1 G)\<^sup>+`
   171       have "G \<turnstile> C \<preceq>C D" by(rule trancl_into_rtrancl)
   172       ultimately show False by contradiction
   173     qed
   174   qed
   175   thus "wf_class G" unfolding wf_class_def
   176     by(rule finite_acyclic_wf_converse[OF finite_subcls1])
   177 qed
   178 
   179 consts
   180   method :: "'c prog \<times> cname => ( sig   \<rightharpoonup> cname \<times> ty \<times> 'c)" (* ###curry *)
   181   field  :: "'c prog \<times> cname => ( vname \<rightharpoonup> cname \<times> ty     )" (* ###curry *)
   182   fields :: "'c prog \<times> cname => ((vname \<times> cname) \<times> ty) list" (* ###curry *)
   183 
   184 -- "methods of a class, with inheritance, overriding and hiding, cf. 8.4.6"
   185 defs method_def [code]: "method \<equiv> \<lambda>(G,C). class_rec G C empty (\<lambda>C fs ms ts.
   186                            ts ++ map_of (map (\<lambda>(s,m). (s,(C,m))) ms))"
   187 
   188 lemma method_rec_lemma: "[|class G C = Some (D,fs,ms); wf ((subcls1 G)^-1)|] ==>
   189   method (G,C) = (if C = Object then empty else method (G,D)) ++  
   190   map_of (map (\<lambda>(s,m). (s,(C,m))) ms)"
   191 apply (unfold method_def)
   192 apply (simp split del: split_if)
   193 apply (erule (1) class_rec_lemma [THEN trans]);
   194 apply auto
   195 done
   196 
   197 
   198 -- "list of fields of a class, including inherited and hidden ones"
   199 defs fields_def [code]: "fields \<equiv> \<lambda>(G,C). class_rec G C []    (\<lambda>C fs ms ts.
   200                            map (\<lambda>(fn,ft). ((fn,C),ft)) fs @ ts)"
   201 
   202 lemma fields_rec_lemma: "[|class G C = Some (D,fs,ms); wf ((subcls1 G)^-1)|] ==>
   203  fields (G,C) = 
   204   map (\<lambda>(fn,ft). ((fn,C),ft)) fs @ (if C = Object then [] else fields (G,D))"
   205 apply (unfold fields_def)
   206 apply (simp split del: split_if)
   207 apply (erule (1) class_rec_lemma [THEN trans]);
   208 apply auto
   209 done
   210 
   211 
   212 defs field_def [code]: "field == map_of o (map (\<lambda>((fn,fd),ft). (fn,(fd,ft)))) o fields"
   213 
   214 lemma field_fields: 
   215 "field (G,C) fn = Some (fd, fT) \<Longrightarrow> map_of (fields (G,C)) (fn, fd) = Some fT"
   216 apply (unfold field_def)
   217 apply (rule table_of_remap_SomeD)
   218 apply simp
   219 done
   220 
   221 
   222 -- "widening, viz. method invocation conversion,cf. 5.3 i.e. sort of syntactic subtyping"
   223 inductive
   224   widen   :: "'c prog => [ty   , ty   ] => bool" ("_ \<turnstile> _ \<preceq> _"   [71,71,71] 70)
   225   for G :: "'c prog"
   226 where
   227   refl   [intro!, simp]:       "G\<turnstile>      T \<preceq> T"   -- "identity conv., cf. 5.1.1"
   228 | subcls         : "G\<turnstile>C\<preceq>C D ==> G\<turnstile>Class C \<preceq> Class D"
   229 | null   [intro!]:             "G\<turnstile>     NT \<preceq> RefT R"
   230 
   231 code_pred widen .
   232 
   233 lemmas refl = HOL.refl
   234 
   235 -- "casting conversion, cf. 5.5 / 5.1.5"
   236 -- "left out casts on primitve types"
   237 inductive
   238   cast    :: "'c prog => [ty   , ty   ] => bool" ("_ \<turnstile> _ \<preceq>? _"  [71,71,71] 70)
   239   for G :: "'c prog"
   240 where
   241   widen:  "G\<turnstile> C\<preceq> D ==> G\<turnstile>C \<preceq>? D"
   242 | subcls: "G\<turnstile> D\<preceq>C C ==> G\<turnstile>Class C \<preceq>? Class D"
   243 
   244 lemma widen_PrimT_RefT [iff]: "(G\<turnstile>PrimT pT\<preceq>RefT rT) = False"
   245 apply (rule iffI)
   246 apply (erule widen.cases)
   247 apply auto
   248 done
   249 
   250 lemma widen_RefT: "G\<turnstile>RefT R\<preceq>T ==> \<exists>t. T=RefT t"
   251 apply (ind_cases "G\<turnstile>RefT R\<preceq>T")
   252 apply auto
   253 done
   254 
   255 lemma widen_RefT2: "G\<turnstile>S\<preceq>RefT R ==> \<exists>t. S=RefT t"
   256 apply (ind_cases "G\<turnstile>S\<preceq>RefT R")
   257 apply auto
   258 done
   259 
   260 lemma widen_Class: "G\<turnstile>Class C\<preceq>T ==> \<exists>D. T=Class D"
   261 apply (ind_cases "G\<turnstile>Class C\<preceq>T")
   262 apply auto
   263 done
   264 
   265 lemma widen_Class_NullT [iff]: "(G\<turnstile>Class C\<preceq>NT) = False"
   266 apply (rule iffI)
   267 apply (ind_cases "G\<turnstile>Class C\<preceq>NT")
   268 apply auto
   269 done
   270 
   271 lemma widen_Class_Class [iff]: "(G\<turnstile>Class C\<preceq> Class D) = (G\<turnstile>C\<preceq>C D)"
   272 apply (rule iffI)
   273 apply (ind_cases "G\<turnstile>Class C \<preceq> Class D")
   274 apply (auto elim: widen.subcls)
   275 done
   276 
   277 lemma widen_NT_Class [simp]: "G \<turnstile> T \<preceq> NT \<Longrightarrow> G \<turnstile> T \<preceq> Class D"
   278 by (ind_cases "G \<turnstile> T \<preceq> NT",  auto)
   279 
   280 lemma cast_PrimT_RefT [iff]: "(G\<turnstile>PrimT pT\<preceq>? RefT rT) = False"
   281 apply (rule iffI)
   282 apply (erule cast.cases)
   283 apply auto
   284 done
   285 
   286 lemma cast_RefT: "G \<turnstile> C \<preceq>? Class D \<Longrightarrow> \<exists> rT. C = RefT rT"
   287 apply (erule cast.cases)
   288 apply simp apply (erule widen.cases) 
   289 apply auto
   290 done
   291 
   292 theorem widen_trans[trans]: "\<lbrakk>G\<turnstile>S\<preceq>U; G\<turnstile>U\<preceq>T\<rbrakk> \<Longrightarrow> G\<turnstile>S\<preceq>T"
   293 proof -
   294   assume "G\<turnstile>S\<preceq>U" thus "\<And>T. G\<turnstile>U\<preceq>T \<Longrightarrow> G\<turnstile>S\<preceq>T"
   295   proof induct
   296     case (refl T T') thus "G\<turnstile>T\<preceq>T'" .
   297   next
   298     case (subcls C D T)
   299     then obtain E where "T = Class E" by (blast dest: widen_Class)
   300     with subcls show "G\<turnstile>Class C\<preceq>T" by auto
   301   next
   302     case (null R RT)
   303     then obtain rt where "RT = RefT rt" by (blast dest: widen_RefT)
   304     thus "G\<turnstile>NT\<preceq>RT" by auto
   305   qed
   306 qed
   307 
   308 end