src/HOL/Tools/ATP/atp_translate.ML
author blanchet
Tue, 30 Aug 2011 16:07:34 +0200
changeset 44589 0a1dfc6365e9
parent 44587 0f50f158eb57
child 44591 0b107d11f634
permissions -rw-r--r--
first step towards polymorphic TFF + changed defaults for Vampire
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
43283
446e6621762d updated headers;
wenzelm
parents: 43278
diff changeset
     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
0134d6650092 added support for remote Waldmeister
blanchet
parents: 42895
diff changeset
    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
926bfe067a32 fixed soundness bug related to extensionality
blanchet
parents: 43401
diff changeset
    18
  datatype locality =
44585
cfe7f4a68e51 added generation of induction rules
nik
parents: 44540
diff changeset
    19
    General | Helper | Induction | Extensionality | Intro | Elim | Simp |
cfe7f4a68e51 added generation of induction rules
nik
parents: 44540
diff changeset
    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
8d3a5b7b9a00 name tuning
blanchet
parents: 43361
diff changeset
    30
    No_Types
44402
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
    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
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
    35
    Guards of polymorphism * type_level * type_uniformity |
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
    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
eb763b3ff9ed renamed "preds" encodings to "guards"
blanchet
parents: 43987
diff changeset
    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
f497a1e97d37 skip "hBOOL" in new Metis path finder
blanchet
parents: 43167
diff changeset
    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
blanchet
parents: 43092
diff changeset
    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
ef3ff8856245 fixed type helper indices in new Metis
blanchet
parents: 43193
diff changeset
   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
4e850b2c1f5c removed old optimization that isn't one anyone
blanchet
parents: 43213
diff changeset
   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
b46f5d2d42cc make SML/NJ happier
blanchet
parents: 43692
diff changeset
   134
fun isabelle_info s =
b46f5d2d42cc make SML/NJ happier
blanchet
parents: 43692
diff changeset
   135
  if generate_info then SOME (ATerm ("[]", [ATerm ("isabelle_" ^ s, [])]))
b46f5d2d42cc make SML/NJ happier
blanchet
parents: 43692
diff changeset
   136
  else NONE
42879
3b9669b11d33 generate useful information for type axioms
blanchet
parents: 42878
diff changeset
   137
43693
b46f5d2d42cc make SML/NJ happier
blanchet
parents: 43692
diff changeset
   138
val introN = "intro"
b46f5d2d42cc make SML/NJ happier
blanchet
parents: 43692
diff changeset
   139
val elimN = "elim"
b46f5d2d42cc make SML/NJ happier
blanchet
parents: 43692
diff changeset
   140
val simpN = "simp"
42879
3b9669b11d33 generate useful information for type axioms
blanchet
parents: 42878
diff changeset
   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
eb763b3ff9ed renamed "preds" encodings to "guards"
blanchet
parents: 43987
diff changeset
   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
f497a1e97d37 skip "hBOOL" in new Metis path finder
blanchet
parents: 43167
diff changeset
   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
blanchet
parents: 43092
diff changeset
   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
56d352659500 improved translation of lambdas in THF
nik
parents: 43677
diff changeset
   257
       ("fequal", @{const_name ATP.fequal})))),
56d352659500 improved translation of lambdas in THF
nik
parents: 43677
diff changeset
   258
   ("c_All", (@{const_name All}, (@{thm fAll_def},
56d352659500 improved translation of lambdas in THF
nik
parents: 43677
diff changeset
   259
       ("fAll", @{const_name ATP.fAll})))),
