(*  Title:      HOL/TPTP/CASC_Setup.thy

     Author:     Jasmin Blanchette

     Copyright   2011

 Setup for Isabelle, Nitpick, and Refute for participating at CASC in the THF and

 TNT divisions. This theory file should be loaded by the Isabelle theory files

 generated by Geoff Sutcliffe's TPTP2X tool from the original THF0 files.

 *)

 theory CASC_Setup

 imports Complex_Main

 uses "../ex/sledgehammer_tactics.ML"

 begin

 consts

   is_int :: "'a \<Rightarrow> bool"

   is_rat :: "'a \<Rightarrow> bool"

 overloading rat_is_int \<equiv> "is_int :: rat \<Rightarrow> bool"

 begin

   definition "rat_is_int (q\<Colon>rat) \<longleftrightarrow> (\<exists>n\<Colon>int. q = of_int n)"

 end

 overloading real_is_int \<equiv> "is_int :: real \<Rightarrow> bool"

 begin

   definition "real_is_int (x\<Colon>real) \<longleftrightarrow> x \<in> \<int>"

 end

 overloading real_is_rat \<equiv> "is_rat :: real \<Rightarrow> bool"

 begin

   definition "real_is_rat (x\<Colon>real) \<longleftrightarrow> x \<in> \<rat>"

 end

 consts

   to_int :: "'a \<Rightarrow> int"

   to_rat :: "'a \<Rightarrow> rat"

   to_real :: "'a \<Rightarrow> real"

 overloading rat_to_int \<equiv> "to_int :: rat \<Rightarrow> int"

 begin

   definition "rat_to_int (q\<Colon>rat) = floor q"

 end

 overloading real_to_int \<equiv> "to_int :: real \<Rightarrow> int"

 begin

   definition "real_to_int (x\<Colon>real) = floor x"

 end

 overloading int_to_rat \<equiv> "to_rat :: int \<Rightarrow> rat"

 begin

   definition "int_to_rat (n\<Colon>int) = (of_int n\<Colon>rat)"

 end

 overloading real_to_rat \<equiv> "to_rat :: real \<Rightarrow> rat"

 begin

   definition "real_to_rat (x\<Colon>real) = (inv real x\<Colon>rat)"

 end

 overloading int_to_real \<equiv> "to_real :: int \<Rightarrow> real"

 begin

   definition "int_to_real (n\<Colon>int) = real n"

 end

 overloading rat_to_real \<equiv> "to_real :: rat \<Rightarrow> real"

 begin

   definition "rat_to_real (x\<Colon>rat) = (of_rat x\<Colon>real)"

 end

 declare

   rat_is_int_def [simp]

   real_is_int_def [simp]

   real_is_rat_def [simp]

   rat_to_int_def [simp]

   real_to_int_def [simp]

   int_to_rat_def [simp]

   real_to_rat_def [simp]

   int_to_real_def [simp]

   rat_to_real_def [simp]

 lemma to_rat_is_int [intro, simp]: "is_int (to_rat (n\<Colon>int))"

 by (metis int_to_rat_def rat_is_int_def)

 lemma to_real_is_int [intro, simp]: "is_int (to_real (n\<Colon>int))"

 by (metis Ints_real_of_int int_to_real_def real_is_int_def)

 lemma to_real_is_rat [intro, simp]: "is_rat (to_real (q\<Colon>rat))"

 by (metis Rats_of_rat rat_to_real_def real_is_rat_def)

 lemma inj_of_rat [intro, simp]: "inj (of_rat\<Colon>rat\<Rightarrow>real)"

 by (metis injI of_rat_eq_iff rat_to_real_def)

 declare mem_def [simp add]

 declare [[smt_oracle]]

 refute_params [maxtime = 10000, no_assms, expect = genuine]

 nitpick_params [timeout = none, card = 1-50, verbose, dont_box, no_assms,

                 batch_size = 1, expect = genuine]

 ML {* Proofterm.proofs := 0 *}

 ML {*

 fun SOLVE_TIMEOUT seconds name tac st =

   let

     val result =

       TimeLimit.timeLimit (Time.fromSeconds seconds)

         (fn () => SINGLE (SOLVE tac) st) ()

       handle TimeLimit.TimeOut => NONE

         | ERROR _ => NONE

   in

     (case result of

       NONE => (warning ("FAILURE: " ^ name); Seq.empty)

     | SOME st' => (warning ("SUCCESS: " ^ name); Seq.single st'))

   end

 *}

 ML {*

 fun isabellep_tac ctxt max_secs =

    SOLVE_TIMEOUT (max_secs div 10) "smt" (ALLGOALS (SMT_Solver.smt_tac ctxt []))

    ORELSE

    SOLVE_TIMEOUT (max_secs div 5) "sledgehammer"

        (ALLGOALS (Sledgehammer_Tactics.sledgehammer_as_oracle_tac ctxt []

                       Sledgehammer_Filter.no_relevance_override))

    ORELSE

    SOLVE_TIMEOUT (max_secs div 10) "simp" (ALLGOALS (asm_full_simp_tac (simpset_of ctxt)))

    ORELSE

    SOLVE_TIMEOUT (max_secs div 20) "blast" (ALLGOALS (blast_tac ctxt))

    ORELSE

    SOLVE_TIMEOUT (max_secs div 10) "auto" (auto_tac ctxt

        THEN ALLGOALS (Sledgehammer_Tactics.sledgehammer_as_oracle_tac ctxt []

                           Sledgehammer_Filter.no_relevance_override))

    ORELSE

    SOLVE_TIMEOUT (max_secs div 10) "metis"

        (ALLGOALS (Metis_Tactics.metis_tac [] ctxt []))

    ORELSE

    SOLVE_TIMEOUT (max_secs div 10) "fast" (ALLGOALS (fast_tac ctxt))

    ORELSE

    SOLVE_TIMEOUT (max_secs div 20) "best" (ALLGOALS (best_tac ctxt))

    ORELSE

    SOLVE_TIMEOUT (max_secs div 20) "arith" (ALLGOALS (Arith_Data.arith_tac ctxt))

    ORELSE

    SOLVE_TIMEOUT (max_secs div 10) "force" (ALLGOALS (force_tac ctxt))

    ORELSE

    SOLVE_TIMEOUT max_secs "fastsimp" (ALLGOALS (fast_simp_tac ctxt))

 *}

 method_setup isabellep = {*

   Scan.lift (Scan.optional Parse.nat 6000) >>

     (fn m => fn ctxt => SIMPLE_METHOD (isabellep_tac ctxt m))

 *} "combination of Isabelle provers and oracles for CASC"

 end