author  haftmann 
Fri, 09 Dec 2005 09:06:45 +0100  
changeset 18377  0e1d025d57b3 
parent 18358  0a733e11021a 
child 18643  89a7978f90e1 
permissions  rwrr 
4866  1 
(* Title: HOL/Tools/typedef_package.ML 
2 
ID: $Id$ 

16458  3 
Author: Markus Wenzel and Stefan Berghofer, TU Muenchen 
4866  4 

6357  5 
Gordon/HOLstyle type definitions. 
4866  6 
*) 
7 

8 
signature TYPEDEF_PACKAGE = 

9 
sig 

5697  10 
val quiet_mode: bool ref 
5104  11 
val add_typedecls: (bstring * string list * mixfix) list > theory > theory 
11827  12 
val add_typedef: bool > string option > bstring * string list * mixfix > 
11822  13 
string > (bstring * bstring) option > tactic > theory > theory * 
14 
{type_definition: thm, set_def: thm option, Rep: thm, Rep_inverse: thm, 

15 
Abs_inverse: thm, Rep_inject: thm, Abs_inject: thm, Rep_cases: thm, Abs_cases: thm, 

16 
Rep_induct: thm, Abs_induct: thm} 

11827  17 
val add_typedef_i: bool > string option > bstring * string list * mixfix > 
11822  18 
term > (bstring * bstring) option > tactic > theory > theory * 
19 
{type_definition: thm, set_def: thm option, Rep: thm, Rep_inverse: thm, 

20 
Abs_inverse: thm, Rep_inject: thm, Abs_inject: thm, Rep_cases: thm, Abs_cases: thm, 

21 
Rep_induct: thm, Abs_induct: thm} 

17339  22 
val typedef: (bool * string) * (bstring * string list * mixfix) * string 
23 
* (string * string) option > theory > Proof.state 

24 
val typedef_i: (bool * string) * (bstring * string list * mixfix) * term 

25 
* (string * string) option > theory > Proof.state 

15259  26 
val setup: (theory > theory) list 
4866  27 
end; 
28 

29 
structure TypedefPackage: TYPEDEF_PACKAGE = 

30 
struct 

31 

32 

10280  33 
(** theory context references **) 
34 

11608  35 
val type_definitionN = "Typedef.type_definition"; 
10280  36 

13413  37 
val Rep = thm "type_definition.Rep"; 
38 
val Rep_inverse = thm "type_definition.Rep_inverse"; 

39 
val Abs_inverse = thm "type_definition.Abs_inverse"; 

40 
val Rep_inject = thm "type_definition.Rep_inject"; 

41 
val Abs_inject = thm "type_definition.Abs_inject"; 

42 
val Rep_cases = thm "type_definition.Rep_cases"; 

43 
val Abs_cases = thm "type_definition.Abs_cases"; 

44 
val Rep_induct = thm "type_definition.Rep_induct"; 

45 
val Abs_induct = thm "type_definition.Abs_induct"; 

10280  46 

47 

48 

17922  49 
(** type declarations **) 
50 

51 
fun add_typedecls decls thy = 

52 
let 

53 
fun arity_of (raw_name, args, mx) = 

54 
(Sign.full_name thy (Syntax.type_name raw_name mx), 

55 
replicate (length args) HOLogic.typeS, HOLogic.typeS); 

56 
in 

57 
thy 

58 
> Theory.add_typedecls decls 

59 
> can (Theory.assert_super HOL.thy) ? Theory.add_arities_i (map arity_of decls) 

60 
end; 

61 

62 

63 

64 
(** type definitions **) 

65 

66 
(* messages *) 

67 

68 
val quiet_mode = ref false; 

69 
fun message s = if ! quiet_mode then () else writeln s; 

70 

71 

72 
(* theory data *) 

15259  73 

16458  74 
structure TypedefData = TheoryDataFun 
75 
(struct 

15259  76 
val name = "HOL/typedef"; 
77 
type T = (typ * typ * string * string) Symtab.table; 

78 
val empty = Symtab.empty; 

79 
val copy = I; 

16458  80 
val extend = I; 
81 
fun merge _ (tabs: T * T) = Symtab.merge (op =) tabs; 

82 
fun print _ _ = (); 

83 
end); 