56d352659500 improved translation of lambdas in THF
nik
parents: 43677
diff changeset
   260
   ("c_Ex", (@{const_name Ex}, (@{thm fEx_def},
56d352659500 improved translation of lambdas in THF
nik
parents: 43677
diff changeset
   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
56d352659500 improved translation of lambdas in THF
nik
parents: 43677
diff changeset
   277
   (@{const_name All}, "All"),
56d352659500 improved translation of lambdas in THF
nik
parents: 43677
diff changeset
   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
blanchet
parents: 43572
diff changeset
   304
fun ascii_of_indexname (v, 0) = ascii_of v
blanchet
parents: 43572
diff changeset
   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
blanchet
parents: 43572
diff changeset
   313
fun make_schematic_type_var (x, i) =
blanchet
parents: 43572
diff changeset
   314
      tvar_prefix ^ (ascii_of_indexname (unprefix "'" x, i))
blanchet
parents: 43572
diff changeset
   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
0f50f158eb57 removed explicit reliance on Hilbert_Choice.Eps
nik
parents: 44586
diff changeset
   317
(* "HOL.eq" and Choice are mapped to the ATP's equivalents *)
0f50f158eb57 removed explicit reliance on Hilbert_Choice.Eps
nik
parents: 44586
diff changeset
   318
local
0f50f158eb57 removed explicit reliance on Hilbert_Choice.Eps
nik
parents: 44586
diff changeset
   319
  val choice_const = (fst o dest_Const o HOLogic.choice_const) Term.dummyT
0f50f158eb57 removed explicit reliance on Hilbert_Choice.Eps
nik
parents: 44586
diff changeset
   320
  fun default c = const_prefix ^ lookup_const c
0f50f158eb57 removed explicit reliance on Hilbert_Choice.Eps
nik
parents: 44586
diff changeset
   321
in
0f50f158eb57 removed explicit reliance on Hilbert_Choice.Eps
nik
parents: 44586
diff changeset
   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
0f50f158eb57 removed explicit reliance on Hilbert_Choice.Eps
nik
parents: 44586
diff changeset
   324
        if c = choice_const then tptp_choice else default c
0f50f158eb57 removed explicit reliance on Hilbert_Choice.Eps
nik
parents: 44586
diff changeset
   325
    | make_fixed_const _ c = default c
0f50f158eb57 removed explicit reliance on Hilbert_Choice.Eps
nik
parents: 44586
diff changeset
   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
blanchet
parents: 43092
diff changeset
   332
fun new_skolem_var_name_from_const s =
blanchet
parents: 43092
diff changeset
   333
  let val ss = s |> space_explode Long_Name.separator in
blanchet
parents: 43092
diff changeset
   334
    nth ss (length ss - 2)
blanchet
parents: 43092
diff changeset
   335
  end
blanchet
parents: 43092
diff changeset
   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
blanchet
parents: 43092
diff changeset
   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
blanchet
parents: 43259
diff changeset
   378
val type_class = the_single @{sort type}
blanchet
parents: 43259
diff changeset
   379
blanchet
parents: 43259
diff changeset
   380
fun add_packed_sort tvar =
blanchet
parents: 43259
diff changeset
   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
blanchet
parents: 43085
diff changeset
   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
blanchet
parents: 43085
diff changeset
   394
    {name = name,
43263
blanchet
parents: 43259
diff changeset
   395
     prem_lits = [] |> fold (uncurry add_packed_sort) tvars_srts |> map TVarLit,
43086
blanchet
parents: 43085
diff changeset
   396
     concl_lits = TConsLit (`make_type_class cls,
blanchet
parents: 43085
diff changeset
   397
                            `make_fixed_type_const tcons,
blanchet
parents: 43085
diff changeset
   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
75d2e48c5d30 avoid double ASCII-fication
blanchet
parents: 43493
diff changeset
   402
  | arity_clause seen n (tcons, ("HOL.type", _) :: ars) =  (* ignore *)
75d2e48c5d30 avoid double ASCII-fication
blanchet
parents: 43493
diff changeset
   403
    arity_clause seen n (tcons, ars)
75d2e48c5d30 avoid double ASCII-fication
blanchet
parents: 43493
diff changeset
   404
  | arity_clause seen n (tcons, (ar as (class, _)) :: ars) =
75d2e48c5d30 avoid double ASCII-fication
blanchet
parents: 43493
diff changeset
   405
    if member (op =) seen class then
75d2e48c5d30 avoid double ASCII-fication
blanchet
parents: 43493
diff changeset
   406
      (* multiple arities for the same (tycon, class) pair *)
75d2e48c5d30 avoid double ASCII-fication
blanchet
parents: 43493
diff changeset
   407
      make_axiom_arity_clause (tcons,
75d2e48c5d30 avoid double ASCII-fication
blanchet
parents: 43493
diff changeset
   408
          lookup_const tcons ^ "___" ^ ascii_of class ^ "_" ^ string_of_int n,
75d2e48c5d30 avoid double ASCII-fication
blanchet
parents: 43493
diff changeset
   409
          ar) ::
75d2e48c5d30 avoid double ASCII-fication
blanchet
parents: 43493
diff changeset
   410
      arity_clause seen (n + 1) (tcons, ars)
75d2e48c5d30 avoid double ASCII-fication
blanchet
parents: 43493
diff changeset
   411
    else
75d2e48c5d30 avoid double ASCII-fication
blanchet
parents: 43493
diff changeset
   412
      make_axiom_arity_clause (tcons, lookup_const tcons ^ "___" ^
75d2e48c5d30 avoid double ASCII-fication
blanchet
parents: 43493
diff changeset
   413
                               ascii_of class, ar) ::
75d2e48c5d30 avoid double ASCII-fication
blanchet
parents: 43493
diff changeset
   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
blanchet
parents: 43572
diff changeset
   420
(* Generate all pairs (tycon, class, sorts) such that tycon belongs to class in
blanchet
parents: 43572
diff changeset
   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
blanchet
parents: 43092
diff changeset
   423
  let
blanchet
parents: 43092
diff changeset
   424
    val alg = Sign.classes_of thy
blanchet
parents: 43092
diff changeset
   425
    fun domain_sorts tycon = Sorts.mg_domain alg tycon o single
blanchet
parents: 43092
diff changeset
   426
    fun add_class tycon class =
blanchet
parents: 43092
diff changeset
   427
      cons (class, domain_sorts tycon class)
blanchet
parents: 43092
diff changeset
   428
      handle Sorts.CLASS_ERROR _ => I
blanchet
parents: 43092
diff changeset
   429
    fun try_classes tycon = (tycon, fold (add_class tycon) classes [])
blanchet
parents: 43092
diff changeset
   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
blanchet
parents: 43259
diff changeset
   435
      let
blanchet
parents: 43259
diff changeset
   436
        fun maybe_insert_class s =
blanchet
parents: 43259
diff changeset
   437
          (s <> type_class andalso not (member (op =) classes s))
blanchet
parents: 43259
diff changeset
   438
          ? insert (op =) s
blanchet
parents: 43259
diff changeset
   439
        val cpairs = type_class_pairs thy tycons classes
blanchet
parents: 43259
diff changeset
   440
        val newclasses =
blanchet
parents: 43259
diff changeset
   441
          [] |> fold (fold (fold (fold maybe_insert_class) o snd) o snd) cpairs
blanchet
parents: 43259
diff changeset
   442
        val (classes', cpairs') = iter_type_class_pairs thy tycons newclasses
43266
3baf384e2b99 minor optimization
blanchet
parents: 43265
diff changeset
   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
blanchet
parents: 43085
diff changeset
   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
blanchet
parents: 43572
diff changeset
   456
(* Generate all pairs (sub, super) such that sub is a proper subclass of super
blanchet
parents: 43572
diff changeset
   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
blanchet
parents: 43572
diff changeset
   466
fun make_class_rel_clause (sub, super) =
blanchet
parents: 43572
diff changeset
   467
  {name = sub ^ "_" ^ super, subclass = `make_type_class sub,
43086
blanchet
parents: 43085
diff changeset
   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
blanchet
parents: 43092
diff changeset
   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
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   473
(* intermediate terms *)
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   474
datatype iterm =
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   475
  IConst of name * typ * typ list |
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   476
  IVar of name * typ |
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   477
  IApp of iterm * iterm |
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   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
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   480
fun ityp_of (IConst (_, T, _)) = T
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   481
  | ityp_of (IVar (_, T)) = T
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   482
  | ityp_of (IApp (t1, _)) = snd (dest_funT (ityp_of t1))
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   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
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   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
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   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
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   498
(* Converts an Isabelle/HOL term (with combinators) into an intermediate term.
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   499
   Also accumulates sort infomation. *)
44495
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
   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
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
   502
      val (P', P_atomics_Ts) = iterm_from_term thy format bs P
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
   503
      val (Q', Q_atomics_Ts) = iterm_from_term thy format bs Q
43859
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   504
    in (IApp (P', Q'), union (op =) P_atomics_Ts Q_atomics_Ts) end
44495
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
   505
  | iterm_from_term thy format _ (Const (c, T)) =
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
   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
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
   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
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
   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
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
   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
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   523
       IVar ((make_schematic_var v, s), T), atyps_of T)
44495
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
   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
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
   526
  | iterm_from_term thy format bs (Abs (s, T, t)) =
43678
56d352659500 improved translation of lambdas in THF
nik
parents: 43677
diff changeset
   527
    let
56d352659500 improved translation of lambdas in THF
nik
parents: 43677
diff changeset
   528
      fun vary s = s |> AList.defined (op =) bs s ? vary o Symbol.bump_string
56d352659500 improved translation of lambdas in THF
nik
parents: 43677
diff changeset
   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
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
   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
926bfe067a32 fixed soundness bug related to extensionality
blanchet
parents: 43401
diff changeset
   534
datatype locality =
44585
cfe7f4a68e51 added generation of induction rules
nik
parents: 44540
diff changeset
   535
  General | Helper | Induction | Extensionality | Intro | Elim | Simp |
cfe7f4a68e51 added generation of induction rules
nik
parents: 44540
diff changeset
   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
8d3a5b7b9a00 name tuning
blanchet
parents: 43361
diff changeset
   546
  No_Types
44402
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   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
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   551
  Guards of polymorphism * type_level * type_uniformity |
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   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
626e292d22a7 renamed type systems for more consistency
blanchet
parents: 42709
diff changeset
   558
  (case try (unprefix "poly_") s of
626e292d22a7 renamed type systems for more consistency
blanchet
parents: 42709
diff changeset
   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
626e292d22a7 renamed type systems for more consistency
blanchet
parents: 42709
diff changeset
   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
626e292d22a7 renamed type systems for more consistency
blanchet
parents: 42709
diff changeset
   565
         SOME s => (SOME Mangled_Monomorphic, s)
626e292d22a7 renamed type systems for more consistency
blanchet
parents: 42709
diff changeset
   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
8d3a5b7b9a00 name tuning
blanchet
parents: 43361
diff changeset
   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
8794ec73ec13 added syntax for "shallow" encodings
blanchet
parents: 42781
diff changeset
   576
  ||> apsnd (fn s =>
44402
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   577
                case try (unsuffix "_uniform") s of
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   578
                  SOME s => (Uniform, s)
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   579
                | NONE => (Nonuniform, s))
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   580
  |> (fn (poly, (level, (uniformity, core))) =>
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   581
         case (core, (poly, level, uniformity)) of
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   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
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   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
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   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
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   590
           Tags (Polymorphic, level, uniformity)
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   591
         | ("tags", (SOME poly, _, _)) => Tags (poly, level, uniformity)
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   592
         | ("args", (SOME poly, All_Types (* naja *), Nonuniform)) =>
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   593
           Guards (poly, Const_Arg_Types, Nonuniform)
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   594
         | ("erased", (NONE, All_Types (* naja *), Nonuniform)) =>
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   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
eb763b3ff9ed renamed "preds" encodings to "guards"
blanchet
parents: 43987
diff changeset
   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
eb763b3ff9ed renamed "preds" encodings to "guards"
blanchet
parents: 43987
diff changeset
   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
8794ec73ec13 added syntax for "shallow" encodings
blanchet
parents: 42781
diff changeset
   609
44402
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   610
fun uniformity_of_type_enc (Simple_Types _) = Uniform
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   611
  | uniformity_of_type_enc (Guards (_, _, uniformity)) = uniformity
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   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
8870232a87ad make TFF output less explicit where possible
blanchet
parents: 44496
diff changeset
   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
blanchet
parents: 40069
diff changeset
   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
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   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
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   667
fun update_iformula f ({name, locality, kind, iformula, atomic_types}
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   668
                       : translated_formula) =
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   669
  {name = name, locality = locality, kind = kind, iformula = f iformula,
42562
f1d903f789b1 killed needless datatype "combtyp" in Metis
blanchet
parents: 42561
diff changeset
   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
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   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
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
   676
    if exists (type_instance ctxt T o get_T) xs then xs
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
   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
9adf6b3965b3 code cleanup, better handling of corner cases
blanchet
parents: 42834
diff changeset
   686
fun should_drop_arg_type_args (Simple_Types _) =
9adf6b3965b3 code cleanup, better handling of corner cases
blanchet
parents: 42834
diff changeset
   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
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   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
e096b1effbbb mangle "ti" tags
blanchet
parents: 43622
diff changeset
   695
       Mangled_Type_Args
e096b1effbbb mangle "ti" tags
blanchet
parents: 43622
diff changeset
   696
     else
e096b1effbbb mangle "ti" tags
blanchet
parents: 43622
diff changeset
   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
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
   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
d21f7e330ec8 remove needless typing information
blanchet
parents: 44397
diff changeset
   701
    let val level = level_of_type_enc type_enc in
d21f7e330ec8 remove needless typing information
blanchet
parents: 44397
diff changeset
   702
      if level = No_Types orelse s = @{const_name HOL.eq} orelse
d21f7e330ec8 remove needless typing information
blanchet
parents: 44397
diff changeset
   703
         (s = app_op_name andalso level = Const_Arg_Types) then
d21f7e330ec8 remove needless typing information
blanchet
parents: 44397
diff changeset
   704
        No_Type_Args
d21f7e330ec8 remove needless typing information
blanchet
parents: 44397
diff changeset
   705
      else
d21f7e330ec8 remove needless typing information
blanchet
parents: 44397
diff changeset
   706
        should_drop_arg_type_args type_enc
d21f7e330ec8 remove needless typing information
blanchet
parents: 44397
diff changeset
   707
        |> (if polymorphism_of_type_enc type_enc = Mangled_Monomorphic then
d21f7e330ec8 remove needless typing information
blanchet
parents: 44397
diff changeset
   708
              Mangled_Type_Args
d21f7e330ec8 remove needless typing information
blanchet
parents: 44397
diff changeset
   709
            else
d21f7e330ec8 remove needless typing information
blanchet
parents: 44397
diff changeset
   710
              Explicit_Type_Args)
d21f7e330ec8 remove needless typing information
blanchet
parents: 44397
diff changeset
   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
blanchet
parents: 43259
diff changeset
   714
fun generic_add_sorts_on_type (_, []) = I
blanchet
parents: 43259
diff changeset
   715
  | generic_add_sorts_on_type ((x, i), s :: ss) =
blanchet
parents: 43259
diff changeset
   716
    generic_add_sorts_on_type ((x, i), ss)
blanchet
parents: 43259
diff changeset
   717
    #> (if s = the_single @{sort HOL.type} then
43093
blanchet
parents: 43092
diff changeset
   718
          I
blanchet
parents: 43092
diff changeset
   719
        else if i = ~1 then
43263
blanchet
parents: 43259
diff changeset
   720
          insert (op =) (TyLitFree (`make_type_class s, `make_fixed_type_var x))
43093
blanchet
parents: 43092
diff changeset
   721
        else
43263
blanchet
parents: 43259
diff changeset
   722
          insert (op =) (TyLitVar (`make_type_class s,
blanchet
parents: 43259
diff changeset
   723
                                   (make_schematic_type_var (x, i), x))))
blanchet
parents: 43259
diff changeset
   724
fun add_sorts_on_tfree (TFree (s, S)) = generic_add_sorts_on_type ((s, ~1), S)
blanchet
parents: 43259
diff changeset
   725
  | add_sorts_on_tfree _ = I
blanchet
parents: 43259
diff changeset
   726
fun add_sorts_on_tvar (TVar z) = generic_add_sorts_on_type z
blanchet
parents: 43259
diff changeset
   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
46d485f8d144 added room for types in ATP quantifiers
blanchet
parents: 42525
diff changeset
   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
46d485f8d144 added room for types in ATP quantifiers
blanchet
parents: 42525
diff changeset
   749
        union (op =) (atom_vars tm []
46d485f8d144 added room for types in ATP quantifiers
blanchet
parents: 42525
diff changeset
   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
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   753
fun iterm_vars (IApp (tm1, tm2)) = fold iterm_vars [tm1, tm2]
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   754
  | iterm_vars (IConst _) = I
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   755
  | iterm_vars (IVar (name, T)) = insert (op =) (name, SOME T)
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   756
  | iterm_vars (IAbs (_, tm)) = iterm_vars tm
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
   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
f1d903f789b1 killed needless datatype "combtyp" in Metis
blanchet
parents: 42561
diff changeset
   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
f1d903f789b1 killed needless datatype "combtyp" in Metis
blanchet
parents: 42561
diff changeset
   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
f1d903f789b1 killed needless datatype "combtyp" in Metis
blanchet
parents: 42561
diff changeset
   791
fun generic_mangled_type_name f (ATerm (name, [])) = f name
f1d903f789b1 killed needless datatype "combtyp" in Metis
blanchet
parents: 42561
diff changeset
   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
264881a20f50 make SML/NJ happy + tuning
blanchet
parents: 43678
diff changeset
   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
5725deb11ae7 identify HOL functions with THF functions
blanchet
parents: 42962
diff changeset
   810
  let
5725deb11ae7 identify HOL functions with THF functions
blanchet
parents: 42962
diff changeset
   811
    fun to_atype ty =
5725deb11ae7 identify HOL functions with THF functions
blanchet
parents: 42962
diff changeset
   812
      AType ((make_simple_type (generic_mangled_type_name fst ty),
5725deb11ae7 identify HOL functions with THF functions
blanchet
parents: 42962
diff changeset
   813
              generic_mangled_type_name snd ty))
5725deb11ae7 identify HOL functions with THF functions
blanchet
parents: 42962
diff changeset
   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
264881a20f50 make SML/NJ happy + tuning
blanchet
parents: 43678
diff changeset
   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
5725deb11ae7 identify HOL functions with THF functions
blanchet
parents: 42962
diff changeset
   822
43677
2cd0b478d1b6 added generation of lambdas in THF
nik
parents: 43676
diff changeset
   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
5725deb11ae7 identify HOL functions with THF functions
blanchet
parents: 42962
diff changeset
   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
5725deb11ae7 identify HOL functions with THF functions
blanchet
parents: 42962
diff changeset
   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
5725deb11ae7 identify HOL functions with THF functions
blanchet
parents: 42962
diff changeset
   830
    fun type_suffix f g =
5725deb11ae7 identify HOL functions with THF functions
blanchet
parents: 42962
diff changeset
   831
      fold_rev (curry (op ^) o g o prefix mangled_type_sep
5725deb11ae7 identify HOL functions with THF functions
blanchet
parents: 42962
diff changeset
   832
                o generic_mangled_type_name f) ty_args ""
5725deb11ae7 identify HOL functions with THF functions
blanchet
parents: 42962
diff changeset
   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
3cae91385086 workaround THF parser limitation
blanchet
parents: 44088
diff changeset
   889
               if is_tptp_equal s andalso length args = 2 then
3cae91385086 workaround THF parser limitation
blanchet
parents: 44088
diff changeset
   890
                 IConst (`I tptp_equal, T, [])
3cae91385086 workaround THF parser limitation
blanchet
parents: 44088
diff changeset
   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
3cae91385086 workaround THF parser limitation
blanchet
parents: 44088
diff changeset
   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
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
   899
          | NONE => if s = tptp_choice then
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
   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
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
   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
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
   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
096237fe70f1 don't needlessly extensionalize
blanchet
parents: 43264
diff changeset
   960
fun is_fun_equality (@{const_name HOL.eq},
096237fe70f1 don't needlessly extensionalize
blanchet
parents: 43264
diff changeset
   961
                     Type (_, [Type (@{type_name fun}, _), _])) = true
096237fe70f1 don't needlessly extensionalize
blanchet
parents: 43264
diff changeset
   962
  | is_fun_equality _ = false
096237fe70f1 don't needlessly extensionalize
blanchet
parents: 43264
diff changeset
   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
096237fe70f1 don't needlessly extensionalize
blanchet
parents: 43264
diff changeset
   965
  if exists_Const is_fun_equality t then
096237fe70f1 don't needlessly extensionalize
blanchet
parents: 43264
diff changeset
   966
    let val thy = Proof_Context.theory_of ctxt in
096237fe70f1 don't needlessly extensionalize
blanchet
parents: 43264
diff changeset
   967
      t |> cterm_of thy |> Meson.extensionalize_conv ctxt
096237fe70f1 don't needlessly extensionalize
blanchet
parents: 43264
diff changeset
   968
        |> prop_of |> Logic.dest_equals |> snd
096237fe70f1 don't needlessly extensionalize
blanchet
parents: 43264
diff changeset
   969
    end
096237fe70f1 don't needlessly extensionalize
blanchet
parents: 43264
diff changeset
   970
  else
096237fe70f1 don't needlessly extensionalize
blanchet
parents: 43264
diff changeset
   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
a14fdb8c0497 pass kind to lambda-translation function
blanchet
parents: 43861
diff changeset
   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
578460971517 fixed lambda concealing
blanchet
parents: 43989
diff changeset
  1003
fun do_cheaply_conceal_lambdas Ts (t1 $ t2) =
578460971517 fixed lambda concealing
blanchet
parents: 43989
diff changeset
  1004
    do_cheaply_conceal_lambdas Ts t1
578460971517 fixed lambda concealing
blanchet
parents: 43989
diff changeset
  1005
    $ do_cheaply_conceal_lambdas Ts t2
578460971517 fixed lambda concealing
blanchet
parents: 43989
diff changeset
  1006
  | do_cheaply_conceal_lambdas Ts (Abs (_, T, t)) =
578460971517 fixed lambda concealing
blanchet
parents: 43989
diff changeset
  1007
    Free (polymorphic_free_prefix ^ serial_string (),
578460971517 fixed lambda concealing
blanchet
parents: 43989
diff changeset
  1008
          T --> fastype_of1 (T :: Ts, t))
578460971517 fixed lambda concealing
blanchet
parents: 43989
diff changeset
  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
a14fdb8c0497 pass kind to lambda-translation function
blanchet
parents: 43861
diff changeset
  1011
fun do_introduce_combinators ctxt Ts t =
42361
23f352990944 modernized structure Proof_Context;
wenzelm
parents: 42353
diff changeset
  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
a14fdb8c0497 pass kind to lambda-translation function
blanchet
parents: 43861
diff changeset
  1019
  (* A type variable of sort "{}" will make abstraction fail. *)
43997
578460971517 fixed lambda concealing
blanchet
parents: 43989
diff changeset
  1020
  handle THM _ => t |> do_cheaply_conceal_lambdas Ts
43862
a14fdb8c0497 pass kind to lambda-translation function
blanchet
parents: 43861
diff changeset
  1021
val introduce_combinators = simple_translate_lambdas do_introduce_combinators
a14fdb8c0497 pass kind to lambda-translation function
blanchet
parents: 43861
diff changeset
  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
a14fdb8c0497 pass kind to lambda-translation function
blanchet
parents: 43861
diff changeset
  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
5bde887b4785 make polymorphic encodings more complete
blanchet
parents: 44500
diff changeset
  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
23f352990944 modernized structure Proof_Context;
wenzelm
parents: 42353
diff changeset
  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
e70ffe3846d0 improve helper type instantiation code
blanchet
parents: 42562
diff changeset
  1051
    val need_trueprop = (fastype_of t = @{typ bool})
43096
f181d66046d4 don't preprocess twice
blanchet
parents: 43093
diff changeset
  1052
  in
f181d66046d4 don't preprocess twice
blanchet
parents: 43093
diff changeset
  1053
    t |> need_trueprop ? HOLogic.mk_Trueprop
f181d66046d4 don't preprocess twice
blanchet
parents: 43093
diff changeset
  1054
      |> Raw_Simplifier.rewrite_term thy (Meson.unfold_set_const_simps ctxt) []
f181d66046d4 don't preprocess twice
blanchet
parents: 43093
diff changeset
  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
f181d66046d4 don't preprocess twice
blanchet
parents: 43093
diff changeset
  1058
  end
f181d66046d4 don't preprocess twice
blanchet
parents: 43093
diff changeset
  1059
f181d66046d4 don't preprocess twice
blanchet
parents: 43093
diff changeset
  1060
(* making fact and conjecture formulas *)
44495
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
  1061
fun make_formula thy format type_enc eq_as_iff name loc kind t =
43096
f181d66046d4 don't preprocess twice
blanchet
parents: 43093
diff changeset
  1062
  let
43859
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
  1063
    val (iformula, atomic_types) =
44495
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
  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
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
  1066
    {name = name, locality = loc, kind = kind, iformula = iformula,
42562
f1d903f789b1 killed needless datatype "combtyp" in Metis
blanchet
parents: 42561
diff changeset
  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
f181d66046d4 don't preprocess twice
blanchet
parents: 43093
diff changeset
  1071
  let val thy = Proof_Context.theory_of ctxt in
44495
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
  1072
    case t |> make_formula thy format type_enc (eq_as_iff andalso format <> CNF)
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
  1073
                           name loc Axiom of
43859
b7890554c424 renamed internal data structure
blanchet
parents: 43858
diff changeset
  1074
      formula as {iformula = AAtom (IConst ((s, _), _, _)), ...} =>
43096
f181d66046d4 don't preprocess twice
blanchet
parents: 43093
diff changeset
  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
f181d66046d4 don't preprocess twice
blanchet
parents: 43093
diff changeset
  1077
  end
42561
23ddc4e3d19c have properly type-instantiated helper facts (combinators and If)
blanchet
parents: 42560
diff changeset
  1078
44460
blanchet
parents: 44450
diff changeset
  1079
fun s_not_trueprop (@{const Trueprop} $ t) = @{const Trueprop} $ s_not t
blanchet
parents: 44450
diff changeset
  1080
  | s_not_trueprop t = s_not t
blanchet
parents: 44450
diff changeset
  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
4c2242c8a96c added choice operator output for
nik
parents: 44494
diff changeset
  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
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1089
type monotonicity_info =
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1090
  {maybe_finite_Ts : typ list,
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1091
   surely_finite_Ts : typ list,
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1092
   maybe_infinite_Ts : typ list,
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1093
   surely_infinite_Ts : typ list,
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1094
   maybe_nonmono_Ts : typ list}
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  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
dbd98b549597 make default unsound mode less unsound
blanchet
parents: 44499
diff changeset
  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
dbd98b549597 make default unsound mode less unsound
blanchet
parents: 44499
diff changeset
  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
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1110
fun should_encode_type _ (_ : monotonicity_info) All_Types _ = true
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1111
  | should_encode_type ctxt {maybe_finite_Ts, surely_infinite_Ts,
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1112
                             maybe_nonmono_Ts, ...}
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  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
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1115
    not (exists (type_instance ctxt T) surely_infinite_Ts orelse
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1116
         (not (member (type_aconv ctxt) maybe_finite_Ts T) andalso
44500
dbd98b549597 make default unsound mode less unsound
blanchet
parents: 44499
diff changeset
  1117
          is_type_kind_of_surely_infinite ctxt soundness surely_infinite_Ts T))
44399
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1118
  | should_encode_type ctxt {surely_finite_Ts, maybe_infinite_Ts,
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1119
                             maybe_nonmono_Ts, ...}
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  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
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1123
     (not (member (type_aconv ctxt) maybe_infinite_Ts T) andalso
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  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
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
  1127
fun should_guard_type ctxt mono (Guards (_, level, uniformity)) should_guard_var
44399
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1128
                      T =
44402
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
  1129
    (uniformity = Uniform orelse should_guard_var ()) andalso
44399
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  1130
    should_encode_type ctxt mono level T
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  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
9adf6b3965b3 code cleanup, better handling of corner cases
blanchet
parents: 42834
diff changeset
  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
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
  1145
  | should_tag_with_type ctxt mono (Tags (_, level, uniformity)) site u T =
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
  1146
    (case uniformity of
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
  1147
       Uniform => should_encode_type ctxt mono level T
f0bc74b9161e clearer terminology
blanchet
parents: 44399
diff changeset
  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
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  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
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  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
cd1e32b8d4c4 added caching for (in)finiteness checks
blanchet
parents: 44398
diff changeset
  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