author  skalberg 
Sun, 13 Feb 2005 17:15:14 +0100  
changeset 15531  08c8dad8e399 
parent 15457  1fbd4aba46e3 
child 15570  8d8c70b41bab 
permissions  rwrr 
4866  1 
(* Title: HOL/Tools/typedef_package.ML 
2 
ID: $Id$ 

3 
Author: Markus Wenzel, TU Muenchen 

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 
11822  12 
val add_typedef_x: string > bstring * string list * mixfix > 
4866  13 
string > string list > thm list > tactic option > theory > theory 
11827  14 
val add_typedef: bool > string option > bstring * string list * mixfix > 
11822  15 
string > (bstring * bstring) option > tactic > theory > theory * 
16 
{type_definition: thm, set_def: thm option, Rep: thm, Rep_inverse: thm, 

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

18 
Rep_induct: thm, Abs_induct: thm} 

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

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

23 
Rep_induct: thm, Abs_induct: thm} 

13443  24 
val typedef_proof: (bool * string) * (bstring * string list * mixfix) * string 
25 
* (string * string) option > bool > theory > ProofHistory.T 

26 
val typedef_proof_i: (bool * string) * (bstring * string list * mixfix) * term 

27 
* (string * string) option > bool > theory > ProofHistory.T 

15259  28 
val setup: (theory > theory) list 
4866  29 
end; 
30 

31 
structure TypedefPackage: TYPEDEF_PACKAGE = 

32 
struct 

33 

34 

10280  35 
(** theory context references **) 
36 

11608  37 
val type_definitionN = "Typedef.type_definition"; 
10280  38 

13413  39 
val Rep = thm "type_definition.Rep"; 
40 
val Rep_inverse = thm "type_definition.Rep_inverse"; 

41 
val Abs_inverse = thm "type_definition.Abs_inverse"; 

42 
val Rep_inject = thm "type_definition.Rep_inject"; 

43 
val Abs_inject = thm "type_definition.Abs_inject"; 

44 
val Rep_cases = thm "type_definition.Rep_cases"; 

45 
val Abs_cases = thm "type_definition.Abs_cases"; 

46 
val Rep_induct = thm "type_definition.Rep_induct"; 

47 
val Abs_induct = thm "type_definition.Abs_induct"; 

10280  48 

49 

50 

15259  51 
(** theory data **) 
52 

53 
structure TypedefArgs = 

54 
struct 

55 
val name = "HOL/typedef"; 

56 
type T = (typ * typ * string * string) Symtab.table; 

57 
val empty = Symtab.empty; 

58 
val copy = I; 

59 
val prep_ext = I; 

15265  60 
val merge : T * T > T = Symtab.merge op =; 
15259  61 
fun print sg _ = (); 
62 
end; 

63 

64 
structure TypedefData = TheoryDataFun(TypedefArgs); 

65 

66 
fun put_typedef newT oldT Abs_name Rep_name thy = 

67 
TypedefData.put (Symtab.update_new 

68 
((fst (dest_Type newT), (newT, oldT, Abs_name, Rep_name)), 

69 
TypedefData.get thy)) thy; 

70 

71 

72 

5104  73 
(** type declarations **) 
74 

75 
fun add_typedecls decls thy = 

76 
let 

77 
val full = Sign.full_name (Theory.sign_of thy); 

78 

79 
fun arity_of (raw_name, args, mx) = 

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

80 
(full (Syntax.type_name raw_name mx), replicate (length args) HOLogic.typeS, HOLogic.typeS); 
5104  81 
in 
8141  82 
if can (Theory.assert_super HOL.thy) thy then 
83 
thy 

84 
> PureThy.add_typedecls decls 

85 
> Theory.add_arities_i (map arity_of decls) 

86 
else thy > PureThy.add_typedecls decls 

5104  87 
end; 
88 

89 

90 

91 
(** type definitions **) 

92 

5697  93 
(* messages *) 
94 

95 
val quiet_mode = ref false; 

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

97 

98 

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

99 
(* prove_nonempty  tactical version *) (*exception ERROR*) 
4866  100 

11827  101 
fun prove_nonempty thy cset goal (witn1_tac, witn_names, witn_thms, witn2_tac) = 
6383  102 
let 
103 
val is_def = Logic.is_equals o #prop o Thm.rep_thm; 

