author | blanchet |
Mon, 03 Feb 2014 17:13:31 +0100 | |
changeset 55288 | 1a4358d14ce2 |
parent 55287 | ffa306239316 |
child 55297 | 1dfcd49f5dcb |
permissions | -rw-r--r-- |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
1 |
(* Title: HOL/Tools/Sledgehammer/sledgehammer_prover_minimize.ML |
31037
ac8669134e7a
added Philipp Meyer's implementation of AtpMinimal
immler@in.tum.de
parents:
diff
changeset
|
2 |
Author: Philipp Meyer, TU Muenchen |
36370
a4f601daa175
centralized ATP-specific error handling in "atp_wrapper.ML"
blanchet
parents:
36369
diff
changeset
|
3 |
Author: Jasmin Blanchette, TU Muenchen |
31037
ac8669134e7a
added Philipp Meyer's implementation of AtpMinimal
immler@in.tum.de
parents:
diff
changeset
|
4 |
|
40977 | 5 |
Minimization of fact list for Metis using external provers. |
31037
ac8669134e7a
added Philipp Meyer's implementation of AtpMinimal
immler@in.tum.de
parents:
diff
changeset
|
6 |
*) |
ac8669134e7a
added Philipp Meyer's implementation of AtpMinimal
immler@in.tum.de
parents:
diff
changeset
|
7 |
|
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
8 |
signature SLEDGEHAMMER_PROVER_MINIMIZE = |
32525 | 9 |
sig |
46340 | 10 |
type stature = ATP_Problem_Generate.stature |
55287 | 11 |
type proof_method = Sledgehammer_Proof_Methods.proof_method |
12 |
type play_outcome = Sledgehammer_Proof_Methods.play_outcome |
|
55201 | 13 |
type mode = Sledgehammer_Prover.mode |
14 |
type params = Sledgehammer_Prover.params |
|
15 |
type prover = Sledgehammer_Prover.prover |
|
35867 | 16 |
|
55205 | 17 |
val is_prover_supported : Proof.context -> string -> bool |
18 |
val is_prover_installed : Proof.context -> string -> bool |
|
19 |
val default_max_facts_of_prover : Proof.context -> string -> int |
|
20 |
val get_prover : Proof.context -> mode -> string -> prover |
|
21 |
||
42646
4781fcd53572
replaced some Unsynchronized.refs with Config.Ts
blanchet
parents:
42579
diff
changeset
|
22 |
val binary_min_facts : int Config.T |
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
23 |
val auto_minimize_min_facts : int Config.T |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
24 |
val auto_minimize_max_time : real Config.T |
54824 | 25 |
val minimize_facts : (thm list -> unit) -> string -> params -> bool -> int -> int -> |
55285 | 26 |
Proof.state -> thm -> (proof_method * play_outcome) Lazy.lazy option -> |
54824 | 27 |
((string * stature) * thm list) list -> |
28 |
((string * stature) * thm list) list option |
|
55285 | 29 |
* ((proof_method * play_outcome) Lazy.lazy * ((proof_method * play_outcome) -> string) |
30 |
* string) |
|
54503 | 31 |
val get_minimizing_prover : Proof.context -> mode -> (thm list -> unit) -> string -> prover |
55205 | 32 |
|
54503 | 33 |
val run_minimize : params -> (thm list -> unit) -> int -> (Facts.ref * Attrib.src list) list -> |
34 |
Proof.state -> unit |
|
35866
513074557e06
move the Sledgehammer Isar commands together into one file;
blanchet
parents:
35865
diff
changeset
|
35 |
end; |
32525 | 36 |
|
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
37 |
structure Sledgehammer_Prover_Minimize : SLEDGEHAMMER_PROVER_MINIMIZE = |
31037
ac8669134e7a
added Philipp Meyer's implementation of AtpMinimal
immler@in.tum.de
parents:
diff
changeset
|
38 |
struct |
ac8669134e7a
added Philipp Meyer's implementation of AtpMinimal
immler@in.tum.de
parents:
diff
changeset
|
39 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
40 |
open ATP_Util |
39496
a52a4e4399c1
got caught once again by SML's pattern maching (ctor vs. var)
blanchet
parents:
39491
diff
changeset
|
41 |
open ATP_Proof |
46320 | 42 |
open ATP_Problem_Generate |
55212 | 43 |
open ATP_Proof_Reconstruct |
51200
260cb10aac4b
minimize SMT proofs with E if Isar proofs are desired and Metis managed to preplay
blanchet
parents:
51191
diff
changeset
|
44 |
open ATP_Systems |
36142
f5e15e9aae10
make Sledgehammer "minimize" output less confusing + round up (not down) time limits to nearest second
blanchet
parents:
36063
diff
changeset
|
45 |
open Sledgehammer_Util |
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
46 |
open Sledgehammer_Fact |
55287 | 47 |
open Sledgehammer_Proof_Methods |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
48 |
open Sledgehammer_Isar |
55201 | 49 |
open Sledgehammer_Prover |
55205 | 50 |
open Sledgehammer_Prover_ATP |
51 |
open Sledgehammer_Prover_SMT |
|
52 |
||
55285 | 53 |
fun run_proof_method mode name (params as {debug, verbose, timeout, type_enc, lam_trans, ...}) |
55212 | 54 |
minimize_command |
55 |
({state, subgoal, subgoal_count, factss = (_, facts) :: _, ...} : prover_problem) = |
|
56 |
let |
|
55285 | 57 |
val meth = |
58 |
if name = metisN then Metis_Method (type_enc, lam_trans) |
|
59 |
else if name = smtN then SMT_Method |
|
60 |
else raise Fail ("unknown proof_method: " ^ quote name) |
|
55212 | 61 |
val used_facts = facts |> map fst |
62 |
in |
|
63 |
(case play_one_line_proof (if mode = Minimize then Normal else mode) debug verbose timeout facts |
|
55285 | 64 |
state subgoal meth [meth] of |
55212 | 65 |
play as (_, Played time) => |
66 |
{outcome = NONE, used_facts = used_facts, used_from = facts, run_time = time, |
|
67 |
preplay = Lazy.value play, |
|
68 |
message = |
|
69 |
fn play => |
|
70 |
let |
|
55285 | 71 |
val (_, override_params) = extract_proof_method params meth |
55212 | 72 |
val one_line_params = |
73 |
(play, proof_banner mode name, used_facts, minimize_command override_params name, |
|
74 |
subgoal, subgoal_count) |
|
75 |
val num_chained = length (#facts (Proof.goal state)) |
|
76 |
in |
|
77 |
one_line_proof_text num_chained one_line_params |
|
78 |
end, |
|
79 |
message_tail = ""} |
|
80 |
| play => |
|
81 |
let |
|
82 |
val failure = (case play of (_, Play_Failed) => GaveUp | _ => TimedOut) |
|
83 |
in |
|
84 |
{outcome = SOME failure, used_facts = [], used_from = [], |
|
85 |
run_time = Time.zeroTime, preplay = Lazy.value play, |
|
86 |
message = fn _ => string_of_atp_failure failure, message_tail = ""} |
|
87 |
end) |
|
88 |
end |
|
89 |
||
55205 | 90 |
fun is_prover_supported ctxt = |
91 |
let val thy = Proof_Context.theory_of ctxt in |
|
55285 | 92 |
is_proof_method orf is_atp thy orf is_smt_prover ctxt |
55205 | 93 |
end |
94 |
||
95 |
fun is_prover_installed ctxt = |
|
55285 | 96 |
is_proof_method orf is_smt_prover ctxt orf is_atp_installed (Proof_Context.theory_of ctxt) |
55205 | 97 |
|
55285 | 98 |
val proof_method_default_max_facts = 20 |
55205 | 99 |
|
100 |
fun default_max_facts_of_prover ctxt name = |
|
101 |
let val thy = Proof_Context.theory_of ctxt in |
|
55285 | 102 |
if is_proof_method name then |
103 |
proof_method_default_max_facts |
|
55205 | 104 |
else if is_atp thy name then |
105 |
fold (Integer.max o fst o #1 o fst o snd) (#best_slices (get_atp thy name ()) ctxt) 0 |
|
106 |
else (* is_smt_prover ctxt name *) |
|
107 |
SMT_Solver.default_max_relevant ctxt name |
|
108 |
end |
|
109 |
||
110 |
fun get_prover ctxt mode name = |
|
111 |
let val thy = Proof_Context.theory_of ctxt in |
|
55285 | 112 |
if is_proof_method name then run_proof_method mode name |
55205 | 113 |
else if is_atp thy name then run_atp mode name |
114 |
else if is_smt_prover ctxt name then run_smt_solver mode name |
|
115 |
else error ("No such prover: " ^ name ^ ".") |
|
116 |
end |
|
35866
513074557e06
move the Sledgehammer Isar commands together into one file;
blanchet
parents:
35865
diff
changeset
|
117 |
|
36370
a4f601daa175
centralized ATP-specific error handling in "atp_wrapper.ML"
blanchet
parents:
36369
diff
changeset
|
118 |
(* wrapper for calling external prover *) |
31236 | 119 |
|
40061
71cc5aac8b76
generalization of the Sledgehammer minimizer, to make it possible to handle SMT solvers as well
blanchet
parents:
40060
diff
changeset
|
120 |
fun n_facts names = |
38698
d19c3a7ce38b
clean handling of whether a fact is chained or not;
blanchet
parents:
38696
diff
changeset
|
121 |
let val n = length names in |
40061
71cc5aac8b76
generalization of the Sledgehammer minimizer, to make it possible to handle SMT solvers as well
blanchet
parents:
40060
diff
changeset
|
122 |
string_of_int n ^ " fact" ^ plural_s n ^ |
38092
81a003f7de0d
speed up the minimizer by using the time taken for the first iteration as a timeout for the following iterations, and fix a subtle bug in "string_for_failure"
blanchet
parents:
38084
diff
changeset
|
123 |
(if n > 0 then |
48085
ff5e900d7b1a
avoid dumping definitions several times in LEO-II proofs
blanchet
parents:
47531
diff
changeset
|
124 |
": " ^ (names |> map fst |> sort string_ord |> space_implode " ") |
38092
81a003f7de0d
speed up the minimizer by using the time taken for the first iteration as a timeout for the following iterations, and fix a subtle bug in "string_for_failure"
blanchet
parents:
38084
diff
changeset
|
125 |
else |
81a003f7de0d
speed up the minimizer by using the time taken for the first iteration as a timeout for the following iterations, and fix a subtle bug in "string_for_failure"
blanchet
parents:
38084
diff
changeset
|
126 |
"") |
81a003f7de0d
speed up the minimizer by using the time taken for the first iteration as a timeout for the following iterations, and fix a subtle bug in "string_for_failure"
blanchet
parents:
38084
diff
changeset
|
127 |
end |
81a003f7de0d
speed up the minimizer by using the time taken for the first iteration as a timeout for the following iterations, and fix a subtle bug in "string_for_failure"
blanchet
parents:
38084
diff
changeset
|
128 |
|
41091
0afdf5cde874
implicitly call the minimizer for SMT solvers that don't return an unsat core
blanchet
parents:
41090
diff
changeset
|
129 |
fun print silent f = if silent then () else Output.urgent_message (f ()) |
0afdf5cde874
implicitly call the minimizer for SMT solvers that don't return an unsat core
blanchet
parents:
41090
diff
changeset
|
130 |
|
54824 | 131 |
fun test_facts ({debug, verbose, overlord, spy, provers, max_mono_iters, max_new_mono_instances, |
55288
1a4358d14ce2
added 'smt' option to control generation of 'by smt' proofs
blanchet
parents:
55287
diff
changeset
|
132 |
type_enc, strict, lam_trans, uncurried_aliases, isar_proofs, compress_isar, try0_isar, smt, |
54824 | 133 |
preplay_timeout, ...} : params) |
134 |
silent (prover : prover) timeout i n state goal facts = |
|
31236 | 135 |
let |
41277
1369c27c6966
reduce the minimizer slack and add verbose information
blanchet
parents:
41267
diff
changeset
|
136 |
val _ = |
1369c27c6966
reduce the minimizer slack and add verbose information
blanchet
parents:
41267
diff
changeset
|
137 |
print silent (fn () => |
54816
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
138 |
"Testing " ^ n_facts (map fst facts) ^ |
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
139 |
(if verbose then " (timeout: " ^ string_of_time timeout ^ ")" else "") ^ "...") |
51005
ce4290c33d73
eliminated needless speed optimization -- and simplified code quite a bit
blanchet
parents:
50669
diff
changeset
|
140 |
val facts = facts |> maps (fn (n, ths) => map (pair n) ths) |
38100
e458a0dd3dc1
use "explicit_apply" in the minimizer whenever it might make a difference to prevent freak failures;
blanchet
parents:
38094
diff
changeset
|
141 |
val params = |
53800 | 142 |
{debug = debug, verbose = verbose, overlord = overlord, spy = spy, blocking = true, |
143 |
provers = provers, type_enc = type_enc, strict = strict, lam_trans = lam_trans, |
|
144 |
uncurried_aliases = uncurried_aliases, learn = false, fact_filter = NONE, |
|
145 |
max_facts = SOME (length facts), fact_thresholds = (1.01, 1.01), |
|
146 |
max_mono_iters = max_mono_iters, max_new_mono_instances = max_new_mono_instances, |
|
55288
1a4358d14ce2
added 'smt' option to control generation of 'by smt' proofs
blanchet
parents:
55287
diff
changeset
|
147 |
isar_proofs = isar_proofs, compress_isar = compress_isar, try0_isar = try0_isar, smt = smt, |
53800 | 148 |
slice = false, minimize = SOME false, timeout = timeout, preplay_timeout = preplay_timeout, |
149 |
expect = ""} |
|
40065 | 150 |
val problem = |
54141
f57f8e7a879f
generate a comment storing the goal nickname in "learn_prover"
blanchet
parents:
54130
diff
changeset
|
151 |
{comment = "", state = state, goal = goal, subgoal = i, subgoal_count = n, |
f57f8e7a879f
generate a comment storing the goal nickname in "learn_prover"
blanchet
parents:
54130
diff
changeset
|
152 |
factss = [("", facts)]} |
45370
bab52dafa63a
use "Time.time" rather than milliseconds internally
blanchet
parents:
45369
diff
changeset
|
153 |
val result as {outcome, used_facts, run_time, ...} = |
45520 | 154 |
prover params (K (K (K ""))) problem |
36223
217ca1273786
make Sledgehammer's minimizer also minimize Isar proofs
blanchet
parents:
36143
diff
changeset
|
155 |
in |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
156 |
print silent (fn () => |
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
157 |
(case outcome of |
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
158 |
SOME failure => string_of_atp_failure failure |
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
159 |
| NONE => |
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
160 |
"Found proof" ^ |
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
161 |
(if length used_facts = length facts then "" else " with " ^ n_facts used_facts) ^ |
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
162 |
" (" ^ string_of_time run_time ^ ").")); |
38092
81a003f7de0d
speed up the minimizer by using the time taken for the first iteration as a timeout for the following iterations, and fix a subtle bug in "string_for_failure"
blanchet
parents:
38084
diff
changeset
|
163 |
result |
36223
217ca1273786
make Sledgehammer's minimizer also minimize Isar proofs
blanchet
parents:
36143
diff
changeset
|
164 |
end |
31236 | 165 |
|
40204
da97d75e20e6
standardize on "fact" terminology (vs. "axiom" or "theorem") in Sledgehammer -- but keep "Axiom" in the lower-level "ATP_Problem" module
blanchet
parents:
40200
diff
changeset
|
166 |
(* minimalization of facts *) |
31236 | 167 |
|
45372 | 168 |
(* Give the external prover some slack. The ATP gets further slack because the |
169 |
Sledgehammer preprocessing time is included in the estimate below but isn't |
|
170 |
part of the timeout. *) |
|
171 |
val slack_msecs = 200 |
|
172 |
||
54816
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
173 |
fun new_timeout timeout run_time = |
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
174 |
Int.min (Time.toMilliseconds timeout, Time.toMilliseconds run_time + slack_msecs) |
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
175 |
|> Time.fromMilliseconds |
45372 | 176 |
|
45367 | 177 |
(* The linear algorithm usually outperforms the binary algorithm when over 60% |
178 |
of the facts are actually needed. The binary algorithm is much more |
|
179 |
appropriate for provers that cannot return the list of used facts and hence |
|
180 |
returns all facts as used. Since we cannot know in advance how many facts are |
|
181 |
actually needed, we heuristically set the threshold to 10 facts. *) |
|
42646
4781fcd53572
replaced some Unsynchronized.refs with Config.Ts
blanchet
parents:
42579
diff
changeset
|
182 |
val binary_min_facts = |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
183 |
Attrib.setup_config_int @{binding sledgehammer_minimize_binary_min_facts} (K 20) |
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
184 |
val auto_minimize_min_facts = |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
185 |
Attrib.setup_config_int @{binding sledgehammer_auto_minimize_min_facts} |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
186 |
(fn generic => Config.get_generic generic binary_min_facts) |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
187 |
val auto_minimize_max_time = |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
188 |
Attrib.setup_config_real @{binding sledgehammer_auto_minimize_max_time} (K 5.0) |
40977 | 189 |
|
45368 | 190 |
fun linear_minimize test timeout result xs = |
191 |
let |
|
192 |
fun min _ [] p = p |
|
193 |
| min timeout (x :: xs) (seen, result) = |
|
54816
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
194 |
(case test timeout (xs @ seen) of |
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
195 |
result as {outcome = NONE, used_facts, run_time, ...} : prover_result => |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
196 |
min (new_timeout timeout run_time) (filter_used_facts true used_facts xs) |
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
197 |
(filter_used_facts false used_facts seen, result) |
54816
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
198 |
| _ => min timeout xs (x :: seen, result)) |
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
199 |
in |
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
200 |
min timeout xs ([], result) |
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
201 |
end |
38015 | 202 |
|
45368 | 203 |
fun binary_minimize test timeout result xs = |
40977 | 204 |
let |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
205 |
fun min depth (result as {run_time, ...} : prover_result) sup (xs as _ :: _ :: _) = |
41743 | 206 |
let |
45367 | 207 |
val (l0, r0) = chop (length xs div 2) xs |
41743 | 208 |
(* |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
209 |
val _ = warning (replicate_string depth " " ^ "{ " ^ "sup: " ^ n_facts (map fst sup)) |
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
210 |
val _ = warning (replicate_string depth " " ^ " " ^ "xs: " ^ n_facts (map fst xs)) |
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
211 |
val _ = warning (replicate_string depth " " ^ " " ^ "l0: " ^ n_facts (map fst l0)) |
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
212 |
val _ = warning (replicate_string depth " " ^ " " ^ "r0: " ^ n_facts (map fst r0)) |
41743 | 213 |
*) |
45367 | 214 |
val depth = depth + 1 |
45372 | 215 |
val timeout = new_timeout timeout run_time |
41743 | 216 |
in |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
217 |
(case test timeout (sup @ l0) of |
45372 | 218 |
result as {outcome = NONE, used_facts, ...} => |
48798 | 219 |
min depth result (filter_used_facts true used_facts sup) |
220 |
(filter_used_facts true used_facts l0) |
|
45367 | 221 |
| _ => |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
222 |
(case test timeout (sup @ r0) of |
45367 | 223 |
result as {outcome = NONE, used_facts, ...} => |
48798 | 224 |
min depth result (filter_used_facts true used_facts sup) |
225 |
(filter_used_facts true used_facts r0) |
|
45367 | 226 |
| _ => |
227 |
let |
|
228 |
val (sup_r0, (l, result)) = min depth result (sup @ r0) l0 |
|
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
229 |
val (sup, r0) = (sup, r0) |> pairself (filter_used_facts true (map fst sup_r0)) |
45367 | 230 |
val (sup_l, (r, result)) = min depth result (sup @ l) r0 |
48798 | 231 |
val sup = sup |> filter_used_facts true (map fst sup_l) |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
232 |
in (sup, (l @ r, result)) end)) |
40977 | 233 |
end |
41743 | 234 |
(* |
235 |
|> tap (fn _ => warning (replicate_string depth " " ^ "}")) |
|
236 |
*) |
|
45367 | 237 |
| min _ result sup xs = (sup, (xs, result)) |
238 |
in |
|
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
239 |
(case snd (min 0 result [] xs) of |
45372 | 240 |
([x], result as {run_time, ...}) => |
241 |
(case test (new_timeout timeout run_time) [] of |
|
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
242 |
result as {outcome = NONE, ...} => ([], result) |
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
243 |
| _ => ([x], result)) |
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
244 |
| p => p) |
45367 | 245 |
end |
40977 | 246 |
|
54816
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
247 |
fun minimize_facts do_learn prover_name (params as {learn, timeout, ...}) silent i n state goal |
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
248 |
preplay0 facts = |
31236 | 249 |
let |
40941
a3e6f8634a11
replace "smt" prover with specific SMT solvers, e.g. "z3" -- whatever the SMT module gives us
blanchet
parents:
40553
diff
changeset
|
250 |
val ctxt = Proof.context_of state |
54815 | 251 |
val prover = get_prover ctxt (if silent then Auto_Minimize else Minimize) prover_name |
54130
b4e6cd4cab92
thread the goal through instead of relying on unreliable (possibly fake) state
blanchet
parents:
54127
diff
changeset
|
252 |
fun test timeout = test_facts params silent prover timeout i n state goal |
48796
0f94b8b69e79
consider removing chained facts last, so that they're more likely to be kept
blanchet
parents:
48399
diff
changeset
|
253 |
val (chained, non_chained) = List.partition is_fact_chained facts |
48799 | 254 |
(* Push chained facts to the back, so that they are less likely to be |
255 |
kicked out by the linear minimization algorithm. *) |
|
48796
0f94b8b69e79
consider removing chained facts last, so that they're more likely to be kept
blanchet
parents:
48399
diff
changeset
|
256 |
val facts = non_chained @ chained |
31236 | 257 |
in |
54815 | 258 |
(print silent (fn () => "Sledgehammer minimizer: " ^ quote prover_name ^ "."); |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
259 |
(case test timeout facts of |
45371 | 260 |
result as {outcome = NONE, used_facts, run_time, ...} => |
38015 | 261 |
let |
48798 | 262 |
val facts = filter_used_facts true used_facts facts |
45372 | 263 |
val min = |
54815 | 264 |
if length facts >= Config.get ctxt binary_min_facts then binary_minimize |
265 |
else linear_minimize |
|
45368 | 266 |
val (min_facts, {preplay, message, message_tail, ...}) = |
45371 | 267 |
min test (new_timeout timeout run_time) result facts |
48321 | 268 |
in |
269 |
print silent (fn () => cat_lines |
|
270 |
["Minimized to " ^ n_facts (map fst min_facts)] ^ |
|
48796
0f94b8b69e79
consider removing chained facts last, so that they're more likely to be kept
blanchet
parents:
48399
diff
changeset
|
271 |
(case min_facts |> filter is_fact_chained |> length of |
48321 | 272 |
0 => "" |
273 |
| n => "\n(including " ^ string_of_int n ^ " chained)") ^ "."); |
|
54503 | 274 |
(if learn then do_learn (maps snd min_facts) else ()); |
51187
c344cf148e8f
avoid using "smt" for minimization -- better use the prover itself, since then Sledgehammer gets to try metis again and gives the opportunity to output an Isar proof -- and show Isar proof as fallback for SMT proofs
blanchet
parents:
51130
diff
changeset
|
275 |
(SOME min_facts, |
54815 | 276 |
(if is_some preplay0 andalso length min_facts = length facts then the preplay0 |
277 |
else preplay, |
|
51187
c344cf148e8f
avoid using "smt" for minimization -- better use the prover itself, since then Sledgehammer gets to try metis again and gives the opportunity to output an Isar proof -- and show Isar proof as fallback for SMT proofs
blanchet
parents:
51130
diff
changeset
|
278 |
message, message_tail)) |
48321 | 279 |
end |
43052
8d6a4978cc65
automatically minimize with Metis when this can be done within a few seconds
blanchet
parents:
43051
diff
changeset
|
280 |
| {outcome = SOME TimedOut, preplay, ...} => |
54816
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
281 |
(NONE, (preplay, fn _ => |
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
282 |
"Timeout: You can increase the time limit using the \"timeout\" option (e.g., \ |
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
283 |
\timeout = " ^ string_of_int (10 + Time.toMilliseconds timeout div 1000) ^ "\").", "")) |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
284 |
| {preplay, message, ...} => (NONE, (preplay, prefix "Prover error: " o message, "")))) |
55285 | 285 |
handle ERROR msg => |
286 |
(NONE, (Lazy.value (Metis_Method (NONE, NONE), Play_Failed), fn _ => "Error: " ^ msg, "")) |
|
31236 | 287 |
end |
288 |
||
55285 | 289 |
fun adjust_proof_method_params override_params |
54816
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
290 |
({debug, verbose, overlord, spy, blocking, provers, type_enc, strict, lam_trans, |
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
291 |
uncurried_aliases, learn, fact_filter, max_facts, fact_thresholds, max_mono_iters, |
55288
1a4358d14ce2
added 'smt' option to control generation of 'by smt' proofs
blanchet
parents:
55287
diff
changeset
|
292 |
max_new_mono_instances, isar_proofs, compress_isar, try0_isar, smt, slice, minimize, timeout, |
54816
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
293 |
preplay_timeout, expect} : params) = |
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
294 |
let |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
295 |
fun lookup_override name default_value = |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
296 |
(case AList.lookup (op =) override_params name of |
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
297 |
SOME [s] => SOME s |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
298 |
| _ => default_value) |
55285 | 299 |
(* Only those options that proof_methods are interested in are considered here. *) |
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
300 |
val type_enc = lookup_override "type_enc" type_enc |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
301 |
val lam_trans = lookup_override "lam_trans" lam_trans |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
302 |
in |
53800 | 303 |
{debug = debug, verbose = verbose, overlord = overlord, spy = spy, blocking = blocking, |
304 |
provers = provers, type_enc = type_enc, strict = strict, lam_trans = lam_trans, |
|
305 |
uncurried_aliases = uncurried_aliases, learn = learn, fact_filter = fact_filter, |
|
306 |
max_facts = max_facts, fact_thresholds = fact_thresholds, max_mono_iters = max_mono_iters, |
|
49918
cf441f4a358b
renamed Isar-proof related options + changed semantics of Isar shrinking
blanchet
parents:
49914
diff
changeset
|
307 |
max_new_mono_instances = max_new_mono_instances, isar_proofs = isar_proofs, |
55288
1a4358d14ce2
added 'smt' option to control generation of 'by smt' proofs
blanchet
parents:
55287
diff
changeset
|
308 |
compress_isar = compress_isar, try0_isar = try0_isar, smt = smt, slice = slice, |
1a4358d14ce2
added 'smt' option to control generation of 'by smt' proofs
blanchet
parents:
55287
diff
changeset
|
309 |
minimize = minimize, timeout = timeout, preplay_timeout = preplay_timeout, expect = expect} |
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
310 |
end |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
311 |
|
55205 | 312 |
fun maybe_minimize ctxt mode do_learn name (params as {verbose, isar_proofs, minimize, ...}) |
313 |
({state, goal, subgoal, subgoal_count, ...} : prover_problem) |
|
314 |
(result as {outcome, used_facts, used_from, run_time, preplay, message, message_tail} : |
|
315 |
prover_result) = |
|
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
316 |
if is_some outcome orelse null used_facts then |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
317 |
result |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
318 |
else |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
319 |
let |
55205 | 320 |
val thy = Proof_Context.theory_of ctxt |
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
321 |
val num_facts = length used_facts |
55205 | 322 |
|
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
323 |
val ((perhaps_minimize, (minimize_name, params)), preplay) = |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
324 |
if mode = Normal then |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
325 |
if num_facts >= Config.get ctxt auto_minimize_min_facts then |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
326 |
((true, (name, params)), preplay) |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
327 |
else |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
328 |
let |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
329 |
fun can_min_fast_enough time = |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
330 |
0.001 |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
331 |
* Real.fromInt ((num_facts + 1) * Time.toMilliseconds time) |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
332 |
<= Config.get ctxt auto_minimize_max_time |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
333 |
fun prover_fast_enough () = can_min_fast_enough run_time |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
334 |
in |
51190
2654b3965c8d
made "isar_proofs" a 3-way option, to provide a way to totally disable isar_proofs if desired
blanchet
parents:
51187
diff
changeset
|
335 |
(case Lazy.force preplay of |
55285 | 336 |
(meth as Metis_Method _, Played timeout) => |
51191
89e9e945a005
auto-minimizer should respect "isar_proofs = true"
blanchet
parents:
51190
diff
changeset
|
337 |
if isar_proofs = SOME true then |
54816
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
338 |
(* Cheat: Assume the selected ATP is as fast as "metis" for the goal it proved |
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
339 |
itself. *) |
55205 | 340 |
(can_min_fast_enough timeout, (isar_supported_prover_of thy name, params)) |
51191
89e9e945a005
auto-minimizer should respect "isar_proofs = true"
blanchet
parents:
51190
diff
changeset
|
341 |
else if can_min_fast_enough timeout then |
55285 | 342 |
(true, extract_proof_method params meth |
51190
2654b3965c8d
made "isar_proofs" a 3-way option, to provide a way to totally disable isar_proofs if desired
blanchet
parents:
51187
diff
changeset
|
343 |
||> (fn override_params => |
55285 | 344 |
adjust_proof_method_params override_params params)) |
51190
2654b3965c8d
made "isar_proofs" a 3-way option, to provide a way to totally disable isar_proofs if desired
blanchet
parents:
51187
diff
changeset
|
345 |
else |
2654b3965c8d
made "isar_proofs" a 3-way option, to provide a way to totally disable isar_proofs if desired
blanchet
parents:
51187
diff
changeset
|
346 |
(prover_fast_enough (), (name, params)) |
55285 | 347 |
| (SMT_Method, Played timeout) => |
54816
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
348 |
(* Cheat: Assume the original prover is as fast as "smt" for the goal it proved |
10d48c2a3e32
made timeouts in Sledgehammer not be 'option's -- simplified lots of code
blanchet
parents:
54815
diff
changeset
|
349 |
itself. *) |
51190
2654b3965c8d
made "isar_proofs" a 3-way option, to provide a way to totally disable isar_proofs if desired
blanchet
parents:
51187
diff
changeset
|
350 |
(can_min_fast_enough timeout, (name, params)) |
2654b3965c8d
made "isar_proofs" a 3-way option, to provide a way to totally disable isar_proofs if desired
blanchet
parents:
51187
diff
changeset
|
351 |
| _ => (prover_fast_enough (), (name, params)), |
2654b3965c8d
made "isar_proofs" a 3-way option, to provide a way to totally disable isar_proofs if desired
blanchet
parents:
51187
diff
changeset
|
352 |
preplay) |
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
353 |
end |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
354 |
else |
54127
1e6db1c9f14c
verbose minimization when learning from ATP proofs
blanchet
parents:
54119
diff
changeset
|
355 |
((false, (name, params)), preplay) |
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
356 |
val minimize = minimize |> the_default perhaps_minimize |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
357 |
val (used_facts, (preplay, message, _)) = |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
358 |
if minimize then |
48392
ca998fa08cd9
added "learn_from_atp" command to MaSh, for patient users
blanchet
parents:
48384
diff
changeset
|
359 |
minimize_facts do_learn minimize_name params |
54824 | 360 |
(not verbose orelse (mode <> Normal andalso mode <> MaSh)) subgoal subgoal_count state |
361 |
goal (SOME preplay) (filter_used_facts true used_facts (map (apsnd single) used_from)) |
|
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
362 |
|>> Option.map (map fst) |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
363 |
else |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
364 |
(SOME used_facts, (preplay, message, "")) |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
365 |
in |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
366 |
(case used_facts of |
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
367 |
SOME used_facts => |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
368 |
{outcome = NONE, used_facts = used_facts, used_from = used_from, run_time = run_time, |
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
369 |
preplay = preplay, message = message, message_tail = message_tail} |
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
370 |
| NONE => result) |
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
371 |
end |
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
372 |
|
51187
c344cf148e8f
avoid using "smt" for minimization -- better use the prover itself, since then Sledgehammer gets to try metis again and gives the opportunity to output an Isar proof -- and show Isar proof as fallback for SMT proofs
blanchet
parents:
51130
diff
changeset
|
373 |
fun get_minimizing_prover ctxt mode do_learn name params minimize_command |
c344cf148e8f
avoid using "smt" for minimization -- better use the prover itself, since then Sledgehammer gets to try metis again and gives the opportunity to output an Isar proof -- and show Isar proof as fallback for SMT proofs
blanchet
parents:
51130
diff
changeset
|
374 |
problem = |
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
375 |
get_prover ctxt mode name params minimize_command problem |
48384
83dc102041e6
learn on explicit "min" command but do the learning in a thread, since it may take a couple of seconds
blanchet
parents:
48321
diff
changeset
|
376 |
|> maybe_minimize ctxt mode do_learn name params problem |
48250
1065c307fafe
further ML structure split to permit finer-grained loading/reordering (problem to solve: MaSh needs most of Sledgehammer)
blanchet
parents:
48085
diff
changeset
|
377 |
|
48321 | 378 |
fun run_minimize (params as {provers, ...}) do_learn i refs state = |
38045 | 379 |
let |
380 |
val ctxt = Proof.context_of state |
|
54130
b4e6cd4cab92
thread the goal through instead of relying on unreliable (possibly fake) state
blanchet
parents:
54127
diff
changeset
|
381 |
val {goal, facts = chained_ths, ...} = Proof.goal state |
38696
4c6b65d6a135
quote facts whose names collide with a keyword or command name (cf. "subclass" in "Jinja/J/TypeSafe.thy")
blanchet
parents:
38617
diff
changeset
|
382 |
val reserved = reserved_isar_keyword_table () |
48396 | 383 |
val css = clasimpset_rule_table_of ctxt |
54130
b4e6cd4cab92
thread the goal through instead of relying on unreliable (possibly fake) state
blanchet
parents:
54127
diff
changeset
|
384 |
val facts = refs |> maps (map (apsnd single) o fact_of_ref ctxt reserved chained_ths css) |
38045 | 385 |
in |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
386 |
(case subgoal_count state of |
40132
7ee65dbffa31
renamed Output.priority to Output.urgent_message to emphasize its special role more clearly;
wenzelm
parents:
40114
diff
changeset
|
387 |
0 => Output.urgent_message "No subgoal!" |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
388 |
| n => (case provers of |
41265
a393d6d8e198
let each prover minimizes its own stuff (rather than taking the first prover of the list to minimize every prover's stuff)
blanchet
parents:
41259
diff
changeset
|
389 |
[] => error "No prover is set." |
a393d6d8e198
let each prover minimizes its own stuff (rather than taking the first prover of the list to minimize every prover's stuff)
blanchet
parents:
41259
diff
changeset
|
390 |
| prover :: _ => |
a393d6d8e198
let each prover minimizes its own stuff (rather than taking the first prover of the list to minimize every prover's stuff)
blanchet
parents:
41259
diff
changeset
|
391 |
(kill_provers (); |
54130
b4e6cd4cab92
thread the goal through instead of relying on unreliable (possibly fake) state
blanchet
parents:
54127
diff
changeset
|
392 |
minimize_facts do_learn prover params false i n state goal NONE facts |
43261
a4aeb26a6362
make sure that the message tail (timing + TPTP important message) is preserved upon automatic minimization
blanchet
parents:
43259
diff
changeset
|
393 |
|> (fn (_, (preplay, message, message_tail)) => |
50669
84c7cf36b2e0
use "Lazy" to simplify control flow a bit and guarantee single evaluation (at most)
blanchet
parents:
50668
diff
changeset
|
394 |
message (Lazy.force preplay) ^ message_tail |
55202
824c48a539c9
renamed many Sledgehammer ML files to clarify structure
blanchet
parents:
55201
diff
changeset
|
395 |
|> Output.urgent_message)))) |
38045 | 396 |
end |
397 |
||
35866
513074557e06
move the Sledgehammer Isar commands together into one file;
blanchet
parents:
35865
diff
changeset
|
398 |
end; |