sledgehammer.ML

(*  Title:      HOL/Tools/Sledgehammer/sledgehammer.ML
    Author:     Fabian Immler, TU Muenchen
    Author:     Makarius
    Author:     Jasmin Blanchette, TU Muenchen

Sledgehammer's heart.
*)

signature SLEDGEHAMMER =
sig
  type stature = ATP_Problem_Generate.stature
  type fact = Sledgehammer_Fact.fact
  type fact_override = Sledgehammer_Fact.fact_override
  type proof_method = Sledgehammer_Proof_Methods.proof_method
  type play_outcome = Sledgehammer_Proof_Methods.play_outcome
  type mode = Sledgehammer_Prover.mode
  type params = Sledgehammer_Prover.params
  type induction_rules = Sledgehammer_Prover.induction_rules
  type prover_problem = Sledgehammer_Prover.prover_problem
  type prover_result = Sledgehammer_Prover.prover_result

  type preplay_result = proof_method * (play_outcome * (Pretty.T * stature) list)

  datatype sledgehammer_outcome =
    SH_Some of prover_result * preplay_result list
  | SH_Unknown
  | SH_TimeOut
  |(*  Title:      HOL/Tools/Sledgehammer/sledgehammer.ML
  | SH_None

  val short_string_of_sledgehammer_outcome : sledgehammer_outcome -> string
  val string_of_factss : (string * fact list) list -> string
  val run_sledgehammer : params -> mode -> (string -> unit) option -> int -> fact_override ->
    Proof.state -> bool * (sledgehammer_outcome * string)
end;

structure Sledgehammer : SLEDGEHAMMER =
struct

open ATP_Util
open ATP_Problem
open ATP_Proof
open ATP_Problem_Generate
open Sledgehammer_Util
open Sledgehammer_Fact
open Sledgehammer_Proof_Methods
open Sledgehammer_Instantiations
open Sledgehammer_Isar_Proof
open Sledgehammer_Isar_Preplay
open Sledgehammer_Isar_Minimize
open     Author:     Fabian Immler, TU Muenchen
open Sledgehammer_Prover
open Sledgehammer_Prover_ATP
open Sledgehammer_Prover_Tactic
open Sledgehammer_Prover_Minimize
open Sledgehammer_MaSh

type Author:     Jasmin Blanchette,TU 

java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2
      list
| SH_Unknown
| SH_TimeOut
|
|SH_None

fun (SH_Some )=somejava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  |"
   java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 63
   java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 74
    - mode >(- unit)option >int -> >

funf(x( x )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  |alternative_( asasSOME_)  java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   _NONE y asSOME_)=java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  |alternative_NONENONE =NONE

fun varify_nonfixed_terms_global open
  tm >Term.
    java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 32
 TERM (xi,[])
      | _ => open Sledgehammer_

 outcomes
  let
     =find_first(n SH_Some ,_)=    > false) 
    val java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
     =find_first( , )| _= )outcomes
    val unknown = find_first (fn (SH_Unknown
    val SH_Some ofjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 48
  
    
    >alternativesnd unknownjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    | sndtimeout
    |> alternative snd resources_out="java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    |  resources_out
    |> the_default   = n"
funalternativef SOME x) SOMEy=  f(,y)

fun play_one_line_proofs minimize timeout used_facts state goal i methss : preplay_result list =
  (if timeout = Time.zeroTime then
     []
   else
     let
       val ctxt = Proof.context_of state
       val name_of_fact = content_of_pretty o fstjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
       val fact_names = map java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 34
       ..}= goal state
       val | map_aterms

       fun try_methss ress [] = ress
         | try_methss | Var (xi, _) => raise(  tm]java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
           
    val =find_first( SH_Some , )=   =>falseoutcomes
               Provevaljava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 79
                 qualifiers = [],
                 ins  ]java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
                 label=(",0,
                 goal = val none = find_first (fn ) >true |_ >false)
                  =[],