15531  104 
val thms = PureThy.get_thmss thy (map (rpair NONE) witn_names) @ witn_thms; 
4866  105 
val tac = 
11827  106 
witn1_tac THEN 
4866  107 
TRY (rewrite_goals_tac (filter is_def thms)) THEN 
108 
TRY (REPEAT_FIRST (resolve_tac (filter_out is_def thms))) THEN 

11827  109 
if_none witn2_tac (TRY (ALLGOALS (CLASET' blast_tac))); 
4866  110 
in 
6383  111 
message ("Proving nonemptiness of set " ^ quote (string_of_cterm cset) ^ " ..."); 
11968  112 
Tactic.prove (Theory.sign_of thy) [] [] goal (K tac) 
6383  113 
end handle ERROR => error ("Failed to prove nonemptiness of " ^ quote (string_of_cterm cset)); 
4866  114 

115 

6383  116 
(* prepare_typedef *) 
117 

118 
fun read_term sg used s = 

15531  119 
#1 (Thm.read_def_cterm (sg, K NONE, K NONE) used true (s, HOLogic.typeT)); 
4866  120 

6383  121 
fun cert_term sg _ t = Thm.cterm_of sg t handle TERM (msg, _) => error msg; 
122 

123 
fun err_in_typedef name = 

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

125 

11822  126 
fun prepare_typedef prep_term def name (t, vs, mx) raw_set opt_morphs thy = 
4866  127 
let 
11608  128 
val _ = Theory.requires thy "Typedef" "typedefs"; 
6383  129 
val sign = Theory.sign_of thy; 
10280  130 
val full = Sign.full_name sign; 
4866  131 

132 
(*rhs*) 

10280  133 
val full_name = full name; 
6383  134 
val cset = prep_term sign vs raw_set; 
135 
val {T = setT, t = set, ...} = Thm.rep_cterm cset; 

4866  136 
val rhs_tfrees = term_tfrees set; 
137 
val oldT = HOLogic.dest_setT setT handle TYPE _ => 

138 
error ("Not a set type: " ^ quote (Sign.string_of_typ sign setT)); 

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

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

140 
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

141 
val goal = mk_nonempty set; 
11744  142 
val vname = take_suffix Symbol.is_digit (Symbol.explode name) 
14819  143 
> apfst implode > apsnd (#1 o Library.read_int); 
11744  144 
val goal_pat = mk_nonempty (Var (vname, setT)); 
4866  145 

146 
(*lhs*) 

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

147 
val lhs_tfrees = map (fn v => (v, if_none (assoc (rhs_tfrees, v)) HOLogic.typeS)) vs; 
4866  148 
val tname = Syntax.type_name t mx; 
10280  149 
val full_tname = full tname; 
150 
val newT = Type (full_tname, map TFree lhs_tfrees); 

4866  151 

11744  152 
val (Rep_name, Abs_name) = if_none opt_morphs ("Rep_" ^ name, "Abs_" ^ name); 
10280  153 
val setC = Const (full_name, setT); 
154 
val RepC = Const (full Rep_name, newT > oldT); 

155 
val AbsC = Const (full Abs_name, oldT > newT); 

4866  156 
val x_new = Free ("x", newT); 
157 
val y_old = Free ("y", oldT); 

10280  158 

11822  159 
val set' = if def then setC else set; 
4866  160 

10280  161 
val typedef_name = "type_definition_" ^ name; 
162 
val typedefC = 

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

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

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

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

11822  167 
fun typedef_result (theory, nonempty) = 
6383  168 
theory 
15259  169 
> put_typedef newT oldT (full Abs_name) (full Rep_name) 
6383  170 
> add_typedecls [(t, vs, mx)] 
171 
> Theory.add_consts_i 

11822  172 
((if def then [(name, setT, NoSyn)] else []) @ 
6383  173 
[(Rep_name, newT > oldT, NoSyn), 
174 
(Abs_name, oldT > newT, NoSyn)]) 

15531  175 
> (if def then (apsnd (SOME o hd) oo (PureThy.add_defs_i false o map Thm.no_attributes)) 
11822  176 
[Logic.mk_defpair (setC, set)] 
15531  177 
else rpair NONE) 
14570  178 
>>> PureThy.add_axioms_i [((typedef_name, typedef_prop), 
11727
a27150cc8fa5
test: use SkipProof.make_thm instead of Thm.assume;
wenzelm
parents:
11608
diff
changeset

179 
[apsnd (fn cond_axm => Drule.standard (nonempty RS cond_axm))])] 
14570  180 
>> Theory.add_finals_i false [RepC, AbsC] 
181 
> (fn (theory', (set_def, [type_definition])) => 

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

184 
val (theory'', [Rep, Rep_inverse, Abs_inverse, Rep_inject, Abs_inject, 

185 
Rep_cases, Abs_cases, Rep_induct, Abs_induct]) = 

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

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

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

188 
> PureThy.add_thms 
11822  189 
([((Rep_name, make Rep), []), 
190 
((Rep_name ^ "_inverse", make Rep_inverse), []), 

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

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

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

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

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

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

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

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

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

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

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

201 
[RuleCases.case_names [Abs_name], InductAttrib.induct_type_global full_tname])]) 
de0f4a63baa5
renamed class "term" to "type" (actually "HOL.type");
wenzelm
parents:
12043
diff
changeset

202 
>> Theory.parent_path; 
11822  203 
val result = {type_definition = type_definition, set_def = set_def, 
204 
Rep = Rep, Rep_inverse = Rep_inverse, Abs_inverse = Abs_inverse, 

205 
Rep_inject = Rep_inject, Abs_inject = Abs_inject, Rep_cases = Rep_cases, 

206 
Abs_cases = Abs_cases, Rep_induct = Rep_induct, Abs_induct = Abs_induct}; 

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

6383  208 

4866  209 

210 
(* errors *) 

211 

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

213 

214 
val illegal_vars = 

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

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

217 

218 
val dup_lhs_tfrees = 

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

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

221 

222 
val extra_rhs_tfrees = 

223 
(case gen_rems (op =) (rhs_tfrees, lhs_tfrees) of [] => [] 

224 
 extras => ["Extra type variables on rhs: " ^ show_names extras]); 

225 

226 
val illegal_frees = 

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

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

229 

230 
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

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

232 

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

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

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

235 
val _ = (test_thy, 
11822  236 
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

237 

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

239 
handle ERROR => err_in_typedef name; 
4866  240 

241 

6383  242 
(* add_typedef interfaces *) 
4866  243 

11827  244 
fun gen_typedef prep_term def name typ set opt_morphs tac1 names thms tac2 thy = 
6383  245 
let 
11822  246 
val (cset, goal, _, typedef_result) = 
247 
prepare_typedef prep_term def name typ set opt_morphs thy; 

11827  248 
val non_empty = prove_nonempty thy cset goal (tac1, names, thms, tac2); 
11822  249 
val ((thy', _), result) = (thy, non_empty) > typedef_result; 
250 
in (thy', result) end; 

4866  251 

11827  252 
fun sane_typedef prep_term def opt_name typ set opt_morphs tac = 
253 
gen_typedef prep_term def 

15531  254 
(if_none opt_name (#1 typ)) typ set opt_morphs all_tac [] [] (SOME tac); 
11822  255 

256 
fun add_typedef_x name typ set names thms tac = 

15531  257 
#1 o gen_typedef read_term true name typ set NONE (Tactic.rtac exI 1) names thms tac; 
11822  258 

259 
val add_typedef = sane_typedef read_term; 

260 
val add_typedef_i = sane_typedef cert_term; 

4866  261 

262 

6383  263 
(* typedef_proof interface *) 
264 

13443  265 
fun gen_typedef_proof prep_term ((def, name), typ, set, opt_morphs) int thy = 
11822  266 
let 
267 
val (_, goal, goal_pat, att_result) = 

13443  268 
prepare_typedef prep_term def name typ set opt_morphs thy; 
11822  269 
val att = #1 o att_result; 
12876
a70df1e5bf10
got rid of explicit marginal comments (now stripped earlier from input);
wenzelm
parents:
12694
diff
changeset

270 
in thy > IsarThy.theorem_i Drule.internalK (("", [att]), (goal, ([goal_pat], []))) int end; 
6383  271 

272 
val typedef_proof = gen_typedef_proof read_term; 

273 
val typedef_proof_i = gen_typedef_proof cert_term; 

6357  274 

275 

6383  276 

15259  277 
(** trivial code generator **) 
278 

279 
fun typedef_codegen thy gr dep brack t = 

280 
let 

281 
fun mk_fun s T ts = 

282 
let 

283 
val (gr', _) = Codegen.invoke_tycodegen thy dep false (gr, T); 

284 
val (gr'', ps) = 

285 
foldl_map (Codegen.invoke_codegen thy dep true) (gr', ts); 

286 
val id = Codegen.mk_const_id (sign_of thy) s 

15531  287 
in SOME (gr'', Codegen.mk_app brack (Pretty.str id) ps) end; 
15259  288 
fun get_name (Type (tname, _)) = tname 
289 
 get_name _ = ""; 

290 
fun lookup f T = if_none (apsome f (Symtab.lookup 

291 
(TypedefData.get thy, get_name T))) "" 

292 
in 

293 
(case strip_comb t of 

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

295 
if lookup #4 T = s andalso 

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

297 
then mk_fun s T ts 

298 
else if lookup #3 U = s andalso 

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

300 
then mk_fun s U ts 

15531  301 
else NONE 
302 
 _ => NONE) 

15259  303 
end; 
304 

305 
fun mk_tyexpr [] s = Pretty.str s 

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

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

308 

309 
fun typedef_tycodegen thy gr dep brack (Type (s, Ts)) = 

310 
(case Symtab.lookup (TypedefData.get thy, s) of 

15531  311 
NONE => NONE 
312 
 SOME (newT as Type (tname, Us), oldT, Abs_name, Rep_name) => 

313 
if is_some (Codegen.get_assoc_type thy tname) then NONE else 

15259  314 
let 
315 
val sg = sign_of thy; 

316 
val Abs_id = Codegen.mk_const_id sg Abs_name; 

317 
val Rep_id = Codegen.mk_const_id sg Rep_name; 

318 
val ty_id = Codegen.mk_type_id sg s; 

319 
val (gr', qs) = foldl_map 

320 
(Codegen.invoke_tycodegen thy dep (length Ts = 1)) (gr, Ts); 

321 
val gr'' = Graph.add_edge (Abs_id, dep) gr' handle Graph.UNDEF _ => 

322 
let 

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

324 
(Codegen.invoke_tycodegen thy Abs_id false) 

325 
(Graph.add_edge (Abs_id, dep) 

15531  326 
(Graph.new_node (Abs_id, (NONE, "")) gr'), oldT :: Us); 
15259  327 
val s = 
328 
Pretty.string_of (Pretty.block [Pretty.str "datatype ", 

329 
mk_tyexpr ps ty_id, 

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

337 
Codegen.mk_term_of sg false newT, Pretty.brk 1, 

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, 

343 
Codegen.mk_term_of sg false oldT, Pretty.brk 1, 

344 
Pretty.str "x;"]) ^ "\n\n" 

345 
else "") ^ 

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

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

348 
Codegen.mk_gen sg false [] "" newT, Pretty.brk 1, 

349 
Pretty.str "i =", Pretty.brk 1, 

350 
Pretty.block [Pretty.str (Abs_id ^ " ("), 

351 
Codegen.mk_gen sg false [] "" oldT, Pretty.brk 1, 

352 
Pretty.str "i);"]]) ^ "\n\n" 

353 
else "") 

15531  354 
in Graph.map_node Abs_id (K (NONE, s)) gr'' end 
15259  355 
in 
15531  356 
SOME (gr'', mk_tyexpr qs ty_id) 
15259  357 
end) 
15531  358 
 typedef_tycodegen thy gr dep brack _ = NONE; 
15259  359 

360 
val setup = 

361 
[TypedefData.init, 

362 
Codegen.add_codegen "typedef" typedef_codegen, 

363 
Codegen.add_tycodegen "typedef" typedef_tycodegen]; 

364 

365 

366 

6383  367 
(** outer syntax **) 
368 

6723  369 
local structure P = OuterParse and K = OuterSyntax.Keyword in 
6383  370 

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

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

6723  376 

6383  377 
val typedef_proof_decl = 
13443  378 
Scan.optional (P.$$$ "("  P.!!! 
15531  379 
(((P.$$$ "open" >> K false)  Scan.option P.name  P.name >> (fn s => (true, SOME s))) 
380 
 P.$$$ ")")) (true, NONE)  

11744  381 
(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

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

13443  384 
fun mk_typedef_proof ((((((def, opt_name), (vs, t)), mx), A), morphs)) = 
385 
typedef_proof ((def, if_none opt_name (Syntax.type_name t mx)), (t, vs, mx), A, morphs); 

6357  386 

387 
val typedefP = 

6723  388 
OuterSyntax.command "typedef" "HOL type definition (requires nonemptiness proof)" K.thy_goal 
6383  389 
(typedef_proof_decl >> (Toplevel.print oo (Toplevel.theory_to_proof o mk_typedef_proof))); 
6357  390 

6723  391 

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

4866  395 
end; 
6383  396 

397 
end; 