15259  84 

17280  85 
fun put_typedef newT oldT Abs_name Rep_name = 
17412  86 
TypedefData.map (Symtab.update_new (fst (dest_Type newT), (newT, oldT, Abs_name, Rep_name))); 
15259  87 

88 

6383  89 
(* prepare_typedef *) 
90 

16458  91 
fun read_term thy used s = 
92 
#1 (Thm.read_def_cterm (thy, K NONE, K NONE) used true (s, HOLogic.typeT)); 

4866  93 

16458  94 
fun cert_term thy _ t = Thm.cterm_of thy t handle TERM (msg, _) => error msg; 
6383  95 

96 
fun err_in_typedef name = 

97 
error ("The error(s) above occurred in typedef " ^ quote name); 

98 

11822  99 
fun prepare_typedef prep_term def name (t, vs, mx) raw_set opt_morphs thy = 
4866  100 
let 
11608  101 
val _ = Theory.requires thy "Typedef" "typedefs"; 
16458  102 
val full = Sign.full_name thy; 
4866  103 

104 
(*rhs*) 

10280  105 
val full_name = full name; 
16458  106 
val cset = prep_term thy vs raw_set; 
6383  107 
val {T = setT, t = set, ...} = Thm.rep_cterm cset; 
17280  108 
val rhs_tfrees = Term.add_tfrees set []; 
109 
val rhs_tfreesT = Term.add_tfreesT setT []; 

4866  110 
val oldT = HOLogic.dest_setT setT handle TYPE _ => 
16458  111 
error ("Not a set type: " ^ quote (Sign.string_of_typ thy setT)); 
11426
f280d4b29a2c
abtract nonemptiness statements (no longer use Eps);
wenzelm
parents:
10697
diff
changeset

112 
fun mk_nonempty A = 
f280d4b29a2c
abtract nonemptiness statements (no longer use Eps);
wenzelm
parents:
10697
diff
changeset

113 
HOLogic.mk_Trueprop (HOLogic.mk_exists ("x", oldT, HOLogic.mk_mem (Free ("x", oldT), A))); 
f280d4b29a2c
abtract nonemptiness statements (no longer use Eps);
wenzelm
parents:
10697
diff
changeset

114 
val goal = mk_nonempty set; 
17280  115 
val goal_pat = mk_nonempty (Var (if_none (Syntax.read_variable name) (name, 0), setT)); 
4866  116 

117 
(*lhs*) 

17280  118 
val defS = Sign.defaultS thy; 
119 
val lhs_tfrees = map (fn v => (v, if_none (AList.lookup (op =) rhs_tfrees v) defS)) vs; 

120 
val args_setT = lhs_tfrees 

121 
> filter (member (op =) rhs_tfrees andf (not o member (op =) rhs_tfreesT)) 

122 
> map TFree; 

123 

4866  124 
val tname = Syntax.type_name t mx; 
10280  125 
val full_tname = full tname; 
126 
val newT = Type (full_tname, map TFree lhs_tfrees); 

4866  127 

17280  128 
val (Rep_name, Abs_name) = if_none opt_morphs ("Rep_" ^ name, "Abs_" ^ name); 
129 
val setT' = map itselfT args_setT > setT; 