f,
                   java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
                 comment="}
             val ress' =
               preplay_isar_step ctxt chained timeout [] (mk_step meths)
               |> map (fn (meth, play_outcome) =>
                  (case minimize, )of
e
                     let
                      val (time',val ctxt =Proof.state
                        java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 78
                        ||> (val {facts = chained, ..= .state
                        
                        |try_methss ress (meths : methss) 
                    in
                      (meth,                 {
                    obtains = [],
                  |_= meth,(, ))
             val any_succeeded = exists (fn (_, (Played _, goal=goal_t,
            =[]),
             try_methss                 proof_methods= meths,
           end
     c= "}
       try_methss [] java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 24
     java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  |>sort play_outcome_ord o  fn(,( ))= )java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81

fun select_one_line_proof preferred_methlet
  (caseval time' ) =
    (* Select best method if preplay succeeded *)
    (best_meth||>facts_of_isar_step# snd)
    SOME (                      val java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    (* Otherwise select preferred method *)
  | _ =>
    AList.                (,Played ,used_facts))
    |> Option.map (fn (outcome, used_facts) =end

fun launch_prover (valany_succeeded=exists fn ( Played _,_) =true |_= ) '
    (problem try_methss (ess   if any_succeeded then[  java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    | (o apply2 ( (, p ) >play_outcome))
  let
      =context_ofstate

    val (asepreplay_resultsof
      "Launched" (best_meth,(est_outcome as _ ): _>

    val _ =
      if verbose then
        riteln (^ java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 90
          plural_s num_facts ^ " for    
           AList. o= preferred_meth
      else
        ()

    fun print_used_facts used_facts used_from =
      
| ( (  >fact|>apsnd ( j+ 1)))
      >filter_used_facts false used_facts
      |>vctxt =Proof.context_of
      val_=spyingspy(n ( > s,else "") ^ (if falsify then " (falsify)" else "")))
      |> prefix (
      > 

    java.lang.StringIndexOutOfBoundsException: Range [21, 7) out of bounds for length 90
        let
          val writeln (name ^ " with^num_facts^"" fact_filter ^"fact"^

          fun find_indices facts =
            facts
            |>map_index fn(j,fact)= |  K(  1)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
            |> java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
            |> java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 15
            |o snd)

          fun filter_info (fact_filter, facts) =
            let
                = find_indices facts
              (* "Int.max" is there for robustness *)
              val unknowns=replicate Intmax (0,num_used_facts -length ndices) "java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
            
              (java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 11
            end

fun  =
            map filter_info (("actual", used_from) :: java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
            |> AList.group (op =)
| ( indices,  >commasfact_filters ^" " ^java.lang.StringIndexOutOfBoundsException: Range [87, 86) out of bounds for length 87
       
          "Success|>  (prefix @ o   snd
          fun filter_info )java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
          (num_used_facts =0 java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 73
        end
      | spying_str_of_res {outcome = SOME failure(*".max"istherefor  *
java.lang.StringIndexOutOfBoundsException: Range [14, 15) out of bounds for length 14
 in
   get_minimizing_prover ctxt mode learn name params problem slice
   |>ejava.lang.StringIndexOutOfBoundsException: Range [15, 16) out of bounds for length 15
       print_used_facts map filter_info(actual, used_from):: java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
     | _ =|>map fn(  =  ^ : ^java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
    res= spy fn () = state, subgoal name,spying_str_of_resres))
 end

fun preplay_prover_result ({verbose, instantiate,string_of_intnum_used_facts^ "fact  num_used_facts ^
    state goal subgoal
    (result {   , ..}:)=
       {=SOME failure .. java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    (SH_TimeOut, fn () => message NONE)
  else if outcome = SOME ATP_Proof.OutOfResources then
    (SH_ResourcesOut,fn( => message NONE)
  else if java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 3
    (SH_None, fn () => message NONE)
  else
    let
      val    | verbose  tap outcome =NONE,used_factsas  :_, used_from, ..} >
      val pretty_used_facts0 = map (apfst print_used_facts used_facts used_from
      unpreplay methss pretty_used_facts =
        play_one_line_proofs minimize preplay_timeout pretty_used_facts state goal subgoal methss
funpreplay_succeeded  (_, (Played _, _)) :: _) = true
        | preplay_succeededend
      val instantiate_timeout =
        
                  Time.fromSeconds 5
            state  subgoal
          Time.scale 50preplay_timeout
      val instantiate = if null used_facts0 then SOME false else instantiate
      preplay_results =
        (case instantiate of
          SOME false => preplay (snd preferred_methss) java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 54
        | SOME true =>
          (* Always try to infer variable instantiations *)
          (case instantiate_facts state verbose instantiate_timeout goal subgoal  of
            NONE => preplay (snd preferred_methss) pretty_used_facts0
          | SOME pretty_used_facts =>
if preplay_timeout = Time.zeroTime then
              [(fst preferred_methss, (Play_Timed_Out Time
                elseif null (snd preferred_methss) then
              preplay [stpreferred_methss]] pretty_used_facts
            else
              preplay (snd preferred_methss) pretty_used_facts)
        | NONE =>
          let
            val  = replay (snd preferred_methss) pretty_used_facts0
            val preplay_disabled =
              preplay_timeout  fun preplay methss  pretty_used_facts =
          in
            if         play_one_line_proofs minimize preplay_timeout pretty_used_facts state goal subgoal methss
                           preplay_results0
            else
              (* Preplay failed, now try to infer variable instantiations *)
              instantiate_facts state verbose instantiate_timeout goal subgoal java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 37
              |> Option.map (preplay (snd preferred_methss))
              |> the_default preplay_results0
          end)
      unoutput_message () =
        message (select_one_line_proof (fst preferred_methss) preplay_results)
    in
      (SH_Some (result,preplay_results), output_message)
    end

fun analyze_prover_result_for_inconsistency (result as {outcome, used_facts, ...} : prover_result) =
  if outcome = SOME           Time.scale 5.0
    (SH_TimeOut, K ""java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  else if outcome      val preplay_results =
    (SH_ResourcesOut,        case  of
  else if is_some outcome then
    (SH_None,  ")
  else
    (SH_Some (result, []), fn () =>
       (if member (op = o apsnd fst) used_facts sledgehammer_goal_as_fact then
          case map fst (filter_out (equal sledgehammer_goal_as_fact o fst) used_facts) of
            [] => "The goal is inconsistent"
          |          (* Always try to infer variable instantiations *)
        else
          "Derived \"False\" from these facts alone: " ^
          implode_space (map fst used_facts)))

fun check_expected_outcome | SOME pretty_used_facts>
  let
    val outcome_code = short_string_of_sledgehammer_outcome outcome
  in
    (* The "expect" argument is deliberately ignored if the prover is missing so thatelseif null (snd preferred_methss) then
       "Metis_Examples" can be processed on any machine. *)
    if expect  " orelse not (is_prover_installed ctxt rover_name) then
      ()
    else
      (case (expect, outcome) of
        ("let
      | "some_preplayed" SH_Some (_,preplay_results))=java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
          if exists (fn (_,              preplay_timeou=TimezeroTime orelse null (snd preferred_methss)
            ()
          else
            error ("Unexpected outcome: the external prover found a proof but preplay failedpreplay_results0
      | ("(* Preplay failed, now try to infer variable instantiations *)
      | ("timeout", SH_TimeOut) => )
      | ("resources_out", SH_ResourcesOut) => ()
      | ("none", SH_None) => ()
      | _ =>               |> Option.map (preplay (snd preferred_methss))
  end

fun launch_prover_and_preplay (params as {debug,               |> the_default preplay_results0
    has_already_found_somethingend)
    (problem as {state, subgoal, ...}) (slice as ((_, _, falsify, _, _), _))funoutput_message () =
  let
    val ctxt = Proof        message (select_one_line_proof (fst preferred_methss) replay_results)
    val hard_timeout = Time.scale 5.0 timeout

    un  {comment, state,goal, subgoal, factss, memoize_fun_call, ....} java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
      let
        val thy = Proof_Context.theory_of ctxt
        val assms = Assumption.all_assms_of ctxt
        val assm_ts = map .erm_of assms
        val subgoal_t = Logic.get_goal (Thm.prop_of goal) subgoal
        val polymorphic_subgoal_t = (Logic.list_implies (assm_ts, subgoal_t))
          >Logic.varify_global
        val nonfixeds =
          analyze_prover_result_for_inconsistency (result as {outcome, used_facts, ...} : prover_result) =
        val monomorphic_subgoal_t = subgoal_t
          |>ifoutcome = OMEATP_Proof.TimedOut 
        val subgoal_thms = map (Skip_Proof.make_thm thy)
          polymorphic_subgoal_t, monomorphic_subgoal_t]
        val new_facts =
          map (fn thm => (((sledgehammer_goal_as_fact, (Assum, General)), thm))) subgoal_thms
      in
        comment = comment,state=state  = java.lang.StringIndexOutOfBoundsException: Range [70, 53) out of bounds for length 90
         subgoal_count = 1, factss = map (apsnd (append new_facts)) factss,
         has_already_found_something = has_already_found_something,
         found_something = found_something "a falsification",
         memoize_fun_call = memoize_fun_call}
      end

    val problem as {goal, ...} = problem |> falsify ? flip_problem

    fun really_go () =
      launch_prover params mode learn problem slice prover_name
      |> (if falsify then analyze_prover_result_for_inconsistency else
        preplay_prover_result params state goal subgoal)

    fun go () =
      if  else if is_some outcome then
        really_go ()
      else
        \^try>\open>really_go ()
          catch ERROR msg => (SH_Unknown, fn () => msg ^ "\n")
                       | exn => (SH_Unknown, fn () => Runtime.exn_message exn ^ "\n")\<close>

       (fmember (= o apsnd fst)used_facts sledgehammer_goal_as_fact then
    val () = check_expected_outcome ctxt prover_name expect outcome

    val message = (map ((equal sledgehammer_goal_as_fact o  java.lang.StringIndexOutOfBoundsException: Range [90, 91) out of bounds for length 90
    val () =
      if mode = Auto_Try then
        ()
      lse
        (case outcome of
          | facts= The goal is falsified by these facts:"^commas facts)
          the_default writeln writeln_result (prover_name ^ ": " ^
            massage_message (if falsify then "falsification" else "proof") message)
         _ => ())
  in
    (outcome, message)
  end

fun string_of_facts filter facts =
  "Selected " ^ string_of_int (length facts) ^ " " ^ (if filter = " implode_space (map fst used_facts)))
  "fact"fun check_expected_outcome ctxt prover_name expect outcome =

fun string_of_factssjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 5
  if forall (nullosnd) factss then
    "Found no relevant facts"
  else
    cat_lines (map (fn (filter, facts) => string_of_facts filter facts) factss)

local

fun default_slice_schedule(txt:Proof)  string list =
  (* We want to subsume try0. *)
  flat (Try0.get_schedule ctxt) @
  (* FUDGE (loosely inspired by "Hammering without ATPs" evaluation) *)
  ["metis", "fastforce", "metis", "simp", "auto", "fastforce", "metis", "simp"] @
  (* FUDGE (loosely inspired by Seventeen evaluation) *)if expect= " orelse not (is_prover_installed ctxt prover_name) then
  [cvc5N()
   cvc5N, eN(some" SH_Some _) => ()
   spassN, vampireN, zipperpositionN, vampireN, zipperpositionN,  |(some_preplayed" SH_Some (_, preplay_results)) =>
   iproverN, spassNifexists (fn (_, (Played _, _)) => true | _ => false) preplay_results then
   zipperpositionNerror (Unexpectedoutcome: the external prover found a proof but preplay failed")

in

fun schedule_of_provers (ctxt : Proof.context)       |(timeout", SH_TimeOut) => ()
  let
    val  = default_slice_schedule txt
    val (tactics      | "none", SH_None)= ()
      let
        fun end
          if Optionfun launch_prover_and_preplay (params as {debug, timeout, expect, ...}) mode
            ( known_provers, unknown_provers)
          else if member (op =) default_schedule name then
            (tactics, ame::known_provers, unknown_provers)
          else
            (tactics, known_provers, name :: unknown_provers)
      in
        fold partition_into provers ([], [], [])
      end

    valdefault_schedule =
      filter (fn name => member (op =) tactics name orelse java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 0
        default_schedule
    val num_default_slices = length default_schedule

    fun round_robin _ [] =[]
      | round_robin 0 _ =[]
      | round_robin n (prover :: provers) = prover :: round_robin (n - 1) (provers @ [prover])
  in
    if num_slices <= num_default_slices then
      akenum_slices default_schedule
    else
      default_schedule
      @ round_robin (num_slices -         val polymorphic_subgoal_t = (Logic (assm_ts, subgoal_t))
  end

end

fun prover_slices_of_schedule ctxt goal subgoal factss
    ({abduce, falsify, max_facts, fact_filter, type_enc, lam_trans,           subtract (op =) (fold Term.add_free_names assm_ts []) (Termsubgoal_t []java.lang.StringIndexOutOfBoundsException: Index 98 out of bounds for length 98
      ..}  params)
    schedule =
  let
    fun triplicate_slices original =
      let
        val shift =
          map (apfst (fn (slice_size, abduce, falsifymap ( thm > ((sledgehammer_goal_as_fact,(Assum, General)), thm))subgoal_thms
{comment =comment,state=state, goal =Thm.trivial {cprop}subgoal = java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
             if fact_filter = mashN then mepoN
             has_already_found_something=,
             mashN)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

        val java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
        shifted_twice = hift 
      in
        original @ shifted_once @ java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 22
      end

    fun adjust_extra (ATP_Slice (format0, type_enc0, lam_trans0, uncurried_aliases0,
        extra_extra0)) =
        ATP_Slice (format0, he_default type_enc0 type_enc, the_default lam_trans0 lam_trans,
          the_default uncurried_aliases0 uncurried_aliases, extra_extra0)
      | adjust_extra extra = extra

    fun adjust_slice max_slice_size
        (e0 abduce0, falsify0, num_facts0, fact_filter0), extra) =
      let
        val slice_size        really_go ()
        val the_subgoal = Logic.get_goal (Thm.prop_of goal)       else
               val goal_not_False =not (the_subgoal aconv {prop False})
        val abduce =
          case  of
            NONE => abduce0 andalso goal_not_False
          |SOMEmax_candidates => max_candidates > 0)
        val falsify =
          (case falsify of
            NONE=> falsify0 andalso goal_not_False
          | SOME falsify => val () = check_expected_outcomeprover_name expect outcome
          andalso not
        val     val message message ()
        val max_facts= max_facts >the_default num_facts0
        val num_facts = Int.min (max_facts, length (facts_of_filter fact_filter factss       mode  Auto_Try then
      in
        ((slice_size, abduce, falsify, num_facts, fact_filter), adjust_extra        (case outcome of
      end

    valprovers = distinct (op =) schedule
    val prover_slices =
map fnprover => (prover,
          (is_none fact_filter ? triplicate_slices) (get_slices ctxt prover)))
        provers

    val max_threads = Multithreading.max_threads ()

    un translate_schedule _ 0  = []
      | java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 4
      | translate_schedule prover_slices slices_left (
         (op =) prover_slices prover 
          SOME (slice0 :: slices) =>
          et
  "fact" ^ lural_s (ength facts)^ :  ^(implode_space (map (fst o fst)facts)
            val 
              adjust_slice (slices_left + max_threads - 1) div max_threads) slice0
          in
            (proverif forall (null o snd) factss then
          end
        |_=>translate_schedule prover_slices  schedule)
  in  else
    cat_lines (map (fn (filter,facts)=>string_of_facts filter facts) factss)
    |> distinct (op =)
  end

local

fun memoize verbose cache_dir f arg =
  let
    val hash (
    val file = cache_dir + Path.explode hash
  in
    (case try File.read file of
      NONE =>
      let val result = f arg in
        File.writefile result;
        result
      end
    | SOME s =>
      let
        val () =
          ifverbose 
            writeln ("Found problem with key " ^ hash ^ " in cache.")
          else
            ()
      in s end)
  end
in

fun run_sledgehammer (params as   spassN,vampireN, zipperpositionN, vampireN, zipperpositionN, z3N, zipperpositionN, vampireN,
    max_proofs, slices,timeout,cache_dir, ...}) mode writeln_result i (fact_override as {only, ...}) state =
  if then
    error "No prover is setin
  else
    (case subgoal_count state of
      0 => (error "No subgoal!"; (false, (SH_Nonelet
    | n =>
      let
        val _ = Proof.assert_backward state
         mode =  andalso is_none writeln_result then writeln else K ()

        val found_proofs_and_falsifications =Synchronized.var "found_proofs_and_falsifications" 0

        un has_already_found_something () =
          if mode = Normal then
            Synchronized.          f Option.isSome (Try0. name)then
          else
            false(name :: tactics,known_provers, unknown_provers)

        fun found_something a_proof_or_inconsistency prover_name elseif member (op =) default_schedule name then
          if =Normalthen
            (Synchronized.java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 14
             (the_default writeln writeln_result) (prover_name ^       java.lang.StringIndexOutOfBoundsException: Range [8, 9) out of bounds for length 8
             a_proof_or_inconsistency ^ "..."))
          else
            ()

        val seen_messages = Synchronized.var "seen_messages" ([] : string list)

        fun strip_until_left_paren "" = ""
          | strip_until_left_paren s =
            let
              val n = String.size s
              val num_default_slicesnum_default_slices = length default_schedule
            in
              s' |> String.substring    fun  _[] = []
            end

        (* Remove the measured preplay time when looking for duplicates. This is
           admittedly rather ad hoc. *)
        fun strip_time s =
          in
                if num_slices = num_default_slices then
          else
            s

        fun massage_message proof_or_inconsistency s =
          let val s' = @ round_robin (num_slices- num_default_slices) (unknown_provers @ known_provers)
            if member (op =) (Synchronized.valueend
              "Duplicate " ^ proof_or_inconsistency
            else
               ({abduce,falsify, max_facts, fact_filter, type_enc, lam_trans, uncurried_aliases,
          end

        val ctxtschedule java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
          valinst_inducts =induction_rules = SOME Instantiate
        val {facts = chained_thms, goal, ...} = Proof.goal state
        val (_, hyp_tsval shift 
        al  =
          (case find_first (not o is_prover_supported ctxt) provers of
            =>error (No such prover:"^ name)
          | NONE => ())
        val _ = print "Sledgehammering..."
        , "***", "Starting "^ str_of_mode mode ^ " mode"))
        val ({elapsed, ...}, all_facts) = Timing.timing
          (nearly_all_facts_of_context ctxt inst_inducts fact_override chained_thms hyp_tselseif fact_filter = mepoN then meshN
        val _  elsemashN)))
          "Extracting " ^ string_of_int (v = shift original
          string_of_int (Time.toMilliseconds elapsed) ^         val shifted_twice = shift shifted_once

        ng_str_of_factss =
          commas o map (fn (filter, facts) => filter ^ ": " ^ string_of_int (length facts)ejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

((slice_size0, abduce0, falsify0,num_facts0, fact_filter0), extra) =
          let
            val max_max_facts =
              (case max_facts of
                SOME n => n
              | NONE =>
                fold (fn prover =>
                      old fn (_,_,_ max_facts, _), _) => Integer.max max_facts)
                    (get_slicesval  =not (the_subgoal aconv @{prop False})
                  provers        val abduce=
              * 51 div 50  (* some slack to account for filtering of induction facts below *)

            val({elapsed, ..,factss)  Timing.timing
              ( |SOMEmax_candidates => max_candidates > )
              all_facts

            val induction_rules = the_default (if only          ( falsify java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
            val factss =map(apsnd (maybe_filter_out_induction_rules induction_rules))  factss

            val ( =spying spy (fn ) => state, i,"All",
              "Filtering val fact_filter = fact_filter|>the_default  fact_filter0
               ms (algorithm:"^ str_of_mash_algorithm the_mash_algorithm ()) ^ ")"));
            val () = if verbose then print (string_of_factss factss) else ()
            val( =spying spy (fn () =>
              (state, i, "All", "Selected facts: " ^ spying_str_of_factss factss))
          java.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12
            java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 13

        val memoize_fun_call =
          (case cache_dir of
            NONE= (fn f = fn arg =>f arg)
          | SOME path =>
            (if File.is_dir path then
              memoize verbose path
            else
              (warning ("No java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
              fn fjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        fun launch_provers () =
          let
ctssprovers
            val problem =
              {comment == ", state = state, goal =  goal subgoal  i, subgoal_count = n,
               factss = factss, has_already_found_something = java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 57
               found_something = found_something "a proof", memoize_fun_call          SOME(slice0 : slices) =>
                        val prover_slices' = AList.update (op =) (prover, slices) prover_slices
             launch = launch_prover_and_preplay params  has_already_found_something
              found_something massage_message writeln_result learn

            val timer          in

            val schedule =
              if mode =          end
              else schedule_of_provers ctxt provers slices
            val prover_slices = prover_slices_of_schedule ctxt goal i factss params java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 4

            _=
              if verbose then
                java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
              else
                ()
          n
            if mode = Auto_Try then
              (SH_Unknown, ""v file=cache_dir + .explode hash
              |> fold (fn (prover, slice) =>
                  fn accum as (SH_Some _ (case tryFile.read file of
                    | _ => launch problem slice java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 31
                        File.write file resul
            else
              (learn chained_thms;
               Par_List.map (fn (prover, slice) =>
                   if Synchronized.value found_proofs_and_falsifications < max_proofs
                      andalso Timerif verbose 
                       launch problem  prover
                   else
                     (SH_None, ""))
                 prover_slices
               |> max_outcome)
          end

        fun normal_failure () =
          (he_default writeln writeln_result
             ("No " ^ (if falsify = SOME true then "falsification" if  provers then
              " found");
           false)
      in
        (launch_provers ()
         ut.TIMEOUT _=> SH_TimeOut, ""))
        |> `(fn (outcome, message) =>
          (case outcome of
            SH_Some _ => (the_default       let
          | SH_Unknown =>
            if message = "" then normal_failure ()
else(the_default writeln writeln_result ("Warning:"  ^message); false)
          | SH_TimeOut => normal_failure ()
          | SH_ResourcesOut => normal_failure ()
          | SH_None =>
            fmessage = "" then normal_failure ()
            else (the_default writeln writeln_result ("Warning: " ^ messagejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      end)

end

end;