author  wenzelm 
Sat, 21 Jan 2006 23:02:14 +0100  
changeset 18728  6790126ab5f6 
parent 18708  4b3dadb4fe33 
child 18799  f137c5e971f5 
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 

18708  26 
val setup: theory > theory 
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 

18678  96 
fun err_in_typedef msg name = 
97 
cat_error msg ("The error(s) above occurred in typedef " ^ quote name); 

6383  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 

18728  153 
fun typedef_result (context, nonempty) = 
154 
Context.the_theory context 

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), 

18728  179 
[RuleCases.case_names [Rep_name], InductAttrib.cases_set full_name]), 
11822  180 
((Abs_name ^ "_cases", make Abs_cases), 
18728  181 
[RuleCases.case_names [Abs_name], InductAttrib.cases_type full_tname]), 
11822  182 
((Rep_name ^ "_induct", make Rep_induct), 
18728  183 
[RuleCases.case_names [Rep_name], InductAttrib.induct_set full_name]), 
11822  184 
((Abs_name ^ "_induct", make Abs_induct), 
18728  185 
[RuleCases.case_names [Abs_name], InductAttrib.induct_type 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}; 

18728  191 
in ((Context.Theory 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; 
18728  219 
val _ = (Context.Theory 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 
18678  223 
handle ERROR msg => err_in_typedef msg 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) ^ " ..."); 
18678  236 
val non_empty = Goal.prove thy [] [] goal (K tac) handle ERROR msg => 
237 
cat_error msg ("Failed to prove nonemptiness of " ^ quote (string_of_cterm cset)); 

18728  238 
val (thy', result) = 
239 
(Context.Theory thy, non_empty) > typedef_result >> (Context.the_theory o fst); 

11822  240 
in (thy', result) end; 
4866  241 

17339  242 
in 
243 

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

4866  246 

17339  247 
end; 
4866  248 

17339  249 

250 
(* Isar typedef interface *) 

6383  251 

17339  252 
local 
253 

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

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

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

261 
in 

6383  262 

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

265 

266 
end; 

6357  267 

268 

6383  269 

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

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

15259  276 
fun mk_fun s T ts = 
277 
let 

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

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

15259  287 
in 
288 
(case strip_comb t of 

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

290 
if lookup #4 T = s andalso 

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

292 
then mk_fun s T ts 

293 
else if lookup #3 U = s andalso 

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

295 
then mk_fun s U ts 

15531  296 
else NONE 
297 
 _ => NONE) 

15259  298 
end; 
299 

300 
fun mk_tyexpr [] s = Pretty.str s 

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

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

303 

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

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

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

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

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

315 
(gr, Ts) >>> 

316 
Codegen.mk_const_id module' Abs_name >>> 

317 
Codegen.mk_const_id module' Rep_name >>> 

318 
Codegen.mk_type_id module' s; 

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

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

321 
NONE => 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

359 
val setup = 

18708  360 
TypedefData.init #> 
361 
Codegen.add_codegen "typedef" typedef_codegen #> 

362 
Codegen.add_tycodegen "typedef" typedef_tycodegen; 

15259  363 

364 

365 

6383  366 
(** outer syntax **) 
367 

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

6357  370 
val typedeclP = 
12624  371 
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

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

6723  375 

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

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

378 
((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

379 
 P.$$$ ")") (true, NONE)  
11744  380 
(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

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

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

6357  385 

386 
val typedefP = 

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

6723  390 

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

4866  394 
end; 
6383  395 

396 
end; 