130 
val setC = Term.list_comb (Const (full_name, setT'), map Logic.mk_type args_setT); 

10280  131 
val RepC = Const (full Rep_name, newT > oldT); 
132 
val AbsC = Const (full Abs_name, oldT > newT); 

4866  133 
val x_new = Free ("x", newT); 
134 
val y_old = Free ("y", oldT); 

10280  135 

11822  136 
val set' = if def then setC else set; 
4866  137 

10280  138 
val typedef_name = "type_definition_" ^ name; 
139 
val typedefC = 

140 
Const (type_definitionN, (newT > oldT) > (oldT > newT) > setT > HOLogic.boolT); 

11426
f280d4b29a2c
abtract nonemptiness statements (no longer use Eps);
wenzelm
parents:
10697
diff
changeset

141 
val typedef_prop = 
f280d4b29a2c
abtract nonemptiness statements (no longer use Eps);
wenzelm
parents:
10697
diff
changeset

142 
Logic.mk_implies (goal, HOLogic.mk_Trueprop (typedefC $ RepC $ AbsC $ set')); 
4866  143 

18358  144 
fun add_def def def' thy = 
145 
if def 

146 
then 

147 
thy 

148 
> PureThy.add_defs_i false [Thm.no_attributes def'] 

149 
> (fn [def'] => pair (SOME def')) 

150 
else 

151 
(NONE, thy); 

152 

11822  153 
fun typedef_result (theory, nonempty) = 
6383  154 
theory 
15259  155 
> put_typedef newT oldT (full Abs_name) (full Rep_name) 
6383  156 
> add_typedecls [(t, vs, mx)] 
157 
> Theory.add_consts_i 

17280  158 
((if def then [(name, setT', NoSyn)] else []) @ 
6383  159 
[(Rep_name, newT > oldT, NoSyn), 
160 
(Abs_name, oldT > newT, NoSyn)]) 

18358  161 
> add_def def (Logic.mk_defpair (setC, set)) 
18377  162 
>> PureThy.add_axioms_i [((typedef_name, typedef_prop), 
163 
[apsnd (fn cond_axm => Drule.standard (nonempty RS cond_axm))])] 

18358  164 
> Theory.add_finals_i false [RepC, AbsC] 
165 
> (fn (set_def, [type_definition]) => fn theory' => 

11822  166 
let 
167 
fun make th = Drule.standard (th OF [type_definition]); 

18377  168 
val ([Rep, Rep_inverse, Abs_inverse, Rep_inject, Abs_inject, 
169 
Rep_cases, Abs_cases, Rep_induct, Abs_induct], theory'') = 

12338
de0f4a63baa5
renamed class "term" to "type" (actually "HOL.type");
wenzelm
parents:
12043
diff
changeset

170 
theory' 
de0f4a63baa5
renamed class "term" to "type" (actually "HOL.type");
wenzelm
parents:
12043
diff
changeset

171 
> Theory.add_path name 
de0f4a63baa5
renamed class "term" to "type" (actually "HOL.type");
wenzelm
parents:
12043
diff
changeset

172 
> PureThy.add_thms 
11822  173 
([((Rep_name, make Rep), []), 
174 
((Rep_name ^ "_inverse", make Rep_inverse), []), 

175 
((Abs_name ^ "_inverse", make Abs_inverse), []), 

176 
((Rep_name ^ "_inject", make Rep_inject), []), 

177 
((Abs_name ^ "_inject", make Abs_inject), []), 

178 
((Rep_name ^ "_cases", make Rep_cases), 

179 
[RuleCases.case_names [Rep_name], InductAttrib.cases_set_global full_name]), 

180 
((Abs_name ^ "_cases", make Abs_cases), 

181 
[RuleCases.case_names [Abs_name], InductAttrib.cases_type_global full_tname]), 

182 
((Rep_name ^ "_induct", make Rep_induct), 

183 
[RuleCases.case_names [Rep_name], InductAttrib.induct_set_global full_name]), 

184 
((Abs_name ^ "_induct", make Abs_induct), 

12338
de0f4a63baa5
renamed class "term" to "type" (actually "HOL.type");
wenzelm
parents:
12043
diff
changeset

185 
[RuleCases.case_names [Abs_name], InductAttrib.induct_type_global full_tname])]) 
18377  186 
> Theory.parent_path; 
11822  187 
val result = {type_definition = type_definition, set_def = set_def, 
188 
Rep = Rep, Rep_inverse = Rep_inverse, Abs_inverse = Abs_inverse, 

189 
Rep_inject = Rep_inject, Abs_inject = Abs_inject, Rep_cases = Rep_cases, 

190 
Abs_cases = Abs_cases, Rep_induct = Rep_induct, Abs_induct = Abs_induct}; 

191 
in ((theory'', type_definition), result) end); 

6383  192 

4866  193 

194 
(* errors *) 

195 

196 
fun show_names pairs = commas_quote (map fst pairs); 

197 

198 
val illegal_vars = 

199 
if null (term_vars set) andalso null (term_tvars set) then [] 

200 
else ["Illegal schematic variable(s) on rhs"]; 

201 

202 
val dup_lhs_tfrees = 

203 
(case duplicates lhs_tfrees of [] => [] 

204 
 dups => ["Duplicate type variables on lhs: " ^ show_names dups]); 

205 

206 
val extra_rhs_tfrees = 

17280  207 
(case fold (remove (op =)) lhs_tfrees rhs_tfrees of [] => [] 
4866  208 
 extras => ["Extra type variables on rhs: " ^ show_names extras]); 
209 

210 
val illegal_frees = 

211 
(case term_frees set of [] => [] 

212 
 xs => ["Illegal variables on rhs: " ^ show_names (map dest_Free xs)]); 

213 

214 
val errs = illegal_vars @ dup_lhs_tfrees @ extra_rhs_tfrees @ illegal_frees; 

11426
f280d4b29a2c
abtract nonemptiness statements (no longer use Eps);
wenzelm
parents:
10697
diff
changeset

215 
val _ = if null errs then () else error (cat_lines errs); 
f280d4b29a2c
abtract nonemptiness statements (no longer use Eps);
wenzelm
parents:
10697
diff
changeset

216 

f280d4b29a2c
abtract nonemptiness statements (no longer use Eps);
wenzelm
parents:
10697
diff
changeset

217 
(*test theory errors now!*) 
f280d4b29a2c
abtract nonemptiness statements (no longer use Eps);
wenzelm
parents:
10697
diff
changeset

218 
val test_thy = Theory.copy thy; 
11727
a27150cc8fa5
test: use SkipProof.make_thm instead of Thm.assume;
wenzelm
parents:
11608
diff
changeset

219 
val _ = (test_thy, 
11822  220 
setmp quick_and_dirty true (SkipProof.make_thm test_thy) goal) > typedef_result; 
11426
f280d4b29a2c
abtract nonemptiness statements (no longer use Eps);
wenzelm
parents:
10697
diff
changeset

221 

11822  222 
in (cset, goal, goal_pat, typedef_result) end 
11426
f280d4b29a2c
abtract nonemptiness statements (no longer use Eps);
wenzelm
parents:
10697
diff
changeset

223 
handle ERROR => err_in_typedef name; 
4866  224 

225 

6383  226 
(* add_typedef interfaces *) 
4866  227 

17339  228 
local 
229 

17922  230 
fun gen_typedef prep_term def opt_name typ set opt_morphs tac thy = 
6383  231 
let 
17922  232 
val name = the_default (#1 typ) opt_name; 
11822  233 
val (cset, goal, _, typedef_result) = 
234 
prepare_typedef prep_term def name typ set opt_morphs thy; 

17922  235 
val _ = message ("Proving nonemptiness of set " ^ quote (string_of_cterm cset) ^ " ..."); 
17956  236 
val non_empty = Goal.prove thy [] [] goal (K tac) handle ERROR_MESSAGE msg => 
237 
error (msg ^ "\nFailed to prove nonemptiness of " ^ quote (string_of_cterm cset)); 

11822  238 
val ((thy', _), result) = (thy, non_empty) > typedef_result; 
239 
in (thy', result) end; 

4866  240 

17339  241 
in 
242 

17922  243 
val add_typedef = gen_typedef read_term; 
244 
val add_typedef_i = gen_typedef cert_term; 

4866  245 

17339  246 
end; 
4866  247 

17339  248 

249 
(* Isar typedef interface *) 

6383  250 

17339  251 
local 
252 

253 
fun gen_typedef prep_term ((def, name), typ, set, opt_morphs) thy = 

11822  254 
let 
255 
val (_, goal, goal_pat, att_result) = 

13443  256 
prepare_typedef prep_term def name typ set opt_morphs thy; 
11822  257 
val att = #1 o att_result; 
17339  258 
in IsarThy.theorem_i Drule.internalK ("", [att]) (goal, ([goal_pat], [])) thy end; 
259 

260 
in 

6383  261 

17339  262 
val typedef = gen_typedef read_term; 
263 
val typedef_i = gen_typedef cert_term; 

264 

265 
end; 

6357  266 

267 

6383  268 

15259  269 
(** trivial code generator **) 
270 

17144  271 
fun typedef_codegen thy defs gr dep module brack t = 
15259  272 
let 
16645  273 
fun get_name (Type (tname, _)) = tname 
274 
 get_name _ = ""; 

15259  275 
fun mk_fun s T ts = 
276 
let 

17144  277 
val (gr', _) = Codegen.invoke_tycodegen thy defs dep module false (gr, T); 
15259  278 
val (gr'', ps) = 
17144  279 
foldl_map (Codegen.invoke_codegen thy defs dep module true) (gr', ts); 
280 
val id = Codegen.mk_qual_id module (Codegen.get_const_id s gr'') 

15531  281 
in SOME (gr'', Codegen.mk_app brack (Pretty.str id) ps) end; 
17261  282 
fun lookup f T = 
17412  283 
(case Symtab.lookup (TypedefData.get thy) (get_name T) of 
17261  284 
NONE => "" 
285 
 SOME s => f s); 

15259  286 
in 
287 
(case strip_comb t of 

288 
(Const (s, Type ("fun", [T, U])), ts) => 

289 
if lookup #4 T = s andalso 

290 
is_none (Codegen.get_assoc_type thy (get_name T)) 

291 
then mk_fun s T ts 

292 
else if lookup #3 U = s andalso 

293 
is_none (Codegen.get_assoc_type thy (get_name U)) 

294 
then mk_fun s U ts 

15531  295 
else NONE 
296 
 _ => NONE) 

15259  297 
end; 
298 

299 
fun mk_tyexpr [] s = Pretty.str s 

300 
 mk_tyexpr [p] s = Pretty.block [p, Pretty.str (" " ^ s)] 

301 
 mk_tyexpr ps s = Pretty.list "(" (") " ^ s) ps; 

302 

17144  303 
fun typedef_tycodegen thy defs gr dep module brack (Type (s, Ts)) = 
17412  304 
(case Symtab.lookup (TypedefData.get thy) s of 
15531  305 
NONE => NONE 
306 
 SOME (newT as Type (tname, Us), oldT, Abs_name, Rep_name) => 

17280  307 
if is_some (Codegen.get_assoc_type thy tname) then NONE else 
15259  308 
let 
17144  309 
val module' = Codegen.if_library 
310 
(Codegen.thyname_of_type tname thy) module; 

311 
val node_id = tname ^ " (type)"; 

312 
val (gr', (((qs, (_, Abs_id)), (_, Rep_id)), ty_id)) = foldl_map 

313 
(Codegen.invoke_tycodegen thy defs dep module (length Ts = 1)) 

314 
(gr, Ts) >>> 

315 
Codegen.mk_const_id module' Abs_name >>> 

316 
Codegen.mk_const_id module' Rep_name >>> 

317 
Codegen.mk_type_id module' s; 

318 
val tyexpr = mk_tyexpr qs (Codegen.mk_qual_id module ty_id) 

319 
in SOME (case try (Codegen.get_node gr') node_id of 

320 
NONE => 

15259  321 
let 
322 
val (gr'', p :: ps) = foldl_map 

17144  323 
(Codegen.invoke_tycodegen thy defs node_id module' false) 
324 
(Codegen.add_edge (node_id, dep) 

325 
(Codegen.new_node (node_id, (NONE, "", "")) gr'), oldT :: Us); 

15259  326 
val s = 
327 
Pretty.string_of (Pretty.block [Pretty.str "datatype ", 

17144  328 
mk_tyexpr ps (snd ty_id), 
15259  329 
Pretty.str " =", Pretty.brk 1, Pretty.str (Abs_id ^ " of"), 
330 
Pretty.brk 1, p, Pretty.str ";"]) ^ "\n\n" ^ 

331 
Pretty.string_of (Pretty.block [Pretty.str ("fun " ^ Rep_id), 

332 
Pretty.brk 1, Pretty.str ("(" ^ Abs_id), Pretty.brk 1, 

333 
Pretty.str "x) = x;"]) ^ "\n\n" ^ 

334 
(if "term_of" mem !Codegen.mode then 

335 
Pretty.string_of (Pretty.block [Pretty.str "fun ", 

17144  336 
Codegen.mk_term_of gr'' module' false newT, Pretty.brk 1, 
15259  337 
Pretty.str ("(" ^ Abs_id), Pretty.brk 1, 
338 
Pretty.str "x) =", Pretty.brk 1, 

339 
Pretty.block [Pretty.str ("Const (\"" ^ Abs_name ^ "\","), 

340 
Pretty.brk 1, Codegen.mk_type false (oldT > newT), 

341 
Pretty.str ")"], Pretty.str " $", Pretty.brk 1, 

17144  342 
Codegen.mk_term_of gr'' module' false oldT, Pretty.brk 1, 
15259  343 
Pretty.str "x;"]) ^ "\n\n" 
344 
else "") ^ 

345 
(if "test" mem !Codegen.mode then 

346 
Pretty.string_of (Pretty.block [Pretty.str "fun ", 

17144  347 
Codegen.mk_gen gr'' module' false [] "" newT, Pretty.brk 1, 
15259  348 
Pretty.str "i =", Pretty.brk 1, 
349 
Pretty.block [Pretty.str (Abs_id ^ " ("), 

17144  350 
Codegen.mk_gen gr'' module' false [] "" oldT, Pretty.brk 1, 
15259  351 
Pretty.str "i);"]]) ^ "\n\n" 
352 
else "") 

17144  353 
in Codegen.map_node node_id (K (NONE, module', s)) gr'' end 
354 
 SOME _ => Codegen.add_edge (node_id, dep) gr', tyexpr) 

15259  355 
end) 
17144  356 
 typedef_tycodegen thy defs gr dep module brack _ = NONE; 
15259  357 

358 
val setup = 

359 
[TypedefData.init, 

360 
Codegen.add_codegen "typedef" typedef_codegen, 

361 
Codegen.add_tycodegen "typedef" typedef_tycodegen]; 

362 

363 

364 

6383  365 
(** outer syntax **) 
366 

17057  367 
local structure P = OuterParse and K = OuterKeyword in 
6383  368 

6357  369 
val typedeclP = 
12624  370 
OuterSyntax.command "typedecl" "type declaration (HOL)" K.thy_decl 
12876
a70df1e5bf10
got rid of explicit marginal comments (now stripped earlier from input);
wenzelm
parents:
12694
diff
changeset

371 
(P.type_args  P.name  P.opt_infix >> (fn ((vs, t), mx) => 
6357  372 
Toplevel.theory (add_typedecls [(t, vs, mx)]))); 
373 

6723  374 

17339  375 
val typedef_decl = 
16126
3ba9eb7ea366
fixed outer syntax: allow type_args with parentheses;
wenzelm
parents:
15570
diff
changeset

376 
Scan.optional (P.$$$ "("  
3ba9eb7ea366
fixed outer syntax: allow type_args with parentheses;
wenzelm
parents:
15570
diff
changeset

377 
((P.$$$ "open" >> K false)  Scan.option P.name  P.name >> (fn s => (true, SOME s))) 
3ba9eb7ea366
fixed outer syntax: allow type_args with parentheses;
wenzelm
parents:
15570
diff
changeset

378 
 P.$$$ ")") (true, NONE)  
11744  379 
(P.type_args  P.name)  P.opt_infix  (P.$$$ "="  P.term)  
12876
a70df1e5bf10
got rid of explicit marginal comments (now stripped earlier from input);
wenzelm
parents:
12694
diff
changeset

380 
Scan.option (P.$$$ "morphisms"  P.!!! (P.name  P.name)); 
6357  381 

17339  382 
fun mk_typedef ((((((def, opt_name), (vs, t)), mx), A), morphs)) = 
383 
typedef ((def, if_none opt_name (Syntax.type_name t mx)), (t, vs, mx), A, morphs); 

6357  384 

385 
val typedefP = 

6723  386 
OuterSyntax.command "typedef" "HOL type definition (requires nonemptiness proof)" K.thy_goal 
17339  387 
(typedef_decl >> (Toplevel.print oo (Toplevel.theory_to_proof o mk_typedef))); 
6357  388 

6723  389 

11744  390 
val _ = OuterSyntax.add_keywords ["morphisms"]; 
6357  391 
val _ = OuterSyntax.add_parsers [typedeclP, typedefP]; 
392 

4866  393 
end; 
6383  394 

395 
end; 