author | blanchet |
Tue, 30 Aug 2011 16:07:34 +0200 | |
changeset 44589 | 0a1dfc6365e9 |
parent 44587 | 0f50f158eb57 |
child 44591 | 0b107d11f634 |
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 = |
44585 | 19 |
General | Helper | Induction | Extensionality | Intro | Elim | Simp | |
20 |
Local | Assum | 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 |
44494
a77901b3774e
rationalized option names -- mono becomes raw_mono and mangled becomes mono
blanchet
parents:
44493
diff
changeset
|
23 |
datatype polymorphism = Polymorphic | Raw_Monomorphic | Mangled_Monomorphic |
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
24 |
datatype soundness = Unsound | Sound_Modulo_Infiniteness | Sound |
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
|
25 |
datatype type_level = |
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
26 |
All_Types | |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
27 |
Noninf_Nonmono_Types of soundness | |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
28 |
Fin_Nonmono_Types | |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
29 |
Const_Arg_Types | |
43362 | 30 |
No_Types |
44402 | 31 |
datatype type_uniformity = Uniform | Nonuniform |
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
|
32 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
33 |
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
|
34 |
Simple_Types of order * type_level | |
44402 | 35 |
Guards of polymorphism * type_level * type_uniformity | |
36 |
Tags of polymorphism * type_level * type_uniformity |
|
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
|
37 |
|
44496
c1884789ff80
added config options to control two aspects of the translation, for evaluation purposes
blanchet
parents:
44495
diff
changeset
|
38 |
val type_tag_idempotence : bool Config.T |
c1884789ff80
added config options to control two aspects of the translation, for evaluation purposes
blanchet
parents:
44495
diff
changeset
|
39 |
val type_tag_arguments : bool Config.T |
44088
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
40 |
val no_lambdasN : string |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
41 |
val concealedN : string |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
42 |
val liftingN : string |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
43 |
val combinatorsN : string |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
44 |
val hybridN : string |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
45 |
val lambdasN : string |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
46 |
val smartN : string |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
47 |
val schematic_var_prefix : string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
48 |
val fixed_var_prefix : string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
49 |
val tvar_prefix : string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
50 |
val tfree_prefix : string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
51 |
val const_prefix : string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
52 |
val type_const_prefix : string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
53 |
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
|
54 |
val polymorphic_free_prefix : string |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
55 |
val skolem_const_prefix : string |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
56 |
val old_skolem_const_prefix : string |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
57 |
val new_skolem_const_prefix : string |
43125
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
58 |
val type_decl_prefix : string |
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
59 |
val sym_decl_prefix : string |
43989 | 60 |
val guards_sym_formula_prefix : string |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
61 |
val 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
|
62 |
val fact_prefix : string |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
63 |
val conjecture_prefix : string |
42881
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
64 |
val helper_prefix : string |
43125
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
65 |
val class_rel_clause_prefix : string |
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
66 |
val arity_clause_prefix : string |
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
67 |
val tfree_clause_prefix : string |
42881
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
68 |
val typed_helper_suffix : string |
43125
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
69 |
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
|
70 |
val type_tag_idempotence_helper_name : string |
42966
4e2d6c1e5392
more work on parsing LEO-II proofs without lambdas
blanchet
parents:
42963
diff
changeset
|
71 |
val predicator_name : string |
4e2d6c1e5392
more work on parsing LEO-II proofs without lambdas
blanchet
parents:
42963
diff
changeset
|
72 |
val app_op_name : string |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
73 |
val type_guard_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
|
74 |
val type_tag_name : string |
42962
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
75 |
val simple_type_prefix : string |
43174 | 76 |
val prefixed_predicator_name : string |
43130
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
77 |
val prefixed_app_op_name : string |
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
78 |
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
|
79 |
val ascii_of : string -> string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
80 |
val unascii_of : string -> string |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
81 |
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
|
82 |
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
|
83 |
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
|
84 |
val invert_const : string -> string |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
85 |
val unproxify_const : string -> string |
43093 | 86 |
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
|
87 |
val atp_irrelevant_consts : string list |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
88 |
val atp_schematic_consts_of : term -> typ list Symtab.table |
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
89 |
val type_enc_from_string : soundness -> 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
|
90 |
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
|
91 |
val polymorphism_of_type_enc : type_enc -> polymorphism |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
92 |
val level_of_type_enc : type_enc -> type_level |
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
93 |
val is_type_enc_quasi_sound : type_enc -> bool |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
94 |
val is_type_enc_fairly_sound : type_enc -> bool |
44416
cabd06b69c18
added formats to the slice and use TFF for remote Vampire
blanchet
parents:
44410
diff
changeset
|
95 |
val adjust_type_enc : format -> type_enc -> type_enc |
43136
cf5cda219058
handle lightweight tags sym theorems gracefully in the presence of TVars with interesting type classes
blanchet
parents:
43130
diff
changeset
|
96 |
val mk_aconns : |
cf5cda219058
handle lightweight tags sym theorems gracefully in the presence of TVars with interesting type classes
blanchet
parents:
43130
diff
changeset
|
97 |
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
|
98 |
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
|
99 |
val unmangled_const_name : string -> string |
43194 | 100 |
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
|
101 |
val factsN : string |
40059
6ad9081665db
use consistent terminology in Sledgehammer: "prover = ATP or SMT solver or ..."
blanchet
parents:
39975
diff
changeset
|
102 |
val prepare_atp_problem : |
44394
20bd9f90accc
added option to control soundness of encodings more precisely, for evaluation purposes
blanchet
parents:
44393
diff
changeset
|
103 |
Proof.context -> format -> formula_kind -> formula_kind -> type_enc |
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
104 |
-> bool -> string -> bool -> bool -> term list -> term |
44088
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
105 |
-> ((string * locality) * term) list |
42541
8938507b2054
move type declarations to the front, for TFF-compliance
blanchet
parents:
42540
diff
changeset
|
106 |
-> string problem * string Symtab.table * int * int |
43214 | 107 |
* (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
|
108 |
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
|
109 |
end; |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
110 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
111 |
structure ATP_Translate : ATP_TRANSLATE = |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
112 |
struct |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
113 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
114 |
open ATP_Util |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
115 |
open ATP_Problem |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
116 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
117 |
type name = string * string |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
118 |
|
44496
c1884789ff80
added config options to control two aspects of the translation, for evaluation purposes
blanchet
parents:
44495
diff
changeset
|
119 |
val type_tag_idempotence = |
44540
968115499161
change default for generation of tag idempotence and tag argument equations
blanchet
parents:
44508
diff
changeset
|
120 |
Attrib.setup_config_bool @{binding atp_type_tag_idempotence} (K false) |
44496
c1884789ff80
added config options to control two aspects of the translation, for evaluation purposes
blanchet
parents:
44495
diff
changeset
|
121 |
val type_tag_arguments = |
44540
968115499161
change default for generation of tag idempotence and tag argument equations
blanchet
parents:
44508
diff
changeset
|
122 |
Attrib.setup_config_bool @{binding atp_type_tag_arguments} (K false) |
44496
c1884789ff80
added config options to control two aspects of the translation, for evaluation purposes
blanchet
parents:
44495
diff
changeset
|
123 |
|
44088
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
124 |
val no_lambdasN = "no_lambdas" |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
125 |
val concealedN = "concealed" |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
126 |
val liftingN = "lifting" |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
127 |
val combinatorsN = "combinators" |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
128 |
val hybridN = "hybrid" |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
129 |
val lambdasN = "lambdas" |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
130 |
val smartN = "smart" |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
131 |
|
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
|
132 |
val generate_info = false (* experimental *) |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
133 |
|
43693 | 134 |
fun isabelle_info s = |
135 |
if generate_info then SOME (ATerm ("[]", [ATerm ("isabelle_" ^ s, [])])) |
|
136 |
else NONE |
|
42879 | 137 |
|
43693 | 138 |
val introN = "intro" |
139 |
val elimN = "elim" |
|
140 |
val simpN = "simp" |
|
42879 | 141 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
142 |
val bound_var_prefix = "B_" |
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
143 |
val all_bound_var_prefix = "BA_" |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
144 |
val exist_bound_var_prefix = "BE_" |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
145 |
val schematic_var_prefix = "V_" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
146 |
val fixed_var_prefix = "v_" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
147 |
val tvar_prefix = "T_" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
148 |
val tfree_prefix = "t_" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
149 |
val const_prefix = "c_" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
150 |
val type_const_prefix = "tc_" |
44491
ba22ed224b20
fixed bang encoding detection of which types to encode
blanchet
parents:
44463
diff
changeset
|
151 |
val simple_type_prefix = "s_" |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
152 |
val class_prefix = "cl_" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
153 |
|
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
|
154 |
val polymorphic_free_prefix = "poly_free" |
43907
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
155 |
|
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
|
156 |
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
|
157 |
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
|
158 |
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
|
159 |
|
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
160 |
val type_decl_prefix = "ty_" |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
161 |
val sym_decl_prefix = "sy_" |
43989 | 162 |
val guards_sym_formula_prefix = "gsy_" |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
163 |
val 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
|
164 |
val fact_prefix = "fact_" |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
165 |
val conjecture_prefix = "conj_" |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
166 |
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
|
167 |
val class_rel_clause_prefix = "clar_" |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
168 |
val arity_clause_prefix = "arity_" |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
169 |
val tfree_clause_prefix = "tfree_" |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
170 |
|
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
|
171 |
val lambda_fact_prefix = "ATP.lambda_" |
42881
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
172 |
val typed_helper_suffix = "_T" |
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
173 |
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
|
174 |
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
|
175 |
|
44491
ba22ed224b20
fixed bang encoding detection of which types to encode
blanchet
parents:
44463
diff
changeset
|
176 |
val predicator_name = "pp" |
ba22ed224b20
fixed bang encoding detection of which types to encode
blanchet
parents:
44463
diff
changeset
|
177 |
val app_op_name = "aa" |
ba22ed224b20
fixed bang encoding detection of which types to encode
blanchet
parents:
44463
diff
changeset
|
178 |
val type_guard_name = "gg" |
ba22ed224b20
fixed bang encoding detection of which types to encode
blanchet
parents:
44463
diff
changeset
|
179 |
val type_tag_name = "tt" |
42531
a462dbaa584f
added more rudimentary type support to Sledgehammer's ATP encoding
blanchet
parents:
42530
diff
changeset
|
180 |
|
43174 | 181 |
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
|
182 |
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
|
183 |
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
|
184 |
|
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
185 |
(* 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
|
186 |
val atp_weak_prefix = "ATP:" |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
187 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
188 |
(*Escaping of special characters. |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
189 |
Alphanumeric characters are left unchanged. |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
190 |
The character _ goes to __ |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
191 |
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
|
192 |
Other characters go to _nnn where nnn is the decimal ASCII code.*) |
43093 | 193 |
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
|
194 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
195 |
fun stringN_of_int 0 _ = "" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
196 |
| stringN_of_int k n = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
197 |
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
|
198 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
199 |
fun ascii_of_char c = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
200 |
if Char.isAlphaNum c then |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
201 |
String.str c |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
202 |
else if c = #"_" then |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
203 |
"__" |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
204 |
else if #" " <= c andalso c <= #"/" then |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
205 |
"_" ^ 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
|
206 |
else |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
207 |
(* fixed width, in case more digits follow *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
208 |
"_" ^ stringN_of_int 3 (Char.ord c) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
209 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
210 |
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
|
211 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
212 |
(** 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
|
213 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
214 |
(* 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
|
215 |
thread. Also, the errors are impossible. *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
216 |
val unascii_of = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
217 |
let |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
218 |
fun un rcs [] = String.implode(rev rcs) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
219 |
| un rcs [#"_"] = un (#"_" :: rcs) [] (* ERROR *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
220 |
(* 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
|
221 |
| un rcs (#"_" :: #"_" :: cs) = un (#"_" :: rcs) cs |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
222 |
| un rcs (#"_" :: c :: cs) = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
223 |
if #"A" <= c andalso c<= #"P" then |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
224 |
(* translation of #" " to #"/" *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
225 |
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
|
226 |
else |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
227 |
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
|
228 |
case Int.fromString (String.implode digits) of |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
229 |
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
|
230 |
| NONE => un (c :: #"_" :: rcs) cs (* ERROR *) |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
231 |
end |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
232 |
| 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
|
233 |
in un [] o String.explode end |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
234 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
235 |
(* 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
|
236 |
un-ASCII'd. *) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
237 |
fun strip_prefix_and_unascii s1 s = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
238 |
if String.isPrefix s1 s then |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
239 |
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
|
240 |
else |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
241 |
NONE |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
242 |
|
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
243 |
val proxy_table = |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
244 |
[("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
|
245 |
("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
|
246 |
("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
|
247 |
("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
|
248 |
("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
|
249 |
("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
|
250 |
("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
|
251 |
("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
|
252 |
("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
|
253 |
("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
|
254 |
("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
|
255 |
("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
|
256 |
("equal", (@{const_name HOL.eq}, (@{thm fequal_def}, |
43678 | 257 |
("fequal", @{const_name ATP.fequal})))), |
258 |
("c_All", (@{const_name All}, (@{thm fAll_def}, |
|
259 |
("fAll", @{const_name ATP.fAll})))), |
|
260 |
("c_Ex", (@{const_name Ex}, (@{thm fEx_def}, |
|
261 |
("fEx", @{const_name ATP.fEx}))))] |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
262 |
|
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
263 |
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
|
264 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
265 |
(* 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
|
266 |
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
|
267 |
val const_trans_table = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
268 |
[(@{type_name Product_Type.prod}, "prod"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
269 |
(@{type_name Sum_Type.sum}, "sum"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
270 |
(@{const_name False}, "False"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
271 |
(@{const_name True}, "True"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
272 |
(@{const_name Not}, "Not"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
273 |
(@{const_name conj}, "conj"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
274 |
(@{const_name disj}, "disj"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
275 |
(@{const_name implies}, "implies"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
276 |
(@{const_name HOL.eq}, "equal"), |
43678 | 277 |
(@{const_name All}, "All"), |
278 |
(@{const_name Ex}, "Ex"), |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
279 |
(@{const_name If}, "If"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
280 |
(@{const_name Set.member}, "member"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
281 |
(@{const_name Meson.COMBI}, "COMBI"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
282 |
(@{const_name Meson.COMBK}, "COMBK"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
283 |
(@{const_name Meson.COMBB}, "COMBB"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
284 |
(@{const_name Meson.COMBC}, "COMBC"), |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
285 |
(@{const_name Meson.COMBS}, "COMBS")] |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
286 |
|> Symtab.make |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
287 |
|> 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
|
288 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
289 |
(* 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
|
290 |
val const_trans_table_inv = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
291 |
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
|
292 |
val const_trans_table_unprox = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
293 |
Symtab.empty |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
294 |
|> 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
|
295 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
296 |
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
|
297 |
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
|
298 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
299 |
fun lookup_const c = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
300 |
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
|
301 |
SOME c' => c' |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
302 |
| NONE => ascii_of c |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
303 |
|
43622 | 304 |
fun ascii_of_indexname (v, 0) = ascii_of v |
305 |
| 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
|
306 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
307 |
fun make_bound_var x = bound_var_prefix ^ ascii_of x |
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
308 |
fun make_all_bound_var x = all_bound_var_prefix ^ ascii_of x |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
309 |
fun make_exist_bound_var x = exist_bound_var_prefix ^ ascii_of x |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
310 |
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
|
311 |
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
|
312 |
|
43622 | 313 |
fun make_schematic_type_var (x, i) = |
314 |
tvar_prefix ^ (ascii_of_indexname (unprefix "'" x, i)) |
|
315 |
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
|
316 |
|
44587 | 317 |
(* "HOL.eq" and Choice are mapped to the ATP's equivalents *) |
318 |
local |
|
319 |
val choice_const = (fst o dest_Const o HOLogic.choice_const) Term.dummyT |
|
320 |
fun default c = const_prefix ^ lookup_const c |
|
321 |
in |
|
322 |
fun make_fixed_const _ @{const_name HOL.eq} = tptp_old_equal |
|
44589
0a1dfc6365e9
first step towards polymorphic TFF + changed defaults for Vampire
blanchet
parents:
44587
diff
changeset
|
323 |
| make_fixed_const (SOME (THF0 THF_With_Choice)) c = |
44587 | 324 |
if c = choice_const then tptp_choice else default c |
325 |
| make_fixed_const _ c = default c |
|
326 |
end |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
327 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
328 |
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
|
329 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
330 |
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
|
331 |
|
43093 | 332 |
fun new_skolem_var_name_from_const s = |
333 |
let val ss = s |> space_explode Long_Name.separator in |
|
334 |
nth ss (length ss - 2) |
|
335 |
end |
|
336 |
||
43248
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
337 |
(* 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
|
338 |
handled specially via "fFalse", "fTrue", ..., "fequal". *) |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
339 |
val atp_irrelevant_consts = |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
340 |
[@{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
|
341 |
@{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
|
342 |
@{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
|
343 |
|
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
344 |
val atp_monomorph_bad_consts = |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
345 |
atp_irrelevant_consts @ |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
346 |
(* 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
|
347 |
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
|
348 |
[@{const_name all}, @{const_name "==>"}, @{const_name "=="}, |
69375eaa9016
more suitable implementation of "schematic_consts_of" for monomorphizer, for ATPs
blanchet
parents:
43222
diff
changeset
|
349 |
@{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
|
350 |
@{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
|
351 |
|
43258
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
352 |
fun add_schematic_const (x as (_, T)) = |
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
353 |
Monomorph.typ_has_tvars T ? Symtab.insert_list (op =) x |
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
354 |
val add_schematic_consts_of = |
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
355 |
Term.fold_aterms (fn Const (x as (s, _)) => |
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
356 |
not (member (op =) atp_monomorph_bad_consts s) |
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
357 |
? add_schematic_const x |
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
358 |
| _ => I) |
956895f99904
slightly faster/cleaner accumulation of polymorphic consts
blanchet
parents:
43248
diff
changeset
|
359 |
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
|
360 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
361 |
(** 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
|
362 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
363 |
(* 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
|
364 |
datatype type_literal = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
365 |
TyLitVar of name * name | |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
366 |
TyLitFree of name * name |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
367 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
368 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
369 |
(** Isabelle arities **) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
370 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
371 |
datatype arity_literal = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
372 |
TConsLit of name * name * name list | |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
373 |
TVarLit of name * name |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
374 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
375 |
fun gen_TVars 0 = [] |
43093 | 376 |
| 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
|
377 |
|
43263 | 378 |
val type_class = the_single @{sort type} |
379 |
||
380 |
fun add_packed_sort tvar = |
|
381 |
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
|
382 |
|
43086 | 383 |
type arity_clause = |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
384 |
{name : string, |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
385 |
prem_lits : arity_literal list, |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
386 |
concl_lits : arity_literal} |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
387 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
388 |
(* 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
|
389 |
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
|
390 |
let |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
391 |
val tvars = gen_TVars (length args) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
392 |
val tvars_srts = ListPair.zip (tvars, args) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
393 |
in |
43086 | 394 |
{name = name, |
43263 | 395 |
prem_lits = [] |> fold (uncurry add_packed_sort) tvars_srts |> map TVarLit, |
43086 | 396 |
concl_lits = TConsLit (`make_type_class cls, |
397 |
`make_fixed_type_const tcons, |
|
398 |
tvars ~~ tvars)} |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
399 |
end |
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 |
fun arity_clause _ _ (_, []) = [] |
43495 | 402 |
| arity_clause seen n (tcons, ("HOL.type", _) :: ars) = (* ignore *) |
403 |
arity_clause seen n (tcons, ars) |
|
404 |
| arity_clause seen n (tcons, (ar as (class, _)) :: ars) = |
|
405 |
if member (op =) seen class then |
|
406 |
(* multiple arities for the same (tycon, class) pair *) |
|
407 |
make_axiom_arity_clause (tcons, |
|
408 |
lookup_const tcons ^ "___" ^ ascii_of class ^ "_" ^ string_of_int n, |
|
409 |
ar) :: |
|
410 |
arity_clause seen (n + 1) (tcons, ars) |
|
411 |
else |
|
412 |
make_axiom_arity_clause (tcons, lookup_const tcons ^ "___" ^ |
|
413 |
ascii_of class, ar) :: |
|
414 |
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
|
415 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
416 |
fun multi_arity_clause [] = [] |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
417 |
| multi_arity_clause ((tcons, ars) :: tc_arlists) = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
418 |
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
|
419 |
|
43622 | 420 |
(* Generate all pairs (tycon, class, sorts) such that tycon belongs to class in |
421 |
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
|
422 |
fun type_class_pairs thy tycons classes = |
43093 | 423 |
let |
424 |
val alg = Sign.classes_of thy |
|
425 |
fun domain_sorts tycon = Sorts.mg_domain alg tycon o single |
|
426 |
fun add_class tycon class = |
|
427 |
cons (class, domain_sorts tycon class) |
|
428 |
handle Sorts.CLASS_ERROR _ => I |
|
429 |
fun try_classes tycon = (tycon, fold (add_class tycon) classes []) |
|
430 |
in map try_classes tycons end |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
431 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
432 |
(*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
|
433 |
fun iter_type_class_pairs _ _ [] = ([], []) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
434 |
| iter_type_class_pairs thy tycons classes = |
43263 | 435 |
let |
436 |
fun maybe_insert_class s = |
|
437 |
(s <> type_class andalso not (member (op =) classes s)) |
|
438 |
? insert (op =) s |
|
439 |
val cpairs = type_class_pairs thy tycons classes |
|
440 |
val newclasses = |
|
441 |
[] |> fold (fold (fold (fold maybe_insert_class) o snd) o snd) cpairs |
|
442 |
val (classes', cpairs') = iter_type_class_pairs thy tycons newclasses |
|
43266 | 443 |
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
|
444 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
445 |
fun make_arity_clauses thy tycons = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
446 |
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
|
447 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
448 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
449 |
(** Isabelle class relations **) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
450 |
|
43086 | 451 |
type class_rel_clause = |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
452 |
{name : string, |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
453 |
subclass : name, |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
454 |
superclass : name} |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
455 |
|
43622 | 456 |
(* Generate all pairs (sub, super) such that sub is a proper subclass of super |
457 |
in theory "thy". *) |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
458 |
fun class_pairs _ [] _ = [] |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
459 |
| class_pairs thy subs supers = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
460 |
let |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
461 |
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
|
462 |
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
|
463 |
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
|
464 |
in fold add_supers subs [] end |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
465 |
|
43622 | 466 |
fun make_class_rel_clause (sub, super) = |
467 |
{name = sub ^ "_" ^ super, subclass = `make_type_class sub, |
|
43086 | 468 |
superclass = `make_type_class super} |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
469 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
470 |
fun make_class_rel_clauses thy subs supers = |
43093 | 471 |
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
|
472 |
|
43859 | 473 |
(* intermediate terms *) |
474 |
datatype iterm = |
|
475 |
IConst of name * typ * typ list | |
|
476 |
IVar of name * typ | |
|
477 |
IApp of iterm * iterm | |
|
478 |
IAbs of (name * typ) * iterm |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
479 |
|
43859 | 480 |
fun ityp_of (IConst (_, T, _)) = T |
481 |
| ityp_of (IVar (_, T)) = T |
|
482 |
| ityp_of (IApp (t1, _)) = snd (dest_funT (ityp_of t1)) |
|
483 |
| 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
|
484 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
485 |
(*gets the head of a combinator application, along with the list of arguments*) |
43859 | 486 |
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
|
487 |
let |
43859 | 488 |
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
|
489 |
| stripc x = x |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
490 |
in stripc (u, []) end |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
491 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
492 |
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
|
493 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
494 |
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
|
495 |
[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
|
496 |
|> space_implode Long_Name.separator |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
497 |
|
43859 | 498 |
(* Converts an Isabelle/HOL term (with combinators) into an intermediate term. |
499 |
Also accumulates sort infomation. *) |
|
44495 | 500 |
fun iterm_from_term thy format bs (P $ Q) = |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
501 |
let |
44495 | 502 |
val (P', P_atomics_Ts) = iterm_from_term thy format bs P |
503 |
val (Q', Q_atomics_Ts) = iterm_from_term thy format bs Q |
|
43859 | 504 |
in (IApp (P', Q'), union (op =) P_atomics_Ts Q_atomics_Ts) end |
44495 | 505 |
| iterm_from_term thy format _ (Const (c, T)) = |
506 |
(IConst (`(make_fixed_const (SOME format)) c, T, |
|
43907
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
507 |
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
|
508 |
[] |> Term.add_tvarsT T |> map TVar |
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
509 |
else |
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
510 |
(c, T) |> Sign.const_typargs thy), |
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
511 |
atyps_of T) |
44495 | 512 |
| iterm_from_term _ _ _ (Free (s, T)) = |
43907
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
513 |
(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
|
514 |
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
|
515 |
atyps_of T) |
44495 | 516 |
| iterm_from_term _ format _ (Var (v as (s, _), T)) = |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
517 |
(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
|
518 |
let |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
519 |
val Ts = T |> strip_type |> swap |> op :: |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
520 |
val s' = new_skolem_const_name s (length Ts) |
44495 | 521 |
in IConst (`(make_fixed_const (SOME format)) s', T, Ts) end |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
522 |
else |
43859 | 523 |
IVar ((make_schematic_var v, s), T), atyps_of T) |
44495 | 524 |
| iterm_from_term _ _ bs (Bound j) = |
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
525 |
nth bs j |> (fn (_, (name, T)) => (IConst (name, T, []), atyps_of T)) |
44495 | 526 |
| iterm_from_term thy format bs (Abs (s, T, t)) = |
43678 | 527 |
let |
528 |
fun vary s = s |> AList.defined (op =) bs s ? vary o Symbol.bump_string |
|
529 |
val s = vary s |
|
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
530 |
val name = `make_bound_var s |
44495 | 531 |
val (tm, atomic_Ts) = iterm_from_term thy format ((s, (name, T)) :: bs) t |
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
532 |
in (IAbs ((name, T), tm), union (op =) atomic_Ts (atyps_of T)) end |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
533 |
|
43421 | 534 |
datatype locality = |
44585 | 535 |
General | Helper | Induction | Extensionality | Intro | Elim | Simp | |
536 |
Local | Assum | Chained |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
537 |
|
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
|
538 |
datatype order = First_Order | Higher_Order |
44494
a77901b3774e
rationalized option names -- mono becomes raw_mono and mangled becomes mono
blanchet
parents:
44493
diff
changeset
|
539 |
datatype polymorphism = Polymorphic | Raw_Monomorphic | Mangled_Monomorphic |
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
540 |
datatype soundness = Unsound | Sound_Modulo_Infiniteness | Sound |
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
|
541 |
datatype type_level = |
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
542 |
All_Types | |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
543 |
Noninf_Nonmono_Types of soundness | |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
544 |
Fin_Nonmono_Types | |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
545 |
Const_Arg_Types | |
43362 | 546 |
No_Types |
44402 | 547 |
datatype type_uniformity = Uniform | Nonuniform |
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 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
549 |
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
|
550 |
Simple_Types of order * type_level | |
44402 | 551 |
Guards of polymorphism * type_level * type_uniformity | |
552 |
Tags of polymorphism * type_level * type_uniformity |
|
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
|
553 |
|
42689
e38590764c34
versions of ! and ? for the ASCII-challenged Mirabelle
blanchet
parents:
42688
diff
changeset
|
554 |
fun try_unsuffixes ss s = |
e38590764c34
versions of ! and ? for the ASCII-challenged Mirabelle
blanchet
parents:
42688
diff
changeset
|
555 |
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
|
556 |
|
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
557 |
fun type_enc_from_string soundness s = |
42722 | 558 |
(case try (unprefix "poly_") s of |
559 |
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
|
560 |
| NONE => |
44494
a77901b3774e
rationalized option names -- mono becomes raw_mono and mangled becomes mono
blanchet
parents:
44493
diff
changeset
|
561 |
case try (unprefix "raw_mono_") s of |
a77901b3774e
rationalized option names -- mono becomes raw_mono and mangled becomes mono
blanchet
parents:
44493
diff
changeset
|
562 |
SOME s => (SOME Raw_Monomorphic, s) |
42722 | 563 |
| NONE => |
44494
a77901b3774e
rationalized option names -- mono becomes raw_mono and mangled becomes mono
blanchet
parents:
44493
diff
changeset
|
564 |
case try (unprefix "mono_") s of |
42722 | 565 |
SOME s => (SOME Mangled_Monomorphic, s) |
566 |
| 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
|
567 |
||> (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
|
568 |
(* "_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
|
569 |
Mirabelle. *) |
42689
e38590764c34
versions of ! and ? for the ASCII-challenged Mirabelle
blanchet
parents:
42688
diff
changeset
|
570 |
case try_unsuffixes ["?", "_query"] s of |
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
571 |
SOME s => (Noninf_Nonmono_Types soundness, 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
|
572 |
| NONE => |
42689
e38590764c34
versions of ! and ? for the ASCII-challenged Mirabelle
blanchet
parents:
42688
diff
changeset
|
573 |
case try_unsuffixes ["!", "_bang"] s of |
43362 | 574 |
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
|
575 |
| NONE => (All_Types, s)) |
42828 | 576 |
||> apsnd (fn s => |
44402 | 577 |
case try (unsuffix "_uniform") s of |
578 |
SOME s => (Uniform, s) |
|
579 |
| NONE => (Nonuniform, s)) |
|
580 |
|> (fn (poly, (level, (uniformity, core))) => |
|
581 |
case (core, (poly, level, uniformity)) of |
|
582 |
("simple", (NONE, _, Nonuniform)) => |
|
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
|
583 |
Simple_Types (First_Order, level) |
44402 | 584 |
| ("simple_higher", (NONE, _, Nonuniform)) => |
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
585 |
(case level of |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
586 |
Noninf_Nonmono_Types _ => raise Same.SAME |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
587 |
| _ => Simple_Types (Higher_Order, level)) |
44402 | 588 |
| ("guards", (SOME poly, _, _)) => Guards (poly, level, uniformity) |
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
|
589 |
| ("tags", (SOME Polymorphic, _, _)) => |
44402 | 590 |
Tags (Polymorphic, level, uniformity) |
591 |
| ("tags", (SOME poly, _, _)) => Tags (poly, level, uniformity) |
|
592 |
| ("args", (SOME poly, All_Types (* naja *), Nonuniform)) => |
|
593 |
Guards (poly, Const_Arg_Types, Nonuniform) |
|
594 |
| ("erased", (NONE, All_Types (* naja *), Nonuniform)) => |
|
595 |
Guards (Polymorphic, No_Types, Nonuniform) |
|
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
|
596 |
| _ => 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
|
597 |
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
|
598 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
599 |
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
|
600 |
| 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
|
601 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
602 |
fun polymorphism_of_type_enc (Simple_Types _) = Mangled_Monomorphic |
43989 | 603 |
| polymorphism_of_type_enc (Guards (poly, _, _)) = poly |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
604 |
| 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
|
605 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
606 |
fun level_of_type_enc (Simple_Types (_, level)) = level |
43989 | 607 |
| level_of_type_enc (Guards (_, level, _)) = level |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
608 |
| level_of_type_enc (Tags (_, level, _)) = level |
42828 | 609 |
|
44402 | 610 |
fun uniformity_of_type_enc (Simple_Types _) = Uniform |
611 |
| uniformity_of_type_enc (Guards (_, _, uniformity)) = uniformity |
|
612 |
| uniformity_of_type_enc (Tags (_, _, uniformity)) = uniformity |
|
42831
c9b0968484fb
more work on "shallow" encoding + adjustments to other encodings
blanchet
parents:
42830
diff
changeset
|
613 |
|
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
614 |
fun is_type_level_quasi_sound All_Types = true |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
615 |
| is_type_level_quasi_sound (Noninf_Nonmono_Types _) = true |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
616 |
| is_type_level_quasi_sound _ = false |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
617 |
val is_type_enc_quasi_sound = |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
618 |
is_type_level_quasi_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
|
619 |
|
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
|
620 |
fun is_type_level_fairly_sound level = |
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
621 |
is_type_level_quasi_sound level orelse level = Fin_Nonmono_Types |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
622 |
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
|
623 |
|
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
624 |
fun is_type_level_monotonicity_based (Noninf_Nonmono_Types _) = true |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
625 |
| is_type_level_monotonicity_based Fin_Nonmono_Types = true |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
626 |
| is_type_level_monotonicity_based _ = false |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
627 |
|
44589
0a1dfc6365e9
first step towards polymorphic TFF + changed defaults for Vampire
blanchet
parents:
44587
diff
changeset
|
628 |
fun adjust_type_enc (THF0 _) type_enc = type_enc |
44499 | 629 |
| adjust_type_enc (TFF _) (Simple_Types (_, level)) = |
44416
cabd06b69c18
added formats to the slice and use TFF for remote Vampire
blanchet
parents:
44410
diff
changeset
|
630 |
Simple_Types (First_Order, level) |
cabd06b69c18
added formats to the slice and use TFF for remote Vampire
blanchet
parents:
44410
diff
changeset
|
631 |
| adjust_type_enc format (Simple_Types (_, level)) = |
cabd06b69c18
added formats to the slice and use TFF for remote Vampire
blanchet
parents:
44410
diff
changeset
|
632 |
adjust_type_enc format (Guards (Mangled_Monomorphic, level, Uniform)) |
cabd06b69c18
added formats to the slice and use TFF for remote Vampire
blanchet
parents:
44410
diff
changeset
|
633 |
| adjust_type_enc CNF_UEQ (type_enc as Guards stuff) = |
cabd06b69c18
added formats to the slice and use TFF for remote Vampire
blanchet
parents:
44410
diff
changeset
|
634 |
(if is_type_enc_fairly_sound type_enc then Tags else Guards) stuff |
cabd06b69c18
added formats to the slice and use TFF for remote Vampire
blanchet
parents:
44410
diff
changeset
|
635 |
| adjust_type_enc _ type_enc = type_enc |
43101
1d46d85cd78b
make "prepare_atp_problem" more robust w.r.t. choice of type system
blanchet
parents:
43098
diff
changeset
|
636 |
|
44088
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
637 |
fun lift_lambdas ctxt type_enc = |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
638 |
map (close_form o Envir.eta_contract) #> rpair ctxt |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
639 |
#-> Lambda_Lifting.lift_lambdas |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
640 |
(if polymorphism_of_type_enc type_enc = Polymorphic then |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
641 |
SOME polymorphic_free_prefix |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
642 |
else |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
643 |
NONE) |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
644 |
Lambda_Lifting.is_quantifier |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
645 |
#> fst |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
646 |
|
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
647 |
fun intentionalize_def (Const (@{const_name All}, _) $ Abs (_, _, t)) = |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
648 |
intentionalize_def t |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
649 |
| intentionalize_def (Const (@{const_name HOL.eq}, _) $ t $ u) = |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
650 |
let |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
651 |
fun lam T t = Abs (Name.uu, T, t) |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
652 |
val (head, args) = strip_comb t ||> rev |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
653 |
val head_T = fastype_of head |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
654 |
val n = length args |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
655 |
val arg_Ts = head_T |> binder_types |> take n |> rev |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
656 |
val u = u |> subst_atomic (args ~~ map Bound (0 upto n - 1)) |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
657 |
in HOLogic.eq_const head_T $ head $ fold lam arg_Ts u end |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
658 |
| intentionalize_def t = t |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
659 |
|
40114 | 660 |
type translated_formula = |
43496
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
661 |
{name : string, |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
662 |
locality : locality, |
92f5a4c78b37
remove historical bloat -- another benefit of merging Metis's and Sledgehammer's translations
blanchet
parents:
43495
diff
changeset
|
663 |
kind : formula_kind, |
43859 | 664 |
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
|
665 |
atomic_types : typ list} |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
666 |
|
43859 | 667 |
fun update_iformula f ({name, locality, kind, iformula, atomic_types} |
668 |
: translated_formula) = |
|
669 |
{name = name, locality = locality, kind = kind, iformula = f iformula, |
|
42562 | 670 |
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
|
671 |
|
43859 | 672 |
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
|
673 |
|
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
|
674 |
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
|
675 |
let val T = get_T x in |
44399 | 676 |
if exists (type_instance ctxt T o get_T) xs then xs |
677 |
else x :: filter_out (type_generalization ctxt T o get_T) xs |
|
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
|
678 |
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
|
679 |
|
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
|
680 |
(* 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
|
681 |
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
|
682 |
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
|
683 |
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
|
684 |
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
|
685 |
|
42836 | 686 |
fun should_drop_arg_type_args (Simple_Types _) = |
687 |
false (* since TFF doesn't support overloading *) |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
688 |
| should_drop_arg_type_args type_enc = |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
689 |
level_of_type_enc type_enc = All_Types andalso |
44402 | 690 |
uniformity_of_type_enc type_enc = Uniform |
42831
c9b0968484fb
more work on "shallow" encoding + adjustments to other encodings
blanchet
parents:
42830
diff
changeset
|
691 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
692 |
fun type_arg_policy type_enc s = |
43628
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
693 |
if s = type_tag_name then |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
694 |
(if polymorphism_of_type_enc type_enc = Mangled_Monomorphic then |
43623 | 695 |
Mangled_Type_Args |
696 |
else |
|
697 |
Explicit_Type_Args) false |
|
43628
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
698 |
else case type_enc of |
44402 | 699 |
Tags (_, All_Types, Uniform) => No_Type_Args |
43628
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
700 |
| _ => |
44398 | 701 |
let val level = level_of_type_enc type_enc in |
702 |
if level = No_Types orelse s = @{const_name HOL.eq} orelse |
|
703 |
(s = app_op_name andalso level = Const_Arg_Types) then |
|
704 |
No_Type_Args |
|
705 |
else |
|
706 |
should_drop_arg_type_args type_enc |
|
707 |
|> (if polymorphism_of_type_enc type_enc = Mangled_Monomorphic then |
|
708 |
Mangled_Type_Args |
|
709 |
else |
|
710 |
Explicit_Type_Args) |
|
711 |
end |
|
42227
662b50b7126f
if "monomorphize" is enabled, mangle the type information in the names by default
blanchet
parents:
42180
diff
changeset
|
712 |
|
43628
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
713 |
(* Make literals for sorted type variables. *) |
43263 | 714 |
fun generic_add_sorts_on_type (_, []) = I |
715 |
| generic_add_sorts_on_type ((x, i), s :: ss) = |
|
716 |
generic_add_sorts_on_type ((x, i), ss) |
|
717 |
#> (if s = the_single @{sort HOL.type} then |
|
43093 | 718 |
I |
719 |
else if i = ~1 then |
|
43263 | 720 |
insert (op =) (TyLitFree (`make_type_class s, `make_fixed_type_var x)) |
43093 | 721 |
else |
43263 | 722 |
insert (op =) (TyLitVar (`make_type_class s, |
723 |
(make_schematic_type_var (x, i), x)))) |
|
724 |
fun add_sorts_on_tfree (TFree (s, S)) = generic_add_sorts_on_type ((s, ~1), S) |
|
725 |
| add_sorts_on_tfree _ = I |
|
726 |
fun add_sorts_on_tvar (TVar z) = generic_add_sorts_on_type z |
|
727 |
| add_sorts_on_tvar _ = I |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
728 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
729 |
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
|
730 |
[] |> 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
|
731 |
|
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
|
732 |
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
|
733 |
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
|
734 |
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
|
735 |
end |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
736 |
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
|
737 |
| 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
|
738 |
fun mk_aquant _ [] phi = phi |
413b56894f82
close ATP formulas universally earlier, so that we can add type predicates
blanchet
parents:
42521
diff
changeset
|
739 |
| 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
|
740 |
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
|
741 |
| 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
|
742 |
|
42522
413b56894f82
close ATP formulas universally earlier, so that we can add type predicates
blanchet
parents:
42521
diff
changeset
|
743 |
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
|
744 |
let |
a5ee3b8e5a90
improve partially tagged encoding by adding a helper fact that coalesces consecutive "ti" tags
blanchet
parents:
41140
diff
changeset
|
745 |
fun formula_vars bounds (AQuant (_, xs, phi)) = |
42526 | 746 |
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
|
747 |
| 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
|
748 |
| formula_vars bounds (AAtom tm) = |
42526 | 749 |
union (op =) (atom_vars tm [] |
750 |
|> 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
|
751 |
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
|
752 |
|
43859 | 753 |
fun iterm_vars (IApp (tm1, tm2)) = fold iterm_vars [tm1, tm2] |
754 |
| iterm_vars (IConst _) = I |
|
755 |
| iterm_vars (IVar (name, T)) = insert (op =) (name, SOME T) |
|
756 |
| iterm_vars (IAbs (_, tm)) = iterm_vars tm |
|
757 |
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
|
758 |
|
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
|
759 |
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
|
760 |
(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
|
761 |
? 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
|
762 |
| 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
|
763 |
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
|
764 |
|
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
765 |
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
|
766 |
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
|
767 |
|
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
|
768 |
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
|
769 |
let |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
770 |
fun term (Type (s, Ts)) = |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
771 |
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
|
772 |
(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
|
773 |
| (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
|
774 |
| _ => if s = homo_infinite_type_name andalso |
44235
85e9dad3c187
distinguish THF syntax with and without choice (Satallax vs. LEO-II)
blanchet
parents:
44121
diff
changeset
|
775 |
is_format_typed format then |
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
|
776 |
`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
|
777 |
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
|
778 |
`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
|
779 |
map term Ts) |
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
780 |
| 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
|
781 |
| 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
|
782 |
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
|
783 |
in term end |
42562 | 784 |
|
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
|
785 |
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
|
786 |
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
|
787 |
|
42562 | 788 |
(* 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
|
789 |
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
|
790 |
|
42562 | 791 |
fun generic_mangled_type_name f (ATerm (name, [])) = f name |
792 |
| 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
|
793 |
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
|
794 |
^ ")" |
43692 | 795 |
| 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
|
796 |
|
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
797 |
fun mangled_type format type_enc = |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
798 |
generic_mangled_type_name fst o ho_term_from_typ format type_enc |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
799 |
|
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
800 |
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
|
801 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
802 |
fun make_simple_type s = |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
803 |
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
|
804 |
s = tptp_individual_type then |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
805 |
s |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
806 |
else |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
807 |
simple_type_prefix ^ ascii_of s |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
808 |
|
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
|
809 |
fun ho_type_from_ho_term type_enc pred_sym ary = |
42963 | 810 |
let |
811 |
fun to_atype ty = |
|
812 |
AType ((make_simple_type (generic_mangled_type_name fst ty), |
|
813 |
generic_mangled_type_name snd ty)) |
|
814 |
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
|
815 |
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
|
816 |
| to_fo ary (ATerm (_, tys)) = to_afun to_atype (to_fo (ary - 1)) tys |
43692 | 817 |
| 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
|
818 |
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
|
819 |
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
|
820 |
| to_ho _ = raise Fail "unexpected type abstraction" |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
821 |
in if is_type_enc_higher_order type_enc then to_ho else to_fo ary end |
42963 | 822 |
|
43677 | 823 |
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
|
824 |
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
|
825 |
o ho_term_from_typ format type_enc |
42963 | 826 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
827 |
fun mangled_const_name format type_enc T_args (s, s') = |
42963 | 828 |
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
|
829 |
val ty_args = T_args |> map_filter (ho_term_for_type_arg format type_enc) |
42963 | 830 |
fun type_suffix f g = |
831 |
fold_rev (curry (op ^) o g o prefix mangled_type_sep |
|
832 |
o generic_mangled_type_name f) ty_args "" |
|
833 |
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
|
834 |
|
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
|
835 |
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
|
836 |
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
|
837 |
|
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
|
838 |
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
|
839 |
(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
|
840 |
-- 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
|
841 |
[] >> 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
|
842 |
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
|
843 |
(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
|
844 |
|
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
|
845 |
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
|
846 |
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
|
847 |
|> 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
|
848 |
(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
|
849 |
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
|
850 |
|> 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
|
851 |
|
42561
23ddc4e3d19c
have properly type-instantiated helper facts (combinators and If)
blanchet
parents:
42560
diff
changeset
|
852 |
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
|
853 |
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
|
854 |
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
|
855 |
(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
|
856 |
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
|
857 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
858 |
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
|
859 |
let |
43987
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
860 |
fun tweak_ho_quant ho_quant T [IAbs _] = IConst (`I ho_quant, T, []) |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
861 |
| tweak_ho_quant ho_quant (T as Type (_, [p_T as Type (_, [x_T, _]), _])) |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
862 |
_ = |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
863 |
(* Eta-expand "!!" and "??", to work around LEO-II 1.2.8 parser |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
864 |
limitation. This works in conjuction with special code in |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
865 |
"ATP_Problem" that uses the syntactic sugar "!" and "?" whenever |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
866 |
possible. *) |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
867 |
IAbs ((`I "P", p_T), |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
868 |
IApp (IConst (`I ho_quant, T, []), |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
869 |
IAbs ((`I "X", x_T), |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
870 |
IApp (IConst (`I "P", p_T, []), |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
871 |
IConst (`I "X", x_T, []))))) |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
872 |
| tweak_ho_quant _ _ _ = raise Fail "unexpected type for quantifier" |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
873 |
fun intro top_level args (IApp (tm1, tm2)) = |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
874 |
IApp (intro top_level (tm2 :: args) tm1, intro false [] tm2) |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
875 |
| intro top_level args (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
|
876 |
(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
|
877 |
SOME proxy_base => |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
878 |
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
|
879 |
case (top_level, s) of |
43987
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
880 |
(_, "c_False") => IConst (`I tptp_false, T, []) |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
881 |
| (_, "c_True") => IConst (`I tptp_true, T, []) |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
882 |
| (false, "c_Not") => IConst (`I tptp_not, T, []) |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
883 |
| (false, "c_conj") => IConst (`I tptp_and, T, []) |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
884 |
| (false, "c_disj") => IConst (`I tptp_or, T, []) |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
885 |
| (false, "c_implies") => IConst (`I tptp_implies, T, []) |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
886 |
| (false, "c_All") => tweak_ho_quant tptp_ho_forall T args |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
887 |
| (false, "c_Ex") => tweak_ho_quant tptp_ho_exists T args |
43000
bd424c3dde46
cleaner handling of equality and proxies (esp. for THF)
blanchet
parents:
42998
diff
changeset
|
888 |
| (false, s) => |
44097 | 889 |
if is_tptp_equal s andalso length args = 2 then |
890 |
IConst (`I tptp_equal, T, []) |
|
891 |
else |
|
44589
0a1dfc6365e9
first step towards polymorphic TFF + changed defaults for Vampire
blanchet
parents:
44587
diff
changeset
|
892 |
(* Use a proxy even for partially applied THF0 equality, |
0a1dfc6365e9
first step towards polymorphic TFF + changed defaults for Vampire
blanchet
parents:
44587
diff
changeset
|
893 |
because the LEO-II and Satallax parsers complain about not |
0a1dfc6365e9
first step towards polymorphic TFF + changed defaults for Vampire
blanchet
parents:
44587
diff
changeset
|
894 |
being able to infer the type of "=". *) |
44097 | 895 |
IConst (proxy_base |>> prefix const_prefix, T, T_args) |
43987
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
896 |
| _ => IConst (name, T, []) |
42569
5737947e4c77
make sure that fequal keeps its type arguments for mangled type systems
blanchet
parents:
42568
diff
changeset
|
897 |
else |
43987
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
898 |
IConst (proxy_base |>> prefix const_prefix, T, T_args) |
44495 | 899 |
| NONE => if s = tptp_choice then |
900 |
tweak_ho_quant tptp_choice T args |
|
44589
0a1dfc6365e9
first step towards polymorphic TFF + changed defaults for Vampire
blanchet
parents:
44587
diff
changeset
|
901 |
else |
0a1dfc6365e9
first step towards polymorphic TFF + changed defaults for Vampire
blanchet
parents:
44587
diff
changeset
|
902 |
IConst (name, T, T_args)) |
43987
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
903 |
| intro _ _ (IAbs (bound, tm)) = IAbs (bound, intro false [] tm) |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
904 |
| intro _ _ tm = tm |
2850b7dc27a4
further worked around LEO-II parser limitation, with eta-expansion
blanchet
parents:
43985
diff
changeset
|
905 |
in intro true [] end |
42568
7b9801a34836
no needless "fequal" proxies if "explicit_apply" is set + always have readable names
blanchet
parents:
42566
diff
changeset
|
906 |
|
44495 | 907 |
fun iformula_from_prop thy format type_enc eq_as_iff = |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
908 |
let |
42568
7b9801a34836
no needless "fequal" proxies if "explicit_apply" is set + always have readable names
blanchet
parents:
42566
diff
changeset
|
909 |
fun do_term bs t atomic_types = |
44495 | 910 |
iterm_from_term thy format bs (Envir.eta_contract t) |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
911 |
|>> (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
|
912 |
||> union (op =) atomic_types |
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
913 |
fun do_quant bs q pos s T t' = |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
914 |
let |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
915 |
val s = singleton (Name.variant_list (map fst bs)) s |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
916 |
val universal = Option.map (q = AExists ? not) pos |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
917 |
val name = |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
918 |
s |> `(case universal of |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
919 |
SOME true => make_all_bound_var |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
920 |
| SOME false => make_exist_bound_var |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
921 |
| NONE => make_bound_var) |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
922 |
in |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
923 |
do_formula ((s, (name, T)) :: bs) pos t' |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
924 |
#>> mk_aquant q [(name, SOME T)] |
38518
54727b44e277
handle bound name conflicts gracefully in FOF translation
blanchet
parents:
38496
diff
changeset
|
925 |
end |
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
926 |
and do_conn bs c pos1 t1 pos2 t2 = |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
927 |
do_formula bs pos1 t1 ##>> do_formula bs pos2 t2 #>> uncurry (mk_aconn c) |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
928 |
and do_formula bs pos t = |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
929 |
case t of |
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
930 |
@{const Trueprop} $ t1 => do_formula bs pos t1 |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
931 |
| @{const Not} $ t1 => do_formula bs (Option.map not pos) t1 #>> mk_anot |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
932 |
| Const (@{const_name All}, _) $ Abs (s, T, t') => |
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
933 |
do_quant bs AForall pos s T t' |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
934 |
| Const (@{const_name Ex}, _) $ Abs (s, T, t') => |
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
935 |
do_quant bs AExists pos s T t' |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
936 |
| @{const HOL.conj} $ t1 $ t2 => do_conn bs AAnd pos t1 pos t2 |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
937 |
| @{const HOL.disj} $ t1 $ t2 => do_conn bs AOr pos t1 pos t2 |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
938 |
| @{const HOL.implies} $ t1 $ t2 => |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
939 |
do_conn bs AImplies (Option.map not pos) t1 pos t2 |
38864
4abe644fcea5
formerly unnamed infix equality now named HOL.eq
haftmann
parents:
38829
diff
changeset
|
940 |
| Const (@{const_name HOL.eq}, Type (_, [@{typ bool}, _])) $ t1 $ t2 => |
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
941 |
if eq_as_iff then do_conn bs AIff NONE t1 NONE t2 else do_term bs t |
41140
9c68004b8c9d
added Sledgehammer support for higher-order propositional reasoning
blanchet
parents:
41138
diff
changeset
|
942 |
| _ => do_term bs t |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
943 |
in do_formula [] end |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
944 |
|
43264
a1a48c69d623
don't needlessly presimplify -- makes ATP problem preparation much faster
blanchet
parents:
43263
diff
changeset
|
945 |
fun presimplify_term _ [] t = t |
a1a48c69d623
don't needlessly presimplify -- makes ATP problem preparation much faster
blanchet
parents:
43263
diff
changeset
|
946 |
| presimplify_term ctxt presimp_consts t = |
a1a48c69d623
don't needlessly presimplify -- makes ATP problem preparation much faster
blanchet
parents:
43263
diff
changeset
|
947 |
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
|
948 |
? (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
|
949 |
#> Meson.presimplify ctxt |
a1a48c69d623
don't needlessly presimplify -- makes ATP problem preparation much faster
blanchet
parents:
43263
diff
changeset
|
950 |
#> prop_of) |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
951 |
|
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
|
952 |
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
|
953 |
fun conceal_bounds Ts t = |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
954 |
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
|
955 |
(0 upto length Ts - 1 ~~ Ts), t) |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
956 |
fun reveal_bounds Ts = |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
957 |
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
|
958 |
(0 upto length Ts - 1 ~~ Ts)) |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
959 |
|
43265 | 960 |
fun is_fun_equality (@{const_name HOL.eq}, |
961 |
Type (_, [Type (@{type_name fun}, _), _])) = true |
|
962 |
| is_fun_equality _ = false |
|
963 |
||
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
|
964 |
fun extensionalize_term ctxt t = |
43265 | 965 |
if exists_Const is_fun_equality t then |
966 |
let val thy = Proof_Context.theory_of ctxt in |
|
967 |
t |> cterm_of thy |> Meson.extensionalize_conv ctxt |
|
968 |
|> prop_of |> Logic.dest_equals |> snd |
|
969 |
end |
|
970 |
else |
|
971 |
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
|
972 |
|
43862 | 973 |
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
|
974 |
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
|
975 |
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
|
976 |
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
|
977 |
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
|
978 |
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
|
979 |
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
|
980 |
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
|
981 |
@{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
|
982 |
| (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
|
983 |
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
|
984 |
| (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
|
985 |
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
|
986 |
| (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
|
987 |
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
|
988 |
| (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
|
989 |
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
|
990 |
| (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
|
991 |
| (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
|
992 |
| (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
|
993 |
| (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
|
994 |
$ 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
|
995 |
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
|
996 |
| _ => |
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
|
997 |
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
|
998 |
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
|
999 |
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
|
1000 |
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
|
1001 |
end |
43856
d636b053d4ff
move more lambda-handling logic to Sledgehammer, from ATP module, for formal dependency reasons
blanchet
parents:
43830
diff
changeset
|
1002 |
|
43997 | 1003 |
fun do_cheaply_conceal_lambdas Ts (t1 $ t2) = |
1004 |
do_cheaply_conceal_lambdas Ts t1 |
|
1005 |
$ do_cheaply_conceal_lambdas Ts t2 |
|
1006 |
| do_cheaply_conceal_lambdas Ts (Abs (_, T, t)) = |
|
1007 |
Free (polymorphic_free_prefix ^ serial_string (), |
|
1008 |
T --> fastype_of1 (T :: Ts, t)) |
|
1009 |
| do_cheaply_conceal_lambdas _ t = t |
|
43856
d636b053d4ff
move more lambda-handling logic to Sledgehammer, from ATP module, for formal dependency reasons
blanchet
parents:
43830
diff
changeset
|
1010 |
|
43862 | 1011 |
fun do_introduce_combinators ctxt Ts t = |
42361 | 1012 |
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
|
1013 |
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
|
1014 |
|> 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
|
1015 |
|> 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
|
1016 |
|> 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
|
1017 |
|> 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
|
1018 |
end |
43862 | 1019 |
(* A type variable of sort "{}" will make abstraction fail. *) |
43997 | 1020 |
handle THM _ => t |> do_cheaply_conceal_lambdas Ts |
43862 | 1021 |
val introduce_combinators = simple_translate_lambdas do_introduce_combinators |
1022 |
||
43864
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1023 |
fun preprocess_abstractions_in_terms trans_lambdas facts = |
43862 | 1024 |
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
|
1025 |
val (facts, lambda_ts) = |
44501 | 1026 |
facts |> map (snd o snd) |> trans_lambdas |
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
|
1027 |
|>> 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
|
1028 |
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
|
1029 |
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
|
1030 |
((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
|
1031 |
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
|
1032 |
in (facts, lambda_facts) end |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1033 |
|
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1034 |
(* 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
|
1035 |
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
|
1036 |
fun freeze_term t = |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1037 |
let |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1038 |
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
|
1039 |
| 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
|
1040 |
| 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
|
1041 |
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
|
1042 |
| aux t = t |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1043 |
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
|
1044 |
|
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
|
1045 |
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
|
1046 |
let |
42361 | 1047 |
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
|
1048 |
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
|
1049 |
|> transform_elim_prop |
41211
1e2e16bc0077
no need to do a super-duper atomization if Metis fails afterwards anyway
blanchet
parents:
41199
diff
changeset
|
1050 |
|> Object_Logic.atomize_term thy |
42563 | 1051 |
val need_trueprop = (fastype_of t = @{typ bool}) |
43096 | 1052 |
in |
1053 |
t |> need_trueprop ? HOLogic.mk_Trueprop |
|
1054 |
|> Raw_Simplifier.rewrite_term thy (Meson.unfold_set_const_simps ctxt) [] |
|
1055 |
|> extensionalize_term ctxt |
|
43264
a1a48c69d623
don't needlessly presimplify -- makes ATP problem preparation much faster
blanchet
parents:
43263
diff
changeset
|
1056 |
|> 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
|
1057 |
|> perhaps (try (HOLogic.dest_Trueprop)) |
43096 | 1058 |
end |
1059 |
||
1060 |
(* making fact and conjecture formulas *) |
|
44495 | 1061 |
fun make_formula thy format type_enc eq_as_iff name loc kind t = |
43096 | 1062 |
let |
43859 | 1063 |
val (iformula, atomic_types) = |
44495 | 1064 |
iformula_from_prop thy format type_enc eq_as_iff (SOME (kind <> Conjecture)) t [] |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1065 |
in |
43859 | 1066 |
{name = name, locality = loc, kind = kind, iformula = iformula, |
42562 | 1067 |
atomic_types = atomic_types} |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1068 |
end |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1069 |
|
43860
57ef3cd4126e
more refactoring of preprocessing, so as to be able to centralize it
blanchet
parents:
43859
diff
changeset
|
1070 |
fun make_fact ctxt format type_enc eq_as_iff ((name, loc), t) = |
43096 | 1071 |
let val thy = Proof_Context.theory_of ctxt in |
44495 | 1072 |
case t |> make_formula thy format type_enc (eq_as_iff andalso format <> CNF) |
1073 |
name loc Axiom of |
|
43859 | 1074 |
formula as {iformula = AAtom (IConst ((s, _), _, _)), ...} => |
43096 | 1075 |
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
|
1076 |
| formula => SOME formula |
43096 | 1077 |
end |
42561
23ddc4e3d19c
have properly type-instantiated helper facts (combinators and If)
blanchet
parents:
42560
diff
changeset
|
1078 |
|
44460 | 1079 |
fun s_not_trueprop (@{const Trueprop} $ t) = @{const Trueprop} $ s_not t |
1080 |
| s_not_trueprop t = s_not t |
|
1081 |
||
44463
c471a2b48fa1
make sure that all facts are passed to ATP from minimizer
blanchet
parents:
44460
diff
changeset
|
1082 |
fun make_conjecture thy format type_enc = |
c471a2b48fa1
make sure that all facts are passed to ATP from minimizer
blanchet
parents:
44460
diff
changeset
|
1083 |
map (fn ((name, loc), (kind, t)) => |
c471a2b48fa1
make sure that all facts are passed to ATP from minimizer
blanchet
parents:
44460
diff
changeset
|
1084 |
t |> kind = Conjecture ? s_not_trueprop |
44495 | 1085 |
|> make_formula thy format type_enc (format <> CNF) name loc kind) |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1086 |
|
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
|
1087 |
(** 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
|
1088 |
|
44399 | 1089 |
type monotonicity_info = |
1090 |
{maybe_finite_Ts : typ list, |
|
1091 |
surely_finite_Ts : typ list, |
|
1092 |
maybe_infinite_Ts : typ list, |
|
1093 |
surely_infinite_Ts : typ list, |
|
1094 |
maybe_nonmono_Ts : typ list} |
|
1095 |
||
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
1096 |
(* These types witness that the type classes they belong to allow infinite |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
1097 |
models and hence that any types with these type classes is monotonic. *) |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
1098 |
val known_infinite_types = |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
1099 |
[@{typ nat}, Type ("Int.int", []), @{typ "nat => bool"}] |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
1100 |
|
44500 | 1101 |
fun is_type_kind_of_surely_infinite ctxt soundness cached_Ts T = |
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
1102 |
soundness <> Sound andalso |
44500 | 1103 |
is_type_surely_infinite ctxt (soundness <> Unsound) cached_Ts 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
|
1104 |
|
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
|
1105 |
(* 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
|
1106 |
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
|
1107 |
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
|
1108 |
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
|
1109 |
|
44399 | 1110 |
fun should_encode_type _ (_ : monotonicity_info) All_Types _ = true |
1111 |
| should_encode_type ctxt {maybe_finite_Ts, surely_infinite_Ts, |
|
1112 |
maybe_nonmono_Ts, ...} |
|
1113 |
(Noninf_Nonmono_Types soundness) T = |
|
44491
ba22ed224b20
fixed bang encoding detection of which types to encode
blanchet
parents:
44463
diff
changeset
|
1114 |
exists (type_intersect ctxt T) maybe_nonmono_Ts andalso |
44399 | 1115 |
not (exists (type_instance ctxt T) surely_infinite_Ts orelse |
1116 |
(not (member (type_aconv ctxt) maybe_finite_Ts T) andalso |
|
44500 | 1117 |
is_type_kind_of_surely_infinite ctxt soundness surely_infinite_Ts T)) |
44399 | 1118 |
| should_encode_type ctxt {surely_finite_Ts, maybe_infinite_Ts, |
1119 |
maybe_nonmono_Ts, ...} |
|
1120 |
Fin_Nonmono_Types T = |
|
44491
ba22ed224b20
fixed bang encoding detection of which types to encode
blanchet
parents:
44463
diff
changeset
|
1121 |
exists (type_intersect ctxt T) maybe_nonmono_Ts andalso |
ba22ed224b20
fixed bang encoding detection of which types to encode
blanchet
parents:
44463
diff
changeset
|
1122 |
(exists (type_generalization ctxt T) surely_finite_Ts orelse |
44399 | 1123 |
(not (member (type_aconv ctxt) maybe_infinite_Ts T) andalso |
1124 |
is_type_surely_finite ctxt 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
|
1125 |
| 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
|
1126 |
|
44402 | 1127 |
fun should_guard_type ctxt mono (Guards (_, level, uniformity)) should_guard_var |
44399 | 1128 |
T = |
44402 | 1129 |
(uniformity = Uniform orelse should_guard_var ()) andalso |
44399 | 1130 |
should_encode_type ctxt mono level T |
1131 |
| should_guard_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
|
1132 |
|
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
1133 |
fun is_maybe_universal_var (IConst ((s, _), _, _)) = |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
1134 |
String.isPrefix bound_var_prefix s orelse |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
1135 |
String.isPrefix all_bound_var_prefix s |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
1136 |
| is_maybe_universal_var (IVar _) = true |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
1137 |
| is_maybe_universal_var _ = false |
42836 | 1138 |
|
43361
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1139 |
datatype tag_site = |
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1140 |
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
|
1141 |
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
|
1142 |
Elsewhere |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1143 |
|
43361
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1144 |
fun should_tag_with_type _ _ _ (Top_Level _) _ _ = false |
44402 | 1145 |
| should_tag_with_type ctxt mono (Tags (_, level, uniformity)) site u T = |
1146 |
(case uniformity of |
|
1147 |
Uniform => should_encode_type ctxt mono level T |
|
1148 |
| Nonuniform => |
|
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
1149 |
case (site, is_maybe_universal_var u) of |
44399 | 1150 |
(Eq_Arg _, true) => should_encode_type ctxt mono level T |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1151 |
| _ => false) |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1152 |
| 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
|
1153 |
|
44399 | 1154 |
fun homogenized_type ctxt mono level = |
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1155 |
let |
44399 | 1156 |
val should_encode = should_encode_type ctxt mono level |
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1157 |
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
|
1158 |
| 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
|
1159 |
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
|
1160 |
| 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
|
1161 |
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
|
1162 |
|
44450
d848dd7b21f4
fixed "hBOOL" of existential variables, and generate more helpers
blanchet
parents:
44418
diff
changeset
|
1163 |
(** predicators and application operators **) |
41313
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
1164 |
|
42574 | 1165 |
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
|
1166 |
{pred_sym : bool, min_ary : int, max_ary : int, types : typ list} |
42563 | 1167 |
|
43859 | 1168 |
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
|
1169 |
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
|
1170 |
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
|
1171 |
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
|
1172 |
fun iter ary T = |
44399 | 1173 |
if ary = max_ary orelse type_instance ctxt var_T T orelse |
1174 |
type_instance ctxt T var_T then |
|
43210
7384b771805d
made "explicit_apply"'s smart mode (more) complete
blanchet
parents:
43207
diff
changeset
|
1175 |
ary |
7384b771805d
made "explicit_apply"'s smart mode (more) complete
blanchet
parents:
43207
diff
changeset
|
1176 |
else |
7384b771805d
made "explicit_apply"'s smart mode (more) complete
blanchet
parents:
43207
diff
changeset
|
1177 |
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
|
1178 |
in iter 0 const_T end |
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
1179 |
fun add_universal_var T (accum as ((bool_vars, fun_var_Ts), 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
|
1180 |
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
|
1181 |
(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
|
1182 |
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
|
1183 |
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
|
1184 |
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
|
1185 |
{pred_sym = pred_sym andalso not bool_vars', |
43213
e1fdd27e0c98
generate less type information in polymorphic case
blanchet
parents:
43210
diff
changeset
|
1186 |
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
|
1187 |
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
|
1188 |
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
|
1189 |
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
|
1190 |
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
|
1191 |
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
|
1192 |
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
|
1193 |
accum |
43167
839f599bc7ed
ensured that the logic for "explicit_apply = smart" also works on CNF (i.e. new Metis)
blanchet
parents:
43159
diff
changeset
|
1194 |
else |
43213
e1fdd27e0c98
generate less type information in polymorphic case
blanchet
parents:
43210
diff
changeset
|
1195 |
((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
|
1196 |
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
|
1197 |
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
|
1198 |
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
|
1199 |
fun add top_level tm (accum as ((bool_vars, fun_var_Ts), sym_tab)) = |
43859 | 1200 |
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
|
1201 |
(case head of |
43859 | 1202 |
IConst ((s, _), T, _) => |
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
1203 |
if String.isPrefix bound_var_prefix s orelse |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
1204 |
String.isPrefix all_bound_var_prefix s then |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
1205 |
add_universal_var T accum |
44450
d848dd7b21f4
fixed "hBOOL" of existential variables, and generate more helpers
blanchet
parents:
44418
diff
changeset
|
1206 |
else if String.isPrefix exist_bound_var_prefix s then |
d848dd7b21f4
fixed "hBOOL" of existential variables, and generate more helpers
blanchet
parents:
44418
diff
changeset
|
1207 |
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
|
1208 |
else |
43139
9ed5d8ad8fa0
fixed debilitating translation bug introduced in b6e61d22fa61 -- "equal" and "=" should always have arity 2
blanchet
parents:
43136
diff
changeset
|
1209 |
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
|
1210 |
((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
|
1211 |
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
|
1212 |
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
|
1213 |
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
|
1214 |
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
|
1215 |
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
|
1216 |
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
|
1217 |
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
|
1218 |
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
|
1219 |
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
|
1220 |
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
|
1221 |
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
|
1222 |
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
|
1223 |
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
|
1224 |
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
|
1225 |
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
|
1226 |
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
|
1227 |
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
|
1228 |
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
|
1229 |
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
|
1230 |
| 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
|
1231 |
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
|
1232 |
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
|
1233 |
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
|
1234 |
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
|
1235 |
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
|
1236 |
| 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
|
1237 |
| 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
|
1238 |
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
|
1239 |
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
|
1240 |
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
|
1241 |
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
|
1242 |
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
|
1243 |
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
|
1244 |
end |
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
1245 |
| IVar (_, T) => add_universal_var T accum |
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
1246 |
| IAbs ((_, T), tm) => accum |> add_universal_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
|
1247 |
| _ => 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
|
1248 |
|> 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
|
1249 |
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
|
1250 |
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
|
1251 |
fun add_fact_syms_to_table ctxt explicit_apply = |
44501 | 1252 |
K (add_iterm_syms_to_table ctxt explicit_apply) |
1253 |
|> formula_fold NONE |> fact_lift |
|
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1254 |
|
43966 | 1255 |
val tvar_a = TVar (("'a", 0), HOLogic.typeS) |
1256 |
||
43139
9ed5d8ad8fa0
fixed debilitating translation bug introduced in b6e61d22fa61 -- "equal" and "=" should always have arity 2
blanchet
parents:
43136
diff
changeset
|
1257 |
val default_sym_tab_entries : (string * sym_info) list = |
43174 | 1258 |
(prefixed_predicator_name, |
44508 | 1259 |
{pred_sym = true, min_ary = 1, max_ary = 1, types = []}) |
1260 |
(* FIXME: needed? *) :: |
|
44495 | 1261 |
(make_fixed_const NONE @{const_name undefined}, |
43966 | 1262 |
{pred_sym = false, min_ary = 0, max_ary = 0, types = []}) :: |
42568
7b9801a34836
no needless "fequal" proxies if "explicit_apply" is set + always have readable names
blanchet
parents:
42566
diff
changeset
|
1263 |
([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
|
1264 |
|> 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
|
1265 |
([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
|
1266 |
|> 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
|
1267 |
|
44496
c1884789ff80
added config options to control two aspects of the translation, for evaluation purposes
blanchet
parents:
44495
diff
changeset
|
1268 |
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
|
1269 |
((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
|
1270 |
|> 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
|
1271 |
|> 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
|
1272 |
|
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
|
1273 |
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
|
1274 |
case Symtab.lookup sym_tab s of |
42574 | 1275 |
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
|
1276 |
| 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
|
1277 |
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
|
1278 |
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
|
1279 |
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
|
1280 |
if s = predicator_name then 1 |
4e2d6c1e5392
more work on parsing LEO-II proofs without lambdas
blanchet
parents:
42963
diff
changeset
|
1281 |
else if s = app_op_name then 2 |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1282 |
else if s = type_guard_name then 1 |
42557
ae0deb39a254
fixed min-arity computation when "explicit_apply" is specified
blanchet
parents:
42556
diff
changeset
|
1283 |
else 0 |
42547
b5eec0c99528
fixed arity of special constants if "explicit_apply" is set
blanchet
parents:
42546
diff
changeset
|
1284 |
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
|
1285 |
| NONE => 0 |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1286 |
|
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1287 |
(* 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
|
1288 |
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
|
1289 |
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
|
1290 |
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
|
1291 |
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
|
1292 |
case Symtab.lookup sym_tab s of |
42574 | 1293 |
SOME ({pred_sym, min_ary, max_ary, ...} : sym_info) => |
1294 |
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
|
1295 |
| NONE => false |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1296 |
|
42568
7b9801a34836
no needless "fequal" proxies if "explicit_apply" is set + always have readable names
blanchet
parents:
42566
diff
changeset
|
1297 |
val predicator_combconst = |
44495 | 1298 |
IConst (`(make_fixed_const NONE) predicator_name, @{typ "bool => bool"}, []) |
43859 | 1299 |
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
|
1300 |
|
43859 | 1301 |
fun introduce_predicators_in_iterm sym_tab tm = |
1302 |
case strip_iterm_comb tm of |
|
1303 |
(IConst ((s, _), _, _), _) => |
|
42568
7b9801a34836
no needless "fequal" proxies if "explicit_apply" is set + always have readable names
blanchet
parents:
42566
diff
changeset
|
1304 |
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
|
1305 |
| _ => 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
|
1306 |
|
43859 | 1307 |
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
|
1308 |
|
44495 | 1309 |
val app_op = `(make_fixed_const NONE) app_op_name |
43130
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
1310 |
|
42544
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1311 |
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
|
1312 |
let |
43859 | 1313 |
val head_T = ityp_of head |
42693
3c2baf9b3c61
reverted 6efda6167e5d because unsound -- Vampire found a counterexample
blanchet
parents:
42691
diff
changeset
|
1314 |
val (arg_T, res_T) = dest_funT head_T |
43859 | 1315 |
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
|
1316 |
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
|
1317 |
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
|
1318 |
|
43859 | 1319 |
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
|
1320 |
let |
75cb06eee990
reimplemented the hAPP introduction code so that it's done earlier, when the types are still available
blanchet
parents:
42543
diff
changeset
|
1321 |
fun aux tm = |
43859 | 1322 |
case strip_iterm_comb tm of |
1323 |
(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
|
1324 |
args |> map aux |
42557
ae0deb39a254
fixed min-arity computation when "explicit_apply" is specified
blanchet
parents:
42556
diff
changeset
|
1325 |
|> 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
|
1326 |
|>> 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
|
1327 |
|-> 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
|
1328 |
| (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
|
1329 |
in aux end |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1330 |
|
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
|
1331 |
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
|
1332 |
| 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
|
1333 |
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
|
1334 |
| 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
|
1335 |
|
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
|
1336 |
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
|
1337 |
| 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
|
1338 |
let |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1339 |
(* will throw "TYPE" for pseudo-constants *) |
42966
4e2d6c1e5392
more work on parsing LEO-II proofs without lambdas
blanchet
parents:
42963
diff
changeset
|
1340 |
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
|
1341 |
@{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
|
1342 |
else |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1343 |
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
|
1344 |
in |
42781 | 1345 |
case Term.add_tvarsT (U |> chop_fun arity |> snd) [] of |
1346 |
[] => [] |
|
1347 |
| res_U_vars => |
|
1348 |
let val U_args = (s, U) |> Sign.const_typargs thy in |
|
1349 |
U_args ~~ T_args |
|
43401
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1350 |
|> map (fn (U, T) => |
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1351 |
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
|
1352 |
else dummyT) |
42781 | 1353 |
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
|
1354 |
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
|
1355 |
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
|
1356 |
|
43859 | 1357 |
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
|
1358 |
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
|
1359 |
val thy = Proof_Context.theory_of ctxt |
43859 | 1360 |
fun aux arity (IApp (tm1, tm2)) = IApp (aux (arity + 1) tm1, aux 0 tm2) |
1361 |
| 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
|
1362 |
(case strip_prefix_and_unascii const_prefix s of |
43961 | 1363 |
NONE => |
44495 | 1364 |
(name, if level_of_type_enc type_enc = No_Types orelse s = tptp_choice |
1365 |
then [] else 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
|
1366 |
| 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
|
1367 |
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
|
1368 |
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
|
1369 |
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
|
1370 |
| 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
|
1371 |
in |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1372 |
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
|
1373 |
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
|
1374 |
(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
|
1375 |
| Mangled_Type_Args drop_args => |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1376 |
(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
|
1377 |
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
|
1378 |
| 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
|
1379 |
end) |
43859 | 1380 |
|> (fn (name, T_args) => IConst (name, T, T_args)) |
1381 |
| 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
|
1382 |
| 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
|
1383 |
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
|
1384 |
|
43859 | 1385 |
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
|
1386 |
not (is_type_enc_higher_order type_enc) |
43859 | 1387 |
? (introduce_explicit_apps_in_iterm sym_tab |
1388 |
#> introduce_predicators_in_iterm sym_tab) |
|
1389 |
#> 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
|
1390 |
fun repair_fact ctxt format type_enc sym_tab = |
43859 | 1391 |
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
|
1392 |
|
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
|
1393 |
(** 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
|
1394 |
|
44450
d848dd7b21f4
fixed "hBOOL" of existential variables, and generate more helpers
blanchet
parents:
44418
diff
changeset
|
1395 |
val not_ffalse = @{lemma "~ fFalse" by (unfold fFalse_def) fast} |
d848dd7b21f4
fixed "hBOOL" of existential variables, and generate more helpers
blanchet
parents:
44418
diff
changeset
|
1396 |
val ftrue = @{lemma "fTrue" by (unfold fTrue_def) fast} |
d848dd7b21f4
fixed "hBOOL" of existential variables, and generate more helpers
blanchet
parents:
44418
diff
changeset
|
1397 |
|
43194 | 1398 |
(* 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
|
1399 |
val helper_table = |
43194 | 1400 |
[(("COMBI", false), @{thms Meson.COMBI_def}), |
1401 |
(("COMBK", false), @{thms Meson.COMBK_def}), |
|
1402 |
(("COMBB", false), @{thms Meson.COMBB_def}), |
|
1403 |
(("COMBC", false), @{thms Meson.COMBC_def}), |
|
1404 |
(("COMBS", false), @{thms Meson.COMBS_def}), |
|
44450
d848dd7b21f4
fixed "hBOOL" of existential variables, and generate more helpers
blanchet
parents:
44418
diff
changeset
|
1405 |
((predicator_name, false), [not_ffalse, ftrue]), |
d848dd7b21f4
fixed "hBOOL" of existential variables, and generate more helpers
blanchet
parents:
44418
diff
changeset
|
1406 |
(("fFalse", false), [not_ffalse]), |
43194 | 1407 |
(("fFalse", true), @{thms True_or_False}), |
44450
d848dd7b21f4
fixed "hBOOL" of existential variables, and generate more helpers
blanchet
parents:
44418
diff
changeset
|
1408 |
(("fTrue", false), [ftrue]), |
43194 | 1409 |
(("fTrue", true), @{thms True_or_False}), |
1410 |
(("fNot", false), |
|
1411 |
@{thms fNot_def [THEN Meson.iff_to_disjD, THEN conjunct1] |
|
1412 |
fNot_def [THEN Meson.iff_to_disjD, THEN conjunct2]}), |
|
1413 |
(("fconj", false), |
|
1414 |
@{lemma "~ P | ~ Q | fconj P Q" "~ fconj P Q | P" "~ fconj P Q | Q" |
|
1415 |
by (unfold fconj_def) fast+}), |
|
1416 |
(("fdisj", false), |
|
1417 |
@{lemma "~ P | fdisj P Q" "~ Q | fdisj P Q" "~ fdisj P Q | P | Q" |
|
1418 |
by (unfold fdisj_def) fast+}), |
|
1419 |
(("fimplies", false), |
|
43210
7384b771805d
made "explicit_apply"'s smart mode (more) complete
blanchet
parents:
43207
diff
changeset
|
1420 |
@{lemma "P | fimplies P Q" "~ Q | fimplies P Q" "~ fimplies P Q | ~ P | Q" |
43194 | 1421 |
by (unfold fimplies_def) fast+}), |
43678 | 1422 |
(("fequal", true), |
1423 |
(* This is a lie: Higher-order equality doesn't need a sound type encoding. |
|
1424 |
However, this is done so for backward compatibility: Including the |
|
1425 |
equality helpers by default in Metis breaks a few existing proofs. *) |
|
1426 |
@{thms fequal_def [THEN Meson.iff_to_disjD, THEN conjunct1] |
|
1427 |
fequal_def [THEN Meson.iff_to_disjD, THEN conjunct2]}), |
|
44003 | 1428 |
(* Partial characterization of "fAll" and "fEx". A complete characterization |
1429 |
would require the axiom of choice for replay with Metis. *) |
|
1430 |
(("fAll", false), [@{lemma "~ fAll P | P x" by (auto simp: fAll_def)}]), |
|
1431 |
(("fEx", false), [@{lemma "~ P x | fEx P" by (auto simp: fEx_def)}]), |
|
43194 | 1432 |
(("If", true), @{thms if_True if_False True_or_False})] |
1433 |
|> map (apsnd (map zero_var_indexes)) |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1434 |
|
44404
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1435 |
fun fo_literal_from_type_literal (TyLitVar (class, name)) = |
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1436 |
(true, ATerm (class, [ATerm (name, [])])) |
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1437 |
| fo_literal_from_type_literal (TyLitFree (class, name)) = |
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1438 |
(true, ATerm (class, [ATerm (name, [])])) |
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1439 |
|
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1440 |
fun formula_from_fo_literal (pos, t) = AAtom t |> not pos ? mk_anot |
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1441 |
|
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1442 |
fun bound_tvars type_enc Ts = |
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1443 |
mk_ahorn (map (formula_from_fo_literal o fo_literal_from_type_literal) |
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1444 |
(type_literals_for_types type_enc add_sorts_on_tvar Ts)) |
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1445 |
|
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1446 |
fun eq_formula type_enc atomic_Ts pred_sym tm1 tm2 = |
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1447 |
(if pred_sym then AConn (AIff, [AAtom tm1, AAtom tm2]) |
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1448 |
else AAtom (ATerm (`I tptp_equal, [tm1, tm2]))) |
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1449 |
|> bound_tvars type_enc atomic_Ts |
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1450 |
|> close_formula_universally |
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1451 |
|
44495 | 1452 |
val type_tag = `(make_fixed_const NONE) type_tag_name |
43130
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
1453 |
|
44404
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1454 |
fun type_tag_idempotence_fact 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
|
1455 |
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
|
1456 |
fun var s = ATerm (`I s, []) |
44408
30ea62ab4f16
made reconstruction of type tag equalities "\?x = \?x" reliable
blanchet
parents:
44406
diff
changeset
|
1457 |
fun tag tm = ATerm (type_tag, [var "A", tm]) |
30ea62ab4f16
made reconstruction of type tag equalities "\?x = \?x" reliable
blanchet
parents:
44406
diff
changeset
|
1458 |
val tagged_var = tag (var "X") |
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
|
1459 |
in |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
1460 |
Formula (type_tag_idempotence_helper_name, Axiom, |
44405
6fe1a89bb69a
generate tag equations for existential variables
blanchet
parents:
44404
diff
changeset
|
1461 |
eq_formula type_enc [] false (tag tagged_var) tagged_var, |
44404
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1462 |
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
|
1463 |
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
|
1464 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1465 |
fun should_specialize_helper type_enc t = |
44493
c2602c5d4b0a
handle nonmangled monomorphich the same way as mangled monomorphic when it comes to helper -- otherwise we can end up generating too tight type guards
blanchet
parents:
44491
diff
changeset
|
1466 |
polymorphism_of_type_enc type_enc <> Polymorphic andalso |
43628
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1467 |
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
|
1468 |
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
|
1469 |
|
43858
be41d12de6fa
simplify code -- there are no lambdas in helpers anyway
blanchet
parents:
43857
diff
changeset
|
1470 |
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
|
1471 |
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
|
1472 |
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
|
1473 |
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
|
1474 |
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
|
1475 |
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
|
1476 |
fun dub needs_fairly_sound j k = |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1477 |
(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
|
1478 |
(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
|
1479 |
(if needs_fairly_sound then typed_helper_suffix |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1480 |
else untyped_helper_suffix), |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1481 |
Helper) |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
1482 |
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
|
1483 |
let val t = prop_of th in |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1484 |
if should_specialize_helper type_enc t then |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1485 |
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
|
1486 |
types |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1487 |
else |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1488 |
[t] |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1489 |
end |
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1490 |
|> 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
|
1491 |
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
|
1492 |
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
|
1493 |
in |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1494 |
helper_table |
43194 | 1495 |
|> 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
|
1496 |
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
|
1497 |
(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
|
1498 |
[] |
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
|
1499 |
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
|
1500 |
ths ~~ (1 upto length ths) |
43628
996b2022ff78
further repair "mangled_tags", now that tags are also mangled
blanchet
parents:
43626
diff
changeset
|
1501 |
|> 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
|
1502 |
|> 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
|
1503 |
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
|
1504 |
| NONE => [] |
43858
be41d12de6fa
simplify code -- there are no lambdas in helpers anyway
blanchet
parents:
43857
diff
changeset
|
1505 |
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
|
1506 |
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
|
1507 |
[] |
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 |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1509 |
(***************************************************************) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1510 |
(* 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
|
1511 |
(***************************************************************) |
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1512 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1513 |
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
|
1514 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1515 |
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
|
1516 |
|
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1517 |
(* 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
|
1518 |
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
|
1519 |
|
43093 | 1520 |
fun classes_of_terms get_Ts = |
43121 | 1521 |
map (map snd o get_Ts) |
43093 | 1522 |
#> List.foldl add_classes Symtab.empty |
1523 |
#> delete_type #> Symtab.keys |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1524 |
|
44121 | 1525 |
val tfree_classes_of_terms = classes_of_terms Misc_Legacy.term_tfrees |
1526 |
val tvar_classes_of_terms = classes_of_terms Misc_Legacy.term_tvars |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1527 |
|
43622 | 1528 |
fun fold_type_constrs f (Type (s, Ts)) x = |
1529 |
fold (fold_type_constrs f) Ts (f (s, x)) |
|
43189 | 1530 |
| fold_type_constrs _ _ x = x |
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1531 |
|
43907
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
1532 |
(* 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
|
1533 |
needed. *) |
43189 | 1534 |
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
|
1535 |
let |
43188
0c36ae874fcc
fixed detection of Skolem constants in type construction detection code
blanchet
parents:
43185
diff
changeset
|
1536 |
fun add (Const (@{const_name Meson.skolem}, _) $ _) = I |
43181 | 1537 |
| add (t $ u) = add t #> add u |
43188
0c36ae874fcc
fixed detection of Skolem constants in type construction detection code
blanchet
parents:
43185
diff
changeset
|
1538 |
| add (Const (x as (s, _))) = |
0c36ae874fcc
fixed detection of Skolem constants in type construction detection code
blanchet
parents:
43185
diff
changeset
|
1539 |
if String.isPrefix skolem_const_prefix s then I |
43189 | 1540 |
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
|
1541 |
| 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
|
1542 |
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
|
1543 |
T |> fold_type_constrs set_insert |
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
1544 |
else |
073ab5379842
pass type arguments to lambda-lifted Frees, to account for polymorphism
blanchet
parents:
43906
diff
changeset
|
1545 |
I |
43181 | 1546 |
| add (Abs (_, _, u)) = add u |
1547 |
| add _ = I |
|
1548 |
in add end |
|
43085
0a2f5b86bdd7
first step in sharing more code between ATP and Metis translation
blanchet
parents:
43064
diff
changeset
|
1549 |
|
43189 | 1550 |
fun type_constrs_of_terms thy ts = |
1551 |
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
|
1552 |
|
43856
d636b053d4ff
move more lambda-handling logic to Sledgehammer, from ATP module, for formal dependency reasons
blanchet
parents:
43830
diff
changeset
|
1553 |
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
|
1554 |
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
|
1555 |
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
|
1556 |
val thy = Proof_Context.theory_of ctxt |
43264
a1a48c69d623
don't needlessly presimplify -- makes ATP problem preparation much faster
blanchet
parents:
43263
diff
changeset
|
1557 |
val presimp_consts = Meson.presimplified_consts ctxt |
43861 | 1558 |
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
|
1559 |
(* 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
|
1560 |
boost an ATP's performance (for some reason). *) |
43192 | 1561 |
val hyp_ts = |
1562 |
hyp_ts |
|
1563 |
|> 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
|
1564 |
val facts = facts |> map (apsnd (pair Axiom)) |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1565 |
val conjs = |
44460 | 1566 |
map (pair prem_kind) hyp_ts @ [(Conjecture, s_not_trueprop 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
|
1567 |
|> 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
|
1568 |
val ((conjs, facts), lambdas) = |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1569 |
if preproc then |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1570 |
conjs @ facts |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1571 |
|> 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
|
1572 |
|> preprocess_abstractions_in_terms trans_lambdas |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1573 |
|>> chop (length conjs) |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1574 |
|>> apfst (map (apsnd (apsnd freeze_term))) |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1575 |
else |
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1576 |
((conjs, facts), []) |
44460 | 1577 |
val conjs = conjs |> make_conjecture thy 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
|
1578 |
val (fact_names, facts) = |
43864
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1579 |
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
|
1580 |
|> 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
|
1581 |
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
|
1582 |
|> Option.map (pair name)) |
43861 | 1583 |
|> 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
|
1584 |
val lambdas = |
43864
58a7b3fdc193
fixed lambda-liftg: must ensure the formulas are in close form
blanchet
parents:
43863
diff
changeset
|
1585 |
lambdas |> map_filter (make_fact ctxt format type_enc true o apsnd snd) |
43861 | 1586 |
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
|
1587 |
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
|
1588 |
val supers = tvar_classes_of_terms all_ts |
43189 | 1589 |
val tycons = type_constrs_of_terms thy all_ts |
43861 | 1590 |
val (supers, arity_clauses) = |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1591 |
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
|
1592 |
else make_arity_clauses thy tycons supers |
43861 | 1593 |
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
|
1594 |
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
|
1595 |
(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
|
1596 |
(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
|
1597 |
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
|
1598 |
|
44495 | 1599 |
val type_guard = `(make_fixed_const NONE) type_guard_name |
43130
d73fc2e55308
implemented missing hAPP and ti cases of new path finder
blanchet
parents:
43129
diff
changeset
|
1600 |
|
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1601 |
fun type_guard_iterm ctxt format type_enc T tm = |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1602 |
IApp (IConst (type_guard, T --> @{typ bool}, [T]) |
43859 | 1603 |
|> 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
|
1604 |
|
43421 | 1605 |
fun is_var_positively_naked_in_term _ (SOME false) _ accum = accum |
1606 |
| 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
|
1607 |
accum orelse (is_tptp_equal s andalso member (op =) tms (ATerm (name, []))) |
43692 | 1608 |
| is_var_positively_naked_in_term _ _ _ _ = true |
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
1609 |
|
44406
392c69bdb170
revert guard logic -- make sure that typing information is generated for existentials
blanchet
parents:
44405
diff
changeset
|
1610 |
fun should_guard_var_in_formula pos phi (SOME true) name = |
43421 | 1611 |
formula_fold pos (is_var_positively_naked_in_term name) phi false |
44406
392c69bdb170
revert guard logic -- make sure that typing information is generated for existentials
blanchet
parents:
44405
diff
changeset
|
1612 |
| should_guard_var_in_formula _ _ _ _ = true |
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1613 |
|
44405
6fe1a89bb69a
generate tag equations for existential variables
blanchet
parents:
44404
diff
changeset
|
1614 |
fun should_generate_tag_bound_decl _ _ _ (SOME true) _ = false |
6fe1a89bb69a
generate tag equations for existential variables
blanchet
parents:
44404
diff
changeset
|
1615 |
| should_generate_tag_bound_decl ctxt mono (Tags (_, level, Nonuniform)) _ T = |
44404
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1616 |
should_encode_type ctxt mono level T |
44405
6fe1a89bb69a
generate tag equations for existential variables
blanchet
parents:
44404
diff
changeset
|
1617 |
| should_generate_tag_bound_decl _ _ _ _ _ = false |
44404
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
1618 |
|
43677 | 1619 |
fun mk_aterm format type_enc name T_args args = |
1620 |
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
|
1621 |
|
44399 | 1622 |
fun tag_with_type ctxt format mono type_enc pos T tm = |
43859 | 1623 |
IConst (type_tag, T --> T, [T]) |
1624 |
|> enforce_type_arg_policy_in_iterm ctxt format type_enc |
|
44399 | 1625 |
|> ho_term_from_iterm ctxt format mono type_enc (Top_Level pos) |
43692 | 1626 |
|> (fn ATerm (s, tms) => ATerm (s, tms @ [tm]) |
1627 |
| _ => raise Fail "unexpected lambda-abstraction") |
|
44399 | 1628 |
and ho_term_from_iterm ctxt format mono 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
|
1629 |
let |
42962
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1630 |
fun aux site u = |
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1631 |
let |
43859 | 1632 |
val (head, args) = strip_iterm_comb u |
43677 | 1633 |
val pos = |
43361
e37b54d429f5
revived the lightweight "poly_tags_{query,bang}" type encodings by fixing their soundness bug
blanchet
parents:
43324
diff
changeset
|
1634 |
case site of |
43677 | 1635 |
Top_Level pos => pos |
1636 |
| Eq_Arg pos => pos |
|
1637 |
| Elsewhere => NONE |
|
1638 |
val t = |
|
1639 |
case head of |
|
43859 | 1640 |
IConst (name as (s, _), _, T_args) => |
43677 | 1641 |
let |
1642 |
val arg_site = if is_tptp_equal s then Eq_Arg pos else Elsewhere |
|
1643 |
in |
|
1644 |
mk_aterm format type_enc name T_args (map (aux arg_site) args) |
|
1645 |
end |
|
43859 | 1646 |
| IVar (name, _) => |
1647 |
mk_aterm format type_enc name [] (map (aux Elsewhere) args) |
|
1648 |
| IAbs ((name, T), tm) => |
|
1649 |
AAbs ((name, ho_type_from_typ format type_enc true 0 T), |
|
1650 |
aux Elsewhere tm) |
|
1651 |
| IApp _ => raise Fail "impossible \"IApp\"" |
|
1652 |
val T = ityp_of u |
|
42962
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1653 |
in |
44399 | 1654 |
t |> (if should_tag_with_type ctxt mono type_enc site u T then |
1655 |
tag_with_type ctxt format mono type_enc pos T |
|
42962
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1656 |
else |
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1657 |
I) |
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1658 |
end |
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
1659 |
in aux end |
44399 | 1660 |
and formula_from_iformula ctxt format mono type_enc should_guard_var = |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1661 |
let |
44399 | 1662 |
val do_term = ho_term_from_iterm ctxt format mono 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
|
1663 |
val do_bound_type = |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1664 |
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
|
1665 |
Simple_Types (_, level) => |
44399 | 1666 |
homogenized_type ctxt mono level 0 |
43677 | 1667 |
#> 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
|
1668 |
| _ => 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
|
1669 |
fun do_out_of_bound_type pos phi universal (name, T) = |
44399 | 1670 |
if should_guard_type ctxt mono type_enc |
1671 |
(fn () => should_guard_var pos phi universal name) T then |
|
43859 | 1672 |
IVar (name, T) |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1673 |
|> type_guard_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
|
1674 |
|> do_term pos |> AAtom |> SOME |
44405
6fe1a89bb69a
generate tag equations for existential variables
blanchet
parents:
44404
diff
changeset
|
1675 |
else if should_generate_tag_bound_decl ctxt mono type_enc universal T then |
6fe1a89bb69a
generate tag equations for existential variables
blanchet
parents:
44404
diff
changeset
|
1676 |
let |
6fe1a89bb69a
generate tag equations for existential variables
blanchet
parents:
44404
diff
changeset
|
1677 |
val var = ATerm (name, []) |
44505 | 1678 |
val tagged_var = var |> tag_with_type ctxt format mono type_enc pos T |
44405
6fe1a89bb69a
generate tag equations for existential variables
blanchet
parents:
44404
diff
changeset
|
1679 |
in SOME (AAtom (ATerm (`I tptp_equal, [tagged_var, var]))) 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
|
1680 |
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
|
1681 |
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
|
1682 |
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
|
1683 |
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
|
1684 |
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
|
1685 |
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
|
1686 |
in |
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1687 |
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
|
1688 |
| 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
|
1689 |
(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
|
1690 |
(map_filter |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1691 |
(fn (_, NONE) => NONE |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1692 |
| (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
|
1693 |
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
|
1694 |
xs) |
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1695 |
phi) |
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1696 |
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
|
1697 |
| 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
|
1698 |
| 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
|
1699 |
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
|
1700 |
|
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
|
1701 |
(* 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
|
1702 |
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
|
1703 |
the remote provers might care. *) |
44399 | 1704 |
fun formula_line_for_fact ctxt format prefix encode freshen pos mono type_enc |
1705 |
(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
|
1706 |
(prefix ^ (if freshen then string_of_int j ^ "_" else "") ^ encode name, kind, |
43859 | 1707 |
iformula |
1708 |
|> close_iformula_universally |
|
44399 | 1709 |
|> formula_from_iformula ctxt format mono type_enc |
1710 |
should_guard_var_in_formula |
|
43859 | 1711 |
(if pos then SOME true else NONE) |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1712 |
|> 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
|
1713 |
|> close_formula_universally, |
bdb11c68f142
generate type predicates for existentials/skolems, otherwise some problems might not be provable
blanchet
parents:
43423
diff
changeset
|
1714 |
NONE, |
bdb11c68f142
generate type predicates for existentials/skolems, otherwise some problems might not be provable
blanchet
parents:
43423
diff
changeset
|
1715 |
case locality of |
43693 | 1716 |
Intro => isabelle_info introN |
1717 |
| Elim => isabelle_info elimN |
|
1718 |
| Simp => isabelle_info simpN |
|
43493
bdb11c68f142
generate type predicates for existentials/skolems, otherwise some problems might not be provable
blanchet
parents:
43423
diff
changeset
|
1719 |
| _ => NONE) |
bdb11c68f142
generate type predicates for existentials/skolems, otherwise some problems might not be provable
blanchet
parents:
43423
diff
changeset
|
1720 |
|> 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
|
1721 |
|
43086 | 1722 |
fun formula_line_for_class_rel_clause ({name, subclass, superclass, ...} |
1723 |
: 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
|
1724 |
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
|
1725 |
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
|
1726 |
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
|
1727 |
AAtom (ATerm (superclass, [ty_arg]))]) |
43693 | 1728 |
|> 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
|
1729 |
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
|
1730 |
|
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
|
1731 |
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
|
1732 |
(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
|
1733 |
| 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
|
1734 |
(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
|
1735 |
|
43086 | 1736 |
fun formula_line_for_arity_clause ({name, prem_lits, concl_lits, ...} |
1737 |
: arity_clause) = |
|
43495 | 1738 |
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
|
1739 |
mk_ahorn (map (formula_from_fo_literal o apfst not |
42895 | 1740 |
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
|
1741 |
(formula_from_fo_literal |
42895 | 1742 |
(fo_literal_from_arity_literal concl_lits)) |
43693 | 1743 |
|> 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
|
1744 |
|
44399 | 1745 |
fun formula_line_for_conjecture ctxt format mono type_enc |
43859 | 1746 |
({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
|
1747 |
Formula (conjecture_prefix ^ name, kind, |
44399 | 1748 |
formula_from_iformula ctxt format mono type_enc |
1749 |
should_guard_var_in_formula (SOME false) |
|
43859 | 1750 |
(close_iformula_universally iformula) |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1751 |
|> 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
|
1752 |
|> 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
|
1753 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1754 |
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
|
1755 |
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
|
1756 |
|> 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
|
1757 |
|
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
|
1758 |
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
|
1759 |
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
|
1760 |
formula_from_fo_literal lit, NONE, NONE) |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1761 |
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
|
1762 |
let |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1763 |
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
|
1764 |
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
|
1765 |
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
|
1766 |
|
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
|
1767 |
(** 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
|
1768 |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1769 |
fun should_declare_sym type_enc pred_sym s = |
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1770 |
(case type_enc of |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1771 |
Guards _ => not pred_sym |
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
1772 |
| _ => true) andalso |
44450
d848dd7b21f4
fixed "hBOOL" of existential variables, and generate more helpers
blanchet
parents:
44418
diff
changeset
|
1773 |
is_tptp_user_symbol s |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
1774 |
|
43984 | 1775 |
fun sym_decl_table_for_facts ctxt format type_enc repaired_sym_tab |
1776 |
(conjs, facts) = |
|
42574 | 1777 |
let |
43966 | 1778 |
fun add_iterm_syms in_conj tm = |
43859 | 1779 |
let val (head, args) = strip_iterm_comb tm in |
42574 | 1780 |
(case head of |
43859 | 1781 |
IConst ((s, s'), T, T_args) => |
42574 | 1782 |
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
|
1783 |
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
|
1784 |
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
|
1785 |
(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
|
1786 |
in_conj)) |
42574 | 1787 |
else |
1788 |
I |
|
1789 |
end |
|
43966 | 1790 |
| IAbs (_, tm) => add_iterm_syms in_conj tm |
42574 | 1791 |
| _ => I) |
43966 | 1792 |
#> fold (add_iterm_syms in_conj) args |
42574 | 1793 |
end |
43966 | 1794 |
fun add_fact_syms in_conj = |
44501 | 1795 |
K (add_iterm_syms in_conj) |> formula_fold NONE |> fact_lift |
43966 | 1796 |
fun add_formula_var_types (AQuant (_, xs, phi)) = |
1797 |
fold (fn (_, SOME T) => insert_type ctxt I T | _ => I) xs |
|
1798 |
#> add_formula_var_types phi |
|
1799 |
| add_formula_var_types (AConn (_, phis)) = |
|
1800 |
fold add_formula_var_types phis |
|
1801 |
| add_formula_var_types _ = I |
|
1802 |
fun var_types () = |
|
1803 |
if polymorphism_of_type_enc type_enc = Polymorphic then [tvar_a] |
|
1804 |
else fold (fact_lift add_formula_var_types) (conjs @ facts) [] |
|
1805 |
fun add_undefined_const T = |
|
43984 | 1806 |
let |
1807 |
val (s, s') = |
|
44495 | 1808 |
`(make_fixed_const (SOME format)) @{const_name undefined} |
44001 | 1809 |
|> (case type_arg_policy type_enc @{const_name undefined} of |
1810 |
Mangled_Type_Args _ => mangled_const_name format type_enc [T] |
|
1811 |
| _ => I) |
|
43984 | 1812 |
in |
1813 |
Symtab.map_default (s, []) |
|
1814 |
(insert_type ctxt #3 (s', [T], T, false, 0, false)) |
|
1815 |
end |
|
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
|
1816 |
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
|
1817 |
Symtab.empty |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1818 |
|> is_type_enc_fairly_sound type_enc |
43966 | 1819 |
? (fold (add_fact_syms true) conjs |
1820 |
#> fold (add_fact_syms false) facts |
|
43985
33d8b99531c2
no need for existential witnesses for sorts in TFF and THF formats
blanchet
parents:
43984
diff
changeset
|
1821 |
#> (case type_enc of |
33d8b99531c2
no need for existential witnesses for sorts in TFF and THF formats
blanchet
parents:
43984
diff
changeset
|
1822 |
Simple_Types _ => I |
33d8b99531c2
no need for existential witnesses for sorts in TFF and THF formats
blanchet
parents:
43984
diff
changeset
|
1823 |
| _ => fold add_undefined_const (var_types ()))) |
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
|
1824 |
end |
42533 | 1825 |
|
44399 | 1826 |
(* We add "bool" in case the helper "True_or_False" is included later. *) |
1827 |
val default_mono = |
|
1828 |
{maybe_finite_Ts = [@{typ bool}], |
|
1829 |
surely_finite_Ts = [@{typ bool}], |
|
1830 |
maybe_infinite_Ts = known_infinite_types, |
|
1831 |
surely_infinite_Ts = known_infinite_types, |
|
1832 |
maybe_nonmono_Ts = [@{typ bool}]} |
|
1833 |
||
42685 | 1834 |
(* This inference is described in section 2.3 of Claessen et al.'s "Sorting it |
1835 |
out with monotonicity" paper presented at CADE 2011. *) |
|
44399 | 1836 |
fun add_iterm_mononotonicity_info _ _ (SOME false) _ mono = mono |
1837 |
| add_iterm_mononotonicity_info ctxt level _ |
|
1838 |
(IApp (IApp (IConst ((s, _), Type (_, [T, _]), _), tm1), tm2)) |
|
1839 |
(mono as {maybe_finite_Ts, surely_finite_Ts, maybe_infinite_Ts, |
|
1840 |
surely_infinite_Ts, maybe_nonmono_Ts}) = |
|
44403
15160cdc4688
precisely distinguish between universal and existential quantifiers, instead of assuming the worst (universal), for monotonicity analysis
blanchet
parents:
44402
diff
changeset
|
1841 |
if is_tptp_equal s andalso exists is_maybe_universal_var [tm1, tm2] then |
44399 | 1842 |
case level of |
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
1843 |
Noninf_Nonmono_Types soundness => |
44399 | 1844 |
if exists (type_instance ctxt T) surely_infinite_Ts orelse |
1845 |
member (type_aconv ctxt) maybe_finite_Ts T then |
|
1846 |
mono |
|
44500 | 1847 |
else if is_type_kind_of_surely_infinite ctxt soundness |
1848 |
surely_infinite_Ts T then |
|
44399 | 1849 |
{maybe_finite_Ts = maybe_finite_Ts, |
1850 |
surely_finite_Ts = surely_finite_Ts, |
|
1851 |
maybe_infinite_Ts = maybe_infinite_Ts, |
|
1852 |
surely_infinite_Ts = surely_infinite_Ts |> insert_type ctxt I T, |
|
1853 |
maybe_nonmono_Ts = maybe_nonmono_Ts} |
|
1854 |
else |
|
1855 |
{maybe_finite_Ts = maybe_finite_Ts |> insert (type_aconv ctxt) T, |
|
1856 |
surely_finite_Ts = surely_finite_Ts, |
|
1857 |
maybe_infinite_Ts = maybe_infinite_Ts, |
|
1858 |
surely_infinite_Ts = surely_infinite_Ts, |
|
1859 |
maybe_nonmono_Ts = maybe_nonmono_Ts |> insert_type ctxt I T} |
|
1860 |
| Fin_Nonmono_Types => |
|
1861 |
if exists (type_instance ctxt T) surely_finite_Ts orelse |
|
1862 |
member (type_aconv ctxt) maybe_infinite_Ts T then |
|
1863 |
mono |
|
1864 |
else if is_type_surely_finite ctxt T then |
|
1865 |
{maybe_finite_Ts = maybe_finite_Ts, |
|
1866 |
surely_finite_Ts = surely_finite_Ts |> insert_type ctxt I T, |
|
1867 |
maybe_infinite_Ts = maybe_infinite_Ts, |
|
1868 |
surely_infinite_Ts = surely_infinite_Ts, |
|
1869 |
maybe_nonmono_Ts = maybe_nonmono_Ts |> insert_type ctxt I T} |
|
1870 |
else |
|
1871 |
{maybe_finite_Ts = maybe_finite_Ts, |
|
1872 |
surely_finite_Ts = surely_finite_Ts, |
|
1873 |
maybe_infinite_Ts = maybe_infinite_Ts |> insert (type_aconv ctxt) T, |
|
1874 |
surely_infinite_Ts = surely_infinite_Ts, |
|
1875 |
maybe_nonmono_Ts = maybe_nonmono_Ts} |
|
1876 |
| _ => mono |
|
1877 |
else |
|
1878 |
mono |
|
1879 |
| add_iterm_mononotonicity_info _ _ _ _ mono = mono |
|
1880 |
fun add_fact_mononotonicity_info ctxt level |
|
1881 |
({kind, iformula, ...} : translated_formula) = |
|
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
1882 |
formula_fold (SOME (kind <> Conjecture)) |
44399 | 1883 |
(add_iterm_mononotonicity_info ctxt level) iformula |
1884 |
fun mononotonicity_info_for_facts ctxt type_enc facts = |
|
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1885 |
let val level = level_of_type_enc type_enc in |
44399 | 1886 |
default_mono |
1887 |
|> is_type_level_monotonicity_based level |
|
1888 |
? fold (add_fact_mononotonicity_info ctxt level) facts |
|
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1889 |
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
|
1890 |
|
44501 | 1891 |
fun add_iformula_monotonic_types ctxt mono type_enc = |
1892 |
let |
|
1893 |
val level = level_of_type_enc type_enc |
|
1894 |
val should_encode = should_encode_type ctxt mono level |
|
44504
6f29df8d2007
fixed inverted logic and improve precision when handling monotonic types in polymorphic encodings
blanchet
parents:
44502
diff
changeset
|
1895 |
fun add_type T = not (should_encode T) ? insert_type ctxt I T |
44506 | 1896 |
fun add_args (IApp (tm1, tm2)) = add_args tm1 #> add_term tm2 |
1897 |
| add_args _ = I |
|
1898 |
and add_term tm = add_type (ityp_of tm) #> add_args tm |
|
44501 | 1899 |
in formula_fold NONE (K add_term) end |
1900 |
fun add_fact_monotonic_types ctxt mono type_enc = |
|
1901 |
add_iformula_monotonic_types ctxt mono type_enc |> fact_lift |
|
1902 |
fun monotonic_types_for_facts ctxt mono type_enc facts = |
|
1903 |
[] |> (polymorphism_of_type_enc type_enc = Polymorphic andalso |
|
1904 |
is_type_level_monotonicity_based (level_of_type_enc type_enc)) |
|
1905 |
? fold (add_fact_monotonic_types ctxt mono type_enc) facts |
|
1906 |
||
44399 | 1907 |
fun formula_line_for_guards_mono_type ctxt format mono type_enc T = |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1908 |
Formula (guards_sym_formula_prefix ^ |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1909 |
ascii_of (mangled_type format type_enc T), |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1910 |
Axiom, |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1911 |
IConst (`make_bound_var "X", T, []) |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1912 |
|> type_guard_iterm ctxt format type_enc T |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1913 |
|> AAtom |
44399 | 1914 |
|> formula_from_iformula ctxt format mono type_enc |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1915 |
(K (K (K (K true)))) (SOME true) |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1916 |
|> bound_tvars type_enc (atyps_of T) |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1917 |
|> close_formula_universally, |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1918 |
isabelle_info introN, NONE) |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1919 |
|
44399 | 1920 |
fun formula_line_for_tags_mono_type ctxt format mono type_enc T = |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1921 |
let val x_var = ATerm (`make_bound_var "X", []) in |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1922 |
Formula (tags_sym_formula_prefix ^ |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1923 |
ascii_of (mangled_type format type_enc T), |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1924 |
Axiom, |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1925 |
eq_formula type_enc (atyps_of T) false |
44399 | 1926 |
(tag_with_type ctxt format mono type_enc NONE T x_var) |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1927 |
x_var, |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1928 |
isabelle_info simpN, NONE) |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1929 |
end |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1930 |
|
44399 | 1931 |
fun problem_lines_for_mono_types ctxt format mono type_enc Ts = |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1932 |
case type_enc of |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1933 |
Simple_Types _ => [] |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1934 |
| Guards _ => |
44399 | 1935 |
map (formula_line_for_guards_mono_type ctxt format mono type_enc) Ts |
1936 |
| Tags _ => map (formula_line_for_tags_mono_type ctxt format mono type_enc) Ts |
|
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1937 |
|
44399 | 1938 |
fun decl_line_for_sym ctxt format mono type_enc s |
42994
fe291ab75eb5
towards supporting non-simply-typed encodings for TFF and THF (for orthogonality and experiments)
blanchet
parents:
42966
diff
changeset
|
1939 |
(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
|
1940 |
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
|
1941 |
val (T_arg_Ts, level) = |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1942 |
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
|
1943 |
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
|
1944 |
| _ => (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
|
1945 |
in |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
1946 |
Decl (sym_decl_prefix ^ s, (s, s'), |
44399 | 1947 |
(T_arg_Ts ---> (T |> homogenized_type ctxt mono level ary)) |
43677 | 1948 |
|> 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
|
1949 |
end |
42579
2552c09b1a72
implement the new ATP type system in Sledgehammer
blanchet
parents:
42577
diff
changeset
|
1950 |
|
44399 | 1951 |
fun formula_line_for_guards_sym_decl ctxt format conj_sym_kind mono type_enc n s |
1952 |
j (s', T_args, T, _, ary, in_conj) = |
|
42579
2552c09b1a72
implement the new ATP type system in Sledgehammer
blanchet
parents:
42577
diff
changeset
|
1953 |
let |
42709
e7af132d48fe
allow each prover to specify its own formula kind for symbols occurring in the conjecture
blanchet
parents:
42701
diff
changeset
|
1954 |
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
|
1955 |
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
|
1956 |
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
|
1957 |
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
|
1958 |
val num_args = length arg_Ts |
42579
2552c09b1a72
implement the new ATP type system in Sledgehammer
blanchet
parents:
42577
diff
changeset
|
1959 |
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
|
1960 |
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
|
1961 |
val bounds = |
43859 | 1962 |
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
|
1963 |
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
|
1964 |
fun should_keep_arg_type T = |
44393 | 1965 |
sym_needs_arg_types andalso |
44399 | 1966 |
should_guard_type ctxt mono type_enc (K true) T |
42579
2552c09b1a72
implement the new ATP type system in Sledgehammer
blanchet
parents:
42577
diff
changeset
|
1967 |
val bound_Ts = |
43401
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
1968 |
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
|
1969 |
in |
43989 | 1970 |
Formula (guards_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
|
1971 |
(if n > 1 then "_" ^ string_of_int j else ""), kind, |
43859 | 1972 |
IConst ((s, s'), T, T_args) |
1973 |
|> fold (curry (IApp o swap)) bounds |
|
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1974 |
|> type_guard_iterm ctxt format type_enc res_T |
42963 | 1975 |
|> AAtom |> mk_aquant AForall (bound_names ~~ bound_Ts) |
44399 | 1976 |
|> formula_from_iformula ctxt format mono type_enc |
43859 | 1977 |
(K (K (K (K true)))) (SOME true) |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
1978 |
|> 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
|
1979 |
|> close_formula_universally |
e7af132d48fe
allow each prover to specify its own formula kind for symbols occurring in the conjecture
blanchet
parents:
42701
diff
changeset
|
1980 |
|> maybe_negate, |
43693 | 1981 |
isabelle_info introN, NONE) |
42579
2552c09b1a72
implement the new ATP type system in Sledgehammer
blanchet
parents:
42577
diff
changeset
|
1982 |
end |
2552c09b1a72
implement the new ATP type system in Sledgehammer
blanchet
parents:
42577
diff
changeset
|
1983 |
|
44405
6fe1a89bb69a
generate tag equations for existential variables
blanchet
parents:
44404
diff
changeset
|
1984 |
fun formula_lines_for_nonuniform_tags_sym_decl ctxt format conj_sym_kind mono |
44399 | 1985 |
type_enc n s (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
|
1986 |
let |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1987 |
val ident_base = |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1988 |
tags_sym_formula_prefix ^ s ^ |
43125
ddf63baabdec
distinguish different kinds of typing informations in the fact name
blanchet
parents:
43121
diff
changeset
|
1989 |
(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
|
1990 |
val (kind, maybe_negate) = |
40649ab0cead
honor "conj_sym_kind" also for tag symbol declarations
blanchet
parents:
42851
diff
changeset
|
1991 |
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
|
1992 |
else (Axiom, I) |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1993 |
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
|
1994 |
val bound_names = |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
1995 |
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
|
1996 |
val bounds = bound_names |> map (fn name => ATerm (name, [])) |
43677 | 1997 |
val cst = mk_aterm format type_enc (s, s') T_args |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
1998 |
val eq = maybe_negate oo eq_formula type_enc (atyps_of T) pred_sym |
44398 | 1999 |
val should_encode = |
44399 | 2000 |
should_encode_type ctxt mono (level_of_type_enc type_enc) |
2001 |
val tag_with = tag_with_type ctxt format mono type_enc NONE |
|
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
2002 |
val add_formula_for_res = |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
2003 |
if should_encode res_T then |
42852
40649ab0cead
honor "conj_sym_kind" also for tag symbol declarations
blanchet
parents:
42851
diff
changeset
|
2004 |
cons (Formula (ident_base ^ "_res", kind, |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
2005 |
eq (tag_with res_T (cst bounds)) (cst bounds), |
43693 | 2006 |
isabelle_info simpN, NONE)) |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
2007 |
else |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
2008 |
I |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
2009 |
fun add_formula_for_arg k = |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
2010 |
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
|
2011 |
if should_encode arg_T then |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
2012 |
case chop k bounds of |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
2013 |
(bounds1, bound :: bounds2) => |
42852
40649ab0cead
honor "conj_sym_kind" also for tag symbol declarations
blanchet
parents:
42851
diff
changeset
|
2014 |
cons (Formula (ident_base ^ "_arg" ^ string_of_int (k + 1), kind, |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
2015 |
eq (cst (bounds1 @ tag_with arg_T bound :: bounds2)) |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
2016 |
(cst bounds), |
43693 | 2017 |
isabelle_info simpN, NONE)) |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
2018 |
| _ => raise Fail "expected nonempty tail" |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
2019 |
else |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
2020 |
I |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
2021 |
end |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
2022 |
in |
42834
40f7691d0539
implemented thin versions of "preds" type systems + fixed various issues with type args
blanchet
parents:
42832
diff
changeset
|
2023 |
[] |> not pred_sym ? add_formula_for_res |
44496
c1884789ff80
added config options to control two aspects of the translation, for evaluation purposes
blanchet
parents:
44495
diff
changeset
|
2024 |
|> Config.get ctxt type_tag_arguments |
c1884789ff80
added config options to control two aspects of the translation, for evaluation purposes
blanchet
parents:
44495
diff
changeset
|
2025 |
? fold add_formula_for_arg (ary - 1 downto 0) |
42829
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
2026 |
end |
1558741f8a72
started implementing "shallow" type systems, based on ideas by Claessen et al.
blanchet
parents:
42828
diff
changeset
|
2027 |
|
42836 | 2028 |
fun result_type_of_decl (_, _, T, _, ary, _) = chop_fun ary T |> snd |
2029 |
||
44399 | 2030 |
fun problem_lines_for_sym_decls ctxt format conj_sym_kind mono type_enc |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
2031 |
(s, decls) = |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
2032 |
case type_enc of |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2033 |
Simple_Types _ => |
44399 | 2034 |
decls |> map (decl_line_for_sym ctxt format mono type_enc s) |
44398 | 2035 |
| Guards (_, level, _) => |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2036 |
let |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2037 |
val decls = |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2038 |
case decls of |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2039 |
decl :: (decls' as _ :: _) => |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2040 |
let val T = result_type_of_decl decl in |
44399 | 2041 |
if forall (type_generalization ctxt T o result_type_of_decl) |
2042 |
decls' then |
|
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2043 |
[decl] |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2044 |
else |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2045 |
decls |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2046 |
end |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2047 |
| _ => decls |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2048 |
val n = length decls |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2049 |
val decls = |
44399 | 2050 |
decls |> filter (should_encode_type ctxt mono level |
43401
e93dfcb53535
fixed soundness bug made more visible by previous change
blanchet
parents:
43399
diff
changeset
|
2051 |
o result_type_of_decl) |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2052 |
in |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2053 |
(0 upto length decls - 1, decls) |
44399 | 2054 |
|-> map2 (formula_line_for_guards_sym_decl ctxt format conj_sym_kind mono |
2055 |
type_enc n s) |
|
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2056 |
end |
44402 | 2057 |
| Tags (_, _, uniformity) => |
2058 |
(case uniformity of |
|
2059 |
Uniform => [] |
|
2060 |
| Nonuniform => |
|
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2061 |
let val n = length decls in |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2062 |
(0 upto n - 1 ~~ decls) |
44405
6fe1a89bb69a
generate tag equations for existential variables
blanchet
parents:
44404
diff
changeset
|
2063 |
|> maps (formula_lines_for_nonuniform_tags_sym_decl ctxt format |
44399 | 2064 |
conj_sym_kind mono type_enc n s) |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2065 |
end) |
42579
2552c09b1a72
implement the new ATP type system in Sledgehammer
blanchet
parents:
42577
diff
changeset
|
2066 |
|
44399 | 2067 |
fun problem_lines_for_sym_decl_table ctxt format conj_sym_kind mono type_enc |
44501 | 2068 |
mono_Ts sym_decl_tab = |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
2069 |
let |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
2070 |
val syms = sym_decl_tab |> Symtab.dest |> sort_wrt fst |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
2071 |
val mono_lines = |
44399 | 2072 |
problem_lines_for_mono_types ctxt format mono type_enc mono_Ts |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
2073 |
val decl_lines = |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
2074 |
fold_rev (append o problem_lines_for_sym_decls ctxt format conj_sym_kind |
44399 | 2075 |
mono type_enc) |
44396
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
2076 |
syms [] |
66b9b3fcd608
started cleaning up polymorphic monotonicity-based encodings, based on discussions with Nick Smallbone
blanchet
parents:
44394
diff
changeset
|
2077 |
in mono_lines @ decl_lines end |
42543
f9d402d144d4
declare TFF types so that SNARK can be used with types
blanchet
parents:
42542
diff
changeset
|
2078 |
|
44496
c1884789ff80
added config options to control two aspects of the translation, for evaluation purposes
blanchet
parents:
44495
diff
changeset
|
2079 |
fun needs_type_tag_idempotence ctxt (Tags (poly, level, uniformity)) = |
c1884789ff80
added config options to control two aspects of the translation, for evaluation purposes
blanchet
parents:
44495
diff
changeset
|
2080 |
Config.get ctxt type_tag_idempotence andalso |
43185
697d32fa183d
also exploit type tag idempotence in lightweight encodings, following a suggestion from Gothenburg
blanchet
parents:
43181
diff
changeset
|
2081 |
poly <> Mangled_Monomorphic andalso |
44402 | 2082 |
((level = All_Types andalso uniformity = Nonuniform) orelse |
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
2083 |
is_type_level_monotonicity_based level) |
44496
c1884789ff80
added config options to control two aspects of the translation, for evaluation purposes
blanchet
parents:
44495
diff
changeset
|
2084 |
| needs_type_tag_idempotence _ _ = false |
42831
c9b0968484fb
more work on "shallow" encoding + adjustments to other encodings
blanchet
parents:
42830
diff
changeset
|
2085 |
|
42939 | 2086 |
fun offset_of_heading_in_problem _ [] j = j |
2087 |
| offset_of_heading_in_problem needle ((heading, lines) :: problem) j = |
|
2088 |
if heading = needle then j |
|
2089 |
else offset_of_heading_in_problem needle problem (j + length lines) |
|
2090 |
||
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2091 |
val implicit_declsN = "Should-be-implicit typings" |
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2092 |
val explicit_declsN = "Explicit typings" |
41157 | 2093 |
val factsN = "Relevant facts" |
2094 |
val class_relsN = "Class relationships" |
|
42543
f9d402d144d4
declare TFF types so that SNARK can be used with types
blanchet
parents:
42542
diff
changeset
|
2095 |
val aritiesN = "Arities" |
41157 | 2096 |
val helpersN = "Helper facts" |
2097 |
val conjsN = "Conjectures" |
|
41313
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2098 |
val free_typesN = "Type variables" |
41157 | 2099 |
|
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
|
2100 |
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
|
2101 |
|
44397
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
2102 |
fun prepare_atp_problem ctxt format conj_sym_kind prem_kind type_enc exporter |
06375952f1fa
cleaner handling of polymorphic monotonicity inference
blanchet
parents:
44396
diff
changeset
|
2103 |
lambda_trans 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
|
2104 |
let |
44416
cabd06b69c18
added formats to the slice and use TFF for remote Vampire
blanchet
parents:
44410
diff
changeset
|
2105 |
val type_enc = type_enc |> adjust_type_enc format |
44088
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2106 |
val lambda_trans = |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2107 |
if lambda_trans = smartN then |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2108 |
if is_type_enc_higher_order type_enc then lambdasN else combinatorsN |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2109 |
else if lambda_trans = lambdasN andalso |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2110 |
not (is_type_enc_higher_order type_enc) then |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2111 |
error ("Lambda translation method incompatible with first-order \ |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2112 |
\encoding.") |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2113 |
else |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2114 |
lambda_trans |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2115 |
val trans_lambdas = |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2116 |
if lambda_trans = no_lambdasN then |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2117 |
rpair [] |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2118 |
else if lambda_trans = concealedN then |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2119 |
lift_lambdas ctxt type_enc ##> K [] |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2120 |
else if lambda_trans = liftingN then |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2121 |
lift_lambdas ctxt type_enc |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2122 |
else if lambda_trans = combinatorsN then |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2123 |
map (introduce_combinators ctxt) #> rpair [] |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2124 |
else if lambda_trans = hybridN then |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2125 |
lift_lambdas ctxt type_enc |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2126 |
##> maps (fn t => [t, introduce_combinators ctxt |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2127 |
(intentionalize_def t)]) |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2128 |
else if lambda_trans = lambdasN then |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2129 |
map (Envir.eta_contract) #> rpair [] |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2130 |
else |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2131 |
error ("Unknown lambda translation method: " ^ |
3693baa6befb
move lambda-lifting code to ATP encoding, so it can be used by Metis
blanchet
parents:
44003
diff
changeset
|
2132 |
quote lambda_trans ^ ".") |
41313
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2133 |
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
|
2134 |
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
|
2135 |
hyp_ts concl_t facts |
44496
c1884789ff80
added config options to control two aspects of the translation, for evaluation purposes
blanchet
parents:
44495
diff
changeset
|
2136 |
val sym_tab = conjs @ facts |> sym_table_for_facts ctxt explicit_apply |
44399 | 2137 |
val mono = conjs @ facts |> mononotonicity_info_for_facts ctxt type_enc |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
2138 |
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
|
2139 |
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
|
2140 |
val repaired_sym_tab = |
44496
c1884789ff80
added config options to control two aspects of the translation, for evaluation purposes
blanchet
parents:
44495
diff
changeset
|
2141 |
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
|
2142 |
val helpers = |
43858
be41d12de6fa
simplify code -- there are no lambdas in helpers anyway
blanchet
parents:
43857
diff
changeset
|
2143 |
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
|
2144 |
|> map repair |
44501 | 2145 |
val mono_Ts = |
2146 |
helpers @ conjs @ facts |
|
2147 |
|> monotonic_types_for_facts ctxt mono type_enc |
|
42680 | 2148 |
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
|
2149 |
(conjs, helpers @ facts) |
43984 | 2150 |
|> sym_decl_table_for_facts ctxt format type_enc repaired_sym_tab |
44399 | 2151 |
|> problem_lines_for_sym_decl_table ctxt format conj_sym_kind mono |
44501 | 2152 |
type_enc mono_Ts |
42881
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
2153 |
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
|
2154 |
0 upto length helpers - 1 ~~ helpers |
44399 | 2155 |
|> map (formula_line_for_fact ctxt format helper_prefix I false true mono |
2156 |
type_enc) |
|
44496
c1884789ff80
added config options to control two aspects of the translation, for evaluation purposes
blanchet
parents:
44495
diff
changeset
|
2157 |
|> (if needs_type_tag_idempotence ctxt type_enc then |
44404
3111af540141
tuning, plus started implementing tag equation generation for existential variables
blanchet
parents:
44403
diff
changeset
|
2158 |
cons (type_tag_idempotence_fact type_enc) |
43159
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
2159 |
else |
29b55f292e0b
added support for helpers in new Metis, so far only for polymorphic type encodings
blanchet
parents:
43139
diff
changeset
|
2160 |
I) |
42522
413b56894f82
close ATP formulas universally earlier, so that we can add type predicates
blanchet
parents:
42521
diff
changeset
|
2161 |
(* Reordering these might confuse the proof reconstruction code or the SPASS |
43039 | 2162 |
FLOTTER hack. *) |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
2163 |
val problem = |
42998
1c80902d0456
fully support all type system encodings in typed formats (TFF, THF)
blanchet
parents:
42994
diff
changeset
|
2164 |
[(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
|
2165 |
(factsN, |
43501
0e422a84d0b2
don't change the way helpers are generated for the exporter's sake
blanchet
parents:
43496
diff
changeset
|
2166 |
map (formula_line_for_fact ctxt format fact_prefix ascii_of |
44399 | 2167 |
(not exporter) (not exporter) mono |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
2168 |
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
|
2169 |
(0 upto length facts - 1 ~~ facts)), |
42545 | 2170 |
(class_relsN, map formula_line_for_class_rel_clause class_rel_clauses), |
2171 |
(aritiesN, map formula_line_for_arity_clause arity_clauses), |
|
42881
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
2172 |
(helpersN, helper_lines), |
42962
3b50fdeb6cfc
started adding support for THF output (but no lambdas)
blanchet
parents:
42956
diff
changeset
|
2173 |
(conjsN, |
44399 | 2174 |
map (formula_line_for_conjecture ctxt format mono type_enc) conjs), |
43626
a867ebb12209
renamed "type_sys" to "type_enc", which is more accurate
blanchet
parents:
43624
diff
changeset
|
2175 |
(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
|
2176 |
val problem = |
42561
23ddc4e3d19c
have properly type-instantiated helper facts (combinators and If)
blanchet
parents:
42560
diff
changeset
|
2177 |
problem |
43092
93ec303e1917
more work on new metis that exploits the powerful new type encodings
blanchet
parents:
43086
diff
changeset
|
2178 |
|> (case format of |
93ec303e1917
more work on new metis that exploits the powerful new type encodings
blanchet
parents:
43086
diff
changeset
|
2179 |
CNF => ensure_cnf_problem |
93ec303e1917
more work on new metis that exploits the powerful new type encodings
blanchet
parents:
43086
diff
changeset
|
2180 |
| CNF_UEQ => filter_cnf_ueq_problem |
44589
0a1dfc6365e9
first step towards polymorphic TFF + changed defaults for Vampire
blanchet
parents:
44587
diff
changeset
|
2181 |
| FOF => I |
0a1dfc6365e9
first step towards polymorphic TFF + changed defaults for Vampire
blanchet
parents:
44587
diff
changeset
|
2182 |
| TFF (_, TFF_Implicit) => I |
0a1dfc6365e9
first step towards polymorphic TFF + changed defaults for Vampire
blanchet
parents:
44587
diff
changeset
|
2183 |
| _ => declare_undeclared_syms_in_atp_problem type_decl_prefix |
0a1dfc6365e9
first step towards polymorphic TFF + changed defaults for Vampire
blanchet
parents:
44587
diff
changeset
|
2184 |
implicit_declsN) |
43092
93ec303e1917
more work on new metis that exploits the powerful new type encodings
blanchet
parents:
43086
diff
changeset
|
2185 |
val (problem, pool) = problem |> nice_atp_problem readable_names |
42881
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
2186 |
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
|
2187 |
val typed_helpers = |
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
2188 |
map_filter (fn (j, {name, ...}) => |
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
2189 |
if String.isSuffix typed_helper_suffix name then SOME j |
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
2190 |
else NONE) |
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
2191 |
((helpers_offset + 1 upto helpers_offset + length helpers) |
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
2192 |
~~ helpers) |
42778 | 2193 |
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
|
2194 |
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
|
2195 |
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
|
2196 |
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
|
2197 |
| 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
|
2198 |
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
|
2199 |
I |
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
2200 |
in |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
2201 |
(problem, |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
2202 |
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
|
2203 |
offset_of_heading_in_problem conjsN problem 0, |
42541
8938507b2054
move type declarations to the front, for TFF-compliance
blanchet
parents:
42540
diff
changeset
|
2204 |
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
|
2205 |
fact_names |> Vector.fromList, |
42881
dbdfe2d5b6ab
automatically use "metisFT" when typed helpers are necessary
blanchet
parents:
42879
diff
changeset
|
2206 |
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
|
2207 |
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
|
2208 |
end |
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
2209 |
|
41313
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2210 |
(* FUDGE *) |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2211 |
val conj_weight = 0.0 |
41770 | 2212 |
val hyp_weight = 0.1 |
2213 |
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
|
2214 |
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
|
2215 |
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
|
2216 |
|
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2217 |
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
|
2218 |
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
|
2219 |
#> 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
|
2220 |
| 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
|
2221 |
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
|
2222 |
formula_fold NONE (K (add_term_weights weight)) phi |
42528 | 2223 |
| 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
|
2224 |
|
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2225 |
fun add_conjectures_weights [] = I |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2226 |
| add_conjectures_weights conjs = |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2227 |
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
|
2228 |
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
|
2229 |
#> 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
|
2230 |
end |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2231 |
|
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2232 |
fun add_facts_weights facts = |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2233 |
let |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2234 |
val num_facts = length facts |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2235 |
fun weight_of j = |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2236 |
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
|
2237 |
/ Real.fromInt num_facts |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2238 |
in |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2239 |
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
|
2240 |
|> 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
|
2241 |
end |
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2242 |
|
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2243 |
(* 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
|
2244 |
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
|
2245 |
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
|
2246 |
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
|
2247 |
|> 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
|
2248 |
|> 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
|
2249 |
|> 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
|
2250 |
[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
|
2251 |
|> 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
|
2252 |
|> 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
|
2253 |
end |
41313
a96ac4d180b7
optionally supply constant weights to E -- turned off by default until properly parameterized
blanchet
parents:
41211
diff
changeset
|
2254 |
|
38282
319c59682c51
move Sledgehammer's HOL -> FOL translation to separate file (sledgehammer_translate.ML)
blanchet
parents:
diff
changeset
|
2255 |
end; |