author  paulson 
Thu, 24 Oct 1996 10:42:42 +0200  
changeset 2126  d927beecedf8 
parent 1928  3d1d73e3d185 
child 2169  31ba286f2307 
permissions  rwrr 
1460  1 
(* Title: Pure/goals.ML 
0  2 
ID: $Id$ 
1460  3 
Author: Lawrence C Paulson, Cambridge University Computer Laboratory 
0  4 
Copyright 1993 University of Cambridge 
5 

6 
Goal stack package. The goal stack initially holds a dummy proof, and can 

7 
never become empty. Each goal stack consists of a list of levels. The 

8 
undo list is a list of goal stacks. Finally, there may be a stack of 

9 
pending proofs. 

10 
*) 

11 

12 

13 
signature GOALS = 

14 
sig 

15 
type proof 

1460  16 
val ba : int > unit 
17 
val back : unit > unit 

18 
val bd : thm > int > unit 

19 
val bds : thm list > int > unit 

20 
val be : thm > int > unit 

21 
val bes : thm list > int > unit 

22 
val br : thm > int > unit 

23 
val brs : thm list > int > unit 

24 
val bw : thm > unit 

25 
val bws : thm list > unit 

26 
val by : tactic > unit 

27 
val byev : tactic list > unit 

28 
val chop : unit > unit 

29 
val choplev : int > unit 

30 
val fa : unit > unit 

31 
val fd : thm > unit 

32 
val fds : thm list > unit 

33 
val fe : thm > unit 

34 
val fes : thm list > unit 

35 
val filter_goal : (term*term>bool) > thm list > int > thm list 

36 
val fr : thm > unit 

37 
val frs : thm list > unit 

38 
val getgoal : int > term 

39 
val gethyps : int > thm list 

40 
val goal : theory > string > thm list 

41 
val goalw : theory > thm list > string > thm list 

42 
val goalw_cterm : thm list > cterm > thm list 

43 
val pop_proof : unit > thm list 

44 
val pr : unit > unit 

1628
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

45 
val pr_latex : unit > unit 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

46 
val printgoal_latex : int > unit 
1460  47 
val premises : unit > thm list 
48 
val prin : term > unit 

49 
val printyp : typ > unit 

50 
val pprint_term : term > pprint_args > unit 

51 
val pprint_typ : typ > pprint_args > unit 

52 
val print_exn : exn > 'a 

53 
val print_sign_exn : Sign.sg > exn > 'a 

54 
val prlev : int > unit 

55 
val proof_timing : bool ref 

56 
val prove_goal : theory > string > (thm list > tactic list) > thm 

577  57 
val prove_goalw : theory>thm list>string>(thm list>tactic list)>thm 
1460  58 
val prove_goalw_cterm : thm list>cterm>(thm list>tactic list)>thm 
59 
val push_proof : unit > unit 

60 
val read : string > term 

61 
val ren : string > int > unit 

62 
val restore_proof : proof > thm list 

63 
val result : unit > thm 

1928  64 
val result_error_ref : (thm > string > thm) ref 
1460  65 
val rotate_proof : unit > thm list 
66 
val uresult : unit > thm 

67 
val save_proof : unit > proof 

68 
val topthm : unit > thm 

69 
val undo : unit > unit 

0  70 
end; 
71 

1500  72 
structure Goals : GOALS = 
0  73 
struct 
74 

75 
(*Each level of goal stack includes a proof state and alternative states, 

76 
the output of the tactic applied to the preceeding level. *) 

77 
type gstack = (thm * thm Sequence.seq) list; 

78 

79 
datatype proof = Proof of gstack list * thm list * (bool*thm>thm); 

80 

81 
(*** References ***) 

82 

83 
(*Should process time be printed after proof steps?*) 

84 
val proof_timing = ref false; 

85 

86 
(*Current assumption list  set by "goal".*) 

87 
val curr_prems = ref([] : thm list); 

88 

89 
(*Return assumption list  useful if you didn't save "goal"'s result. *) 

90 
fun premises() = !curr_prems; 

91 

92 
(*Current result maker  set by "goal", used by "result". *) 

