author | blanchet |
Wed, 20 Jul 2011 23:47:27 +0200 | |
changeset 43936 | 127749bbc639 |
parent 43907 | 073ab5379842 |
child 43939 | 081718c0b0a8 |
permissions | -rw-r--r-- |
43283 | 1 |
(* Title: HOL/Tools/ATP/atp_translate.ML |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
2 |
Author: Fabian Immler, TU Muenchen |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
3 |
Author: Makarius |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
4 |
Author: Jasmin Blanchette, TU Muenchen |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
5 |
|
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
6 |
Translation of HOL to FOL for Metis and Sledgehammer. |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
7 |
*) |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
8 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
9 |
signature ATP_TRANSLATE = |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
10 |
sig |
43676
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
11 |
type ('a, 'b) ho_term = ('a, 'b) ATP_Problem.ho_term |
43136
cf5cda219058
handle lightweight tags sym theorems gracefully in the presence of TVars with interesting type classes
blanchet
parents:
43130
diff
changeset
|
12 |
type connective = ATP_Problem.connective |
cf5cda219058
handle lightweight tags sym theorems gracefully in the presence of TVars with interesting type classes
blanchet
parents:
43130
diff
changeset
|
13 |
type ('a, 'b, 'c) formula = ('a, 'b, 'c) ATP_Problem.formula |
42939 | 14 |
type format = ATP_Problem.format |
42709
e7af132d48fe
allow each prover to specify its own formula kind for symbols occurring in the conjecture
blanchet
parents:
42701
diff
changeset
|
15 |
type formula_kind = ATP_Problem.formula_kind |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
16 |
type 'a problem = 'a ATP_Problem.problem |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
17 |
|
43421 | 18 |
datatype locality = |
19 |
General | Helper | Extensionality | Intro | Elim | Simp | Local | Assum | |
|
20 |
Chained |
|
42613
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
21 |
|
43624
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
22 |
datatype order = First_Order | Higher_Order |
42613
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
23 |
datatype polymorphism = Polymorphic | Monomorphic | Mangled_Monomorphic |
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
24 |
datatype type_level = |
43362 | 25 |
All_Types | Noninf_Nonmono_Types | Fin_Nonmono_Types | Const_Arg_Types | |
26 |
No_Types |
|
43128 | 27 |
datatype type_heaviness = Heavyweight | Lightweight |
42613
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
28 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
29 |
datatype type_enc = |
43624
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
30 |
Simple_Types of order * type_level | |
42837 | 31 |
Preds of polymorphism * type_level * type_heaviness | |
32 |
Tags of polymorphism * type_level * type_heaviness |
|
42613
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
33 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
34 |
val bound_var_prefix : string |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
35 |
val schematic_var_prefix : string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
36 |
val fixed_var_prefix : string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
37 |
val tvar_prefix : string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
38 |
val tfree_prefix : string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
39 |
val const_prefix : string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
40 |
val type_const_prefix : string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
41 |
val class_prefix : string |
43936
127749bbc639
use a more robust naming convention for "polymorphic" frees -- the check is an overapproximation but that's fine as far as soundness is concerned
blanchet
parents:
43907
diff
changeset
|
42 |
val polymorphic_free_prefix : string |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
43 |
val skolem_const_prefix : string |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
44 |
val old_skolem_const_prefix : string |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
45 |
val new_skolem_const_prefix : string |
43125
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
46 |
val type_decl_prefix : string |
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
47 |
val sym_decl_prefix : string |
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
48 |
val preds_sym_formula_prefix : string |
43129 | 49 |
val lightweight_tags_sym_formula_prefix : string |
40204
da97d75e20e6
standardize on "fact" terminology (vs. "axiom" or "theorem") in Sledgehammer -- but keep "Axiom" in the lower-level "ATP_Problem" module
blanchet
parents:
40145
diff
changeset
|
50 |
val fact_prefix : string |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
51 |
val conjecture_prefix : string |
42881
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
52 |
val helper_prefix : string |
43125
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
53 |
val class_rel_clause_prefix : string |
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
54 |
val arity_clause_prefix : string |
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
55 |
val tfree_clause_prefix : string |
42881
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
56 |
val typed_helper_suffix : string |
43125
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
57 |
val untyped_helper_suffix : string |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
58 |
val type_tag_idempotence_helper_name : string |
42966
4e2d6c1e5392
more work on parsing LEO-II proofs without lambdas
blanchet
parents:
42963
diff
changeset
|
59 |
val predicator_name : string |
4e2d6c1e5392
more work on parsing LEO-II proofs without lambdas
blanchet
parents:
42963
diff
changeset
|
60 |
val app_op_name : string |
43104
81d1b15aa0ae
use ":" for type information (looks good in Metis's output) and handle it in new path finder
blanchet
parents:
43102
diff
changeset
|
61 |
val type_tag_name : string |
42966
4e2d6c1e5392
more work on parsing LEO-II proofs without lambdas
blanchet
parents:
42963
diff
changeset
|
62 |
val type_pred_name : string |
42962
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
63 |
val simple_type_prefix : string |
43174 | 64 |
val prefixed_predicator_name : string |
43130
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
65 |
val prefixed_app_op_name : string |
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
66 |
val prefixed_type_tag_name : string |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
67 |
val ascii_of : string -> string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
68 |
val unascii_of : string -> string |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
69 |
val strip_prefix_and_unascii : string -> string -> string option |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
70 |
val proxy_table : (string * (string * (thm * (string * string)))) list |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
71 |
val proxify_const : string -> (string * string) option |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
72 |
val invert_const : string -> string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
73 |
val unproxify_const : string -> string |
43093 | 74 |
val new_skolem_var_name_from_const : string -> string |
43248
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
75 |
val atp_irrelevant_consts : string list |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
76 |
val atp_schematic_consts_of : term -> typ list Symtab.table |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
77 |
val is_locality_global : locality -> bool |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
78 |
val type_enc_from_string : string -> type_enc |
43828
e07a2c4cbad8
move lambda translation option from ATP to Sledgehammer, to avoid accidentally breaking Metis (its reconstruction code can only deal with combinators)
blanchet
parents:
43827
diff
changeset
|
79 |
val is_type_enc_higher_order : type_enc -> bool |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
80 |
val polymorphism_of_type_enc : type_enc -> polymorphism |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
81 |
val level_of_type_enc : type_enc -> type_level |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
82 |
val is_type_enc_virtually_sound : type_enc -> bool |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
83 |
val is_type_enc_fairly_sound : type_enc -> bool |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
84 |
val choose_format : format list -> type_enc -> format * type_enc |
43136
cf5cda219058
handle lightweight tags sym theorems gracefully in the presence of TVars with interesting type classes
blanchet
parents:
43130
diff
changeset
|
85 |
val mk_aconns : |
cf5cda219058
handle lightweight tags sym theorems gracefully in the presence of TVars with interesting type classes
blanchet
parents:
43130
diff
changeset
|
86 |
connective -> ('a, 'b, 'c) formula list -> ('a, 'b, 'c) formula |
43676
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
87 |
val unmangled_const : string -> string * (string, 'b) ho_term list |
43130
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
88 |
val unmangled_const_name : string -> string |
43194 | 89 |
val helper_table : ((string * bool) * thm list) list |
43501
0e422a84d0b2
don't change the way helpers are generated for the exporter's sake
blanchet
parents:
43496
diff
changeset
|
90 |
val factsN : string |
43856
d636b053d4ff
move more lambda-handling logic to Sledgehammer, from ATP module, for formal dependency reasons
blanchet
parents:
43830
diff
changeset
|
91 |
val conceal_lambdas : Proof.context -> term -> term |
d636b053d4ff
move more lambda-handling logic to Sledgehammer, from ATP module, for formal dependency reasons
blanchet
parents:
43830
diff
changeset
|
92 |
val introduce_combinators : Proof.context -> term -> term |
40059
6ad9081665db
use consistent terminology in Sledgehammer: "prover = ATP or SMT solver or ..."
blanchet
parents:
39975
diff
changeset
|
93 |
val prepare_atp_problem : |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
94 |
Proof.context -> format -> formula_kind -> formula_kind -> type_enc -> bool |
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
95 |
-> bool -> (term list -> term list * term list) -> bool -> bool -> term list |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
96 |
-> term -> ((string * locality) * term) list |
42541
8938507b2054
move type declarations to the front, for TFF-compliance
blanchet
parents:
42540
diff
changeset
|
97 |
-> string problem * string Symtab.table * int * int |
43214 | 98 |
* (string * locality) list vector * int list * int Symtab.table |
41313
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
99 |
val atp_problem_weights : string problem -> (string * real) list |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
100 |
end; |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
101 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
102 |
structure ATP_Translate : ATP_TRANSLATE = |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
103 |
struct |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
104 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
105 |
open ATP_Util |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
106 |
open ATP_Problem |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
107 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
108 |
type name = string * string |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
109 |
|
43828
e07a2c4cbad8
move lambda translation option from ATP to Sledgehammer, to avoid accidentally breaking Metis (its reconstruction code can only deal with combinators)
blanchet
parents:
43827
diff
changeset
|
110 |
val generate_info = false (* experimental *) |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
111 |
|
43693 | 112 |
fun isabelle_info s = |
113 |
if generate_info then SOME (ATerm ("[]", [ATerm ("isabelle_" ^ s, [])])) |
|
114 |
else NONE |
|
42879 | 115 |
|
43693 | 116 |
val introN = "intro" |
117 |
val elimN = "elim" |
|
118 |
val simpN = "simp" |
|
42879 | 119 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
120 |
val bound_var_prefix = "B_" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
121 |
val schematic_var_prefix = "V_" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
122 |
val fixed_var_prefix = "v_" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
123 |
val tvar_prefix = "T_" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
124 |
val tfree_prefix = "t_" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
125 |
val const_prefix = "c_" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
126 |
val type_const_prefix = "tc_" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
127 |
val class_prefix = "cl_" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
128 |
|
43936
127749bbc639
use a more robust naming convention for "polymorphic" frees -- the check is an overapproximation but that's fine as far as soundness is concerned
blanchet
parents:
43907
diff
changeset
|
129 |
val polymorphic_free_prefix = "poly_free" |
43907
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
130 |
|
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
131 |
val skolem_const_prefix = "ATP" ^ Long_Name.separator ^ "Sko" |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
132 |
val old_skolem_const_prefix = skolem_const_prefix ^ "o" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
133 |
val new_skolem_const_prefix = skolem_const_prefix ^ "n" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
134 |
|
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
135 |
val type_decl_prefix = "ty_" |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
136 |
val sym_decl_prefix = "sy_" |
43125
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
137 |
val preds_sym_formula_prefix = "psy_" |
43129 | 138 |
val lightweight_tags_sym_formula_prefix = "tsy_" |
40204
da97d75e20e6
standardize on "fact" terminology (vs. "axiom" or "theorem") in Sledgehammer -- but keep "Axiom" in the lower-level "ATP_Problem" module
blanchet
parents:
40145
diff
changeset
|
139 |
val fact_prefix = "fact_" |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
140 |
val conjecture_prefix = "conj_" |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
141 |
val helper_prefix = "help_" |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
142 |
val class_rel_clause_prefix = "clar_" |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
143 |
val arity_clause_prefix = "arity_" |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
144 |
val tfree_clause_prefix = "tfree_" |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
145 |
|
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
146 |
val lambda_fact_prefix = "ATP.lambda_" |
42881
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
147 |
val typed_helper_suffix = "_T" |
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
148 |
val untyped_helper_suffix = "_U" |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
149 |
val type_tag_idempotence_helper_name = helper_prefix ^ "ti_idem" |
42881
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
150 |
|
42966
4e2d6c1e5392
more work on parsing LEO-II proofs without lambdas
blanchet
parents:
42963
diff
changeset
|
151 |
val predicator_name = "hBOOL" |
4e2d6c1e5392
more work on parsing LEO-II proofs without lambdas
blanchet
parents:
42963
diff
changeset
|
152 |
val app_op_name = "hAPP" |
43104
81d1b15aa0ae
use ":" for type information (looks good in Metis's output) and handle it in new path finder
blanchet
parents:
43102
diff
changeset
|
153 |
val type_tag_name = "ti" |
42966
4e2d6c1e5392
more work on parsing LEO-II proofs without lambdas
blanchet
parents:
42963
diff
changeset
|
154 |
val type_pred_name = "is" |
42962
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
155 |
val simple_type_prefix = "ty_" |
42531
a462dbaa584f
added more rudimentary type support to Sledgehammer's ATP encoding
blanchet
parents:
42530
diff
changeset
|
156 |
|
43174 | 157 |
val prefixed_predicator_name = const_prefix ^ predicator_name |
43130
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
158 |
val prefixed_app_op_name = const_prefix ^ app_op_name |
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
159 |
val prefixed_type_tag_name = const_prefix ^ type_tag_name |
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
160 |
|
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
161 |
(* Freshness almost guaranteed! *) |
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
162 |
val atp_weak_prefix = "ATP:" |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
163 |
|
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
164 |
val concealed_lambda_prefix = atp_weak_prefix ^ "lambda_" |
43827
62d64709af3b
added option to control which lambda translation to use (for experiments)
blanchet
parents:
43693
diff
changeset
|
165 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
166 |
(*Escaping of special characters. |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
167 |
Alphanumeric characters are left unchanged. |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
168 |
The character _ goes to __ |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
169 |
Characters in the range ASCII space to / go to _A to _P, respectively. |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
170 |
Other characters go to _nnn where nnn is the decimal ASCII code.*) |
43093 | 171 |
val upper_a_minus_space = Char.ord #"A" - Char.ord #" " |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
172 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
173 |
fun stringN_of_int 0 _ = "" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
174 |
| stringN_of_int k n = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
175 |
stringN_of_int (k - 1) (n div 10) ^ string_of_int (n mod 10) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
176 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
177 |
fun ascii_of_char c = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
178 |
if Char.isAlphaNum c then |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
179 |
String.str c |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
180 |
else if c = #"_" then |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
181 |
"__" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
182 |
else if #" " <= c andalso c <= #"/" then |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
183 |
"_" ^ String.str (Char.chr (Char.ord c + upper_a_minus_space)) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
184 |
else |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
185 |
(* fixed width, in case more digits follow *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
186 |
"_" ^ stringN_of_int 3 (Char.ord c) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
187 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
188 |
val ascii_of = String.translate ascii_of_char |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
189 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
190 |
(** Remove ASCII armoring from names in proof files **) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
191 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
192 |
(* We don't raise error exceptions because this code can run inside a worker |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
193 |
thread. Also, the errors are impossible. *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
194 |
val unascii_of = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
195 |
let |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
196 |
fun un rcs [] = String.implode(rev rcs) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
197 |
| un rcs [#"_"] = un (#"_" :: rcs) [] (* ERROR *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
198 |
(* Three types of _ escapes: __, _A to _P, _nnn *) |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
199 |
| un rcs (#"_" :: #"_" :: cs) = un (#"_" :: rcs) cs |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
200 |
| un rcs (#"_" :: c :: cs) = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
201 |
if #"A" <= c andalso c<= #"P" then |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
202 |
(* translation of #" " to #"/" *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
203 |
un (Char.chr (Char.ord c - upper_a_minus_space) :: rcs) cs |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
204 |
else |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
205 |
let val digits = List.take (c :: cs, 3) handle General.Subscript => [] in |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
206 |
case Int.fromString (String.implode digits) of |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
207 |
SOME n => un (Char.chr n :: rcs) (List.drop (cs, 2)) |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
208 |
| NONE => un (c :: #"_" :: rcs) cs (* ERROR *) |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
209 |
end |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
210 |
| un rcs (c :: cs) = un (c :: rcs) cs |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
211 |
in un [] o String.explode end |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
212 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
213 |
(* If string s has the prefix s1, return the result of deleting it, |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
214 |
un-ASCII'd. *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
215 |
fun strip_prefix_and_unascii s1 s = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
216 |
if String.isPrefix s1 s then |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
217 |
SOME (unascii_of (String.extract (s, size s1, NONE))) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
218 |
else |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
219 |
NONE |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
220 |
|
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
221 |
val proxy_table = |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
222 |
[("c_False", (@{const_name False}, (@{thm fFalse_def}, |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
223 |
("fFalse", @{const_name ATP.fFalse})))), |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
224 |
("c_True", (@{const_name True}, (@{thm fTrue_def}, |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
225 |
("fTrue", @{const_name ATP.fTrue})))), |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
226 |
("c_Not", (@{const_name Not}, (@{thm fNot_def}, |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
227 |
("fNot", @{const_name ATP.fNot})))), |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
228 |
("c_conj", (@{const_name conj}, (@{thm fconj_def}, |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
229 |
("fconj", @{const_name ATP.fconj})))), |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
230 |
("c_disj", (@{const_name disj}, (@{thm fdisj_def}, |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
231 |
("fdisj", @{const_name ATP.fdisj})))), |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
232 |
("c_implies", (@{const_name implies}, (@{thm fimplies_def}, |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
233 |
("fimplies", @{const_name ATP.fimplies})))), |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
234 |
("equal", (@{const_name HOL.eq}, (@{thm fequal_def}, |
43678 | 235 |
("fequal", @{const_name ATP.fequal})))), |
236 |
("c_All", (@{const_name All}, (@{thm fAll_def}, |
|
237 |
("fAll", @{const_name ATP.fAll})))), |
|
238 |
("c_Ex", (@{const_name Ex}, (@{thm fEx_def}, |
|
239 |
("fEx", @{const_name ATP.fEx}))))] |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
240 |
|
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
241 |
val proxify_const = AList.lookup (op =) proxy_table #> Option.map (snd o snd) |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
242 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
243 |
(* Readable names for the more common symbolic functions. Do not mess with the |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
244 |
table unless you know what you are doing. *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
245 |
val const_trans_table = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
246 |
[(@{type_name Product_Type.prod}, "prod"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
247 |
(@{type_name Sum_Type.sum}, "sum"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
248 |
(@{const_name False}, "False"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
249 |
(@{const_name True}, "True"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
250 |
(@{const_name Not}, "Not"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
251 |
(@{const_name conj}, "conj"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
252 |
(@{const_name disj}, "disj"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
253 |
(@{const_name implies}, "implies"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
254 |
(@{const_name HOL.eq}, "equal"), |
43678 | 255 |
(@{const_name All}, "All"), |
256 |
(@{const_name Ex}, "Ex"), |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
257 |
(@{const_name If}, "If"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
258 |
(@{const_name Set.member}, "member"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
259 |
(@{const_name Meson.COMBI}, "COMBI"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
260 |
(@{const_name Meson.COMBK}, "COMBK"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
261 |
(@{const_name Meson.COMBB}, "COMBB"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
262 |
(@{const_name Meson.COMBC}, "COMBC"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
263 |
(@{const_name Meson.COMBS}, "COMBS")] |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
264 |
|> Symtab.make |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
265 |
|> fold (Symtab.update o swap o snd o snd o snd) proxy_table |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
266 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
267 |
(* Invert the table of translations between Isabelle and ATPs. *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
268 |
val const_trans_table_inv = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
269 |
const_trans_table |> Symtab.dest |> map swap |> Symtab.make |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
270 |
val const_trans_table_unprox = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
271 |
Symtab.empty |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
272 |
|> fold (fn (_, (isa, (_, (_, atp)))) => Symtab.update (atp, isa)) proxy_table |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
273 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
274 |
val invert_const = perhaps (Symtab.lookup const_trans_table_inv) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
275 |
val unproxify_const = perhaps (Symtab.lookup const_trans_table_unprox) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
276 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
277 |
fun lookup_const c = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
278 |
case Symtab.lookup const_trans_table c of |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
279 |
SOME c' => c' |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
280 |
| NONE => ascii_of c |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
281 |
|
43622 | 282 |
fun ascii_of_indexname (v, 0) = ascii_of v |
283 |
| ascii_of_indexname (v, i) = ascii_of v ^ "_" ^ string_of_int i |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
284 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
285 |
fun make_bound_var x = bound_var_prefix ^ ascii_of x |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
286 |
fun make_schematic_var v = schematic_var_prefix ^ ascii_of_indexname v |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
287 |
fun make_fixed_var x = fixed_var_prefix ^ ascii_of x |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
288 |
|
43622 | 289 |
fun make_schematic_type_var (x, i) = |
290 |
tvar_prefix ^ (ascii_of_indexname (unprefix "'" x, i)) |
|
291 |
fun make_fixed_type_var x = tfree_prefix ^ (ascii_of (unprefix "'" x)) |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
292 |
|
43622 | 293 |
(* "HOL.eq" is mapped to the ATP's equality. *) |
294 |
fun make_fixed_const @{const_name HOL.eq} = tptp_old_equal |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
295 |
| make_fixed_const c = const_prefix ^ lookup_const c |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
296 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
297 |
fun make_fixed_type_const c = type_const_prefix ^ lookup_const c |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
298 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
299 |
fun make_type_class clas = class_prefix ^ ascii_of clas |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
300 |
|
43093 | 301 |
fun new_skolem_var_name_from_const s = |
302 |
let val ss = s |> space_explode Long_Name.separator in |
|
303 |
nth ss (length ss - 2) |
|
304 |
end |
|
305 |
||
43248
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
306 |
(* These are either simplified away by "Meson.presimplify" (most of the time) or |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
307 |
handled specially via "fFalse", "fTrue", ..., "fequal". *) |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
308 |
val atp_irrelevant_consts = |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
309 |
[@{const_name False}, @{const_name True}, @{const_name Not}, |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
310 |
@{const_name conj}, @{const_name disj}, @{const_name implies}, |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
311 |
@{const_name HOL.eq}, @{const_name If}, @{const_name Let}] |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
312 |
|
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
313 |
val atp_monomorph_bad_consts = |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
314 |
atp_irrelevant_consts @ |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
315 |
(* These are ignored anyway by the relevance filter (unless they appear in |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
316 |
higher-order places) but not by the monomorphizer. *) |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
317 |
[@{const_name all}, @{const_name "==>"}, @{const_name "=="}, |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
318 |
@{const_name Trueprop}, @{const_name All}, @{const_name Ex}, |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
319 |
@{const_name Ex1}, @{const_name Ball}, @{const_name Bex}] |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
320 |
|
43258
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
321 |
fun add_schematic_const (x as (_, T)) = |
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
322 |
Monomorph.typ_has_tvars T ? Symtab.insert_list (op =) x |
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
323 |
val add_schematic_consts_of = |
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
324 |
Term.fold_aterms (fn Const (x as (s, _)) => |
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
325 |
not (member (op =) atp_monomorph_bad_consts s) |
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
326 |
? add_schematic_const x |
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
327 |
| _ => I) |
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
328 |
fun atp_schematic_consts_of t = add_schematic_consts_of t Symtab.empty |
43248
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
329 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
330 |
(** Definitions and functions for FOL clauses and formulas for TPTP **) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
331 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
332 |
(* The first component is the type class; the second is a "TVar" or "TFree". *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
333 |
datatype type_literal = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
334 |
TyLitVar of name * name | |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
335 |
TyLitFree of name * name |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
336 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
337 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
338 |
(** Isabelle arities **) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
339 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
340 |
datatype arity_literal = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
341 |
TConsLit of name * name * name list | |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
342 |
TVarLit of name * name |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
343 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
344 |
fun gen_TVars 0 = [] |
43093 | 345 |
| gen_TVars n = ("T_" ^ string_of_int n) :: gen_TVars (n-1) |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
346 |
|
43263 | 347 |
val type_class = the_single @{sort type} |
348 |
||
349 |
fun add_packed_sort tvar = |
|
350 |
fold (fn s => s <> type_class ? cons (`make_type_class s, `I tvar)) |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
351 |
|
43086 | 352 |
type arity_clause = |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
353 |
{name : string, |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
354 |
prem_lits : arity_literal list, |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
355 |
concl_lits : arity_literal} |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
356 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
357 |
(* Arity of type constructor "tcon :: (arg1, ..., argN) res" *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
358 |
fun make_axiom_arity_clause (tcons, name, (cls, args)) = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
359 |
let |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
360 |
val tvars = gen_TVars (length args) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
361 |
val tvars_srts = ListPair.zip (tvars, args) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
362 |
in |
43086 | 363 |
{name = name, |
43263 | 364 |
prem_lits = [] |> fold (uncurry add_packed_sort) tvars_srts |> map TVarLit, |
43086 | 365 |
concl_lits = TConsLit (`make_type_class cls, |
366 |
`make_fixed_type_const tcons, |
|
367 |
tvars ~~ tvars)} |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
368 |
end |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
369 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
370 |
fun arity_clause _ _ (_, []) = [] |
43495 | 371 |
| arity_clause seen n (tcons, ("HOL.type", _) :: ars) = (* ignore *) |
372 |
arity_clause seen n (tcons, ars) |
|
373 |
| arity_clause seen n (tcons, (ar as (class, _)) :: ars) = |
|
374 |
if member (op =) seen class then |
|
375 |
(* multiple arities for the same (tycon, class) pair *) |
|
376 |
make_axiom_arity_clause (tcons, |
|
377 |
lookup_const tcons ^ "___" ^ ascii_of class ^ "_" ^ string_of_int n, |
|
378 |
ar) :: |
|
379 |
arity_clause seen (n + 1) (tcons, ars) |
|
380 |
else |
|
381 |
make_axiom_arity_clause (tcons, lookup_const tcons ^ "___" ^ |
|
382 |
ascii_of class, ar) :: |
|
383 |
arity_clause (class :: seen) n (tcons, ars) |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
384 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
385 |
fun multi_arity_clause [] = [] |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
386 |
| multi_arity_clause ((tcons, ars) :: tc_arlists) = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
387 |
arity_clause [] 1 (tcons, ars) @ multi_arity_clause tc_arlists |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
388 |
|
43622 | 389 |
(* Generate all pairs (tycon, class, sorts) such that tycon belongs to class in |
390 |
theory thy provided its arguments have the corresponding sorts. *) |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
391 |
fun type_class_pairs thy tycons classes = |
43093 | 392 |
let |
393 |
val alg = Sign.classes_of thy |
|
394 |
fun domain_sorts tycon = Sorts.mg_domain alg tycon o single |
|
395 |
fun add_class tycon class = |
|
396 |
cons (class, domain_sorts tycon class) |
|
397 |
handle Sorts.CLASS_ERROR _ => I |
|
398 |
fun try_classes tycon = (tycon, fold (add_class tycon) classes []) |
|
399 |
in map try_classes tycons end |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
400 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
401 |
(*Proving one (tycon, class) membership may require proving others, so iterate.*) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
402 |
fun iter_type_class_pairs _ _ [] = ([], []) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
403 |
| iter_type_class_pairs thy tycons classes = |
43263 | 404 |
let |
405 |
fun maybe_insert_class s = |
|
406 |
(s <> type_class andalso not (member (op =) classes s)) |
|
407 |
? insert (op =) s |
|
408 |
val cpairs = type_class_pairs thy tycons classes |
|
409 |
val newclasses = |
|
410 |
[] |> fold (fold (fold (fold maybe_insert_class) o snd) o snd) cpairs |
|
411 |
val (classes', cpairs') = iter_type_class_pairs thy tycons newclasses |
|
43266 | 412 |
in (classes' @ classes, union (op =) cpairs' cpairs) end |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
413 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
414 |
fun make_arity_clauses thy tycons = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
415 |
iter_type_class_pairs thy tycons ##> multi_arity_clause |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
416 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
417 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
418 |
(** Isabelle class relations **) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
419 |
|
43086 | 420 |
type class_rel_clause = |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
421 |
{name : string, |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
422 |
subclass : name, |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
423 |
superclass : name} |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
424 |
|
43622 | 425 |
(* Generate all pairs (sub, super) such that sub is a proper subclass of super |
426 |
in theory "thy". *) |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
427 |
fun class_pairs _ [] _ = [] |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
428 |
| class_pairs thy subs supers = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
429 |
let |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
430 |
val class_less = Sorts.class_less (Sign.classes_of thy) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
431 |
fun add_super sub super = class_less (sub, super) ? cons (sub, super) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
432 |
fun add_supers sub = fold (add_super sub) supers |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
433 |
in fold add_supers subs [] end |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
434 |
|
43622 | 435 |
fun make_class_rel_clause (sub, super) = |
436 |
{name = sub ^ "_" ^ super, subclass = `make_type_class sub, |
|
43086 | 437 |
superclass = `make_type_class super} |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
438 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
439 |
fun make_class_rel_clauses thy subs supers = |
43093 | 440 |
map make_class_rel_clause (class_pairs thy subs supers) |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
441 |
|
43859 | 442 |
(* intermediate terms *) |
443 |
datatype iterm = |
|
444 |
IConst of name * typ * typ list | |
|
445 |
IVar of name * typ | |
|
446 |
IApp of iterm * iterm | |
|
447 |
IAbs of (name * typ) * iterm |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
448 |
|
43859 | 449 |
fun ityp_of (IConst (_, T, _)) = T |
450 |
| ityp_of (IVar (_, T)) = T |
|
451 |
| ityp_of (IApp (t1, _)) = snd (dest_funT (ityp_of t1)) |
|
452 |
| ityp_of (IAbs ((_, T), tm)) = T --> ityp_of tm |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
453 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
454 |
(*gets the head of a combinator application, along with the list of arguments*) |
43859 | 455 |
fun strip_iterm_comb u = |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
456 |
let |
43859 | 457 |
fun stripc (IApp (t, u), ts) = stripc (t, u :: ts) |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
458 |
| stripc x = x |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
459 |
in stripc (u, []) end |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
460 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
461 |
fun atyps_of T = fold_atyps (insert (op =)) T [] |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
462 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
463 |
fun new_skolem_const_name s num_T_args = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
464 |
[new_skolem_const_prefix, s, string_of_int num_T_args] |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
465 |
|> space_implode Long_Name.separator |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
466 |
|
43859 | 467 |
(* Converts an Isabelle/HOL term (with combinators) into an intermediate term. |
468 |
Also accumulates sort infomation. *) |
|
469 |
fun iterm_from_term thy bs (P $ Q) = |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
470 |
let |
43859 | 471 |
val (P', P_atomics_Ts) = iterm_from_term thy bs P |
472 |
val (Q', Q_atomics_Ts) = iterm_from_term thy bs Q |
|
473 |
in (IApp (P', Q'), union (op =) P_atomics_Ts Q_atomics_Ts) end |
|
474 |
| iterm_from_term thy _ (Const (c, T)) = |
|
43907
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
475 |
(IConst (`make_fixed_const c, T, |
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
476 |
if String.isPrefix old_skolem_const_prefix c then |
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
477 |
[] |> Term.add_tvarsT T |> map TVar |
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
478 |
else |
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
479 |
(c, T) |> Sign.const_typargs thy), |
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
480 |
atyps_of T) |
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
481 |
| iterm_from_term _ _ (Free (s, T)) = |
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
482 |
(IConst (`make_fixed_var s, T, |
43936
127749bbc639
use a more robust naming convention for "polymorphic" frees -- the check is an overapproximation but that's fine as far as soundness is concerned
blanchet
parents:
43907
diff
changeset
|
483 |
if String.isPrefix polymorphic_free_prefix s then [T] else []), |
43907
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
484 |
atyps_of T) |
43859 | 485 |
| iterm_from_term _ _ (Var (v as (s, _), T)) = |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
486 |
(if String.isPrefix Meson_Clausify.new_skolem_var_prefix s then |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
487 |
let |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
488 |
val Ts = T |> strip_type |> swap |> op :: |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
489 |
val s' = new_skolem_const_name s (length Ts) |
43859 | 490 |
in IConst (`make_fixed_const s', T, Ts) end |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
491 |
else |
43859 | 492 |
IVar ((make_schematic_var v, s), T), atyps_of T) |
493 |
| iterm_from_term _ bs (Bound j) = |
|
494 |
nth bs j |> (fn (s, T) => (IConst (`make_bound_var s, T, []), atyps_of T)) |
|
495 |
| iterm_from_term thy bs (Abs (s, T, t)) = |
|
43678 | 496 |
let |
497 |
fun vary s = s |> AList.defined (op =) bs s ? vary o Symbol.bump_string |
|
498 |
val s = vary s |
|
43859 | 499 |
val (tm, atomic_Ts) = iterm_from_term thy ((s, T) :: bs) t |
43678 | 500 |
in |
43859 | 501 |
(IAbs ((`make_bound_var s, T), tm), |
43677 | 502 |
union (op =) atomic_Ts (atyps_of T)) |
503 |
end |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
504 |
|
43421 | 505 |
datatype locality = |
506 |
General | Helper | Extensionality | Intro | Elim | Simp | Local | Assum | |
|
507 |
Chained |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
508 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
509 |
(* (quasi-)underapproximation of the truth *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
510 |
fun is_locality_global Local = false |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
511 |
| is_locality_global Assum = false |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
512 |
| is_locality_global Chained = false |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
513 |
| is_locality_global _ = true |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
514 |
|
43624
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
515 |
datatype order = First_Order | Higher_Order |
42613
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
516 |
datatype polymorphism = Polymorphic | Monomorphic | Mangled_Monomorphic |
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
517 |
datatype type_level = |
43362 | 518 |
All_Types | Noninf_Nonmono_Types | Fin_Nonmono_Types | Const_Arg_Types | |
519 |
No_Types |
|
43128 | 520 |
datatype type_heaviness = Heavyweight | Lightweight |
42613
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
521 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
522 |
datatype type_enc = |
43624
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
523 |
Simple_Types of order * type_level | |
42837 | 524 |
Preds of polymorphism * type_level * type_heaviness | |
525 |
Tags of polymorphism * type_level * type_heaviness |
|
42613
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
526 |
|
42689
e38590764c34
versions of ! and ? for the ASCII-challenged Mirabelle
blanchet
parents:
42688
diff
changeset
|
527 |
fun try_unsuffixes ss s = |
e38590764c34
versions of ! and ? for the ASCII-challenged Mirabelle
blanchet
parents:
42688
diff
changeset
|
528 |
fold (fn s' => fn NONE => try (unsuffix s') s | some => some) ss NONE |
e38590764c34
versions of ! and ? for the ASCII-challenged Mirabelle
blanchet
parents:
42688
diff
changeset
|
529 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
530 |
fun type_enc_from_string s = |
42722 | 531 |
(case try (unprefix "poly_") s of |
532 |
SOME s => (SOME Polymorphic, s) |
|
42613
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
533 |
| NONE => |
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
534 |
case try (unprefix "mono_") s of |
42722 | 535 |
SOME s => (SOME Monomorphic, s) |
536 |
| NONE => |
|
537 |
case try (unprefix "mangled_") s of |
|
538 |
SOME s => (SOME Mangled_Monomorphic, s) |
|
539 |
| NONE => (NONE, s)) |
|
42613
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
540 |
||> (fn s => |
43624
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
541 |
(* "_query" and "_bang" are for the ASCII-challenged Metis and |
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
542 |
Mirabelle. *) |
42689
e38590764c34
versions of ! and ? for the ASCII-challenged Mirabelle
blanchet
parents:
42688
diff
changeset
|
543 |
case try_unsuffixes ["?", "_query"] s of |
43362 | 544 |
SOME s => (Noninf_Nonmono_Types, s) |
42613
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
545 |
| NONE => |
42689
e38590764c34
versions of ! and ? for the ASCII-challenged Mirabelle
blanchet
parents:
42688
diff
changeset
|
546 |
case try_unsuffixes ["!", "_bang"] s of |
43362 | 547 |
SOME s => (Fin_Nonmono_Types, s) |
42613
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
548 |
| NONE => (All_Types, s)) |
42828 | 549 |
||> apsnd (fn s => |
42837 | 550 |
case try (unsuffix "_heavy") s of |
43128 | 551 |
SOME s => (Heavyweight, s) |
552 |
| NONE => (Lightweight, s)) |
|
42837 | 553 |
|> (fn (poly, (level, (heaviness, core))) => |
554 |
case (core, (poly, level, heaviness)) of |
|
43624
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
555 |
("simple", (NONE, _, Lightweight)) => |
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
556 |
Simple_Types (First_Order, level) |
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
557 |
| ("simple_higher", (NONE, _, Lightweight)) => |
43676
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
558 |
if level = Noninf_Nonmono_Types then raise Same.SAME |
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
559 |
else Simple_Types (Higher_Order, level) |
42854
d99167ac4f8a
since we always default on the "_light" encoding (for good reasons, according to Judgment Day), get rid of that suffix
blanchet
parents:
42852
diff
changeset
|
560 |
| ("preds", (SOME poly, _, _)) => Preds (poly, level, heaviness) |
42886
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
561 |
| ("tags", (SOME Polymorphic, _, _)) => |
43361
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
562 |
Tags (Polymorphic, level, heaviness) |
42854
d99167ac4f8a
since we always default on the "_light" encoding (for good reasons, according to Judgment Day), get rid of that suffix
blanchet
parents:
42852
diff
changeset
|
563 |
| ("tags", (SOME poly, _, _)) => Tags (poly, level, heaviness) |
43128 | 564 |
| ("args", (SOME poly, All_Types (* naja *), Lightweight)) => |
565 |
Preds (poly, Const_Arg_Types, Lightweight) |
|
566 |
| ("erased", (NONE, All_Types (* naja *), Lightweight)) => |
|
567 |
Preds (Polymorphic, No_Types, Lightweight) |
|
42753
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
568 |
| _ => raise Same.SAME) |
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
569 |
handle Same.SAME => error ("Unknown type system: " ^ quote s ^ ".") |
42613
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
570 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
571 |
fun is_type_enc_higher_order (Simple_Types (Higher_Order, _)) = true |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
572 |
| is_type_enc_higher_order _ = false |
43624
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
573 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
574 |
fun polymorphism_of_type_enc (Simple_Types _) = Mangled_Monomorphic |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
575 |
| polymorphism_of_type_enc (Preds (poly, _, _)) = poly |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
576 |
| polymorphism_of_type_enc (Tags (poly, _, _)) = poly |
42613
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
577 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
578 |
fun level_of_type_enc (Simple_Types (_, level)) = level |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
579 |
| level_of_type_enc (Preds (_, level, _)) = level |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
580 |
| level_of_type_enc (Tags (_, level, _)) = level |
42828 | 581 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
582 |
fun heaviness_of_type_enc (Simple_Types _) = Heavyweight |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
583 |
| heaviness_of_type_enc (Preds (_, _, heaviness)) = heaviness |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
584 |
| heaviness_of_type_enc (Tags (_, _, heaviness)) = heaviness |
42831
c9b0968484fb
more work on "shallow" encoding + adjustments to other encodings
blanchet
parents:
42830
diff
changeset
|
585 |
|
42687 | 586 |
fun is_type_level_virtually_sound level = |
43362 | 587 |
level = All_Types orelse level = Noninf_Nonmono_Types |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
588 |
val is_type_enc_virtually_sound = |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
589 |
is_type_level_virtually_sound o level_of_type_enc |
42613
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
590 |
|
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
591 |
fun is_type_level_fairly_sound level = |
43362 | 592 |
is_type_level_virtually_sound level orelse level = Fin_Nonmono_Types |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
593 |
val is_type_enc_fairly_sound = is_type_level_fairly_sound o level_of_type_enc |
42613
23b13b1bd565
use strings to encode type systems in ATP module, to reduce the amount of out-of-place information and also to make it easier to print the type system used
blanchet
parents:
42612
diff
changeset
|
594 |
|
43624
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
595 |
fun choose_format formats (Simple_Types (order, level)) = |
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
596 |
if member (op =) formats THF then |
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
597 |
(THF, Simple_Types (order, level)) |
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
598 |
else if member (op =) formats TFF then |
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
599 |
(TFF, Simple_Types (First_Order, level)) |
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
600 |
else |
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
601 |
choose_format formats (Preds (Mangled_Monomorphic, level, Heavyweight)) |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
602 |
| choose_format formats type_enc = |
43101
1d46d85cd78b
make "prepare_atp_problem" more robust w.r.t. choice of type system
blanchet
parents:
43098
diff
changeset
|
603 |
(case hd formats of |
1d46d85cd78b
make "prepare_atp_problem" more robust w.r.t. choice of type system
blanchet
parents:
43098
diff
changeset
|
604 |
CNF_UEQ => |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
605 |
(CNF_UEQ, case type_enc of |
43101
1d46d85cd78b
make "prepare_atp_problem" more robust w.r.t. choice of type system
blanchet
parents:
43098
diff
changeset
|
606 |
Preds stuff => |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
607 |
(if is_type_enc_fairly_sound type_enc then Tags else Preds) |
43101
1d46d85cd78b
make "prepare_atp_problem" more robust w.r.t. choice of type system
blanchet
parents:
43098
diff
changeset
|
608 |
stuff |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
609 |
| _ => type_enc) |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
610 |
| format => (format, type_enc)) |
43101
1d46d85cd78b
make "prepare_atp_problem" more robust w.r.t. choice of type system
blanchet
parents:
43098
diff
changeset
|
611 |
|
40114 | 612 |
type translated_formula = |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
613 |
{name : string, |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
614 |
locality : locality, |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
615 |
kind : formula_kind, |
43859 | 616 |
iformula : (name, typ, iterm) formula, |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
617 |
atomic_types : typ list} |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
618 |
|
43859 | 619 |
fun update_iformula f ({name, locality, kind, iformula, atomic_types} |
620 |
: translated_formula) = |
|
621 |
{name = name, locality = locality, kind = kind, iformula = f iformula, |
|
42562 | 622 |
atomic_types = atomic_types} : translated_formula |
42542
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
623 |
|
43859 | 624 |
fun fact_lift f ({iformula, ...} : translated_formula) = f iformula |
42558
3d9930cb6770
cleaned up "explicit_apply" so that it shares most of its code path with the default mode of operation
blanchet
parents:
42557
diff
changeset
|
625 |
|
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
626 |
val type_instance = Sign.typ_instance o Proof_Context.theory_of |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
627 |
|
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
628 |
fun insert_type ctxt get_T x xs = |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
629 |
let val T = get_T x in |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
630 |
if exists (curry (type_instance ctxt) T o get_T) xs then xs |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
631 |
else x :: filter_out (curry (type_instance ctxt o swap) T o get_T) xs |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
632 |
end |
42677
25496cd3c199
monotonic type inference in ATP Sledgehammer problems -- based on Claessen & al.'s CADE 2011 paper, Sect. 2.3.
blanchet
parents:
42675
diff
changeset
|
633 |
|
42753
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
634 |
(* The Booleans indicate whether all type arguments should be kept. *) |
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
635 |
datatype type_arg_policy = |
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
636 |
Explicit_Type_Args of bool | |
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
637 |
Mangled_Type_Args of bool | |
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
638 |
No_Type_Args |
41136
30bedf58b177
implemented new type system encoding "overload_args", which is more lightweight than "const_args" (the unsound default) and hopefully almost as sound
blanchet
parents:
41134
diff
changeset
|
639 |
|
42836 | 640 |
fun should_drop_arg_type_args (Simple_Types _) = |
641 |
false (* since TFF doesn't support overloading *) |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
642 |
| should_drop_arg_type_args type_enc = |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
643 |
level_of_type_enc type_enc = All_Types andalso |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
644 |
heaviness_of_type_enc type_enc = Heavyweight |
42831
c9b0968484fb
more work on "shallow" encoding + adjustments to other encodings
blanchet
parents:
42830
diff
changeset
|
645 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
646 |
fun type_arg_policy type_enc s = |
43628
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
647 |
if s = type_tag_name then |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
648 |
(if polymorphism_of_type_enc type_enc = Mangled_Monomorphic then |
43623 | 649 |
Mangled_Type_Args |
650 |
else |
|
651 |
Explicit_Type_Args) false |
|
43628
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
652 |
else case type_enc of |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
653 |
Tags (_, All_Types, Heavyweight) => No_Type_Args |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
654 |
| _ => |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
655 |
if level_of_type_enc type_enc = No_Types orelse |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
656 |
s = @{const_name HOL.eq} orelse |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
657 |
(s = app_op_name andalso |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
658 |
level_of_type_enc type_enc = Const_Arg_Types) then |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
659 |
No_Type_Args |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
660 |
else |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
661 |
should_drop_arg_type_args type_enc |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
662 |
|> (if polymorphism_of_type_enc type_enc = Mangled_Monomorphic then |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
663 |
Mangled_Type_Args |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
664 |
else |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
665 |
Explicit_Type_Args) |
42227
662b50b7126f
if "monomorphize" is enabled, mangle the type information in the names by default
blanchet
parents:
42180
diff
changeset
|
666 |
|
43628
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
667 |
(* Make literals for sorted type variables. *) |
43263 | 668 |
fun generic_add_sorts_on_type (_, []) = I |
669 |
| generic_add_sorts_on_type ((x, i), s :: ss) = |
|
670 |
generic_add_sorts_on_type ((x, i), ss) |
|
671 |
#> (if s = the_single @{sort HOL.type} then |
|
43093 | 672 |
I |
673 |
else if i = ~1 then |
|
43263 | 674 |
insert (op =) (TyLitFree (`make_type_class s, `make_fixed_type_var x)) |
43093 | 675 |
else |
43263 | 676 |
insert (op =) (TyLitVar (`make_type_class s, |
677 |
(make_schematic_type_var (x, i), x)))) |
|
678 |
fun add_sorts_on_tfree (TFree (s, S)) = generic_add_sorts_on_type ((s, ~1), S) |
|
679 |
| add_sorts_on_tfree _ = I |
|
680 |
fun add_sorts_on_tvar (TVar z) = generic_add_sorts_on_type z |
|
681 |
| add_sorts_on_tvar _ = I |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
682 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
683 |
fun type_literals_for_types type_enc add_sorts_on_typ Ts = |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
684 |
[] |> level_of_type_enc type_enc <> No_Types ? fold add_sorts_on_typ Ts |
41137
8b634031b2a5
implemented "no_types" encoding, which is too unsound to be useful but can come in handy for evaluations
blanchet
parents:
41136
diff
changeset
|
685 |
|
42534
46e690db16b8
fake type declarations for full-type args and mangled type encodings, so that type assumptions can be discharged
blanchet
parents:
42533
diff
changeset
|
686 |
fun mk_aconns c phis = |
46e690db16b8
fake type declarations for full-type args and mangled type encodings, so that type assumptions can be discharged
blanchet
parents:
42533
diff
changeset
|
687 |
let val (phis', phi') = split_last phis in |
46e690db16b8
fake type declarations for full-type args and mangled type encodings, so that type assumptions can be discharged
blanchet
parents:
42533
diff
changeset
|
688 |
fold_rev (mk_aconn c) phis' phi' |
46e690db16b8
fake type declarations for full-type args and mangled type encodings, so that type assumptions can be discharged
blanchet
parents:
42533
diff
changeset
|
689 |
end |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
690 |
fun mk_ahorn [] phi = phi |
42534
46e690db16b8
fake type declarations for full-type args and mangled type encodings, so that type assumptions can be discharged
blanchet
parents:
42533
diff
changeset
|
691 |
| mk_ahorn phis psi = AConn (AImplies, [mk_aconns AAnd phis, psi]) |
42522
413b56894f82
close ATP formulas universally earlier, so that we can add type predicates
blanchet
parents:
42521
diff
changeset
|
692 |
fun mk_aquant _ [] phi = phi |
413b56894f82
close ATP formulas universally earlier, so that we can add type predicates
blanchet
parents:
42521
diff
changeset
|
693 |
| mk_aquant q xs (phi as AQuant (q', xs', phi')) = |
413b56894f82
close ATP formulas universally earlier, so that we can add type predicates
blanchet
parents:
42521
diff
changeset
|
694 |
if q = q' then AQuant (q, xs @ xs', phi') else AQuant (q, xs, phi) |
413b56894f82
close ATP formulas universally earlier, so that we can add type predicates
blanchet
parents:
42521
diff
changeset
|
695 |
| mk_aquant q xs phi = AQuant (q, xs, phi) |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
696 |
|
42522
413b56894f82
close ATP formulas universally earlier, so that we can add type predicates
blanchet
parents:
42521
diff
changeset
|
697 |
fun close_universally atom_vars phi = |
41145
a5ee3b8e5a90
improve partially tagged encoding by adding a helper fact that coalesces consecutive "ti" tags
blanchet
parents:
41140
diff
changeset
|
698 |
let |
a5ee3b8e5a90
improve partially tagged encoding by adding a helper fact that coalesces consecutive "ti" tags
blanchet
parents:
41140
diff
changeset
|
699 |
fun formula_vars bounds (AQuant (_, xs, phi)) = |
42526 | 700 |
formula_vars (map fst xs @ bounds) phi |
41145
a5ee3b8e5a90
improve partially tagged encoding by adding a helper fact that coalesces consecutive "ti" tags
blanchet
parents:
41140
diff
changeset
|
701 |
| formula_vars bounds (AConn (_, phis)) = fold (formula_vars bounds) phis |
42522
413b56894f82
close ATP formulas universally earlier, so that we can add type predicates
blanchet
parents:
42521
diff
changeset
|
702 |
| formula_vars bounds (AAtom tm) = |
42526 | 703 |
union (op =) (atom_vars tm [] |
704 |
|> filter_out (member (op =) bounds o fst)) |
|
42522
413b56894f82
close ATP formulas universally earlier, so that we can add type predicates
blanchet
parents:
42521
diff
changeset
|
705 |
in mk_aquant AForall (formula_vars [] phi []) phi end |
413b56894f82
close ATP formulas universally earlier, so that we can add type predicates
blanchet
parents:
42521
diff
changeset
|
706 |
|
43859 | 707 |
fun iterm_vars (IApp (tm1, tm2)) = fold iterm_vars [tm1, tm2] |
708 |
| iterm_vars (IConst _) = I |
|
709 |
| iterm_vars (IVar (name, T)) = insert (op =) (name, SOME T) |
|
710 |
| iterm_vars (IAbs (_, tm)) = iterm_vars tm |
|
711 |
fun close_iformula_universally phi = close_universally iterm_vars phi |
|
42522
413b56894f82
close ATP formulas universally earlier, so that we can add type predicates
blanchet
parents:
42521
diff
changeset
|
712 |
|
43676
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
713 |
fun term_vars bounds (ATerm (name as (s, _), tms)) = |
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
714 |
(is_tptp_variable s andalso not (member (op =) bounds name)) |
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
715 |
? insert (op =) (name, NONE) #> fold (term_vars bounds) tms |
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
716 |
| term_vars bounds (AAbs ((name, _), tm)) = term_vars (name :: bounds) tm |
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
717 |
fun close_formula_universally phi = close_universally (term_vars []) phi |
41145
a5ee3b8e5a90
improve partially tagged encoding by adding a helper fact that coalesces consecutive "ti" tags
blanchet
parents:
41140
diff
changeset
|
718 |
|
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
719 |
val homo_infinite_type_name = @{type_name ind} (* any infinite type *) |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
720 |
val homo_infinite_type = Type (homo_infinite_type_name, []) |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
721 |
|
43676
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
722 |
fun ho_term_from_typ format type_enc = |
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
723 |
let |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
724 |
fun term (Type (s, Ts)) = |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
725 |
ATerm (case (is_type_enc_higher_order type_enc, s) of |
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
726 |
(true, @{type_name bool}) => `I tptp_bool_type |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
727 |
| (true, @{type_name fun}) => `I tptp_fun_type |
43178
b5862142d378
use "" type only in THF and TFF -- might cause strange failures if used in FOF or CNF, depending on how liberal the prover is
blanchet
parents:
43175
diff
changeset
|
728 |
| _ => if s = homo_infinite_type_name andalso |
b5862142d378
use "" type only in THF and TFF -- might cause strange failures if used in FOF or CNF, depending on how liberal the prover is
blanchet
parents:
43175
diff
changeset
|
729 |
(format = TFF orelse format = THF) then |
b5862142d378
use "" type only in THF and TFF -- might cause strange failures if used in FOF or CNF, depending on how liberal the prover is
blanchet
parents:
43175
diff
changeset
|
730 |
`I tptp_individual_type |
b5862142d378
use "" type only in THF and TFF -- might cause strange failures if used in FOF or CNF, depending on how liberal the prover is
blanchet
parents:
43175
diff
changeset
|
731 |
else |
b5862142d378
use "" type only in THF and TFF -- might cause strange failures if used in FOF or CNF, depending on how liberal the prover is
blanchet
parents:
43175
diff
changeset
|
732 |
`make_fixed_type_const s, |
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
733 |
map term Ts) |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
734 |
| term (TFree (s, _)) = ATerm (`make_fixed_type_var s, []) |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
735 |
| term (TVar ((x as (s, _)), _)) = |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
736 |
ATerm ((make_schematic_type_var x, s), []) |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
737 |
in term end |
42562 | 738 |
|
43676
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
739 |
fun ho_term_for_type_arg format type_enc T = |
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
740 |
if T = dummyT then NONE else SOME (ho_term_from_typ format type_enc T) |
43401
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
741 |
|
42562 | 742 |
(* This shouldn't clash with anything else. *) |
42542
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
743 |
val mangled_type_sep = "\000" |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
744 |
|
42562 | 745 |
fun generic_mangled_type_name f (ATerm (name, [])) = f name |
746 |
| generic_mangled_type_name f (ATerm (name, tys)) = |
|
42761
8ea9c6fa8b53
fixed several bugs in Isar proof reconstruction, in particular w.r.t. mangled types and hAPP
blanchet
parents:
42755
diff
changeset
|
747 |
f name ^ "(" ^ space_implode "," (map (generic_mangled_type_name f) tys) |
8ea9c6fa8b53
fixed several bugs in Isar proof reconstruction, in particular w.r.t. mangled types and hAPP
blanchet
parents:
42755
diff
changeset
|
748 |
^ ")" |
43692 | 749 |
| generic_mangled_type_name _ _ = raise Fail "unexpected type abstraction" |
42542
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
750 |
|
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
751 |
val bool_atype = AType (`I tptp_bool_type) |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
752 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
753 |
fun make_simple_type s = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
754 |
if s = tptp_bool_type orelse s = tptp_fun_type orelse |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
755 |
s = tptp_individual_type then |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
756 |
s |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
757 |
else |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
758 |
simple_type_prefix ^ ascii_of s |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
759 |
|
43676
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
760 |
fun ho_type_from_ho_term type_enc pred_sym ary = |
42963 | 761 |
let |
762 |
fun to_atype ty = |
|
763 |
AType ((make_simple_type (generic_mangled_type_name fst ty), |
|
764 |
generic_mangled_type_name snd ty)) |
|
765 |
fun to_afun f1 f2 tys = AFun (f1 (hd tys), f2 (nth tys 1)) |
|
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
766 |
fun to_fo 0 ty = if pred_sym then bool_atype else to_atype ty |
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
767 |
| to_fo ary (ATerm (_, tys)) = to_afun to_atype (to_fo (ary - 1)) tys |
43692 | 768 |
| to_fo _ _ = raise Fail "unexpected type abstraction" |
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
769 |
fun to_ho (ty as ATerm ((s, _), tys)) = |
43676
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
770 |
if s = tptp_fun_type then to_afun to_ho to_ho tys else to_atype ty |
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
771 |
| to_ho _ = raise Fail "unexpected type abstraction" |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
772 |
in if is_type_enc_higher_order type_enc then to_ho else to_fo ary end |
42963 | 773 |
|
43677 | 774 |
fun ho_type_from_typ format type_enc pred_sym ary = |
43676
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
775 |
ho_type_from_ho_term type_enc pred_sym ary |
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
776 |
o ho_term_from_typ format type_enc |
42963 | 777 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
778 |
fun mangled_const_name format type_enc T_args (s, s') = |
42963 | 779 |
let |
43676
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
780 |
val ty_args = T_args |> map_filter (ho_term_for_type_arg format type_enc) |
42963 | 781 |
fun type_suffix f g = |
782 |
fold_rev (curry (op ^) o g o prefix mangled_type_sep |
|
783 |
o generic_mangled_type_name f) ty_args "" |
|
784 |
in (s ^ type_suffix fst ascii_of, s' ^ type_suffix snd I) end |
|
42542
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
785 |
|
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
786 |
val parse_mangled_ident = |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
787 |
Scan.many1 (not o member (op =) ["(", ")", ","]) >> implode |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
788 |
|
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
789 |
fun parse_mangled_type x = |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
790 |
(parse_mangled_ident |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
791 |
-- Scan.optional ($$ "(" |-- Scan.optional parse_mangled_types [] --| $$ ")") |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
792 |
[] >> ATerm) x |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
793 |
and parse_mangled_types x = |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
794 |
(parse_mangled_type ::: Scan.repeat ($$ "," |-- parse_mangled_type)) x |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
795 |
|
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
796 |
fun unmangled_type s = |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
797 |
s |> suffix ")" |> raw_explode |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
798 |
|> Scan.finite Symbol.stopper |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
799 |
(Scan.error (!! (fn _ => raise Fail ("unrecognized mangled type " ^ |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
800 |
quote s)) parse_mangled_type)) |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
801 |
|> fst |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
802 |
|
42561
23ddc4e3d19c
have properly type-instantiated helper facts (combinators and If)
blanchet
parents:
42560
diff
changeset
|
803 |
val unmangled_const_name = space_explode mangled_type_sep #> hd |
42542
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
804 |
fun unmangled_const s = |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
805 |
let val ss = space_explode mangled_type_sep s in |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
806 |
(hd ss, map unmangled_type (tl ss)) |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
807 |
end |
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
808 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
809 |
fun introduce_proxies type_enc = |
42568
7b9801a34836
no needless "fequal" proxies if "explicit_apply" is set + always have readable names
blanchet
parents:
42566
diff
changeset
|
810 |
let |
43859 | 811 |
fun intro top_level (IApp (tm1, tm2)) = |
812 |
IApp (intro top_level tm1, intro false tm2) |
|
813 |
| intro top_level (IConst (name as (s, _), T, T_args)) = |
|
42570
77f94ac04f32
cleanup proxification/unproxification and make sure that "num_atp_type_args" is called on the proxy in the reconstruction code, since "c_fequal" has one type arg but the unproxified equal has 0
blanchet
parents:
42569
diff
changeset
|
814 |
(case proxify_const s of |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
815 |
SOME proxy_base => |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
816 |
if top_level orelse is_type_enc_higher_order type_enc then |
43000
bd424c3dde46
cleaner handling of equality and proxies (esp. for THF)
blanchet
parents:
42998
diff
changeset
|
817 |
case (top_level, s) of |
bd424c3dde46
cleaner handling of equality and proxies (esp. for THF)
blanchet
parents:
42998
diff
changeset
|
818 |
(_, "c_False") => (`I tptp_false, []) |
bd424c3dde46
cleaner handling of equality and proxies (esp. for THF)
blanchet
parents:
42998
diff
changeset
|
819 |
| (_, "c_True") => (`I tptp_true, []) |
bd424c3dde46
cleaner handling of equality and proxies (esp. for THF)
blanchet
parents:
42998
diff
changeset
|
820 |
| (false, "c_Not") => (`I tptp_not, []) |
bd424c3dde46
cleaner handling of equality and proxies (esp. for THF)
blanchet
parents:
42998
diff
changeset
|
821 |
| (false, "c_conj") => (`I tptp_and, []) |
bd424c3dde46
cleaner handling of equality and proxies (esp. for THF)
blanchet
parents:
42998
diff
changeset
|
822 |
| (false, "c_disj") => (`I tptp_or, []) |
bd424c3dde46
cleaner handling of equality and proxies (esp. for THF)
blanchet
parents:
42998
diff
changeset
|
823 |
| (false, "c_implies") => (`I tptp_implies, []) |
43678 | 824 |
| (false, "c_All") => (`I tptp_ho_forall, []) |
825 |
| (false, "c_Ex") => (`I tptp_ho_exists, []) |
|
43000
bd424c3dde46
cleaner handling of equality and proxies (esp. for THF)
blanchet
parents:
42998
diff
changeset
|
826 |
| (false, s) => |
43017
944b19ab6003
removed THF equality proxy hack now that Geoff Sutcliffe has fixed SystemOnTPTP
blanchet
parents:
43001
diff
changeset
|
827 |
if is_tptp_equal s then (`I tptp_equal, []) |
944b19ab6003
removed THF equality proxy hack now that Geoff Sutcliffe has fixed SystemOnTPTP
blanchet
parents:
43001
diff
changeset
|
828 |
else (proxy_base |>> prefix const_prefix, T_args) |
43000
bd424c3dde46
cleaner handling of equality and proxies (esp. for THF)
blanchet
parents:
42998
diff
changeset
|
829 |
| _ => (name, []) |
42569
5737947e4c77
make sure that fequal keeps its type arguments for mangled type systems
blanchet
parents:
42568
diff
changeset
|
830 |
else |
42574 | 831 |
(proxy_base |>> prefix const_prefix, T_args) |
832 |
| NONE => (name, T_args)) |
|
43859 | 833 |
|> (fn (name, T_args) => IConst (name, T, T_args)) |
834 |
| intro _ (IAbs (bound, tm)) = IAbs (bound, intro false tm) |
|
43017
944b19ab6003
removed THF equality proxy hack now that Geoff Sutcliffe has fixed SystemOnTPTP
blanchet
parents:
43001
diff
changeset
|
835 |
| intro _ tm = tm |
944b19ab6003
removed THF equality proxy hack now that Geoff Sutcliffe has fixed SystemOnTPTP
blanchet
parents:
43001
diff
changeset
|
836 |
in intro true end |
42568
7b9801a34836
no needless "fequal" proxies if "explicit_apply" is set + always have readable names
blanchet
parents:
42566
diff
changeset
|
837 |
|
43859 | 838 |
fun iformula_from_prop thy type_enc eq_as_iff = |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
839 |
let |
42568
7b9801a34836
no needless "fequal" proxies if "explicit_apply" is set + always have readable names
blanchet
parents:
42566
diff
changeset
|
840 |
fun do_term bs t atomic_types = |
43859 | 841 |
iterm_from_term thy bs (Envir.eta_contract t) |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
842 |
|>> (introduce_proxies type_enc #> AAtom) |
42568
7b9801a34836
no needless "fequal" proxies if "explicit_apply" is set + always have readable names
blanchet
parents:
42566
diff
changeset
|
843 |
||> union (op =) atomic_types |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
844 |
fun do_quant bs q s T t' = |
43324
2b47822868e4
discontinued Name.variant to emphasize that this is old-style / indirect;
wenzelm
parents:
43304
diff
changeset
|
845 |
let val s = singleton (Name.variant_list (map fst bs)) s in |
38518
54727b44e277
handle bound name conflicts gracefully in FOF translation
blanchet
parents:
38496
diff
changeset
|
846 |
do_formula ((s, T) :: bs) t' |
42562 | 847 |
#>> mk_aquant q [(`make_bound_var s, SOME T)] |
38518
54727b44e277
handle bound name conflicts gracefully in FOF translation
blanchet
parents:
38496
diff
changeset
|
848 |
end |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
849 |
and do_conn bs c t1 t2 = |
43198 | 850 |
do_formula bs t1 ##>> do_formula bs t2 #>> uncurry (mk_aconn c) |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
851 |
and do_formula bs t = |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
852 |
case t of |
43096 | 853 |
@{const Trueprop} $ t1 => do_formula bs t1 |
854 |
| @{const Not} $ t1 => do_formula bs t1 #>> mk_anot |
|
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
855 |
| Const (@{const_name All}, _) $ Abs (s, T, t') => |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
856 |
do_quant bs AForall s T t' |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
857 |
| Const (@{const_name Ex}, _) $ Abs (s, T, t') => |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
858 |
do_quant bs AExists s T t' |
38795
848be46708dc
formerly unnamed infix conjunction and disjunction now named HOL.conj and HOL.disj
haftmann
parents:
38786
diff
changeset
|
859 |
| @{const HOL.conj} $ t1 $ t2 => do_conn bs AAnd t1 t2 |
848be46708dc
formerly unnamed infix conjunction and disjunction now named HOL.conj and HOL.disj
haftmann
parents:
38786
diff
changeset
|
860 |
| @{const HOL.disj} $ t1 $ t2 => do_conn bs AOr t1 t2 |
38786
e46e7a9cb622
formerly unnamed infix impliciation now named HOL.implies
haftmann
parents:
38752
diff
changeset
|
861 |
| @{const HOL.implies} $ t1 $ t2 => do_conn bs AImplies t1 t2 |
38864
4abe644fcea5
formerly unnamed infix equality now named HOL.eq
haftmann
parents:
38829
diff
changeset
|
862 |
| Const (@{const_name HOL.eq}, Type (_, [@{typ bool}, _])) $ t1 $ t2 => |
41140
9c68004b8c9d
added Sledgehammer support for higher-order propositional reasoning
blanchet
parents:
41138
diff
changeset
|
863 |
if eq_as_iff then do_conn bs AIff t1 t2 else do_term bs t |
9c68004b8c9d
added Sledgehammer support for higher-order propositional reasoning
blanchet
parents:
41138
diff
changeset
|
864 |
| _ => do_term bs t |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
865 |
in do_formula [] end |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
866 |
|
43264
a1a48c69d623
don't needlessly presimplify -- makes ATP problem preparation much faster
blanchet
parents:
43263
diff
changeset
|
867 |
fun presimplify_term _ [] t = t |
a1a48c69d623
don't needlessly presimplify -- makes ATP problem preparation much faster
blanchet
parents:
43263
diff
changeset
|
868 |
| presimplify_term ctxt presimp_consts t = |
a1a48c69d623
don't needlessly presimplify -- makes ATP problem preparation much faster
blanchet
parents:
43263
diff
changeset
|
869 |
t |> exists_Const (member (op =) presimp_consts o fst) t |
a1a48c69d623
don't needlessly presimplify -- makes ATP problem preparation much faster
blanchet
parents:
43263
diff
changeset
|
870 |
? (Skip_Proof.make_thm (Proof_Context.theory_of ctxt) |
a1a48c69d623
don't needlessly presimplify -- makes ATP problem preparation much faster
blanchet
parents:
43263
diff
changeset
|
871 |
#> Meson.presimplify ctxt |
a1a48c69d623
don't needlessly presimplify -- makes ATP problem preparation much faster
blanchet
parents:
43263
diff
changeset
|
872 |
#> prop_of) |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
873 |
|
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
874 |
fun concealed_bound_name j = atp_weak_prefix ^ string_of_int j |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
875 |
fun conceal_bounds Ts t = |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
876 |
subst_bounds (map (Free o apfst concealed_bound_name) |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
877 |
(0 upto length Ts - 1 ~~ Ts), t) |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
878 |
fun reveal_bounds Ts = |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
879 |
subst_atomic (map (fn (j, T) => (Free (concealed_bound_name j, T), Bound j)) |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
880 |
(0 upto length Ts - 1 ~~ Ts)) |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
881 |
|
43265 | 882 |
fun is_fun_equality (@{const_name HOL.eq}, |
883 |
Type (_, [Type (@{type_name fun}, _), _])) = true |
|
884 |
| is_fun_equality _ = false |
|
885 |
||
42747
f132d13fcf75
use the same code for extensionalization in Metis and Sledgehammer and generalize that code so that it gracefully handles negations (e.g. negated conjecture), formulas of the form (%x. t) = u, etc.
blanchet
parents:
42742
diff
changeset
|
886 |
fun extensionalize_term ctxt t = |
43265 | 887 |
if exists_Const is_fun_equality t then |
888 |
let val thy = Proof_Context.theory_of ctxt in |
|
889 |
t |> cterm_of thy |> Meson.extensionalize_conv ctxt |
|
890 |
|> prop_of |> Logic.dest_equals |> snd |
|
891 |
end |
|
892 |
else |
|
893 |
t |
|
38608
01ed56c46259
beta eta contract the Sledgehammer conjecture (and also the axioms, although this might not be needed), just like Metis does (implicitly);
blanchet
parents:
38606
diff
changeset
|
894 |
|
43862 | 895 |
fun simple_translate_lambdas do_lambdas ctxt t = |
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
896 |
let val thy = Proof_Context.theory_of ctxt in |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
897 |
if Meson.is_fol_term thy t then |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
898 |
t |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
899 |
else |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
900 |
let |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
901 |
fun aux Ts t = |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
902 |
case t of |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
903 |
@{const Not} $ t1 => @{const Not} $ aux Ts t1 |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
904 |
| (t0 as Const (@{const_name All}, _)) $ Abs (s, T, t') => |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
905 |
t0 $ Abs (s, T, aux (T :: Ts) t') |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
906 |
| (t0 as Const (@{const_name All}, _)) $ t1 => |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
907 |
aux Ts (t0 $ eta_expand Ts t1 1) |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
908 |
| (t0 as Const (@{const_name Ex}, _)) $ Abs (s, T, t') => |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
909 |
t0 $ Abs (s, T, aux (T :: Ts) t') |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
910 |
| (t0 as Const (@{const_name Ex}, _)) $ t1 => |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
911 |
aux Ts (t0 $ eta_expand Ts t1 1) |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
912 |
| (t0 as @{const HOL.conj}) $ t1 $ t2 => t0 $ aux Ts t1 $ aux Ts t2 |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
913 |
| (t0 as @{const HOL.disj}) $ t1 $ t2 => t0 $ aux Ts t1 $ aux Ts t2 |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
914 |
| (t0 as @{const HOL.implies}) $ t1 $ t2 => t0 $ aux Ts t1 $ aux Ts t2 |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
915 |
| (t0 as Const (@{const_name HOL.eq}, Type (_, [@{typ bool}, _]))) |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
916 |
$ t1 $ t2 => |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
917 |
t0 $ aux Ts t1 $ aux Ts t2 |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
918 |
| _ => |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
919 |
if not (exists_subterm (fn Abs _ => true | _ => false) t) then t |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
920 |
else t |> Envir.eta_contract |> do_lambdas ctxt Ts |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
921 |
val (t, ctxt') = Variable.import_terms true [t] ctxt |>> the_single |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
922 |
in t |> aux [] |> singleton (Variable.export_terms ctxt' ctxt) end |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
923 |
end |
43856
d636b053d4ff
move more lambda-handling logic to Sledgehammer, from ATP module, for formal dependency reasons
blanchet
parents:
43830
diff
changeset
|
924 |
|
d636b053d4ff
move more lambda-handling logic to Sledgehammer, from ATP module, for formal dependency reasons
blanchet
parents:
43830
diff
changeset
|
925 |
fun do_conceal_lambdas Ts (t1 $ t2) = |
d636b053d4ff
move more lambda-handling logic to Sledgehammer, from ATP module, for formal dependency reasons
blanchet
parents:
43830
diff
changeset
|
926 |
do_conceal_lambdas Ts t1 $ do_conceal_lambdas Ts t2 |
d636b053d4ff
move more lambda-handling logic to Sledgehammer, from ATP module, for formal dependency reasons
blanchet
parents:
43830
diff
changeset
|
927 |
| do_conceal_lambdas Ts (Abs (_, T, t)) = |
43828
e07a2c4cbad8
move lambda translation option from ATP to Sledgehammer, to avoid accidentally breaking Metis (its reconstruction code can only deal with combinators)
blanchet
parents:
43827
diff
changeset
|
928 |
(* slightly unsound because of hash collisions *) |
43827
62d64709af3b
added option to control which lambda translation to use (for experiments)
blanchet
parents:
43693
diff
changeset
|
929 |
Free (concealed_lambda_prefix ^ string_of_int (hash_term t), |
62d64709af3b
added option to control which lambda translation to use (for experiments)
blanchet
parents:
43693
diff
changeset
|
930 |
T --> fastype_of1 (Ts, t)) |
43856
d636b053d4ff
move more lambda-handling logic to Sledgehammer, from ATP module, for formal dependency reasons
blanchet
parents:
43830
diff
changeset
|
931 |
| do_conceal_lambdas _ t = t |
43862 | 932 |
val conceal_lambdas = simple_translate_lambdas (K do_conceal_lambdas) |
43856
d636b053d4ff
move more lambda-handling logic to Sledgehammer, from ATP module, for formal dependency reasons
blanchet
parents:
43830
diff
changeset
|
933 |
|
43862 | 934 |
fun do_introduce_combinators ctxt Ts t = |
42361 | 935 |
let val thy = Proof_Context.theory_of ctxt in |
43905
1ace987e22e5
avoid calling "Term.is_first_order" (indirectly) on a term with loose de Bruijns -- this is not necessary anyway because of the Abs check in "simple_translate_lambdas"
blanchet
parents:
43864
diff
changeset
|
936 |
t |> conceal_bounds Ts |
1ace987e22e5
avoid calling "Term.is_first_order" (indirectly) on a term with loose de Bruijns -- this is not necessary anyway because of the Abs check in "simple_translate_lambdas"
blanchet
parents:
43864
diff
changeset
|
937 |
|> cterm_of thy |
1ace987e22e5
avoid calling "Term.is_first_order" (indirectly) on a term with loose de Bruijns -- this is not necessary anyway because of the Abs check in "simple_translate_lambdas"
blanchet
parents:
43864
diff
changeset
|
938 |
|> Meson_Clausify.introduce_combinators_in_cterm |
1ace987e22e5
avoid calling "Term.is_first_order" (indirectly) on a term with loose de Bruijns -- this is not necessary anyway because of the Abs check in "simple_translate_lambdas"
blanchet
parents:
43864
diff
changeset
|
939 |
|> prop_of |> Logic.dest_equals |> snd |
1ace987e22e5
avoid calling "Term.is_first_order" (indirectly) on a term with loose de Bruijns -- this is not necessary anyway because of the Abs check in "simple_translate_lambdas"
blanchet
parents:
43864
diff
changeset
|
940 |
|> reveal_bounds Ts |
38491
f7e51d981a9f
invoke Variable.export/import_term on the entire formula, to make sure that schematic variables don't get different indices in different subterms;
blanchet
parents:
38282
diff
changeset
|
941 |
end |
43862 | 942 |
(* A type variable of sort "{}" will make abstraction fail. *) |
43864
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
943 |
handle THM _ => t |> do_conceal_lambdas Ts |
43862 | 944 |
val introduce_combinators = simple_translate_lambdas do_introduce_combinators |
945 |
||
43864
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
946 |
fun preprocess_abstractions_in_terms trans_lambdas facts = |
43862 | 947 |
let |
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
948 |
val (facts, lambda_ts) = |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
949 |
facts |> map (snd o snd) |> trans_lambdas |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
950 |
|>> map2 (fn (name, (kind, _)) => fn t => (name, (kind, t))) facts |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
951 |
val lambda_facts = |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
952 |
map2 (fn t => fn j => |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
953 |
((lambda_fact_prefix ^ Int.toString j, Helper), (Axiom, t))) |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
954 |
lambda_ts (1 upto length lambda_ts) |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
955 |
in (facts, lambda_facts) end |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
956 |
|
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
957 |
(* Metis's use of "resolve_tac" freezes the schematic variables. We simulate the |
42353
7797efa897a1
correctly handle TFrees that occur in (local) facts -- Metis did the right thing here but Sledgehammer was incorrectly generating spurious preconditions such as "dense_linorder(t_a)"
blanchet
parents:
42237
diff
changeset
|
958 |
same in Sledgehammer to prevent the discovery of unreplayable proofs. *) |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
959 |
fun freeze_term t = |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
960 |
let |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
961 |
fun aux (t $ u) = aux t $ aux u |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
962 |
| aux (Abs (s, T, t)) = Abs (s, T, aux t) |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
963 |
| aux (Var ((s, i), T)) = |
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
964 |
Free (atp_weak_prefix ^ s ^ "_" ^ string_of_int i, T) |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
965 |
| aux t = t |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
966 |
in t |> exists_subterm is_Var t ? aux end |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
967 |
|
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
968 |
fun presimp_prop ctxt presimp_consts t = |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
969 |
let |
42361 | 970 |
val thy = Proof_Context.theory_of ctxt |
38608
01ed56c46259
beta eta contract the Sledgehammer conjecture (and also the axioms, although this might not be needed), just like Metis does (implicitly);
blanchet
parents:
38606
diff
changeset
|
971 |
val t = t |> Envir.beta_eta_contract |
42944
9e620869a576
improved Waldmeister support -- even run it by default on unit equational goals
blanchet
parents:
42943
diff
changeset
|
972 |
|> transform_elim_prop |
41211
1e2e16bc0077
no need to do a super-duper atomization if Metis fails afterwards anyway
blanchet
parents:
41199
diff
changeset
|
973 |
|> Object_Logic.atomize_term thy |
42563 | 974 |
val need_trueprop = (fastype_of t = @{typ bool}) |
43096 | 975 |
in |
976 |
t |> need_trueprop ? HOLogic.mk_Trueprop |
|
977 |
|> Raw_Simplifier.rewrite_term thy (Meson.unfold_set_const_simps ctxt) [] |
|
978 |
|> extensionalize_term ctxt |
|
43264
a1a48c69d623
don't needlessly presimplify -- makes ATP problem preparation much faster
blanchet
parents:
43263
diff
changeset
|
979 |
|> presimplify_term ctxt presimp_consts |
43120
a9c2cdf4ae97
make sure "Trueprop" is removed before combinators are added -- the code is fragile in that respect
blanchet
parents:
43105
diff
changeset
|
980 |
|> perhaps (try (HOLogic.dest_Trueprop)) |
43096 | 981 |
end |
982 |
||
983 |
(* making fact and conjecture formulas *) |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
984 |
fun make_formula thy type_enc eq_as_iff name loc kind t = |
43096 | 985 |
let |
43859 | 986 |
val (iformula, atomic_types) = |
987 |
iformula_from_prop thy type_enc eq_as_iff t [] |
|
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
988 |
in |
43859 | 989 |
{name = name, locality = loc, kind = kind, iformula = iformula, |
42562 | 990 |
atomic_types = atomic_types} |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
991 |
end |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
992 |
|
43860
57ef3cd4126e
more refactoring of preprocessing, so as to be able to centralize it
blanchet
parents:
43859
diff
changeset
|
993 |
fun make_fact ctxt format type_enc eq_as_iff ((name, loc), t) = |
43096 | 994 |
let val thy = Proof_Context.theory_of ctxt in |
43860
57ef3cd4126e
more refactoring of preprocessing, so as to be able to centralize it
blanchet
parents:
43859
diff
changeset
|
995 |
case t |> make_formula thy type_enc (eq_as_iff andalso format <> CNF) name |
43624
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
996 |
loc Axiom of |
43859 | 997 |
formula as {iformula = AAtom (IConst ((s, _), _, _)), ...} => |
43096 | 998 |
if s = tptp_true then NONE else SOME formula |
43295
30aaab778416
pass Metis facts and negated conjecture as facts, with (almost) correctly set localities, so that the correct encoding is used for nonmonotonic occurrences of infinite types
blanchet
parents:
43293
diff
changeset
|
999 |
| formula => SOME formula |
43096 | 1000 |
end |
42561
23ddc4e3d19c
have properly type-instantiated helper facts (combinators and If)
blanchet
parents:
42560
diff
changeset
|
1001 |
|
43860
57ef3cd4126e
more refactoring of preprocessing, so as to be able to centralize it
blanchet
parents:
43859
diff
changeset
|
1002 |
fun make_conjecture ctxt format type_enc ps = |
43096 | 1003 |
let |
1004 |
val thy = Proof_Context.theory_of ctxt |
|
43860
57ef3cd4126e
more refactoring of preprocessing, so as to be able to centralize it
blanchet
parents:
43859
diff
changeset
|
1005 |
val last = length ps - 1 |
43096 | 1006 |
in |
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
1007 |
map2 (fn j => fn ((name, loc), (kind, t)) => |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
1008 |
t |> make_formula thy type_enc (format <> CNF) name loc kind |
43860
57ef3cd4126e
more refactoring of preprocessing, so as to be able to centralize it
blanchet
parents:
43859
diff
changeset
|
1009 |
|> (j <> last) = (kind = Conjecture) ? update_iformula mk_anot) |
57ef3cd4126e
more refactoring of preprocessing, so as to be able to centralize it
blanchet
parents:
43859
diff
changeset
|
1010 |
(0 upto last) ps |
38613
4ca2cae2653f
use "hypothesis" rather than "conjecture" for hypotheses in TPTP format;
blanchet
parents:
38610
diff
changeset
|
1011 |
end |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1012 |
|
42682
562046fd8e0c
added type homogenization, whereby all (isomorphic) infinite types are mapped to the same type (to reduce the number of different predicates/TFF-types)
blanchet
parents:
42680
diff
changeset
|
1013 |
(** Finite and infinite type inference **) |
562046fd8e0c
added type homogenization, whereby all (isomorphic) infinite types are mapped to the same type (to reduce the number of different predicates/TFF-types)
blanchet
parents:
42680
diff
changeset
|
1014 |
|
42886
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
1015 |
fun deep_freeze_atyp (TVar (_, S)) = TFree ("v", S) |
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
1016 |
| deep_freeze_atyp T = T |
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
1017 |
val deep_freeze_type = map_atyps deep_freeze_atyp |
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
1018 |
|
42682
562046fd8e0c
added type homogenization, whereby all (isomorphic) infinite types are mapped to the same type (to reduce the number of different predicates/TFF-types)
blanchet
parents:
42680
diff
changeset
|
1019 |
(* Finite types such as "unit", "bool", "bool * bool", and "bool => bool" are |
562046fd8e0c
added type homogenization, whereby all (isomorphic) infinite types are mapped to the same type (to reduce the number of different predicates/TFF-types)
blanchet
parents:
42680
diff
changeset
|
1020 |
dangerous because their "exhaust" properties can easily lead to unsound ATP |
562046fd8e0c
added type homogenization, whereby all (isomorphic) infinite types are mapped to the same type (to reduce the number of different predicates/TFF-types)
blanchet
parents:
42680
diff
changeset
|
1021 |
proofs. On the other hand, all HOL infinite types can be given the same |
562046fd8e0c
added type homogenization, whereby all (isomorphic) infinite types are mapped to the same type (to reduce the number of different predicates/TFF-types)
blanchet
parents:
42680
diff
changeset
|
1022 |
models in first-order logic (via Löwenheim-Skolem). *) |
562046fd8e0c
added type homogenization, whereby all (isomorphic) infinite types are mapped to the same type (to reduce the number of different predicates/TFF-types)
blanchet
parents:
42680
diff
changeset
|
1023 |
|
42886
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
1024 |
fun should_encode_type ctxt (nonmono_Ts as _ :: _) _ T = |
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
1025 |
exists (curry (type_instance ctxt) (deep_freeze_type T)) nonmono_Ts |
42836 | 1026 |
| should_encode_type _ _ All_Types _ = true |
43572
ae612a423dad
added "sound" option to force Sledgehammer to be pedantically sound
blanchet
parents:
43501
diff
changeset
|
1027 |
| should_encode_type ctxt _ Fin_Nonmono_Types T = |
ae612a423dad
added "sound" option to force Sledgehammer to be pedantically sound
blanchet
parents:
43501
diff
changeset
|
1028 |
is_type_surely_finite ctxt false T |
42682
562046fd8e0c
added type homogenization, whereby all (isomorphic) infinite types are mapped to the same type (to reduce the number of different predicates/TFF-types)
blanchet
parents:
42680
diff
changeset
|
1029 |
| should_encode_type _ _ _ _ = false |
562046fd8e0c
added type homogenization, whereby all (isomorphic) infinite types are mapped to the same type (to reduce the number of different predicates/TFF-types)
blanchet
parents:
42680
diff
changeset
|
1030 |
|
42837 | 1031 |
fun should_predicate_on_type ctxt nonmono_Ts (Preds (_, level, heaviness)) |
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1032 |
should_predicate_on_var T = |
43128 | 1033 |
(heaviness = Heavyweight orelse should_predicate_on_var ()) andalso |
42878
85ac4c12a4b7
slightly fewer type predicates introduced in the lightweight encoding, based on the observation that only universal positive equalities are dangerous
blanchet
parents:
42855
diff
changeset
|
1034 |
should_encode_type ctxt nonmono_Ts level T |
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1035 |
| should_predicate_on_type _ _ _ _ _ = false |
42682
562046fd8e0c
added type homogenization, whereby all (isomorphic) infinite types are mapped to the same type (to reduce the number of different predicates/TFF-types)
blanchet
parents:
42680
diff
changeset
|
1036 |
|
43859 | 1037 |
fun is_var_or_bound_var (IConst ((s, _), _, _)) = |
42836 | 1038 |
String.isPrefix bound_var_prefix s |
43859 | 1039 |
| is_var_or_bound_var (IVar _) = true |
42836 | 1040 |
| is_var_or_bound_var _ = false |
1041 |
||
43361
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1042 |
datatype tag_site = |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1043 |
Top_Level of bool option | |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1044 |
Eq_Arg of bool option | |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1045 |
Elsewhere |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1046 |
|
43361
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1047 |
fun should_tag_with_type _ _ _ (Top_Level _) _ _ = false |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1048 |
| should_tag_with_type ctxt nonmono_Ts (Tags (poly, level, heaviness)) site |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1049 |
u T = |
42837 | 1050 |
(case heaviness of |
43128 | 1051 |
Heavyweight => should_encode_type ctxt nonmono_Ts level T |
1052 |
| Lightweight => |
|
42836 | 1053 |
case (site, is_var_or_bound_var u) of |
43361
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1054 |
(Eq_Arg pos, true) => |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1055 |
(* The first disjunct prevents a subtle soundness issue explained in |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1056 |
Blanchette's Ph.D. thesis. See also |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1057 |
"formula_lines_for_lightweight_tags_sym_decl". *) |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1058 |
(pos <> SOME false andalso poly = Polymorphic andalso |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1059 |
level <> All_Types andalso heaviness = Lightweight andalso |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1060 |
exists (fn T' => type_instance ctxt (T', T)) nonmono_Ts) orelse |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1061 |
should_encode_type ctxt nonmono_Ts level T |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1062 |
| _ => false) |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1063 |
| should_tag_with_type _ _ _ _ _ _ = false |
42682
562046fd8e0c
added type homogenization, whereby all (isomorphic) infinite types are mapped to the same type (to reduce the number of different predicates/TFF-types)
blanchet
parents:
42680
diff
changeset
|
1064 |
|
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1065 |
fun homogenized_type ctxt nonmono_Ts level = |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1066 |
let |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1067 |
val should_encode = should_encode_type ctxt nonmono_Ts level |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1068 |
fun homo 0 T = if should_encode T then T else homo_infinite_type |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1069 |
| homo ary (Type (@{type_name fun}, [T1, T2])) = |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1070 |
homo 0 T1 --> homo (ary - 1) T2 |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1071 |
| homo _ _ = raise Fail "expected function type" |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1072 |
in homo end |
42682
562046fd8e0c
added type homogenization, whereby all (isomorphic) infinite types are mapped to the same type (to reduce the number of different predicates/TFF-types)
blanchet
parents:
42680
diff
changeset
|
1073 |
|
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1074 |
(** "hBOOL" and "hAPP" **) |
41313
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1075 |
|
42574 | 1076 |
type sym_info = |
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1077 |
{pred_sym : bool, min_ary : int, max_ary : int, types : typ list} |
42563 | 1078 |
|
43859 | 1079 |
fun add_iterm_syms_to_table ctxt explicit_apply = |
42558
3d9930cb6770
cleaned up "explicit_apply" so that it shares most of its code path with the default mode of operation
blanchet
parents:
42557
diff
changeset
|
1080 |
let |
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1081 |
fun consider_var_arity const_T var_T max_ary = |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1082 |
let |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1083 |
fun iter ary T = |
43210
7384b771805d
made "explicit_apply"'s smart mode (more) complete
blanchet
parents:
43207
diff
changeset
|
1084 |
if ary = max_ary orelse type_instance ctxt (var_T, T) orelse |
7384b771805d
made "explicit_apply"'s smart mode (more) complete
blanchet
parents:
43207
diff
changeset
|
1085 |
type_instance ctxt (T, var_T) then |
7384b771805d
made "explicit_apply"'s smart mode (more) complete
blanchet
parents:
43207
diff
changeset
|
1086 |
ary |
7384b771805d
made "explicit_apply"'s smart mode (more) complete
blanchet
parents:
43207
diff
changeset
|
1087 |
else |
7384b771805d
made "explicit_apply"'s smart mode (more) complete
blanchet
parents:
43207
diff
changeset
|
1088 |
iter (ary + 1) (range_type T) |
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1089 |
in iter 0 const_T end |
43201
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1090 |
fun add_var_or_bound_var T (accum as ((bool_vars, fun_var_Ts), sym_tab)) = |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1091 |
if explicit_apply = NONE andalso |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1092 |
(can dest_funT T orelse T = @{typ bool}) then |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1093 |
let |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1094 |
val bool_vars' = bool_vars orelse body_type T = @{typ bool} |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1095 |
fun repair_min_arity {pred_sym, min_ary, max_ary, types} = |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1096 |
{pred_sym = pred_sym andalso not bool_vars', |
43213
e1fdd27e0c98
generate less type information in polymorphic case
blanchet
parents:
43210
diff
changeset
|
1097 |
min_ary = fold (fn T' => consider_var_arity T' T) types min_ary, |
43201
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1098 |
max_ary = max_ary, types = types} |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1099 |
val fun_var_Ts' = |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1100 |
fun_var_Ts |> can dest_funT T ? insert_type ctxt I T |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1101 |
in |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1102 |
if bool_vars' = bool_vars andalso |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1103 |
pointer_eq (fun_var_Ts', fun_var_Ts) then |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1104 |
accum |
43167
839f599bc7ed
ensured that the logic for "explicit_apply = smart" also works on CNF (i.e. new Metis)
blanchet
parents:
43159
diff
changeset
|
1105 |
else |
43213
e1fdd27e0c98
generate less type information in polymorphic case
blanchet
parents:
43210
diff
changeset
|
1106 |
((bool_vars', fun_var_Ts'), Symtab.map (K repair_min_arity) sym_tab) |
43201
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1107 |
end |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1108 |
else |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1109 |
accum |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1110 |
fun add top_level tm (accum as ((bool_vars, fun_var_Ts), sym_tab)) = |
43859 | 1111 |
let val (head, args) = strip_iterm_comb tm in |
42558
3d9930cb6770
cleaned up "explicit_apply" so that it shares most of its code path with the default mode of operation
blanchet
parents:
42557
diff
changeset
|
1112 |
(case head of |
43859 | 1113 |
IConst ((s, _), T, _) => |
42558
3d9930cb6770
cleaned up "explicit_apply" so that it shares most of its code path with the default mode of operation
blanchet
parents:
42557
diff
changeset
|
1114 |
if String.isPrefix bound_var_prefix s then |
43201
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1115 |
add_var_or_bound_var T accum |
42558
3d9930cb6770
cleaned up "explicit_apply" so that it shares most of its code path with the default mode of operation
blanchet
parents:
42557
diff
changeset
|
1116 |
else |
43139
9ed5d8ad8fa0
fixed debilitating translation bug introduced in b6e61d22fa61 -- "equal" and "=" should always have arity 2
blanchet
parents:
43136
diff
changeset
|
1117 |
let val ary = length args in |
43201
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1118 |
((bool_vars, fun_var_Ts), |
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1119 |
case Symtab.lookup sym_tab s of |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1120 |
SOME {pred_sym, min_ary, max_ary, types} => |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1121 |
let |
43201
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1122 |
val pred_sym = |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1123 |
pred_sym andalso top_level andalso not bool_vars |
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1124 |
val types' = types |> insert_type ctxt I T |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1125 |
val min_ary = |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1126 |
if is_some explicit_apply orelse |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1127 |
pointer_eq (types', types) then |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1128 |
min_ary |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1129 |
else |
43201
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1130 |
fold (consider_var_arity T) fun_var_Ts min_ary |
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1131 |
in |
43201
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1132 |
Symtab.update (s, {pred_sym = pred_sym, |
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1133 |
min_ary = Int.min (ary, min_ary), |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1134 |
max_ary = Int.max (ary, max_ary), |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1135 |
types = types'}) |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1136 |
sym_tab |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1137 |
end |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1138 |
| NONE => |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1139 |
let |
43201
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1140 |
val pred_sym = top_level andalso not bool_vars |
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1141 |
val min_ary = |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1142 |
case explicit_apply of |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1143 |
SOME true => 0 |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1144 |
| SOME false => ary |
43201
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1145 |
| NONE => fold (consider_var_arity T) fun_var_Ts ary |
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1146 |
in |
43201
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1147 |
Symtab.update_new (s, {pred_sym = pred_sym, |
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1148 |
min_ary = min_ary, max_ary = ary, |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1149 |
types = [T]}) |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1150 |
sym_tab |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1151 |
end) |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1152 |
end |
43859 | 1153 |
| IVar (_, T) => add_var_or_bound_var T accum |
1154 |
| IAbs ((_, T), tm) => accum |> add_var_or_bound_var T |> add false tm |
|
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1155 |
| _ => accum) |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1156 |
|> fold (add false) args |
42558
3d9930cb6770
cleaned up "explicit_apply" so that it shares most of its code path with the default mode of operation
blanchet
parents:
42557
diff
changeset
|
1157 |
end |
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1158 |
in add true end |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1159 |
fun add_fact_syms_to_table ctxt explicit_apply = |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1160 |
fact_lift (formula_fold NONE |
43859 | 1161 |
(K (add_iterm_syms_to_table ctxt explicit_apply))) |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1162 |
|
43139
9ed5d8ad8fa0
fixed debilitating translation bug introduced in b6e61d22fa61 -- "equal" and "=" should always have arity 2
blanchet
parents:
43136
diff
changeset
|
1163 |
val default_sym_tab_entries : (string * sym_info) list = |
43174 | 1164 |
(prefixed_predicator_name, |
43139
9ed5d8ad8fa0
fixed debilitating translation bug introduced in b6e61d22fa61 -- "equal" and "=" should always have arity 2
blanchet
parents:
43136
diff
changeset
|
1165 |
{pred_sym = true, min_ary = 1, max_ary = 1, types = []}) :: |
42568
7b9801a34836
no needless "fequal" proxies if "explicit_apply" is set + always have readable names
blanchet
parents:
42566
diff
changeset
|
1166 |
([tptp_false, tptp_true] |
43139
9ed5d8ad8fa0
fixed debilitating translation bug introduced in b6e61d22fa61 -- "equal" and "=" should always have arity 2
blanchet
parents:
43136
diff
changeset
|
1167 |
|> map (rpair {pred_sym = true, min_ary = 0, max_ary = 0, types = []})) @ |
9ed5d8ad8fa0
fixed debilitating translation bug introduced in b6e61d22fa61 -- "equal" and "=" should always have arity 2
blanchet
parents:
43136
diff
changeset
|
1168 |
([tptp_equal, tptp_old_equal] |
9ed5d8ad8fa0
fixed debilitating translation bug introduced in b6e61d22fa61 -- "equal" and "=" should always have arity 2
blanchet
parents:
43136
diff
changeset
|
1169 |
|> map (rpair {pred_sym = true, min_ary = 2, max_ary = 2, types = []})) |
41140
9c68004b8c9d
added Sledgehammer support for higher-order propositional reasoning
blanchet
parents:
41138
diff
changeset
|
1170 |
|
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1171 |
fun sym_table_for_facts ctxt explicit_apply facts = |
43201
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1172 |
((false, []), Symtab.empty) |
0c9bf1a8e0d8
make "smart" mode of "explicit_apply" smarter, by also detecting the other kind of higher-order quantification, namely "bool"s
blanchet
parents:
43198
diff
changeset
|
1173 |
|> fold (add_fact_syms_to_table ctxt explicit_apply) facts |> snd |
43139
9ed5d8ad8fa0
fixed debilitating translation bug introduced in b6e61d22fa61 -- "equal" and "=" should always have arity 2
blanchet
parents:
43136
diff
changeset
|
1174 |
|> fold Symtab.update default_sym_tab_entries |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1175 |
|
42558
3d9930cb6770
cleaned up "explicit_apply" so that it shares most of its code path with the default mode of operation
blanchet
parents:
42557
diff
changeset
|
1176 |
fun min_arity_of sym_tab s = |
3d9930cb6770
cleaned up "explicit_apply" so that it shares most of its code path with the default mode of operation
blanchet
parents:
42557
diff
changeset
|
1177 |
case Symtab.lookup sym_tab s of |
42574 | 1178 |
SOME ({min_ary, ...} : sym_info) => min_ary |
42558
3d9930cb6770
cleaned up "explicit_apply" so that it shares most of its code path with the default mode of operation
blanchet
parents:
42557
diff
changeset
|
1179 |
| NONE => |
3d9930cb6770
cleaned up "explicit_apply" so that it shares most of its code path with the default mode of operation
blanchet
parents:
42557
diff
changeset
|
1180 |
case strip_prefix_and_unascii const_prefix s of |
42547
b5eec0c99528
fixed arity of special constants if "explicit_apply" is set
blanchet
parents:
42546
diff
changeset
|
1181 |
SOME s => |
42570
77f94ac04f32
cleanup proxification/unproxification and make sure that "num_atp_type_args" is called on the proxy in the reconstruction code, since "c_fequal" has one type arg but the unproxified equal has 0
blanchet
parents:
42569
diff
changeset
|
1182 |
let val s = s |> unmangled_const_name |> invert_const in |
42966
4e2d6c1e5392
more work on parsing LEO-II proofs without lambdas
blanchet
parents:
42963
diff
changeset
|
1183 |
if s = predicator_name then 1 |
4e2d6c1e5392
more work on parsing LEO-II proofs without lambdas
blanchet
parents:
42963
diff
changeset
|
1184 |
else if s = app_op_name then 2 |
4e2d6c1e5392
more work on parsing LEO-II proofs without lambdas
blanchet
parents:
42963
diff
changeset
|
1185 |
else if s = type_pred_name then 1 |
42557
ae0deb39a254
fixed min-arity computation when "explicit_apply" is specified
blanchet
parents:
42556
diff
changeset
|
1186 |
else 0 |
42547
b5eec0c99528
fixed arity of special constants if "explicit_apply" is set
blanchet
parents:
42546
diff
changeset
|
1187 |
end |
42544
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1188 |
| NONE => 0 |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1189 |
|
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1190 |
(* True if the constant ever appears outside of the top-level position in |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1191 |
literals, or if it appears with different arities (e.g., because of different |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1192 |
type instantiations). If false, the constant always receives all of its |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1193 |
arguments and is used as a predicate. *) |
42558
3d9930cb6770
cleaned up "explicit_apply" so that it shares most of its code path with the default mode of operation
blanchet
parents:
42557
diff
changeset
|
1194 |
fun is_pred_sym sym_tab s = |
3d9930cb6770
cleaned up "explicit_apply" so that it shares most of its code path with the default mode of operation
blanchet
parents:
42557
diff
changeset
|
1195 |
case Symtab.lookup sym_tab s of |
42574 | 1196 |
SOME ({pred_sym, min_ary, max_ary, ...} : sym_info) => |
1197 |
pred_sym andalso min_ary = max_ary |
|
42558
3d9930cb6770
cleaned up "explicit_apply" so that it shares most of its code path with the default mode of operation
blanchet
parents:
42557
diff
changeset
|
1198 |
| NONE => false |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1199 |
|
42568
7b9801a34836
no needless "fequal" proxies if "explicit_apply" is set + always have readable names
blanchet
parents:
42566
diff
changeset
|
1200 |
val predicator_combconst = |
43859 | 1201 |
IConst (`make_fixed_const predicator_name, @{typ "bool => bool"}, []) |
1202 |
fun predicator tm = IApp (predicator_combconst, tm) |
|
42542
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
1203 |
|
43859 | 1204 |
fun introduce_predicators_in_iterm sym_tab tm = |
1205 |
case strip_iterm_comb tm of |
|
1206 |
(IConst ((s, _), _, _), _) => |
|
42568
7b9801a34836
no needless "fequal" proxies if "explicit_apply" is set + always have readable names
blanchet
parents:
42566
diff
changeset
|
1207 |
if is_pred_sym sym_tab s then tm else predicator tm |
7b9801a34836
no needless "fequal" proxies if "explicit_apply" is set + always have readable names
blanchet
parents:
42566
diff
changeset
|
1208 |
| _ => predicator tm |
42542
024920b65ce2
perform constant mangling and/or removal of its type args in an earlier phase, so that the rest of the code doesn't need to worry about it
blanchet
parents:
42541
diff
changeset
|
1209 |
|
43859 | 1210 |
fun list_app head args = fold (curry (IApp o swap)) args head |
42544
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1211 |
|
43130
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
1212 |
val app_op = `make_fixed_const app_op_name |
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
1213 |
|
42544
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1214 |
fun explicit_app arg head = |
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1215 |
let |
43859 | 1216 |
val head_T = ityp_of head |
42693
3c2baf9b3c61
reverted 6efda6167e5d because unsound -- Vampire found a counterexample
blanchet
parents:
42691
diff
changeset
|
1217 |
val (arg_T, res_T) = dest_funT head_T |
43859 | 1218 |
val explicit_app = IConst (app_op, head_T --> head_T, [arg_T, res_T]) |
42544
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1219 |
in list_app explicit_app [head, arg] end |
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1220 |
fun list_explicit_app head args = fold explicit_app args head |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1221 |
|
43859 | 1222 |
fun introduce_explicit_apps_in_iterm sym_tab = |
42544
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1223 |
let |
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1224 |
fun aux tm = |
43859 | 1225 |
case strip_iterm_comb tm of |
1226 |
(head as IConst ((s, _), _, _), args) => |
|
42544
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1227 |
args |> map aux |
42557
ae0deb39a254
fixed min-arity computation when "explicit_apply" is specified
blanchet
parents:
42556
diff
changeset
|
1228 |
|> chop (min_arity_of sym_tab s) |
42544
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1229 |
|>> list_app head |
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1230 |
|-> list_explicit_app |
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1231 |
| (head, args) => list_explicit_app head (map aux args) |
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1232 |
in aux end |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1233 |
|
42753
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
1234 |
fun chop_fun 0 T = ([], T) |
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
1235 |
| chop_fun n (Type (@{type_name fun}, [dom_T, ran_T])) = |
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
1236 |
chop_fun (n - 1) ran_T |>> cons dom_T |
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
1237 |
| chop_fun _ _ = raise Fail "unexpected non-function" |
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
1238 |
|
42780
be6164bc9744
avoid "UnequalLengths" exception for special constant "fequal" -- and optimize code in the common case where no type arguments are needed
blanchet
parents:
42778
diff
changeset
|
1239 |
fun filter_type_args _ _ _ [] = [] |
be6164bc9744
avoid "UnequalLengths" exception for special constant "fequal" -- and optimize code in the common case where no type arguments are needed
blanchet
parents:
42778
diff
changeset
|
1240 |
| filter_type_args thy s arity T_args = |
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1241 |
let |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1242 |
(* will throw "TYPE" for pseudo-constants *) |
42966
4e2d6c1e5392
more work on parsing LEO-II proofs without lambdas
blanchet
parents:
42963
diff
changeset
|
1243 |
val U = if s = app_op_name then |
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1244 |
@{typ "('a => 'b) => 'a => 'b"} |> Logic.varifyT_global |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1245 |
else |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1246 |
s |> Sign.the_const_type thy |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1247 |
in |
42781 | 1248 |
case Term.add_tvarsT (U |> chop_fun arity |> snd) [] of |
1249 |
[] => [] |
|
1250 |
| res_U_vars => |
|
1251 |
let val U_args = (s, U) |> Sign.const_typargs thy in |
|
1252 |
U_args ~~ T_args |
|
43401
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1253 |
|> map (fn (U, T) => |
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1254 |
if member (op =) res_U_vars (dest_TVar U) then T |
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1255 |
else dummyT) |
42781 | 1256 |
end |
42780
be6164bc9744
avoid "UnequalLengths" exception for special constant "fequal" -- and optimize code in the common case where no type arguments are needed
blanchet
parents:
42778
diff
changeset
|
1257 |
end |
be6164bc9744
avoid "UnequalLengths" exception for special constant "fequal" -- and optimize code in the common case where no type arguments are needed
blanchet
parents:
42778
diff
changeset
|
1258 |
handle TYPE _ => T_args |
42753
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
1259 |
|
43859 | 1260 |
fun enforce_type_arg_policy_in_iterm ctxt format type_enc = |
42753
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
1261 |
let |
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
1262 |
val thy = Proof_Context.theory_of ctxt |
43859 | 1263 |
fun aux arity (IApp (tm1, tm2)) = IApp (aux (arity + 1) tm1, aux 0 tm2) |
1264 |
| aux arity (IConst (name as (s, _), T, T_args)) = |
|
43179
db5fb1d4df42
don't merge "hAPP"s even in unsound heavy modes, because "hAPP" then sometimes gets declared with too strict arguments ("ind"), and we lose some proofs
blanchet
parents:
43178
diff
changeset
|
1265 |
(case strip_prefix_and_unascii const_prefix s of |
db5fb1d4df42
don't merge "hAPP"s even in unsound heavy modes, because "hAPP" then sometimes gets declared with too strict arguments ("ind"), and we lose some proofs
blanchet
parents:
43178
diff
changeset
|
1266 |
NONE => (name, T_args) |
db5fb1d4df42
don't merge "hAPP"s even in unsound heavy modes, because "hAPP" then sometimes gets declared with too strict arguments ("ind"), and we lose some proofs
blanchet
parents:
43178
diff
changeset
|
1267 |
| SOME s'' => |
db5fb1d4df42
don't merge "hAPP"s even in unsound heavy modes, because "hAPP" then sometimes gets declared with too strict arguments ("ind"), and we lose some proofs
blanchet
parents:
43178
diff
changeset
|
1268 |
let |
db5fb1d4df42
don't merge "hAPP"s even in unsound heavy modes, because "hAPP" then sometimes gets declared with too strict arguments ("ind"), and we lose some proofs
blanchet
parents:
43178
diff
changeset
|
1269 |
val s'' = invert_const s'' |
db5fb1d4df42
don't merge "hAPP"s even in unsound heavy modes, because "hAPP" then sometimes gets declared with too strict arguments ("ind"), and we lose some proofs
blanchet
parents:
43178
diff
changeset
|
1270 |
fun filtered_T_args false = T_args |
db5fb1d4df42
don't merge "hAPP"s even in unsound heavy modes, because "hAPP" then sometimes gets declared with too strict arguments ("ind"), and we lose some proofs
blanchet
parents:
43178
diff
changeset
|
1271 |
| filtered_T_args true = filter_type_args thy s'' arity T_args |
db5fb1d4df42
don't merge "hAPP"s even in unsound heavy modes, because "hAPP" then sometimes gets declared with too strict arguments ("ind"), and we lose some proofs
blanchet
parents:
43178
diff
changeset
|
1272 |
in |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1273 |
case type_arg_policy type_enc s'' of |
43179
db5fb1d4df42
don't merge "hAPP"s even in unsound heavy modes, because "hAPP" then sometimes gets declared with too strict arguments ("ind"), and we lose some proofs
blanchet
parents:
43178
diff
changeset
|
1274 |
Explicit_Type_Args drop_args => |
db5fb1d4df42
don't merge "hAPP"s even in unsound heavy modes, because "hAPP" then sometimes gets declared with too strict arguments ("ind"), and we lose some proofs
blanchet
parents:
43178
diff
changeset
|
1275 |
(name, filtered_T_args drop_args) |
db5fb1d4df42
don't merge "hAPP"s even in unsound heavy modes, because "hAPP" then sometimes gets declared with too strict arguments ("ind"), and we lose some proofs
blanchet
parents:
43178
diff
changeset
|
1276 |
| Mangled_Type_Args drop_args => |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1277 |
(mangled_const_name format type_enc (filtered_T_args drop_args) |
43179
db5fb1d4df42
don't merge "hAPP"s even in unsound heavy modes, because "hAPP" then sometimes gets declared with too strict arguments ("ind"), and we lose some proofs
blanchet
parents:
43178
diff
changeset
|
1278 |
name, []) |
db5fb1d4df42
don't merge "hAPP"s even in unsound heavy modes, because "hAPP" then sometimes gets declared with too strict arguments ("ind"), and we lose some proofs
blanchet
parents:
43178
diff
changeset
|
1279 |
| No_Type_Args => (name, []) |
db5fb1d4df42
don't merge "hAPP"s even in unsound heavy modes, because "hAPP" then sometimes gets declared with too strict arguments ("ind"), and we lose some proofs
blanchet
parents:
43178
diff
changeset
|
1280 |
end) |
43859 | 1281 |
|> (fn (name, T_args) => IConst (name, T, T_args)) |
1282 |
| aux _ (IAbs (bound, tm)) = IAbs (bound, aux 0 tm) |
|
42753
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
1283 |
| aux _ tm = tm |
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
1284 |
in aux 0 end |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1285 |
|
43859 | 1286 |
fun repair_iterm ctxt format type_enc sym_tab = |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1287 |
not (is_type_enc_higher_order type_enc) |
43859 | 1288 |
? (introduce_explicit_apps_in_iterm sym_tab |
1289 |
#> introduce_predicators_in_iterm sym_tab) |
|
1290 |
#> enforce_type_arg_policy_in_iterm ctxt format type_enc |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1291 |
fun repair_fact ctxt format type_enc sym_tab = |
43859 | 1292 |
update_iformula (formula_map (repair_iterm ctxt format type_enc sym_tab)) |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1293 |
|
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1294 |
(** Helper facts **) |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1295 |
|
43194 | 1296 |
(* The Boolean indicates that a fairly sound type encoding is needed. *) |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1297 |
val helper_table = |
43194 | 1298 |
[(("COMBI", false), @{thms Meson.COMBI_def}), |
1299 |
(("COMBK", false), @{thms Meson.COMBK_def}), |
|
1300 |
(("COMBB", false), @{thms Meson.COMBB_def}), |
|
1301 |
(("COMBC", false), @{thms Meson.COMBC_def}), |
|
1302 |
(("COMBS", false), @{thms Meson.COMBS_def}), |
|
1303 |
(("fFalse", false), [@{lemma "~ fFalse" by (unfold fFalse_def) fast}]), |
|
1304 |
(("fFalse", true), @{thms True_or_False}), |
|
1305 |
(("fTrue", false), [@{lemma "fTrue" by (unfold fTrue_def) fast}]), |
|
1306 |
(("fTrue", true), @{thms True_or_False}), |
|
1307 |
(("fNot", false), |
|
1308 |
@{thms fNot_def [THEN Meson.iff_to_disjD, THEN conjunct1] |
|
1309 |
fNot_def [THEN Meson.iff_to_disjD, THEN conjunct2]}), |
|
1310 |
(("fconj", false), |
|
1311 |
@{lemma "~ P | ~ Q | fconj P Q" "~ fconj P Q | P" "~ fconj P Q | Q" |
|
1312 |
by (unfold fconj_def) fast+}), |
|
1313 |
(("fdisj", false), |
|
1314 |
@{lemma "~ P | fdisj P Q" "~ Q | fdisj P Q" "~ fdisj P Q | P | Q" |
|
1315 |
by (unfold fdisj_def) fast+}), |
|
1316 |
(("fimplies", false), |
|
43210
7384b771805d
made "explicit_apply"'s smart mode (more) complete
blanchet
parents:
43207
diff
changeset
|
1317 |
@{lemma "P | fimplies P Q" "~ Q | fimplies P Q" "~ fimplies P Q | ~ P | Q" |
43194 | 1318 |
by (unfold fimplies_def) fast+}), |
43678 | 1319 |
(("fequal", true), |
1320 |
(* This is a lie: Higher-order equality doesn't need a sound type encoding. |
|
1321 |
However, this is done so for backward compatibility: Including the |
|
1322 |
equality helpers by default in Metis breaks a few existing proofs. *) |
|
1323 |
@{thms fequal_def [THEN Meson.iff_to_disjD, THEN conjunct1] |
|
1324 |
fequal_def [THEN Meson.iff_to_disjD, THEN conjunct2]}), |
|
1325 |
(("fAll", false), []), (*TODO: add helpers*) |
|
1326 |
(("fEx", false), []), (*TODO: add helpers*) |
|
43194 | 1327 |
(("If", true), @{thms if_True if_False True_or_False})] |
1328 |
|> map (apsnd (map zero_var_indexes)) |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1329 |
|
43130
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
1330 |
val type_tag = `make_fixed_const type_tag_name |
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
1331 |
|
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
1332 |
fun type_tag_idempotence_fact () = |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1333 |
let |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1334 |
fun var s = ATerm (`I s, []) |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
1335 |
fun tag tm = ATerm (type_tag, [var "T", tm]) |
43207
cb8b9786ffe3
change var name as a workaround for rare issue in Metis's reconstruction code -- namely, "find_var" fails because "X = X" is wrongly mirrorred as "A = A"
blanchet
parents:
43201
diff
changeset
|
1336 |
val tagged_a = tag (var "A") |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1337 |
in |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
1338 |
Formula (type_tag_idempotence_helper_name, Axiom, |
43207
cb8b9786ffe3
change var name as a workaround for rare issue in Metis's reconstruction code -- namely, "find_var" fails because "X = X" is wrongly mirrorred as "A = A"
blanchet
parents:
43201
diff
changeset
|
1339 |
AAtom (ATerm (`I tptp_equal, [tag tagged_a, tagged_a])) |
43693 | 1340 |
|> close_formula_universally, isabelle_info simpN, NONE) |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1341 |
end |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1342 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1343 |
fun should_specialize_helper type_enc t = |
43628
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1344 |
polymorphism_of_type_enc type_enc = Mangled_Monomorphic andalso |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1345 |
level_of_type_enc type_enc <> No_Types andalso |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1346 |
not (null (Term.hidden_polymorphism t)) |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
1347 |
|
43858
be41d12de6fa
simplify code -- there are no lambdas in helpers anyway
blanchet
parents:
43857
diff
changeset
|
1348 |
fun helper_facts_for_sym ctxt format type_enc (s, {types, ...} : sym_info) = |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1349 |
case strip_prefix_and_unascii const_prefix s of |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1350 |
SOME mangled_s => |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1351 |
let |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1352 |
val thy = Proof_Context.theory_of ctxt |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1353 |
val unmangled_s = mangled_s |> unmangled_const_name |
43628
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1354 |
fun dub needs_fairly_sound j k = |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1355 |
(unmangled_s ^ "_" ^ string_of_int j ^ "_" ^ string_of_int k ^ |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1356 |
(if mangled_s = unmangled_s then "" else "_" ^ ascii_of mangled_s) ^ |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1357 |
(if needs_fairly_sound then typed_helper_suffix |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1358 |
else untyped_helper_suffix), |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1359 |
Helper) |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
1360 |
fun dub_and_inst needs_fairly_sound (th, j) = |
43628
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1361 |
let val t = prop_of th in |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1362 |
if should_specialize_helper type_enc t then |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1363 |
map (fn T => specialize_type thy (invert_const unmangled_s, T) t) |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1364 |
types |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1365 |
else |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1366 |
[t] |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1367 |
end |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1368 |
|> map (fn (k, t) => (dub needs_fairly_sound j k, t)) o tag_list 1 |
43860
57ef3cd4126e
more refactoring of preprocessing, so as to be able to centralize it
blanchet
parents:
43859
diff
changeset
|
1369 |
val make_facts = map_filter (make_fact ctxt format type_enc false) |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1370 |
val fairly_sound = is_type_enc_fairly_sound type_enc |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1371 |
in |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1372 |
helper_table |
43194 | 1373 |
|> maps (fn ((helper_s, needs_fairly_sound), ths) => |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
1374 |
if helper_s <> unmangled_s orelse |
42894
ce269ee43800
further improvements to "poly_{preds,tags}_{bang,query}" -- better solution to the combinator problem + make sure type assumptions can be discharged
blanchet
parents:
42893
diff
changeset
|
1375 |
(needs_fairly_sound andalso not fairly_sound) then |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1376 |
[] |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1377 |
else |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1378 |
ths ~~ (1 upto length ths) |
43628
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1379 |
|> maps (dub_and_inst needs_fairly_sound) |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
1380 |
|> make_facts) |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1381 |
end |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1382 |
| NONE => [] |
43858
be41d12de6fa
simplify code -- there are no lambdas in helpers anyway
blanchet
parents:
43857
diff
changeset
|
1383 |
fun helper_facts_for_sym_table ctxt format type_enc sym_tab = |
be41d12de6fa
simplify code -- there are no lambdas in helpers anyway
blanchet
parents:
43857
diff
changeset
|
1384 |
Symtab.fold_rev (append o helper_facts_for_sym ctxt format type_enc) sym_tab |
be41d12de6fa
simplify code -- there are no lambdas in helpers anyway
blanchet
parents:
43857
diff
changeset
|
1385 |
[] |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1386 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1387 |
(***************************************************************) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1388 |
(* Type Classes Present in the Axiom or Conjecture Clauses *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1389 |
(***************************************************************) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1390 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1391 |
fun set_insert (x, s) = Symtab.update (x, ()) s |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1392 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1393 |
fun add_classes (sorts, cset) = List.foldl set_insert cset (flat sorts) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1394 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1395 |
(* Remove this trivial type class (FIXME: similar code elsewhere) *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1396 |
fun delete_type cset = Symtab.delete_safe (the_single @{sort HOL.type}) cset |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1397 |
|
43093 | 1398 |
fun classes_of_terms get_Ts = |
43121 | 1399 |
map (map snd o get_Ts) |
43093 | 1400 |
#> List.foldl add_classes Symtab.empty |
1401 |
#> delete_type #> Symtab.keys |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1402 |
|
43093 | 1403 |
val tfree_classes_of_terms = classes_of_terms OldTerm.term_tfrees |
1404 |
val tvar_classes_of_terms = classes_of_terms OldTerm.term_tvars |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1405 |
|
43622 | 1406 |
fun fold_type_constrs f (Type (s, Ts)) x = |
1407 |
fold (fold_type_constrs f) Ts (f (s, x)) |
|
43189 | 1408 |
| fold_type_constrs _ _ x = x |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1409 |
|
43907
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
1410 |
(* Type constructors used to instantiate overloaded constants are the only ones |
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
1411 |
needed. *) |
43189 | 1412 |
fun add_type_constrs_in_term thy = |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1413 |
let |
43188
0c36ae874fcc
fixed detection of Skolem constants in type construction detection code
blanchet
parents:
43185
diff
changeset
|
1414 |
fun add (Const (@{const_name Meson.skolem}, _) $ _) = I |
43181 | 1415 |
| add (t $ u) = add t #> add u |
43188
0c36ae874fcc
fixed detection of Skolem constants in type construction detection code
blanchet
parents:
43185
diff
changeset
|
1416 |
| add (Const (x as (s, _))) = |
0c36ae874fcc
fixed detection of Skolem constants in type construction detection code
blanchet
parents:
43185
diff
changeset
|
1417 |
if String.isPrefix skolem_const_prefix s then I |
43189 | 1418 |
else x |> Sign.const_typargs thy |> fold (fold_type_constrs set_insert) |
43907
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
1419 |
| add (Free (s, T)) = |
43936
127749bbc639
use a more robust naming convention for "polymorphic" frees -- the check is an overapproximation but that's fine as far as soundness is concerned
blanchet
parents:
43907
diff
changeset
|
1420 |
if String.isPrefix polymorphic_free_prefix s then |
43907
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
1421 |
T |> fold_type_constrs set_insert |
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
1422 |
else |
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
1423 |
I |
43181 | 1424 |
| add (Abs (_, _, u)) = add u |
1425 |
| add _ = I |
|
1426 |
in add end |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1427 |
|
43189 | 1428 |
fun type_constrs_of_terms thy ts = |
1429 |
Symtab.keys (fold (add_type_constrs_in_term thy) ts Symtab.empty) |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1430 |
|
43856
d636b053d4ff
move more lambda-handling logic to Sledgehammer, from ATP module, for formal dependency reasons
blanchet
parents:
43830
diff
changeset
|
1431 |
fun translate_formulas ctxt format prem_kind type_enc trans_lambdas preproc |
43828
e07a2c4cbad8
move lambda translation option from ATP to Sledgehammer, to avoid accidentally breaking Metis (its reconstruction code can only deal with combinators)
blanchet
parents:
43827
diff
changeset
|
1432 |
hyp_ts concl_t facts = |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1433 |
let |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1434 |
val thy = Proof_Context.theory_of ctxt |
43264
a1a48c69d623
don't needlessly presimplify -- makes ATP problem preparation much faster
blanchet
parents:
43263
diff
changeset
|
1435 |
val presimp_consts = Meson.presimplified_consts ctxt |
43861 | 1436 |
val fact_ts = facts |> map snd |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1437 |
(* Remove existing facts from the conjecture, as this can dramatically |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1438 |
boost an ATP's performance (for some reason). *) |
43192 | 1439 |
val hyp_ts = |
1440 |
hyp_ts |
|
1441 |
|> map (fn t => if member (op aconv) fact_ts t then @{prop True} else t) |
|
43864
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1442 |
val facts = facts |> map (apsnd (pair Axiom)) |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1443 |
val conjs = |
43861 | 1444 |
map (pair prem_kind) hyp_ts @ [(Conjecture, concl_t)] |
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
1445 |
|> map2 (pair o rpair Local o string_of_int) (0 upto length hyp_ts) |
43864
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1446 |
val ((conjs, facts), lambdas) = |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1447 |
if preproc then |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1448 |
conjs @ facts |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1449 |
|> map (apsnd (apsnd (presimp_prop ctxt presimp_consts))) |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1450 |
|> preprocess_abstractions_in_terms trans_lambdas |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1451 |
|>> chop (length conjs) |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1452 |
|>> apfst (map (apsnd (apsnd freeze_term))) |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1453 |
else |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1454 |
((conjs, facts), []) |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1455 |
val conjs = conjs |> make_conjecture ctxt format type_enc |
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
1456 |
val (fact_names, facts) = |
43864
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1457 |
facts |
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
1458 |
|> map_filter (fn (name, (_, t)) => |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
1459 |
make_fact ctxt format type_enc true (name, t) |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
1460 |
|> Option.map (pair name)) |
43861 | 1461 |
|> ListPair.unzip |
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
1462 |
val lambdas = |
43864
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1463 |
lambdas |> map_filter (make_fact ctxt format type_enc true o apsnd snd) |
43861 | 1464 |
val all_ts = concl_t :: hyp_ts @ fact_ts |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1465 |
val subs = tfree_classes_of_terms all_ts |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1466 |
val supers = tvar_classes_of_terms all_ts |
43189 | 1467 |
val tycons = type_constrs_of_terms thy all_ts |
43861 | 1468 |
val (supers, arity_clauses) = |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1469 |
if level_of_type_enc type_enc = No_Types then ([], []) |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1470 |
else make_arity_clauses thy tycons supers |
43861 | 1471 |
val class_rel_clauses = make_class_rel_clauses thy subs supers |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1472 |
in |
43863
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
1473 |
(fact_names |> map single, |
a43d61270142
ensure that the lambda translation procedure is called only once with all the facts, which is necessary for soundness of lambda-lifting (freshness of new names)
blanchet
parents:
43862
diff
changeset
|
1474 |
(conjs, facts @ lambdas, class_rel_clauses, arity_clauses)) |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1475 |
end |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1476 |
|
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1477 |
fun fo_literal_from_type_literal (TyLitVar (class, name)) = |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1478 |
(true, ATerm (class, [ATerm (name, [])])) |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1479 |
| fo_literal_from_type_literal (TyLitFree (class, name)) = |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1480 |
(true, ATerm (class, [ATerm (name, [])])) |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1481 |
|
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1482 |
fun formula_from_fo_literal (pos, t) = AAtom t |> not pos ? mk_anot |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1483 |
|
43130
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
1484 |
val type_pred = `make_fixed_const type_pred_name |
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
1485 |
|
43859 | 1486 |
fun type_pred_iterm ctxt format type_enc T tm = |
1487 |
IApp (IConst (type_pred, T --> @{typ bool}, [T]) |
|
1488 |
|> enforce_type_arg_policy_in_iterm ctxt format type_enc, tm) |
|
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1489 |
|
43421 | 1490 |
fun is_var_positively_naked_in_term _ (SOME false) _ accum = accum |
1491 |
| is_var_positively_naked_in_term name _ (ATerm ((s, _), tms)) accum = |
|
43000
bd424c3dde46
cleaner handling of equality and proxies (esp. for THF)
blanchet
parents:
42998
diff
changeset
|
1492 |
accum orelse (is_tptp_equal s andalso member (op =) tms (ATerm (name, []))) |
43692 | 1493 |
| is_var_positively_naked_in_term _ _ _ _ = true |
43493
bdb11c68f142
generate type predicates for existentials/skolems, otherwise some problems might not be provable
blanchet
parents:
43423
diff
changeset
|
1494 |
fun should_predicate_on_var_in_formula pos phi (SOME true) name = |
43421 | 1495 |
formula_fold pos (is_var_positively_naked_in_term name) phi false |
43493
bdb11c68f142
generate type predicates for existentials/skolems, otherwise some problems might not be provable
blanchet
parents:
43423
diff
changeset
|
1496 |
| should_predicate_on_var_in_formula _ _ _ _ = true |
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1497 |
|
43677 | 1498 |
fun mk_aterm format type_enc name T_args args = |
1499 |
ATerm (name, map_filter (ho_term_for_type_arg format type_enc) T_args @ args) |
|
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1500 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1501 |
fun tag_with_type ctxt format nonmono_Ts type_enc pos T tm = |
43859 | 1502 |
IConst (type_tag, T --> T, [T]) |
1503 |
|> enforce_type_arg_policy_in_iterm ctxt format type_enc |
|
1504 |
|> ho_term_from_iterm ctxt format nonmono_Ts type_enc (Top_Level pos) |
|
43692 | 1505 |
|> (fn ATerm (s, tms) => ATerm (s, tms @ [tm]) |
1506 |
| _ => raise Fail "unexpected lambda-abstraction") |
|
43859 | 1507 |
and ho_term_from_iterm ctxt format nonmono_Ts type_enc = |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1508 |
let |
42962
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1509 |
fun aux site u = |
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1510 |
let |
43859 | 1511 |
val (head, args) = strip_iterm_comb u |
43677 | 1512 |
val pos = |
43361
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1513 |
case site of |
43677 | 1514 |
Top_Level pos => pos |
1515 |
| Eq_Arg pos => pos |
|
1516 |
| Elsewhere => NONE |
|
1517 |
val t = |
|
1518 |
case head of |
|
43859 | 1519 |
IConst (name as (s, _), _, T_args) => |
43677 | 1520 |
let |
1521 |
val arg_site = if is_tptp_equal s then Eq_Arg pos else Elsewhere |
|
1522 |
in |
|
1523 |
mk_aterm format type_enc name T_args (map (aux arg_site) args) |
|
1524 |
end |
|
43859 | 1525 |
| IVar (name, _) => |
1526 |
mk_aterm format type_enc name [] (map (aux Elsewhere) args) |
|
1527 |
| IAbs ((name, T), tm) => |
|
1528 |
AAbs ((name, ho_type_from_typ format type_enc true 0 T), |
|
1529 |
aux Elsewhere tm) |
|
1530 |
| IApp _ => raise Fail "impossible \"IApp\"" |
|
1531 |
val T = ityp_of u |
|
42962
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1532 |
in |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1533 |
t |> (if should_tag_with_type ctxt nonmono_Ts type_enc site u T then |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1534 |
tag_with_type ctxt format nonmono_Ts type_enc pos T |
42962
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1535 |
else |
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1536 |
I) |
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1537 |
end |
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1538 |
in aux end |
43859 | 1539 |
and formula_from_iformula ctxt format nonmono_Ts type_enc |
1540 |
should_predicate_on_var = |
|
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1541 |
let |
43860
57ef3cd4126e
more refactoring of preprocessing, so as to be able to centralize it
blanchet
parents:
43859
diff
changeset
|
1542 |
val do_term = ho_term_from_iterm ctxt format nonmono_Ts type_enc o Top_Level |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1543 |
val do_bound_type = |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1544 |
case type_enc of |
43624
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
1545 |
Simple_Types (_, level) => |
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1546 |
homogenized_type ctxt nonmono_Ts level 0 |
43677 | 1547 |
#> ho_type_from_typ format type_enc false 0 #> SOME |
42682
562046fd8e0c
added type homogenization, whereby all (isomorphic) infinite types are mapped to the same type (to reduce the number of different predicates/TFF-types)
blanchet
parents:
42680
diff
changeset
|
1548 |
| _ => K NONE |
42878
85ac4c12a4b7
slightly fewer type predicates introduced in the lightweight encoding, based on the observation that only universal positive equalities are dangerous
blanchet
parents:
42855
diff
changeset
|
1549 |
fun do_out_of_bound_type pos phi universal (name, T) = |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1550 |
if should_predicate_on_type ctxt nonmono_Ts type_enc |
42878
85ac4c12a4b7
slightly fewer type predicates introduced in the lightweight encoding, based on the observation that only universal positive equalities are dangerous
blanchet
parents:
42855
diff
changeset
|
1551 |
(fn () => should_predicate_on_var pos phi universal name) T then |
43859 | 1552 |
IVar (name, T) |
1553 |
|> type_pred_iterm ctxt format type_enc T |
|
43361
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1554 |
|> do_term pos |> AAtom |> SOME |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1555 |
else |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1556 |
NONE |
42878
85ac4c12a4b7
slightly fewer type predicates introduced in the lightweight encoding, based on the observation that only universal positive equalities are dangerous
blanchet
parents:
42855
diff
changeset
|
1557 |
fun do_formula pos (AQuant (q, xs, phi)) = |
85ac4c12a4b7
slightly fewer type predicates introduced in the lightweight encoding, based on the observation that only universal positive equalities are dangerous
blanchet
parents:
42855
diff
changeset
|
1558 |
let |
85ac4c12a4b7
slightly fewer type predicates introduced in the lightweight encoding, based on the observation that only universal positive equalities are dangerous
blanchet
parents:
42855
diff
changeset
|
1559 |
val phi = phi |> do_formula pos |
85ac4c12a4b7
slightly fewer type predicates introduced in the lightweight encoding, based on the observation that only universal positive equalities are dangerous
blanchet
parents:
42855
diff
changeset
|
1560 |
val universal = Option.map (q = AExists ? not) pos |
85ac4c12a4b7
slightly fewer type predicates introduced in the lightweight encoding, based on the observation that only universal positive equalities are dangerous
blanchet
parents:
42855
diff
changeset
|
1561 |
in |
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1562 |
AQuant (q, xs |> map (apsnd (fn NONE => NONE |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1563 |
| SOME T => do_bound_type T)), |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1564 |
(if q = AForall then mk_ahorn else fold_rev (mk_aconn AAnd)) |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1565 |
(map_filter |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1566 |
(fn (_, NONE) => NONE |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1567 |
| (s, SOME T) => |
42878
85ac4c12a4b7
slightly fewer type predicates introduced in the lightweight encoding, based on the observation that only universal positive equalities are dangerous
blanchet
parents:
42855
diff
changeset
|
1568 |
do_out_of_bound_type pos phi universal (s, T)) |
85ac4c12a4b7
slightly fewer type predicates introduced in the lightweight encoding, based on the observation that only universal positive equalities are dangerous
blanchet
parents:
42855
diff
changeset
|
1569 |
xs) |
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1570 |
phi) |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1571 |
end |
42878
85ac4c12a4b7
slightly fewer type predicates introduced in the lightweight encoding, based on the observation that only universal positive equalities are dangerous
blanchet
parents:
42855
diff
changeset
|
1572 |
| do_formula pos (AConn conn) = aconn_map pos do_formula conn |
43361
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1573 |
| do_formula pos (AAtom tm) = AAtom (do_term pos tm) |
43493
bdb11c68f142
generate type predicates for existentials/skolems, otherwise some problems might not be provable
blanchet
parents:
43423
diff
changeset
|
1574 |
in do_formula end |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1575 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1576 |
fun bound_tvars type_enc Ts = |
42727
f365f5138771
ensure type class predicates are generated in symbol declarations (for "poly_preds" and similar)
blanchet
parents:
42726
diff
changeset
|
1577 |
mk_ahorn (map (formula_from_fo_literal o fo_literal_from_type_literal) |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1578 |
(type_literals_for_types type_enc add_sorts_on_tvar Ts)) |
42727
f365f5138771
ensure type class predicates are generated in symbol declarations (for "poly_preds" and similar)
blanchet
parents:
42726
diff
changeset
|
1579 |
|
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1580 |
(* Each fact is given a unique fact number to avoid name clashes (e.g., because |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1581 |
of monomorphization). The TPTP explicitly forbids name clashes, and some of |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1582 |
the remote provers might care. *) |
43501
0e422a84d0b2
don't change the way helpers are generated for the exporter's sake
blanchet
parents:
43496
diff
changeset
|
1583 |
fun formula_line_for_fact ctxt format prefix encode freshen pos nonmono_Ts |
43859 | 1584 |
type_enc (j, {name, locality, kind, iformula, atomic_types}) = |
43864
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1585 |
(prefix ^ (if freshen then string_of_int j ^ "_" else "") ^ encode name, kind, |
43859 | 1586 |
iformula |
1587 |
|> close_iformula_universally |
|
1588 |
|> formula_from_iformula ctxt format nonmono_Ts type_enc |
|
1589 |
should_predicate_on_var_in_formula |
|
1590 |
(if pos then SOME true else NONE) |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1591 |
|> bound_tvars type_enc atomic_types |
43493
bdb11c68f142
generate type predicates for existentials/skolems, otherwise some problems might not be provable
blanchet
parents:
43423
diff
changeset
|
1592 |
|> close_formula_universally, |
bdb11c68f142
generate type predicates for existentials/skolems, otherwise some problems might not be provable
blanchet
parents:
43423
diff
changeset
|
1593 |
NONE, |
bdb11c68f142
generate type predicates for existentials/skolems, otherwise some problems might not be provable
blanchet
parents:
43423
diff
changeset
|
1594 |
case locality of |
43693 | 1595 |
Intro => isabelle_info introN |
1596 |
| Elim => isabelle_info elimN |
|
1597 |
| Simp => isabelle_info simpN |
|
43493
bdb11c68f142
generate type predicates for existentials/skolems, otherwise some problems might not be provable
blanchet
parents:
43423
diff
changeset
|
1598 |
| _ => NONE) |
bdb11c68f142
generate type predicates for existentials/skolems, otherwise some problems might not be provable
blanchet
parents:
43423
diff
changeset
|
1599 |
|> Formula |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1600 |
|
43086 | 1601 |
fun formula_line_for_class_rel_clause ({name, subclass, superclass, ...} |
1602 |
: class_rel_clause) = |
|
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1603 |
let val ty_arg = ATerm (`I "T", []) in |
42577
78414ec6fa4e
made the format (TFF or FOF) of the TPTP problem a global argument of the problem again and have the ATPs report which formats they support
blanchet
parents:
42576
diff
changeset
|
1604 |
Formula (class_rel_clause_prefix ^ ascii_of name, Axiom, |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1605 |
AConn (AImplies, [AAtom (ATerm (subclass, [ty_arg])), |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1606 |
AAtom (ATerm (superclass, [ty_arg]))]) |
43693 | 1607 |
|> close_formula_universally, isabelle_info introN, NONE) |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1608 |
end |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1609 |
|
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1610 |
fun fo_literal_from_arity_literal (TConsLit (c, t, args)) = |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1611 |
(true, ATerm (c, [ATerm (t, map (fn arg => ATerm (arg, [])) args)])) |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1612 |
| fo_literal_from_arity_literal (TVarLit (c, sort)) = |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1613 |
(false, ATerm (c, [ATerm (sort, [])])) |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1614 |
|
43086 | 1615 |
fun formula_line_for_arity_clause ({name, prem_lits, concl_lits, ...} |
1616 |
: arity_clause) = |
|
43495 | 1617 |
Formula (arity_clause_prefix ^ name, Axiom, |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1618 |
mk_ahorn (map (formula_from_fo_literal o apfst not |
42895 | 1619 |
o fo_literal_from_arity_literal) prem_lits) |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1620 |
(formula_from_fo_literal |
42895 | 1621 |
(fo_literal_from_arity_literal concl_lits)) |
43693 | 1622 |
|> close_formula_universally, isabelle_info introN, NONE) |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1623 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1624 |
fun formula_line_for_conjecture ctxt format nonmono_Ts type_enc |
43859 | 1625 |
({name, kind, iformula, atomic_types, ...} : translated_formula) = |
42577
78414ec6fa4e
made the format (TFF or FOF) of the TPTP problem a global argument of the problem again and have the ATPs report which formats they support
blanchet
parents:
42576
diff
changeset
|
1626 |
Formula (conjecture_prefix ^ name, kind, |
43859 | 1627 |
formula_from_iformula ctxt format nonmono_Ts type_enc |
43493
bdb11c68f142
generate type predicates for existentials/skolems, otherwise some problems might not be provable
blanchet
parents:
43423
diff
changeset
|
1628 |
should_predicate_on_var_in_formula (SOME false) |
43859 | 1629 |
(close_iformula_universally iformula) |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1630 |
|> bound_tvars type_enc atomic_types |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1631 |
|> close_formula_universally, NONE, NONE) |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1632 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1633 |
fun free_type_literals type_enc ({atomic_types, ...} : translated_formula) = |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1634 |
atomic_types |> type_literals_for_types type_enc add_sorts_on_tfree |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1635 |
|> map fo_literal_from_type_literal |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1636 |
|
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1637 |
fun formula_line_for_free_type j lit = |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1638 |
Formula (tfree_clause_prefix ^ string_of_int j, Hypothesis, |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1639 |
formula_from_fo_literal lit, NONE, NONE) |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1640 |
fun formula_lines_for_free_types type_enc facts = |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1641 |
let |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1642 |
val litss = map (free_type_literals type_enc) facts |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1643 |
val lits = fold (union (op =)) litss [] |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1644 |
in map2 formula_line_for_free_type (0 upto length lits - 1) lits end |
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1645 |
|
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1646 |
(** Symbol declarations **) |
42544
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1647 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1648 |
fun should_declare_sym type_enc pred_sym s = |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1649 |
is_tptp_user_symbol s andalso not (String.isPrefix bound_var_prefix s) andalso |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1650 |
(case type_enc of |
42894
ce269ee43800
further improvements to "poly_{preds,tags}_{bang,query}" -- better solution to the combinator problem + make sure type assumptions can be discharged
blanchet
parents:
42893
diff
changeset
|
1651 |
Simple_Types _ => true |
43128 | 1652 |
| Tags (_, _, Lightweight) => true |
42894
ce269ee43800
further improvements to "poly_{preds,tags}_{bang,query}" -- better solution to the combinator problem + make sure type assumptions can be discharged
blanchet
parents:
42893
diff
changeset
|
1653 |
| _ => not pred_sym) |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1654 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1655 |
fun sym_decl_table_for_facts ctxt type_enc repaired_sym_tab (conjs, facts) = |
42574 | 1656 |
let |
43859 | 1657 |
fun add_iterm in_conj tm = |
1658 |
let val (head, args) = strip_iterm_comb tm in |
|
42574 | 1659 |
(case head of |
43859 | 1660 |
IConst ((s, s'), T, T_args) => |
42574 | 1661 |
let val pred_sym = is_pred_sym repaired_sym_tab s in |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1662 |
if should_declare_sym type_enc pred_sym s then |
42576
a8a80a2a34be
merge symbol declarations that are type-instances of each other -- useful for type system "Args true" with monomorphization turned off
blanchet
parents:
42575
diff
changeset
|
1663 |
Symtab.map_default (s, []) |
42886
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
1664 |
(insert_type ctxt #3 (s', T_args, T, pred_sym, length args, |
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
1665 |
in_conj)) |
42574 | 1666 |
else |
1667 |
I |
|
1668 |
end |
|
43859 | 1669 |
| IAbs (_, tm) => add_iterm in_conj tm |
42574 | 1670 |
| _ => I) |
43859 | 1671 |
#> fold (add_iterm in_conj) args |
42574 | 1672 |
end |
43859 | 1673 |
fun add_fact in_conj = fact_lift (formula_fold NONE (K (add_iterm in_conj))) |
42698
ffd1ae4ff5c6
help SOS by ensuring that typing information is marked as part of the conjecture + be more precise w.r.t. typedefs in monotonicity check
blanchet
parents:
42697
diff
changeset
|
1674 |
in |
ffd1ae4ff5c6
help SOS by ensuring that typing information is marked as part of the conjecture + be more precise w.r.t. typedefs in monotonicity check
blanchet
parents:
42697
diff
changeset
|
1675 |
Symtab.empty |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1676 |
|> is_type_enc_fairly_sound type_enc |
42698
ffd1ae4ff5c6
help SOS by ensuring that typing information is marked as part of the conjecture + be more precise w.r.t. typedefs in monotonicity check
blanchet
parents:
42697
diff
changeset
|
1677 |
? (fold (add_fact true) conjs #> fold (add_fact false) facts) |
ffd1ae4ff5c6
help SOS by ensuring that typing information is marked as part of the conjecture + be more precise w.r.t. typedefs in monotonicity check
blanchet
parents:
42697
diff
changeset
|
1678 |
end |
42533 | 1679 |
|
42685 | 1680 |
(* This inference is described in section 2.3 of Claessen et al.'s "Sorting it |
1681 |
out with monotonicity" paper presented at CADE 2011. *) |
|
43859 | 1682 |
fun add_iterm_nonmonotonic_types _ _ _ _ (SOME false) _ = I |
1683 |
| add_iterm_nonmonotonic_types ctxt level sound locality _ |
|
1684 |
(IApp (IApp (IConst ((s, _), Type (_, [T, _]), _), tm1), tm2)) = |
|
43000
bd424c3dde46
cleaner handling of equality and proxies (esp. for THF)
blanchet
parents:
42998
diff
changeset
|
1685 |
(is_tptp_equal s andalso exists is_var_or_bound_var [tm1, tm2] andalso |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1686 |
(case level of |
43362 | 1687 |
Noninf_Nonmono_Types => |
43293
a80cdc4b27a3
made "query" type systes a bit more sound -- local facts, e.g. the negated conjecture, may make invalid the infinity check, e.g. if we are proving that there exists two values of an infinite type, we can use the negated conjecture that there is only one value to derive unsound proofs unless the type is properly encoded
blanchet
parents:
43289
diff
changeset
|
1688 |
not (is_locality_global locality) orelse |
43572
ae612a423dad
added "sound" option to force Sledgehammer to be pedantically sound
blanchet
parents:
43501
diff
changeset
|
1689 |
not (is_type_surely_infinite ctxt sound T) |
ae612a423dad
added "sound" option to force Sledgehammer to be pedantically sound
blanchet
parents:
43501
diff
changeset
|
1690 |
| Fin_Nonmono_Types => is_type_surely_finite ctxt false T |
42886
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
1691 |
| _ => true)) ? insert_type ctxt I (deep_freeze_type T) |
43859 | 1692 |
| add_iterm_nonmonotonic_types _ _ _ _ _ _ = I |
43572
ae612a423dad
added "sound" option to force Sledgehammer to be pedantically sound
blanchet
parents:
43501
diff
changeset
|
1693 |
fun add_fact_nonmonotonic_types ctxt level sound |
43859 | 1694 |
({kind, locality, iformula, ...} : translated_formula) = |
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1695 |
formula_fold (SOME (kind <> Conjecture)) |
43859 | 1696 |
(add_iterm_nonmonotonic_types ctxt level sound locality) |
1697 |
iformula |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1698 |
fun nonmonotonic_types_for_facts ctxt type_enc sound facts = |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1699 |
let val level = level_of_type_enc type_enc in |
43362 | 1700 |
if level = Noninf_Nonmono_Types orelse level = Fin_Nonmono_Types then |
43572
ae612a423dad
added "sound" option to force Sledgehammer to be pedantically sound
blanchet
parents:
43501
diff
changeset
|
1701 |
[] |> fold (add_fact_nonmonotonic_types ctxt level sound) facts |
42886
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
1702 |
(* We must add "bool" in case the helper "True_or_False" is added |
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
1703 |
later. In addition, several places in the code rely on the list of |
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
1704 |
nonmonotonic types not being empty. *) |
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
1705 |
|> insert_type ctxt I @{typ bool} |
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
1706 |
else |
208ec29cc013
improved "poly_preds_{bang,query}" by picking up good witnesses for the possible infinity of common type classes and ensuring that "?'a::type" doesn't ruin everything
blanchet
parents:
42885
diff
changeset
|
1707 |
[] |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1708 |
end |
42677
25496cd3c199
monotonic type inference in ATP Sledgehammer problems -- based on Claessen & al.'s CADE 2011 paper, Sect. 2.3.
blanchet
parents:
42675
diff
changeset
|
1709 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1710 |
fun decl_line_for_sym ctxt format nonmono_Ts type_enc s |
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1711 |
(s', T_args, T, pred_sym, ary, _) = |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1712 |
let |
43178
b5862142d378
use "" type only in THF and TFF -- might cause strange failures if used in FOF or CNF, depending on how liberal the prover is
blanchet
parents:
43175
diff
changeset
|
1713 |
val (T_arg_Ts, level) = |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1714 |
case type_enc of |
43624
de026aecab9b
cleaner handling of higher-order simple types, so that it's also possible to use first-order simple types with LEO-II and company
blanchet
parents:
43623
diff
changeset
|
1715 |
Simple_Types (_, level) => ([], level) |
43178
b5862142d378
use "" type only in THF and TFF -- might cause strange failures if used in FOF or CNF, depending on how liberal the prover is
blanchet
parents:
43175
diff
changeset
|
1716 |
| _ => (replicate (length T_args) homo_infinite_type, No_Types) |
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1717 |
in |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1718 |
Decl (sym_decl_prefix ^ s, (s, s'), |
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1719 |
(T_arg_Ts ---> (T |> homogenized_type ctxt nonmono_Ts level ary)) |
43677 | 1720 |
|> ho_type_from_typ format type_enc pred_sym (length T_arg_Ts + ary)) |
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1721 |
end |
42579
2552c09b1a72
implement the new ATP type system in Sledgehammer
blanchet
parents:
42577
diff
changeset
|
1722 |
|
43125
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
1723 |
fun formula_line_for_preds_sym_decl ctxt format conj_sym_kind nonmono_Ts |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1724 |
poly_nonmono_Ts type_enc n s j (s', T_args, T, _, ary, in_conj) = |
42579
2552c09b1a72
implement the new ATP type system in Sledgehammer
blanchet
parents:
42577
diff
changeset
|
1725 |
let |
42709
e7af132d48fe
allow each prover to specify its own formula kind for symbols occurring in the conjecture
blanchet
parents:
42701
diff
changeset
|
1726 |
val (kind, maybe_negate) = |
e7af132d48fe
allow each prover to specify its own formula kind for symbols occurring in the conjecture
blanchet
parents:
42701
diff
changeset
|
1727 |
if in_conj then (conj_sym_kind, conj_sym_kind = Conjecture ? mk_anot) |
e7af132d48fe
allow each prover to specify its own formula kind for symbols occurring in the conjecture
blanchet
parents:
42701
diff
changeset
|
1728 |
else (Axiom, I) |
42753
c9552e617acc
drop some type arguments to constants in unsound type systems + remove a few type systems that make no sense from the circulation
blanchet
parents:
42750
diff
changeset
|
1729 |
val (arg_Ts, res_T) = chop_fun ary T |
43399
5b499c360df6
type arguments now (unlike back when fa2cf11d6351 was done) normally carry enough information to reconstruct the type of an applied constant, so no need to constraint the argument types in those cases
blanchet
parents:
43362
diff
changeset
|
1730 |
val num_args = length arg_Ts |
42579
2552c09b1a72
implement the new ATP type system in Sledgehammer
blanchet
parents:
42577
diff
changeset
|
1731 |
val bound_names = |
43399
5b499c360df6
type arguments now (unlike back when fa2cf11d6351 was done) normally carry enough information to reconstruct the type of an applied constant, so no need to constraint the argument types in those cases
blanchet
parents:
43362
diff
changeset
|
1732 |
1 upto num_args |> map (`I o make_bound_var o string_of_int) |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1733 |
val bounds = |
43859 | 1734 |
bound_names ~~ arg_Ts |> map (fn (name, T) => IConst (name, T, [])) |
43907
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
1735 |
val sym_needs_arg_types = exists (curry (op =) dummyT) T_args |
43401
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1736 |
fun should_keep_arg_type T = |
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1737 |
sym_needs_arg_types orelse |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1738 |
not (should_predicate_on_type ctxt nonmono_Ts type_enc (K false) T) |
42579
2552c09b1a72
implement the new ATP type system in Sledgehammer
blanchet
parents:
42577
diff
changeset
|
1739 |
val bound_Ts = |
43401
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1740 |
arg_Ts |> map (fn T => if should_keep_arg_type T then SOME T else NONE) |
42579
2552c09b1a72
implement the new ATP type system in Sledgehammer
blanchet
parents:
42577
diff
changeset
|
1741 |
in |
43125
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
1742 |
Formula (preds_sym_formula_prefix ^ s ^ |
42709
e7af132d48fe
allow each prover to specify its own formula kind for symbols occurring in the conjecture
blanchet
parents:
42701
diff
changeset
|
1743 |
(if n > 1 then "_" ^ string_of_int j else ""), kind, |
43859 | 1744 |
IConst ((s, s'), T, T_args) |
1745 |
|> fold (curry (IApp o swap)) bounds |
|
1746 |
|> type_pred_iterm ctxt format type_enc res_T |
|
42963 | 1747 |
|> AAtom |> mk_aquant AForall (bound_names ~~ bound_Ts) |
43859 | 1748 |
|> formula_from_iformula ctxt format poly_nonmono_Ts type_enc |
1749 |
(K (K (K (K true)))) (SOME true) |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1750 |
|> n > 1 ? bound_tvars type_enc (atyps_of T) |
42709
e7af132d48fe
allow each prover to specify its own formula kind for symbols occurring in the conjecture
blanchet
parents:
42701
diff
changeset
|
1751 |
|> close_formula_universally |
e7af132d48fe
allow each prover to specify its own formula kind for symbols occurring in the conjecture
blanchet
parents:
42701
diff
changeset
|
1752 |
|> maybe_negate, |
43693 | 1753 |
isabelle_info introN, NONE) |
42579
2552c09b1a72
implement the new ATP type system in Sledgehammer
blanchet
parents:
42577
diff
changeset
|
1754 |
end |
2552c09b1a72
implement the new ATP type system in Sledgehammer
blanchet
parents:
42577
diff
changeset
|
1755 |
|
43129 | 1756 |
fun formula_lines_for_lightweight_tags_sym_decl ctxt format conj_sym_kind |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1757 |
poly_nonmono_Ts type_enc n s |
43401
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1758 |
(j, (s', T_args, T, pred_sym, ary, in_conj)) = |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1759 |
let |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1760 |
val ident_base = |
43129 | 1761 |
lightweight_tags_sym_formula_prefix ^ s ^ |
43125
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
1762 |
(if n > 1 then "_" ^ string_of_int j else "") |
42852
40649ab0cead
honor "conj_sym_kind" also for tag symbol declarations
blanchet
parents:
42851
diff
changeset
|
1763 |
val (kind, maybe_negate) = |
40649ab0cead
honor "conj_sym_kind" also for tag symbol declarations
blanchet
parents:
42851
diff
changeset
|
1764 |
if in_conj then (conj_sym_kind, conj_sym_kind = Conjecture ? mk_anot) |
40649ab0cead
honor "conj_sym_kind" also for tag symbol declarations
blanchet
parents:
42851
diff
changeset
|
1765 |
else (Axiom, I) |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1766 |
val (arg_Ts, res_T) = chop_fun ary T |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1767 |
val bound_names = |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1768 |
1 upto length arg_Ts |> map (`I o make_bound_var o string_of_int) |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1769 |
val bounds = bound_names |> map (fn name => ATerm (name, [])) |
43677 | 1770 |
val cst = mk_aterm format type_enc (s, s') T_args |
42830
1068d8fc1331
generate type classes predicates in new "shallow" encoding
blanchet
parents:
42829
diff
changeset
|
1771 |
val atomic_Ts = atyps_of T |
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1772 |
fun eq tms = |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1773 |
(if pred_sym then AConn (AIff, map AAtom tms) |
43000
bd424c3dde46
cleaner handling of equality and proxies (esp. for THF)
blanchet
parents:
42998
diff
changeset
|
1774 |
else AAtom (ATerm (`I tptp_equal, tms))) |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1775 |
|> bound_tvars type_enc atomic_Ts |
42830
1068d8fc1331
generate type classes predicates in new "shallow" encoding
blanchet
parents:
42829
diff
changeset
|
1776 |
|> close_formula_universally |
42852
40649ab0cead
honor "conj_sym_kind" also for tag symbol declarations
blanchet
parents:
42851
diff
changeset
|
1777 |
|> maybe_negate |
43361
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1778 |
(* See also "should_tag_with_type". *) |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1779 |
fun should_encode T = |
43401
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1780 |
should_encode_type ctxt poly_nonmono_Ts All_Types T orelse |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1781 |
(case type_enc of |
43361
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1782 |
Tags (Polymorphic, level, Lightweight) => |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1783 |
level <> All_Types andalso Monomorph.typ_has_tvars T |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1784 |
| _ => false) |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1785 |
val tag_with = tag_with_type ctxt format poly_nonmono_Ts type_enc NONE |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1786 |
val add_formula_for_res = |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1787 |
if should_encode res_T then |
42852
40649ab0cead
honor "conj_sym_kind" also for tag symbol declarations
blanchet
parents:
42851
diff
changeset
|
1788 |
cons (Formula (ident_base ^ "_res", kind, |
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1789 |
eq [tag_with res_T (cst bounds), cst bounds], |
43693 | 1790 |
isabelle_info simpN, NONE)) |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1791 |
else |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1792 |
I |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1793 |
fun add_formula_for_arg k = |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1794 |
let val arg_T = nth arg_Ts k in |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1795 |
if should_encode arg_T then |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1796 |
case chop k bounds of |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1797 |
(bounds1, bound :: bounds2) => |
42852
40649ab0cead
honor "conj_sym_kind" also for tag symbol declarations
blanchet
parents:
42851
diff
changeset
|
1798 |
cons (Formula (ident_base ^ "_arg" ^ string_of_int (k + 1), kind, |
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1799 |
eq [cst (bounds1 @ tag_with arg_T bound :: bounds2), |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1800 |
cst bounds], |
43693 | 1801 |
isabelle_info simpN, NONE)) |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1802 |
| _ => raise Fail "expected nonempty tail" |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1803 |
else |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1804 |
I |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1805 |
end |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1806 |
in |
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1807 |
[] |> not pred_sym ? add_formula_for_res |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1808 |
|> fold add_formula_for_arg (ary - 1 downto 0) |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1809 |
end |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1810 |
|
42836 | 1811 |
fun result_type_of_decl (_, _, T, _, ary, _) = chop_fun ary T |> snd |
1812 |
||
43401
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1813 |
fun problem_lines_for_sym_decls ctxt format conj_sym_kind nonmono_Ts |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1814 |
poly_nonmono_Ts type_enc (s, decls) = |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1815 |
case type_enc of |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1816 |
Simple_Types _ => |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1817 |
decls |> map (decl_line_for_sym ctxt format nonmono_Ts type_enc s) |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1818 |
| Preds _ => |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1819 |
let |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1820 |
val decls = |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1821 |
case decls of |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1822 |
decl :: (decls' as _ :: _) => |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1823 |
let val T = result_type_of_decl decl in |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1824 |
if forall (curry (type_instance ctxt o swap) T |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1825 |
o result_type_of_decl) decls' then |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1826 |
[decl] |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1827 |
else |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1828 |
decls |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1829 |
end |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1830 |
| _ => decls |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1831 |
val n = length decls |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1832 |
val decls = |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1833 |
decls |> filter (should_predicate_on_type ctxt poly_nonmono_Ts type_enc |
43401
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1834 |
(K true) |
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1835 |
o result_type_of_decl) |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1836 |
in |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1837 |
(0 upto length decls - 1, decls) |
43125
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
1838 |
|-> map2 (formula_line_for_preds_sym_decl ctxt format conj_sym_kind |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1839 |
nonmono_Ts poly_nonmono_Ts type_enc n s) |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1840 |
end |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1841 |
| Tags (_, _, heaviness) => |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1842 |
(case heaviness of |
43128 | 1843 |
Heavyweight => [] |
1844 |
| Lightweight => |
|
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1845 |
let val n = length decls in |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1846 |
(0 upto n - 1 ~~ decls) |
43129 | 1847 |
|> maps (formula_lines_for_lightweight_tags_sym_decl ctxt format |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1848 |
conj_sym_kind poly_nonmono_Ts type_enc n s) |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1849 |
end) |
42579
2552c09b1a72
implement the new ATP type system in Sledgehammer
blanchet
parents:
42577
diff
changeset
|
1850 |
|
42956
9aeb0f6ad971
filter Waldmeister facts better -- and don't encode type classes as predicates, since it doesn't like conditional equations
blanchet
parents:
42951
diff
changeset
|
1851 |
fun problem_lines_for_sym_decl_table ctxt format conj_sym_kind nonmono_Ts |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1852 |
poly_nonmono_Ts type_enc sym_decl_tab = |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1853 |
sym_decl_tab |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1854 |
|> Symtab.dest |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1855 |
|> sort_wrt fst |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1856 |
|> rpair [] |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1857 |
|-> fold_rev (append o problem_lines_for_sym_decls ctxt format conj_sym_kind |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1858 |
nonmono_Ts poly_nonmono_Ts type_enc) |
42543
f9d402d144d4
declare TFF types so that SNARK can be used with types
blanchet
parents:
42542
diff
changeset
|
1859 |
|
43185
697d32fa183d
also exploit type tag idempotence in lightweight encodings, following a suggestion from Gothenburg
blanchet
parents:
43181
diff
changeset
|
1860 |
fun needs_type_tag_idempotence (Tags (poly, level, heaviness)) = |
697d32fa183d
also exploit type tag idempotence in lightweight encodings, following a suggestion from Gothenburg
blanchet
parents:
43181
diff
changeset
|
1861 |
poly <> Mangled_Monomorphic andalso |
697d32fa183d
also exploit type tag idempotence in lightweight encodings, following a suggestion from Gothenburg
blanchet
parents:
43181
diff
changeset
|
1862 |
((level = All_Types andalso heaviness = Lightweight) orelse |
43362 | 1863 |
level = Noninf_Nonmono_Types orelse level = Fin_Nonmono_Types) |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
1864 |
| needs_type_tag_idempotence _ = false |
42831
c9b0968484fb
more work on "shallow" encoding + adjustments to other encodings
blanchet
parents:
42830
diff
changeset
|
1865 |
|
42939 | 1866 |
fun offset_of_heading_in_problem _ [] j = j |
1867 |
| offset_of_heading_in_problem needle ((heading, lines) :: problem) j = |
|
1868 |
if heading = needle then j |
|
1869 |
else offset_of_heading_in_problem needle problem (j + length lines) |
|
1870 |
||
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1871 |
val implicit_declsN = "Should-be-implicit typings" |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1872 |
val explicit_declsN = "Explicit typings" |
41157 | 1873 |
val factsN = "Relevant facts" |
1874 |
val class_relsN = "Class relationships" |
|
42543
f9d402d144d4
declare TFF types so that SNARK can be used with types
blanchet
parents:
42542
diff
changeset
|
1875 |
val aritiesN = "Arities" |
41157 | 1876 |
val helpersN = "Helper facts" |
1877 |
val conjsN = "Conjectures" |
|
41313
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1878 |
val free_typesN = "Type variables" |
41157 | 1879 |
|
43828
e07a2c4cbad8
move lambda translation option from ATP to Sledgehammer, to avoid accidentally breaking Metis (its reconstruction code can only deal with combinators)
blanchet
parents:
43827
diff
changeset
|
1880 |
val explicit_apply = NONE (* for experiments *) |
43259
30c141dc22d6
killed "explicit_apply" option in Sledgehammer -- the "smart" default is about as lightweight as "false" and just as complete as "true"
blanchet
parents:
43258
diff
changeset
|
1881 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1882 |
fun prepare_atp_problem ctxt format conj_sym_kind prem_kind type_enc sound |
43856
d636b053d4ff
move more lambda-handling logic to Sledgehammer, from ATP module, for formal dependency reasons
blanchet
parents:
43830
diff
changeset
|
1883 |
exporter trans_lambdas readable_names preproc hyp_ts concl_t facts = |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1884 |
let |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1885 |
val (format, type_enc) = choose_format [format] type_enc |
41313
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1886 |
val (fact_names, (conjs, facts, class_rel_clauses, arity_clauses)) = |
43856
d636b053d4ff
move more lambda-handling logic to Sledgehammer, from ATP module, for formal dependency reasons
blanchet
parents:
43830
diff
changeset
|
1887 |
translate_formulas ctxt format prem_kind type_enc trans_lambdas preproc |
43828
e07a2c4cbad8
move lambda translation option from ATP to Sledgehammer, to avoid accidentally breaking Metis (its reconstruction code can only deal with combinators)
blanchet
parents:
43827
diff
changeset
|
1888 |
hyp_ts concl_t facts |
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1889 |
val sym_tab = conjs @ facts |> sym_table_for_facts ctxt explicit_apply |
43572
ae612a423dad
added "sound" option to force Sledgehammer to be pedantically sound
blanchet
parents:
43501
diff
changeset
|
1890 |
val nonmono_Ts = |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1891 |
conjs @ facts |> nonmonotonic_types_for_facts ctxt type_enc sound |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1892 |
val repair = repair_fact ctxt format type_enc sym_tab |
42682
562046fd8e0c
added type homogenization, whereby all (isomorphic) infinite types are mapped to the same type (to reduce the number of different predicates/TFF-types)
blanchet
parents:
42680
diff
changeset
|
1893 |
val (conjs, facts) = (conjs, facts) |> pairself (map repair) |
43064
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1894 |
val repaired_sym_tab = |
b6e61d22fa61
made "explicit_apply" smarter -- no need to force explicit applications in minimizer on all constants, better do it more fine granularly
blanchet
parents:
43039
diff
changeset
|
1895 |
conjs @ facts |> sym_table_for_facts ctxt (SOME false) |
42573
744215c3e90c
got rid of one "sym_table" in "prepare_atp_problem" now that proxies are always handled first, and tuned accordingly
blanchet
parents:
42572
diff
changeset
|
1896 |
val helpers = |
43858
be41d12de6fa
simplify code -- there are no lambdas in helpers anyway
blanchet
parents:
43857
diff
changeset
|
1897 |
repaired_sym_tab |> helper_facts_for_sym_table ctxt format type_enc |
be41d12de6fa
simplify code -- there are no lambdas in helpers anyway
blanchet
parents:
43857
diff
changeset
|
1898 |
|> map repair |
43401
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1899 |
val poly_nonmono_Ts = |
43213
e1fdd27e0c98
generate less type information in polymorphic case
blanchet
parents:
43210
diff
changeset
|
1900 |
if null nonmono_Ts orelse nonmono_Ts = [@{typ bool}] orelse |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1901 |
polymorphism_of_type_enc type_enc <> Polymorphic then |
42894
ce269ee43800
further improvements to "poly_{preds,tags}_{bang,query}" -- better solution to the combinator problem + make sure type assumptions can be discharged
blanchet
parents:
42893
diff
changeset
|
1902 |
nonmono_Ts |
ce269ee43800
further improvements to "poly_{preds,tags}_{bang,query}" -- better solution to the combinator problem + make sure type assumptions can be discharged
blanchet
parents:
42893
diff
changeset
|
1903 |
else |
ce269ee43800
further improvements to "poly_{preds,tags}_{bang,query}" -- better solution to the combinator problem + make sure type assumptions can be discharged
blanchet
parents:
42893
diff
changeset
|
1904 |
[TVar (("'a", 0), HOLogic.typeS)] |
42680 | 1905 |
val sym_decl_lines = |
42731
2490e5e2f3f5
gracefully declare fTrue and fFalse proxies' types if the constants only appear in the helpers
blanchet
parents:
42730
diff
changeset
|
1906 |
(conjs, helpers @ facts) |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1907 |
|> sym_decl_table_for_facts ctxt type_enc repaired_sym_tab |
43401
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1908 |
|> problem_lines_for_sym_decl_table ctxt format conj_sym_kind nonmono_Ts |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1909 |
poly_nonmono_Ts type_enc |
42881
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
1910 |
val helper_lines = |
42956
9aeb0f6ad971
filter Waldmeister facts better -- and don't encode type classes as predicates, since it doesn't like conditional equations
blanchet
parents:
42951
diff
changeset
|
1911 |
0 upto length helpers - 1 ~~ helpers |
43501
0e422a84d0b2
don't change the way helpers are generated for the exporter's sake
blanchet
parents:
43496
diff
changeset
|
1912 |
|> map (formula_line_for_fact ctxt format helper_prefix I false true |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1913 |
poly_nonmono_Ts type_enc) |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1914 |
|> (if needs_type_tag_idempotence type_enc then |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
1915 |
cons (type_tag_idempotence_fact ()) |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
1916 |
else |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
1917 |
I) |
42522
413b56894f82
close ATP formulas universally earlier, so that we can add type predicates
blanchet
parents:
42521
diff
changeset
|
1918 |
(* Reordering these might confuse the proof reconstruction code or the SPASS |
43039 | 1919 |
FLOTTER hack. *) |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1920 |
val problem = |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1921 |
[(explicit_declsN, sym_decl_lines), |
42956
9aeb0f6ad971
filter Waldmeister facts better -- and don't encode type classes as predicates, since it doesn't like conditional equations
blanchet
parents:
42951
diff
changeset
|
1922 |
(factsN, |
43501
0e422a84d0b2
don't change the way helpers are generated for the exporter's sake
blanchet
parents:
43496
diff
changeset
|
1923 |
map (formula_line_for_fact ctxt format fact_prefix ascii_of |
0e422a84d0b2
don't change the way helpers are generated for the exporter's sake
blanchet
parents:
43496
diff
changeset
|
1924 |
(not exporter) (not exporter) nonmono_Ts |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1925 |
type_enc) |
42956
9aeb0f6ad971
filter Waldmeister facts better -- and don't encode type classes as predicates, since it doesn't like conditional equations
blanchet
parents:
42951
diff
changeset
|
1926 |
(0 upto length facts - 1 ~~ facts)), |
42545 | 1927 |
(class_relsN, map formula_line_for_class_rel_clause class_rel_clauses), |
1928 |
(aritiesN, map formula_line_for_arity_clause arity_clauses), |
|
42881
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
1929 |
(helpersN, helper_lines), |
42962
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1930 |
(conjsN, |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1931 |
map (formula_line_for_conjecture ctxt format nonmono_Ts type_enc) |
42962
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1932 |
conjs), |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1933 |
(free_typesN, formula_lines_for_free_types type_enc (facts @ conjs))] |
42543
f9d402d144d4
declare TFF types so that SNARK can be used with types
blanchet
parents:
42542
diff
changeset
|
1934 |
val problem = |
42561
23ddc4e3d19c
have properly type-instantiated helper facts (combinators and If)
blanchet
parents:
42560
diff
changeset
|
1935 |
problem |
43092
93ec303e1917
more work on new metis that exploits the powerful new type encodings
blanchet
parents:
43086
diff
changeset
|
1936 |
|> (case format of |
93ec303e1917
more work on new metis that exploits the powerful new type encodings
blanchet
parents:
43086
diff
changeset
|
1937 |
CNF => ensure_cnf_problem |
93ec303e1917
more work on new metis that exploits the powerful new type encodings
blanchet
parents:
43086
diff
changeset
|
1938 |
| CNF_UEQ => filter_cnf_ueq_problem |
93ec303e1917
more work on new metis that exploits the powerful new type encodings
blanchet
parents:
43086
diff
changeset
|
1939 |
| _ => I) |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1940 |
|> (if is_format_typed format then |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1941 |
declare_undeclared_syms_in_atp_problem type_decl_prefix |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1942 |
implicit_declsN |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1943 |
else |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1944 |
I) |
43092
93ec303e1917
more work on new metis that exploits the powerful new type encodings
blanchet
parents:
43086
diff
changeset
|
1945 |
val (problem, pool) = problem |> nice_atp_problem readable_names |
42881
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
1946 |
val helpers_offset = offset_of_heading_in_problem helpersN problem 0 |
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
1947 |
val typed_helpers = |
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
1948 |
map_filter (fn (j, {name, ...}) => |
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
1949 |
if String.isSuffix typed_helper_suffix name then SOME j |
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
1950 |
else NONE) |
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
1951 |
((helpers_offset + 1 upto helpers_offset + length helpers) |
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
1952 |
~~ helpers) |
42778 | 1953 |
fun add_sym_arity (s, {min_ary, ...} : sym_info) = |
42755
4603154a3018
robustly detect how many type args were passed to the ATP, even if some of them were omitted
blanchet
parents:
42754
diff
changeset
|
1954 |
if min_ary > 0 then |
4603154a3018
robustly detect how many type args were passed to the ATP, even if some of them were omitted
blanchet
parents:
42754
diff
changeset
|
1955 |
case strip_prefix_and_unascii const_prefix s of |
4603154a3018
robustly detect how many type args were passed to the ATP, even if some of them were omitted
blanchet
parents:
42754
diff
changeset
|
1956 |
SOME s => Symtab.insert (op =) (s, min_ary) |
4603154a3018
robustly detect how many type args were passed to the ATP, even if some of them were omitted
blanchet
parents:
42754
diff
changeset
|
1957 |
| NONE => I |
4603154a3018
robustly detect how many type args were passed to the ATP, even if some of them were omitted
blanchet
parents:
42754
diff
changeset
|
1958 |
else |
4603154a3018
robustly detect how many type args were passed to the ATP, even if some of them were omitted
blanchet
parents:
42754
diff
changeset
|
1959 |
I |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1960 |
in |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1961 |
(problem, |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1962 |
case pool of SOME the_pool => snd the_pool | NONE => Symtab.empty, |
42585
723b9d1e8ba5
fixed embarrassing bug where conjecture and fact offsets were swapped
blanchet
parents:
42579
diff
changeset
|
1963 |
offset_of_heading_in_problem conjsN problem 0, |
42541
8938507b2054
move type declarations to the front, for TFF-compliance
blanchet
parents:
42540
diff
changeset
|
1964 |
offset_of_heading_in_problem factsN problem 0, |
42755
4603154a3018
robustly detect how many type args were passed to the ATP, even if some of them were omitted
blanchet
parents:
42754
diff
changeset
|
1965 |
fact_names |> Vector.fromList, |
42881
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
1966 |
typed_helpers, |
42755
4603154a3018
robustly detect how many type args were passed to the ATP, even if some of them were omitted
blanchet
parents:
42754
diff
changeset
|
1967 |
Symtab.empty |> Symtab.fold add_sym_arity sym_tab) |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1968 |
end |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1969 |
|
41313
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1970 |
(* FUDGE *) |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1971 |
val conj_weight = 0.0 |
41770 | 1972 |
val hyp_weight = 0.1 |
1973 |
val fact_min_weight = 0.2 |
|
41313
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1974 |
val fact_max_weight = 1.0 |
42608
6ef61823b63b
make sure E type information constants are given a weight, even if they don't appear anywhere else
blanchet
parents:
42592
diff
changeset
|
1975 |
val type_info_default_weight = 0.8 |
41313
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1976 |
|
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1977 |
fun add_term_weights weight (ATerm (s, tms)) = |
43676
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
1978 |
is_tptp_user_symbol s ? Symtab.default (s, weight) |
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
1979 |
#> fold (add_term_weights weight) tms |
3b0b448b4d69
add support for lambdas in TPTP THF generator + killed an unsound type encoding (because the monotonicity calculus assumes first-order)
nik
parents:
43628
diff
changeset
|
1980 |
| add_term_weights weight (AAbs (_, tm)) = add_term_weights weight tm |
42577
78414ec6fa4e
made the format (TFF or FOF) of the TPTP problem a global argument of the problem again and have the ATPs report which formats they support
blanchet
parents:
42576
diff
changeset
|
1981 |
fun add_problem_line_weights weight (Formula (_, _, phi, _, _)) = |
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1982 |
formula_fold NONE (K (add_term_weights weight)) phi |
42528 | 1983 |
| add_problem_line_weights _ _ = I |
41313
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1984 |
|
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1985 |
fun add_conjectures_weights [] = I |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1986 |
| add_conjectures_weights conjs = |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1987 |
let val (hyps, conj) = split_last conjs in |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1988 |
add_problem_line_weights conj_weight conj |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1989 |
#> fold (add_problem_line_weights hyp_weight) hyps |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1990 |
end |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1991 |
|
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1992 |
fun add_facts_weights facts = |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1993 |
let |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1994 |
val num_facts = length facts |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1995 |
fun weight_of j = |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1996 |
fact_min_weight + (fact_max_weight - fact_min_weight) * Real.fromInt j |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1997 |
/ Real.fromInt num_facts |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1998 |
in |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1999 |
map weight_of (0 upto num_facts - 1) ~~ facts |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2000 |
|> fold (uncurry add_problem_line_weights) |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2001 |
end |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2002 |
|
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2003 |
(* Weights are from 0.0 (most important) to 1.0 (least important). *) |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2004 |
fun atp_problem_weights problem = |
42608
6ef61823b63b
make sure E type information constants are given a weight, even if they don't appear anywhere else
blanchet
parents:
42592
diff
changeset
|
2005 |
let val get = these o AList.lookup (op =) problem in |
6ef61823b63b
make sure E type information constants are given a weight, even if they don't appear anywhere else
blanchet
parents:
42592
diff
changeset
|
2006 |
Symtab.empty |
6ef61823b63b
make sure E type information constants are given a weight, even if they don't appear anywhere else
blanchet
parents:
42592
diff
changeset
|
2007 |
|> add_conjectures_weights (get free_typesN @ get conjsN) |
6ef61823b63b
make sure E type information constants are given a weight, even if they don't appear anywhere else
blanchet
parents:
42592
diff
changeset
|
2008 |
|> add_facts_weights (get factsN) |
6ef61823b63b
make sure E type information constants are given a weight, even if they don't appear anywhere else
blanchet
parents:
42592
diff
changeset
|
2009 |
|> fold (fold (add_problem_line_weights type_info_default_weight) o get) |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2010 |
[explicit_declsN, class_relsN, aritiesN] |
42608
6ef61823b63b
make sure E type information constants are given a weight, even if they don't appear anywhere else
blanchet
parents:
42592
diff
changeset
|
2011 |
|> Symtab.dest |
6ef61823b63b
make sure E type information constants are given a weight, even if they don't appear anywhere else
blanchet
parents:
42592
diff
changeset
|
2012 |
|> sort (prod_ord Real.compare string_ord o pairself swap) |
6ef61823b63b
make sure E type information constants are given a weight, even if they don't appear anywhere else
blanchet
parents:
42592
diff
changeset
|
2013 |
end |
41313
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2014 |
|
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
2015 |
end; |