src/HOL/Tools/SMT/smt_solver.ML
changeset 41041 ec2734f34d0f
parent 40981 67f436af0638
child 41065 13424972ade4
equal deleted inserted replaced
41040:a4a5a465da8d 41041:ec2734f34d0f
   214       tracing (Pretty.string_of (Pretty.big_list "SMT used facts:"
   214       tracing (Pretty.string_of (Pretty.big_list "SMT used facts:"
   215         (map (Display.pretty_thm ctxt) thms)))
   215         (map (Display.pretty_thm ctxt) thms)))
   216     else ()
   216     else ()
   217   end
   217   end
   218 
   218 
   219 fun gen_solver name info rm ctxt irules =
   219 
       
   220 
       
   221 (* registry *)
       
   222 
       
   223 type solver = bool option -> Proof.context -> (int * thm) list -> int list * thm
       
   224 
       
   225 type solver_info = {
       
   226   env_var: string,
       
   227   is_remote: bool,
       
   228   options: Proof.context -> string list,
       
   229   interface: interface,
       
   230   reconstruct: string list * SMT_Translate.recon -> Proof.context ->
       
   231     (int list * thm) * Proof.context,
       
   232   default_max_relevant: int }
       
   233 
       
   234 fun gen_solver name (info : solver_info) rm ctxt irules =
   220   let
   235   let
   221     val {env_var, is_remote, options, interface, reconstruct, ...} = info
   236     val {env_var, is_remote, options, interface, reconstruct, ...} = info
   222     val {extra_norm, translate} = interface
   237     val {extra_norm, translate} = interface
   223     val (with_datatypes, translate') =
   238     val (with_datatypes, translate') =
   224       set_has_datatypes (Config.get ctxt C.datatypes) translate
   239       set_has_datatypes (Config.get ctxt C.datatypes) translate
   232     |> singleton (ProofContext.export ctxt' ctxt)
   247     |> singleton (ProofContext.export ctxt' ctxt)
   233     |> discharge_definitions
   248     |> discharge_definitions
   234     |> tap (fn _ => trace_assumptions ctxt irules idxs)
   249     |> tap (fn _ => trace_assumptions ctxt irules idxs)
   235     |> pair idxs)
   250     |> pair idxs)
   236   end
   251   end
   237 
       
   238 
       
   239 
       
   240 (* registry *)
       
   241 
       
   242 type solver = bool option -> Proof.context -> (int * thm) list -> int list * thm
       
   243 
       
   244 type solver_info = {
       
   245   env_var: string,
       
   246   is_remote: bool,
       
   247   options: Proof.context -> string list,
       
   248   interface: interface,
       
   249   reconstruct: string list * SMT_Translate.recon -> Proof.context ->
       
   250     (int list * thm) * Proof.context,
       
   251   default_max_relevant: int }
       
   252 
   252 
   253 structure Solvers = Generic_Data
   253 structure Solvers = Generic_Data
   254 (
   254 (
   255   type T = solver_info Symtab.table
   255   type T = solver_info Symtab.table
   256   val empty = Symtab.empty
   256   val empty = Symtab.empty