93 
val curr_mkresult = 

94 
ref((fn _=> error"No goal has been supplied in subgoal module") 

95 
: bool*thm>thm); 

96 

922
196ca0973a6d
added CPure (curried functions) and ProtoPure (ancestor of Pure and CPure)
clasohm
parents:
914
diff
changeset

97 
val dummy = trivial(read_cterm Sign.proto_pure 
0  98 
("PROP No_goal_has_been_supplied",propT)); 
99 

100 
(*List of previous goal stacks, for the undo operation. Set by setstate. 

101 
A list of lists!*) 

102 
val undo_list = ref([[(dummy, Sequence.null)]] : gstack list); 

103 

104 
(* Stack of proof attempts *) 

105 
val proofstack = ref([]: proof list); 

106 

107 

108 
(*** Setting up goaldirected proof ***) 

109 

110 
(*Generates the list of new theories when the proof state's signature changes*) 

111 
fun sign_error (sign,sign') = 

112 
let val stamps = #stamps(Sign.rep_sg sign') \\ 

113 
#stamps(Sign.rep_sg sign) 

114 
in case stamps of 

115 
[stamp] => "\nNew theory: " ^ !stamp 

116 
 _ => "\nNew theories: " ^ space_implode ", " (map ! stamps) 

117 
end; 

118 

1928  119 
(*Default action is to print an error message; could be suppressed for 
120 
special applications.*) 

121 
fun result_error_default state msg : thm = 

122 
(writeln ("Bad final proof state:"); 

123 
!print_goals_ref (!goals_limit) state; 

124 
error msg); 

125 

126 
val result_error_ref = ref result_error_default; 

127 

0  128 
(*Common treatment of "goal" and "prove_goal": 
129 
Return assumptions, initial proof state, and function to make result. *) 

130 
fun prepare_proof rths chorn = 

230  131 
let val {sign, t=horn,...} = rep_cterm chorn; 
0  132 
val (_,As,B) = Logic.strip_horn(horn); 
230  133 
val cAs = map (cterm_of sign) As; 
1413  134 
val prems = map (rewrite_rule rths o forall_elim_vars(0) o assume) cAs 
135 
and st0 = (rewrite_goals_rule rths o trivial) (cterm_of sign B) 

0  136 
(*discharges assumptions from state in the order they appear in goal; 
1460  137 
checks (if requested) that resulting theorem is equivalent to goal. *) 
0  138 
fun mkresult (check,state) = 
696
eb5b42442b14
Pure/goals/prepare_proof/mkresult: now smashes flexflex pairs in the final
lcp
parents:
678
diff
changeset

139 
let val state = Sequence.hd (flexflex_rule state) 
1565  140 
handle THM _ => state (*smash flexflex pairs*) 
1460  141 
val ngoals = nprems_of state 
1219  142 
val th = strip_shyps (implies_intr_list cAs state) 
1240  143 
val {hyps,prop,sign=sign',...} = rep_thm th 
144 
val xshyps = extra_shyps th; 

0  145 
in if not check then standard th 
1928  146 
else if not (Sign.eq_sg(sign,sign')) then !result_error_ref state 
1460  147 
("Signature of proof state has changed!" ^ 
148 
sign_error (sign,sign')) 

1928  149 
else if ngoals>0 then !result_error_ref state 
1460  150 
(string_of_int ngoals ^ " unsolved goals!") 
1928  151 
else if not (null hyps) then !result_error_ref state 
0  152 
("Additional hypotheses:\n" ^ 
153 
cat_lines (map (Sign.string_of_term sign) hyps)) 

1928  154 
else if not (null xshyps) then !result_error_ref state 
1240  155 
("Extra sort hypotheses: " ^ 
1500  156 
commas (map Type.str_of_sort xshyps)) 
1460  157 
else if Pattern.matches (#tsig(Sign.rep_sg sign)) 
158 
(term_of chorn, prop) 

159 
then standard th 

1928  160 
else !result_error_ref state "proved a different theorem" 
0  161 
end 
678
6151b7f3b606
Modified pattern.ML to perform proper matching of HigherOrder Patterns.
nipkow
parents:
577
diff
changeset

162 
in 
6151b7f3b606
Modified pattern.ML to perform proper matching of HigherOrder Patterns.
nipkow
parents:
577
diff
changeset

163 
if Sign.eq_sg(sign, #sign(rep_thm st0)) 
0  164 
then (prems, st0, mkresult) 
165 
else error ("Definitions would change the proof state's signature" ^ 

1460  166 
sign_error (sign, #sign(rep_thm st0))) 
0  167 
end 
168 
handle THM(s,_,_) => error("prepare_proof: exception THM was raised!\n" ^ s); 

169 

170 
(*Prints exceptions readably to users*) 

577  171 
fun print_sign_exn_unit sign e = 
0  172 
case e of 
173 
THM (msg,i,thms) => 

1460  174 
(writeln ("Exception THM " ^ string_of_int i ^ " raised:\n" ^ msg); 
175 
seq print_thm thms) 

0  176 
 THEORY (msg,thys) => 
1460  177 
(writeln ("Exception THEORY raised:\n" ^ msg); 
178 
seq print_theory thys) 

0  179 
 TERM (msg,ts) => 
1460  180 
(writeln ("Exception TERM raised:\n" ^ msg); 
181 
seq (writeln o Sign.string_of_term sign) ts) 

0  182 
 TYPE (msg,Ts,ts) => 
1460  183 
(writeln ("Exception TYPE raised:\n" ^ msg); 
184 
seq (writeln o Sign.string_of_typ sign) Ts; 

185 
seq (writeln o Sign.string_of_term sign) ts) 

0  186 
 e => raise e; 
187 

577  188 
(*Prints an exception, then fails*) 
189 
fun print_sign_exn sign e = (print_sign_exn_unit sign e; raise ERROR); 

190 

0  191 
(** the prove_goal.... commands 
192 
Prove theorem using the listed tactics; check it has the specified form. 

193 
Augment signature with all type assignments of goal. 

194 
Syntax is similar to "goal" command for easy keyboard use. **) 

195 

196 
(*Version taking the goal as a cterm*) 

197 
fun prove_goalw_cterm rths chorn tacsf = 

198 
let val (prems, st0, mkresult) = prepare_proof rths chorn 

199 
val tac = EVERY (tacsf prems) 

200 
fun statef() = 

1500  201 
(case Sequence.pull (tac st0) of 
1460  202 
Some(st,_) => st 
203 
 _ => error ("prove_goal: tactic failed")) 

545
fc4ff96bb0e9
Pure/goals.ML: prove_goalw_cterm now does its own exceptionhandling, moved
lcp
parents:
253
diff
changeset

204 
in mkresult (true, cond_timeit (!proof_timing) statef) end 
914
cae574c09137
Now prove_goalw_cterm calls print_sign_exn_unit, so that the rest
lcp
parents:
696
diff
changeset

205 
handle e => (print_sign_exn_unit (#sign (rep_cterm chorn)) e; 
1460  206 
error ("The exception above was raised for\n" ^ 
207 
string_of_cterm chorn)); 

545
fc4ff96bb0e9
Pure/goals.ML: prove_goalw_cterm now does its own exceptionhandling, moved
lcp
parents:
253
diff
changeset

208 

0  209 

210 
(*Version taking the goal as a string*) 

211 
fun prove_goalw thy rths agoal tacsf = 

212 
let val sign = sign_of thy 

230  213 
val chorn = read_cterm sign (agoal,propT) 
545
fc4ff96bb0e9
Pure/goals.ML: prove_goalw_cterm now does its own exceptionhandling, moved
lcp
parents:
253
diff
changeset

214 
in prove_goalw_cterm rths chorn tacsf end 
fc4ff96bb0e9
Pure/goals.ML: prove_goalw_cterm now does its own exceptionhandling, moved
lcp
parents:
253
diff
changeset

215 
handle ERROR => error (*from read_cterm?*) 
1460  216 
("The error above occurred for " ^ quote agoal); 
0  217 

218 
(*String version with no metarewriterules*) 

219 
fun prove_goal thy = prove_goalw thy []; 

220 

221 

222 
(*** Commands etc ***) 

223 

224 
(*Return the current goal stack, if any, from undo_list*) 

225 
fun getstate() : gstack = case !undo_list of 

226 
[] => error"No current state in subgoal module" 

227 
 x::_ => x; 

228 

229 
(*Pops the given goal stack*) 

230 
fun pop [] = error"Cannot go back past the beginning of the proof!" 

231 
 pop (pair::pairs) = (pair,pairs); 

232 

233 

234 
(*Print a level of the goal stack.*) 

235 
fun print_top ((th,_), pairs) = 

236 
(prs("Level " ^ string_of_int(length pairs) ^ "\n"); 

68
d8f380764934
goals/print_top,prepare_proof: now call \!print_goals_ref
lcp
parents:
39
diff
changeset

237 
!print_goals_ref (!goals_limit) th); 
0  238 

239 
(*Printing can raise exceptions, so the assignment occurs last. 

240 
Can do setstate[(st,Sequence.null)] to set st as the state. *) 

241 
fun setstate newgoals = 

242 
(print_top (pop newgoals); undo_list := newgoals :: !undo_list); 

243 

244 
(*Given a proof state transformation, return a command that updates 

245 
the goal stack*) 

246 
fun make_command com = setstate (com (pop (getstate()))); 

247 

248 
(*Apply a function on proof states to the current goal stack*) 

249 
fun apply_fun f = f (pop(getstate())); 

250 

251 
(*Return the top theorem, representing the proof state*) 

252 
fun topthm () = apply_fun (fn ((th,_), _) => th); 

253 

254 
(*Return the final result. *) 

255 
fun result () = !curr_mkresult (true, topthm()); 

256 

257 
(*Return the result UNCHECKED that it equals the goal  for synthesis, 

258 
answer extraction, or other instantiation of Vars *) 

259 
fun uresult () = !curr_mkresult (false, topthm()); 

260 

261 
(*Get subgoal i from goal stack*) 

262 
fun getgoal i = 

263 
(case drop (i1, prems_of (topthm())) of 

1460  264 
[] => error"getgoal: Goal number out of range" 
265 
 Q::_ => Q); 

0  266 

267 
(*Return subgoal i's hypotheses as metalevel assumptions. 

268 
For debugging uses of METAHYPS*) 

269 
local exception GETHYPS of thm list 

270 
in 

271 
fun gethyps i = 

1500  272 
(METAHYPS (fn hyps => raise (GETHYPS hyps)) i (topthm()); []) 
0  273 
handle GETHYPS hyps => hyps 
274 
end; 

275 

276 
(*Which thms could apply to goal i? (debugs tactics involving filter_thms) *) 

277 
fun filter_goal could ths i = filter_thms could (999, getgoal i, ths); 

278 

279 
(*For inspecting earlier levels of the backward proof*) 

280 
fun chop_level n (pair,pairs) = 

281 
let val level = length pairs 

2126
d927beecedf8
Allowing negative levels (as offsets) in prlev and choplev
paulson
parents:
1928
diff
changeset

282 
in if n<0 andalso ~n <= level 
d927beecedf8
Allowing negative levels (as offsets) in prlev and choplev
paulson
parents:
1928
diff
changeset

283 
then drop (~n, pair::pairs) 
d927beecedf8
Allowing negative levels (as offsets) in prlev and choplev
paulson
parents:
1928
diff
changeset

284 
else if 0<=n andalso n<= level 
0  285 
then drop (level  n, pair::pairs) 
286 
else error ("Level number must lie between 0 and " ^ 

1460  287 
string_of_int level) 
0  288 
end; 
289 

290 
(*Print the given level of the proof*) 

291 
fun prlev n = apply_fun (print_top o pop o (chop_level n)); 

292 
fun pr () = apply_fun print_top; 

293 

294 
(** the goal.... commands 

295 
Read main goal. Set global variables curr_prems, curr_mkresult. 

296 
Initial subgoal and premises are rewritten using rths. **) 

297 

298 
(*Version taking the goal as a cterm; if you have a term t and theory thy, use 

230  299 
goalw_cterm rths (cterm_of (sign_of thy) t); *) 
0  300 
fun goalw_cterm rths chorn = 
301 
let val (prems, st0, mkresult) = prepare_proof rths chorn 

302 
in undo_list := []; 

303 
setstate [ (st0, Sequence.null) ]; 

304 
curr_prems := prems; 

305 
curr_mkresult := mkresult; 

306 
prems 

307 
end; 

308 

309 
(*Version taking the goal as a string*) 

310 
fun goalw thy rths agoal = 

230  311 
goalw_cterm rths (read_cterm(sign_of thy)(agoal,propT)) 
0  312 
handle ERROR => error (*from type_assign, etc via prepare_proof*) 
1460  313 
("The error above occurred for " ^ quote agoal); 
0  314 

315 
(*String version with no metarewriterules*) 

316 
fun goal thy = goalw thy []; 

317 

318 
(*Proof step "by" the given tactic  apply tactic to the proof state*) 

319 
fun by_com tac ((th,ths), pairs) : gstack = 

1500  320 
(case Sequence.pull(tac th) of 
0  321 
None => error"by: tactic failed" 
322 
 Some(th2,ths2) => 

323 
(if eq_thm(th,th2) 

1580
e3fd931e6095
Added some functions which allow redirection of Isabelle's output
berghofe
parents:
1565
diff
changeset

324 
then warning "same as previous level" 
1460  325 
else if eq_thm_sg(th,th2) then () 
1580
e3fd931e6095
Added some functions which allow redirection of Isabelle's output
berghofe
parents:
1565
diff
changeset

326 
else warning("signature of proof state has changed" ^ 
1460  327 
sign_error (#sign(rep_thm th), #sign(rep_thm th2))); 
0  328 
((th2,ths2)::(th,ths)::pairs))); 
329 

330 
fun by tac = cond_timeit (!proof_timing) 

331 
(fn() => make_command (by_com tac)); 

332 

333 
(* byev[tac1,...,tacn] applies tac1 THEN ... THEN tacn. 

334 
Good for debugging proofs involving prove_goal.*) 

335 
val byev = by o EVERY; 

336 

337 

338 
(*Backtracking means find an alternative result from a tactic. 

339 
If none at this level, try earlier levels*) 

340 
fun backtrack [] = error"back: no alternatives" 

341 
 backtrack ((th,thstr) :: pairs) = 

342 
(case Sequence.pull thstr of 

1460  343 
None => (writeln"Going back a level..."; backtrack pairs) 
344 
 Some(th2,thstr2) => 

345 
(if eq_thm(th,th2) 

1580
e3fd931e6095
Added some functions which allow redirection of Isabelle's output
berghofe
parents:
1565
diff
changeset

346 
then warning "same as previous choice at this level" 
1460  347 
else if eq_thm_sg(th,th2) then () 
1580
e3fd931e6095
Added some functions which allow redirection of Isabelle's output
berghofe
parents:
1565
diff
changeset

348 
else warning "signature of proof state has changed"; 
1460  349 
(th2,thstr2)::pairs)); 
0  350 

351 
fun back() = setstate (backtrack (getstate())); 

352 

353 
(*Chop back to previous level of the proof*) 

354 
fun choplev n = make_command (chop_level n); 

355 

356 
(*Chopping back the goal stack*) 

357 
fun chop () = make_command (fn (_,pairs) => pairs); 

358 

359 
(*Restore the previous proof state; discard current state. *) 

360 
fun undo() = case !undo_list of 

361 
[] => error"No proof state" 

362 
 [_] => error"Already at initial state" 

363 
 _::newundo => (undo_list := newundo; pr()) ; 

364 

365 

366 
(*** Managing the proof stack ***) 

367 

368 
fun save_proof() = Proof(!undo_list, !curr_prems, !curr_mkresult); 

369 

370 
fun restore_proof(Proof(ul,prems,mk)) = 

371 
(undo_list:= ul; curr_prems:= prems; curr_mkresult := mk; prems); 

372 

373 

374 
fun top_proof() = case !proofstack of 

1460  375 
[] => error("Stack of proof attempts is empty!") 
0  376 
 p::ps => (p,ps); 
377 

378 
(* push a copy of the current proof state on to the stack *) 

379 
fun push_proof() = (proofstack := (save_proof() :: !proofstack)); 

380 

381 
(* discard the top proof state of the stack *) 

382 
fun pop_proof() = 

383 
let val (p,ps) = top_proof() 

384 
val prems = restore_proof p 

385 
in proofstack := ps; pr(); prems end; 

386 

387 
(* rotate the stack so that the top element goes to the bottom *) 

388 
fun rotate_proof() = let val (p,ps) = top_proof() 

1460  389 
in proofstack := ps@[save_proof()]; 
390 
restore_proof p; 

391 
pr(); 

392 
!curr_prems 

393 
end; 

0  394 

395 

396 
(** Shortcuts for commonlyused tactics **) 

397 

398 
fun bws rls = by (rewrite_goals_tac rls); 

399 
fun bw rl = bws [rl]; 

400 

401 
fun brs rls i = by (resolve_tac rls i); 

402 
fun br rl = brs [rl]; 

403 

404 
fun bes rls i = by (eresolve_tac rls i); 

405 
fun be rl = bes [rl]; 

406 

407 
fun bds rls i = by (dresolve_tac rls i); 

408 
fun bd rl = bds [rl]; 

409 

410 
fun ba i = by (assume_tac i); 

411 

412 
fun ren str i = by (rename_tac str i); 

413 

414 
(** Shortcuts to work on the first applicable subgoal **) 

415 

416 
fun frs rls = by (FIRSTGOAL (trace_goalno_tac (resolve_tac rls))); 

417 
fun fr rl = frs [rl]; 

418 

419 
fun fes rls = by (FIRSTGOAL (trace_goalno_tac (eresolve_tac rls))); 

420 
fun fe rl = fes [rl]; 

421 

422 
fun fds rls = by (FIRSTGOAL (trace_goalno_tac (dresolve_tac rls))); 

423 
fun fd rl = fds [rl]; 

424 

425 
fun fa() = by (FIRSTGOAL (trace_goalno_tac assume_tac)); 

426 

427 
(** Reading and printing terms wrt the current theory **) 

428 

429 
fun top_sg() = #sign(rep_thm(topthm())); 

430 

230  431 
fun read s = term_of (read_cterm (top_sg()) 
1460  432 
(s, (TVar(("DUMMY",0),[])))); 
0  433 

434 
(*Print a term under the current signature of the proof state*) 

435 
fun prin t = writeln (Sign.string_of_term (top_sg()) t); 

436 

437 
fun printyp T = writeln (Sign.string_of_typ (top_sg()) T); 

438 

439 
fun pprint_term t = Sign.pprint_term (top_sg()) t; 

440 

441 
fun pprint_typ T = Sign.pprint_typ (top_sg()) T; 

442 

1628
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

443 
(* Redirect output of function f:unit>unit to LaTeX *) 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

444 
fun redirect_to_latex f = 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

445 
let 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

446 
val s = ref "" 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

447 
val old_prs_fn = !prs_fn 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

448 
in 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

449 
(prs_fn := (fn a => s := !s ^ a); 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

450 
f (); 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

451 
latex (!s); 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

452 
prs_fn := old_prs_fn) 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

453 
end; 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

454 

60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

455 
(* Display current proof state in xdvi window *) 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

456 
fun pr_latex () = redirect_to_latex pr; 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

457 

60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

458 
(* Display goal n of current proof state in xdvi window *) 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

459 
fun printgoal_latex n = redirect_to_latex (fn () => prin(getgoal n)); 
60136fdd80c4
Added functions pr_latex and printgoal_latex which
berghofe
parents:
1580
diff
changeset

460 

0  461 
(*Prints exceptions nicely at top level; 
462 
raises the exception in order to have a polymorphic type!*) 

914
cae574c09137
Now prove_goalw_cterm calls print_sign_exn_unit, so that the rest
lcp
parents:
696
diff
changeset

463 
fun print_exn e = (print_sign_exn_unit (top_sg()) e; raise e); 
0  464 

465 
end; 

1500  466 

467 
open Goals; 